adding many more python tests

python/mochi/bedrock/client.py

@@ -86,7 +86,7 @@ def add_abtio_instance(self, config: str|dict|AbtIOSpec):
     def add_client(self, config: str|dict|ClientSpec):
         if isinstance(config, str):
             config = json.loads(config)
-        elif isinstance(config, AbtIOSpec):
+        elif isinstance(config, ClientSpec):
             config = config.to_dict()
         if "config" not in config:
             config["config"] = {}
@@ -104,14 +104,16 @@ def add_client(self, config: str|dict|ClientSpec):
     def start_provider(self, config: str|dict|ProviderSpec):
         if isinstance(config, str):
             config = json.loads(config)
-        elif isinstance(config, AbtIOSpec):
+        elif isinstance(config, ProviderSpec):
             config = config.to_dict()
         if "config" not in config:
             config["config"] = {}
         if "dependencies" not in config:
             config["dependencies"] = {}
         if "tags" not in config:
             config["tags"] = []
+        if "pool" not in config:
+            config["pool"] = "__primary__"
         return self._internal.start_provider(
             name=config["name"],
             type=config["type"],

python/mochi/bedrock/spec.py

@@ -1035,18 +1035,23 @@ class AbtIOSpec:
 
     :param pool: Pool associated with the instance
     :type pool: PoolSpec
+
+    :param config: Configuration
+    :type config: dict
     """
 
     name: str = attr.ib(
         validator=[instance_of(str), _validate_object_name],
         on_setattr=attr.setters.frozen)
     pool: PoolSpec = attr.ib(validator=instance_of(PoolSpec))
+    config: dict = attr.ib(validator=instance_of(dict))
 
     def to_dict(self) -> dict:
         """Convert the AbtIOSpec into a dictionary.
         """
         return {'name': self.name,
-                'pool': self.pool.name}
+                'pool': self.pool.name,
+                'config': self.config}
 
     @staticmethod
     def from_dict(data: dict, abt_spec: ArgobotsSpec) -> 'AbtIOSpec':
@@ -1061,8 +1066,9 @@ def from_dict(data: dict, abt_spec: ArgobotsSpec) -> 'AbtIOSpec':
         :type abt_spec: ArgobotsSpec
         """
         name = data['name']
+        config = data['config']
         pool = abt_spec.pools[data['pool']]
-        abtio = AbtIOSpec(name=name, pool=pool)
+        abtio = AbtIOSpec(name=name, pool=pool, config=config)
         return abtio
 
     def to_json(self, *args, **kwargs) -> str:
@@ -1395,7 +1401,7 @@ def from_dict(data: dict) -> 'ClientSpec':
         :param data: Dictionary
         :type data: dict
         """
-        return ClientSpec(**args)
+        return ClientSpec(**data)
 
     def to_json(self, *args, **kwargs) -> str:
         """Convert the ClientSpec into a JSON string.
@@ -1583,6 +1589,7 @@ def from_dict(data: dict) -> 'ProcSpec':
         libraries = dict()
         providers = []
         bedrock = {}
+        clients = []
         if 'libraries' in data:
             libraries = data['libraries']
         if 'abt_io' in data:
@@ -1604,6 +1611,7 @@ def from_dict(data: dict) -> 'ProcSpec':
                         ssg=ssg,
                         libraries=libraries,
                         providers=providers,
+                        clients=clients,
                         bedrock=bedrock)
 
     def to_json(self, *args, **kwargs) -> str:

python/mochi/bedrock/test_service_handle.py

@@ -180,6 +180,158 @@ def test_remove_xstream(self):
         with self.assertRaises(mbc.ClientException):
             self.server.margo.xstreams["my_xstream"]
 
