ipfabric_netbox 4.3.0b6__tar.gz → 4.3.0b8__tar.gz

{ipfabric_netbox-4.3.0b6 → ipfabric_netbox-4.3.0b8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ipfabric_netbox
-Version: 4.3.0b6
+Version: 4.3.0b8
 Summary: NetBox plugin to sync IP Fabric data into NetBox
 License: MIT
 Keywords: netbox,ipfabric,plugin,sync

{ipfabric_netbox-4.3.0b6 → ipfabric_netbox-4.3.0b8}/ipfabric_netbox/__init__.py

@@ -6,7 +6,7 @@ class NetboxIPFabricConfig(PluginConfig):
     name = "ipfabric_netbox"
     verbose_name = "NetBox IP Fabric SoT Plugin"
     description = "Sync IP Fabric into NetBox"
-    version = "4.3.0b6"
+    version = "4.3.0b8"
     base_url = "ipfabric"
     min_version = "4.4.0"
 

{ipfabric_netbox-4.3.0b6 → ipfabric_netbox-4.3.0b8}/ipfabric_netbox/api/serializers.py

@@ -176,6 +176,7 @@ class IPFabricSnapshotSerializer(NestedGroupModelSerializer):
 
 class IPFabricSyncSerializer(NestedGroupModelSerializer):
     snapshot_data = IPFabricSnapshotSerializer(nested=True)
+    parameters = serializers.JSONField()
 
     class Meta:
         model = IPFabricSync
@@ -244,3 +245,7 @@ class IPFabricIngestionIssueSerializer(NestedGroupModelSerializer):
             "message",
             "model",
         )
+
+
+class EmptySerializer(serializers.Serializer):
+    pass

{ipfabric_netbox-4.3.0b6 → ipfabric_netbox-4.3.0b8}/ipfabric_netbox/api/views.py

@@ -1,10 +1,15 @@
+from core.api.serializers_.jobs import JobSerializer
+from django.core.exceptions import PermissionDenied
 from django.db import transaction
+from django.http import HttpResponseBadRequest
+from drf_spectacular.utils import extend_schema
 from netbox.api.viewsets import NetBoxModelViewSet
 from netbox.api.viewsets import NetBoxReadOnlyModelViewSet
 from rest_framework.decorators import action
 from rest_framework.response import Response
 from utilities.query import count_related
 
+from .serializers import EmptySerializer
 from .serializers import IPFabricIngestionIssueSerializer
 from .serializers import IPFabricIngestionSerializer
 from .serializers import IPFabricRelationshipFieldSerializer
@@ -56,6 +61,27 @@ class IPFabricSyncViewSet(NetBoxModelViewSet):
     queryset = IPFabricSync.objects.all()
     serializer_class = IPFabricSyncSerializer
 
+    @extend_schema(
+        methods=["post"],
+        request=EmptySerializer(),
+        responses={201: JobSerializer()},
+    )
+    @action(detail=True, methods=["post"])
+    def sync(self, request, pk):
+        if not request.user.has_perm("ipfabric_netbox.sync_ipfabricsync"):
+            raise PermissionDenied(
+                "This user does not have permission to sync IPFabricSync."
+            )
+        sync = self.get_object()
+        if not sync.ready_for_sync:
+            return HttpResponseBadRequest(
+                f"Sync '{sync.name}' is not ready to be synced."
+            )
+        job = sync.enqueue_sync_job(user=request.user, adhoc=True)
+        return Response(
+            JobSerializer(job, context={"request": request}).data, status=201
+        )
+
 
 class IPFabricIngestionViewSet(NetBoxReadOnlyModelViewSet):
     queryset = IPFabricIngestion.objects.all()
@@ -122,3 +148,24 @@ class IPFabricSourceViewSet(NetBoxModelViewSet):
     )
     serializer_class = IPFabricSourceSerializer
     filterset_class = IPFabricSourceFilterSet
+
+    @extend_schema(
+        methods=["post"],
+        request=EmptySerializer(),
+        responses={201: JobSerializer()},
+    )
+    @action(detail=True, methods=["post"])
+    def sync(self, request, pk):
+        if not request.user.has_perm("ipfabric_netbox.sync_ipfabricsource"):
+            raise PermissionDenied(
+                "This user does not have permission to sync IPFabricSource."
+            )
+        source = self.get_object()
+        if not source.ready_for_sync:
+            return HttpResponseBadRequest(
+                f"Source '{source.name}' is not ready to be synced."
+            )
+        job = source.enqueue_sync_job(request=request)
+        return Response(
+            JobSerializer(job, context={"request": request}).data, status=201
+        )

