@almadar/cli 0.3.2 → 1.0.3

package/shells/python-shell/tests/test_generated_traits.py

@@ -0,0 +1,268 @@
+"""
+Generated Traits Integration Tests
+
+Tests that generated trait routes work correctly:
+- State endpoints return valid states
+- INIT events transition from idle to ready
+- Effects are returned in correct format
+- State transitions happen properly
+
+These tests are designed to work with any generated Orbital app.
+"""
+import pytest
+from typing import List, Dict, Any
+from fastapi.testclient import TestClient
+
+
+class TestGeneratedTraitRoutes:
+    """Test that generated trait routes work correctly."""
+
+    def get_trait_routes(self, client: TestClient) -> List[str]:
+        """Get all trait route prefixes from OpenAPI schema."""
+        response = client.get("/openapi.json")
+        assert response.status_code == 200
+        paths = response.json().get("paths", {})
+
+        # Find unique trait prefixes (e.g., /api/neural_network_manager)
+        prefixes = set()
+        for path in paths.keys():
+            if path.startswith("/api/") and "/events/" in path:
+                # Extract prefix before /events/
+                prefix = path.split("/events/")[0]
+                prefixes.add(prefix)
+
+        return list(prefixes)
+
+    def test_all_traits_have_state_endpoint(self, test_client: TestClient):
+        """All generated traits have a /state endpoint."""
+        trait_prefixes = self.get_trait_routes(test_client)
+
+        for prefix in trait_prefixes:
+            response = test_client.get(f"{prefix}/state")
+            assert response.status_code == 200, f"State endpoint failed for {prefix}"
+            data = response.json()
+            assert "state" in data, f"State response missing 'state' field for {prefix}"
+
+    def test_state_endpoint_returns_valid_state(self, test_client: TestClient):
+        """State endpoints return valid state names."""
+        trait_prefixes = self.get_trait_routes(test_client)
+
+        for prefix in trait_prefixes:
+            response = test_client.get(f"{prefix}/state")
+            data = response.json()
+            # State should be a string
+            assert isinstance(data["state"], str), f"State should be string for {prefix}"
+            # State should not be empty
+            assert len(data["state"]) > 0, f"State should not be empty for {prefix}"
+
+
+class TestINITEvent:
+    """Test INIT event handling for traits that have it."""
+
+    def get_init_routes(self, client: TestClient) -> List[str]:
+        """Get all trait routes that have INIT event."""
+        response = client.get("/openapi.json")
+        paths = response.json().get("paths", {})
+        return [path for path in paths.keys() if "/events/init" in path]
+
+    def test_init_event_works(self, test_client: TestClient):
+        """INIT event transitions trait from idle state."""
+        init_routes = self.get_init_routes(test_client)
+
+        for route in init_routes:
+            # Extract trait prefix for state check
+            prefix = route.split("/events/")[0]
+
+            # Get initial state
+            state_response = test_client.get(f"{prefix}/state")
+            initial_state = state_response.json()["state"]
+
+            # Call INIT
+            response = test_client.post(
+                route,
+                json={"payload": {}, "entity_id": "test-entity-1"},
+            )
+
+            assert response.status_code == 200, f"INIT failed for {route}"
+            data = response.json()
+
+            # Check response format
+            assert "success" in data, f"Response missing 'success' for {route}"
+            assert "effects" in data, f"Response missing 'effects' for {route}"
+            assert "state" in data, f"Response missing 'state' for {route}"
+
+    def test_init_returns_effects(self, test_client: TestClient):
+        """INIT event returns render-ui effects with action buttons."""
+        init_routes = self.get_init_routes(test_client)
+
+        for route in init_routes:
+            response = test_client.post(
+                route,
+                json={"payload": {}, "entity_id": "test-entity-2"},
+            )
+
+            if response.status_code == 200:
+                data = response.json()
+                if data.get("success"):
+                    effects = data.get("effects", [])
+                    # Check effect format
+                    for effect in effects:
+                        assert isinstance(effect, dict), f"Effect should be dict for {route}"
+                        assert "type" in effect, f"Effect missing 'type' for {route}"
+
+
+class TestEffectFormat:
+    """Test that effects are in the correct format."""
+
+    def test_notify_effect_format(self):
+        """Notify effects have correct structure."""
+        from orbital_app.generated.effect_helpers import notify
+
+        effect = notify("Test message", "Info")
+
+        assert effect["type"] == "notify"
+        assert effect["message"] == "Test message"
+        assert effect["severity"] == "Info"
+
+    def test_render_ui_effect_format(self):
+        """Render-ui effects have correct structure."""
+        from orbital_app.generated.effect_helpers import render_ui
+
+        effect = render_ui("main", {"pattern_type": "card"})
+
+        assert effect["type"] == "render-ui"
+        assert effect["slot"] == "main"
+        assert effect["data"]["pattern_type"] == "card"
+
+    def test_navigate_effect_format(self):
+        """Navigate effects have correct structure."""
+        from orbital_app.generated.effect_helpers import navigate
+
+        effect = navigate("/dashboard", {"id": "123"})
+
+        assert effect["type"] == "navigate"
+        assert effect["path"] == "/dashboard"
+        assert effect["params"]["id"] == "123"
+
+    def test_emit_effect_format(self):
+        """Emit effects have correct structure."""
+        from orbital_app.generated.effect_helpers import emit
+
+        effect = emit("user:created", {"userId": "123"})
+
+        assert effect["type"] == "emit"
+        assert effect["event"] == "user:created"
+        assert effect["data"]["userId"] == "123"
+
+
+class TestEventRequest:
+    """Test event request validation."""
+
+    def get_any_event_route(self, client: TestClient) -> str:
+        """Get any event route for testing."""
+        response = client.get("/openapi.json")
+        paths = response.json().get("paths", {})
+        for path in paths.keys():
+            if "/events/" in path:
+                return path
+        return None
+
+    def test_event_requires_entity_id(self, test_client: TestClient):
+        """Event requests require entity_id."""
+        route = self.get_any_event_route(test_client)
+        if not route:
+            pytest.skip("No event routes found")
+
+        response = test_client.post(
+            route,
+            json={"payload": {}},  # Missing entity_id
+        )
+
+        # Should fail validation
+        assert response.status_code == 422
+
+    def test_event_accepts_payload(self, test_client: TestClient):
+        """Event requests accept optional payload."""
+        route = self.get_any_event_route(test_client)
+        if not route:
+            pytest.skip("No event routes found")
+
+        response = test_client.post(
+            route,
+            json={
+                "payload": {"key": "value"},
+                "entity_id": "test-entity",
+            },
+        )
+
+        # Should not fail on payload format
+        assert response.status_code in (200, 400, 500)  # May fail for business logic reasons
+
+
+class TestWebSocketBroadcast:
+    """Test WebSocket broadcasting of effects."""
+
+    def test_websocket_connect(self, test_client: TestClient):
+        """Can connect to global WebSocket."""
+        with test_client.websocket_connect("/ws") as ws:
+            ws.send_text("ping")
+            response = ws.receive_text()
+            assert response == "pong"
+
+    def test_websocket_entity_connect(self, test_client: TestClient):
+        """Can connect to entity-specific WebSocket."""
+        with test_client.websocket_connect("/ws/test_trait/test-123") as ws:
+            ws.send_text("ping")
+            response = ws.receive_text()
+            assert response == "pong"
+
+
+class TestStateTransitions:
+    """Test state machine transitions."""
+
+    def get_trait_with_multiple_events(self, client: TestClient) -> Dict[str, Any]:
+        """Find a trait with multiple events to test transitions."""
+        response = client.get("/openapi.json")
+        paths = response.json().get("paths", {})
+
+        # Group events by trait
+        trait_events: Dict[str, List[str]] = {}
+        for path in paths.keys():
+            if "/events/" in path:
+                parts = path.split("/events/")
+                prefix = parts[0]
+                event = parts[1]
+                if prefix not in trait_events:
+                    trait_events[prefix] = []
+                trait_events[prefix].append(event)
+
+        # Find trait with multiple events
+        for prefix, events in trait_events.items():
+            if len(events) > 1:
+                return {"prefix": prefix, "events": events}
+
+        return None
+
+    def test_state_changes_after_event(self, test_client: TestClient):
+        """State changes after processing an event."""
+        trait_info = self.get_trait_with_multiple_events(test_client)
+        if not trait_info:
+            pytest.skip("No trait with multiple events found")
+
+        prefix = trait_info["prefix"]
+
+        # Get initial state
+        initial = test_client.get(f"{prefix}/state").json()["state"]
+
+        # If there's an init event, call it
+        if "init" in trait_info["events"]:
+            response = test_client.post(
+                f"{prefix}/events/init",
+                json={"payload": {}, "entity_id": "transition-test"},
+            )
+
+            if response.status_code == 200 and response.json().get("success"):
+                # Check state changed
+                new_state = test_client.get(f"{prefix}/state").json()["state"]
+                # State should have changed or stayed same (depending on current state)
+                assert isinstance(new_state, str)