+    def test_add_ssg_group_from_dict(self):
+        group_config = {
+            "name": "my_group",
+            "pool": "__primary__",
+            "bootstrap": "init",
+            "swim": {
+                "disabled": True
+            }
+        }
+        self.sh.add_ssg_group(group_config)
+        group = self.server.ssg["my_group"]
+        self.assertIsInstance(group, mbs.SSGGroup)
+
+    def test_add_ssg_group_from_str(self):
+        group_config = {
+            "name": "my_group",
+            "pool": "__primary__",
+            "bootstrap": "init",
+            "swim": {
+                "disabled": True
+            }
+        }
+        self.sh.add_ssg_group(json.dumps(group_config))
+        group = self.server.ssg["my_group"]
+        self.assertIsInstance(group, mbs.SSGGroup)
+
+    def test_add_ssg_group_from_spec(self):
+        group_config = spec.SSGSpec(
+            name="my_group",
+            pool=spec.PoolSpec(name="__primary__", kind="fifo_wait", access="mpmc"),
+            bootstrap="init",
+            swim=spec.SwimSpec(disabled=True)
+        )
+        self.sh.add_ssg_group(group_config)
+        group = self.server.ssg["my_group"]
+        self.assertIsInstance(group, mbs.SSGGroup)
+
+    def test_add_abtio_instance_from_dict(self):
+        abtio_config = {
+            "name": "my_abtio",
+            "pool": "__primary__",
+            "config": {}
+        }
+        self.sh.add_abtio_instance(abtio_config)
+        abtio = self.server.abtio["my_abtio"]
+        self.assertIsInstance(abtio, mbs.AbtIOInstance)
+
+    def test_add_abtio_instance_from_src(self):
+        abtio_config = {
+            "name": "my_abtio",
+            "pool": "__primary__",
+            "config": {}
+        }
+        self.sh.add_abtio_instance(json.dumps(abtio_config))
+        abtio = self.server.abtio["my_abtio"]
+        self.assertIsInstance(abtio, mbs.AbtIOInstance)
+
+    def test_add_abtio_instance_from_spec(self):
+        abtio_config = spec.AbtIOSpec(
+            name="my_abtio",
+            pool=spec.PoolSpec(name="__primary__", kind="fifo_wait", access="mpmc"),
+            config={}
+        )
+        self.sh.add_abtio_instance(abtio_config)
+        abtio = self.server.abtio["my_abtio"]
+        self.assertIsInstance(abtio, mbs.AbtIOInstance)
+
+    def test_add_client_from_dict(self):
+        self.test_load_module()
+        client_config = {
+            "name": "my_client",
+            "type": "module_a",
+            "config": {},
+            "dependencies": {},
+            "tags": ["my_tag_1", "my_tag_2"]
+        }
+        self.sh.add_client(client_config)
+        proc_spec = self.server.spec
+        client_spec = proc_spec.clients["my_client"]
+
+    def test_add_client_from_src(self):
+        self.test_load_module()
+        client_config = {
+            "name": "my_client",
+            "type": "module_a",
+            "config": {},
+            "dependencies": {},
+            "tags": ["my_tag_1", "my_tag_2"]
+        }
+        self.sh.add_client(json.dumps(client_config))
+        proc_spec = self.server.spec
+        client_spec = proc_spec.clients["my_client"]
+
+    def test_add_client_from_spec(self):
+        self.test_load_module()
+        client_config = spec.ClientSpec(
+            name="my_client",
+            type="module_a",
+            config={},
+            dependencies={},
+            tags=["my_tag_1", "my_tag_2"]
+        )
+        self.sh.add_client(client_config)
+        proc_spec = self.server.spec
+        client_spec = proc_spec.clients["my_client"]
+
+    def test_start_provider_from_dict(self):
+        self.test_load_module()
+        provider_config = {
+            "name": "my_provider",
+            "type": "module_a",
+            "pool": "__primary__",
+            "provider_id": 42,
+            "config": {},
+            "dependencies": {},
+            "tags": ["my_tag_1", "my_tag_2"]
+        }
+        self.sh.start_provider(provider_config)
+        proc_spec = self.server.spec
+        provider_spec = proc_spec.providers["my_provider"]
+
+    def test_start_provider_from_str(self):
+        self.test_load_module()
+        provider_config = {
+            "name": "my_provider",
+            "type": "module_a",
+            "pool": "__primary__",
+            "provider_id": 42,
+            "config": {},
+            "dependencies": {},
+            "tags": ["my_tag_1", "my_tag_2"]
+        }
+        self.sh.start_provider(json.dumps(provider_config))
+        proc_spec = self.server.spec
+        provider_spec = proc_spec.providers["my_provider"]
+
+    def test_start_provider_from_spec(self):
+        self.test_load_module()
+        provider_config = spec.ProviderSpec(
+            name="my_provider",
+            type="module_a",
+            pool=spec.PoolSpec(name="__primary__"),
+            provider_id=42,
+            config={},
+            dependencies={},
+            tags=["my_tag_1", "my_tag_2"]
+        )
+        self.sh.start_provider(provider_config)
+        proc_spec = self.server.spec
+        provider_spec = proc_spec.providers["my_provider"]
+
+
 
 if __name__ == '__main__':
     unittest.main()

src/ClientManager.cpp

@@ -232,7 +232,8 @@ ClientManager::addClientFromJSON(
     auto deps_from_config = config.value("dependencies", json::object());
     if(!deps_from_config.is_object()) {
         throw DETAILED_EXCEPTION(
-                "\"dependencies\" field in client definition should be an object");
+                "\"dependencies\" field in client definition should be an object (found {})",
+                deps_from_config.type_name());
     }
 
     ResolvedDependencyMap resolved_dependency_map;

src/ServerImpl.hpp

@@ -147,7 +147,8 @@ class ServerImpl : public tl::provider<ServerImpl> {
         fullconfig["name"]   = name;
         fullconfig["type"]   = type;
         fullconfig["config"] = jsonconfig;
-        fullconfig["tags"] = tags;
+        fullconfig["tags"]   = tags;
+        fullconfig["dependencies"] = json::object();
         auto& depconfig      = fullconfig["dependencies"];
         for (auto& p : dependencies) {
             auto& name = p.first;