experimaestro 2.0.0b8__py3-none-any.whl → 2.0.0b17__py3-none-any.whl

experimaestro/tests/test_remote_state.py

@@ -30,10 +30,13 @@ from experimaestro.scheduler.remote.protocol import (
     create_notification,
     serialize_datetime,
     deserialize_datetime,
-    serialize_job,
-    serialize_experiment,
-    serialize_run,
 )
+from experimaestro.scheduler.state_provider import (
+    MockJob,
+    MockExperiment,
+    MockService,
+)
+from experimaestro.notifications import LevelInformation
 
 
 # =============================================================================
@@ -111,13 +114,17 @@ class TestProtocolMessages:
     def test_notification_creation(self):
         """Test creating a JSON-RPC notification"""
         notif_json = create_notification(
-            NotificationMethod.JOB_UPDATED, {"job_id": "job1", "state": "running"}
+            NotificationMethod.STATE_EVENT,
+            {"event_type": "JobStateChangedEvent", "data": {"job_id": "job1"}},
         )
         data = json.loads(notif_json)
 
         assert data["jsonrpc"] == JSONRPC_VERSION
-        assert data["method"] == "notification.job_updated"
-        assert data["params"] == {"job_id": "job1", "state": "running"}
+        assert data["method"] == "notification.state_event"
+        assert data["params"] == {
+            "event_type": "JobStateChangedEvent",
+            "data": {"job_id": "job1"},
+        }
         assert "id" not in data
 
     def test_notification_parsing(self):
@@ -187,90 +194,231 @@ class TestDatetimeSerialization:
 
 
 class TestJobSerialization:
-    """Test job serialization"""
+    """Test job serialization using state_dict"""
 
     def test_serialize_mock_job(self):
-        """Test serializing a MockJob-like object"""
-        from experimaestro.scheduler.state_provider import MockJob
-
+        """Test serializing a MockJob using state_dict()"""
+        # Note: tags, experiment_id, run_id are not part of MockJob
+        # as they are experiment-specific
         job = MockJob(
             identifier="job123",
             task_id="task.MyTask",
-            locator="job123",
             path=Path("/tmp/jobs/job123"),
             state="running",
             submittime=1704067200.0,
             starttime=1704067300.0,
             endtime=None,
             progress=[],
-            tags={"tag1": "value1"},
-            experiment_id="exp1",
-            run_id="run1",
             updated_at="2024-01-01T00:00:00",
         )
 
-        result = serialize_job(job)
+        result = job.state_dict()
 
-        assert result["identifier"] == "job123"
+        assert result["job_id"] == "job123"
         assert result["task_id"] == "task.MyTask"
         assert result["path"] == "/tmp/jobs/job123"
         # State is serialized from JobState enum - case may vary
         assert result["state"].upper() == "RUNNING"
-        assert result["tags"] == {"tag1": "value1"}
-        assert result["experiment_id"] == "exp1"
-        assert result["run_id"] == "run1"
 
 
 class TestExperimentSerialization:
-    """Test experiment serialization"""
+    """Test experiment serialization using state_dict"""
 
     def test_serialize_mock_experiment(self):
-        """Test serializing a MockExperiment-like object"""
-        from experimaestro.scheduler.state_provider import MockExperiment
+        """Test serializing a MockExperiment using state_dict()"""
+        from experimaestro.scheduler.interfaces import ExperimentStatus
 
+        # New layout: experiments/{experiment_id}/{run_id}
         exp = MockExperiment(
-            workdir=Path("/tmp/xp/myexp"),
-            current_run_id="run_20240101",
-            total_jobs=10,
-            finished_jobs=5,
-            failed_jobs=1,
-            updated_at="2024-01-01T12:00:00",
+            workdir=Path("/tmp/experiments/myexp/run_20240101"),
+            run_id="run_20240101",
+            status=ExperimentStatus.RUNNING,
             started_at=1704067200.0,
             ended_at=None,
             hostname="server1",
         )
 
-        result = serialize_experiment(exp)
+        result = exp.state_dict()
 
         assert result["experiment_id"] == "myexp"
