nautobot 2.2.4__py3-none-any.whl → 2.2.6__py3-none-any.whl

nautobot/extras/tests/test_datasources.py

@@ -1,4 +1,3 @@
-import json
 import os
 import sys
 import tempfile
@@ -6,6 +5,7 @@ from unittest import mock
 import uuid
 
 from celery.exceptions import NotRegistered
+from django.conf import settings
 from django.contrib.contenttypes.models import ContentType
 from django.core.exceptions import ValidationError
 from django.test import RequestFactory
@@ -31,6 +31,8 @@ from nautobot.extras.models import (
     ExportTemplate,
     GitRepository,
     Job,
+    JobButton,
+    JobHook,
     JobLogEntry,
     JobResult,
     Role,
@@ -39,10 +41,10 @@ from nautobot.extras.models import (
     SecretsGroupAssociation,
     Status,
 )
+from nautobot.extras.tests.git_helper import create_and_populate_git_repository
 from nautobot.ipam.models import VLAN
 
 
-@mock.patch("nautobot.extras.datasources.git.GitRepo")
 class GitTest(TransactionTestCase):
     """
     Tests for Git repository handling.
@@ -51,7 +53,6 @@ class GitTest(TransactionTestCase):
     """
 
     databases = ("default", "job_logs")
-    COMMIT_HEXSHA = "88dd9cd78df89e887ee90a1d209a3e9a04e8c841"
 
     def setUp(self):
         super().setUp()
@@ -80,11 +81,15 @@ class GitTest(TransactionTestCase):
             status=status,
         )
 
+        self.tempdir = tempfile.TemporaryDirectory()  # pylint: disable=consider-using-with
+        create_and_populate_git_repository(self.tempdir.name)
+
         self.repo_slug = "test_git_repo"
         self.repo = GitRepository(
             name="Test Git Repository",
             slug=self.repo_slug,
-            remote_url="http://localhost/git.git",
+            remote_url="file://" + self.tempdir.name,  # file:// URLs aren't permitted normally, but very useful here!
+            branch="empty-repo",
             # Provide everything we know we can provide
             provided_contents=[entry.content_identifier for entry in get_datasource_contents("extras.gitrepository")],
         )
@@ -92,138 +97,34 @@ class GitTest(TransactionTestCase):
 
         self.job_result = JobResult.objects.create(name=self.repo.name)
 
-        self.config_context_schema = {
-            "_metadata": {
-                "name": "Config Context Schema 1",
-                "description": "Schema for defining first names, last names and ages.",
-            },
-            "data_schema": {
-                "title": "Person",
-                "type": "object",
-                "properties": {
-                    "firstName": {
-                        "type": "string",
-                        "description": "The person's first name.",
-                    },
-                    "lastName": {
-                        "type": "string",
-                        "description": "The person's last name.",
-                    },
-                    "age": {
-                        "description": "Age in years which must be equal to or greater than zero.",
-                        "type": "integer",
-                        "minimum": 0,
-                    },
-                },
-            },
-        }
-
     def tearDown(self):
         if f"{self.repo_slug}.jobs" in sys.modules:
             del sys.modules[f"{self.repo_slug}.jobs"]
         if f"{self.repo_slug}" in sys.modules:
             del sys.modules[f"{self.repo_slug}"]
+        self.tempdir.cleanup()
         if self.repo is not None:
             self.repo.delete()
         super().tearDown()
 
