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

experimaestro/tests/test_dynamic_locking.py

@@ -0,0 +1,317 @@
+"""Tests for the dynamic locking infrastructure.
+
+Tests for DynamicLockFile, JobDependencyLock, and related classes.
+"""
+
+import json
+import pytest
+from pathlib import Path
+
+from experimaestro.locking import (
+    DynamicLockFile,
+    JobDependencyLock,
+    LockError,
+)
+from experimaestro.tokens import TokenLockFile
+from experimaestro.core.partial_lock import PartialLockFile
+
+
+# --- Test implementations ---
+
+
+class MockLockFile(DynamicLockFile):
+    """Mock implementation of DynamicLockFile for testing."""
+
+    value: int
+
+    def from_information(self, info) -> None:
+        if info is None:
+            self.value = 0
+        elif isinstance(info, dict):
+            self.value = info.get("value", 0)
+        else:
+            raise ValueError(f"Invalid information format: {info}")
+
+    def to_information(self) -> dict:
+        return {"value": self.value}
+
+
+class MockJobLock(JobDependencyLock):
+    """Mock implementation of JobDependencyLock for testing."""
+
+    def __init__(self, lock_file_path: Path = None):
+        self.lock_file_path = lock_file_path
+        self.acquired = False
+        self.released = False
+
+    def acquire(self) -> None:
+        self.verify_lock_file()
+        self.acquired = True
+
+    def release(self) -> None:
+        self.released = True
+        super().release()
+
+
+# --- DynamicLockFile tests ---
+
+
+class TestDynamicLockFile:
+    """Tests for DynamicLockFile."""
+
+    def test_create_writes_json_file(self, tmp_path: Path):
+        """create() should write a JSON file with correct structure."""
+        lock_path = tmp_path / "test.lock"
+        job_uri = "/path/to/job"
+
+        lock_file = MockLockFile.create(lock_path, job_uri, information={"value": 42})
+
+        assert lock_path.is_file()
+        content = json.loads(lock_path.read_text())
+        assert content["job_uri"] == job_uri
+        assert content["information"] == {"value": 42}
+        assert lock_file.job_uri == job_uri
+        assert lock_file.value == 42
+
+    def test_create_with_none_information(self, tmp_path: Path):
+        """create() with None information should use defaults."""
+        lock_path = tmp_path / "test.lock"
+        job_uri = "/path/to/job"
+
+        lock_file = MockLockFile.create(lock_path, job_uri, information=None)
+
+        assert lock_file.value == 0
+        content = json.loads(lock_path.read_text())
+        assert content["information"] == {"value": 0}
+
+    def test_load_reads_json_file(self, tmp_path: Path):
+        """Loading should read JSON file correctly."""
+        lock_path = tmp_path / "test.lock"
+        lock_path.write_text(
+            json.dumps({"job_uri": "/some/job", "information": {"value": 123}})
+        )
+
+        lock_file = MockLockFile(lock_path)
+
+        assert lock_file.job_uri == "/some/job"
+        assert lock_file.value == 123
+
+    def test_load_missing_file(self, tmp_path: Path):
+        """Loading missing file should set defaults."""
+        lock_path = tmp_path / "nonexistent.lock"
+
+        lock_file = MockLockFile(lock_path)
+
+        assert lock_file.job_uri is None
+        # Note: value is not set when file doesn't exist
+
+    def test_load_invalid_information_raises(self, tmp_path: Path):
+        """Loading with invalid information format should raise."""
+        lock_path = tmp_path / "test.lock"
+        lock_path.write_text(
+            json.dumps(
+                {
+                    "job_uri": "/some/job",
+                    "information": "invalid",  # Should be dict
+                }
+            )
+        )
+
+        with pytest.raises(ValueError, match="Invalid information format"):
+            MockLockFile(lock_path)
+
+    def test_delete_removes_file(self, tmp_path: Path):
+        """delete() should remove the lock file."""
+        lock_path = tmp_path / "test.lock"
+        lock_file = MockLockFile.create(lock_path, "/job", information={"value": 1})
+
+        assert lock_path.is_file()
+        lock_file.delete()
+        assert not lock_path.is_file()
+
+    def test_delete_missing_file_noop(self, tmp_path: Path):
+        """delete() on missing file should not raise."""
+        lock_path = tmp_path / "nonexistent.lock"
+        lock_file = MockLockFile(lock_path)
+
+        # Should not raise
+        lock_file.delete()
+
+
+# --- JobDependencyLock tests ---
+
+
+class TestJobDependencyLock:
+    """Tests for JobDependencyLock."""
+
+    def test_verify_lock_file_passes_when_exists(self, tmp_path: Path):
+        """verify_lock_file() should pass when file exists."""
+        lock_path = tmp_path / "test.lock"
+        lock_path.write_text("{}")
+
+        lock = MockJobLock(lock_file_path=lock_path)
+        lock.verify_lock_file()  # Should not raise
+
+    def test_verify_lock_file_raises_when_missing(self, tmp_path: Path):
+        """verify_lock_file() should raise LockError when file is missing."""
+        lock_path = tmp_path / "nonexistent.lock"
+
+        lock = MockJobLock(lock_file_path=lock_path)
+
+        with pytest.raises(LockError, match="Lock file missing"):
+            lock.verify_lock_file()
+
+    def test_verify_lock_file_noop_when_path_none(self):
+        """verify_lock_file() should be no-op when lock_file_path is None."""
+        lock = MockJobLock(lock_file_path=None)
+        lock.verify_lock_file()  # Should not raise
+
+    def test_release_deletes_lock_file(self, tmp_path: Path):
+        """release() should delete the lock file."""
+        lock_path = tmp_path / "test.lock"
+        lock_path.write_text("{}")
+
+        lock = MockJobLock(lock_file_path=lock_path)
+        lock.release()
+
+        assert not lock_path.is_file()
+
+    def test_release_noop_when_path_none(self):
+        """release() should not raise when lock_file_path is None."""
+        lock = MockJobLock(lock_file_path=None)
+        lock.release()  # Should not raise
+
+    def test_context_manager_acquire_release(self, tmp_path: Path):
+        """Context manager should acquire on enter and release on exit."""
+        lock_path = tmp_path / "test.lock"
+        lock_path.write_text("{}")
+
+        lock = MockJobLock(lock_file_path=lock_path)
+
+        with lock:
+            assert lock.acquired
+            assert lock_path.is_file()
+
+        assert lock.released
+        assert not lock_path.is_file()
+
+    def test_acquire_fails_if_lock_file_missing(self, tmp_path: Path):
+        """acquire() should fail if lock file verification fails."""
+        lock_path = tmp_path / "nonexistent.lock"
+        lock = MockJobLock(lock_file_path=lock_path)
+
+        with pytest.raises(LockError):
+            lock.acquire()
+
+
+# --- TokenLockFile tests ---
+
+
+class TestTokenLockFile:
+    """Tests for TokenLockFile."""
+
+    def test_create_with_count(self, tmp_path: Path):
+        """create() should store count in information."""
+        lock_path = tmp_path / "test.token"
+        job_uri = "/path/to/job"
+
+        lock_file = TokenLockFile.create(lock_path, job_uri, information={"count": 5})
+
+        assert lock_file.count == 5
+        content = json.loads(lock_path.read_text())
+        assert content["information"]["count"] == 5
+
+    def test_load_json_format(self, tmp_path: Path):
+        """Loading should read JSON format correctly."""
+        lock_path = tmp_path / "test.token"
+        lock_path.write_text(
+            json.dumps({"job_uri": "/some/job", "information": {"count": 10}})
+        )
+
+        lock_file = TokenLockFile(lock_path)
+
+        assert lock_file.job_uri == "/some/job"
+        assert lock_file.count == 10
+
+    def test_load_old_line_format(self, tmp_path: Path):
+        """Loading should read old line-based format for backward compatibility."""
+        lock_path = tmp_path / "test.token"
+        # Old format: line1=count, line2=job_uri
+        lock_path.write_text("7\n/old/job/path")
+
+        lock_file = TokenLockFile(lock_path)
+
+        assert lock_file.job_uri == "/old/job/path"
+        assert lock_file.count == 7
+
+    def test_to_information(self, tmp_path: Path):
+        """to_information() should return count dict."""
+        lock_path = tmp_path / "test.token"
+        lock_file = TokenLockFile.create(lock_path, "/job", information={"count": 3})
+
+        assert lock_file.to_information() == {"count": 3}
+
+    def test_from_information_none(self, tmp_path: Path):
+        """from_information(None) should set count to 0."""
+        lock_path = tmp_path / "test.token"
+        lock_file = TokenLockFile.create(lock_path, "/job", information=None)
+
+        assert lock_file.count == 0
+
+
+# --- PartialLockFile tests ---
+
+
+class TestPartialLockFile:
+    """Tests for PartialLockFile."""
+
+    def test_create_with_partial_name(self, tmp_path: Path):
+        """create() should store partial_name in information."""
+        lock_path = tmp_path / "holder.json"
+        job_uri = "/path/to/job"
+
+        lock_file = PartialLockFile.create(
+            lock_path, job_uri, information={"partial_name": "checkpoints"}
+        )
+
+        assert lock_file.partial_name == "checkpoints"
+        content = json.loads(lock_path.read_text())
+        assert content["information"]["partial_name"] == "checkpoints"
+
+    def test_load_json_format(self, tmp_path: Path):
+        """Loading should read JSON format correctly."""
+        lock_path = tmp_path / "holder.json"
+        lock_path.write_text(
+            json.dumps(
+                {"job_uri": "/some/job", "information": {"partial_name": "outputs"}}
+            )
+        )
+
+        lock_file = PartialLockFile(lock_path)
+
+        assert lock_file.job_uri == "/some/job"
+        assert lock_file.partial_name == "outputs"
+
+    def test_to_information(self, tmp_path: Path):
+        """to_information() should return partial_name dict."""
+        lock_path = tmp_path / "holder.json"
+        lock_file = PartialLockFile.create(
+            lock_path, "/job", information={"partial_name": "data"}
+        )
+
+        assert lock_file.to_information() == {"partial_name": "data"}
+
+    def test_from_information_none(self, tmp_path: Path):
+        """from_information(None) should set partial_name to empty string."""
+        lock_path = tmp_path / "holder.json"
+        lock_file = PartialLockFile.create(lock_path, "/job", information=None)
+
+        assert lock_file.partial_name == ""
+
+    def test_from_information_invalid_raises(self, tmp_path: Path):
+        """from_information with invalid format should raise."""
+        lock_path = tmp_path / "holder.json"
+        lock_path.write_text(json.dumps({"job_uri": "/job", "information": "invalid"}))
+
+        with pytest.raises(ValueError, match="Invalid information format"):
+            PartialLockFile(lock_path)

