nautobot 2.4.1__py3-none-any.whl → 2.4.2__py3-none-any.whl

nautobot/extras/tests/test_api.py

@@ -1207,6 +1207,10 @@ class GitRepositoryTest(APIViewTestCases.APIViewTestCase):
         url = reverse("extras-api:gitrepository-sync", kwargs={"pk": self.repos[0].id})
         response = self.client.post(url, format="json", **self.header)
         self.assertHttpStatus(response, status.HTTP_200_OK)
+        self.assertIn("message", response.data)
+        self.assertIn("job_result", response.data)
+        self.assertEqual(response.data["message"], f"Repository {self.repos[0].name} sync job added to queue.")
+        self.assertIsInstance(response.data["job_result"], dict)
 
     def test_create_with_app_provided_contents(self):
         """Test that `provided_contents` published by an App works."""
@@ -1241,6 +1245,8 @@ class GraphQLQueryTest(APIViewTestCases.APIViewTestCase):
         },
     ]
 
+    choices_fields = ["owner_content_type"]
+
     @classmethod
     def setUpTestData(cls):
         cls.graphqlqueries = (

nautobot/extras/tests/test_customfields.py

@@ -53,12 +53,12 @@ class CustomFieldTest(ModelTestCases.BaseModelTestCase, TestCase):
 
         instance.refresh_from_db()
         instance.key = "custom_field_2"
-        with self.assertRaises(ValidationError):
+        with self.assertRaisesRegex(ValidationError, "Key cannot be changed once created"):
             instance.validated_save()
 
         instance.refresh_from_db()
         instance.type = CustomFieldTypeChoices.TYPE_SELECT
-        with self.assertRaises(ValidationError):
+        with self.assertRaisesRegex(ValidationError, "Type cannot be changed once created"):
             instance.validated_save()
 
     def test_simple_fields(self):
@@ -165,9 +165,14 @@ class CustomFieldTest(ModelTestCases.BaseModelTestCase, TestCase):
         cf.save()
         cf.content_types.set([obj_type])
 
-        CustomFieldChoice.objects.create(custom_field=cf, value="Option A")
-        CustomFieldChoice.objects.create(custom_field=cf, value="Option B")
-        CustomFieldChoice.objects.create(custom_field=cf, value="Option C")
+        CustomFieldChoice.objects.create(custom_field=cf, value="Option A", weight=100)
+        self.assertEqual(["Option A"], cf.choices)
+        CustomFieldChoice.objects.create(custom_field=cf, value="Option B", weight=200)
+        self.assertEqual(["Option A", "Option B"], cf.choices)
+        CustomFieldChoice.objects.create(custom_field=cf, value="Option C", weight=300)
+        self.assertEqual(["Option A", "Option B", "Option C"], cf.choices)
+        with self.assertNumQueries(0):  # verify caching
+            self.assertEqual(["Option A", "Option B", "Option C"], cf.choices)
 
         # Assign a value to the first Location
         location = Location.objects.get(name="Location A")
@@ -199,9 +204,14 @@ class CustomFieldTest(ModelTestCases.BaseModelTestCase, TestCase):
         cf.save()
         cf.content_types.set([obj_type])
 
-        CustomFieldChoice.objects.create(custom_field=cf, value="Option A")
-        CustomFieldChoice.objects.create(custom_field=cf, value="Option B")
-        CustomFieldChoice.objects.create(custom_field=cf, value="Option C")
+        CustomFieldChoice.objects.create(custom_field=cf, value="Option A", weight=100)
+        self.assertEqual(["Option A"], cf.choices)
+        CustomFieldChoice.objects.create(custom_field=cf, value="Option B", weight=200)
+        self.assertEqual(["Option A", "Option B"], cf.choices)
+        CustomFieldChoice.objects.create(custom_field=cf, value="Option C", weight=300)
+        self.assertEqual(["Option A", "Option B", "Option C"], cf.choices)
+        with self.assertNumQueries(0):  # verify caching
+            self.assertEqual(["Option A", "Option B", "Option C"], cf.choices)
 
         # Assign a value to the first Location
         location = Location.objects.get(name="Location A")
@@ -293,21 +303,18 @@ class CustomFieldTest(ModelTestCases.BaseModelTestCase, TestCase):
         # Assign a disallowed value (list) to the first Location
         location = Location.objects.get(name="Location A")
         location.cf[cf.key] = ["I", "am", "a", "list"]
-        with self.assertRaises(ValidationError) as context:
+        with self.assertRaisesRegex(ValidationError, "Value must be a string"):
             location.validated_save()
-        self.assertIn("Value must be a string", str(context.exception))
 
         # Assign another disallowed value (int) to the first Location
         location.cf[cf.key] = 2
-        with self.assertRaises(ValidationError) as context:
+        with self.assertRaisesRegex(ValidationError, "Value must be a string"):
             location.validated_save()
-        self.assertIn("Value must be a string", str(context.exception))
 
         # Assign another disallowed value (bool) to the first Location
         location.cf[cf.key] = True
-        with self.assertRaises(ValidationError) as context:
+        with self.assertRaisesRegex(ValidationError, "Value must be a string"):
             location.validated_save()
-        self.assertIn("Value must be a string", str(context.exception))
 
         # Delete the stored value
         location.cf.pop(cf.key)
@@ -1294,7 +1301,7 @@ class CustomFieldModelTest(TestCase):
         custom_field.content_types.set([ContentType.objects.get_for_model(Provider)])
 
         provider = Provider.objects.create(name="Test")
-        with self.assertRaises(ValidationError):
+        with self.assertRaisesRegex(ValidationError, "Missing required custom field 'custom_field'"):
             provider.validated_save()
 
     def test_custom_field_required_on_update(self):
@@ -1312,7 +1319,7 @@ class CustomFieldModelTest(TestCase):
         provider = Provider.objects.create(name="Test", _custom_field_data={"custom_field": "Value"})
         provider.validated_save()
         provider._custom_field_data.pop("custom_field")
-        with self.assertRaises(ValidationError):
+        with self.assertRaisesRegex(ValidationError, "Missing required custom field 'custom_field'"):
             provider.validated_save()
 
     def test_update_removed_custom_field(self):
@@ -1373,7 +1380,7 @@ class CustomFieldModelTest(TestCase):
         """
         Check that a ValidationError is raised if any required custom fields are not present.
         """
-        cf3 = CustomField(type=CustomFieldTypeChoices.TYPE_TEXT, label="Baz", required=True)
+        cf3 = CustomField(key="baz", type=CustomFieldTypeChoices.TYPE_TEXT, label="Baz", required=True)
         cf3.save()
         cf3.content_types.set([ContentType.objects.get_for_model(Location)])
 
@@ -1381,7 +1388,7 @@ class CustomFieldModelTest(TestCase):
 
         # Set custom field data with a required field omitted
         location.cf["foo"] = "abc"
-        with self.assertRaises(ValidationError):
+        with self.assertRaisesRegex(ValidationError, "Missing required custom field 'baz'"):
             location.clean()
 
         location.cf["baz"] = "def"
@@ -1427,38 +1434,20 @@ class CustomFieldModelTest(TestCase):
         """
         Check the GraphQL validation method on CustomField Key Attribute.
         """
-        # Check if it catches the cf.key starting with a digit.
-        cf1 = CustomField(type=CustomFieldTypeChoices.TYPE_TEXT, label="Test 1", key="12_test_1")
-        with self.assertRaises(ValidationError) as error:
-            cf1.validated_save()
-        self.assertIn(
-            "This key is not Python/GraphQL safe. Please do not start the key with a digit and do not use hyphens or whitespace",
-            str(error.exception),
-        )
-        # Check if it catches the cf.key with whitespace.
-        cf1.key = "test 1"
-        with self.assertRaises(ValidationError) as error:
-            cf1.validated_save()
-        self.assertIn(
-            "This key is not Python/GraphQL safe. Please do not start the key with a digit and do not use hyphens or whitespace",
-            str(error.exception),
-        )
-        # Check if it catches the cf.key with hyphens.
-        cf1.key = "test-1-custom-field"
-        with self.assertRaises(ValidationError) as error:
-            cf1.validated_save()
-        self.assertIn(
-            "This key is not Python/GraphQL safe. Please do not start the key with a digit and do not use hyphens or whitespace",
-            str(error.exception),
-        )
-        # Check if it catches the cf.key with special characters
-        cf1.key = "test_1_custom_f)(&d"
-        with self.assertRaises(ValidationError) as error:
-            cf1.validated_save()
-        self.assertIn(
-            "This key is not Python/GraphQL safe. Please do not start the key with a digit and do not use hyphens or whitespace",
-            str(error.exception),
-        )
+        cf1 = CustomField(type=CustomFieldTypeChoices.TYPE_TEXT, label="Test 1")
+        for invalid_key in [
+            "12_test_1",  # Check if it catches the cf.key starting with a digit.
+            "test 1",  # Check if it catches the cf.key with whitespace.
+            "test-1-custom-field",  # Check if it catches the cf.key with hyphens.
+            "test_1_custom_f)(&d",  # Check if it catches the cf.key with special characters
+        ]:
+            with self.assertRaisesRegex(
+                ValidationError,
+                "This key is not Python/GraphQL safe. "
+                "Please do not start the key with a digit and do not use hyphens or whitespace",
+            ):
+                cf1.key = invalid_key
+                cf1.validated_save()
 
 
 class CustomFieldFilterTest(TestCase):
@@ -1934,9 +1923,11 @@ class CustomFieldChoiceTest(ModelTestCases.BaseModelTestCase):
         )
         self.cf.save()
         self.cf.content_types.set([obj_type])