-    def populate_repo(self, path, url, *args, **kwargs):
-        os.makedirs(path, exist_ok=True)
-
-        os.makedirs(os.path.join(path, "config_contexts"), exist_ok=True)
-        os.makedirs(os.path.join(path, "config_contexts", "devices"), exist_ok=True)
-        os.makedirs(os.path.join(path, "config_contexts", "locations"), exist_ok=True)
-        os.makedirs(os.path.join(path, "config_context_schemas"), exist_ok=True)
-        os.makedirs(os.path.join(path, "export_templates", "dcim", "device"), exist_ok=True)
-        os.makedirs(os.path.join(path, "export_templates", "ipam", "vlan"), exist_ok=True)
-        os.makedirs(os.path.join(path, "jobs"), exist_ok=True)
-
-        with open(os.path.join(path, "__init__.py"), "w") as fd:
-            # Required for job importing
-            pass
-
-        with open(os.path.join(path, "config_contexts", "context.yaml"), "w") as fd:
-            yaml.dump(
-                {
-                    "_metadata": {
-                        "name": "Frobozz 1000 NTP servers",
-                        "weight": 1500,
-                        "description": "NTP servers for Frobozz 1000 devices **only**",
-                        "is_active": True,
-                        "config_context_schema": "Config Context Schema 1",
-                        "device_types": [{"model": self.device_type.model}],
-                    },
-                    "ntp-servers": ["172.16.10.22", "172.16.10.33"],
-                },
-                fd,
-            )
-
-        with open(os.path.join(path, "config_contexts", "locations", f"{self.location.name}.json"), "w") as fd:
-            json.dump(
-                {
-                    "_metadata": {"name": "Location context", "is_active": False},
-                    "domain_name": "example.com",
-                },
-                fd,
-            )
-
-        with open(os.path.join(path, "config_contexts", "devices", f"{self.device.name}.json"), "w") as fd:
-            json.dump({"dns-servers": ["8.8.8.8"]}, fd)
-
-        with open(os.path.join(path, "config_context_schemas", "schema-1.yaml"), "w") as fd:
-            yaml.dump(self.config_context_schema, fd)
-
-        with open(os.path.join(path, "export_templates", "dcim", "device", "template.j2"), "w") as fd:
-            fd.write("{% for device in queryset %}\n{{ device.name }}\n{% endfor %}")
-
-        with open(os.path.join(path, "export_templates", "dcim", "device", "template2.html"), "w") as fd:
-            fd.write("<!DOCTYPE html>/n{% for device in queryset %}\n{{ device.name }}\n{% endfor %}")
-
-        with open(os.path.join(path, "export_templates", "ipam", "vlan", "template.j2"), "w") as fd:
-            fd.write("{% for vlan in queryset %}\n{{ vlan.name }}\n{% endfor %}")
-
-        with open(os.path.join(path, "jobs", "__init__.py"), "w") as fd:
-            fd.write("from nautobot.core.celery import register_jobs\nfrom .my_job import MyJob\nregister_jobs(MyJob)")
-
-        with open(os.path.join(path, "jobs", "my_job.py"), "w") as fd:
-            fd.write("from nautobot.extras.jobs import Job\nclass MyJob(Job):\n    def run(self):\n        pass")
-
-        return mock.DEFAULT
-
-    def empty_repo(self, path, url, *args, **kwargs):
-        try:
-            os.remove(os.path.join(path, "__init__.py"))
-            os.remove(os.path.join(path, "config_contexts", "context.yaml"))
-            os.remove(os.path.join(path, "config_contexts", "locations", f"{self.location.name}.json"))
-            os.remove(os.path.join(path, "config_contexts", "devices", f"{self.device.name}.json"))
-            os.remove(os.path.join(path, "config_context_schemas", "schema-1.yaml"))
-            os.remove(os.path.join(path, "export_templates", "dcim", "device", "template.j2"))
-            os.remove(os.path.join(path, "export_templates", "dcim", "device", "template2.html"))
-            os.remove(os.path.join(path, "export_templates", "ipam", "vlan", "template.j2"))
-            os.remove(os.path.join(path, "jobs", "__init__.py"))
-            os.remove(os.path.join(path, "jobs", "my_job.py"))
-        except FileNotFoundError:
-            pass
-        return mock.DEFAULT
-
     def assert_repo_slug_valid_python_package_name(self):
         git_repository = GitRepository.objects.create(
             name="1 Very-Bad Git_____Repo Name (2)", remote_url="http://localhost/git.git"
         )
         self.assertEqual(git_repository.slug, "a1_very_bad_git_____repo_name_2")
 
-    def assert_config_context_schema_record_exists(self, name):
-        """Helper Func to assert ConfigContextSchema with name=name exists"""
+    def assert_config_context_schema_record_exists(self, name, filename="schema-1.yaml"):
+        """Assert that a ConfigContextSchema record exists with the expected name and data_schema."""
         config_context_schema_record = ConfigContextSchema.objects.get(
             name=name,
             owner_object_id=self.repo.pk,
             owner_content_type=ContentType.objects.get_for_model(GitRepository),
         )