-        assert result["workdir"] == "/tmp/xp/myexp"
-        assert result["current_run_id"] == "run_20240101"
-        assert result["total_jobs"] == 10
-        assert result["finished_jobs"] == 5
-        assert result["failed_jobs"] == 1
-        assert result["hostname"] == "server1"
-
-
-class TestRunSerialization:
-    """Test run serialization"""
-
-    def test_serialize_run_dict(self):
-        """Test serializing a run dictionary"""
-        run_dict = {
-            "run_id": "run_20240101",
-            "experiment_id": "exp1",
-            "hostname": "server1",
-            "started_at": "2024-01-01T10:00:00",
-            "ended_at": None,
-            "status": "active",
-        }
+        assert result["run_id"] == "run_20240101"
+        assert result["status"] == "running"
 
-        result = serialize_run(run_dict)
 
-        assert result["run_id"] == "run_20240101"
-        assert result["experiment_id"] == "exp1"
-        assert result["hostname"] == "server1"
-        assert result["status"] == "active"
+class TestServiceSerialization:
+    """Test service serialization using state_dict"""
+
+    def test_serialize_mock_service(self):
+        """Test serializing a MockService using full_state_dict()
+
+        MockService.full_state_dict() preserves the original service class name
+        (not MockService's class name) to enable proper round-trip serialization.
+        """
+        service = MockService(
+            service_id="svc123",
+            description_text="Test service",
+            state_dict_data={"port": 8080},
+            service_class="mymodule.MyService",
+            experiment_id="exp1",
+            run_id="run1",
+            url="http://localhost:8080",
+        )
+
+        result = service.full_state_dict()
+
+        assert result["service_id"] == "svc123"
+        assert result["description"] == "Test service"
+        # Preserves original service class, not MockService's class name
+        assert result["class"] == "mymodule.MyService"
+        assert result["state_dict"] == {"port": 8080}
+
+    def test_serialize_mock_service_no_class(self):
+        """Test serializing a MockService with service_class=None"""
+        service = MockService(
+            service_id="svc123",
+            description_text="Test service",
+            state_dict_data={"port": 8080},
+            service_class=None,
+        )
+
+        result = service.full_state_dict()
+
+        # class is always present, even when None
+        assert result["class"] is None
+        assert result["service_id"] == "svc123"
+        assert result["description"] == "Test service"
+        assert result["state_dict"] == {"port": 8080}
+
+
+# =============================================================================
+# SSH Round-Trip Tests (Mock → full_state_dict → client → Mock)
+# =============================================================================
+
+
+class MockSSHClient:
+    """Minimal mock of SSHStateProviderClient for testing deserialization"""
+
+    def __init__(self, remote_workspace: str, local_cache_dir: Path):
+        self.remote_workspace = remote_workspace
+        self.local_cache_dir = local_cache_dir
+
+    def _parse_datetime_to_timestamp(self, value) -> float | None:
+        """Convert datetime value to Unix timestamp"""
+        if value is None:
+            return None
+        if isinstance(value, (int, float)):
+            return float(value)
+        if isinstance(value, str):
+            try:
+                dt = datetime.fromisoformat(value)
+                return dt.timestamp()
+            except ValueError:
+                return None
+        if isinstance(value, datetime):
+            return value.timestamp()
+        return None
+
+
+class TestSSHRoundTrip:
+    """Test SSH round-trip serialization: Mock → state_dict → from_state_dict"""
+
+    def test_mockjob_ssh_roundtrip(self, tmp_path: Path):
+        """Test MockJob round-trip through SSH serialization path"""
+        from experimaestro.scheduler.remote.client import SSHStateProviderClient
+
+        workspace_path = tmp_path / "workspace"
+        workspace_path.mkdir()
+        job_path = workspace_path / "jobs" / "my.Task" / "abc123"
+
+        # Create original MockJob
+        # Note: tags, experiment_id, run_id are not part of MockJob
+        original = MockJob(
+            identifier="abc123",
+            task_id="my.Task",
+            path=job_path,
+            state="running",
+            submittime=1234567890.0,
+            starttime=1234567891.0,
+            endtime=None,
+            progress=[LevelInformation(level=0, progress=0.5, desc="halfway")],
+            updated_at="2024-01-01T00:00:00",
+            exit_code=None,
+            retry_count=2,
+        )
+
+        # Server-side: serialize using state_dict
+        serialized = original.state_dict()
+
+        # Client-side: deserialize using _dict_to_job (which uses from_state_dict)
+        mock_client = MockSSHClient(
+            remote_workspace=str(workspace_path),
+            local_cache_dir=workspace_path,
+        )
+        restored = SSHStateProviderClient._dict_to_job(mock_client, serialized)
+
+        # Verify equality by comparing state_dict outputs
+        assert original.state_dict() == restored.state_dict()
+
+    def test_mockexperiment_ssh_roundtrip(self, tmp_path: Path):
+        """Test MockExperiment round-trip through SSH serialization path"""
+        from experimaestro.scheduler.interfaces import ExperimentStatus
+        from experimaestro.scheduler.remote.client import SSHStateProviderClient
+
+        workspace_path = tmp_path / "workspace"
+        workspace_path.mkdir()
+        # New layout: experiments/{exp-id}/{run-id}/
+        (workspace_path / "experiments" / "test_exp" / "run_001").mkdir(parents=True)
+
+        # Create original MockExperiment
+        original = MockExperiment(
+            workdir=workspace_path / "experiments" / "test_exp" / "run_001",
+            run_id="run_001",
+            status=ExperimentStatus.RUNNING,
+            started_at=1234567890.0,
+            ended_at=None,
+            hostname="testhost",
+        )
+
+        # Server-side: serialize using state_dict
+        serialized = original.state_dict()
+
+        # Client-side: deserialize using _dict_to_experiment
+        mock_client = MockSSHClient(
+            remote_workspace=str(workspace_path),
+            local_cache_dir=workspace_path,
+        )
+        restored = SSHStateProviderClient._dict_to_experiment(mock_client, serialized)
+
+        # Verify equality by comparing state_dict outputs
+        assert original.state_dict() == restored.state_dict()
+
+    def test_mockservice_ssh_roundtrip(self, tmp_path: Path):
+        """Test MockService round-trip through SSH serialization path"""
+        from experimaestro.scheduler.remote.client import SSHStateProviderClient
+
+        # Create original MockService (no service_class to avoid Service recreation)
+        original = MockService(
+            service_id="svc_123",
+            description_text="Test service description",
+            state_dict_data={"port": 8080, "host": "localhost"},
+            service_class=None,
+            experiment_id="exp1",
+            run_id="run1",
+            url="http://localhost:8080",
+        )
+
+        # Server-side: serialize using full_state_dict
+        serialized = original.full_state_dict()
+
+        # Client-side: deserialize using _dict_to_service
+        mock_client = MockSSHClient(
+            remote_workspace="/tmp/workspace",
+            local_cache_dir=tmp_path,
+        )
+        restored = SSHStateProviderClient._dict_to_service(mock_client, serialized)
+
+        # Verify equality by comparing full_state_dict outputs
+        assert original.full_state_dict() == restored.full_state_dict()
 
 
 # =============================================================================
