deep-code 0.0.1__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,21 @@
+#!/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
+
+
+@click.group()
+def main():
+    """Deep Code CLI."""
+    pass
+
+
+main.add_command(publish)
+
+if __name__ == "__main__":
+    main()

deep_code/cli/publish.py

@@ -0,0 +1,21 @@
+#!/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 Publisher
+
+
+@click.command(name="publish")
+@click.argument("dataset_config", type=click.Path(exists=True))
+@click.argument("workflow_config", type=click.Path(exists=True))
+def publish(dataset_config, workflow_config):
+    """Request publishing a dataset to the open science catalogue.
+    """
+    publisher = Publisher(
+        dataset_config_path=dataset_config, workflow_config_path=workflow_config
+    )
+    publisher.publish_all()

deep_code/constants.py

@@ -0,0 +1,31 @@
+#!/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/schema.json"
+CF_SCHEMA_URI = "https://stac-extensions.github.io/cf/v0.2.0/schema.json"
+THEMES_SCHEMA_URI = "https://stac-extensions.github.io/themes/v1.0.0/schema.json"
+OSC_THEME_SCHEME = "https://github.com/stac-extensions/osc#theme"
+OSC_REPO_OWNER = "ESA-EarthCODE"
+OSC_REPO_NAME = "open-science-catalog-metadata"
+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"
+VARIABLE_BASE_CATALOG_SELF_HREF = "https://esa-earthcode.github.io/open-science-catalog-metadata/variables/catalog.json"
+PRODUCT_BASE_CATALOG_SELF_HREF = "https://esa-earthcode.github.io/open-science-catalog-metadata/products/catalog.json"
+DEEPESDL_COLLECTION_SELF_HREF = (
+    "https://esa-earthcode.github.io/open-science-catalog-metadata/projects/deepesdl"
+    "/collection.json"
+)
+BASE_URL_OSC = "https://esa-earthcode.github.io/open-science-catalog-metadata"
+EXPERIMENT_BASE_CATALOG_SELF_HREF = "https://esa-earthcode.github.io/open-science-catalog-metadata/experiments/catalog.json"
+WORKFLOW_BASE_CATALOG_SELF_HREF = (
+    "https://esa-earthcode.github.io/open-science-catalog-metadata/workflows/catalog"
+    ".json"
+)
+PROJECT_COLLECTION_NAME = "deep-earth-system-data-lab"

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,108 @@
+import unittest
+from unittest.mock import patch, mock_open, MagicMock
+import json
+import yaml
+from pathlib import Path
+import tempfile
+from pystac import Catalog
+
+from deep_code.tools.publish import Publisher
+
+
+class TestPublisher(unittest.TestCase):
+    @patch("fsspec.open")
+    @patch("deep_code.tools.publish.GitHubPublisher")
+    def setUp(self, mock_github_publisher, mock_fsspec_open):
+        # Mock GitHubPublisher to avoid reading .gitaccess
+        self.mock_github_publisher_instance = MagicMock()
+        mock_github_publisher.return_value = self.mock_github_publisher_instance
+
+        # Mock dataset and workflow config files
+        self.dataset_config = {
+            "collection_id": "test-collection",
+            "dataset_id": "test-dataset",
+        }
+        self.workflow_config = {
+            "properties": {"title": "Test Workflow"},
+            "workflow_id": "test-workflow",
+        }
+
+        # Mock fsspec.open for config files
+        self.mock_fsspec_open = mock_fsspec_open
+        self.mock_fsspec_open.side_effect = [
+            mock_open(read_data=yaml.dump(self.dataset_config)).return_value,
+            mock_open(read_data=yaml.dump(self.workflow_config)).return_value,
+        ]
+
+        # Initialize Publisher
+        self.publisher = Publisher(
+            dataset_config_path="test-dataset-config.yaml",
+            workflow_config_path="test-workflow-config.yaml",
+        )
+
+    def test_normalize_name(self):
+        self.assertEqual(Publisher._normalize_name("Test Name"), "test-name")
+        self.assertEqual(Publisher._normalize_name("Test   Name"), "test---name")
+        self.assertIsNone(Publisher._normalize_name(""))
+        self.assertIsNone(Publisher._normalize_name(None))
+
+    def test_write_to_file(self):
+        # Create a temporary file
+        with tempfile.NamedTemporaryFile(delete=False) as temp_file:
+            file_path = temp_file.name
+
+        # Test data
+        data = {"key": "value"}
+
+        # Call the method
+        Publisher._write_to_file(file_path, data)
+
+        # Read the file and verify its content
+        with open(file_path, "r") as f:
+            content = json.load(f)
+            self.assertEqual(content, data)
+
+        # Clean up
+        Path(file_path).unlink()
+
+    def test_update_base_catalog(self):
+        # Create a mock Catalog
+        catalog = Catalog(id="test-catalog", description="Test Catalog")
+
+        # Mock file path and item ID
+        catalog_path = "test-catalog.json"
+        item_id = "test-item"
+        self_href = "https://example.com/catalog.json"
+
+        self.publisher.workflow_title = "Test Workflow"
+
+        # Mock the Catalog.from_file method
+        with patch("pystac.Catalog.from_file", return_value=catalog):
+            updated_catalog = self.publisher._update_base_catalog(
+                catalog_path, item_id, self_href
+            )
+
+        # Assertions
+        self.assertEqual(updated_catalog.get_self_href(), self_href)
+        self.assertIsInstance(updated_catalog, Catalog)
+
+    def test_read_config_files(self):
+        # Mock dataset and workflow config files
+        dataset_config = {
+            "collection_id": "test-collection",
+            "dataset_id": "test-dataset",
+        }
+        workflow_config = {
+            "properties": {"title": "Test Workflow"},
+            "workflow_id": "test-workflow",
+        }
+
+        # Mock fsspec.open for config files
+        self.mock_fsspec_open.side_effect = [
+            mock_open(read_data=yaml.dump(dataset_config)).return_value,
+            mock_open(read_data=yaml.dump(workflow_config)).return_value,
+        ]
+
+        # Assertions
+        self.assertEqual(self.publisher.dataset_config, dataset_config)
+        self.assertEqual(self.publisher.workflow_config, workflow_config)

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,277 @@
+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)
+
+
+class TestFormatString(unittest.TestCase):
+    def test_single_word(self):
+        self.assertEqual(
+            OscDatasetStacGenerator.format_string("temperature"), "Temperature"
+        )
+        self.assertEqual(OscDatasetStacGenerator.format_string("temp"), "Temp")
+        self.assertEqual(OscDatasetStacGenerator.format_string("hello"), "Hello")
+
+    def test_multiple_words_with_spaces(self):
+        self.assertEqual(
+            OscDatasetStacGenerator.format_string("surface temp"), "Surface Temp"
+        )
+        self.assertEqual(
+            OscDatasetStacGenerator.format_string("this is a test"), "This Is A Test"
+        )
+
+    def test_multiple_words_with_underscores(self):
+        self.assertEqual(
+            OscDatasetStacGenerator.format_string("surface_temp"), "Surface Temp"
+        )
+        self.assertEqual(
+            OscDatasetStacGenerator.format_string("this_is_a_test"), "This Is A Test"
+        )
+
+    def test_mixed_spaces_and_underscores(self):
+        self.assertEqual(
+            OscDatasetStacGenerator.format_string("surface_temp and_more"),
+            "Surface Temp And More",
+        )
+        self.assertEqual(
+            OscDatasetStacGenerator.format_string(
+                "mixed_case_with_underscores_and spaces"
+            ),
+            "Mixed Case With Underscores And Spaces",
+        )
+
+    def test_edge_cases(self):
+        # Empty string
+        self.assertEqual(OscDatasetStacGenerator.format_string(""), "")
+        # Single word with trailing underscore
+        self.assertEqual(
+            OscDatasetStacGenerator.format_string("temperature_"), "Temperature"
+        )
+        # Single word with leading underscore
+        self.assertEqual(OscDatasetStacGenerator.format_string("_temp"), "Temp")
+        # Single word with leading/trailing spaces
+        self.assertEqual(OscDatasetStacGenerator.format_string("  hello  "), "Hello")
+        # Multiple spaces or underscores
+        self.assertEqual(
+            OscDatasetStacGenerator.format_string("too___many___underscores"),
+            "Too Many Underscores",
+        )
+        self.assertEqual(
+            OscDatasetStacGenerator.format_string("too   many   spaces"),
+            "Too Many Spaces",
+        )

