increase test coverage

TejasMorbagal · TejasMorbagal · commit 2d28ea945b03 · 2026-03-19T17:22:01.000+01:00
diff --git a/deep_code/tests/tools/test_publish.py b/deep_code/tests/tools/test_publish.py
@@ -386,7 +386,6 @@ def test_publish_dataset_updates_project_collection_when_exists(
         self.assertIn(mock_gen.update_deepesdl_collection, update_methods)
 
     def test_publish_dataset_raises_when_stac_root_missing(self):
-        # stac_catalog_s3_root is mandatory; publish_dataset must raise ValueError
         self.publisher.dataset_config = {
             "collection_id": "test-collection",
             "dataset_id": "test-dataset",
@@ -395,6 +394,166 @@ def test_publish_dataset_raises_when_stac_root_missing(self):
         with pytest.raises(ValueError, match="stac_catalog_s3_root"):
             self.publisher.publish_dataset(write_to_file=False)
 
+    def test_publish_dataset_raises_when_no_dataset_config(self):
+        self.publisher.dataset_config = None
+        with pytest.raises(ValueError, match="No dataset config"):
+            self.publisher.publish_dataset(write_to_file=False)
+
+    def test_publish_dataset_raises_when_ids_missing(self):
+        self.publisher.dataset_config = {"collection_id": "", "dataset_id": ""}
+        with pytest.raises(ValueError, match="Dataset ID or Collection ID missing"):
+            self.publisher.publish_dataset(write_to_file=False)
+
+    def test_publish_dataset_raises_when_license_missing(self):
+        self.publisher.dataset_config = {
+            "collection_id": "test-collection",
+            "dataset_id": "test-dataset",
+        }
+        with pytest.raises(ValueError, match="license_type is required"):
+            self.publisher.publish_dataset(write_to_file=False)
+
+    def test_write_to_file_serializes_dict(self):
+        import json
+        import os
+        import tempfile
+
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".json") as f:
+            path = f.name
+        try:
+            Publisher._write_to_file(path, {"a": 1})
+            with open(path) as f:
+                result = json.load(f)
+            self.assertEqual(result, {"a": 1})
+        finally:
+            os.unlink(path)
+
+    def test_update_and_add_to_file_dict(self):
+        file_dict = {}
+        self.publisher.gh_publisher.github_automation.local_clone_dir = "/tmp"
+        update_method = MagicMock(return_value={"key": "value"})
+        self.publisher._update_and_add_to_file_dict(file_dict, "some/catalog.json", update_method)
+        update_method.assert_called_once()
+        assert any("some/catalog.json" in str(k) for k in file_dict)
+
+    def test_update_variable_catalogs_creates_new_when_missing(self):
+        mock_gen = MagicMock()
+        mock_gen.variables_metadata = {"var1": {"variable_id": "var1"}}
+        mock_gen.build_variable_catalog.return_value.to_dict.return_value = {"id": "var1"}
+        self.publisher.gh_publisher.github_automation.file_exists.return_value = False
+
+        file_dict = {}
+        self.publisher._update_variable_catalogs(mock_gen, file_dict, ["var1"])
+
+        mock_gen.build_variable_catalog.assert_called_once()
+        assert "variables/var1/catalog.json" in file_dict
+
+    def test_update_variable_catalogs_updates_existing(self):
+        mock_gen = MagicMock()
+        self.publisher.gh_publisher.github_automation.file_exists.return_value = True
+        self.publisher.gh_publisher.github_automation.local_clone_dir = "/tmp"
+        mock_gen.update_existing_variable_catalog.return_value = {"id": "var1"}
+
+        file_dict = {}
+        self.publisher._update_variable_catalogs(mock_gen, file_dict, ["var1"])
+
+        mock_gen.update_existing_variable_catalog.assert_called_once()
+        assert "variables/var1/catalog.json" in file_dict
+
+    # ------------------------------------------------------------------
+    # generate_workflow_experiment_records
+    # ------------------------------------------------------------------
+
+    def _setup_workflow_mocks(self):
+        """Patch all internals of generate_workflow_experiment_records."""
+        mock_rg = MagicMock()
+        mock_props = MagicMock()
+        mock_props.jupyter_kernel_info.to_dict.return_value = {}
+        mock_rg.build_record_properties.return_value = mock_props
+
+        mock_wf_record = MagicMock()
+        mock_wf_record.to_dict.return_value = {"id": "wf", "properties": {}}
+
+        mock_exp_record = MagicMock()
+        mock_exp_record.to_dict.return_value = {
+            "id": "wf",
+            "properties": {},
+            "jupyter_notebook_url": "url",
+            "collection_id": "col",
+        }
+        return mock_rg, mock_props, mock_wf_record, mock_exp_record
+
+    @patch("deep_code.tools.publish.WorkflowAsOgcRecord")
+    @patch("deep_code.tools.publish.LinksBuilder")
+    @patch("deep_code.tools.publish.OSCWorkflowOGCApiRecordGenerator")
+    def test_generate_workflow_records_mode_workflow(self, MockRG, MockLinks, MockWF):
+        mock_rg, mock_props, mock_wf_record, _ = self._setup_workflow_mocks()
+        MockRG.return_value = mock_rg
+        MockWF.return_value = mock_wf_record
+
+        self.publisher.workflow_config = {
+            "workflow_id": "my-workflow",
+            "properties": {"title": "My WF", "license": "CC-BY-4.0"},
+        }
+        with patch.object(self.publisher, "_update_base_catalog", return_value={}):
+            result = self.publisher.generate_workflow_experiment_records(
+                write_to_file=False, mode="workflow"
+            )
+
+        self.assertIn("workflows/my-workflow/record.json", result)
+        self.assertIn("workflows/catalog.json", result)
+        self.assertNotIn("experiments/catalog.json", result)
+
+    @patch("deep_code.tools.publish.ExperimentAsOgcRecord")
+    @patch("deep_code.tools.publish.WorkflowAsOgcRecord")
+    @patch("deep_code.tools.publish.LinksBuilder")
+    @patch("deep_code.tools.publish.OSCWorkflowOGCApiRecordGenerator")
+    def test_generate_workflow_records_mode_all(self, MockRG, MockLinks, MockWF, MockExp):
+        mock_rg, mock_props, mock_wf_record, mock_exp_record = self._setup_workflow_mocks()
+        MockRG.return_value = mock_rg
+        MockWF.return_value = mock_wf_record
+        MockExp.return_value = mock_exp_record
+
+        self.publisher.workflow_config = {
+            "workflow_id": "my-workflow",
+            "properties": {"title": "My WF", "license": "CC-BY-4.0"},
+        }
+        self.publisher.collection_id = "my-collection"
+        with patch.object(self.publisher, "_update_base_catalog", return_value={}):
+            result = self.publisher.generate_workflow_experiment_records(
+                write_to_file=False, mode="all"
+            )
+
+        self.assertIn("workflows/my-workflow/record.json", result)
+        self.assertIn("workflows/catalog.json", result)
+        self.assertIn("experiments/catalog.json", result)
+
+    @patch("deep_code.tools.publish.OSCWorkflowOGCApiRecordGenerator")
+    def test_generate_workflow_records_raises_when_workflow_id_missing(self, MockRG):
+        self.publisher.workflow_config = {
+            "properties": {"title": "My WF", "license": "CC-BY-4.0"},
+        }
+        with pytest.raises(ValueError, match="workflow_id is missing"):
+            self.publisher.generate_workflow_experiment_records(
+                write_to_file=False, mode="workflow"
+            )
+
+    @patch("deep_code.tools.publish.OSCWorkflowOGCApiRecordGenerator")
+    def test_generate_workflow_records_raises_when_license_missing(self, MockRG):
+        self.publisher.workflow_config = {
+            "workflow_id": "my-wf",
+            "properties": {"title": "My WF"},
+        }
+        with pytest.raises(ValueError, match="license is required"):
+            self.publisher.generate_workflow_experiment_records(
+                write_to_file=False, mode="workflow"
+            )
+
+    def test_generate_workflow_records_returns_empty_for_dataset_mode(self):
+        result = self.publisher.generate_workflow_experiment_records(
+            write_to_file=False, mode="dataset"
+        )
+        self.assertEqual(result, {})
+
 
 class TestParseGithubNotebookUrl:
     @pytest.mark.parametrize(
diff --git a/deep_code/tests/utils/test_dataset_stac_generator.py b/deep_code/tests/utils/test_dataset_stac_generator.py
@@ -607,3 +607,159 @@ def test_edge_cases(self):
             OscDatasetStacGenerator.format_string("too   many   spaces"),
             "Too Many Spaces",
         )
+
+
+class TestOscDatasetStacGeneratorExtra(unittest.TestCase):
+    """Additional tests to cover branches not exercised by TestOSCProductSTACGenerator."""
+
+    def _make_generator(self, mock_ds, collection_id="my-collection", **kwargs):
+        with patch("deep_code.utils.dataset_stac_generator.open_dataset", return_value=mock_ds):
+            return OscDatasetStacGenerator(
+                dataset_id="test.zarr",
+                collection_id=collection_id,
+                workflow_id="wf",
+                workflow_title="WF",
+                license_type="CC-BY-4.0",
+                **kwargs,
+            )
+
+    def _make_dataset(self, coord_type="lon_lat"):
+        import numpy as np
+        from datetime import datetime
+        if coord_type == "lon_lat":
+            coords = {
+                "lon": ("lon", np.linspace(-10, 10, 3)),
+                "lat": ("lat", np.linspace(-5, 5, 2)),
+                "time": ("time", [np.datetime64(datetime(2020, 1, 1), "ns")]),
+            }
+        elif coord_type == "longitude_latitude":
+            coords = {
+                "longitude": ("longitude", np.linspace(-10, 10, 3)),
+                "latitude": ("latitude", np.linspace(-5, 5, 2)),
+                "time": ("time", [np.datetime64(datetime(2020, 1, 1), "ns")]),
+            }
+        elif coord_type == "x_y":
+            coords = {
+                "x": ("x", np.linspace(0, 100, 3)),
+                "y": ("y", np.linspace(0, 50, 2)),
+                "time": ("time", [np.datetime64(datetime(2020, 1, 1), "ns")]),
+            }
+        else:
+            coords = {}
+        from xarray import Dataset
+        return Dataset(coords=coords)
+
+    @patch("deep_code.utils.dataset_stac_generator.open_dataset")
+    def test_collection_id_with_space_raises(self, mock_open_ds):
+        mock_open_ds.return_value = self._make_dataset()
+        with self.assertRaisesRegex(ValueError, "must not contain spaces"):
+            OscDatasetStacGenerator(
+                dataset_id="test.zarr",
+                collection_id="bad id",
+                workflow_id="wf",
+                workflow_title="WF",
+                license_type="CC-BY-4.0",
+            )
+
+    @patch("deep_code.utils.dataset_stac_generator.open_dataset")
+    def test_spatial_extent_longitude_latitude(self, mock_open_ds):
+        ds = self._make_dataset("longitude_latitude")
+        mock_open_ds.return_value = ds
+        gen = self._make_generator(ds)
+        extent = gen._get_spatial_extent()
+        self.assertAlmostEqual(extent.bboxes[0][0], -10.0)
+        self.assertAlmostEqual(extent.bboxes[0][1], -5.0)
+
+    @patch("deep_code.utils.dataset_stac_generator.open_dataset")
+    def test_spatial_extent_x_y(self, mock_open_ds):
+        ds = self._make_dataset("x_y")
+        mock_open_ds.return_value = ds
+        gen = self._make_generator(ds)
+        extent = gen._get_spatial_extent()
+        self.assertAlmostEqual(extent.bboxes[0][0], 0.0)
+
+    @patch("deep_code.utils.dataset_stac_generator.open_dataset")
+    def test_spatial_extent_unknown_coords_raises(self, mock_open_ds):
+        ds = self._make_dataset("none")
+        mock_open_ds.return_value = ds
+        gen = self._make_generator(ds)
+        with self.assertRaisesRegex(ValueError, "recognized spatial coordinates"):
+            gen._get_spatial_extent()
+
+    @patch("deep_code.utils.dataset_stac_generator.open_dataset")
+    def test_temporal_extent_no_time_raises(self, mock_open_ds):
+        ds = self._make_dataset("none")
+        mock_open_ds.return_value = ds
+        gen = self._make_generator(ds)
+        with self.assertRaisesRegex(ValueError, "time"):
+            gen._get_temporal_extent()
+
+    @patch("deep_code.utils.dataset_stac_generator.open_dataset")
+    def test_normalize_name_none_returns_none(self, mock_open_ds):
+        ds = self._make_dataset()
+        mock_open_ds.return_value = ds
+        self.assertIsNone(OscDatasetStacGenerator._normalize_name(None))
+
+    @patch("deep_code.utils.dataset_stac_generator.open_dataset")
+    def test_build_collection_with_cf_params(self, mock_open_ds):
+        ds = self._make_dataset()
+        mock_open_ds.return_value = ds
+        gen = self._make_generator(ds, cf_params=[{"name": "temperature", "units": "K"}])
+        collection = gen.build_dataset_stac_collection(mode="dataset")
+        self.assertEqual(collection.extra_fields.get("cf:parameter"), [{"name": "temperature", "units": "K"}])
+
+    @patch("deep_code.utils.dataset_stac_generator.open_dataset")
+    def test_build_collection_with_visualisation_link(self, mock_open_ds):
+        ds = self._make_dataset()
+        mock_open_ds.return_value = ds
+        gen = self._make_generator(ds, visualisation_link="https://viewer.example.com/")
+        collection = gen.build_dataset_stac_collection(mode="dataset")
+        vis_links = [lnk for lnk in collection.links if lnk.rel == "visualisation"]
+        self.assertEqual(len(vis_links), 1)
+        self.assertEqual(vis_links[0].target, "https://viewer.example.com/")
+        self.assertEqual(vis_links[0].title, "Dataset visualisation")
+
+    @patch("deep_code.utils.dataset_stac_generator.open_dataset")
+    def test_build_collection_mode_all_adds_experiment_link(self, mock_open_ds):
+        ds = self._make_dataset()
+        mock_open_ds.return_value = ds
+        gen = self._make_generator(ds)
+        collection = gen.build_dataset_stac_collection(mode="all")
+        exp_links = [lnk for lnk in collection.links if "experiments" in str(lnk.target)]
+        self.assertEqual(len(exp_links), 1)
+
+    @patch("deep_code.utils.dataset_stac_generator.open_dataset")
+    def test_s3_to_https(self, mock_open_ds):
+        self.assertEqual(
+            OscDatasetStacGenerator._s3_to_https("s3://my-bucket/path/to/file.json"),
+            "https://my-bucket.s3.amazonaws.com/path/to/file.json",
+        )
+
+    @patch("deep_code.utils.dataset_stac_generator.open_dataset")
+    def test_update_existing_variable_catalog(self, mock_open_ds):
+        import json
+        import os
+        import tempfile
+
+        ds = self._make_dataset()
+        mock_open_ds.return_value = ds
+        gen = self._make_generator(ds, osc_themes=["land"])
+
+        base = {
+            "type": "Catalog",
+            "id": "var1",
+            "stac_version": "1.0.0",
+            "description": "Variable catalog",
+            "links": [],
+        }
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as f:
+            json.dump(base, f)
+            tmp_path = f.name
+        try:
+            result = gen.update_existing_variable_catalog(tmp_path, "var1")
+        finally:
+            os.unlink(tmp_path)
+
+        rels = [lnk["rel"] for lnk in result["links"]]
+        self.assertIn("child", rels)
+        self.assertIn("related", rels)  # theme link
diff --git a/deep_code/tests/utils/test_helper.py b/deep_code/tests/utils/test_helper.py
@@ -10,7 +10,7 @@
 import xarray
 import xarray as xr
 
-from deep_code.utils.helper import open_dataset
+from deep_code.utils.helper import open_dataset, serialize
 
 
 def make_dummy_dataset():
@@ -156,3 +156,23 @@ def test_uses_provided_logger(self, mock_new_store, mock_get_logger):
         custom_logger.info.assert_any_call(
             "Successfully opened dataset 'test-id' with configuration: Public store"
         )
+
+
+class TestSerialize(unittest.TestCase):
+    def test_set_converted_to_list(self):
+        result = serialize({1, 2, 3})
+        self.assertIsInstance(result, list)
+        self.assertCountEqual(result, [1, 2, 3])
+
+    def test_object_with_dict_returns_dict(self):
+        class Obj:
+            def __init__(self):
+                self.x = 1
+                self.y = 2
+
+        result = serialize(Obj())
+        self.assertEqual(result, {"x": 1, "y": 2})
+
+    def test_unserializable_raises_type_error(self):
+        with self.assertRaises(TypeError):
+            serialize(42)