experimaestro/tests/test_environment.py

@@ -7,8 +7,9 @@ from experimaestro.utils.git import get_git_info
 from experimaestro.utils.environment import (
     get_environment_info,
     get_editable_packages_git_info,
-    save_environment_info,
+    get_current_environment,
     load_environment_info,
+    ExperimentEnvironment,
 )
 
 
@@ -40,8 +41,8 @@ class TestGetGitInfo:
         assert len(git_info["commit"]) == 40
         assert all(c in "0123456789abcdef" for c in git_info["commit"])
 
-        # Short commit should be 7 characters
-        assert len(git_info["commit_short"]) == 7
+        # Short commit should be 7-12 characters (git uses more if needed for uniqueness)
+        assert 7 <= len(git_info["commit_short"]) <= 12
 
     def test_returns_none_for_non_git_dir(self, tmp_path):
         """Test that get_git_info returns None for non-git directories"""
@@ -131,22 +132,24 @@ class TestGetEditablePackagesGitInfo:
 
 
 class TestSaveAndLoadEnvironmentInfo:
-    """Tests for save_environment_info and load_environment_info functions"""
+    """Tests for get_current_environment and load_environment_info functions"""
 
     def test_save_creates_file(self, tmp_path):
-        """Test that save_environment_info creates a JSON file"""
+        """Test that get_current_environment + save creates a JSON file"""
         path = tmp_path / "environment.json"
 