-        config_context_schema = self.config_context_schema
-        config_context_schema_metadata = config_context_schema["_metadata"]
         self.assertIsNotNone(config_context_schema_record)
-        self.assertEqual(config_context_schema_metadata["name"], config_context_schema_record.name)
-        self.assertEqual(config_context_schema["data_schema"], config_context_schema_record.data_schema)
+        with open(os.path.join(settings.GIT_ROOT, self.repo.slug, "config_context_schemas", filename)) as fd:
+            config_context_schema_data = yaml.safe_load(fd)
+        self.assertEqual(config_context_schema_data["_metadata"]["name"], config_context_schema_record.name)
+        self.assertEqual(config_context_schema_data["data_schema"], config_context_schema_record.data_schema)
 
     def assert_device_exists(self, name):
         """Helper function to assert device exists"""
@@ -258,7 +159,7 @@ class GitTest(TransactionTestCase):
             {"ntp-servers": ["172.16.10.22", "172.16.10.33"]},
             config_context.data,
         )
-        self.assertEqual(self.config_context_schema["_metadata"]["name"], config_context.config_context_schema.name)
+        self.assertIsNotNone(config_context.config_context_schema)
 
     def assert_implicit_config_context_exists(self, name):
         """Helper function to assert that an 'implicit' ConfigContext exists and is configured appropriately."""
@@ -296,10 +197,10 @@ class GitTest(TransactionTestCase):
         )
         self.assertIsNotNone(export_template_vlan)
 
-    def assert_job_exists(self, installed=True):
+    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?
-        job_model = Job.objects.get(name="MyJob", module_name=f"{self.repo_slug}.jobs.my_job", job_class_name="MyJob")
+        job_model = Job.objects.get(name=name, module_name=f"{self.repo_slug}.jobs.my_job", job_class_name=name)
         self.assertIsNotNone(job_model)
         if installed:
             self.assertTrue(job_model.installed)
@@ -312,20 +213,12 @@ class GitTest(TransactionTestCase):
             with self.assertRaises(NotRegistered):
                 job_model.job_task
 
-    def test_pull_git_repository_and_refresh_data_with_no_data(self, MockGitRepo):
+    def test_pull_git_repository_and_refresh_data_with_no_data(self):
         """
         The pull_git_repository_and_refresh_data job should fail if the given repo is empty.
         """
         with tempfile.TemporaryDirectory() as tempdir:
             with self.settings(GIT_ROOT=tempdir):
-
-                def create_empty_repo(path, url):
-                    os.makedirs(path, exist_ok=True)
-                    return mock.DEFAULT
-
-                MockGitRepo.side_effect = create_empty_repo
-                MockGitRepo.return_value.checkout.return_value = (self.COMMIT_HEXSHA, True)
-
                 # Run the Git operation and refresh the object from the DB
                 # pull_git_repository_and_refresh_data(self.repo.pk, self.mock_request, self.job_result.pk)
                 job_result = create_job_result_and_run_job(
@@ -341,8 +234,6 @@ class GitTest(TransactionTestCase):
                     (job_result.result, list(job_result.job_log_entries.values_list("message", "log_object"))),
                 )
                 self.repo.refresh_from_db()
-                self.assertEqual(self.repo.current_head, self.COMMIT_HEXSHA, job_result.result)
-                MockGitRepo.assert_called_with(os.path.join(tempdir, self.repo.slug), "http://localhost/git.git")
 
                 log_entries = JobLogEntry.objects.filter(job_result=job_result)
                 failure_logs = log_entries.filter(log_level=LogLevelChoices.LOG_ERROR)
@@ -354,20 +245,14 @@ class GitTest(TransactionTestCase):
                     print(job_result.traceback)
                     raise
 
+    @mock.patch("nautobot.extras.datasources.git.GitRepo")
     def test_pull_git_repository_and_refresh_data_with_secrets(self, MockGitRepo):
         """
         The pull_git_repository_and_refresh_data job should correctly make use of secrets.
         """
         with tempfile.TemporaryDirectory() as tempdir:
             with self.settings(GIT_ROOT=tempdir):
