feat: add tests for client-config-builder

packages/polywrap-client-config-builder/polywrap_client_config_builder/configures/env_configure.py

@@ -1,6 +1,6 @@
 """This module contains the env configure class for the client config builder."""
 from abc import ABC
-from typing import Any, Dict, List, Union
+from typing import Any, Dict, List, Union, cast
 
 from polywrap_core import Uri
 
@@ -35,9 +35,9 @@ def add_env(self, uri: Uri, env: Any) -> ClientConfigBuilder:
 
         If an Any is already associated with the uri, it is modified.
         """
-        if self.config.envs.get(uri):
-            for key in self.config.envs[uri]:
-                self.config.envs[uri][key] = env[key]
+        if old_env := self.config.envs.get(uri):
+            new_env = self._merge_envs(old_env, env)
+            self.config.envs[uri] = new_env
         else:
             self.config.envs[uri] = env
         return self
@@ -58,3 +58,19 @@ def remove_envs(self, uris: List[Uri]) -> ClientConfigBuilder:
         for uri in uris:
             self.remove_env(uri)
         return self
+
+    @staticmethod
+    def _merge_envs(env1: Dict[str, Any], env2: Dict[str, Any]) -> Dict[str, Any]:
+        for key, val in env2.items():
+            if key not in env1:
+                env1[key] = val
+                continue
+
+            if isinstance(val, dict):
+                old_val = cast(Dict[str, Any], env1[key])
+                new_val = cast(Dict[str, Any], val)
+
+                EnvConfigure._merge_envs(old_val, new_val)
+            else:
+                env1[key] = val
+        return env1

packages/polywrap-client-config-builder/polywrap_client_config_builder/configures/interface_configure.py

@@ -26,7 +26,10 @@ def add_interface_implementations(
     ) -> ClientConfigBuilder:
         """Add a list of implementation URIs for the given interface URI to the builder's config."""
         if interface_uri in self.config.interfaces.keys():
-            self.config.interfaces[interface_uri].extend(implementations_uris)
+            existing_implementations = set(self.config.interfaces[interface_uri])
+            for implementation_uri in implementations_uris:
+                if implementation_uri not in existing_implementations:
+                    self.config.interfaces[interface_uri].append(implementation_uri)
         else:
             self.config.interfaces[interface_uri] = implementations_uris
         return self

packages/polywrap-client-config-builder/polywrap_client_config_builder/polywrap_client_config_builder.py

@@ -54,13 +54,7 @@ def __init__(self):
 
     def build(self, options: Optional[BuildOptions] = None) -> ClientConfig:
         """Build the ClientConfig object from the builder's config."""
-        static_resolver_like = cast(StaticResolverLike, self.config.redirects)
-
-        for uri, wrapper in self.config.wrappers.items():
-            static_resolver_like[uri] = UriWrapper(uri=uri, wrapper=wrapper)
-
-        for uri, package in self.config.packages.items():
-            static_resolver_like[uri] = UriPackage(uri=uri, package=package)
+        static_resolver_like = self._build_static_resolver_like()
 
         resolver = (
             options.resolver
@@ -87,5 +81,16 @@ def build(self, options: Optional[BuildOptions] = None) -> ClientConfig:
             resolver=resolver,
         )
 
+    def _build_static_resolver_like(self) -> StaticResolverLike:
+        static_resolver_like = cast(StaticResolverLike, self.config.redirects)
+
+        for uri, wrapper in self.config.wrappers.items():
+            static_resolver_like[uri] = UriWrapper(uri=uri, wrapper=wrapper)
+
+        for uri, package in self.config.packages.items():
+            static_resolver_like[uri] = UriPackage(uri=uri, package=package)
+
+        return static_resolver_like
+
 
 __all__ = ["PolywrapClientConfigBuilder"]

packages/polywrap-client-config-builder/polywrap_client_config_builder/types/builder_config.py

@@ -1,5 +1,5 @@
 """This module contains the BuilderConfig class."""
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Any, Dict, List
 
 from polywrap_core import Uri, UriResolver, WrapPackage, Wrapper
