deep-code 0.0.1.dev0__py3-none-any.whl

deep_code/__init__.py

@@ -0,0 +1,24 @@
+# The MIT License (MIT)
+# Copyright (c) 2024 by DeepESDL and Brockmann Consult GmbH
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the "Software"),
+# to deal in the Software without restriction, including without limitation
+# the rights to use, copy, modify, merge, publish, distribute, sublicense,
+# and/or sell copies of the Software, and to permit persons to whom the
+# Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NON INFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+# DEALINGS IN THE SOFTWARE.
+
+from .version import version
+
+__version__ = version

deep_code/cli/__init__.py

@@ -0,0 +1,3 @@
+# Copyright (c) 2025 by Brockmann Consult GmbH
+# Permissions are hereby granted under the terms of the MIT License:
+# https://opensource.org/licenses/MIT.

deep_code/cli/main.py

@@ -0,0 +1,22 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2025 by Brockmann Consult GmbH
+# Permissions are hereby granted under the terms of the MIT License:
+# https://opensource.org/licenses/MIT.
+
+import click
+
+from deep_code.cli.publish import publish_dataset, publish_workflow
+
+
+@click.group()
+def main():
+    """Deep Code CLI."""
+    pass
+
+
+main.add_command(publish_dataset)
+main.add_command(publish_workflow)
+
+if __name__ == "__main__":
+    main()

deep_code/cli/publish.py

@@ -0,0 +1,26 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2025 by Brockmann Consult GmbH
+# Permissions are hereby granted under the terms of the MIT License:
+# https://opensource.org/licenses/MIT.
+
+import click
+
+from deep_code.tools.publish import DatasetPublisher, WorkflowPublisher
+
+
+@click.command(name="publish-dataset")
+@click.argument("dataset_config", type=click.Path(exists=True))
+def publish_dataset(dataset_config):
+    """Request publishing a dataset to the open science catalogue.
+    """
+    publisher = DatasetPublisher()
+    publisher.publish_dataset(dataset_config_path=dataset_config)
+
+
+@click.command(name="publish-workflow")
+@click.argument("workflow_metadata", type=click.Path(exists=True))
+def publish_workflow(workflow_metadata):
+
+    workflow_publisher = WorkflowPublisher()
+    workflow_publisher.publish_workflow(workflow_config_path=workflow_metadata)

deep_code/constants.py

@@ -0,0 +1,16 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2024 by Brockmann Consult GmbH
+# Permissions are hereby granted under the terms of the MIT License:
+# https://opensource.org/licenses/MIT.
+
+OSC_SCHEMA_URI = "https://stac-extensions.github.io/osc/v1.0.0-rc.3/schema.json"
+CF_SCHEMA_URI = "https://stac-extensions.github.io/cf/v0.2.0/schema.json"
+OSC_REPO_OWNER = "ESA-EarthCODE"
+OSC_REPO_NAME = "open-science-catalog-metadata-testing"
+OSC_BRANCH_NAME = "add-new-collection"
+DEFAULT_THEME_SCHEME = (
+    "https://gcmd.earthdata.nasa.gov/kms/concepts/concept_scheme/sciencekeywords"
+)
+OGC_API_RECORD_SPEC = "http://www.opengis.net/spec/ogcapi-records-1/1.0/req/record-core"
+WF_BRANCH_NAME = "add-new-workflow-from-deepesdl"

deep_code/tests/tools/__init__.py

@@ -0,0 +1,3 @@
+# Copyright (c) 2025 by Brockmann Consult GmbH
+# Permissions are hereby granted under the terms of the MIT License:
+# https://opensource.org/licenses/MIT.

deep_code/tests/tools/test_publish.py