-        result = save_environment_info(path)
+        env = get_current_environment()
+        env.save(path)
 
         assert path.exists()
-        assert isinstance(result, dict)
+        assert isinstance(env, ExperimentEnvironment)
 
     def test_save_writes_valid_json(self, tmp_path):
         """Test that saved file contains valid JSON"""
         path = tmp_path / "environment.json"
 
-        save_environment_info(path)
+        env = get_current_environment()
+        env.save(path)
 
         content = json.loads(path.read_text())
         assert "python_version" in content
@@ -157,10 +160,13 @@ class TestSaveAndLoadEnvironmentInfo:
         """Test that load_environment_info reads back saved data"""
         path = tmp_path / "environment.json"
 
-        saved = save_environment_info(path)
+        saved = get_current_environment()
+        saved.save(path)
         loaded = load_environment_info(path)
 
-        assert loaded == saved
+        assert loaded.python_version == saved.python_version
+        assert loaded.packages == saved.packages
+        assert loaded.editable_packages == saved.editable_packages
 
     def test_load_returns_none_for_missing_file(self, tmp_path):
         """Test that load returns None for non-existent file"""
@@ -170,14 +176,18 @@ class TestSaveAndLoadEnvironmentInfo:
 
         assert result is None
 
-    def test_load_returns_none_for_invalid_json(self, tmp_path):
-        """Test that load returns None for invalid JSON"""
+    def test_load_returns_empty_for_invalid_json(self, tmp_path):
+        """Test that load returns empty ExperimentEnvironment for invalid JSON"""
         path = tmp_path / "invalid.json"
         path.write_text("not valid json{")
 
         result = load_environment_info(path)
 