-
-                def create_empty_repo(path, url):
-                    os.makedirs(path, exist_ok=True)
-                    return mock.DEFAULT
-
-                MockGitRepo.side_effect = create_empty_repo
-                MockGitRepo.return_value.checkout.return_value = (self.COMMIT_HEXSHA, True)
-
+                MockGitRepo.return_value.checkout.return_value = ("0123456789abcdef", True)
                 with open(os.path.join(tempdir, "username.txt"), "wt") as handle:
                     handle.write("núñez")
 
@@ -399,6 +284,7 @@ class GitTest(TransactionTestCase):
                 )
 
                 self.repo.secrets_group = secrets_group
+                self.repo.remote_url = "http://localhost/git.git"
                 self.repo.provided_contents.remove("extras.job")  # avoid failing due to lack of jobs module
                 self.repo.save()
 
@@ -422,16 +308,15 @@ class GitTest(TransactionTestCase):
                     "http://n%C3%BA%C3%B1ez:1%3A3%40%2F%3F%3Dab%40@localhost/git.git",
                 )
 
-    def test_pull_git_repository_and_refresh_data_with_valid_data(self, MockGitRepo):
+    def test_pull_git_repository_and_refresh_data_with_valid_data(self):
         """
         The test_pull_git_repository_and_refresh_data job should succeed if valid data is present in the repo.
         """
         with tempfile.TemporaryDirectory() as tempdir:
             with self.settings(GIT_ROOT=tempdir):
-                MockGitRepo.side_effect = self.populate_repo
-                MockGitRepo.return_value.checkout.return_value = (self.COMMIT_HEXSHA, True)
-
                 # Run the Git operation and refresh the object from the DB
+                self.repo.branch = "valid-files"  # actually a tag
+                self.repo.save()
                 job_model = GitRepositorySync().job_model
                 job_result = run_job_for_testing(job=job_model, repository=self.repo.pk)
                 job_result.refresh_from_db()
@@ -462,14 +347,23 @@ 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 Job was successfully loaded from file and registered as a JobModel
-                self.assert_job_exists()
+                # Make sure Jobs were successfully loaded from file and registered as JobModels
+                self.assert_job_exists(name="MyJob")
+                self.assert_job_exists(name="MyJobButtonReceiver")
+                self.assert_job_exists(name="MyJobHookReceiver")
 
-                # Now "resync" the repository, but now those files no longer exist in the repository
-                MockGitRepo.side_effect = self.empty_repo
+                # Create JobButton and JobHook
+                JobButton.objects.create(
+                    name="MyJobButton", enabled=True, text="Click me", job=Job.objects.get(name="MyJobButtonReceiver")
+                )
+                JobHook.objects.create(name="MyJobHook", enabled=True, job=Job.objects.get(name="MyJobHookReceiver"))
 
-                # For verisimilitude, don't re-use the old request and job_result
-                self.mock_request.id = uuid.uuid4()
+                # TODO: test successful sync against a branch name or a commit hash as well
+
+                # Now "resync" the repository, but now those files no longer exist in the repository
+                self.repo.refresh_from_db()
+                self.repo.branch = "empty-repo"  # actually a tag
+                self.repo.save()
 
                 # Run the Git operation and refresh the object from the DB
                 job_result = run_job_for_testing(job=job_model, repository=self.repo.pk)
@@ -489,6 +383,7 @@ class GitTest(TransactionTestCase):
                             owner_object_id=self.repo.pk,
                         )
                     ),
+                    list(job_result.job_log_entries.values_list("message", flat=True)),
                 )
                 self.assertEqual(
                     [],
@@ -498,6 +393,7 @@ class GitTest(TransactionTestCase):
                             owner_object_id=self.repo.pk,
                         )
                     ),
+                    list(job_result.job_log_entries.values_list("message", flat=True)),
                 )
                 device = Device.objects.get(name=self.device.name)
                 self.assertIsNone(device.local_config_context_data)
@@ -505,61 +401,23 @@ class GitTest(TransactionTestCase):
 
                 # Verify that Job database record still exists but code is no longer installed/loaded
                 self.assert_job_exists(installed=False)