{ipfabric_netbox-4.3.0b6 → ipfabric_netbox-4.3.0b8}/ipfabric_netbox/forms.py

@@ -802,11 +802,7 @@ class IPFabricSyncForm(NetBoxModelForm):
                 ]
         self.instance.parameters = parameters
         self.instance.status = DataSourceStatusChoices.NEW
-
-        object = super().save(*args, **kwargs)
-        if object.scheduled:
-            object.enqueue_sync_job()
-        return object
+        return super().save(*args, **kwargs)
 
 
 class IPFabricSyncBulkEditForm(NetBoxModelBulkEditForm):

{ipfabric_netbox-4.3.0b6 → ipfabric_netbox-4.3.0b8}/ipfabric_netbox/jobs.py

@@ -4,7 +4,6 @@ from datetime import timedelta
 from core.choices import DataSourceStatusChoices
 from core.choices import JobStatusChoices
 from core.exceptions import SyncError
-from core.models import Job
 from netbox.context_managers import event_tracking
 from rq.timeouts import JobTimeoutException
 from utilities.datetime import local_now
@@ -36,15 +35,15 @@ def sync_ipfabricsource(job, *args, **kwargs):
 
 
 def sync_ipfabric(job, *args, **kwargs):
-    obj = IPFabricSync.objects.get(pk=job.object_id)
+    sync = IPFabricSync.objects.get(pk=job.object_id)
 
     try:
         job.start()
-        obj.sync(job=job)
+        sync.sync(job=job)
         job.terminate()
     except Exception as e:
         job.terminate(status=JobStatusChoices.STATUS_ERRORED)