-        assert result is None
+        # Returns empty ExperimentEnvironment (graceful degradation)
+        assert result is not None
+        assert result.python_version is None
+        assert result.packages == {}
+        assert result.editable_packages == {}
 
 
 class TestExperimentEnvironmentSaving:
@@ -188,7 +198,7 @@ class TestExperimentEnvironmentSaving:
         from experimaestro import experiment
 
         # Just enter the experiment context, no need to run any tasks
-        with experiment(xpmdirectory, "test-env-save", port=-1) as xp:
+        with experiment(xpmdirectory, "test-env-save") as xp:
             pass  # environment.json should be saved on __enter__
 
         env_path = xp.workdir / "environment.json"

experimaestro/tests/test_experiment.py

@@ -1,5 +1,12 @@
-from experimaestro import Task, Param, get_experiment, tag
+import json
+from pathlib import Path
+
+import pytest
+
+from experimaestro import Task, Param
 from experimaestro.tests.utils import TemporaryDirectory, TemporaryExperiment
+from experimaestro.scheduler.experiment import cleanup_experiment_history
+from experimaestro.settings import HistorySettings
 
 
 class TaskA(Task):
@@ -15,41 +22,6 @@ class TaskB(Task):
         pass
 
 
-# xp = get_experiment(id="my-xp-1")
-
-# # Returns a list of tasks which were submitted and successful
-# tasks = xp.get_tasks(myxps.evaluation.Evaluation, status=Job.DONE)
-
-# for task in tasks:
-#     # Look at the tags
-#     print(task.tags)
-
-#     # Get some information
-#     print("Task ran in {task.workdir}")
-
-#     # Look at the parent jobs
-#    print(task.depends_on)
-
-#    # Look at the dependant
-#    print(task.dependents)
-
-
-def test_experiment_history():
-    """Test retrieving experiment history"""
-    with TemporaryDirectory() as workdir:
-        with TemporaryExperiment("experiment", workdir=workdir):
-            task_a = TaskA.C().submit()
-            TaskB.C(task_a=task_a, x=tag(1)).submit()
-
-        # Look at the experiment
-        xp = get_experiment("experiment", workdir=workdir)
-
-        (task_a_info,) = xp.get_jobs(TaskA)
-        (task_b_info,) = xp.get_jobs(TaskB)
-        assert task_b_info.tags == {"x": 1}
-        assert task_b_info.depends_on == [task_a_info]
-
-
 class FlagHandler:
     def __init__(self):
         self.flag = False
@@ -71,3 +43,166 @@ def test_experiment_events():
         task_a.on_completed(flag.set)
 
     assert flag.is_set()
