Add python sdk unit tests and ci

.github/workflows/publish-python-sdk.yml

@@ -29,6 +29,9 @@ jobs:
 
       - run: uv sync --locked --dev
 
+      - name: Run tests
+        run: uvx --from pytest pytest -q
+
       - run: uv build
 
       - run: uv publish

.github/workflows/test-python-sdk.yml

@@ -0,0 +1,56 @@
+name: Python SDK Tests
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - 'python-sdk/**'
+  pull_request:
+    branches: [main]
+    paths:
+      - 'python-sdk/**'
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v2
+        with:
+          cache: true
+
+      - name: Install dev dependencies with uv
+        working-directory: python-sdk
+        run: |
+          uv sync --group dev
+
+      - name: Run tests with pytest and coverage
+        working-directory: python-sdk
+        run: |
+          uv run pytest --cov=exospherehost --cov-report=xml --cov-report=term-missing -v --junitxml=pytest-report.xml
+
+      - name: Upload coverage reports to Codecov
+        uses: codecov/codecov-action@v5
+        with:
+          token: ${{ secrets.CODECOV_TOKEN }}
+          slug: exospherehost/exospherehost
+          files: python-sdk/coverage.xml
+          flags: python-sdk-unittests
+          name: python-sdk-coverage-report
+          fail_ci_if_error: true
+
+      - name: Upload test results
+        uses: actions/upload-artifact@v4
+        if: always()
+        with:
+          name: python-sdk-test-results
+          path: python-sdk/pytest-report.xml
+          retention-days: 30

python-sdk/exospherehost/runtime.py

@@ -271,27 +271,31 @@ def _validate_nodes(self):
                 errors.append(f"{node.__name__} does not have an Inputs class")
             if not hasattr(node, "Outputs"):
                 errors.append(f"{node.__name__} does not have an Outputs class")
-            if not issubclass(node.Inputs, BaseModel):
-                errors.append(f"{node.__name__} does not have an Inputs class that inherits from pydantic.BaseModel")                                          
-            if not issubclass(node.Outputs, BaseModel):
+            inputs_is_basemodel = hasattr(node, "Inputs") and issubclass(node.Inputs, BaseModel)
+            if not inputs_is_basemodel:
+                errors.append(f"{node.__name__} does not have an Inputs class that inherits from pydantic.BaseModel")
+            outputs_is_basemodel = hasattr(node, "Outputs") and issubclass(node.Outputs, BaseModel)
+            if not outputs_is_basemodel:
                 errors.append(f"{node.__name__} does not have an Outputs class that inherits from pydantic.BaseModel")
             if not hasattr(node, "Secrets"):
                 errors.append(f"{node.__name__} does not have an Secrets class")
-            if not issubclass(node.Secrets, BaseModel):
+            secrets_is_basemodel = hasattr(node, "Secrets") and issubclass(node.Secrets, BaseModel)
+            if not secrets_is_basemodel:
                 errors.append(f"{node.__name__} does not have an Secrets class that inherits from pydantic.BaseModel")
 
             # check all data objects are strings
-            for field_name, field_info in node.Inputs.model_fields.items():
-                if field_info.annotation is not str:
-                    errors.append(f"{node.__name__}.Inputs field '{field_name}' must be of type str, got {field_info.annotation}")
-
-            for field_name, field_info in node.Outputs.model_fields.items():
-                if field_info.annotation is not str:
-                    errors.append(f"{node.__name__}.Outputs field '{field_name}' must be of type str, got {field_info.annotation}")
-
-            for field_name, field_info in node.Secrets.model_fields.items():
-                if field_info.annotation is not str:
-                    errors.append(f"{node.__name__}.Secrets field '{field_name}' must be of type str, got {field_info.annotation}")
+            if inputs_is_basemodel:
+                for field_name, field_info in node.Inputs.model_fields.items():
+                    if field_info.annotation is not str:
+                        errors.append(f"{node.__name__}.Inputs field '{field_name}' must be of type str, got {field_info.annotation}")
+            if outputs_is_basemodel:
+                for field_name, field_info in node.Outputs.model_fields.items():
+                    if field_info.annotation is not str:
+                        errors.append(f"{node.__name__}.Outputs field '{field_name}' must be of type str, got {field_info.annotation}")
+            if secrets_is_basemodel:
+                for field_name, field_info in node.Secrets.model_fields.items():
+                    if field_info.annotation is not str:
+                        errors.append(f"{node.__name__}.Secrets field '{field_name}' must be of type str, got {field_info.annotation}")
 
         # Find nodes with the same __class__.__name__
         class_names = [node.__name__ for node in self._nodes]
