chore: static resolver works as expected

Author: cbrzn

packages/polywrap-client/tests/test_client.py

@@ -1,13 +1,44 @@
+import pytest
 from pathlib import Path
 
 from polywrap_client import PolywrapClient
-from polywrap_core import Uri, InvokerOptions, InterfaceImplementations, Env
-from polywrap_uri_resolvers import BaseUriResolver, SimpleFileReader
-
+from polywrap_core import Uri, InvokerOptions, InterfaceImplementations, Env, UriWrapper
+from polywrap_uri_resolvers import BaseUriResolver, SimpleFileReader, StaticResolver
+from polywrap_result import Result, Ok, Err
 from polywrap_client.client import PolywrapClientConfig
-
-
-async def test_invoke():
+from polywrap_wasm import WRAP_MANIFEST_PATH, WRAP_MODULE_PATH, IFileReader, WasmWrapper
+
+@pytest.fixture
+def simple_wrap_module():
+    wrap_path = Path(__file__).parent / "cases" / "simple-invoke" / "wrap.wasm"
+    with open(wrap_path, "rb") as f:
+        yield f.read()
+
+
+@pytest.fixture
+def simple_wrap_manifest():
+    wrap_path = Path(__file__).parent / "cases" / "simple-invoke" / "wrap.info"
+    with open(wrap_path, "rb") as f:
+        yield f.read()
+
+@pytest.fixture
+def simple_file_reader(simple_wrap_module: bytes, simple_wrap_manifest: bytes):
+    class FileReader(IFileReader):
+        async def read_file(self, file_path: str) -> Result[bytes]:
+            if file_path == WRAP_MODULE_PATH:
+                return Ok(simple_wrap_module)
+            if file_path == WRAP_MANIFEST_PATH:
+                return Ok(simple_wrap_manifest)
+            return Err.from_str(f"FileNotFound: {file_path}")
+
+    yield FileReader()
+
+@pytest.mark.asyncio
+async def test_invoke(
+    simple_file_reader: IFileReader,
+    simple_wrap_module: bytes,
+    simple_wrap_manifest: bytes
+):
     client = PolywrapClient()
     uri = Uri(
         f'fs/{Path(__file__).parent.joinpath("cases", "simple-invoke").absolute()}'
@@ -20,6 +51,27 @@ async def test_invoke():
 
     assert result.unwrap() == args["arg"]
 
+    wrapper = WasmWrapper(
+        file_reader=simple_file_reader, 
+        wasm_module=simple_wrap_module, 
+        manifest=simple_wrap_manifest
+    )
+    uri_wrapper = UriWrapper(uri=Uri("ens/wrapper.eth"), wrapper=wrapper)
+    resolver = StaticResolver._from([uri_wrapper])
+
+    config = PolywrapClientConfig(resolver=resolver)
+    client = PolywrapClient(config=config)
+
+    args = {"arg": "hello polywrap"}
+    options = InvokerOptions(
+        uri=Uri("ens/wrapper.eth"), 
+        method="simpleMethod", 
+        args=args, 
+        encode_result=False
+    )
+    result = await client.invoke(options)
+
+    assert result.unwrap() == args["arg"]
 
 async def test_subinvoke():
     uri_resolver = BaseUriResolver(

packages/polywrap-uri-resolvers/polywrap_uri_resolvers/static_resolver.py

@@ -39,13 +39,12 @@ async def try_resolve_uri(self, uri: Uri, client: Client, resolution_context: IU
 
         if package_or_wrapper:
             if hasattr(package_or_wrapper, "package"):
-                result = UriResolutionResult.ok(uri, cast(IWrapPackage, package_or_wrapper))
+                result = UriResolutionResult.ok(uri, cast(IWrapPackage, package_or_wrapper.package))
                 description = f"Static - Package ({uri.uri})"
             elif hasattr(package_or_wrapper, "wrapper"):
-                result = UriResolutionResult.ok(uri, None, cast(Wrapper, package_or_wrapper))
+                result = UriResolutionResult.ok(uri, None, cast(Wrapper, package_or_wrapper.wrapper))
                 description = f"Static - Wrapper ({uri.uri})"
 
         step = IUriResolutionStep(source_uri=uri, result=result, description=description)
         resolution_context.track_step(step)
-
         return result

packages/polywrap-uri-resolvers/tests/test_static_resolver.py

@@ -3,7 +3,7 @@
 
 from polywrap_result import Ok, Err, Result
 from polywrap_wasm import WRAP_MANIFEST_PATH, WRAP_MODULE_PATH, IFileReader, WasmPackage, WasmWrapper
-from polywrap_core import UriPackage, Uri, UriResolutionContext, UriWrapper
+from polywrap_core import UriPackage, Uri, UriResolutionContext, UriWrapper, IWrapPackage
 from polywrap_client import PolywrapClient
 from polywrap_uri_resolvers import StaticResolver
 from polywrap_manifest import deserialize_wrap_manifest
@@ -56,15 +56,15 @@ async def test_static_resolver(
     result = await resolver.try_resolve_uri(Uri("ens/package.eth"), PolywrapClient(), resolution_context)
 
     assert result.is_ok
-    assert isinstance((result.unwrap()).package, UriPackage)
+    assert isinstance((result.unwrap()).package, IWrapPackage)
 
     result = await resolver.try_resolve_uri(Uri("ens/wrapper.eth"), PolywrapClient(), resolution_context)
 
     assert result.is_ok
-    assert isinstance((result.unwrap()).wrapper, UriWrapper)
+    assert isinstance((result.unwrap()).wrapper, WasmWrapper)
 
     result = await resolver.try_resolve_uri(Uri("ens/nested-package.eth"), PolywrapClient(), resolution_context)
 
     assert result.is_ok
-    assert isinstance((result.unwrap()).package, UriPackage)
+    assert isinstance((result.unwrap()).package, IWrapPackage)