@@ -0,0 +1,120 @@
+from unittest.mock import MagicMock, mock_open, patch
+
+import pytest
+
+from deep_code.tools.publish import DatasetPublisher
+
+
+class TestDatasetPublisher:
+    @patch("deep_code.tools.publish.fsspec.open")
+    def test_init_missing_credentials(self, mock_fsspec_open):
+        mock_fsspec_open.return_value.__enter__.return_value = mock_open(
+            read_data="{}"
+        )()
+
+        with pytest.raises(
+            ValueError, match="GitHub credentials are missing in the `.gitaccess` file."
+        ):
+            DatasetPublisher()
+
+    @patch("deep_code.tools.publish.fsspec.open")
+    def test_publish_dataset_missing_ids(self, mock_fsspec_open):
+        git_yaml_content = """
+        github-username: test-user
+        github-token: test-token
+        """
+        dataset_yaml_content = """
+        collection-id: test-collection
+        """
+        mock_fsspec_open.side_effect = [
+            mock_open(read_data=git_yaml_content)(),
+            mock_open(read_data=dataset_yaml_content)(),
+        ]
+
+        publisher = DatasetPublisher()
+
+        with pytest.raises(
+            ValueError, match="Dataset ID or Collection ID missing in the config."
+        ):
+            publisher.publish_dataset("/path/to/dataset-config.yaml")
+
+    @patch("deep_code.utils.github_automation.os.chdir")
+    @patch("deep_code.utils.github_automation.subprocess.run")
+    @patch("deep_code.utils.github_automation.os.path.expanduser", return_value="/tmp")
+    @patch("requests.post")
+    @patch("deep_code.utils.github_automation.GitHubAutomation")
+    @patch("deep_code.tools.publish.fsspec.open")
+    def test_publish_dataset_success(
+        self,
+        mock_fsspec_open,
+        mock_github_automation,
+        mock_requests_post,
+        mock_expanduser,
+        mock_subprocess_run,
+        mock_chdir,
+    ):
+        #  Mock the YAML reads
+        git_yaml_content = """
+             github-username: test-user
+             github-token: test-token
+             """
+        dataset_yaml_content = """
+             dataset_id: test-dataset
+             collection_id: test-collection
+             documentation_link: http://example.com/doc
+             access_link: http://example.com/access
+             dataset_status: ongoing
+             dataset_region: Global
+             osc_theme: ["climate"]
+             cf_parameter: []
+             """
+        mock_fsspec_open.side_effect = [
+            mock_open(read_data=git_yaml_content)(),
+            mock_open(read_data=dataset_yaml_content)(),
+        ]
+
+        # Mock GitHubAutomation methods
+        mock_git = mock_github_automation.return_value
+        mock_git.fork_repository.return_value = None
+        mock_git.clone_repository.return_value = None
+        mock_git.create_branch.return_value = None
+        mock_git.add_file.return_value = None
+        mock_git.commit_and_push.return_value = None
+        mock_git.create_pull_request.return_value = "http://example.com/pr"
+        mock_git.clean_up.return_value = None
+
+        # Mock subprocess.run & os.chdir
+        mock_subprocess_run.return_value = None
+        mock_chdir.return_value = None
+
+        # Mock STAC generator
+        mock_collection = MagicMock()
+        mock_collection.to_dict.return_value = {
+            "type": "Collection",
+            "id": "test-collection",
+            "description": "A test STAC collection",
+            "extent": {
+                "spatial": {"bbox": [[-180.0, -90.0, 180.0, 90.0]]},
+                "temporal": {"interval": [["2023-01-01T00:00:00Z", None]]},
+            },
+            "links": [],
+            "stac_version": "1.0.0",
+        }
+        with patch("deep_code.tools.publish.OscDatasetStacGenerator") as mock_generator:
+            mock_generator.return_value.build_dataset_stac_collection.return_value = (
+                mock_collection
+            )
+
+            # Instantiate & publish
+            publisher = DatasetPublisher()
+            publisher.publish_dataset("/fake/path/to/dataset-config.yaml")
+
+        # Assert that we called git clone with /tmp/temp_repo
+        # Because expanduser("~") is now patched to /tmp, the actual path is /tmp/temp_repo
+        auth_url = "https://test-user:test-token@github.com/test-user/open-science-catalog-metadata-testing.git"
+        mock_subprocess_run.assert_any_call(
+            ["git", "clone", auth_url, "/tmp/temp_repo"], check=True
+        )
+
+        # Also confirm we changed directories to /tmp/temp_repo
+        mock_chdir.assert_any_call("/tmp/temp_repo")

deep_code/tests/utils/__init__.py

@@ -0,0 +1,3 @@
+# Copyright (c) 2025 by Brockmann Consult GmbH
+# Permissions are hereby granted under the terms of the MIT License:
+# https://opensource.org/licenses/MIT.

deep_code/tests/utils/test_dataset_stac_generator.py