+
+
+# === Tests for cleanup_experiment_history ===
+
+
+def _create_run_dir(experiment_base: Path, run_id: str, status: str) -> Path:
+    """Helper to create a fake run directory with a given status."""
+    run_dir = experiment_base / run_id
+    run_dir.mkdir(parents=True, exist_ok=True)
+    env_data = {"run": {"status": status}}
+    (run_dir / "environment.json").write_text(json.dumps(env_data))
+    return run_dir
+
+
+# fmt: off
+# Cleanup uses `while count > max` logic, so max_done=N keeps N runs
+CLEANUP_TEST_CASES = [
+    # runs [(run_id, status, should_remain)], max_done, max_failed, current_run_id, current_status
+    pytest.param(
+        [
+            ("20260101_000000", "completed", False),
+            ("20260101_010000", "completed", False),
+            ("20260101_020000", "completed", True),   # kept (3rd newest)
+            ("20260101_030000", "completed", True),   # kept (2nd newest)
+            ("20260101_040000", "completed", True),   # kept (newest)
+        ],
+        3, 1, None, None,
+        id="oldest_deleted_first__max_done_3_keeps_3",
+    ),
+    pytest.param(
+        [
+            ("20260101_000000", "completed", False),  # removed (oldest completed)
+            ("20260101_010000", "completed", True),   # kept (2nd newest completed)
+            ("20260101_020000", "failed",    False),   # remove (failed after success)
+            ("20260101_030000", "completed", True),   # kept (newest completed)
+        ],
+        2, 1, None, None,
+        id="max_done_2_keeps_2_and_failed_1",
+    ),
+    pytest.param(
+        [
+            ("20260101_000000", "completed", False),
+            ("20260101_010000", "completed", False),
+            ("20260101_020000", "completed", True),   # kept (2nd newest)
+            ("20260101_030000", "completed", True),   # kept (newest)
+        ],
+        2, 1, None, None,
+        id="max_done_2_keeps_2",
+    ),
+    pytest.param(
+        [
+            ("20260101_000000", "completed", True),
+            ("20260101_010000", "completed", True),
+            ("20260101_020000", "completed", True),
+            ("20260101_030000", "completed", True),
+        ],
+        5, 1, None, None,
+        id="max_done_5_keeps_all_4",
+    ),
+    pytest.param(
+        [
+            ("20260101_000000", "failed",    False),  # removed (oldest failed)
+            ("20260101_010000", "completed", True),   # kept (only completed)
+            ("20260101_020000", "failed",    True),   # kept (2nd newest failed)
+            ("20260101_030000", "failed",    True),   # kept (newest failed)
+        ],
+        5, 2, None, None,
+        id="max_failed_2_keeps_2",
+    ),
+    pytest.param(
+        [
+            ("20260101_000000", "completed", True),   # current, preserved
+            ("20260101_010000", "completed", True),   # kept (2 non-current <= max_done=2)
+            ("20260101_020000", "completed", True),   # kept (newest)
+        ],
+        2, 1, "20260101_000000", None,
+        id="excludes_current_run__all_kept",
+    ),
+    pytest.param(
+        [
+            ("20260101_000000", "failed",    False),  # removed (success clears failed)
+            ("20260101_010000", "completed", True),
+            ("20260101_020000", "failed",    False),  # removed (success clears failed)
+            ("20260101_030000", "completed", True),
+        ],
+        5, 5, "current_run", "completed",
+        id="success_removes_all_failed",
+    ),
+    pytest.param(
+        [
+            ("20260101_010000", "completed", False),  # removed (oldest completed)
+            ("20260101_020000", "failed",    False),  # removed (before newest success)
+            ("20260101_030000", "completed", False),  # removed (oldest completed)
+            ("20260101_040000", "failed",    False),  # removed (before newest success)
+            ("20260101_050000", "completed", True),   # kept (2nd newest completed)
+            ("20260101_060000", "failed",    False),  # removed (before newest success)
+            ("20260101_070000", "completed", True),   # kept (newest completed)
+        ],
+        2, 1, None, None,
+        id="mixed_runs__max_done_2_max_failed_1",
+    ),
+    pytest.param(
+        [
+            ("20260101_120000",   "completed", False),
+            ("20260101_120000.1", "completed", False),
+            ("20260101_120000.2", "completed", True),  # kept (2nd newest)
+            ("20260101_130000",   "completed", True),  # kept (newest)
+        ],
+        2, 1, None, None,
+        id="handles_modifiers_in_order",
+    ),
+]
+# fmt: on
+
+
+@pytest.mark.parametrize(
+    "runs,max_done,max_failed,current_run_id,current_status",
+    CLEANUP_TEST_CASES,
+)
+def test_cleanup_experiment_history(
+    runs: list[tuple[str, str, bool]],
+    max_done: int,
+    max_failed: int,
+    current_run_id: str | None,
+    current_status: str | None,
+):
+    """Test cleanup_experiment_history with various configurations.
+
+    Args:
+        runs: List of (run_id, status, should_remain) tuples
+        max_done: HistorySettings.max_done (removes while count >= max_done)
+        max_failed: HistorySettings.max_failed (removes while count >= max_failed)
+        current_run_id: Run to exclude from cleanup
+        current_status: If "completed", removes ALL past failed runs
+    """
+    with TemporaryDirectory() as workdir:
+        experiment_base = workdir / "experiments" / "test-exp"
+        experiment_base.mkdir(parents=True)
+
+        # Create all run directories
+        for run_id, status, _ in runs:
+            _create_run_dir(experiment_base, run_id, status)
+
+        # Run cleanup
+        history = HistorySettings(max_done=max_done, max_failed=max_failed)
+        removed = cleanup_experiment_history(
+            experiment_base,
+            current_run_id=current_run_id,
+            current_status=current_status,
+            history=history,
+        )
+
+        # Verify results
+        remaining = {d.name for d in experiment_base.iterdir()}
+        expected_remaining = {run_id for run_id, _, keep in runs if keep}
+        expected_removed = {run_id for run_id, _, keep in runs if not keep}
+
+        assert remaining == expected_remaining, (
+            f"Remaining mismatch: got {remaining}, expected {expected_remaining}"
+        )
+        assert len(removed) == len(expected_removed), (
+            f"Removed count: got {len(removed)}, expected {len(expected_removed)}"
+        )