add integration test

Author: Datata1

examples/create_workspace_with_landscape.py

@@ -0,0 +1,72 @@
+import asyncio
+
+from codesphere import CodesphereSDK
+from codesphere.resources.workspace import WorkspaceCreate
+from codesphere.resources.workspace.landscape import ProfileBuilder
+
+TEAM_ID = 123  # Replace with your actual team ID
+
+
+async def main():
+    async with CodesphereSDK() as sdk:
+        plans = await sdk.metadata.list_plans()
+        plan_id = next(
+            (p for p in plans if p.title == "Micro" and not p.deprecated), None
+        ).id
+
+        payload = WorkspaceCreate(
+            plan_id,
+            team_id=TEAM_ID,
+            name=f"my-unique-landscape-demo-{int(asyncio.time())}",
+        )
+
+        print("\nCreating workspace...")
+        workspace = await sdk.workspaces.create(payload)
+        print(f"Created workspace: {workspace.name} (ID: {workspace.id})")
+
+        try:
+            print("Waiting for workspace to be running...")
+            await workspace.wait_until_running(timeout=300.0, poll_interval=5.0)
+            print("Workspace is now running!")
+
+            print("\nCreating landscape profile...")
+            profile = (
+                ProfileBuilder()
+                .prepare()
+                .add_step("npm install", name="Install dependencies")
+                .done()
+                .add_reactive_service("web")
+                .plan(plan_id)
+                .add_step("npm start")
+                .add_port(3000, public=True)
+                .add_path("/", port=3000)
+                .replicas(1)
+                .env("NODE_ENV", "production")
+                .done()
+                .build()
+            )
+
+            profile_name = "production"
+            await workspace.landscape.save_profile(profile_name, profile)
+            print(f"Saved profile: {profile_name}")
+
+            profiles = await workspace.landscape.list_profiles()
+            print(f"Available profiles: {[p.name for p in profiles]}")
+
+            yaml_content = await workspace.landscape.get_profile(profile_name)
+            print(f"\nGenerated profile YAML:\n{yaml_content}")
+
+            print("\nDeploying landscape...")
+            await workspace.landscape.deploy(profile=profile_name)
+            print("Deployment started!")
+
+        finally:
+            # Cleanup: Delete the workspace
+            # print("\nCleaning up...")
+            # await workspace.delete()
+            # print(f"Deleted workspace: {workspace.name}")
+            pass
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

src/codesphere/resources/workspace/landscape/schemas.py

@@ -47,9 +47,9 @@ class ReactiveServiceConfig(CamelModel):
     """Configuration for a reactive (custom) service in the run stage."""
 
     steps: List[Step] = Field(default_factory=list)
-    env: Optional[Dict[str, str]] = None
-    plan: Optional[int] = None
+    plan: int  # Required - workspace plan ID
     replicas: int = 1
+    env: Optional[Dict[str, str]] = None
     base_image: Optional[str] = None
     run_as_user: Optional[int] = Field(default=None, ge=0, le=65534)
     run_as_group: Optional[int] = Field(default=None, ge=0, le=65534)
@@ -289,16 +289,25 @@ def build(self) -> tuple[str, ReactiveServiceConfig]:
 
         Returns:
             Tuple of (service_name, ReactiveServiceConfig).