@@ -300,7 +304,7 @@ def _validate_nodes(self):
             errors.append(f"Duplicate node class names found: {duplicate_class_names}")
 
         if len(errors) > 0:
-            raise ValidationError("Following errors while validating nodes: " + "\n".join(errors))
+            raise ValueError("Following errors while validating nodes: " + "\n".join(errors))
 
     async def _worker(self):
         """

python-sdk/pyproject.toml

@@ -31,4 +31,6 @@ version = {attr = "exospherehost._version.version"}
 [dependency-groups]
 dev = [
     "ruff>=0.12.5",
+    "pytest>=8.3.0",
+    "pytest-cov>=5.0.0",
 ]

python-sdk/tests/test_base_node.py

@@ -0,0 +1,29 @@
+from exospherehost.node.BaseNode import BaseNode
+from pydantic import BaseModel
+import asyncio
+
+
+class EchoNode(BaseNode):
+	class Inputs(BaseModel):
+		text: str
+
+	class Outputs(BaseModel):
+		message: str
+
+	class Secrets(BaseModel):
+		token: str
+
+	async def execute(self) -> Outputs:
+		return self.Outputs(message=f"{self.inputs.text}:{self.secrets.token}")
+
+
+def test_base_node_execute_sets_inputs_and_returns_outputs():
+	node = EchoNode()
+	inputs = EchoNode.Inputs(text="hello")
+	secrets = EchoNode.Secrets(token="tkn")
+	outputs = asyncio.run(node._execute(inputs, secrets))
+
+	assert isinstance(outputs, EchoNode.Outputs)
+	assert outputs.message == "hello:tkn"
+	assert node.inputs == inputs
+	assert node.secrets == secrets

python-sdk/tests/test_runtime_validation.py

@@ -0,0 +1,96 @@
+import os
+import pytest
+from pydantic import BaseModel
+from exospherehost.runtime import Runtime
+from exospherehost.node.BaseNode import BaseNode
+
+
+class GoodNode(BaseNode):
+	class Inputs(BaseModel):
+		name: str
+
+	class Outputs(BaseModel):
+		message: str
+
+	class Secrets(BaseModel):
+		api_key: str
+
+	async def execute(self):
+		return self.Outputs(message=f"hi {self.inputs.name}")
+
+
+class BadNodeWrongInputsBase(BaseNode):
+	Inputs = object  # not a pydantic BaseModel
+	class Outputs(BaseModel):
+		message: str
+	class Secrets(BaseModel):
+		token: str
+	async def execute(self):
+		return self.Outputs(message="x")
+
+
+class BadNodeWrongTypes(BaseNode):
+	class Inputs(BaseModel):
+		count: int
+	class Outputs(BaseModel):
+		ok: bool
+	class Secrets(BaseModel):
+		secret: bytes
+	async def execute(self):
+		return self.Outputs(ok=True)
+
+
+
+
+def test_runtime_missing_config_raises(monkeypatch):
+	# Ensure env vars not set
+	monkeypatch.delenv("EXOSPHERE_STATE_MANAGER_URI", raising=False)
+	monkeypatch.delenv("EXOSPHERE_API_KEY", raising=False)
+	with pytest.raises(ValueError):
+		Runtime(namespace="ns", name="rt", nodes=[GoodNode])
+
+
+def test_runtime_with_env_ok(monkeypatch):
+	monkeypatch.setenv("EXOSPHERE_STATE_MANAGER_URI", "http://sm")
+	monkeypatch.setenv("EXOSPHERE_API_KEY", "k")
+	rt = Runtime(namespace="ns", name="rt", nodes=[GoodNode])
+	assert rt is not None
+
+
+def test_runtime_invalid_params_raises(monkeypatch):
+	monkeypatch.setenv("EXOSPHERE_STATE_MANAGER_URI", "http://sm")
+	monkeypatch.setenv("EXOSPHERE_API_KEY", "k")
+	with pytest.raises(ValueError):
+		Runtime(namespace="ns", name="rt", nodes=[GoodNode], batch_size=0)
+	with pytest.raises(ValueError):
+		Runtime(namespace="ns", name="rt", nodes=[GoodNode], workers=0)
+
+
+def test_node_validation_errors(monkeypatch):
+	monkeypatch.setenv("EXOSPHERE_STATE_MANAGER_URI", "http://sm")
+	monkeypatch.setenv("EXOSPHERE_API_KEY", "k")
+	with pytest.raises(ValueError) as e:
+		Runtime(namespace="ns", name="rt", nodes=[BadNodeWrongInputsBase])
+	assert "Inputs class that inherits" in str(e.value)
+
+	with pytest.raises(ValueError) as e2:
+		Runtime(namespace="ns", name="rt", nodes=[BadNodeWrongTypes])
+	msg = str(e2.value)
+	assert "Inputs field" in msg and "Outputs field" in msg and "Secrets field" in msg
+
+
+def test_duplicate_node_names_raise(monkeypatch):
+	monkeypatch.setenv("EXOSPHERE_STATE_MANAGER_URI", "http://sm")
+	monkeypatch.setenv("EXOSPHERE_API_KEY", "k")
+	class AnotherGood(BaseNode):
+		class Inputs(BaseModel):
+			name: str
+		class Outputs(BaseModel):
+			message: str
+		class Secrets(BaseModel):
+			api_key: str
+		async def execute(self):
+			return self.Outputs(message="ok")
+	AnotherGood.__name__ = "GoodNode"  # force duplicate name
+	with pytest.raises(ValueError):
+		Runtime(namespace="ns", name="rt", nodes=[GoodNode, AnotherGood])

python-sdk/tests/test_state_manager.py

@@ -0,0 +1,28 @@
+import pytest
+import asyncio
+from exospherehost.statemanager import StateManager, TriggerState
+
+
+def test_trigger_requires_either_state_or_states(monkeypatch):
+	monkeypatch.setenv("EXOSPHERE_STATE_MANAGER_URI", "http://sm")
+	monkeypatch.setenv("EXOSPHERE_API_KEY", "k")
+	sm = StateManager(namespace="ns")
+	with pytest.raises(ValueError):
+		asyncio.run(sm.trigger("g"))
+
+
+def test_trigger_rejects_both_state_and_states(monkeypatch):
+	monkeypatch.setenv("EXOSPHERE_STATE_MANAGER_URI", "http://sm")
+	monkeypatch.setenv("EXOSPHERE_API_KEY", "k")
+	sm = StateManager(namespace="ns")
+	state = TriggerState(identifier="id", inputs={})
+	with pytest.raises(ValueError):
+		asyncio.run(sm.trigger("g", state=state, states=[state]))
+
+
+def test_trigger_rejects_empty_states_list(monkeypatch):
+	monkeypatch.setenv("EXOSPHERE_STATE_MANAGER_URI", "http://sm")
+	monkeypatch.setenv("EXOSPHERE_API_KEY", "k")
+	sm = StateManager(namespace="ns")
+	with pytest.raises(ValueError):
+		asyncio.run(sm.trigger("g", states=[]))