+                self.assert_job_exists(name="MyJobButtonReceiver", installed=False)
+                self.assert_job_exists(name="MyJobHookReceiver", installed=False)
+
+                # Verify that JobButton and JobHook are auto-disabled since the jobs are no longer available
+                jb = JobButton.objects.get(name="MyJobButton")
+                self.assertFalse(jb.enabled)
+                jh = JobHook.objects.get(name="MyJobHook")
+                self.assertFalse(jh.enabled)
 
-    def test_pull_git_repository_and_refresh_data_with_bad_data(self, MockGitRepo):
+    def test_pull_git_repository_and_refresh_data_with_bad_data(self):
         """
         The test_pull_git_repository_and_refresh_data job should gracefully handle bad data in the Git repository
         """
         with tempfile.TemporaryDirectory() as tempdir:
             with self.settings(GIT_ROOT=tempdir):
-
-                def populate_repo(path, url):
-                    os.makedirs(path, exist_ok=True)
-                    os.makedirs(os.path.join(path, "config_contexts"), exist_ok=True)
-                    os.makedirs(os.path.join(path, "config_contexts", "devices"), exist_ok=True)
-                    os.makedirs(os.path.join(path, "config_context_schemas"), exist_ok=True)
-                    os.makedirs(os.path.join(path, "export_templates", "nosuchapp", "device"), exist_ok=True)
-                    os.makedirs(os.path.join(path, "export_templates", "dcim", "nosuchmodel"), exist_ok=True)
-                    os.makedirs(os.path.join(path, "jobs"), exist_ok=True)
-                    # Incorrect directories
-                    os.makedirs(os.path.join(path, "devices"), exist_ok=True)
-                    os.makedirs(os.path.join(path, "dcim"), exist_ok=True)
-                    with open(os.path.join(path, "__init__.py"), "w") as fd:
-                        pass
-                    # Malformed JSON
-                    with open(os.path.join(path, "config_contexts", "context.json"), "w") as fd:
-                        fd.write('{"data": ')
-                    # Valid JSON but missing required keys
-                    with open(os.path.join(path, "config_contexts", "context2.json"), "w") as fd:
-                        fd.write("{}")
-                    with open(os.path.join(path, "config_contexts", "context3.json"), "w") as fd:
-                        fd.write('{"_metadata": {}}')
-                    # Malformed JSON
-                    with open(os.path.join(path, "config_context_schemas", "schema-1.yaml"), "w") as fd:
-                        fd.write('{"data": ')
-                    # Valid JSON but missing required keys
-                    with open(os.path.join(path, "config_context_schemas", "schema-2.yaml"), "w") as fd:
-                        fd.write("{}")
-                    # No such device
-                    with open(os.path.join(path, "config_contexts", "devices", "nosuchdevice.json"), "w") as fd:
-                        fd.write("{}")
-                    # Invalid paths
-                    with open(os.path.join(path, "export_templates", "nosuchapp", "device", "template.j2"), "w") as fd:
-                        fd.write("{% for device in queryset %}\n{{ device.name }}\n{% endfor %}")
-                    with open(os.path.join(path, "export_templates", "dcim", "nosuchmodel", "template.j2"), "w") as fd:
-                        fd.write("{% for device in queryset %}\n{{ device.name }}\n{% endfor %}")
-                    # Malformed Python
-                    with open(os.path.join(path, "jobs", "syntaxerror.py"), "w") as fd:
-                        fd.write("print(")
-                    with open(os.path.join(path, "jobs", "importerror.py"), "w") as fd:
-                        fd.write("import nosuchmodule")
-                    with open(os.path.join(path, "jobs", "__init__.py"), "w") as fd:
-                        fd.write("import .syntaxerror\nimport .importerror")
-                    return mock.DEFAULT
-
-                MockGitRepo.side_effect = populate_repo
-                MockGitRepo.return_value.checkout.return_value = (self.COMMIT_HEXSHA, True)
-
+                self.repo.branch = "invalid-files"
+                self.repo.save()
                 # Run the Git operation and refresh the object from the DB
                 job_model = GitRepositorySync().job_model
                 self.assertIsNotNone(job_model)