+        self.assertEqual(self.cf.choices, [])
 
         self.choice = CustomFieldChoice(custom_field=self.cf, value="Foo")
         self.choice.save()
+        self.assertEqual(self.cf.choices, ["Foo"])
 
         location_status = Status.objects.get_for_model(Location).first()
         self.location_type = LocationType.objects.get(name="Campus")
@@ -1952,7 +1943,7 @@ class CustomFieldChoiceTest(ModelTestCases.BaseModelTestCase):
 
     def test_default_value_must_be_valid_choice_sad_path(self):
         self.cf.default = "invalid value"
-        with self.assertRaises(ValidationError):
+        with self.assertRaisesRegex(ValidationError, 'Invalid default value "invalid value"'):
             self.cf.full_clean()
 
     def test_default_value_must_be_valid_choice_happy_path(self):
@@ -1965,6 +1956,13 @@ class CustomFieldChoiceTest(ModelTestCases.BaseModelTestCase):
         with self.assertRaises(ProtectedError):
             self.choice.delete()
 
+    def test_inactive_choice_can_be_deleted(self):
+        self.location._custom_field_data.pop("cf1")
+        self.location.validated_save()
+        self.assertEqual(self.cf.choices, ["Foo"])
+        self.choice.delete()
+        self.assertEqual(self.cf.choices, [])
+
     def test_custom_choice_deleted_with_field(self):
         self.cf.delete()
         self.assertEqual(CustomField.objects.count(), 1)  # custom field automatically added by the Example App