-        IPFabricSync.objects.filter(pk=obj.pk).update(
+        IPFabricSync.objects.filter(pk=sync.pk).update(
             status=DataSourceStatusChoices.FAILED
         )
         if type(e) in (SyncError, JobTimeoutException):
@@ -52,15 +51,38 @@ def sync_ipfabric(job, *args, **kwargs):
         else:
             raise e
     finally:
-        if obj.interval and not kwargs.get("adhoc"):
-            new_scheduled_time = local_now() + timedelta(minutes=obj.interval)
-            job = Job.enqueue(
-                sync_ipfabric,
-                name=f"{obj.name} - (scheduled)",
-                instance=obj,
-                user=obj.user,
-                schedule_at=new_scheduled_time,
-                interval=obj.interval,
+        if sync.interval and not kwargs.get("adhoc"):
+            new_scheduled_time = local_now() + timedelta(minutes=sync.interval)
+            # We want to create new Job only if scheduled time was before this Job started
+            # The current sync might have been changed while this job was running
+            sync.refresh_from_db()
+            if not sync.scheduled or (sync.scheduled and sync.scheduled > job.started):
+                logger.info(
+                    f"Not scheduling a new job for IPFabricSync {sync.pk} as the scheduled time was changed while the job was running."
+                )
+                return
+            # Update the sync object with the new scheduled time
+            # This also triggers the creation of a new Job
+            # Running in fake request context to ensure user is set for changelog
+            request = NetBoxFakeRequest(
+                {
+                    "META": {},
+                    "POST": sync.parameters,
+                    "GET": {},
+                    "FILES": {},
+                    "user": sync.user,
+                    "path": "",
+                    "id": job.job_id,
+                }
+            )
+
+            with event_tracking(request):
+                sync.scheduled = new_scheduled_time
+                sync.status = DataSourceStatusChoices.QUEUED
+                sync.full_clean()
+                sync.save()
+            logger.info(
+                f"Scheduled next sync for IPFabricSync {sync.pk} at {new_scheduled_time}."
             )
 
 

ipfabric_netbox-4.3.0b8/ipfabric_netbox/migrations/0020_clean_scheduled_jobs.py

@@ -0,0 +1,70 @@
+from datetime import timedelta
+from typing import TYPE_CHECKING
+
+from django.db import migrations
+from utilities.datetime import local_now
+
+if TYPE_CHECKING:
+    from django.apps import apps as apps_type
+    from django.db.backends.base.schema import BaseDatabaseSchemaEditor
+
+
+def clean_scheduled_jobs(
+    apps: "apps_type", schema_editor: "BaseDatabaseSchemaEditor"
+) -> None:
+    Job = apps.get_model("core", "Job")
+    IPFabricSync = apps.get_model("ipfabric_netbox", "IPFabricSync")
+    ObjectType = apps.get_model("core", "ObjectType")
+
+    for sync in IPFabricSync.objects.all():
+        try:
+            scheduled_jobs = Job.objects.filter(
+                object_id=sync.id,
+                object_type=ObjectType.objects.get_for_model(sync),
+                scheduled__isnull=False,
+            ).order_by("scheduled")
+            if not scheduled_jobs.exists():
+                continue
+            if not sync.scheduled:
+                # Delete all scheduled jobs if the sync is not scheduled
+                scheduled_jobs.delete()
+                continue
+            if scheduled_jobs.count() == 1:
+                # Only one scheduled job exists, let's update scheduled time on the sync object
+                # This does not create a new job since sync is a Faked object in migration
+                sync.scheduled = scheduled_jobs.first().scheduled
+                sync.full_clean()
+                sync.save()
+                continue
+            # More than one scheduled job exists
+            # Find the one that is closest to scheduled + N * interval
+            interval = timedelta(minutes=sync.interval)
+            elapsed = local_now() - sync.scheduled
+            intervals_passed = (elapsed // interval) + 1
+            closest_future_scheduled = sync.scheduled + intervals_passed * interval
+            closest_job = min(
+                scheduled_jobs,
+                key=lambda job: abs(job.scheduled - closest_future_scheduled),
+            )
+            for job in scheduled_jobs:
+                if job != closest_job:
+                    job.delete()
+            sync.scheduled = closest_job.scheduled
+            sync.full_clean()
+            sync.save()
+        except Exception as err:
+            # Always be safe inside a migration
+            print(f"Error cleaning scheduled jobs for IPFabricSync {sync.id}: {err}")
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        (
+            "ipfabric_netbox",
+            "0019_alter_ipfabrictransformmap_options_and_more",
+        ),
+    ]
+
+    operations = [
+        migrations.RunPython(clean_scheduled_jobs, migrations.RunPython.noop),
+    ]

{ipfabric_netbox-4.3.0b6 → ipfabric_netbox-4.3.0b8}/ipfabric_netbox/models.py

@@ -8,6 +8,7 @@ from uuid import uuid4
 
 import httpx
 from core.choices import DataSourceStatusChoices
+from core.choices import JobStatusChoices
 from core.exceptions import SyncError
 from core.models import Job
 from core.models import ObjectType
@@ -669,6 +670,11 @@ class IPFabricSync(IPFabricClient, JobsMixin, TagsMixin, ChangeLoggedModel):
     def get_status_color(self):
         return DataSourceStatusChoices.colors.get(self.status)
 
+    def save(self, *args, **kwargs):
+        super().save(*args, **kwargs)
+        if self.scheduled:
+            self.enqueue_sync_job()
+
     @property
     def ready_for_sync(self):
         if self.status not in (DataSourceStatusChoices.SYNCING,):
@@ -705,32 +711,56 @@ class IPFabricSync(IPFabricClient, JobsMixin, TagsMixin, ChangeLoggedModel):
             pk__in=[tm.pk for tm in maps_by_target.values()]
         )
 
-    def enqueue_sync_job(self, adhoc=False, user=None):
-        # Set the status to "syncing"
-        self.status = DataSourceStatusChoices.QUEUED
-        IPFabricSync.objects.filter(pk=self.pk).update(status=self.status)
-
-        Job.enqueue(
-            import_string("ipfabric_netbox.jobs.sync_ipfabricsource"),
-            name=f"{self.name} Snapshot Sync (Pre Ingestion)",
-            instance=self.snapshot_data.source,
-            user=self.user,
-        )
+    def delete_scheduled_jobs(self) -> None:
+        Job.objects.filter(
+            object_type=ObjectType.objects.get_for_model(self),
+            object_id=self.pk,
+            status__in=[
+                JobStatusChoices.STATUS_PENDING,
+                JobStatusChoices.STATUS_SCHEDULED,
+            ],
+        ).delete()
+
+    def enqueue_sync_job(self, adhoc=False, user=None) -> Job | None:
+        def set_syncing_status():
+            self.status = DataSourceStatusChoices.QUEUED
+            IPFabricSync.objects.filter(pk=self.pk).update(status=self.status)
+
+        def sync_snapshots():
+            Job.enqueue(
+                import_string("ipfabric_netbox.jobs.sync_ipfabricsource"),
+                name=f"{self.name} Snapshot Sync (Pre Ingestion)",
+                instance=self.snapshot_data.source,
+                user=self.user,
+            )
 
         # Enqueue a sync job
         if not user:
             user = self.user
 
-        if not adhoc and self.scheduled:
-            job = Job.enqueue(
-                import_string("ipfabric_netbox.jobs.sync_ipfabric"),
-                name=f"{self.name} - (scheduled)",
-                instance=self,
-                user=self.user,
-                schedule_at=self.scheduled,
-                interval=self.interval,
-            )
-        elif adhoc:
+        if not adhoc:
+            if self.scheduled:
+                # We want to schedule a recurring Job
+                # We need to replace the old scheduled Job to make sure it has current context
+                self.delete_scheduled_jobs()
+                set_syncing_status()
+                sync_snapshots()
+                job = Job.enqueue(
+                    import_string("ipfabric_netbox.jobs.sync_ipfabric"),
+                    name=f"{self.name} - (scheduled)",
+                    instance=self,
+                    user=self.user,
+                    schedule_at=self.scheduled,
+                    interval=self.interval,
+                )
+            else:
+                # There should be no scheduled Job anymore, clean it up
+                self.delete_scheduled_jobs()
+                job = None
+        else:
+            # Start adhoc job immediately
+            set_syncing_status()
+            sync_snapshots()
             job = Job.enqueue(
                 import_string("ipfabric_netbox.jobs.sync_ipfabric"),
                 instance=self,

{ipfabric_netbox-4.3.0b6 → ipfabric_netbox-4.3.0b8}/ipfabric_netbox/templates/ipfabric_netbox/ipfabricsync.html

@@ -58,7 +58,7 @@
           </tr>
           <tr>
             <th scope="row">Schedule</th>
-            <td><div>{{ object.scheduled }}</div></td>
+            <td><div>{% if scheduled_job %}<a href="{% url 'core:job' pk=scheduled_job.pk %}">{{ object.scheduled }}</a>{% else %} {{ object.scheduled | placeholder }} {% endif %}</div></td>
           </tr>
           <tr>
             <th scope="row">Interval</th>

{ipfabric_netbox-4.3.0b6 → ipfabric_netbox-4.3.0b8}/ipfabric_netbox/tests/api/test_api.py

@@ -1,3 +1,4 @@
+from core.choices import DataSourceStatusChoices
 from django.contrib.contenttypes.models import ContentType
 from django.utils import timezone
 from rest_framework import status
@@ -15,7 +16,7 @@ from ipfabric_netbox.models import IPFabricTransformMap
 from ipfabric_netbox.models import IPFabricTransformMapGroup
 
 
-BASE = "/api/plugins/ipfabric/"
+BASE = "/api/plugins/ipfabric"
 
 
 class IPFabricTransformMapGroupTest(APIViewTestCases.APIViewTestCase):
@@ -36,10 +37,10 @@ class IPFabricTransformMapGroupTest(APIViewTestCases.APIViewTestCase):
     }
 
     def _get_list_url(self):
-        return f"{BASE}transform-map-group/"
+        return f"{BASE}/transform-map-group/"
 
     def _get_detail_url(self, instance):
-        return f"{BASE}transform-map-group/{instance.pk}/"
+        return f"{BASE}/transform-map-group/{instance.pk}/"
 
     @classmethod
     def setUpTestData(cls):
@@ -62,10 +63,10 @@ class IPFabricTransformMapTest(APIViewTestCases.APIViewTestCase):
     ]
 
     def _get_list_url(self):