@@ -312,15 +460,13 @@ class TestServerRequestHandling:
 
     def test_handle_get_experiments(self, server_with_mock, mock_state_provider):
         """Test handling get_experiments request"""
-        from experimaestro.scheduler.state_provider import MockExperiment
+        from experimaestro.scheduler.interfaces import ExperimentStatus
 
+        # New layout: experiments/{exp-id}/{run-id}
         mock_exp = MockExperiment(
-            workdir=Path("/tmp/xp/exp1"),
-            current_run_id="run1",
-            total_jobs=5,
-            finished_jobs=3,
-            failed_jobs=0,
-            updated_at="2024-01-01T00:00:00",
+            workdir=Path("/tmp/experiments/exp1/run1"),
+            run_id="run1",
+            status=ExperimentStatus.RUNNING,
         )
         mock_state_provider.get_experiments.return_value = [mock_exp]
 
@@ -330,23 +476,67 @@ class TestServerRequestHandling:
         assert result[0]["experiment_id"] == "exp1"
         mock_state_provider.get_experiments.assert_called_once_with(since=None)
 
+    def test_handle_get_experiment(self, server_with_mock, mock_state_provider):
+        """Test handling get_experiment request"""
+        from experimaestro.scheduler.interfaces import ExperimentStatus
+
+        # New layout: experiments/{exp-id}/{run-id}
+        mock_exp = MockExperiment(
+            workdir=Path("/tmp/experiments/exp1/run1"),
+            run_id="run1",
+            status=ExperimentStatus.RUNNING,
+        )
+        mock_state_provider.get_experiment.return_value = mock_exp
+
+        result = server_with_mock._handle_get_experiment({"experiment_id": "exp1"})
+
+        assert result["experiment_id"] == "exp1"
+        assert result["run_id"] == "run1"
+        mock_state_provider.get_experiment.assert_called_once_with("exp1")
+
+    def test_handle_get_experiment_not_found(
+        self, server_with_mock, mock_state_provider
+    ):
+        """Test handling get_experiment when experiment not found"""
+        mock_state_provider.get_experiment.return_value = None
+
+        result = server_with_mock._handle_get_experiment(
+            {"experiment_id": "nonexistent"}
+        )
+
+        assert result is None
+
+    def test_handle_get_experiment_runs(self, server_with_mock, mock_state_provider):
+        """Test handling get_experiment_runs request"""
+        from experimaestro.scheduler.interfaces import ExperimentStatus
+
+        mock_run = MockExperiment(
+            workdir=Path("/tmp/experiments/exp1/run1"),
+            run_id="run1",
+            status=ExperimentStatus.DONE,
+            hostname="server1",
+            started_at=1704067200.0,
+            ended_at=1704070800.0,
+        )
+        mock_state_provider.get_experiment_runs.return_value = [mock_run]
+
+        result = server_with_mock._handle_get_experiment_runs({"experiment_id": "exp1"})
+
+        assert len(result) == 1
+        assert result[0]["run_id"] == "run1"
+        assert result[0]["status"] == "done"
+
     def test_handle_get_jobs(self, server_with_mock, mock_state_provider):
         """Test handling get_jobs request"""