@@ -0,0 +1,219 @@
+import os
+import unittest
+from datetime import datetime
+from unittest.mock import MagicMock, patch
+
+import numpy as np
+from pystac import Collection
+from xarray import Dataset
+
+from deep_code.utils.dataset_stac_generator import OscDatasetStacGenerator
+
+
+class TestOSCProductSTACGenerator(unittest.TestCase):
+    @patch("deep_code.utils.dataset_stac_generator.new_data_store")
+    def setUp(self, mock_data_store):
+        """Set up a mock dataset and generator."""
+        self.mock_dataset = Dataset(
+            coords={
+                "lon": ("lon", np.linspace(-180, 180, 10)),
+                "lat": ("lat", np.linspace(-90, 90, 5)),
+                "time": (
+                    "time",
+                    [
+                        np.datetime64(datetime(2023, 1, 1), "ns"),
+                        np.datetime64(datetime(2023, 1, 2), "ns"),
+                    ],
+                ),
+            },
+            attrs={"description": "Mock dataset for testing.", "title": "Mock Dataset"},
+            data_vars={
+                "var1": (
+                    ("time", "lat", "lon"),
+                    np.random.rand(2, 5, 10),
+                    {
+                        "description": "dummy",
+                        "standard_name": "var1",
+                        "gcmd_keyword_url": "https://dummy",
+                    },
+                ),
+                "var2": (
+                    ("time", "lat", "lon"),
+                    np.random.rand(2, 5, 10),
+                    {
+                        "description": "dummy",
+                        "standard_name": "var2",
+                        "gcmd_keyword_url": "https://dummy",
+                    },
+                ),
+            },
+        )
+        mock_store = MagicMock()
+        mock_store.open_data.return_value = self.mock_dataset
+        mock_data_store.return_value = mock_store
+
+        self.generator = OscDatasetStacGenerator(
+            dataset_id="mock-dataset-id",
+            collection_id="mock-collection-id",
+            access_link="s3://mock-bucket/mock-dataset",
+            documentation_link="https://example.com/docs",
+            osc_status="ongoing",
+            osc_region="Global",
+            osc_themes=["climate", "environment"],
+        )
+
+    def test_open_dataset(self):
+        """Test if the dataset is opened correctly."""
+        self.assertIsInstance(self.generator.dataset, Dataset)
+        self.assertIn("lon", self.generator.dataset.coords)
+        self.assertIn("lat", self.generator.dataset.coords)
+        self.assertIn("time", self.generator.dataset.coords)
+
+    def test_get_spatial_extent(self):
+        """Test spatial extent extraction."""
+        extent = self.generator._get_spatial_extent()
+        self.assertEqual(extent.bboxes[0], [-180.0, -90.0, 180.0, 90.0])
+
+    def test_get_temporal_extent(self):
+        """Test temporal extent extraction."""
+        extent = self.generator._get_temporal_extent()
+        expected_intervals = [datetime(2023, 1, 1, 0, 0), datetime(2023, 1, 2, 0, 0)]
+        self.assertEqual(extent.intervals[0], expected_intervals)
+
+    def test_get_variables(self):
+        """Test variable extraction."""
+        variables = self.generator.get_variable_ids()
+        self.assertEqual(variables, ["var1", "var2"])
+
+    def test_get_general_metadata(self):
+        """Test general metadata extraction."""
+        metadata = self.generator._get_general_metadata()
+        self.assertEqual(metadata["description"], "Mock dataset for testing.")
+
+    @patch("pystac.Collection.add_link")
+    @patch("pystac.Collection.set_self_href")
+    def test_build_stac_collection(self, mock_set_self_href, mock_add_link):
+        """Test STAC collection creation."""
+        collection = self.generator.build_dataset_stac_collection()
+        self.assertIsInstance(collection, Collection)
+        self.assertEqual(collection.id, "mock-collection-id")
+        self.assertEqual(collection.description, "Mock dataset for testing.")
+        self.assertEqual(
+            collection.extent.spatial.bboxes[0], [-180.0, -90.0, 180.0, 90.0]
+        )
+        self.assertEqual(
+            collection.extent.temporal.intervals[0],
+            [datetime(2023, 1, 1, 0, 0), datetime(2023, 1, 2, 0, 0)],
+        )
+        mock_set_self_href.assert_called_once()
+        mock_add_link.assert_called()
+
+    def test_invalid_spatial_extent(self):
+        """Test spatial extent extraction with missing coordinates."""
+        self.generator.dataset = Dataset(coords={"x": [], "y": []})
+        with self.assertRaises(ValueError):
+            self.generator._get_spatial_extent()
+
+    def test_invalid_temporal_extent(self):
+        """Test temporal extent extraction with missing time."""
+        self.generator.dataset = Dataset(coords={})
+        with self.assertRaises(ValueError):
+            self.generator._get_temporal_extent()
+
+    @patch("deep_code.utils.dataset_stac_generator.new_data_store")
+    @patch("deep_code.utils.dataset_stac_generator.logging.getLogger")
+    def test_open_dataset_success_public_store(self, mock_logger, mock_new_data_store):
+        """Test dataset opening with the public store configuration."""
+        # Create a mock store and mock its `open_data` method
+        mock_store = MagicMock()
+        mock_new_data_store.return_value = mock_store
+        mock_store.open_data.return_value = self.mock_dataset
+
+        # Instantiate the generator (this will implicitly call _open_dataset)
+        generator = OscDatasetStacGenerator("mock-dataset-id", "mock-collection-id")
+
+        # Validate that the dataset is assigned correctly
+        self.assertEqual(generator.dataset, "mock_dataset")
+
+        # Validate that `new_data_store` was called once with the correct parameters
+        mock_new_data_store.assert_called_once_with(
+            "s3", root="deep-esdl-public", storage_options={"anon": True}
+        )
+
+        # Ensure `open_data` was called once on the returned store
+        mock_store.open_data.assert_called_once_with("mock-dataset-id")
+
+        # Validate logging behavior
+        mock_logger().info.assert_any_call(
+            "Attempting to open dataset with configuration: Public store"
+        )
+        mock_logger().info.assert_any_call(
+            "Successfully opened dataset with configuration: Public store"
+        )
+
+    @patch("deep_code.utils.dataset_stac_generator.new_data_store")
+    @patch("deep_code.utils.dataset_stac_generator.logging.getLogger")
+    def test_open_dataset_success_authenticated_store(
+        self, mock_logger, mock_new_data_store
+    ):
+        """Test dataset opening with the authenticated store configuration."""
+        # Simulate public store failure
+        mock_store = MagicMock()
+        mock_new_data_store.side_effect = [
+            Exception("Public store failure"),
+            # First call (public store) raises an exception
+            mock_store,
+            # Second call (authenticated store) returns a mock store
+        ]
+        mock_store.open_data.return_value = self.mock_dataset
+
+        os.environ["S3_USER_STORAGE_BUCKET"] = "mock-bucket"
+        os.environ["S3_USER_STORAGE_KEY"] = "mock-key"
+        os.environ["S3_USER_STORAGE_SECRET"] = "mock-secret"
+
+        generator = OscDatasetStacGenerator("mock-dataset-id", "mock-collection-id")
+
+        # Validate that the dataset was successfully opened with the authenticated store
+        self.assertEqual(generator.dataset, "mock_dataset")
+        self.assertEqual(mock_new_data_store.call_count, 2)
+
+        # Validate calls to `new_data_store`
+        mock_new_data_store.assert_any_call(
+            "s3", root="deep-esdl-public", storage_options={"anon": True}
+        )
+        mock_new_data_store.assert_any_call(
+            "s3",
+            root="mock-bucket",
+            storage_options={"anon": False, "key": "mock-key", "secret": "mock-secret"},
+        )
+
+        # Validate logging calls
+        mock_logger().info.assert_any_call(
+            "Attempting to open dataset with configuration: Public store"
+        )
+        mock_logger().info.assert_any_call(
+            "Attempting to open dataset with configuration: Authenticated store"
+        )
+        mock_logger().info.assert_any_call(
+            "Successfully opened dataset with configuration: Authenticated store"
+        )
+
+    @patch("deep_code.utils.dataset_stac_generator.new_data_store")
+    @patch("deep_code.utils.dataset_stac_generator.logging.getLogger")
+    def test_open_dataset_failure(self, mock_logger, mock_new_data_store):
+        """Test dataset opening failure with all configurations."""
+        # Simulate all store failures
+        mock_new_data_store.side_effect = Exception("Store failure")
+        os.environ["S3_USER_STORAGE_BUCKET"] = "mock-bucket"
+        os.environ["S3_USER_STORAGE_KEY"] = "mock-key"
+        os.environ["S3_USER_STORAGE_SECRET"] = "mock-secret"
+
+        with self.assertRaises(ValueError) as context:
+            OscDatasetStacGenerator("mock-dataset-id", "mock-collection-id")
+
+        self.assertIn(
+            "Failed to open Zarr dataset with ID mock-dataset-id",
+            str(context.exception),
+        )
+        self.assertIn("Public store, Authenticated store", str(context.exception))
+        self.assertEqual(mock_new_data_store.call_count, 2)