@@ -18,12 +18,12 @@ class BuilderConfig:
         redirects (Dict[Uri, Uri]): The URI redirects.
     """
 
-    envs: Dict[Uri, Any]
-    interfaces: Dict[Uri, List[Uri]]
-    wrappers: Dict[Uri, Wrapper]
-    packages: Dict[Uri, WrapPackage]
-    resolvers: List[UriResolver]
-    redirects: Dict[Uri, Uri]
+    envs: Dict[Uri, Any] = field(default_factory=dict)
+    interfaces: Dict[Uri, List[Uri]] = field(default_factory=dict)
+    wrappers: Dict[Uri, Wrapper] = field(default_factory=dict)
+    packages: Dict[Uri, WrapPackage] = field(default_factory=dict)
+    resolvers: List[UriResolver] = field(default_factory=list)
+    redirects: Dict[Uri, Uri] = field(default_factory=dict)
 
 
 __all__ = ["BuilderConfig"]

packages/polywrap-client-config-builder/pyproject.toml

@@ -25,6 +25,9 @@ isort = "^5.10.1"
 pyright = "^1.1.275"
 pydocstyle = "^6.1.1"
 
+[tool.poetry.group.dev.dependencies]
+hypothesis = "^6.76.0"
+
 [tool.bandit]
 exclude_dirs = ["tests"]
 

packages/polywrap-client-config-builder/tests/.gitignore

@@ -0,0 +1 @@
+!env/

packages/polywrap-client-config-builder/tests/consts.py

@@ -0,0 +1,2 @@
+C_LONG_MIN = -9223372036854775808
+C_LONG_MAX = 9223372036854775807

packages/polywrap-client-config-builder/tests/env/test_add_env.py

@@ -0,0 +1,27 @@
+from typing import Any
+from hypothesis import given, settings
+
+from polywrap_client_config_builder import (
+    ClientConfigBuilder,
+    PolywrapClientConfigBuilder,
+)
+from polywrap_core import Uri
+
+from ..strategies import uri_strategy, env_strategy
+
+
+@settings(max_examples=100)
+@given(uri=uri_strategy, old_env=env_strategy, new_env=env_strategy)
+def test_add_env(uri: Uri, old_env: Any, new_env: Any):
+    builder: ClientConfigBuilder = PolywrapClientConfigBuilder()
+    builder.config.envs = {uri: {"common": old_env, "unique_1": "unique_env_1"}}
+
+    builder.add_env(uri, {"common": new_env, "unique_2": "unique_env_2"})
+
+    updated_env = {**old_env, **new_env}
+
+    assert builder.config.envs[uri] == {
+        "common": updated_env,
+        "unique_1": "unique_env_1",
+        "unique_2": "unique_env_2",
+    }

packages/polywrap-client-config-builder/tests/env/test_get_env.py

@@ -0,0 +1,40 @@
+from typing import Any, Dict
+from hypothesis import given, settings
+
+from polywrap_client_config_builder import (
+    ClientConfigBuilder,
+    PolywrapClientConfigBuilder,
+)
+from polywrap_core import Uri
+
+from ..strategies import envs_strategy
+
+
+@settings(max_examples=100)
+@given(envs=envs_strategy)
+def test_get_env_exists(
+    envs: Dict[Uri, Any]
+):
+    builder: ClientConfigBuilder = PolywrapClientConfigBuilder()
+    builder.config.envs = envs
+
+    for uri in envs:
+        assert builder.get_env(uri) == envs[uri]
+    assert builder.get_env(Uri.from_str("test/not-exists")) is None
+
+
+def test_get_env_not_exists():
+    builder: ClientConfigBuilder = PolywrapClientConfigBuilder()
+    assert builder.get_env(Uri.from_str("test/not-exists")) is None
+
+
+@settings(max_examples=100)
+@given(envs=envs_strategy)
+def test_get_envs(
+    envs: Dict[Uri, Any]
+):
+    builder: ClientConfigBuilder = PolywrapClientConfigBuilder()
+    assert builder.get_envs() == {}
+
+    builder.config.envs = envs
+    assert builder.get_envs() == envs

packages/polywrap-client-config-builder/tests/env/test_remove_env.py

@@ -0,0 +1,59 @@
+from typing import Any, Dict
+from random import randint
+from hypothesis import assume, event, given, settings
+
+from polywrap_client_config_builder import (
+    ClientConfigBuilder,
+    PolywrapClientConfigBuilder,
+)
+from polywrap_core import Uri
+
+from ..strategies import envs_strategy
+
+
+@settings(max_examples=100)
+@given(envs=envs_strategy)
+def test_remove_env(envs: Dict[Uri, Any]):
+    assume(envs)
+    builder: ClientConfigBuilder = PolywrapClientConfigBuilder()
+    builder.config.envs = {**envs}
+
+    uris = list(envs.keys())
+    uri_index = randint(0, len(uris) - 1)
+    remove_uri = uris[uri_index]
+    event(f"Uri to remove: {remove_uri}")
+
+    builder.remove_env(remove_uri)
+    assert len(builder.config.envs) == len(envs) - 1
+    assert remove_uri not in builder.config.envs
+
+
+@settings(max_examples=100)
+@given(envs=envs_strategy)
+def test_remove_non_existent_env(envs: Dict[Uri, Any]):
+    builder: ClientConfigBuilder = PolywrapClientConfigBuilder()
+    builder.config.envs = {**envs}
+
+    builder.remove_env(Uri("test", "non-existent"))
+    assert builder.config.envs == envs
+
+
+@settings(max_examples=100)
+@given(envs=envs_strategy)
+def test_remove_envs(envs: Dict[Uri, Any]):
+    assume(envs)
+    builder: ClientConfigBuilder = PolywrapClientConfigBuilder()
+    builder.config.envs = {**envs}
+
+    uris = list(envs.keys())
+    uri_indices = [
+        randint(0, len(uris) - 1) for _ in range(randint(0, len(uris) - 1))
+    ]
+    remove_uris = list({uris[uri_index] for uri_index in uri_indices})
+    event(f"Uris to remove: {remove_uris}")
+
+    builder.remove_envs(remove_uris)
+    assert len(builder.config.envs) == len(envs) - len(remove_uris)
+    assert set(remove_uris) & set(builder.config.envs.keys()) == set()
+
+

packages/polywrap-client-config-builder/tests/env/test_set_env.py

@@ -0,0 +1,50 @@
+from typing import Any, Dict
+from hypothesis import assume, given, settings
+
+from polywrap_client_config_builder import (
+    ClientConfigBuilder,
+    PolywrapClientConfigBuilder,
+)
+from polywrap_core import Uri
+
+from ..strategies import envs_strategy, uri_strategy, env_strategy
+
+
+@settings(max_examples=100)
+@given(envs=envs_strategy, new_uri=uri_strategy, new_env=env_strategy)
+def test_set_env(envs: Dict[Uri, Any], new_uri: Uri, new_env: Any):
+    builder: ClientConfigBuilder = PolywrapClientConfigBuilder()
+    builder.config.envs = {**envs}
+
+    existing_uris = set(builder.config.envs.keys())
+    assume(new_uri not in existing_uris)
+
+    builder.set_env(new_uri, new_env)
+
+    assert len(builder.config.envs) == len(existing_uris) + 1
+    assert builder.config.envs[new_uri] == new_env
+
+
+@settings(max_examples=100)
+@given(uri=uri_strategy, old_env=env_strategy, new_env=env_strategy)
+def test_set_env_overwrite(uri: Uri, old_env: Any, new_env: Any):
+    builder: ClientConfigBuilder = PolywrapClientConfigBuilder()
+    builder.config.envs = {uri: old_env}
+
+    builder.set_env(uri, new_env)
+
+    assert builder.config.envs == {uri: new_env}
+
+
+@settings(max_examples=100)
+@given(initial_envs=envs_strategy, new_envs=envs_strategy)
+def test_set_envs(
+    initial_envs: Dict[Uri, Any],
+    new_envs: Dict[Uri, Any],
+):
+    builder: ClientConfigBuilder = PolywrapClientConfigBuilder()
+    builder.config.envs = {**initial_envs}
+
+    builder.set_envs(new_envs)
+
+    assert len(builder.config.envs) <= len(initial_envs) + len(new_envs)

packages/polywrap-client-config-builder/tests/interface/test_add_interface.py

@@ -0,0 +1,25 @@
+from typing import List
+from hypothesis import given, settings, strategies as st
+
+from polywrap_client_config_builder import (
+    ClientConfigBuilder,
+    PolywrapClientConfigBuilder,
+)
+from polywrap_core import Uri
+
+from ..strategies import uri_strategy
+
+
+@settings(max_examples=100)
+@given(uri=uri_strategy, old_impls=st.lists(uri_strategy), new_impls=st.lists(uri_strategy))
+def test_add_implementations_to_existing_interface(uri: Uri, old_impls: List[Uri], new_impls: List[Uri]):
+    builder: ClientConfigBuilder = PolywrapClientConfigBuilder()
+    builder.config.interfaces = {uri: old_impls}
+
+    builder.add_interface_implementations(uri, new_impls)
+
+    updated_impls = {*old_impls, *new_impls}
+
+    assert set(builder.config.interfaces[uri]) == updated_impls
+
+

packages/polywrap-client-config-builder/tests/interface/test_get_interface.py

@@ -0,0 +1,40 @@
+from typing import Any, Dict, List
+from hypothesis import given, settings
+
+from polywrap_client_config_builder import (
+    ClientConfigBuilder,
+    PolywrapClientConfigBuilder,
+)
+from polywrap_core import Uri
+
+from ..strategies import interfaces_strategy
+
+
+@settings(max_examples=100)
+@given(interfaces=interfaces_strategy)
+def test_get_interface_implementations(
+    interfaces: Dict[Uri, List[Uri]]
+):
+    builder: ClientConfigBuilder = PolywrapClientConfigBuilder()
+    builder.config.interfaces = interfaces
+
+    for uri in interfaces:
+        assert builder.get_interface_implementations(uri) == interfaces[uri]
+    assert builder.get_interface_implementations(Uri.from_str("test/not-exists")) is None
+
+
+def test_get_implementations_not_exists():
+    builder: ClientConfigBuilder = PolywrapClientConfigBuilder()
+    assert builder.get_interface_implementations(Uri.from_str("test/not-exists")) is None
+
+
+@settings(max_examples=100)
+@given(interfaces=interfaces_strategy)
+def test_get_interfaces(
+    interfaces: Dict[Uri, List[Uri]]
+):
+    builder: ClientConfigBuilder = PolywrapClientConfigBuilder()
+    assert builder.get_interfaces() == {}
+
+    builder.config.interfaces = interfaces
+    assert builder.get_interfaces() == interfaces