+
+        Raises:
+            ValueError: If plan is not set.
         """
+        if self._plan is None:
+            raise ValueError(
+                f"Service '{self._name}' requires a plan ID. "
+                "Use .plan(plan_id) to set it."
+            )
+
         network = None
         if self._ports or self._paths:
             network = NetworkConfig(ports=self._ports, paths=self._paths)
 
         config = ReactiveServiceConfig(
             steps=self._steps,
-            env=self._env if self._env else None,
             plan=self._plan,
             replicas=self._replicas,
+            env=self._env if self._env else None,
             base_image=self._base_image,
             run_as_user=self._run_as_user,
             run_as_group=self._run_as_group,

src/codesphere/resources/workspace/schemas.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import asyncio
 import logging
 from functools import cached_property
 from typing import Dict, List, Optional
@@ -96,6 +97,39 @@ async def get_status(self) -> WorkspaceStatus:
 
         return await self._execute_operation(_GET_STATUS_OP)
 
+    async def wait_until_running(
+        self,
+        *,
+        timeout: float = 300.0,
+        poll_interval: float = 5.0,
+    ) -> None:
+        """Wait until the workspace is in a running state.
+
+        Args:
+            timeout: Maximum time to wait in seconds (default: 300s / 5 minutes).
+            poll_interval: Time between status checks in seconds (default: 5s).
+
+        Raises:
+            TimeoutError: If the workspace is not running within the timeout period.
+        """
+        elapsed = 0.0
+        while elapsed < timeout:
+            status = await self.get_status()
+            if status.is_running:
+                log.debug(f"Workspace {self.id} is now running.")
+                return
+
+            log.debug(
+                f"Workspace {self.id} not running yet, "
+                f"waiting {poll_interval}s... (elapsed: {elapsed:.1f}s)"
+            )
+            await asyncio.sleep(poll_interval)
+            elapsed += poll_interval
+
+        raise TimeoutError(
+            f"Workspace {self.id} did not reach running state within {timeout} seconds."
+        )
+
     async def execute_command(
         self, command: str, env: Optional[Dict[str, str]] = None
     ) -> CommandOutput:

tests/integration/test_landscape.py

@@ -185,6 +185,7 @@ async def test_save_profile_with_builder(
         self,
         sdk_client: CodesphereSDK,
         test_workspace: Workspace,
+        test_plan_id: int,
     ):
         """save_profile should create a profile file using ProfileBuilder."""
         workspace = await sdk_client.workspaces.get(workspace_id=test_workspace.id)
@@ -196,6 +197,7 @@ async def test_save_profile_with_builder(
             .add_step("echo 'Installing dependencies'")
             .done()
             .add_reactive_service("web")
+            .plan(test_plan_id)
             .add_step("echo 'Starting server'")
             .add_port(3000, public=True)
             .replicas(1)
@@ -280,6 +282,7 @@ async def test_get_profile_returns_yaml_content(
         self,
         sdk_client: CodesphereSDK,
         test_workspace: Workspace,
+        test_plan_id: int,
     ):
         """get_profile should return the YAML content of a saved profile."""
         workspace = await sdk_client.workspaces.get(workspace_id=test_workspace.id)
@@ -291,6 +294,7 @@ async def test_get_profile_returns_yaml_content(
             .add_step("npm install")
             .done()
             .add_reactive_service("api")
+            .plan(test_plan_id)
             .add_step("npm start")
             .add_port(8080)
             .env("NODE_ENV", "production")
@@ -357,6 +361,7 @@ async def test_complex_profile_roundtrip(
         self,
         sdk_client: CodesphereSDK,
         test_workspace: Workspace,
+        test_plan_id: int,
     ):
         """A complex profile should survive save and retrieve."""
         workspace = await sdk_client.workspaces.get(workspace_id=test_workspace.id)
@@ -372,6 +377,7 @@ async def test_complex_profile_roundtrip(
             .add_step("npm test")
             .done()
             .add_reactive_service("frontend")
+            .plan(test_plan_id)
             .add_step("npm run serve")
             .add_port(3000, public=True)
             .add_path("/", port=3000)
@@ -380,6 +386,7 @@ async def test_complex_profile_roundtrip(
             .health_endpoint("/health")
             .done()
             .add_reactive_service("backend")
+            .plan(test_plan_id)
             .add_step("python -m uvicorn main:app")
             .add_port(8000)
             .add_path("/api", port=8000, strip_path=True)
@@ -412,6 +419,7 @@ async def test_profile_with_special_characters_in_env(
         self,
         sdk_client: CodesphereSDK,
         test_workspace: Workspace,
+        test_plan_id: int,
     ):
         """Profile with special characters in env values should work."""
         workspace = await sdk_client.workspaces.get(workspace_id=test_workspace.id)
@@ -420,6 +428,7 @@ async def test_profile_with_special_characters_in_env(
         profile = (
             ProfileBuilder()
             .add_reactive_service("app")
+            .plan(test_plan_id)
             .add_step("npm start")
             .add_port(3000)
             .env("DATABASE_URL", "postgres://user:p@ss=word@localhost:5432/db")
@@ -437,3 +446,148 @@ async def test_profile_with_special_characters_in_env(
 
         finally:
             await workspace.landscape.delete_profile(profile_name)
+
+
+class TestLandscapeDeploymentWorkflow:
+    """Integration tests for the complete landscape deployment workflow."""
+
+    async def test_full_landscape_workflow_deploy_teardown_delete(
+        self,
+        sdk_client: CodesphereSDK,
+        test_workspace: Workspace,
+        test_plan_id: int,
+    ):
+        """Test the complete workflow: create profile, deploy, teardown, delete profile."""
+        workspace = await sdk_client.workspaces.get(workspace_id=test_workspace.id)
+        profile_name = "sdk-workflow-test"
+
+        # Step 1: Create a valid profile with ProfileBuilder
+        profile = (
+            ProfileBuilder()
+            .prepare()
+            .add_step("echo 'Preparing...'", name="Prepare")
+            .done()
+            .add_reactive_service("web")
+            .plan(test_plan_id)
+            .add_step("echo 'Starting web service' && sleep infinity")
+            .add_port(3000, public=True)
+            .add_path("/", port=3000)
+            .replicas(1)
+            .env("NODE_ENV", "production")
+            .done()
+            .build()
+        )
+
+        try:
+            # Step 2: Save the profile
+            await workspace.landscape.save_profile(profile_name, profile)
+
+            # Verify profile exists
+            profiles = await workspace.landscape.list_profiles()
+            profile_names = [p.name for p in profiles]
+            assert profile_name in profile_names, "Profile should exist after saving"
+
+            # Verify profile content
+            content = await workspace.landscape.get_profile(profile_name)
+            assert "schemaVersion: v0.2" in content
+            assert "web:" in content
+            assert f"plan: {test_plan_id}" in content
+
+            # Step 3: Deploy the landscape
+            await workspace.landscape.deploy(profile=profile_name)
+
+            # Step 4: Teardown the landscape
+            await workspace.landscape.teardown()
+
+        finally:
+            # Step 5: Delete the profile
+            await workspace.landscape.delete_profile(profile_name)
+
+            # Verify profile is deleted
+            profiles = await workspace.landscape.list_profiles()
+            profile_names = [p.name for p in profiles]
+            assert profile_name not in profile_names, (
+                "Profile should not exist after deletion"
+            )
+
+    async def test_deploy_and_teardown_only(
+        self,
+        sdk_client: CodesphereSDK,
+        test_workspace: Workspace,
+        test_plan_id: int,
+    ):
+        """Test deploy and teardown without profile deletion."""
+        workspace = await sdk_client.workspaces.get(workspace_id=test_workspace.id)
+        profile_name = "sdk-deploy-teardown-test"
+
+        profile = (
+            ProfileBuilder()
+            .prepare()
+            .add_step("echo 'Setup complete'")
+            .done()
+            .add_reactive_service("api")
+            .plan(test_plan_id)
+            .add_step("echo 'API running' && sleep infinity")
+            .add_port(8080)
+            .add_path("/api", port=8080)
+            .replicas(1)
+            .done()
+            .build()
+        )
+
+        try:
+            # Save profile
+            await workspace.landscape.save_profile(profile_name, profile)
+
+            # Deploy
+            await workspace.landscape.deploy(profile=profile_name)
+
+            # Teardown
+            await workspace.landscape.teardown()
+
+            # Profile should still exist after teardown
+            profiles = await workspace.landscape.list_profiles()
+            profile_names = [p.name for p in profiles]
+            assert profile_name in profile_names, (
+                "Profile should still exist after teardown"
+            )
+
+        finally:
+            # Cleanup
+            await workspace.landscape.delete_profile(profile_name)
+
+    async def test_profile_deletion_removes_from_list(
+        self,
+        sdk_client: CodesphereSDK,
+        test_workspace: Workspace,
+        test_plan_id: int,
+    ):
+        """Verify that deleting a profile removes it from the profile list."""
+        workspace = await sdk_client.workspaces.get(workspace_id=test_workspace.id)
+        profile_name = "sdk-deletion-verify-test"
+
+        profile = (
+            ProfileBuilder()
+            .add_reactive_service("service")
+            .plan(test_plan_id)
+            .add_step("echo 'running'")
+            .add_port(3000)
+            .done()
+            .build()
+        )
+
+        # Create profile
+        await workspace.landscape.save_profile(profile_name, profile)
+
+        # Verify it exists
+        profiles_before = await workspace.landscape.list_profiles()
+        assert profile_name in [p.name for p in profiles_before]
+
+        # Delete profile
+        await workspace.landscape.delete_profile(profile_name)
+
+        # Verify it's gone
+        profiles_after = await workspace.landscape.list_profiles()
+        assert profile_name not in [p.name for p in profiles_after], (
+            f"Profile '{profile_name}' should be removed after deletion"
+        )