deep_code/tests/utils/test_github_automation.py

@@ -0,0 +1,120 @@
+import json
+import unittest
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+from deep_code.utils.github_automation import GitHubAutomation
+
+
+class TestGitHubAutomation(unittest.TestCase):
+    def setUp(self):
+        self.github = GitHubAutomation(
+            username="test-user",
+            token="test-token",
+            repo_owner="test-owner",
+            repo_name="test-repo",
+        )
+
+    @patch("requests.post")
+    def test_fork_repository(self, mock_post):
+        """Test the fork_repository method."""
+        mock_response = MagicMock()
+        mock_response.raise_for_status.return_value = None
+        mock_post.return_value = mock_response
+
+        self.github.fork_repository()
+
+        mock_post.assert_called_once_with(
+            "https://api.github.com/repos/test-owner/test-repo/forks",
+            headers={"Authorization": "token test-token"},
+        )
+
+    @patch("subprocess.run")
+    @patch("os.chdir")
+    def test_clone_repository(self, mock_chdir, mock_run):
+        """Test the clone_repository method."""
+        self.github.clone_repository()
+
+        mock_run.assert_called_once_with(
+            ["git", "clone", self.github.fork_repo_url, self.github.local_clone_dir],
+            check=True,
+        )
+        mock_chdir.assert_called_once_with(self.github.local_clone_dir)
+
+    @patch("subprocess.run")
+    def test_create_branch(self, mock_run):
+        """Test the create_branch method."""
+        branch_name = "test-branch"
+        self.github.create_branch(branch_name)
+
+        mock_run.assert_called_once_with(
+            ["git", "checkout", "-b", branch_name], check=True
+        )
+
+    @patch("subprocess.run")
+    @patch("builtins.open", new_callable=unittest.mock.mock_open)
+    @patch("pathlib.Path.mkdir")
+    def test_add_file(self, mock_mkdir, mock_open, mock_run):
+        """Test the add_file method."""
+        file_path = "test-dir/test-file.json"
+        content = {"key": "value"}
+
+        self.github.add_file(file_path, content)
+
+        mock_mkdir.assert_called_once_with(parents=True, exist_ok=True)
+        mock_open.assert_called_once_with(
+            Path(self.github.local_clone_dir) / file_path, "w"
+        )
+        mock_open().write.assert_called_once_with(json.dumps(content, indent=2))
+        mock_run.assert_called_once_with(
+            ["git", "add", str(Path(self.github.local_clone_dir) / file_path)],
+            check=True,
+        )
+
+    @patch("subprocess.run")
+    def test_commit_and_push(self, mock_run):
+        """Test the commit_and_push method."""
+        branch_name = "test-branch"
+        commit_message = "Test commit message"
+
+        self.github.commit_and_push(branch_name, commit_message)
+
+        mock_run.assert_any_call(["git", "commit", "-m", commit_message], check=True)
+        mock_run.assert_any_call(
+            ["git", "push", "-u", "origin", branch_name], check=True
+        )
+
+    @patch("requests.post")
+    def test_create_pull_request(self, mock_post):
+        """Test the create_pull_request method."""
+        branch_name = "test-branch"
+        pr_title = "Test PR"
+        pr_body = "This is a test PR"
+        base_branch = "main"
+
+        mock_response = MagicMock()
+        mock_response.json.return_value = {"html_url": "https://github.com/test-pr"}
+        mock_response.raise_for_status.return_value = None
+        mock_post.return_value = mock_response
+
+        self.github.create_pull_request(branch_name, pr_title, pr_body, base_branch)
+
+        mock_post.assert_called_once_with(
+            "https://api.github.com/repos/test-owner/test-repo/pulls",
+            headers={"Authorization": "token test-token"},
+            json={
+                "title": pr_title,
+                "head": f"test-user:{branch_name}",
+                "base": base_branch,
+                "body": pr_body,
+            },
+        )
+
+    @patch("subprocess.run")
+    @patch("os.chdir")
+    def test_clean_up(self, mock_chdir, mock_run):
+        """Test the clean_up method."""
+        self.github.clean_up()
+
+        mock_chdir.assert_called_once_with("..")
+        mock_run.assert_called_once_with(["rm", "-rf", self.github.local_clone_dir])

