ipfabric_netbox 4.3.2b9__py3-none-any.whl → 4.3.2b10__py3-none-any.whl

ipfabric_netbox/tests/api/test_api.py

@@ -3,9 +3,13 @@ from django.utils import timezone
 from rest_framework import status
 from utilities.testing import APIViewTestCases
 
+from ipfabric_netbox.choices import IPFabricFilterTypeChoices
 from ipfabric_netbox.choices import IPFabricSourceStatusChoices
 from ipfabric_netbox.choices import IPFabricSyncStatusChoices
 from ipfabric_netbox.models import IPFabricData
+from ipfabric_netbox.models import IPFabricEndpoint
+from ipfabric_netbox.models import IPFabricFilter
+from ipfabric_netbox.models import IPFabricFilterExpression
 from ipfabric_netbox.models import IPFabricIngestion
 from ipfabric_netbox.models import IPFabricIngestionIssue
 from ipfabric_netbox.models import IPFabricRelationshipField
@@ -25,6 +29,7 @@ class IPFabricTransformMapGroupTest(APIViewTestCases.APIViewTestCase):
     graphql_base_name = "ipfabric_transform_map_group"
     brief_fields = [
         "description",
+        "display",
         "id",
         "name",
     ]
@@ -56,10 +61,11 @@ class IPFabricTransformMapTest(APIViewTestCases.APIViewTestCase):
     model = IPFabricTransformMap
     graphql_base_name = "ipfabric_transform_map"
     brief_fields = [
+        "display",
         "group",
         "id",
         "name",
-        "source_model",
+        "source_endpoint",
         "target_model",
     ]
 
@@ -77,20 +83,32 @@ class IPFabricTransformMapTest(APIViewTestCases.APIViewTestCase):
             IPFabricTransformMapGroup.objects.create(name="Group C"),
         )
 
+        # Get existing endpoints created by migrations
+        endpoints = {
+            "site": IPFabricEndpoint.objects.get(endpoint="/inventory/sites/overview"),
+            "device": IPFabricEndpoint.objects.get(endpoint="/inventory/devices"),
+            "ipaddress": IPFabricEndpoint.objects.get(
+                endpoint="/technology/addressing/managed-ip/ipv4"
+            ),
+            "vrf": IPFabricEndpoint.objects.get(
+                endpoint="/technology/routing/vrf/detail"
+            ),
+        }
+
         IPFabricTransformMap.objects.create(
             name="TransformMap D",
-            source_model="site",
+            source_endpoint=endpoints["site"],
             target_model=ContentType.objects.get(app_label="dcim", model="site"),
         )
         IPFabricTransformMap.objects.create(
             name="TransformMap E",
-            source_model="site",
+            source_endpoint=endpoints["site"],
             target_model=ContentType.objects.get(app_label="dcim", model="site"),
             group=groups[0],
         )
         IPFabricTransformMap.objects.create(
             name="TransformMap F",
-            source_model="ipaddress",
+            source_endpoint=endpoints["ipaddress"],
             target_model=ContentType.objects.get(app_label="ipam", model="ipaddress"),
             group=groups[0],
         )