-        from experimaestro.scheduler.state_provider import MockJob
-
         mock_job = MockJob(
             identifier="job1",
             task_id="task.Test",
-            locator="job1",
             path=Path("/tmp/jobs/job1"),
             state="done",
             submittime=None,
             starttime=None,
             endtime=None,
             progress=[],
-            tags={},
-            experiment_id="exp1",
-            run_id="run1",
             updated_at="",
         )
         mock_state_provider.get_jobs.return_value = [mock_job]
@@ -359,7 +549,196 @@ class TestServerRequestHandling:
         )
 
         assert len(result) == 1
-        assert result[0]["identifier"] == "job1"
+        assert result[0]["job_id"] == "job1"
+
+    def test_handle_get_job(self, server_with_mock, mock_state_provider):
+        """Test handling get_job request"""
+        mock_job = MockJob(
+            identifier="job1",
+            task_id="task.Test",
+            path=Path("/tmp/jobs/job1"),
+            state="running",
+            submittime=1704067200.0,
+            starttime=1704067300.0,
+            endtime=None,
+            progress=[],
+            updated_at="2024-01-01T00:00:00",
+        )
+        mock_state_provider.get_job.return_value = mock_job
+
+        result = server_with_mock._handle_get_job(
+            {"job_id": "job1", "experiment_id": "exp1", "run_id": "run1"}
+        )
+
+        assert result["job_id"] == "job1"
+        assert result["task_id"] == "task.Test"
+
+    def test_handle_get_job_not_found(self, server_with_mock, mock_state_provider):
+        """Test handling get_job when job not found"""
+        mock_state_provider.get_job.return_value = None
+
+        result = server_with_mock._handle_get_job(
+            {"job_id": "nonexistent", "experiment_id": "exp1", "run_id": "run1"}
+        )
+
+        assert result is None
+
+    def test_handle_get_all_jobs(self, server_with_mock, mock_state_provider):
+        """Test handling get_all_jobs request"""
+        mock_job1 = MockJob(
+            identifier="job1",
+            task_id="task.Test1",
+            path=Path("/tmp/jobs/job1"),
+            state="done",
+            submittime=None,
+            starttime=None,
+            endtime=None,
+            progress=[],
+            updated_at="",
+        )
+        mock_job2 = MockJob(
+            identifier="job2",
+            task_id="task.Test2",
+            path=Path("/tmp/jobs/job2"),
+            state="running",
+            submittime=None,
+            starttime=None,
+            endtime=None,
+            progress=[],
+            updated_at="",
+        )
+        mock_state_provider.get_all_jobs.return_value = [mock_job1, mock_job2]
+
+        result = server_with_mock._handle_get_all_jobs({"state": None, "tags": None})
+
+        assert len(result) == 2
+        assert result[0]["job_id"] == "job1"
+        assert result[1]["job_id"] == "job2"
+
+    def test_handle_get_services(self, server_with_mock, mock_state_provider):
+        """Test handling get_services request"""
+        mock_service = MockService(
+            service_id="svc1",
+            description_text="Test service",
+            state_dict_data={"port": 8080},
+            service_class="mymodule.MyService",
+            experiment_id="exp1",
+            run_id="run1",
+            url="http://localhost:8080",
+        )
+        mock_state_provider.get_services.return_value = [mock_service]
+
+        result = server_with_mock._handle_get_services(
+            {"experiment_id": "exp1", "run_id": "run1"}
+        )
+
+        assert len(result) == 1
+        assert result[0]["service_id"] == "svc1"
+        assert result[0]["description"] == "Test service"
+
+    def test_handle_get_tags_map(self, server_with_mock, mock_state_provider):
+        """Test handling get_tags_map request"""
+        mock_state_provider.get_tags_map.return_value = {
+            "job1": {"model": "bert", "dataset": "squad"},
+            "job2": {"model": "gpt"},
+        }
+
+        result = server_with_mock._handle_get_tags_map(
+            {"experiment_id": "exp1", "run_id": "run1"}
+        )
+
+        assert result["job1"]["model"] == "bert"
+        assert result["job2"]["model"] == "gpt"
+
+    def test_handle_get_tags_map_missing_experiment(self, server_with_mock):
+        """Test get_tags_map raises TypeError when experiment_id missing"""
+        with pytest.raises(TypeError, match="experiment_id is required"):
+            server_with_mock._handle_get_tags_map({"run_id": "run1"})
+
+    def test_handle_get_dependencies_map(self, server_with_mock, mock_state_provider):
+        """Test handling get_dependencies_map request"""
+        mock_state_provider.get_dependencies_map.return_value = {
+            "job2": ["job1"],
+            "job3": ["job1", "job2"],
+        }
+
+        result = server_with_mock._handle_get_dependencies_map(
+            {"experiment_id": "exp1", "run_id": "run1"}
+        )
+
+        assert result["job2"] == ["job1"]
+        assert result["job3"] == ["job1", "job2"]
+
+    def test_handle_get_dependencies_map_missing_experiment(self, server_with_mock):
+        """Test get_dependencies_map raises TypeError when experiment_id missing"""
+        with pytest.raises(TypeError, match="experiment_id is required"):
+            server_with_mock._handle_get_dependencies_map({"run_id": "run1"})
+
+    def test_handle_kill_job(self, server_with_mock, mock_state_provider):
+        """Test handling kill_job request"""
+        mock_job = MockJob(
+            identifier="job1",
+            task_id="task.Test",
+            path=Path("/tmp/jobs/job1"),
+            state="running",
+            submittime=None,
+            starttime=None,
+            endtime=None,
+            progress=[],
+            updated_at="",
+        )
+        mock_state_provider.get_job.return_value = mock_job
+        mock_state_provider.kill_job.return_value = True
+
+        result = server_with_mock._handle_kill_job(
+            {"job_id": "job1", "experiment_id": "exp1", "run_id": "run1"}
+        )
+
+        assert result["success"] is True
+
+    def test_handle_kill_job_not_found(self, server_with_mock, mock_state_provider):
+        """Test handling kill_job when job not found"""
+        mock_state_provider.get_job.return_value = None
+
+        result = server_with_mock._handle_kill_job(
+            {"job_id": "nonexistent", "experiment_id": "exp1", "run_id": "run1"}
+        )
+
+        assert result["success"] is False
+        assert "error" in result
+
+    def test_handle_clean_job(self, server_with_mock, mock_state_provider):
+        """Test handling clean_job request"""
+        mock_job = MockJob(
+            identifier="job1",
+            task_id="task.Test",
+            path=Path("/tmp/jobs/job1"),
+            state="done",
+            submittime=None,
+            starttime=None,
+            endtime=None,
+            progress=[],
+            updated_at="",
+        )
+        mock_state_provider.get_job.return_value = mock_job
+        mock_state_provider.clean_job.return_value = True
+
+        result = server_with_mock._handle_clean_job(
+            {"job_id": "job1", "experiment_id": "exp1", "run_id": "run1"}
+        )
+
+        assert result["success"] is True
+
+    def test_handle_clean_job_not_found(self, server_with_mock, mock_state_provider):
+        """Test handling clean_job when job not found"""
+        mock_state_provider.get_job.return_value = None
+
+        result = server_with_mock._handle_clean_job(
+            {"job_id": "nonexistent", "experiment_id": "exp1", "run_id": "run1"}
+        )
+
+        assert result["success"] is False
+        assert "error" in result
 
     def test_handle_get_sync_info(self, server_with_mock):
         """Test handling get_sync_info request"""