deep_code/tests/utils/test_github_automation.py

@@ -0,0 +1,171 @@
+import logging
+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):
+        # Set up test data
+        self.username = "testuser"
+        self.token = "testtoken"
+        self.repo_owner = "testowner"
+        self.repo_name = "testrepo"
+        self.github_automation = GitHubAutomation(
+            self.username, self.token, self.repo_owner, self.repo_name
+        )
+        logging.disable(logging.CRITICAL)  # Disable logging during tests
+
+    def tearDown(self):
+        logging.disable(logging.NOTSET)  # Re-enable logging after tests
+
+    @patch("requests.post")
+    def test_fork_repository(self, mock_post):
+        # Mock the response from GitHub API
+        mock_response = MagicMock()
+        mock_response.raise_for_status.return_value = None
+        mock_post.return_value = mock_response
+
+        # Call the method
+        self.github_automation.fork_repository()
+
+        # Assertions
+        mock_post.assert_called_once_with(
+            f"https://api.github.com/repos/{self.repo_owner}/{self.repo_name}/forks",
+            headers={"Authorization": f"token {self.token}"},
+        )
+
+    @patch("subprocess.run")
+    def test_clone_repository_new(self, mock_run):
+        # Mock the subprocess.run method
+        mock_run.return_value = MagicMock()
+
+        # Mock os.path.exists to return False (directory does not exist)
+        with patch("os.path.exists", return_value=False):
+            self.github_automation.clone_sync_repository()
+
+        # Assertions
+        mock_run.assert_called_once_with(
+            [
+                "git",
+                "clone",
+                f"https://{self.username}:{self.token}@github.com/{self.username}/{self.repo_name}.git",
+                self.github_automation.local_clone_dir,
+            ],
+            check=True,
+        )
+
+    @patch("subprocess.run")
+    def test_clone_repository_existing(self, mock_run):
+        # Mock the subprocess.run method
+        mock_run.return_value = MagicMock()
+
+        # Mock os.path.exists to return True (directory exists)
+        with patch("os.path.exists", return_value=True):
+            with patch("os.chdir"):
+                self.github_automation.clone_sync_repository()
+
+        # Assertions
+        mock_run.assert_called_once_with(["git", "pull"], check=True)
+
+    @patch("subprocess.run")
+    def test_create_branch(self, mock_run):
+        # Mock the subprocess.run method
+        mock_run.return_value = MagicMock()
+
+        # Mock os.chdir
+        with patch("os.chdir"):
+            self.github_automation.create_branch("test-branch")
+
+        # Assertions
+        mock_run.assert_called_once_with(
+            ["git", "checkout", "-b", "test-branch"], check=True
+        )
+
+    @patch("subprocess.run")
+    def test_add_file(self, mock_run):
+        # Mock the subprocess.run method
+        mock_run.return_value = MagicMock()
+
+        # Mock os.chdir and Path
+        with patch("os.chdir"), patch("pathlib.Path.mkdir"), patch(
+            "builtins.open", unittest.mock.mock_open()
+        ):
+            self.github_automation.add_file("test/file.json", {"key": "value"})
+
+        # Assertions
+        mock_run.assert_called_once_with(
+            [
+                "git",
+                "add",
+                str(Path(self.github_automation.local_clone_dir) / "test/file.json"),
+            ],
+            check=True,
+        )
+
+    @patch("subprocess.run")
+    def test_commit_and_push(self, mock_run):
+        # Mock the subprocess.run method
+        mock_run.return_value = MagicMock()
+
+        # Mock os.chdir
+        with patch("os.chdir"):
+            self.github_automation.commit_and_push("test-branch", "Test commit message")
+
+        # Assertions
+        mock_run.assert_any_call(
+            ["git", "commit", "-m", "Test commit message"], check=True
+        )
+        mock_run.assert_any_call(
+            ["git", "push", "-u", "origin", "test-branch"], check=True
+        )
+
+    @patch("requests.post")
+    def test_create_pull_request(self, mock_post):
+        # Mock the response from GitHub API
+        mock_response = MagicMock()
+        mock_response.raise_for_status.return_value = None
+        mock_response.json.return_value = {"html_url": "https://github.com/test/pull/1"}
+        mock_post.return_value = mock_response
+
+        # Mock os.chdir
+        with patch("os.chdir"):
+            self.github_automation.create_pull_request(
+                "test-branch", "Test PR", "Test body"
+            )
+
+        # Assertions
+        mock_post.assert_called_once_with(
+            f"https://api.github.com/repos/{self.repo_owner}/{self.repo_name}/pulls",
+            headers={"Authorization": f"token {self.token}"},
+            json={
+                "title": "Test PR",
+                "head": f"{self.username}:test-branch",
+                "base": "main",
+                "body": "Test body",
+            },
+        )
+
+    @patch("subprocess.run")
+    def test_clean_up(self, mock_run):
+        # Mock the subprocess.run method
+        mock_run.return_value = MagicMock()
+
+        # Mock os.chdir
+        with patch("os.chdir"):
+            self.github_automation.clean_up()
+
+        # Assertions
+        mock_run.assert_called_once_with(
+            ["rm", "-rf", self.github_automation.local_clone_dir]
+        )
+
+    def test_file_exists(self):
+        # Mock os.path.isfile
+        with patch("os.path.isfile", return_value=True):
+            result = self.github_automation.file_exists("test/file.json")
+
+        # Assertions
+        self.assertTrue(result)