@@ -98,19 +116,19 @@ class IPFabricTransformMapTest(APIViewTestCases.APIViewTestCase):
         cls.create_data = [
             {
                 "name": "Transform Map A",
-                "source_model": "site",
+                "source_endpoint": endpoints["site"].pk,
                 "target_model": "dcim.site",
                 "group": groups[1].pk,
             },
             {
                 "name": "Transform Map B",
-                "source_model": "device",
+                "source_endpoint": endpoints["device"].pk,
                 "target_model": "dcim.device",
                 "group": groups[1].pk,
             },
             {
                 "name": "Transform Map C",
-                "source_model": "vrf",
+                "source_endpoint": endpoints["vrf"].pk,
                 "target_model": "ipam.vrf",
                 "group": groups[1].pk,
             },
@@ -126,6 +144,7 @@ class IPFabricTransformFieldTest(APIViewTestCases.APIViewTestCase):
     # in this case brief fields are the same, but they are needed fot the test
     brief_fields = [
         "coalesce",
+        "display",
         "id",
         "source_field",
         "target_field",
@@ -148,23 +167,32 @@ class IPFabricTransformFieldTest(APIViewTestCases.APIViewTestCase):
             IPFabricTransformMapGroup.objects.create(name="Field Test Group C"),
         )
 
+        # Get existing endpoints created by migrations
+        endpoints = {
+            "site": IPFabricEndpoint.objects.get(endpoint="/inventory/sites/overview"),
+            "device": IPFabricEndpoint.objects.get(endpoint="/inventory/devices"),
+            "ipaddress": IPFabricEndpoint.objects.get(
+                endpoint="/technology/addressing/managed-ip/ipv4"
+            ),
+        }
+
         # Create transform maps for the fields to reference
         transform_maps = [
             IPFabricTransformMap.objects.create(
                 name="Field Map A",
-                source_model="site",
+                source_endpoint=endpoints["site"],
                 target_model=ContentType.objects.get(app_label="dcim", model="site"),
                 group=groups[0],
             ),
             IPFabricTransformMap.objects.create(
                 name="Field Map B",
-                source_model="device",
+                source_endpoint=endpoints["device"],
                 target_model=ContentType.objects.get(app_label="dcim", model="device"),
                 group=groups[0],
             ),
             IPFabricTransformMap.objects.create(
                 name="Field Map C",
-                source_model="ipaddress",
+                source_endpoint=endpoints["ipaddress"],
                 target_model=ContentType.objects.get(
                     app_label="ipam", model="ipaddress"
                 ),
@@ -229,6 +257,7 @@ class IPFabricRelationshipFieldTest(APIViewTestCases.APIViewTestCase):
     # in this case brief fields are the same, but they are needed fot the test
     brief_fields = [
         "coalesce",
+        "display",
         "id",
         "source_model",
         "target_field",
@@ -251,23 +280,32 @@ class IPFabricRelationshipFieldTest(APIViewTestCases.APIViewTestCase):
             IPFabricTransformMapGroup.objects.create(name="Relationship Test Group C"),
         )
 
+        # Get existing endpoints created by migrations
+        endpoints = {
+            "site": IPFabricEndpoint.objects.get(endpoint="/inventory/sites/overview"),
+            "device": IPFabricEndpoint.objects.get(endpoint="/inventory/devices"),
+            "ipaddress": IPFabricEndpoint.objects.get(
+                endpoint="/technology/addressing/managed-ip/ipv4"
+            ),
+        }
+
         # Create transform maps for the relationship fields to reference
         transform_maps = [
             IPFabricTransformMap.objects.create(
                 name="Relationship Map A",
-                source_model="site",
+                source_endpoint=endpoints["site"],
                 target_model=ContentType.objects.get(app_label="dcim", model="site"),
                 group=groups[0],
             ),
             IPFabricTransformMap.objects.create(
                 name="Relationship Map B",
-                source_model="device",
+                source_endpoint=endpoints["device"],
                 target_model=ContentType.objects.get(app_label="dcim", model="device"),
                 group=groups[0],
             ),
             IPFabricTransformMap.objects.create(
                 name="Relationship Map C",
-                source_model="ipaddress",
+                source_endpoint=endpoints["ipaddress"],
                 target_model=ContentType.objects.get(
                     app_label="ipam", model="ipaddress"
                 ),
@@ -547,6 +585,30 @@ class IPFabricSnapshotTest(
             labels = [i["name"].lower() for i in body["results"]]
             self.assertTrue(all("site" in name for name in labels))
 
+    def test_sites_action_with_no_data(self):
+        """Test sites endpoint when snapshot.data is None."""
+        self.add_permissions("ipfabric_netbox.view_ipfabricsnapshot")
+
+        # Create a snapshot with data=None
+        source = IPFabricSource.objects.first()
+        snapshot_no_data = IPFabricSnapshot.objects.create(
+            name="Snapshot No Data",
+            source=source,
+            snapshot_id="snap-no-data",
+            status="unloaded",
+            data=None,
+            date=timezone.now(),
+            last_updated=timezone.now(),
+        )
+
+        # Call sites endpoint on snapshot with no data
+        url = f"{BASE}/snapshot/{snapshot_no_data.pk}/sites/"
+        resp = self.client.get(url, **self.header)
+        self.assertHttpStatus(resp, status.HTTP_200_OK)
+        body = resp.json()
+        # Should return empty list when data is None
+        self.assertEqual(body, [])
+
     def test_raw_patch_and_delete(self):
         self.add_permissions(
             "ipfabric_netbox.view_ipfabricsnapshot",
@@ -585,6 +647,7 @@ class IPFabricSyncTest(APIViewTestCases.APIViewTestCase):
     graphql_base_name = "ipfabric_sync"
     brief_fields = [
         "auto_merge",
+        "display",
         "id",
         "last_synced",
         "name",
@@ -595,16 +658,19 @@ class IPFabricSyncTest(APIViewTestCases.APIViewTestCase):
         {
             "name": "Test Sync A",
             "parameters": {"site": True, "device": False},
+            "filters": [],
         },
         {
             "name": "Test Sync B",
             "parameters": {"ipaddress": True, "prefix": True},
             "auto_merge": True,
+            "filters": [],
         },
         {
             "name": "Test Sync C",
             "parameters": {"device": True, "interface": True},
             "interval": 60,
+            "filters": [],
         },
     ]
     bulk_update_data = {
@@ -775,6 +841,7 @@ class IPFabricIngestionTest(
     graphql_base_name = "ipfabric_ingestion"
     brief_fields = [
         "branch",
+        "display",
         "id",
         "name",
         "sync",
@@ -874,6 +941,7 @@ class IPFabricIngestionIssueTest(
     model = IPFabricIngestionIssue
     graphql_base_name = "ipfabric_ingestion_issue"
     brief_fields = [
+        "display",
         "exception",
         "id",
         "ingestion",
@@ -1005,3 +1073,255 @@ class IPFabricIngestionIssueTest(
             defaults='{"dns_name": ""}',
             exception="IntegrityError: IP address 192.168.1.1/24 already exists",
         )
+
+
+class IPFabricEndpointTest(
+    APIViewTestCases.GetObjectViewTestCase,
+    APIViewTestCases.ListObjectsViewTestCase,
+    APIViewTestCases.GraphQLTestCase,
+):
+    model = IPFabricEndpoint
+    brief_fields = [
+        "display",
+        "endpoint",
+        "id",
+        "name",
+    ]
+    graphql_base_name = "ipfabric_endpoint"
+
+    def _get_list_url(self):
+        return f"{BASE}/endpoint/"
+
+    def _get_detail_url(self, instance):
+        return f"{BASE}/endpoint/{instance.pk}/"
+
+    @classmethod
+    def setUpTestData(cls):
+        # Note: IPFabricEndpoint is read-only in the API (NetBoxReadOnlyModelViewSet)
+        # The endpoints are created by migrations and should not be modified via API
+        # We rely on the existing endpoints created by migrations for these tests
+        pass
+
+
+class IPFabricFilterTest(
+    APIViewTestCases.GetObjectViewTestCase,
+    APIViewTestCases.ListObjectsViewTestCase,
+    APIViewTestCases.GraphQLTestCase,
+):
+    model = IPFabricFilter
+    brief_fields = [
+        "display",
+        "endpoints",
+        "expressions",
+        "filter_type",
+        "id",
+        "name",
+        "syncs",
+    ]
+    graphql_base_name = "ip_fabric_filter"
+
+    def _get_list_url(self):
+        return f"{BASE}/filter/"
+
+    def _get_detail_url(self, instance):
+        return f"{BASE}/filter/{instance.pk}/"
+
+    @classmethod
+    def setUpTestData(cls):
+        # Get existing endpoints created by migrations
+        endpoints = {
+            "site": IPFabricEndpoint.objects.get(endpoint="/inventory/sites/overview"),
+            "device": IPFabricEndpoint.objects.get(endpoint="/inventory/devices"),
+            "ipaddress": IPFabricEndpoint.objects.get(
+                endpoint="/technology/addressing/managed-ip/ipv4"
+            ),
+            "vrf": IPFabricEndpoint.objects.get(
+                endpoint="/technology/routing/vrf/detail"
+            ),
+        }
+
+        # Create sources for snapshots
+        sources = (
+            IPFabricSource.objects.create(
+                name="Filter Test Source A",
+                url="https://filter-a.local",
+                parameters={"auth": "token", "verify": True},
+                last_synced=timezone.now(),
+            ),
+            IPFabricSource.objects.create(
+                name="Filter Test Source B",
+                url="https://filter-b.local",
+                parameters={"auth": "token", "verify": False},
+                last_synced=timezone.now(),
+            ),
+        )
+
+        # Create snapshots for syncs
+        snapshots = (
+            IPFabricSnapshot.objects.create(
+                name="Filter Test Snapshot A",
+                source=sources[0],
+                snapshot_id="filter-snap-a",
+                status="loaded",
+                data={"sites": ["FilterSiteA"]},
+                date=timezone.now(),
+                last_updated=timezone.now(),
+            ),
+            IPFabricSnapshot.objects.create(
+                name="Filter Test Snapshot B",
+                source=sources[1],
+                snapshot_id="filter-snap-b",
+                status="loaded",
+                data={"devices": ["FilterDevice1"]},
+                date=timezone.now(),
+                last_updated=timezone.now(),
+            ),
+        )
+
+        # Create syncs to associate with filters
+        syncs = (
+            IPFabricSync.objects.create(
+                name="Filter Test Sync A",
+                snapshot_data=snapshots[0],
+                parameters={"site": True, "device": False},
+            ),
+            IPFabricSync.objects.create(
+                name="Filter Test Sync B",
+                snapshot_data=snapshots[1],
+                parameters={"device": True, "interface": True},
+            ),
+        )
+
+        # Create existing filters for testing
+        IPFabricFilter.objects.create(
+            name="Filter D",
+            description="Sites and devices filter",
+            filter_type=IPFabricFilterTypeChoices.AND,
+        )
+        IPFabricFilter.objects.create(
+            name="Filter E",
+            description="Device and VRF filter",
+            filter_type=IPFabricFilterTypeChoices.OR,
+        )
+        IPFabricFilter.objects.create(
+            name="Filter F",
+            description="IP address filter",
+            filter_type=IPFabricFilterTypeChoices.AND,
+        )
+
+        cls.create_data = [
+            {
+                "name": "Filter A",
+                "description": "Test filter A",
+                "filter_type": IPFabricFilterTypeChoices.AND,
+                "endpoints": [endpoints["site"].pk, endpoints["device"].pk],
+                "syncs": [syncs[0].pk],
+            },
+            {
+                "name": "Filter B",
+                "description": "Test filter B",
+                "filter_type": IPFabricFilterTypeChoices.OR,
+                "endpoints": [endpoints["device"].pk],
+                "syncs": [syncs[1].pk],
+            },
+            {
+                "name": "Filter C",
+                "description": "Test filter C",
+                "filter_type": IPFabricFilterTypeChoices.AND,
+                "endpoints": [endpoints["ipaddress"].pk, endpoints["vrf"].pk],
+                "syncs": [],
+            },
+        ]
+        cls.bulk_update_data = {
+            "description": "Updated filter description",
+        }
+
+
+class IPFabricFilterExpressionTest(
+    APIViewTestCases.GetObjectViewTestCase,
+    APIViewTestCases.ListObjectsViewTestCase,
+    APIViewTestCases.GraphQLTestCase,
+):
+    model = IPFabricFilterExpression
+    brief_fields = [
+        "display",
+        "expression",
+        "filters",
+        "id",
+        "name",
+    ]
+    graphql_base_name = "ip_fabric_filter_expression"
+
+    def _get_list_url(self):
+        return f"{BASE}/filter-expression/"
+
+    def _get_detail_url(self, instance):
+        return f"{BASE}/filter-expression/{instance.pk}/"
+
+    @classmethod
+    def setUpTestData(cls):
+        # Create filters to associate with expressions
+        filters = (
+            IPFabricFilter.objects.create(
+                name="Expression Test Filter A",
+                description="First expression test filter",
+                filter_type=IPFabricFilterTypeChoices.AND,
+            ),
+            IPFabricFilter.objects.create(
+                name="Expression Test Filter B",
+                description="Second expression test filter",
+                filter_type=IPFabricFilterTypeChoices.OR,
+            ),
+            IPFabricFilter.objects.create(
+                name="Expression Test Filter C",
+                description="Third expression test filter",
+                filter_type=IPFabricFilterTypeChoices.AND,
+            ),
+        )
+
+        # Create existing filter expressions for testing
+        IPFabricFilterExpression.objects.create(
+            name="Expression D",
+            description="Sites expression",
+            expression=[{"siteName": ["eq", "Site1"]}],
+        )
+        IPFabricFilterExpression.objects.create(
+            name="Expression E",
+            description="Devices expression",
+            expression=[{"hostname": ["like", "router%"]}],
+        )
+        IPFabricFilterExpression.objects.create(
+            name="Expression F",
+            description="Complex expression",
+            expression=[
+                {"siteName": ["eq", "Site1"]},
+                {"hostname": ["like", "switch%"]},
+            ],
+        )
+
+        cls.create_data = [
+            {
+                "name": "Expression A",
+                "description": "Test expression A",
+                "expression": [{"siteName": ["eq", "TestSite"]}],
+                "filters": [filters[0].pk],
+            },
+            {
+                "name": "Expression B",
+                "description": "Test expression B",
+                "expression": [{"hostname": ["like", "test-router%"]}],
+                "filters": [filters[1].pk, filters[2].pk],
+            },
+            {
+                "name": "Expression C",
+                "description": "Test expression C",
+                "expression": [
+                    {"siteName": ["eq", "TestSite2"]},
+                    {"vendor": ["eq", "Cisco"]},
+                ],
+                "filters": [filters[0].pk],
+            },
+        ]
+        cls.bulk_update_data = {
+            "description": "Updated expression description",
+        }