-        return f"{BASE}transform-map/"
+        return f"{BASE}/transform-map/"
 
     def _get_detail_url(self, instance):
-        return f"{BASE}transform-map/{instance.pk}/"
+        return f"{BASE}/transform-map/{instance.pk}/"
 
     @classmethod
     def setUpTestData(cls):
@@ -132,10 +133,10 @@ class IPFabricTransformFieldTest(APIViewTestCases.APIViewTestCase):
     ]
 
     def _get_list_url(self):
-        return f"{BASE}transform-field/"
+        return f"{BASE}/transform-field/"
 
     def _get_detail_url(self, instance):
-        return f"{BASE}transform-field/{instance.pk}/"
+        return f"{BASE}/transform-field/{instance.pk}/"
 
     @classmethod
     def setUpTestData(cls):
@@ -235,10 +236,10 @@ class IPFabricRelationshipFieldTest(APIViewTestCases.APIViewTestCase):
     ]
 
     def _get_list_url(self):
-        return f"{BASE}relationship-field/"
+        return f"{BASE}/relationship-field/"
 
     def _get_detail_url(self, instance):
-        return f"{BASE}relationship-field/{instance.pk}/"
+        return f"{BASE}/relationship-field/{instance.pk}/"
 
     @classmethod
     def setUpTestData(cls):