@@ -604,25 +462,25 @@ class GitTest(TransactionTestCase):
                 try:
                     failure_logs.get(
                         grouping="config context schemas",
-                        message__contains="Error in loading config context schema data from `schema-1.yaml`",
+                        message__contains="Error in loading config context schema data from `badschema1.json`",
                     )
                     failure_logs.get(
                         grouping="config context schemas",
-                        message__contains="Error in loading config context schema data from `schema-2.yaml`: "
+                        message__contains="Error in loading config context schema data from `badschema2.json`: "
                         "data is missing the required `_metadata` key",
                     )
                     failure_logs.get(
                         grouping="config contexts",
-                        message__contains="Error in loading config context data from `context.json`",
+                        message__contains="Error in loading config context data from `badcontext1.json`",
                     )
                     failure_logs.get(
                         grouping="config contexts",
-                        message__contains="Error in loading config context data from `context2.json`: "
+                        message__contains="Error in loading config context data from `badcontext2.json`: "
                         "data is missing the required `_metadata` key",
                     )
                     failure_logs.get(
                         grouping="config contexts",
-                        message__contains="Error in loading config context data from `context3.json`: "
+                        message__contains="Error in loading config context data from `badcontext3.json`: "
                         "data `_metadata` is missing the required `name` key",
                     )
                     failure_logs.get(
@@ -640,67 +498,14 @@ class GitTest(TransactionTestCase):
                     print(job_result.traceback)
                     raise
 
-    def test_delete_git_repository_cleanup(self, MockGitRepo):
+    def test_delete_git_repository_cleanup(self):
         """
         When deleting a GitRepository record, the data that it owned should also be deleted.
         """
         with tempfile.TemporaryDirectory() as tempdir:
             with self.settings(GIT_ROOT=tempdir):
-
-                def populate_repo(path, url):
-                    os.makedirs(path, exist_ok=True)
-                    os.makedirs(os.path.join(path, "config_contexts"), exist_ok=True)
-                    os.makedirs(os.path.join(path, "config_contexts", "devices"), exist_ok=True)
-                    os.makedirs(os.path.join(path, "config_context_schemas"), exist_ok=True)
-                    os.makedirs(os.path.join(path, "export_templates", "dcim", "device"), exist_ok=True)
-                    os.makedirs(os.path.join(path, "jobs"), exist_ok=True)
-                    with open(os.path.join(path, "__init__.py"), "w") as fd:
-                        pass
-                    with open(os.path.join(path, "config_contexts", "context.yaml"), "w") as fd:
-                        yaml.dump(
-                            {
-                                "_metadata": {
-                                    "name": "Region NYC servers",
-                                    "weight": 1500,
-                                    "description": "NTP servers for region NYC",
-                                    "is_active": True,
-                                    # Changing this from `config_context_schema` to `schema` to assert that schema can
-                                    # be used inplace of `config_context_schema`.
-                                    # TODO(timizuo): Replace `schema` with `config_context_schema` when `schema`
-                                    #  backwards-compatibility is removed.
-                                    "schema": "Config Context Schema 1",
-                                },
-                                "ntp-servers": ["172.16.10.22", "172.16.10.33"],
-                            },
-                            fd,
-                        )
-                    with open(
-                        os.path.join(path, "config_contexts", "devices", "test-device.json"),
-                        "w",
-                    ) as fd:
-                        json.dump({"dns-servers": ["8.8.8.8"]}, fd)
-                    with open(os.path.join(path, "config_context_schemas", "schema-1.yaml"), "w") as fd:
-                        yaml.dump(self.config_context_schema, fd)
-                    with open(
-                        os.path.join(path, "export_templates", "dcim", "device", "template.j2"),
-                        "w",
-                    ) as fd:
-                        fd.write("{% for device in queryset %}\n{{ device.name }}\n{% endfor %}")
-                    with open(os.path.join(path, "jobs", "__init__.py"), "w") as fd:
-                        fd.write(
-                            "from nautobot.core.celery import register_jobs\nfrom .my_job import MyJob\nregister_jobs(MyJob)"
-                        )
-
-                    with open(os.path.join(path, "jobs", "my_job.py"), "w") as fd:
-                        fd.write(
-                            "from nautobot.extras.jobs import Job\nclass MyJob(Job):\n    def run(self):\n        pass"
-                        )
-
-                    return mock.DEFAULT
-
-                MockGitRepo.side_effect = populate_repo
-                MockGitRepo.return_value.checkout.return_value = (self.COMMIT_HEXSHA, True)
-
+                self.repo.branch = "valid-files"
+                self.repo.save()
                 # Run the Git operation and refresh the object from the DB
                 job_model = GitRepositorySync().job_model
                 job_result = run_job_for_testing(
@@ -717,13 +522,13 @@ class GitTest(TransactionTestCase):
 
                 # Make sure ConfigContext was successfully loaded from file
                 config_context = ConfigContext.objects.get(
-                    name="Region NYC servers",
+                    name="Frobozz 1000 NTP servers",
                     owner_object_id=self.repo.pk,
                     owner_content_type=ContentType.objects.get_for_model(GitRepository),
                 )
                 self.assertIsNotNone(config_context)
                 self.assertEqual(1500, config_context.weight)
-                self.assertEqual("NTP servers for region NYC", config_context.description)
+                self.assertEqual("NTP servers for Frobozz 1000 devices **only**", config_context.description)
                 self.assertTrue(config_context.is_active)
                 self.assertEqual(
                     {"ntp-servers": ["172.16.10.22", "172.16.10.33"]},
@@ -775,19 +580,13 @@ class GitTest(TransactionTestCase):
 
                 self.assert_job_exists(installed=False)
 
-    def test_git_dry_run(self, MockGitRepo):
+    def test_git_dry_run(self):
         with tempfile.TemporaryDirectory() as tempdir:
             with self.settings(GIT_ROOT=tempdir):
-
-                def create_empty_repo(path, url, clone_initially=False):
-                    os.makedirs(path, exist_ok=True)
-                    return mock.DEFAULT
-
-                MockGitRepo.side_effect = create_empty_repo
-                MockGitRepo.return_value.checkout.return_value = (self.COMMIT_HEXSHA, False)
-
                 self.mock_request.id = uuid.uuid4()
 
+                self.repo.branch = "valid-files"
+                self.repo.save()
                 job_model = GitRepositoryDryRun().job_model
                 job_result = run_job_for_testing(
                     job=job_model,
@@ -801,14 +600,33 @@ class GitTest(TransactionTestCase):
                     (job_result.traceback, list(job_result.job_log_entries.values_list("message", flat=True))),
                 )
 
-                MockGitRepo.assert_called_with(
-                    os.path.join(tempdir, self.repo.slug),
-                    self.repo.remote_url,
-                    clone_initially=False,
-                )
-                MockGitRepo.return_value.diff_remote.assert_called()
+                log_entries = JobLogEntry.objects.filter(job_result=job_result)
+
+                try:
+                    log_entries.get(message__contains="Addition - `__init__.py`")
+                    log_entries.get(message__contains="Addition - `config_context_schemas/schema-1.yaml`")
+                    log_entries.get(message__contains="Addition - `config_contexts/context.yaml`")
+                    log_entries.get(message__contains="Addition - `config_contexts/devices/test-device.json`")
+                    log_entries.get(message__contains="Addition - `config_contexts/locations/Test Location.json`")
+                    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 - `jobs/__init__.py`")
+                    log_entries.get(message__contains="Addition - `jobs/my_job.py`")
+                except JobLogEntry.DoesNotExist:
+                    for log in log_entries:
+                        print(log.message)
+                    raise
+
+                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(Job.objects.filter(module_name__startswith=self.repo.slug).exists())
+
+    # TODO: test dry-run against a branch name
+    # TODO: test dry-run against a specific commit hash
 
-    def test_duplicate_repo_url_with_unique_provided_contents(self, MockGitRepo):
+    def test_duplicate_repo_url_with_unique_provided_contents(self):
         """Create a duplicate repo but with unique provided_contents."""
         remote_url = "http://localhost/duplicates.git"
         repo1 = GitRepository(
@@ -828,7 +646,7 @@ class GitTest(TransactionTestCase):
         repos = GitRepository.objects.filter(remote_url=remote_url)
         self.assertEqual(repos.count(), 2)
 
-    def test_duplicate_repo_url_with_duplicate_provided_contents(self, MockGitRepo):
+    def test_duplicate_repo_url_with_duplicate_provided_contents(self):
         """Create a duplicate repo but with duplicate provided_contents."""
         remote_url = "http://localhost/duplicates.git"
         repo1 = GitRepository(