nautobot/extras/tests/test_datasources.py

@@ -30,6 +30,7 @@ from nautobot.extras.models import (
     ConfigContextSchema,
     ExportTemplate,
     GitRepository,
+    GraphQLQuery,
     Job,
     JobButton,
     JobHook,
@@ -197,6 +198,15 @@ class GitTest(TransactionTestCase):
         )
         self.assertIsNotNone(export_template_vlan)
 
+    def assert_graphql_query_exists(self, name="device_names.gql"):
+        """Helper function to assert Graphql query exists."""
+        graphql_query = GraphQLQuery.objects.get(
+            name=name,
+            owner_object_id=self.repo.pk,
+            owner_content_type=ContentType.objects.get_for_model(GitRepository),
+        )
+        self.assertIsNotNone(graphql_query)
+
     def assert_job_exists(self, name="MyJob", installed=True):
         """Helper function to assert JobModel and registered Job exist."""
         # Is it registered correctly in the database?
@@ -348,6 +358,10 @@ class GitTest(TransactionTestCase):
                 # Case when ContentType.model != ContentType.name, template was added and deleted during sync (#570)
                 self.assert_export_template_vlan_exists("template.j2")
 
+                # Make sure Graphgl queries were loaded
+                self.assert_graphql_query_exists("device_names")
+                self.assert_graphql_query_exists("device_interfaces")
+
                 # Make sure Jobs were successfully loaded from file and registered as JobModels
                 self.assert_job_exists(name="MyJob")
                 self.assert_job_exists(name="MyJobButtonReceiver")
@@ -439,6 +453,7 @@ class GitTest(TransactionTestCase):
                 self.assertFalse(ConfigContextSchema.objects.filter(owner_object_id=self.repo.id).exists())
                 self.assertFalse(ConfigContext.objects.filter(owner_object_id=self.repo.id).exists())
                 self.assertFalse(ExportTemplate.objects.filter(owner_object_id=self.repo.id).exists())