@@ -412,22 +791,112 @@ class TestClientServerIntegration:
         assert isinstance(resp_msg, RPCResponse)
         assert resp_msg.result == []
 
-    def test_notification_handling(self):
-        """Test notification message handling"""
+    def test_notification_job_updated(self):
+        """Test job_updated notification message handling via STATE_EVENT"""
         notification = create_notification(
-            NotificationMethod.JOB_UPDATED,
+            NotificationMethod.STATE_EVENT,
             {
-                "job_id": "job1",
-                "experiment_id": "exp1",
-                "run_id": "run1",
-                "state": "running",
+                "event_type": "JobStateChangedEvent",
+                "data": {
+                    "job_id": "job1",
+                    "experiment_id": "exp1",
+                    "run_id": "run1",
+                },
             },
         )
 
         msg = parse_message(notification)
         assert isinstance(msg, RPCNotification)
-        assert msg.method == "notification.job_updated"
-        assert msg.params["job_id"] == "job1"
+        assert msg.method == "notification.state_event"
+        assert msg.params["event_type"] == "JobStateChangedEvent"
+        assert msg.params["data"]["job_id"] == "job1"
+
+    def test_notification_experiment_updated(self):
+        """Test experiment_updated notification message handling via STATE_EVENT"""
+        notification = create_notification(
+            NotificationMethod.STATE_EVENT,
+            {
+                "event_type": "ExperimentUpdatedEvent",
+                "data": {
+                    "experiment_id": "exp1",
+                },
+            },
+        )
+
+        msg = parse_message(notification)
+        assert isinstance(msg, RPCNotification)
+        assert msg.method == "notification.state_event"
+        assert msg.params["event_type"] == "ExperimentUpdatedEvent"
+        assert msg.params["data"]["experiment_id"] == "exp1"
+
+    def test_notification_run_updated(self):
+        """Test run_updated notification message handling via STATE_EVENT"""
+        notification = create_notification(
+            NotificationMethod.STATE_EVENT,
+            {
+                "event_type": "RunUpdatedEvent",
+                "data": {
+                    "experiment_id": "exp1",
+                    "run_id": "run1",
+                },
+            },
+        )
+
+        msg = parse_message(notification)
+        assert isinstance(msg, RPCNotification)
+        assert msg.method == "notification.state_event"
+        assert msg.params["event_type"] == "RunUpdatedEvent"
+        assert msg.params["data"]["run_id"] == "run1"
+
+    def test_notification_service_updated(self):
+        """Test service_updated notification message handling via STATE_EVENT"""
+        notification = create_notification(
+            NotificationMethod.STATE_EVENT,
+            {
+                "event_type": "ServiceAddedEvent",
+                "data": {
+                    "experiment_id": "exp1",
+                    "run_id": "run1",
+                    "service_id": "svc1",
+                },
+            },
+        )
+
+        msg = parse_message(notification)
+        assert isinstance(msg, RPCNotification)
+        assert msg.method == "notification.state_event"
+        assert msg.params["event_type"] == "ServiceAddedEvent"
+        assert msg.params["data"]["service_id"] == "svc1"
+
+    def test_notification_file_changed(self):
+        """Test file_changed notification message handling"""
+        notification = create_notification(
+            NotificationMethod.FILE_CHANGED,
+            {
+                "path": "/workspace/logs/job.log",
+                "event_type": "modified",
+            },
+        )
+
+        msg = parse_message(notification)
+        assert isinstance(msg, RPCNotification)
+        assert msg.method == "notification.file_changed"
+        assert msg.params["path"] == "/workspace/logs/job.log"
+
+    def test_notification_shutdown(self):
+        """Test shutdown notification message handling"""
+        notification = create_notification(
+            NotificationMethod.SHUTDOWN,
+            {
+                "reason": "server_stop",
+                "code": 0,
+            },
+        )
+
+        msg = parse_message(notification)
+        assert isinstance(msg, RPCNotification)
+        assert msg.method == "notification.shutdown"
+        assert msg.params["reason"] == "server_stop"
 
 
 # =============================================================================
