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

ipfabric_netbox/tests/test_models.py

@@ -7,7 +7,11 @@ from django.core import serializers
 from django.test import TestCase
 from django.utils import timezone
 
+from ipfabric_netbox.choices import IPFabricFilterTypeChoices
 from ipfabric_netbox.choices import IPFabricSnapshotStatusModelChoices
+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 IPFabricSnapshot
 from ipfabric_netbox.models import IPFabricSource
@@ -123,19 +127,19 @@ class IPFabricTransformMapModelTestCase(TestCase):
             snapshot_data=snapshot,
             update_custom_fields=True,
             parameters={
-                "vrf": False,
-                "site": True,
-                "vlan": False,
-                "sites": [],
-                "device": True,
-                "prefix": False,
-                "platform": True,
-                "interface": False,
-                "ipaddress": False,
-                "devicerole": True,
-                "devicetype": True,
-                "manufacturer": True,
-                "virtualchassis": False,
+                "ipam.vrf": False,
+                "dcim.site": True,
+                "ipam.vlan": False,
+                "groups": [],
+                "dcim.device": True,
+                "ipam.prefix": False,
+                "dcim.platform": True,
+                "dcim.interface": False,
+                "ipam.ipaddress": False,
+                "dcim.devicerole": True,
+                "dcim.devicetype": True,
+                "dcim.manufacturer": True,
+                "dcim.virtualchassis": False,
             },
         )
 