+                self.assertFalse(GraphQLQuery.objects.filter(owner_object_id=self.repo.id).exists())
                 self.assertFalse(Job.objects.filter(module_name__startswith=f"{self.repo.slug}.").exists())
                 device = Device.objects.get(name=self.device.name)
                 self.assertIsNone(device.local_config_context_data)
@@ -505,6 +520,11 @@ class GitTest(TransactionTestCase):
                         grouping="jobs",
                         message__contains="Error in loading Jobs from Git repository: ",
                     )
+                    failure_logs.get(
+                        grouping="graphql queries",
+                        message__contains="Error processing GraphQL query file 'bad_device_names.gql': Syntax Error GraphQL (4:5) Expected Name, found }",
+                    )
+
                 except (AssertionError, JobLogEntry.DoesNotExist):
                     for log in log_entries:
                         print(log.message)
@@ -630,6 +650,8 @@ class GitTest(TransactionTestCase):
                 self.assert_export_template_device("template.j2")
                 self.assert_export_template_html_exist("template2.html")
                 self.assert_export_template_vlan_exists("template.j2")
+                self.assert_graphql_query_exists(name="device_names")
+                self.assert_graphql_query_exists(name="device_interfaces")
                 self.assert_job_exists(name="MyJob")
                 self.assert_job_exists(name="MyJobButtonReceiver")
                 self.assert_job_exists(name="MyJobHookReceiver")
@@ -669,6 +691,8 @@ class GitTest(TransactionTestCase):
                     self.assert_export_template_device("template.j2")
                     self.assert_export_template_html_exist("template2.html")
                     self.assert_export_template_vlan_exists("template.j2")
+                    self.assert_graphql_query_exists("device_names")
+                    self.assert_graphql_query_exists("device_interfaces")
                     self.assert_job_exists(name="MyJob")
                     self.assert_job_exists(name="MyJobButtonReceiver")
                     self.assert_job_exists(name="MyJobHookReceiver")
@@ -711,6 +735,8 @@ class GitTest(TransactionTestCase):
                     log_entries.get(message__contains="Addition - `export_templates/dcim/device/template.j2`")
                     log_entries.get(message__contains="Addition - `export_templates/dcim/device/template2.html`")
                     log_entries.get(message__contains="Addition - `export_templates/ipam/vlan/template.j2`")
+                    log_entries.get(message__contains="Addition - `graphql_queries/device_interfaces.gql`")
+                    log_entries.get(message__contains="Addition - `graphql_queries/device_names.gql`")
                     log_entries.get(message__contains="Addition - `jobs/__init__.py`")
                     log_entries.get(message__contains="Addition - `jobs/my_job.py`")
                 except JobLogEntry.DoesNotExist:
@@ -721,6 +747,7 @@ class GitTest(TransactionTestCase):
                 self.assertFalse(ConfigContextSchema.objects.filter(owner_object_id=self.repo.pk).exists())
                 self.assertFalse(ConfigContext.objects.filter(owner_object_id=self.repo.pk).exists())
                 self.assertFalse(ExportTemplate.objects.filter(owner_object_id=self.repo.pk).exists())
+                self.assertFalse(GraphQLQuery.objects.filter(owner_object_id=self.repo.pk).exists())
                 self.assertFalse(Job.objects.filter(module_name__startswith=self.repo.slug).exists())
 
     # TODO: test dry-run against a branch name

nautobot/extras/tests/test_models.py

@@ -1,5 +1,6 @@
 from datetime import datetime, timedelta, timezone
 import os
+import shutil
 import tempfile
 from unittest import expectedFailure, mock
 import uuid
@@ -17,6 +18,7 @@ from django.test import override_settings
 from django.test.utils import isolate_apps
 from django.utils.timezone import get_default_timezone, now
 from django_celery_beat.tzcrontab import TzAwareCrontab
+from git import GitCommandError
 from jinja2.exceptions import TemplateAssertionError, TemplateSyntaxError
 import time_machine
 
@@ -48,6 +50,7 @@ from nautobot.extras.constants import (
     JOB_LOG_MAX_LOG_OBJECT_LENGTH,
     JOB_OVERRIDABLE_FIELDS,
 )
