update runs integration test

Author: alexluck-sift

python/lib/sift_client/_tests/resources/test_runs.py

@@ -8,12 +8,14 @@
 """
 
 import os
+from datetime import datetime, timedelta, timezone
 
 import pytest
 
 from sift_client import SiftClient
 from sift_client.resources import RunsAPI, RunsAPIAsync
 from sift_client.sift_types import Run
+from sift_client.sift_types.run import RunCreate, RunUpdate
 
 pytestmark = pytest.mark.integration
 
@@ -58,6 +60,20 @@ def test_run(runs_api_sync):
     assert len(runs) >= 1
     return runs[0]
 
+@pytest.fixture(scope="function")
+def new_run(runs_api_sync):
+    """Create a test run for update tests."""
+    run_name = f"test_run_update_{datetime.now(timezone.utc).isoformat()}"
+    description = "Test run created by Sift Client pytest"
+    created_run = runs_api_sync.create(
+        RunCreate(
+            name=run_name,
+            description=description,
+            tags=["sift-client-pytest"],
+        )
+    )
+    return created_run
+
 
 class TestRunsAPIAsync:
     """Test suite for the async Runs API functionality."""
@@ -111,6 +127,8 @@ async def test_list_with_name_contains_filter(self, runs_api_async):
             for run in runs:
                 assert "test" in run.name.lower()
 
+        # TODO: test run-specific filters
+
         @pytest.mark.asyncio
         async def test_list_with_limit(self, runs_api_async):
             """Test run listing with different limits."""
@@ -195,6 +213,281 @@ async def test_find_multiple_raises_error(self, runs_api_async):
             with pytest.raises(ValueError, match="Multiple"):
                 await runs_api_async.find(name_contains="a")
 
+    class TestCreate:
+        """Tests for the async create method."""
+
+        @pytest.mark.asyncio
+        async def test_create_basic_run(self, runs_api_async):
+            """Test creating a basic run with minimal fields."""
+            run_name = f"test_run_create_{datetime.now(timezone.utc).isoformat()}"
+            description = "Test run created by Sift Client pytest"
+            run_create = RunCreate(
+                name=run_name,
+                description=description,
+                tags=["sift-client-pytest"],
+            )
+
+            created_run = await runs_api_async.create(run_create)
+
+            try:
+                # Verify the run was created
+                assert created_run is not None
+                assert isinstance(created_run, Run)
+                assert created_run.id_ is not None
+                assert created_run.name == run_name
+                assert created_run.description == description
+                assert created_run.created_date is not None
+                assert created_run.modified_date is not None
+            finally:
+                # Clean up: archive the test run
+                await runs_api_async.archive(created_run)
+
+        @pytest.mark.asyncio
+        async def test_create_run_with_all_fields(self, runs_api_async):
+            """Test creating a run with all optional fields."""
+            run_name = f"test_run_full_{datetime.now(timezone.utc).isoformat()}"
+            description = "Test run created by Sift Client pytest"
+            start_time = datetime.now(timezone.utc) - timedelta(hours=1)
+            stop_time = datetime.now(timezone.utc)
+
+            run_create = RunCreate(
+                name=run_name,
+                description=description,
+                client_key=f"client_key_{datetime.now(timezone.utc).timestamp()}",
+                start_time=start_time,
+                stop_time=stop_time,
+                tags=["test", "pytest", "integration", "sift-client-pytest"],
+                metadata={"test_type": "integration", "version": "1.0", "is_automated": True},
+            )
+
+            created_run = await runs_api_async.create(run_create)
+
+            try:
+                # Verify all fields
+                assert created_run.name == run_name
+                assert created_run.description == description
+                assert created_run.client_key is not None
+                assert created_run.start_time is not None
+                assert created_run.stop_time is not None
+                assert created_run.tags == ["test", "pytest", "integration", "sift-client-pytest"]
+                assert created_run.metadata["test_type"] == "integration"
+                assert created_run.metadata["version"] == "1.0"
+                assert created_run.metadata["is_automated"] is True
+            finally:
+                # Clean up
+                await runs_api_async.archive(created_run)
+
+        @pytest.mark.asyncio
+        async def test_create_run_with_dict(self, runs_api_async):
+            """Test creating a run using a dictionary instead of RunCreate object."""
+            run_name = f"test_run_dict_{datetime.now(timezone.utc).isoformat()}"
+            description = "Test run created by Sift Client pytest"
+
+            run_dict = {
+                "name": run_name,
+                "description": description,
+                "tags": ["sift-client-pytest"],
+            }
+
+            created_run = await runs_api_async.create(run_dict)
+
+            try:
+                assert created_run.name == run_name
+                assert created_run.description == description
+                assert created_run.tags == ["sift-client-pytest"]
+            finally:
+                await runs_api_async.archive(created_run)
+
+    class TestUpdate:
+        """Tests for the async update method."""
+
+        @pytest.mark.asyncio
+        async def test_update_run_description(self, runs_api_async, new_run):
+            """Test updating a run's description."""
+            try:
+                # Update the description
+                update = RunUpdate(description="Updated description")
+                updated_run = await runs_api_async.update(new_run, update)
+
+                # Verify the update
+                assert updated_run.id_ == new_run.id_
+                assert updated_run.description == "Updated description"
+                assert updated_run.name == new_run.name  # Name should remain unchanged
+            finally:
+                await runs_api_async.archive(new_run.id_)
+
+        @pytest.mark.asyncio
+        async def test_update_run_name(self, runs_api_async, new_run):
+            """Test updating a run's name."""
+            try:
+                # Update the name
+                new_name = f"updated_{new_run.name}"
+                update = RunUpdate(name=new_name)
+                updated_run = await runs_api_async.update(new_run, update)
+
+                # Verify the update
+                assert updated_run.name == new_name
+                assert updated_run.id_ == new_run.id_
+            finally:
+                await runs_api_async.archive(new_run.id_)
+
+        @pytest.mark.asyncio
+        async def test_update_run_tags_and_metadata(self, runs_api_async, new_run):
+            """Test updating a run's tags and metadata."""
+            try:
+                # Update tags
+                update = RunUpdate(
+                    tags=["updated", "new-tag", "sift-client-pytest"],
+                )
+                updated_run = await runs_api_async.update(new_run, update)
+
+                # Verify the updates
+                assert set(updated_run.tags) == {"updated", "new-tag", "sift-client-pytest"}
+            finally:
+                await runs_api_async.archive(new_run.id_)
+
+        @pytest.mark.asyncio
+        async def test_update_run_times(self, runs_api_async, new_run):
+            """Test updating a run's start and stop times."""
+            try:
+                # Update with start and stop times
+                start_time = datetime.now(timezone.utc) - timedelta(hours=2)
+                stop_time = datetime.now(timezone.utc) - timedelta(hours=1)
+                update = RunUpdate(start_time=start_time, stop_time=stop_time)
+                updated_run = await runs_api_async.update(new_run, update)
+
+                # Verify the times were set
+                assert updated_run.start_time is not None
+                assert updated_run.stop_time is not None
+                # Allow for small time differences due to serialization
+                assert abs((updated_run.start_time - start_time).total_seconds()) < 1
+                assert abs((updated_run.stop_time - stop_time).total_seconds()) < 1
+            finally:
+                await runs_api_async.archive(new_run.id_)
+
+        @pytest.mark.asyncio
+        async def test_update_with_dict(self, runs_api_async, new_run):
+            """Test updating a run using a dictionary instead of RunUpdate object."""
+            try:
+                # Update using dict
+                update_dict = {"description": "Updated via dict"}
+                updated_run = await runs_api_async.update(new_run, update_dict)
+
+                assert updated_run.description == "Updated via dict"
+            finally:
+                await runs_api_async.archive(new_run.id_)
+
+        @pytest.mark.asyncio
+        async def test_update_with_run_id_string(self, runs_api_async, new_run):
+            """Test updating a run by passing run ID as string."""
+            try:
+                # Update using run ID string
+                update = RunUpdate(description="Updated via ID string")
+                updated_run = await runs_api_async.update(new_run.id_, update)
+
+                assert updated_run.id_ == new_run.id_
+                assert updated_run.description == "Updated via ID string"
+            finally:
+                await runs_api_async.archive(new_run.id_)
+
+    class TestArchive:
+        """Tests for the async archive method."""
+
+        @pytest.mark.asyncio
+        async def test_archive_run(self, runs_api_async, new_run):
+            """Test archiving a run."""
+            run = await runs_api_async.archive(new_run)
+
+            assert isinstance(run, Run)
+            assert run.id_ == new_run.id_
+            assert run.is_archived is True
+
+            # Verify it's archived by checking it doesn't appear in normal list
+            runs_without_archived = await runs_api_async.list_(
+                name=new_run.name, include_archived=False
+            )
+            assert len(runs_without_archived) == 0
+
+            # Verify it appears when including archived
+            runs_with_archived = await runs_api_async.list_(
+                name=new_run.name, include_archived=True
+            )
+            assert len(runs_with_archived) == 1
+            assert runs_with_archived[0].id_ == new_run.id_
+            assert runs_with_archived[0].archived_date is not None
+
+        @pytest.mark.asyncio
+        async def test_archive_with_run_id_string(self, runs_api_async, new_run):
+            """Test archiving a run by passing run ID as string."""
+            # Archive using run ID string
+            run = await runs_api_async.archive(new_run.id_)
+
+            assert isinstance(run, Run)
+            assert run.id_ == new_run.id_
+            assert run.is_archived is True
+
+        @pytest.mark.asyncio
+        async def test_get_archived_run_by_id(self, runs_api_async, new_run):
+            """Test that we can still get an archived run by ID."""
+            # Archive the test run
+            run = await runs_api_async.archive(new_run)
+
+            assert isinstance(run, Run)
+            assert run.id_ == new_run.id_
+            assert run.is_archived is True
+
+    class TestStop:
+        """Tests for the async stop method."""
+
+        @pytest.mark.asyncio
+        async def test_stop_run(self, runs_api_async, new_run):
+            """Test stopping a run."""
+            try:
+                # Stop the run
+                stopped_run = await runs_api_async.stop(new_run)
+
+                # Verify the run was stopped
+                assert isinstance(stopped_run, Run)
+                assert stopped_run.id_ == new_run.id_
+                assert stopped_run.stop_time is not None
+            finally:
+                await runs_api_async.archive(new_run.id_)
+
+        @pytest.mark.asyncio
+        async def test_stop_run_with_id_string(self, runs_api_async, new_run):
+            """Test stopping a run by passing run ID as string."""
+            try:
+                # Stop using run ID string
+                stopped_run = await runs_api_async.stop(new_run.id_)
+
+                # Verify the run was stopped
+                assert isinstance(stopped_run, Run)
+                assert stopped_run.id_ == new_run.id_
+                assert stopped_run.stop_time is not None
+            finally:
+                await runs_api_async.archive(new_run.id_)
+
+        @pytest.mark.asyncio
+        async def test_stop_run_with_start_time(self, runs_api_async, new_run):
+            """Test stopping a run that has a start time."""
+            try:
+                # Set start time first
+                start_time = datetime.now(timezone.utc) - timedelta(hours=1)
+                update = RunUpdate(start_time=start_time)
+                await runs_api_async.update(new_run, update)
+
+                # Stop the run
+                stopped_run = await runs_api_async.stop(new_run)
+
+                # Verify the run was stopped and times are valid
+                assert stopped_run.stop_time is not None
+                assert stopped_run.start_time is not None
+                assert stopped_run.stop_time > stopped_run.start_time
+            finally:
+                await runs_api_async.archive(new_run.id_)
+
+
+
 
 class TestRunsAPISync:
     """Test suite for the synchronous Runs API functionality.

python/lib/sift_client/resources/runs.py

@@ -244,14 +244,15 @@ async def archive(
     async def stop(
         self,
         run: str | Run,
-    ) -> None:
+    ) -> Run:
         """Stop a run by setting its stop time to the current time.
 
         Args:
             run: The Run or run ID to stop.
         """
         run_id = run._id_or_error if isinstance(run, Run) else run
         await self._low_level_client.stop_run(run_id=run_id or "")
+        return await self.get(run_id=run_id)
 
     async def create_automatic_association_for_assets(
         self,

python/lib/sift_client/sift_types/_base.py

@@ -151,7 +151,7 @@ def _build_proto_and_paths(
                 try:
                     setattr(proto_msg, field_name, value)
                     paths.append(path)
-                except TypeError as e:
+                except (TypeError, AttributeError) as e:
                     raise TypeError(
                         f"Can't set {field_name} to {value} on {proto_msg.__class__.__name__}"
                     ) from e
@@ -174,7 +174,7 @@ def to_proto(self) -> ProtoT:
         proto_msg = proto_cls()
 
         # Get all fields
-        data = self.model_dump(exclude_none=False)
+        data = self.model_dump(exclude_unset=True)
         self._build_proto_and_paths(proto_msg, data)
 
         return proto_msg

python/lib/sift_client/sift_types/run.py

@@ -155,13 +155,6 @@ class RunUpdate(RunBase, ModelUpdate[RunProto]):
 
     name: str | None = None
 
-    @model_validator(mode="after")
-    def _validate_non_updatable_fields(self):
-        """Validate that the fields that cannot be updated are not set."""
-        if self.client_key is not None:
-            raise ValueError("Cannot update client key")
-        return self
-
     def _get_proto_class(self) -> type[RunProto]:
         return RunProto