@@ -340,10 +341,10 @@ class IPFabricSourceTest(APIViewTestCases.APIViewTestCase):
     graphql_base_name = "ipfabric_source"
 
     def _get_list_url(self):
-        return f"{BASE}source/"
+        return f"{BASE}/source/"
 
     def _get_detail_url(self, instance):
-        return f"{BASE}source/{instance.pk}/"
+        return f"{BASE}/source/{instance.pk}/"
 
     @classmethod
     def setUpTestData(cls):
@@ -387,6 +388,66 @@ class IPFabricSourceTest(APIViewTestCases.APIViewTestCase):
             },
         ]
 
+    def test_sync_action_success(self):
+        """Test successful sync action with proper permissions and ready source."""
+        self.add_permissions(
+            "ipfabric_netbox.add_ipfabricsource",
+            "ipfabric_netbox.sync_ipfabricsource",
+        )
+        # Get the first source from setUpTestData
+        source = IPFabricSource.objects.first()
+        # Set status to make ready_for_sync return True
+        source.status = DataSourceStatusChoices.COMPLETED
+        source.save()
+
+        with self.settings(CELERY_TASK_ALWAYS_EAGER=True):
+            # Create a mock job object to simulate enqueue_sync_job response
+            from unittest.mock import Mock, patch
+
+            mock_job = Mock()
+            mock_job.id = "test-job-123"
+            mock_job.status = "queued"
+
+            with patch.object(source, "enqueue_sync_job", return_value=mock_job):
+                url = f"{BASE}/source/{source.pk}/sync/"
+                response = self.client.post(url, **self.header)
+
+                self.assertHttpStatus(response, status.HTTP_201_CREATED)
+                self.assertIn("id", response.data)
+
+    def test_sync_action_permission_denied(self):
+        """Test sync action without proper permissions."""
+        # Note: Not adding sync_ipfabricsource permission
+        self.add_permissions(
+            "ipfabric_netbox.add_ipfabricsource",
+        )
+
+        source = IPFabricSource.objects.first()
+        url = f"{BASE}/source/{source.pk}/sync/"
+        response = self.client.post(url, **self.header)
+
+        self.assertHttpStatus(response, status.HTTP_403_FORBIDDEN)
+
+    def test_sync_action_not_ready(self):
+        """Test sync action when source is not ready for sync."""
+        self.add_permissions(
+            "ipfabric_netbox.add_ipfabricsource",
+            "ipfabric_netbox.sync_ipfabricsource",
+        )
+
+        source = IPFabricSource.objects.first()
+        # Set status to make ready_for_sync return False
+        source.status = DataSourceStatusChoices.SYNCING
+        source.save()
+
+        url = f"{BASE}/source/{source.pk}/sync/"
+        response = self.client.post(url, **self.header)
+
+        self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
+        self.assertIn(
+            f"Source '{source.name}' is not ready to be synced.", str(response.content)
+        )
+
 
 class IPFabricSnapshotTest(
     APIViewTestCases.GetObjectViewTestCase,
@@ -407,10 +468,10 @@ class IPFabricSnapshotTest(
     ]
 
     def _get_list_url(self):
-        return f"{BASE}snapshot/"
+        return f"{BASE}/snapshot/"
 
     def _get_detail_url(self, instance):
-        return f"{BASE}snapshot/{instance.pk}/"
+        return f"{BASE}/snapshot/{instance.pk}/"
 
     @classmethod
     def setUpTestData(cls):
@@ -468,7 +529,7 @@ class IPFabricSnapshotTest(
     def test_sites_action_lists_all_and_filters(self):
         self.add_permissions("ipfabric_netbox.view_ipfabricsnapshot")
         # list all
-        url = f"{BASE}snapshot/{self.snapshots[0].pk}/sites/"
+        url = f"{BASE}/snapshot/{self.snapshots[0].pk}/sites/"
         resp = self.client.get(url, **self.header)
         self.assertHttpStatus(resp, status.HTTP_200_OK)
         body = resp.json()
@@ -477,7 +538,7 @@ class IPFabricSnapshotTest(
             labels = [i["name"] for i in body["results"]]
             self.assertEqual(labels, self.snapshots[0].data["sites"])
         # filter
-        url = f"{BASE}snapshot/{self.snapshots[0].pk}/sites/?q=site"
+        url = f"{BASE}/snapshot/{self.snapshots[0].pk}/sites/?q=site"
         resp = self.client.get(url, **self.header)
         self.assertHttpStatus(resp, status.HTTP_200_OK)
         body = resp.json()
@@ -496,7 +557,7 @@ class IPFabricSnapshotTest(
             IPFabricData.objects.filter(snapshot_data=self.snapshots[0]).count(), 0
         )
         # PATCH raw
-        url = f"{BASE}snapshot/{self.snapshots[0].pk}/raw/"
+        url = f"{BASE}/snapshot/{self.snapshots[0].pk}/raw/"
         payload = {
             "data": [
                 {"data": {"example": 1}, "type": "device"},
@@ -550,10 +611,10 @@ class IPFabricSyncTest(APIViewTestCases.APIViewTestCase):
     }
 
     def _get_list_url(self):
-        return f"{BASE}sync/"
+        return f"{BASE}/sync/"
 
     def _get_detail_url(self, instance):
-        return f"{BASE}sync/{instance.pk}/"
+        return f"{BASE}/sync/{instance.pk}/"
 
     @classmethod
     def setUpTestData(cls):
@@ -637,6 +698,72 @@ class IPFabricSyncTest(APIViewTestCases.APIViewTestCase):
         cls.create_data[1]["parameters"] = {"ipaddress": True, "prefix": True}
         cls.create_data[2]["parameters"] = {"device": True, "interface": True}
 
+    def test_sync_action_success(self):
+        """Test successful sync action with proper permissions and ready sync."""
+        self.add_permissions(
+            "ipfabric_netbox.add_ipfabricsync",
+            "ipfabric_netbox.sync_ipfabricsync",
+        )
+        # Get the first sync from setUpTestData
+        sync = IPFabricSync.objects.first()
+        # Set status and ensure snapshot has data to make ready_for_sync return True
+        sync.status = DataSourceStatusChoices.COMPLETED
+        sync.save()
+
+        # Ensure the snapshot has data
+        sync.snapshot_data.source.type = (
+            "local"  # For local type, ready_for_sync checks are simpler
+        )
+        sync.snapshot_data.source.save()
+
+        with self.settings(CELERY_TASK_ALWAYS_EAGER=True):
+            # Create a mock job object to simulate enqueue_sync_job response
+            from unittest.mock import Mock, patch
+
+            mock_job = Mock()
+            mock_job.id = "test-sync-job-456"
+            mock_job.status = "queued"
+
+            with patch.object(sync, "enqueue_sync_job", return_value=mock_job):
+                url = f"{BASE}/sync/{sync.pk}/sync/"
+                response = self.client.post(url, **self.header)
+
+                self.assertHttpStatus(response, status.HTTP_201_CREATED)
+                self.assertIn("id", response.data)
+
+    def test_sync_action_permission_denied(self):
+        """Test sync action without proper permissions."""
+        # Note: Not adding sync_ipfabricsource permission
+        self.add_permissions(
+            "ipfabric_netbox.add_ipfabricsync",
+        )
+
+        sync = IPFabricSync.objects.first()
+        url = f"{BASE}/sync/{sync.pk}/sync/"
+        response = self.client.post(url, **self.header)
+
+        self.assertHttpStatus(response, status.HTTP_403_FORBIDDEN)
+
+    def test_sync_action_not_ready(self):
+        """Test sync action when sync is not ready for sync."""
+        self.add_permissions(
+            "ipfabric_netbox.add_ipfabricsync",
+            "ipfabric_netbox.sync_ipfabricsync",
+        )
+
+        sync = IPFabricSync.objects.first()
+        # Set status to make ready_for_sync return False
+        sync.status = DataSourceStatusChoices.SYNCING
+        sync.save()
+
+        url = f"{BASE}/sync/{sync.pk}/sync/"
+        response = self.client.post(url, **self.header)
+
+        self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
+        self.assertIn(
+            f"Sync '{sync.name}' is not ready to be synced.", str(response.content)
+        )
+
 
 class IPFabricIngestionTest(
     APIViewTestCases.GetObjectViewTestCase,
@@ -653,10 +780,10 @@ class IPFabricIngestionTest(
     ]
 
     def _get_list_url(self):
-        return f"{BASE}ingestion/"
+        return f"{BASE}/ingestion/"
 
     def _get_detail_url(self, instance):
-        return f"{BASE}ingestion/{instance.pk}/"
+        return f"{BASE}/ingestion/{instance.pk}/"
 
     @classmethod
     def setUpTestData(cls):
@@ -754,10 +881,10 @@ class IPFabricIngestionIssueTest(
     ]
 
     def _get_list_url(self):
-        return f"{BASE}ingestion-issues/"
+        return f"{BASE}/ingestion-issues/"
 
     def _get_detail_url(self, instance):
-        return f"{BASE}ingestion-issues/{instance.pk}/"
+        return f"{BASE}/ingestion-issues/{instance.pk}/"
 
     @classmethod
     def setUpTestData(cls):

{ipfabric_netbox-4.3.0b6 → ipfabric_netbox-4.3.0b8}/ipfabric_netbox/tests/test_views.py

@@ -1,4 +1,5 @@
 import random
+from datetime import timedelta
 from unittest.mock import patch
 from uuid import uuid4
 
@@ -611,7 +612,7 @@ class IPFabricSyncTestCase(
     # ViewTestCases.BulkImportObjectsViewTestCase,
 ):
     model = IPFabricSync
-    user_permissions = ("ipfabric_netbox.start_ipfabricsync",)
+    user_permissions = ("ipfabric_netbox.sync_ipfabricsync",)
 
     @classmethod
     def setUpTestData(cls):
@@ -656,6 +657,8 @@ class IPFabricSyncTestCase(
                 status=DataSourceStatusChoices.NEW,
                 parameters=get_parameters(),
                 last_synced=timezone.now(),
+                scheduled=timezone.now() + timedelta(hours=6),
+                interval=123456,
             ),
             IPFabricSync(
                 name="Sync Job 2",
@@ -716,7 +719,7 @@ class IPFabricSyncTestCase(
 
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
     def test_get_htmx_request(self):
-        instance = self._get_queryset().first()
+        instance = self._get_queryset().last()
         # Try GET with HTMX
         response = self.client.get(
             instance.get_absolute_url(), **{"HTTP_HX-Request": "true"}

{ipfabric_netbox-4.3.0b6 → ipfabric_netbox-4.3.0b8}/ipfabric_netbox/views.py

@@ -782,7 +782,15 @@ class IPFabricSyncView(generic.ObjectView):
 
         last_ingestion = instance.ipfabricingestion_set.last()
 
-        return {"format": format, "last_ingestion": last_ingestion}
+        scheduled_job = None
+        if instance.scheduled:
+            scheduled_job = instance.jobs.filter(scheduled=instance.scheduled).last()
+
+        return {
+            "format": format,
+            "last_ingestion": last_ingestion,
+            "scheduled_job": scheduled_job,
+        }
 
 
 @register_model_view(IPFabricSync, "sync")
@@ -790,7 +798,7 @@ class IPFabricStartSyncView(BaseObjectView):
     queryset = IPFabricSync.objects.all()
 
     def get_required_permission(self):
-        return "ipfabric_netbox.start_ipfabricsync"
+        return "ipfabric_netbox.sync_ipfabricsync"
 
     def get(self, request, pk):
         ipfabric = get_object_or_404(self.queryset, pk=pk)

{ipfabric_netbox-4.3.0b6 → ipfabric_netbox-4.3.0b8}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "ipfabric_netbox"
-version = "4.3.0b6"
+version = "4.3.0b8"
 description = "NetBox plugin to sync IP Fabric data into NetBox"
 authors = ["Solution Architecture <solution.architecture@ipfabric.io>"]
 license = "MIT"