@@ -143,15 +147,15 @@ class IPFabricTransformMapModelTestCase(TestCase):
 
         runner = IPFabricSyncRunner(
             settings={
-                "site": True,
-                "sites": [],
-                "device": True,
-                "platform": True,
-                "interface": False,
-                "devicerole": True,
-                "devicetype": True,
-                "manufacturer": True,
-                "virtualchassis": True,
+                "dcim.site": True,
+                "groups": [],
+                "dcim.device": True,
+                "dcim.platform": True,
+                "dcim.interface": False,
+                "dcim.devicerole": True,
+                "dcim.devicetype": True,
+                "dcim.manufacturer": True,
+                "dcim.virtualchassis": True,
                 "snapshot_id": "12dd8c61-129c-431a-b98b-4c9211571f89",
             },
             sync=sync,
@@ -251,7 +255,10 @@ class IPFabricTransformMapModelTestCase(TestCase):
     def test_transform_map(self):
         site_transform_map = IPFabricTransformMap.objects.get(name="Site Transform Map")
         self.assertEqual(site_transform_map.name, "Site Transform Map")
-        self.assertEqual(site_transform_map.source_model, "site")
+        self.assertIsNotNone(site_transform_map.source_endpoint)
+        self.assertEqual(
+            site_transform_map.source_endpoint.endpoint, "/inventory/sites/overview"
+        )
         self.assertEqual(
             site_transform_map.target_model,
             ContentType.objects.filter(app_label="dcim", model="site")[0],
@@ -287,7 +294,7 @@ class IPFabricTransformMapModelTestCase(TestCase):
             "pk": site_transform_map.pk,
             "fields": {
                 "name": "Site Transform Map",
-                "source_model": "site",
+                "source_endpoint": site_transform_map.source_endpoint.pk,
                 "target_model": ContentType.objects.get(
                     app_label="dcim", model="site"
                 ).pk,
@@ -358,15 +365,15 @@ class IPFabricTransformMapModelTestCase(TestCase):
 
         runner = IPFabricSyncRunner(
             settings={
-                "site": True,
-                "sites": [],
-                "device": True,
-                "platform": True,
-                "interface": False,
-                "devicerole": True,
-                "devicetype": True,
-                "manufacturer": True,
-                "virtualchassis": True,
+                "dcim.site": True,
+                "groups": [],
+                "dcim.device": True,
+                "dcim.platform": True,
+                "dcim.interface": False,
+                "dcim.devicerole": True,
+                "dcim.devicetype": True,
+                "dcim.manufacturer": True,
+                "dcim.virtualchassis": True,
                 "snapshot_id": "12dd8c61-129c-431a-b98b-4c9211571f89",
             },
             sync=sync,
@@ -409,11 +416,12 @@ class IPFabricTransformMapModelTestCase(TestCase):
             "slug": None,
         }
 
+        device_endpoint = IPFabricEndpoint.objects.get(endpoint="/inventory/devices")
         transform_field = IPFabricTransformField.objects.get(
             source_field="hostname",
             target_field="name",
             transform_map=IPFabricTransformMap.objects.get(
-                source_model="device",
+                source_endpoint=device_endpoint,
                 target_model=ContentType.objects.get(app_label="dcim", model="device"),
             ),
         )
@@ -426,3 +434,203 @@ class IPFabricTransformMapModelTestCase(TestCase):
             cf=sync.update_custom_fields,
         )
         self.assertEqual(device_object.name, "L21PE152 - test")
+
+
+class IPFabricFilterCombinationTestCase(TestCase):
+    """Test cases for recursive filter merging with nested and/or structures."""
+
+    @classmethod
+    def setUpTestData(cls):
+        # Create source
+        cls.source = IPFabricSource.objects.create(
+            name="Test Source",
+            url="https://test.ipfabric.io",
+            status="active",
+            parameters={"auth": "test_token", "verify": False},
+        )
+        # Create snapshot
+        cls.snapshot = IPFabricSnapshot.objects.create(
+            name="Test Snapshot",
+            source=cls.source,
+            snapshot_id="test-snapshot-123",
+            status=IPFabricSnapshotStatusModelChoices.STATUS_LOADED,
+            data={"sites": ["Site1", "Site2"]},
+        )
+        # Create sync
+        cls.sync = IPFabricSync.objects.create(
+            name="Test Sync",
+            snapshot_data=cls.snapshot,
+            status="new",
+        )
+        # Get or create endpoint
+        cls.endpoint, _ = IPFabricEndpoint.objects.get_or_create(
+            endpoint="/inventory/devices",
+            defaults={"name": "Devices Endpoint"},
+        )
+
+    def test_combine_filters_merges_same_nested_or_structure(self):
+        """Test that filters with same nested 'or' structure merge correctly."""
+        # Create two AND-type filters
+        filter1 = IPFabricFilter.objects.create(
+            name="Filter with router1",
+            filter_type=IPFabricFilterTypeChoices.AND,
+        )
+        filter1.endpoints.add(self.endpoint)
+        filter1.syncs.add(self.sync)
+
+        filter2 = IPFabricFilter.objects.create(
+            name="Filter with router2",
+            filter_type=IPFabricFilterTypeChoices.AND,
+        )
+        filter2.endpoints.add(self.endpoint)
+        filter2.syncs.add(self.sync)
+
+        # Create expressions with same nested structure
+        expr1 = IPFabricFilterExpression.objects.create(
+            name="Expression router1",
+            expression=[{"or": [{"hostname": ["like", "router1"]}]}],
+        )
+        expr1.filters.add(filter1)
+
+        expr2 = IPFabricFilterExpression.objects.create(
+            name="Expression router2",
+            expression=[{"or": [{"hostname": ["like", "router2"]}]}],
+        )
+        expr2.filters.add(filter2)
+
+        # Combine filters
+        result = self.endpoint.combine_filters(sync=self.sync)
+
+        # Should have merged into single nested structure
+        self.assertIn("and", result)
+        self.assertEqual(len(result["and"]), 1)
+        self.assertIn("or", result["and"][0])
+        self.assertEqual(len(result["and"][0]["or"]), 2)
+
+        # Verify both hostnames are present
+        hostnames = [item["hostname"][1] for item in result["and"][0]["or"]]
+        self.assertIn("router1", hostnames)
+        self.assertIn("router2", hostnames)
+
+    def test_combine_filters_deeply_nested_structures(self):
+        """Test that deeply nested structures (3+ levels) merge correctly."""
+        # Create two AND-type filters with 3-level nesting
+        filter1 = IPFabricFilter.objects.create(
+            name="Deep filter cisco",
+            filter_type=IPFabricFilterTypeChoices.AND,
+        )
+        filter1.endpoints.add(self.endpoint)
+        filter1.syncs.add(self.sync)
+
+        filter2 = IPFabricFilter.objects.create(
+            name="Deep filter juniper",
+            filter_type=IPFabricFilterTypeChoices.AND,
+        )
+        filter2.endpoints.add(self.endpoint)
+        filter2.syncs.add(self.sync)
+
+        # Create deeply nested expressions
+        expr1 = IPFabricFilterExpression.objects.create(
+            name="Deep expression cisco",
+            expression=[{"or": [{"and": [{"or": [{"vendor": ["eq", "cisco"]}]}]}]}],
+        )
+        expr1.filters.add(filter1)
+
+        expr2 = IPFabricFilterExpression.objects.create(
+            name="Deep expression juniper",
+            expression=[{"or": [{"and": [{"or": [{"vendor": ["eq", "juniper"]}]}]}]}],
+        )
+        expr2.filters.add(filter2)
+
+        # Combine filters
+        result = self.endpoint.combine_filters(sync=self.sync)
+
+        # Should have merged at all levels
+        self.assertIn("and", result)
+        self.assertEqual(len(result["and"]), 1)
+        self.assertIn("or", result["and"][0])
+        self.assertEqual(len(result["and"][0]["or"]), 1)
+        self.assertIn("and", result["and"][0]["or"][0])
+        self.assertEqual(len(result["and"][0]["or"][0]["and"]), 1)
+        self.assertIn("or", result["and"][0]["or"][0]["and"][0])
+
+        # Verify both vendors are in innermost or array
+        innermost_or = result["and"][0]["or"][0]["and"][0]["or"]
+        self.assertEqual(len(innermost_or), 2)
+        vendors = [item["vendor"][1] for item in innermost_or]
+        self.assertIn("cisco", vendors)
+        self.assertIn("juniper", vendors)
+
+    def test_combine_filters_different_structures_no_merge(self):
+        """Test that filters with different structures don't merge."""
+        # Create two AND-type filters with different nested structures
+        filter1 = IPFabricFilter.objects.create(
+            name="Filter with or structure",
+            filter_type=IPFabricFilterTypeChoices.AND,
+        )
+        filter1.endpoints.add(self.endpoint)
+        filter1.syncs.add(self.sync)
+
+        filter2 = IPFabricFilter.objects.create(
+            name="Filter with and structure",
+            filter_type=IPFabricFilterTypeChoices.AND,
+        )
+        filter2.endpoints.add(self.endpoint)
+        filter2.syncs.add(self.sync)
+
+        # Create expressions with different structures
+        expr1 = IPFabricFilterExpression.objects.create(
+            name="Expression with or",
+            expression=[{"or": [{"hostname": ["like", "router1"]}]}],
+        )
+        expr1.filters.add(filter1)
+
+        expr2 = IPFabricFilterExpression.objects.create(
+            name="Expression with and",
+            expression=[{"and": [{"hostname": ["like", "router2"]}]}],
+        )
+        expr2.filters.add(filter2)
+
+        # Combine filters
+        result = self.endpoint.combine_filters(sync=self.sync)
+
+        # Should have two separate structures (not merged)
+        self.assertIn("and", result)
+        self.assertEqual(len(result["and"]), 2)
+
+        # One should have 'or', the other should have 'and'
+        structures = [list(item.keys()) for item in result["and"]]
+        self.assertIn(["or"], structures)
+        self.assertIn(["and"], structures)
+
+    def test_combine_filters_multiple_filters_same_structure(self):
+        """Test that 3+ filters with same structure all merge correctly."""
+        # Create three AND-type filters with same nested structure
+        for i in range(1, 4):
+            filter_obj = IPFabricFilter.objects.create(
+                name=f"Filter with router{i}",
+                filter_type=IPFabricFilterTypeChoices.AND,
+            )
+            filter_obj.endpoints.add(self.endpoint)
+            filter_obj.syncs.add(self.sync)
+
+            expr = IPFabricFilterExpression.objects.create(
+                name=f"Expression router{i}",
+                expression=[{"or": [{"hostname": ["like", f"router{i}"]}]}],
+            )
+            expr.filters.add(filter_obj)
+
+        # Combine filters
+        result = self.endpoint.combine_filters(sync=self.sync)
+
+        # Should have merged all three into single nested structure
+        self.assertIn("and", result)
+        self.assertEqual(len(result["and"]), 1)
+        self.assertIn("or", result["and"][0])
+        self.assertEqual(len(result["and"][0]["or"]), 3)
+
+        # Verify all three hostnames are present
+        hostnames = [item["hostname"][1] for item in result["and"][0]["or"]]
+        self.assertIn("router1", hostnames)
+        self.assertIn("router2", hostnames)
+        self.assertIn("router3", hostnames)