package/shells/python-shell/tests/test_integration.py

@@ -0,0 +1,347 @@
+"""
+Integration Tests for Orbital Python Shell
+
+Tests the full request/response cycle including:
+- HTTP API endpoints
+- WebSocket connections
+- Event processing and effects
+- State management
+"""
+import pytest
+import asyncio
+from typing import List, Any, Dict
+from fastapi.testclient import TestClient
+
+
+class TestHealthCheck:
+    """Test the health check endpoint."""
+
+    def test_health_check_returns_200(self, test_client: TestClient):
+        """Health endpoint returns 200 status."""
+        response = test_client.get("/health")
+        assert response.status_code == 200
+
+    def test_health_check_returns_healthy_status(self, test_client: TestClient):
+        """Health endpoint returns healthy status."""
+        response = test_client.get("/health")
+        data = response.json()
+        assert data["status"] == "healthy"
+        assert "version" in data
+        assert "environment" in data
+
+
+class TestEventAPIRoutes:
+    """Test that event API routes are registered."""
+
+    def test_openapi_schema_available(self, test_client: TestClient):
+        """OpenAPI schema is available."""
+        response = test_client.get("/openapi.json")
+        assert response.status_code == 200
+        data = response.json()
+        assert "paths" in data
+
+    def test_api_routes_registered(self, test_client: TestClient):
+        """API routes are registered in OpenAPI schema."""
+        response = test_client.get("/openapi.json")
+        data = response.json()
+        paths = list(data.get("paths", {}).keys())
+
+        # Should have at least health and some API routes
+        assert "/health" in paths
+        # Check for example task routes (from shell template)
+        api_routes = [p for p in paths if p.startswith("/api/")]
+        assert len(api_routes) > 0, "Should have API routes registered"
+
+
+class TestExampleTaskRoutes:
+    """Test the example task routes from shell template (if present)."""
+
+    def _has_task_routes(self, client: TestClient) -> bool:
+        """Check if example task routes exist."""
+        response = client.get("/openapi.json")
+        paths = response.json().get("paths", {})
+        return "/api/tasks/create" in paths
+
+    def test_create_task_requires_auth(self, test_client: TestClient):
+        """Create task endpoint requires authentication."""
+        if not self._has_task_routes(test_client):
+            pytest.skip("Example task routes not present in this app")
+
+        response = test_client.post(
+            "/api/tasks/create",
+            json={"payload": {"name": "Test Task"}},
+        )
+        assert response.status_code == 401
+
+    def test_complete_task_not_found(self, test_client: TestClient):
+        """Complete task returns 404 for non-existent task."""
+        if not self._has_task_routes(test_client):
+            pytest.skip("Example task routes not present in this app")
+
+        response = test_client.post(
+            "/api/tasks/non-existent-id/complete",
+            json={"payload": {"timestamp": "2024-01-01T00:00:00Z"}},
+        )
+        assert response.status_code == 404
+
+
+class TestWebSocket:
+    """Test WebSocket connections."""
+
+    def test_websocket_global_connect(self, test_client: TestClient):
+        """Can connect to global WebSocket endpoint."""
+        with test_client.websocket_connect("/ws") as websocket:
+            websocket.send_text("ping")
+            data = websocket.receive_text()
+            assert data == "pong"
+
+    def test_websocket_entity_connect(self, test_client: TestClient):
+        """Can connect to entity-specific WebSocket endpoint."""
+        with test_client.websocket_connect("/ws/tasks/123") as websocket:
+            websocket.send_text("ping")
+            data = websocket.receive_text()
+            assert data == "pong"
+
+    def test_websocket_multiple_pings(self, test_client: TestClient):
+        """WebSocket handles multiple ping/pong exchanges."""
+        with test_client.websocket_connect("/ws") as websocket:
+            for _ in range(3):
+                websocket.send_text("ping")
+                data = websocket.receive_text()
+                assert data == "pong"
+
+
+class TestConnectionManager:
+    """Test WebSocket connection manager directly."""
+
+    @pytest.mark.asyncio
+    async def test_connection_manager_init(self):
+        """Connection manager initializes correctly."""
+        from orbital_app.core.websocket import ConnectionManager
+        manager = ConnectionManager()
+        assert manager.active_connections == {}
+        assert manager.global_connections == []
+
+    @pytest.mark.asyncio
+    async def test_broadcast_without_connections(self):
+        """Broadcast doesn't fail without connections."""
+        from orbital_app.core.websocket import ConnectionManager
+        manager = ConnectionManager()
+
+        # Should not raise
+        await manager.broadcast_client_effects(
+            entity_type="tasks",
+            entity_id="123",
+            event="complete",
+            client_effects=[["notify", {"message": "Test"}]],
+            data={"tasks": {"id": "123"}},
+        )
+
+    @pytest.mark.asyncio
+    async def test_broadcast_global(self):
+        """Global broadcast doesn't fail."""
+        from orbital_app.core.websocket import ConnectionManager
+        manager = ConnectionManager()
+
+        await manager.broadcast_global({"type": "test", "data": {}})
+
+
+class TestEventResponse:
+    """Test event response format."""
+
+    def test_event_response_model(self):
+        """EventResponse model has correct fields."""
+        from orbital_app.core.event_router import EventResponse
+
+        response = EventResponse(
+            success=True,
+            newState="completed",
+            data={"test": "data"},
+            clientEffects=[["notify", {"message": "Done"}]],
+        )
+
+        assert response.success is True
+        assert response.newState == "completed"
+        assert response.data == {"test": "data"}
+        assert len(response.clientEffects) == 1
+
+
+class TestClientEffectsFormat:
+    """Test that client effects are properly formatted."""
+
+    def test_client_effects_json_serializable(self):
+        """All client effects must be JSON serializable."""
+        import json
+
+        effects: List[Any] = [
+            ["render-ui", "main", {"type": "entity-detail", "entity": "Task"}],
+            ["navigate", "/tasks/123"],
+            ["notify", {"type": "success", "message": "Done!"}],
+            ["emit", "task:completed", {"taskId": "123"}],
+        ]
+
+        # Should not raise
+        serialized = json.dumps(effects)
+        deserialized = json.loads(serialized)
+        assert deserialized == effects
+
+    def test_nested_effects_serializable(self):
+        """Nested effect data is JSON serializable."""
+        import json
+
+        effect = [
+            "render-ui",
+            "main",
+            {
+                "pattern_type": "stats",
+                "config": {
+                    "items": [
+                        {"label": "Status", "value": "ready"},
+                        {"label": "Count", "value": 42},
+                    ]
+                }
+            }
+        ]
+
+        serialized = json.dumps(effect)
+        deserialized = json.loads(serialized)
+        assert deserialized == effect
+
+
+class TestCORSConfiguration:
+    """Test CORS is properly configured."""
+
+    def test_cors_preflight(self, test_client: TestClient):
+        """CORS preflight request is handled."""
+        response = test_client.options(
+            "/api/tasks/create",
+            headers={
+                "Origin": "http://localhost:3000",
+                "Access-Control-Request-Method": "POST",
+            },
+        )
+        # Should not be 404 - either 200/204 (allowed) or 405 (method not allowed for OPTIONS)
+        assert response.status_code in (200, 204, 405)
+
+
+class TestEffectExecutor:
+    """Test the effect executor."""
+
+    @pytest.mark.asyncio
+    async def test_effect_executor_init(self):
+        """Effect executor initializes correctly."""
+        from orbital_app.core.effect_executor import EffectExecutor
+        from orbital_app.core.repository import InMemoryRepository
+
+        repo = InMemoryRepository()
+        executor = EffectExecutor(repo)
+
+        assert executor.data == {}
+        assert executor.client_effects == []
+        assert executor.effect_results == []
+
+    @pytest.mark.asyncio
+    async def test_effect_executor_client_effects(self):
+        """Effect executor collects client effects."""
+        from orbital_app.core.effect_executor import EffectExecutor
+        from orbital_app.core.repository import InMemoryRepository
+
+        repo = InMemoryRepository()
+        executor = EffectExecutor(repo)
+
+        context = {"entity": {}, "payload": {}}
+
+        # Execute client-side effects
+        await executor.execute(["notify", {"message": "Test"}], context)
+        await executor.execute(["render-ui", "main", {"type": "card"}], context)
+        await executor.execute(["navigate", "/home"], context)
+
+        assert len(executor.client_effects) == 3
+
+
+class TestRepository:
+    """Test the repository layer."""
+
+    @pytest.mark.asyncio
+    async def test_in_memory_repository_crud(self):
+        """In-memory repository supports CRUD operations."""
+        from orbital_app.core.repository import InMemoryRepository
+
+        repo = InMemoryRepository()
+
+        # Create
+        entity = await repo.create("tasks", {"name": "Test Task", "status": "active"})
+        assert "id" in entity
+        assert entity["name"] == "Test Task"
+
+        # Read
+        fetched = await repo.get("tasks", entity["id"])
+        assert fetched is not None
+        assert fetched["name"] == "Test Task"
+
+        # Update
+        updated = await repo.update("tasks", entity["id"], {"status": "completed"})
+        assert updated["status"] == "completed"
+
+        # Delete
+        deleted = await repo.delete("tasks", entity["id"])
+        assert deleted is True
+
+        # Verify deleted
+        gone = await repo.get("tasks", entity["id"])
+        assert gone is None
+
+    @pytest.mark.asyncio
+    async def test_in_memory_repository_list(self):
+        """In-memory repository supports listing entities."""
+        from orbital_app.core.repository import InMemoryRepository
+
+        repo = InMemoryRepository()
+
+        # Create multiple
+        await repo.create("tasks", {"name": "Task 1"})
+        await repo.create("tasks", {"name": "Task 2"})
+        await repo.create("tasks", {"name": "Task 3"})
+
+        # List all
+        tasks = await repo.list("tasks")
+        assert len(tasks) == 3
+
+
+class TestEventBus:
+    """Test the event bus."""
+
+    @pytest.mark.asyncio
+    async def test_event_bus_subscribe_emit(self):
+        """Event bus handles subscribe and emit."""
+        from orbital_app.core.event_bus import EventBus
+
+        bus = EventBus()
+        received = []
+
+        def handler(payload):
+            received.append(payload)
+
+        bus.subscribe("test:event", handler)
+        await bus.emit("test:event", {"data": "test"})
+
+        assert len(received) == 1
+        assert received[0]["data"] == "test"
+
+    @pytest.mark.asyncio
+    async def test_event_bus_once(self):
+        """Event bus once subscription only fires once."""
+        from orbital_app.core.event_bus import EventBus
+
+        bus = EventBus()
+        received = []
+
+        def handler(payload):
+            received.append(payload)
+
+        bus.subscribe("test:event", handler, once=True)
+        await bus.emit("test:event", {"n": 1})
+        await bus.emit("test:event", {"n": 2})
+
+        assert len(received) == 1
+        assert received[0]["n"] == 1