deep_code/tests/utils/test_ogc_api_record.py

@@ -0,0 +1,113 @@
+import unittest
+
+from deep_code.constants import OGC_API_RECORD_SPEC
+from deep_code.utils.ogc_api_record import (
+    Contact,
+    JupyterKernelInfo,
+    OgcRecord,
+    RecordProperties,
+    Theme,
+    ThemeConcept,
+)
+
+
+class TestClasses(unittest.TestCase):
+    def test_contact_initialization(self):
+        contact = Contact(
+            name="Person-X",
+            organization="Organization X",
+            position="Researcher",
+            links=[{"url": "http://example.com", "type": "website"}],
+            contactInstructions="Contact via email",
+            roles=["developer", "reviewer"],
+        )
+
+        self.assertEqual(contact.name, "Person-X")
+        self.assertEqual(contact.organization, "Organization X")
+        self.assertEqual(contact.position, "Researcher")
+        self.assertEqual(len(contact.links), 1)
+        self.assertEqual(contact.contactInstructions, "Contact via email")
+        self.assertIn("developer", contact.roles)
+
+    def test_theme_concept_initialization(self):
+        theme_concept = ThemeConcept(id="concept1")
+        self.assertEqual(theme_concept.id, "concept1")
+
+    def test_theme_initialization(self):
+        theme_concepts = [ThemeConcept(id="concept1"), ThemeConcept(id="concept2")]
+        theme = Theme(concepts=theme_concepts, scheme="http://example.com/scheme")
+
+        self.assertEqual(len(theme.concepts), 2)
+        self.assertEqual(theme.scheme, "http://example.com/scheme")
+
+    def test_jupyter_kernel_info_initialization(self):
+        kernel_info = JupyterKernelInfo(
+            name="Python", python_version=3.9, env_file="env.yml"
+        )
+
+        self.assertEqual(kernel_info.name, "Python")
+        self.assertEqual(kernel_info.python_version, 3.9)
+        self.assertEqual(kernel_info.env_file, "env.yml")
+
+    def test_record_properties_initialization(self):
+        kernel_info = JupyterKernelInfo(
+            name="Python", python_version=3.9, env_file="env.yml"
+        )
+        contacts = [Contact(name="Jane Doe", organization="Org Y")]
+        themes = [Theme(concepts=[ThemeConcept(id="concept1")], scheme="scheme1")]
+
+        record_properties = RecordProperties(
+            created="2025-01-01",
+            type="dataset",
+            title="Sample Dataset",
+            description="A sample dataset",
+            jupyter_kernel_info=kernel_info,
+            updated="2025-01-02",
+            contacts=contacts,
+            themes=themes,
+            keywords=["sample", "test"],
+            formats=[{"format": "JSON"}],
+            license="CC-BY",
+        )
+
+        self.assertEqual(record_properties.created, "2025-01-01")
+        self.assertEqual(record_properties.updated, "2025-01-02")
+        self.assertEqual(record_properties.type, "dataset")
+        self.assertEqual(record_properties.title, "Sample Dataset")
+        self.assertEqual(record_properties.description, "A sample dataset")
+        self.assertEqual(record_properties.jupyter_kernel_info.name, "Python")
+        self.assertEqual(len(record_properties.contacts), 1)
+        self.assertEqual(len(record_properties.themes), 1)
+        self.assertIn("sample", record_properties.keywords)
+        self.assertEqual(record_properties.license, "CC-BY")
+
+    def test_ogc_record_initialization(self):
+        kernel_info = JupyterKernelInfo(
+            name="Python", python_version=3.9, env_file="env.yml"
+        )
+        properties = RecordProperties(
+            created="2025-01-01",
+            type="dataset",
+            title="Sample Dataset",
+            description="A sample dataset",
+            jupyter_kernel_info=kernel_info,
+        )
+
+        ogc_record = OgcRecord(
+            id="record1",
+            type="Feature",
+            time={"start": "2025-01-01T00:00:00Z", "end": "2025-01-02T00:00:00Z"},
+            properties=properties,
+            links=[{"href": "http://example.com", "rel": "self"}],
+            linkTemplates=[{"template": "http://example.com/{id}"}],
+        )
+
+        self.assertEqual(ogc_record.id, "record1")
+        self.assertEqual(ogc_record.type, "Feature")
+        self.assertEqual(ogc_record.time["start"], "2025-01-01T00:00:00Z")
+        self.assertEqual(ogc_record.properties.title, "Sample Dataset")
+        self.assertEqual(len(ogc_record.links), 1)
+        self.assertEqual(
+            ogc_record.linkTemplates[0]["template"], "http://example.com/{id}"
+        )
+        self.assertEqual(ogc_record.conformsTo[0], OGC_API_RECORD_SPEC)