Add tests for experiment result

Author: douglasjacobsen

lib/ramble/ramble/test/end_to_end/experiment_hashes.py

@@ -61,9 +61,17 @@ def test_experiment_hashes(mutable_config, mutable_mock_workspace_path, workspac
     with open(experiment_inventory) as f:
         data = sjson.load(f)
 
-    assert "application_definition" in data
-    assert data["application_definition"] != ""
-    assert data["application_definition"] is not None
+    assert "object_definitions" in data
+    assert data["object_definitions"] is not None
+    assert data["object_definitions"] != []
+
+    found_app = False
+    for definition in data["object_definitions"]:
+        if definition["type"] == "applications":
+            found_app = True
+            assert definition["digest"] != ""
+            assert definition["digest"] is not None
+    assert found_app
 
     # Test Attributes
     expected_attrs = {"variables", "modifiers", "env_vars", "internals", "chained_experiments"}

lib/ramble/ramble/test/experiment_result.py

@@ -8,10 +8,25 @@
 
 """Tests on the ExperimentResult class"""
 
+import pytest
+
 from ramble.experiment_result import ExperimentResult
 
 
-def test_to_dict(mutable_mock_apps_repo):
+@pytest.fixture
+def mock_workspace():
+    class MockWorkspace:
+        def __init__(self):
+            self.path = "/mock/workspace/path"
+            self.name = "mock_workspace"
+
+        def get_path(self):
+            return self.path
+
+    return MockWorkspace()
+
+
+def test_to_dict(mutable_mock_apps_repo, mock_workspace):
     basic_app_inst = mutable_mock_apps_repo.get("basic")
     basic_app_inst.set_variables_and_variants(
         {"workload_name": "test_wl", "experiment_status": "placeholder", "test_var": "my_var"},
@@ -20,7 +35,7 @@ def test_to_dict(mutable_mock_apps_repo):
     )
     basic_app_inst.set_status("UNKNOWN")
     exp_res = ExperimentResult(basic_app_inst)
-    exp_res.finalize()
+    exp_res.finalize(mock_workspace)
     res_dict = exp_res.to_dict()
 
     assert "name" in res_dict

lib/ramble/ramble/test/test_experiment_result.py

@@ -0,0 +1,124 @@
+# Copyright 2022-2025 The Ramble Authors
+#
+# Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+# https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+# <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+# option. This file may not be copied, modified, or distributed
+# except according to those terms.
+
+"""
+Tests for the experiment_result module.
+"""
+
+import os
+import time
+
+import pytest
+
+from ramble.experiment_result import ExperimentResult
+from ramble.util.file_util import get_newest_experiment_file
+
+# pylint: disable=protected-access
+
+
+@pytest.fixture
+def experiment_result(tmpdir):
+    """Fixture for an ExperimentResult object."""
+    app_inst = mock_app_inst(tmpdir)
+    result = ExperimentResult(app_inst)
+    result.name = "test_experiment"
+    result.status = "SUCCESS"
+    result.raw_variables = {"VAR1": "VALUE1"}
+    result.variables = {"VAR1": "VALUE1"}
+    result.variants = ["variant1", "variant2"]
+    result.object_definitions = [{"name": "test_object", "type": "APPLICATION"}]
+    return result
+
+
+def mock_app_inst(tmpdir):
+    """Creates a mock application instance."""
+
+    class MockExpander:
+        """Mock expander class."""
+
+        def __init__(self):
+            self.experiment_run_dir = str(tmpdir)
+
+    class MockAppInst:
+        """Mock application instance class."""
+
+        def __init__(self):
+            self.expander = MockExpander()
+
+        def object_inventory(self, workspace):  # pylint: disable=unused-argument
+            """Returns a mock object inventory."""
+            return [{"name": "test_object", "type": "APPLICATION"}]
+
+    return MockAppInst()
+
+
+def test_write_read_cache(experiment_result, tmpdir):
+    """Test writing and reading the experiment result cache."""
+    app_inst = mock_app_inst(tmpdir)
+    experiment_result.write_cache(app_inst)
+
+    new_result = ExperimentResult(app_inst)
+    assert new_result.read_cache(None, app_inst)
+
+    assert new_result.name == experiment_result.name
+    assert new_result.status == experiment_result.status
+    assert new_result.raw_variables == experiment_result.raw_variables
+    assert new_result.variables == experiment_result.variables
+    assert new_result.variants == experiment_result.variants
+    assert new_result.object_definitions == experiment_result.object_definitions
+
+
+def test_get_newest_experiment_file(tmpdir):
+    """Test the get_newest_experiment_file function."""
+    # Create some files with different modification times
+    file1 = tmpdir.join("file1.txt")
+    file1.write("content")
+    time.sleep(0.1)
+    file2 = tmpdir.join("file2.txt")
+    file2.write("content")
+    time.sleep(0.1)
+    subdir = tmpdir.mkdir("subdir")
+    file3 = subdir.join("file3.txt")
+    file3.write("content")
+
+    newest_file, timestamp = get_newest_experiment_file(str(tmpdir))
+    assert newest_file == str(file3)
+    assert timestamp == os.path.getmtime(str(file3))
+
+
+def test_read_cache_stale(experiment_result, tmpdir):
+    """Test that read_cache returns False if the cache is stale."""
+    app_inst = mock_app_inst(tmpdir)
+    experiment_result.write_cache(app_inst)
+
+    # Make a file that is newer than the cache
+    time.sleep(0.1)
+    new_file = tmpdir.join("new_file.txt")
+    new_file.write("content")
+
+    new_result = ExperimentResult(app_inst)
+    assert not new_result.read_cache(None, app_inst)
+
+
+def test_read_cache_object_inventory_changed(experiment_result, tmpdir):
+    """
+    Test that read_cache returns False if the object inventory has changed.
+    """
+    app_inst = mock_app_inst(tmpdir)
+    experiment_result.write_cache(app_inst)
+
+    class MockAppInstNewInventory(type(app_inst)):
+        """Mock application instance with a different object inventory."""
+
+        def object_inventory(self, workspace):  # pylint: disable=unused-argument
+            """Returns a different mock object inventory."""
+            return [{"name": "new_object", "type": "APPLICATION"}]
+
+    new_app_inst = MockAppInstNewInventory()
+    new_result = ExperimentResult(new_app_inst)
+    assert not new_result.read_cache(None, new_app_inst)