@@ -456,19 +925,17 @@ class TestClientDataConversion:
 
     def test_dict_to_job(self, client, tmp_path):
         """Test converting dictionary to MockJob"""
+        # Note: tags, experiment_id, run_id are not part of MockJob
+        # as they are experiment-specific
         job_dict = {
-            "identifier": "job123",
+            "job_id": "job123",
             "task_id": "task.MyTask",
-            "locator": "job123",
             "path": "/remote/workspace/jobs/job123",
             "state": "running",
-            "submittime": "2024-01-01T10:00:00",
-            "starttime": "2024-01-01T10:01:00",
-            "endtime": None,
+            "submitted_time": "2024-01-01T10:00:00",
+            "started_time": "2024-01-01T10:01:00",
+            "ended_time": None,
             "progress": [],
-            "tags": {"key": "value"},
-            "experiment_id": "exp1",
-            "run_id": "run1",
         }
 
         job = client._dict_to_job(job_dict)
@@ -477,18 +944,15 @@ class TestClientDataConversion:
         assert job.task_id == "task.MyTask"
         # Path should be mapped to local cache
         assert job.path == tmp_path / "jobs/job123"
-        assert job.tags == {"key": "value"}
 
     def test_dict_to_experiment(self, client, tmp_path):
         """Test converting dictionary to MockExperiment"""