+from nautobot.extras.datasources.registry import get_datasource_contents
 from nautobot.extras.jobs import get_job
 from nautobot.extras.models import (
     ComputedField,
@@ -83,6 +86,7 @@ from nautobot.extras.models import (
 from nautobot.extras.models.statuses import StatusModel
 from nautobot.extras.registry import registry
 from nautobot.extras.secrets.exceptions import SecretParametersError, SecretProviderError, SecretValueNotFoundError
+from nautobot.extras.tests.git_helper import create_and_populate_git_repository
 from nautobot.ipam.models import IPAddress
 from nautobot.tenancy.models import Tenant
 from nautobot.virtualization.models import (
@@ -1072,6 +1076,285 @@ class GitRepositoryTest(ModelTestCases.BaseModelTestCase):
         self.repo.remote_url = "http://some-private-host/example.git"
         self.repo.validated_save()
 
+    def test_clone_to_directory_context_manager(self):
+        """Confirm that the clone_to_directory_context() context manager method works as expected."""
+        try:
+            specified_path = tempfile.mkdtemp()
+            self.tempdir = tempfile.TemporaryDirectory()  # pylint: disable=consider-using-with
+            create_and_populate_git_repository(self.tempdir.name, divergent_branch="divergent-branch")
+            self.repo_slug = "new_git_repo"
+            self.repo = GitRepository(
+                name="New Git Repository",
+                slug=self.repo_slug,
+                remote_url="file://"
+                + self.tempdir.name,  # file:// URLs aren't permitted normally, but very useful here!
+                branch="main",
+                # Provide everything we know we can provide
+                provided_contents=[
+                    entry.content_identifier for entry in get_datasource_contents("extras.gitrepository")
+                ],
+            )
+            self.repo.save()
+            with self.subTest("Clone a repository with no path argument provided"):
+                with self.repo.clone_to_directory_context() as path:
+                    # assert that the temporary directory was created in the expected location i.e. /tmp/
+                    self.assertTrue(path.startswith(tempfile.gettempdir()))
+                    self.assertTrue(os.path.exists(path))
+                    self.assertTrue(os.path.exists(path + "/config_context_schemas/badschema1.json"))
+                    self.assertTrue(os.path.exists(path + "/config_context_schemas/badschema2.json"))
+                self.assertFalse(os.path.exists(path))
+
+            with self.subTest("Clone a repository with a path argument provided"):
+                with self.repo.clone_to_directory_context(path=specified_path) as path:
+                    # assert that the temporary directory was created in the expected location i.e. /tmp/
+                    self.assertTrue(path.startswith(specified_path))
+                    self.assertTrue(os.path.exists(path))
+                    self.assertTrue(os.path.exists(path + "/config_context_schemas/badschema1.json"))
+                    self.assertTrue(os.path.exists(path + "/config_context_schemas/badschema2.json"))
+                # Temp directory is cleaned up after the context manager exits
+                self.assertFalse(os.path.exists(path))
+
+            with self.subTest("Clone a repository with the branch argument provided"):
+                with self.repo.clone_to_directory_context(path=specified_path, branch="main") as path:
+                    # assert that the temporary directory was created in the expected location i.e. /tmp/
+                    self.assertTrue(path.startswith(specified_path))
+                    self.assertTrue(os.path.exists(path))
+                    self.assertTrue(os.path.exists(path + "/config_context_schemas/badschema1.json"))
+                    self.assertTrue(os.path.exists(path + "/config_context_schemas/badschema2.json"))
+                # Temp directory is cleaned up after the context manager exits
+                self.assertFalse(os.path.exists(path))
+
+            with self.subTest("Clone a repository with non-default branch provided"):
+                with self.repo.clone_to_directory_context(path=specified_path, branch="empty-repo") as path:
+                    # assert that the temporary directory was created in the expected location i.e. /tmp/
+                    self.assertTrue(path.startswith(specified_path))
+                    self.assertTrue(os.path.exists(path))
+                    # empty-repo should contain no files
+                    self.assertFalse(os.path.exists(path + "/config_context_schemas"))
+                    self.assertFalse(os.path.exists(path + "/config_contexts"))
+                # Temp directory is cleaned up after the context manager exits
+                self.assertFalse(os.path.exists(path))
+
+            with self.subTest("Clone a repository with divergent branch provided"):
+                with self.repo.clone_to_directory_context(path=specified_path, branch="divergent-branch") as path:
+                    # assert that the temporary directory was created in the expected location i.e. /tmp/
+                    self.assertTrue(path.startswith(specified_path))
+                    self.assertTrue(os.path.exists(path))
+                    self.assertTrue(os.path.exists(path + "/config_context_schemas/badschema1.json"))
+                    self.assertTrue(os.path.exists(path + "/config_context_schemas/badschema2.json"))
+                # Temp directory is cleaned up after the context manager exits
+                self.assertFalse(os.path.exists(path))
+
+            with self.subTest("Clone a repository with the head argument provided"):
+                with self.repo.clone_to_directory_context(path=specified_path, head="valid-files") as path:
+                    # assert that the temporary directory was created in the expected location i.e. /tmp/
+                    self.assertTrue(path.startswith(specified_path))
+                    self.assertTrue(os.path.exists(path))
+                    self.assertTrue(os.path.exists(path + "/config_context_schemas/schema-1.yaml"))
+                    self.assertTrue(os.path.exists(path + "/config_contexts/context.yaml"))
+                # Temp directory is cleaned up after the context manager exits
+                self.assertFalse(os.path.exists(path))
+
+            with self.subTest("Clone a repository with depth argument provided"):
+                with self.repo.clone_to_directory_context(path=specified_path, depth=1) as path:
+                    # assert that the temporary directory was created in the expected location i.e. /tmp/
+                    self.assertTrue(path.startswith(specified_path))
+                    self.assertTrue(os.path.exists(path))
+                    self.assertTrue(os.path.exists(path + "/config_context_schemas/badschema1.json"))
+                    self.assertTrue(os.path.exists(path + "/config_contexts/badcontext2.json"))
+                # Temp directory is cleaned up after the context manager exits
+                self.assertFalse(os.path.exists(path))
+
+            with self.subTest("Clone a shallow repository with depth and valid head arguments provided"):
+                with self.repo.clone_to_directory_context(
+                    path=specified_path, depth=1, head="divergent-branch-tag"
+                ) as path:
+                    # assert that the temporary directory was created in the expected location i.e. /tmp/
+                    self.assertTrue(path.startswith(specified_path))
+                    self.assertTrue(os.path.exists(path))
+                    self.assertTrue(os.path.exists(path + "/config_context_schemas/badschema1.json"))
+                    self.assertTrue(os.path.exists(path + "/config_contexts/badcontext2.json"))
+                # Temp directory is cleaned up after the context manager exits
+                self.assertFalse(os.path.exists(path))
+
+            with self.subTest("Clone a shallow repository with depth and invalid head arguments provided"):
+                with self.assertRaisesRegex(GitCommandError, "malformed object name valid-files"):
+                    # Shallow copy a repo should only have the latest commit
+                    with self.repo.clone_to_directory_context(path=specified_path, depth=1, head="valid-files") as path:
+                        pass
+
+            with self.subTest("Clone a shallow repository with depth and valid branch arguments provided"):
+                with self.repo.clone_to_directory_context(path=specified_path, depth=1, branch="main") as path:
+                    # assert that the temporary directory was created in the expected location i.e. /tmp/
+                    self.assertTrue(path.startswith(specified_path))
+                    self.assertTrue(os.path.exists(path))
+                    self.assertTrue(os.path.exists(path + "/config_context_schemas/badschema1.json"))
+                    self.assertTrue(os.path.exists(path + "/config_contexts/badcontext2.json"))
+                # Temp directory is cleaned up after the context manager exits
+                self.assertFalse(os.path.exists(path))
+
+            with self.subTest("Clone a shallow repository with depth and divergent branch arguments provided"):
+                with self.repo.clone_to_directory_context(
+                    path=specified_path, depth=1, branch="divergent-branch"
+                ) as path:
+                    # assert that the temporary directory was created in the expected location i.e. /tmp/
+                    self.assertTrue(path.startswith(specified_path))
+                    self.assertTrue(os.path.exists(path))
+                    self.assertTrue(os.path.exists(path + "/config_context_schemas/badschema1.json"))
+                    self.assertTrue(os.path.exists(path + "/config_contexts/badcontext2.json"))
+                # Temp directory is cleaned up after the context manager exits
+                self.assertFalse(os.path.exists(path))
+
+            with self.subTest("Assert a GitCommandError is raised when an invalid commit hash is provided"):
+                with self.assertRaisesRegex(GitCommandError, "malformed object name non-existent"):
+                    with self.repo.clone_to_directory_context(path=specified_path, head="non-existent") as path:
+                        pass
+
+            with self.subTest("Assert a value error is raised when branch and head are both provided"):
+                with self.assertRaisesRegex(ValueError, "Cannot specify both branch and head"):
+                    with self.repo.clone_to_directory_context(branch="main", head="valid-files") as path:
+                        pass
+        finally:
+            shutil.rmtree(specified_path, ignore_errors=True)
+            shutil.rmtree(self.tempdir.name, ignore_errors=True)
+
+    def test_clone_to_directory_helper_methods(self):
+        """Confirm that the clone_to_directory()/cleanup_cloned_directory() methods work as expected."""
+        try:
+            specified_path = tempfile.mkdtemp()
+            self.tempdir = tempfile.TemporaryDirectory()  # pylint: disable=consider-using-with
+            create_and_populate_git_repository(self.tempdir.name, divergent_branch="divergent-branch")
+            self.repo_slug = "new_git_repo"
+            self.repo = GitRepository(
+                name="New Git Repository",
+                slug=self.repo_slug,
+                remote_url="file://"
+                + self.tempdir.name,  # file:// URLs aren't permitted normally, but very useful here!
+                branch="main",
+                # Provide everything we know we can provide
+                provided_contents=[
+                    entry.content_identifier for entry in get_datasource_contents("extras.gitrepository")
+                ],
+            )
+            self.repo.save()
+            with self.subTest("Clone a repository with no path argument provided"):
+                path = self.repo.clone_to_directory()
+                # assert that the temporary directory was created in the expected location i.e. /tmp/
+                self.assertTrue(path.startswith(tempfile.gettempdir()))
+                self.assertTrue(os.path.exists(path))
+                self.assertTrue(os.path.exists(path + "/config_context_schemas/badschema1.json"))
+                self.assertTrue(os.path.exists(path + "/config_context_schemas/badschema2.json"))
+                self.repo.cleanup_cloned_directory(path)
+                self.assertFalse(os.path.exists(path))
+
+            with self.subTest("Clone a repository with a path argument provided"):
+                path = self.repo.clone_to_directory(path=specified_path)
+                # assert that the temporary directory was created in the expected location i.e. /tmp/
+                self.assertTrue(path.startswith(specified_path))
+                self.assertTrue(os.path.exists(path))
+                self.assertTrue(os.path.exists(path + "/config_context_schemas/badschema1.json"))
+                self.assertTrue(os.path.exists(path + "/config_context_schemas/badschema2.json"))
+                self.repo.cleanup_cloned_directory(path)
+                self.assertFalse(os.path.exists(path))
+
+            with self.subTest("Clone a repository with the branch argument provided"):
+                path = self.repo.clone_to_directory(path=specified_path, branch="main")
+                # assert that the temporary directory was created in the expected location i.e. /tmp/
+                self.assertTrue(path.startswith(specified_path))
+                self.assertTrue(os.path.exists(path))
+                self.assertTrue(os.path.exists(path + "/config_context_schemas/badschema1.json"))
+                self.assertTrue(os.path.exists(path + "/config_context_schemas/badschema2.json"))
+                self.repo.cleanup_cloned_directory(path)
+                self.assertFalse(os.path.exists(path))
+
+            with self.subTest("Clone a repository with non-default branch provided"):
+                path = self.repo.clone_to_directory(path=specified_path, branch="empty-repo")
+                # assert that the temporary directory was created in the expected location i.e. /tmp/
+                self.assertTrue(path.startswith(specified_path))
+                self.assertTrue(os.path.exists(path))
+                self.assertFalse(os.path.exists(path + "/config_context_schemas"))
+                self.assertFalse(os.path.exists(path + "/config_contexts"))
+                self.repo.cleanup_cloned_directory(path)
+                self.assertFalse(os.path.exists(path))
+
+            with self.subTest("Clone a repository with divergent branch provided"):
+                path = self.repo.clone_to_directory(path=specified_path, branch="divergent-branch")
+                # assert that the temporary directory was created in the expected location i.e. /tmp/
+                self.assertTrue(path.startswith(specified_path))
+                self.assertTrue(os.path.exists(path))
+                self.assertTrue(os.path.exists(path + "/config_context_schemas"))
+                self.assertTrue(os.path.exists(path + "/config_contexts"))
+                self.repo.cleanup_cloned_directory(path)
+                self.assertFalse(os.path.exists(path))
+
+            with self.subTest("Clone a repository with the head argument provided"):
+                path = self.repo.clone_to_directory(path=specified_path, head="valid-files")
+                # assert that the temporary directory was created in the expected location i.e. /tmp/
+                self.assertTrue(path.startswith(specified_path))
+                self.assertTrue(os.path.exists(path))
+                self.assertTrue(os.path.exists(path + "/config_context_schemas/schema-1.yaml"))
+                self.assertTrue(os.path.exists(path + "/config_contexts/context.yaml"))
+                self.repo.cleanup_cloned_directory(path)
+                self.assertFalse(os.path.exists(path))
+
+            with self.subTest("Clone a repository with depth argument provided"):
+                path = self.repo.clone_to_directory(path=specified_path, depth=1)
+                # assert that the temporary directory was created in the expected location i.e. /tmp/
+                self.assertTrue(path.startswith(specified_path))
+                self.assertTrue(os.path.exists(path))
+                self.assertTrue(os.path.exists(path + "/config_context_schemas/badschema1.json"))
+                self.assertTrue(os.path.exists(path + "/config_contexts/badcontext2.json"))
+                self.repo.cleanup_cloned_directory(path)
+                self.assertFalse(os.path.exists(path))
+
+            with self.subTest("Clone a shallow repository with depth and valid head arguments provided"):
+                path = self.repo.clone_to_directory(path=specified_path, depth=1, head="divergent-branch-tag")
+                # assert that the temporary directory was created in the expected location i.e. /tmp/
+                self.assertTrue(path.startswith(specified_path))
+                self.assertTrue(os.path.exists(path))
+                self.assertTrue(os.path.exists(path + "/config_context_schemas/badschema1.json"))
+                self.assertTrue(os.path.exists(path + "/config_contexts/badcontext2.json"))
+                self.repo.cleanup_cloned_directory(path)
+                self.assertFalse(os.path.exists(path))
+
+            with self.subTest("Clone a shallow repository with depth and invalid head arguments provided"):
+                with self.assertRaisesRegex(GitCommandError, "malformed object name valid-files"):
+                    # Shallow copy a repo should only have the latest commit
+                    path = self.repo.clone_to_directory(path=specified_path, depth=1, head="valid-files")
+                    self.repo.cleanup_cloned_directory(path)
+                    self.assertFalse(os.path.exists(path))
+
+            with self.subTest("Clone a shallow repository with depth and valid branch arguments provided"):
+                path = self.repo.clone_to_directory(path=specified_path, depth=1, branch="main")
+                # assert that the temporary directory was created in the expected location i.e. /tmp/
+                self.assertTrue(path.startswith(specified_path))
+                self.assertTrue(os.path.exists(path))
+                self.assertTrue(os.path.exists(path + "/config_context_schemas/badschema1.json"))
+                self.assertTrue(os.path.exists(path + "/config_contexts/badcontext2.json"))
+                self.repo.cleanup_cloned_directory(path)
+                self.assertFalse(os.path.exists(path))
+
+            with self.subTest("Clone a shallow repository with depth and divergent branch arguments provided"):
+                path = self.repo.clone_to_directory(path=specified_path, depth=1, branch="divergent-branch")
+                # assert that the temporary directory was created in the expected location i.e. /tmp/
+                self.assertTrue(path.startswith(specified_path))
+                self.assertTrue(os.path.exists(path))
+                self.assertTrue(os.path.exists(path + "/config_context_schemas/badschema1.json"))
+                self.assertTrue(os.path.exists(path + "/config_contexts/badcontext2.json"))
+                self.repo.cleanup_cloned_directory(path)
+                self.assertFalse(os.path.exists(path))
+
+            with self.subTest("Assert a GitCommandError is raised when an invalid commit hash is provided"):
+                with self.assertRaisesRegex(GitCommandError, "malformed object name non-existent"):
+                    path = self.repo.clone_to_directory(path=specified_path, head="non-existent")
+
+            with self.subTest("Assert a ValuError is raised when branch and head are both provided"):
+                with self.assertRaisesRegex(ValueError, "Cannot specify both branch and head"):
+                    path = self.repo.clone_to_directory(branch="main", head="valid-files")
+        finally:
+            shutil.rmtree(specified_path, ignore_errors=True)
+            shutil.rmtree(self.tempdir.name, ignore_errors=True)
+
 
 class JobModelTest(ModelTestCases.BaseModelTestCase):
     """