+        # New layout: experiments/{experiment_id}/{run_id}
         exp_dict = {
             "experiment_id": "myexp",
-            "workdir": "/remote/workspace/xp/myexp",
-            "current_run_id": "run1",
-            "total_jobs": 10,
-            "finished_jobs": 5,
-            "failed_jobs": 1,
-            "updated_at": "2024-01-01T12:00:00",
+            "workdir": "/remote/workspace/experiments/myexp/run1",
+            "run_id": "run1",
+            "status": "running",
             "hostname": "server1",
         }
 
@@ -496,20 +960,17 @@ class TestClientDataConversion:
 
         assert exp.experiment_id == "myexp"
         # Path should be mapped to local cache
-        assert exp.workdir == tmp_path / "xp/myexp"
-        assert exp.total_jobs == 10
+        assert exp.workdir == tmp_path / "experiments/myexp/run1"
         assert exp.hostname == "server1"
 
-    def test_path_mapping_outside_workspace(self, client, tmp_path):
+    def test_path_mapping_outside_workspace(self, client):
         """Test path mapping for paths outside remote workspace"""
         job_dict = {
-            "identifier": "job123",
+            "job_id": "job123",
             "task_id": "task.MyTask",
-            "locator": "job123",
             "path": "/other/path/job123",  # Not under remote_workspace
             "state": "done",
             "progress": [],
-            "tags": {},
         }
 
         job = client._dict_to_job(job_dict)