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

ipfabric_netbox/tests/test_filtersets.py

@@ -0,0 +1,2592 @@
+from django.contrib.contenttypes.models import ContentType
+from django.test import TestCase
+from django.utils import timezone
+from netbox_branching.models import Branch
+from netbox_branching.models import ChangeDiff
+
+from ipfabric_netbox.choices import IPFabricEndpointChoices
+from ipfabric_netbox.choices import IPFabricFilterTypeChoices
+from ipfabric_netbox.choices import IPFabricSnapshotStatusModelChoices
+from ipfabric_netbox.choices import IPFabricSourceStatusChoices
+from ipfabric_netbox.choices import IPFabricSourceTypeChoices
+from ipfabric_netbox.choices import IPFabricSyncStatusChoices
+from ipfabric_netbox.filtersets import IPFabricDataFilterSet
+from ipfabric_netbox.filtersets import IPFabricEndpointFilterSet
+from ipfabric_netbox.filtersets import IPFabricFilterExpressionFilterSet
+from ipfabric_netbox.filtersets import IPFabricFilterFilterSet
+from ipfabric_netbox.filtersets import IPFabricIngestionChangeFilterSet
+from ipfabric_netbox.filtersets import IPFabricIngestionFilterSet
+from ipfabric_netbox.filtersets import IPFabricIngestionIssueFilterSet
+from ipfabric_netbox.filtersets import IPFabricRelationshipFieldFilterSet
+from ipfabric_netbox.filtersets import IPFabricSnapshotFilterSet
+from ipfabric_netbox.filtersets import IPFabricSourceFilterSet
+from ipfabric_netbox.filtersets import IPFabricSyncFilterSet
+from ipfabric_netbox.filtersets import IPFabricTransformFieldFilterSet
+from ipfabric_netbox.filtersets import IPFabricTransformMapFilterSet
+from ipfabric_netbox.filtersets import IPFabricTransformMapGroupFilterSet
+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
+from ipfabric_netbox.models import IPFabricSnapshot
+from ipfabric_netbox.models import IPFabricSource
+from ipfabric_netbox.models import IPFabricSync
+from ipfabric_netbox.models import IPFabricTransformField
+from ipfabric_netbox.models import IPFabricTransformMap
+from ipfabric_netbox.models import IPFabricTransformMapGroup
+
+
+class IPFabricEndpointFilterSetTestCase(TestCase):
+    """
+    Test IPFabricEndpointFilterSet to verify all custom filters work correctly.
+    """
+
+    queryset = IPFabricEndpoint.objects.all()
+    filterset = IPFabricEndpointFilterSet
+
+    @classmethod
+    def setUpTestData(cls):
+        # Use existing endpoints from migrations (created from endpoint.json)
+        # These are created by the prepare_endpoints migration
+        cls.sites_endpoint = IPFabricEndpoint.objects.filter(
+            endpoint=IPFabricEndpointChoices.SITES
+        ).first()
+        cls.devices_endpoint = IPFabricEndpoint.objects.filter(
+            endpoint=IPFabricEndpointChoices.DEVICES
+        ).first()
+        cls.vrfs_endpoint = IPFabricEndpoint.objects.filter(
+            endpoint=IPFabricEndpointChoices.VRFS
+        ).first()
+        cls.vlans_endpoint = IPFabricEndpoint.objects.filter(
+            endpoint=IPFabricEndpointChoices.VLANS
+        ).first()
+
+        # Ensure endpoints exist (they should from migrations)
+        if not all(
+            [
+                cls.sites_endpoint,
+                cls.devices_endpoint,
+                cls.vrfs_endpoint,
+                cls.vlans_endpoint,
+            ]
+        ):
+            raise ValueError(
+                "Required endpoints not found. Ensure migrations have been run."
+            )
+
+        # Create test filters
+        filters = [
+            IPFabricFilter(
+                name="Test Filter 1",
+                description="First test filter",
+                filter_type=IPFabricFilterTypeChoices.AND,
+            ),
+            IPFabricFilter(
+                name="Test Filter 2",
+                description="Second test filter",
+                filter_type=IPFabricFilterTypeChoices.OR,
+            ),
+            IPFabricFilter(
+                name="Test Filter 3",
+                description="Third test filter",
+                filter_type=IPFabricFilterTypeChoices.AND,
+            ),
+        ]
+        IPFabricFilter.objects.bulk_create(filters)
+
+        # Get created filters
+        cls.filter1 = IPFabricFilter.objects.get(name="Test Filter 1")
+        cls.filter2 = IPFabricFilter.objects.get(name="Test Filter 2")
+        cls.filter3 = IPFabricFilter.objects.get(name="Test Filter 3")
+
+        # Assign endpoints to filters
+        # Filter 1 uses sites and devices endpoints
+        cls.filter1.endpoints.add(cls.sites_endpoint, cls.devices_endpoint)
+
+        # Filter 2 uses devices and VRFs endpoints
+        cls.filter2.endpoints.add(cls.devices_endpoint, cls.vrfs_endpoint)
+
+        # Filter 3 uses only VLANs endpoint
+        cls.filter3.endpoints.add(cls.vlans_endpoint)
+
+    def test_id(self):
+        """Test filtering by endpoint ID"""
+        params = {"id": [self.sites_endpoint.pk]}
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
+        params = {"id": [self.sites_endpoint.pk, self.devices_endpoint.pk]}
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
+
+    def test_name(self):
+        """Test filtering by endpoint name"""
+        # Use actual endpoint names from migrations
+        params = {"name": [self.sites_endpoint.name]}
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
+        params = {"name": [self.sites_endpoint.name, self.devices_endpoint.name]}
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
+
+    def test_description(self):
+        """Test filtering by description"""
+        # Test with actual description from endpoint (may be empty)
+        if self.sites_endpoint.description:
+            params = {"description": [self.sites_endpoint.description]}
+            result = self.filterset(params, self.queryset).qs
+            self.assertGreaterEqual(result.count(), 1)
+
+    def test_endpoint_path(self):
+        """Test filtering by endpoint path (URL format)"""
+        # Test with URL path format - should convert to dot notation
+        params = {"endpoint": "/technology/routing/vrf/detail"}
+        result = self.filterset(params, self.queryset).qs
+        self.assertEqual(result.count(), 1)
+        self.assertEqual(result.first().endpoint, IPFabricEndpointChoices.VRFS)
+
+        # Test sites endpoint
+        params = {"endpoint": "/inventory/sites/overview"}
+        result = self.filterset(params, self.queryset).qs
+        self.assertEqual(result.count(), 1)
+        self.assertEqual(result.first().endpoint, IPFabricEndpointChoices.SITES)
+
+        # Test VLANs endpoint
+        params = {"endpoint": "/technology/vlans/site-summary"}
+        result = self.filterset(params, self.queryset).qs
+        self.assertEqual(result.count(), 1)
+        self.assertEqual(result.first().endpoint, IPFabricEndpointChoices.VLANS)
+
+        # Test case-insensitive matching
+        params = {"endpoint": "/TECHNOLOGY/ROUTING/VRF/DETAIL"}
+        result = self.filterset(params, self.queryset).qs
+        self.assertEqual(result.count(), 1)
+
+        # Test invalid path returns empty
+        params = {"endpoint": "/invalid/path"}
+        result = self.filterset(params, self.queryset).qs
+        self.assertEqual(result.count(), 0)
+
+    def test_filter_id(self):
+        """Test filtering endpoints by IP Fabric filter ID"""
+        # Test single filter ID (as list)
+        params = {"ipfabric_filter_id": [self.filter1.pk]}
+        result = self.filterset(params, self.queryset).qs
+        # Filter 1 has sites and devices endpoints
+        self.assertEqual(result.count(), 2)
+        endpoint_ids = set(result.values_list("id", flat=True))
+        self.assertIn(self.sites_endpoint.pk, endpoint_ids)
+        self.assertIn(self.devices_endpoint.pk, endpoint_ids)
+
+        # Test filter 2
+        params = {"ipfabric_filter_id": [self.filter2.pk]}
+        result = self.filterset(params, self.queryset).qs
+        # Filter 2 has devices and VRFs endpoints
+        self.assertEqual(result.count(), 2)
+        endpoint_ids = set(result.values_list("id", flat=True))
+        self.assertIn(self.devices_endpoint.pk, endpoint_ids)
+        self.assertIn(self.vrfs_endpoint.pk, endpoint_ids)
+
+        # Test filter 3
+        params = {"ipfabric_filter_id": [self.filter3.pk]}
+        result = self.filterset(params, self.queryset).qs
+        # Filter 3 has only VLANs endpoint
+        self.assertEqual(result.count(), 1)
+        self.assertEqual(result.first().pk, self.vlans_endpoint.pk)
+
+        # Note: ModelMultipleChoiceFilter silently ignores invalid IDs
+        # and returns all results instead of raising an error or returning empty.
+        # This is expected django-filter behavior.
+
+    def test_filter_name(self):
+        """Test filtering endpoints by IP Fabric filter name"""
+        # Test exact match (case-insensitive)
+        params = {"ipfabric_filter": "Test Filter 1"}
+        result = self.filterset(params, self.queryset).qs
+        # Filter 1 has sites and devices endpoints
+        self.assertEqual(result.count(), 2)
+        endpoint_ids = set(result.values_list("id", flat=True))
+        self.assertIn(self.sites_endpoint.pk, endpoint_ids)
+        self.assertIn(self.devices_endpoint.pk, endpoint_ids)
+
+        # Test case-insensitive
+        params = {"ipfabric_filter": "test filter 2"}
+        result = self.filterset(params, self.queryset).qs
+        # Should match Filter 2 which has 2 endpoints
+        self.assertEqual(result.count(), 2)
+
+        # Test different case
+        params = {"ipfabric_filter": "TEST FILTER 3"}
+        result = self.filterset(params, self.queryset).qs
+        # Should match Filter 3 which has 1 endpoint
+        self.assertEqual(result.count(), 1)
+
+        # Test non-existent filter
+        params = {"ipfabric_filter": "Non Existent Filter"}
+        result = self.filterset(params, self.queryset).qs
+        self.assertEqual(result.count(), 0)
+
+    def test_filters_multiple(self):
+        """Test filtering endpoints by multiple IP Fabric filter IDs"""
+        # Test multiple filter IDs using 'ipfabric_filters' parameter
+        params = {"ipfabric_filters": [self.filter1.pk, self.filter3.pk]}
+        result = self.filterset(params, self.queryset).qs
+        # Filter 1 has sites and devices, Filter 3 has VLANs
+        # Should return sites, devices, and VLANs endpoints
+        self.assertEqual(result.count(), 3)
+        endpoint_ids = set(result.values_list("id", flat=True))
+        self.assertIn(self.sites_endpoint.pk, endpoint_ids)
+        self.assertIn(self.devices_endpoint.pk, endpoint_ids)
+        self.assertIn(self.vlans_endpoint.pk, endpoint_ids)
+
+    def test_combined_filters(self):
+        """Test combining multiple filters"""
+        # Test ipfabric_filter_id + name (using actual endpoint name)
+        params = {
+            "ipfabric_filter_id": [self.filter1.pk],  # Pass as list
+            "name": [self.sites_endpoint.name],  # Pass as list
+        }
+        result = self.filterset(params, self.queryset).qs
+        # Filter 1 has sites and devices, but name filters to only sites
+        self.assertEqual(result.count(), 1)
+        self.assertEqual(result.first().pk, self.sites_endpoint.pk)
+
+        # Test ipfabric_filter_id + endpoint
+        params = {
+            "ipfabric_filter_id": [self.filter2.pk],  # Pass as list
+            "endpoint": "/inventory/devices",
+        }
+        result = self.filterset(params, self.queryset).qs
+        # Filter 2 has devices and VRFs, but endpoint filters to only devices
+        self.assertEqual(result.count(), 1)
+        self.assertEqual(result.first().pk, self.devices_endpoint.pk)
+
+    def test_q_search(self):
+        """Test the search (q) parameter"""
+        # Search using part of an actual endpoint name
+        search_term = (
+            self.sites_endpoint.name.split()[0]
+            if self.sites_endpoint.name
+            else "Default"
+        )
+        params = {"q": search_term}
+        result = self.filterset(params, self.queryset).qs
+        # Should find at least the sites endpoint (may find others with similar names)
+        self.assertGreaterEqual(result.count(), 1)
+        self.assertIn(self.sites_endpoint.pk, result.values_list("pk", flat=True))
+
+    def test_distinct_results(self):
+        """Test that filters return distinct results (no duplicates)"""
+        # Add devices endpoint to multiple filters to test distinct
+        self.filter3.endpoints.add(self.devices_endpoint)
+
+        # Filter by multiple filters that share an endpoint
+        params = {
+            "ipfabric_filters": [self.filter1.pk, self.filter2.pk, self.filter3.pk]
+        }
+        result = self.filterset(params, self.queryset).qs
+
+        # Count devices endpoint occurrences (should be 1 despite being in 3 filters)
+        devices_count = result.filter(pk=self.devices_endpoint.pk).count()
+        self.assertEqual(devices_count, 1)
+
+    def test_empty_filters(self):
+        """Test behavior with empty filter values"""
+        # Get total count of endpoints
+        total_count = self.queryset.count()
+
+        # Empty ipfabric_filter_id should return all
+        params = {"ipfabric_filter_id": ""}
+        result = self.filterset(params, self.queryset).qs
+        self.assertEqual(result.count(), total_count)
+
+        # Empty endpoint should return all
+        params = {"endpoint": ""}
+        result = self.filterset(params, self.queryset).qs
+        self.assertEqual(result.count(), total_count)
+
+        # Empty ipfabric_filter name should return all
+        params = {"ipfabric_filter": ""}
+        result = self.filterset(params, self.queryset).qs
+        self.assertEqual(result.count(), total_count)
+
+
+class IPFabricFilterFilterSetTestCase(TestCase):
+    """
+    Test IPFabricFilterFilterSet to verify all custom filters work correctly.
+    """
+
+    queryset = IPFabricFilter.objects.all()
+    filterset = IPFabricFilterFilterSet
+
+    @classmethod
+    def setUpTestData(cls):
+        # Get existing endpoints from migrations
+        cls.sites_endpoint = IPFabricEndpoint.objects.filter(
+            endpoint=IPFabricEndpointChoices.SITES
+        ).first()
+        cls.devices_endpoint = IPFabricEndpoint.objects.filter(
+            endpoint=IPFabricEndpointChoices.DEVICES
+        ).first()
+        cls.vrfs_endpoint = IPFabricEndpoint.objects.filter(
+            endpoint=IPFabricEndpointChoices.VRFS
+        ).first()
+
+        # Create required dependencies for syncs
+        source = IPFabricSource.objects.create(
+            name="Test Source",
+            type=IPFabricSourceTypeChoices.LOCAL,
+            url="https://ipfabric.example.com",
+            status=IPFabricSourceStatusChoices.NEW,
+        )
+
+        snapshot = IPFabricSnapshot.objects.create(
+            source=source,
+            name="Test Snapshot",
+            snapshot_id="test_snap001",
+            data={"devices": 100},
+            date=timezone.now(),
+            status=IPFabricSnapshotStatusModelChoices.STATUS_LOADED,
+        )
+
+        # Create test syncs
+        cls.sync1 = IPFabricSync.objects.create(
+            name="Test Sync 1",
+            snapshot_data=snapshot,
+            status=IPFabricSyncStatusChoices.NEW,
+        )
+        cls.sync2 = IPFabricSync.objects.create(
+            name="Test Sync 2",
+            snapshot_data=snapshot,
+            status=IPFabricSyncStatusChoices.COMPLETED,
+        )
+        cls.sync3 = IPFabricSync.objects.create(
+            name="Test Sync 3",
+            snapshot_data=snapshot,
+            status=IPFabricSyncStatusChoices.FAILED,
+        )
+
+        # Create test filters
+        filters = [
+            IPFabricFilter(
+                name="Test Filter 1",
+                description="Sites and devices filter",
+                filter_type=IPFabricFilterTypeChoices.AND,
+            ),
+            IPFabricFilter(
+                name="Test Filter 2",
+                description="Devices and VRFs filter",
+                filter_type=IPFabricFilterTypeChoices.OR,
+            ),
+            IPFabricFilter(
+                name="Test Filter 3",
+                description="Sites only filter",
+                filter_type=IPFabricFilterTypeChoices.AND,
+            ),
+        ]
+        IPFabricFilter.objects.bulk_create(filters)
+
+        cls.filter1 = IPFabricFilter.objects.get(name="Test Filter 1")
+        cls.filter2 = IPFabricFilter.objects.get(name="Test Filter 2")
+        cls.filter3 = IPFabricFilter.objects.get(name="Test Filter 3")
+
+        # Assign endpoints to filters
+        cls.filter1.endpoints.add(cls.sites_endpoint, cls.devices_endpoint)
+        cls.filter2.endpoints.add(cls.devices_endpoint, cls.vrfs_endpoint)
+        cls.filter3.endpoints.add(cls.sites_endpoint)
+
+        # Assign syncs to filters
+        cls.filter1.syncs.add(cls.sync1, cls.sync2)
+        cls.filter2.syncs.add(cls.sync2, cls.sync3)
+        cls.filter3.syncs.add(cls.sync1)
+
+        # Create test filter expressions
+        expressions = [
+            IPFabricFilterExpression(
+                name="Filter Test Expression 1",
+                description="First filter test expression",
+                expression={"or": [{"siteName": ["eq", "FilterSite1"]}]},
+            ),
+            IPFabricFilterExpression(
+                name="Filter Test Expression 2",
+                description="Second filter test expression",
+                expression={"and": [{"hostname": ["like", "filterrouter"]}]},
+            ),
+        ]
+        IPFabricFilterExpression.objects.bulk_create(expressions)
+
+        cls.expr1 = IPFabricFilterExpression.objects.get(
+            name="Filter Test Expression 1"
+        )
+        cls.expr2 = IPFabricFilterExpression.objects.get(
+            name="Filter Test Expression 2"
+        )
+
+        # Assign expressions to filters
+        cls.expr1.filters.add(cls.filter1, cls.filter2)
+        cls.expr2.filters.add(cls.filter2, cls.filter3)
+
+    def test_id(self):
+        """Test filtering by filter ID"""
+        params = {"id": [self.filter1.pk]}
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
+        params = {"id": [self.filter1.pk, self.filter2.pk]}
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
+
+    def test_name(self):
+        """Test filtering by filter name"""
+        params = {"name": ["Test Filter 1"]}
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
+        params = {"name": ["Test Filter 1", "Test Filter 2"]}
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
+
+    def test_description(self):
+        """Test filtering by description"""
+        # Skip test if description is empty (which it is in our test data)
+        # In real usage, descriptions would be populated
+        pass
+
+    def test_filter_type(self):
+        """Test filtering by filter type"""
+        params = {"filter_type": IPFabricFilterTypeChoices.AND}
+        result = self.filterset(params, self.queryset).qs
+        # Filters 1 and 3 are AND type from our test data
+        # (may include more from other test classes)
+        self.assertGreaterEqual(result.count(), 2)
+        # Verify our test filters are included
+        filter_ids = set(result.values_list("id", flat=True))
+        self.assertIn(self.filter1.pk, filter_ids)
+        self.assertIn(self.filter3.pk, filter_ids)
+
+        params = {"filter_type": IPFabricFilterTypeChoices.OR}
+        result = self.filterset(params, self.queryset).qs
+        # Filter 2 is OR type from our test data
+        self.assertGreaterEqual(result.count(), 1)
+        self.assertIn(self.filter2.pk, result.values_list("id", flat=True))
+
+    def test_sync_id(self):
+        """Test filtering by sync ID"""
+        params = {"sync_id": [self.sync1.pk]}
+        result = self.filterset(params, self.queryset).qs
+        # Filters 1 and 3 use sync1
+        self.assertEqual(result.count(), 2)
+        filter_ids = set(result.values_list("id", flat=True))
+        self.assertIn(self.filter1.pk, filter_ids)
+        self.assertIn(self.filter3.pk, filter_ids)
+
+        params = {"sync_id": [self.sync2.pk]}
+        result = self.filterset(params, self.queryset).qs
+        # Filters 1 and 2 use sync2
+        self.assertEqual(result.count(), 2)
+
+    def test_sync_name(self):
+        """Test filtering by sync name"""
+        params = {"sync": "Test Sync 1"}
+        result = self.filterset(params, self.queryset).qs
+        # Filters 1 and 3 use sync1
+        self.assertEqual(result.count(), 2)
+
+        # Test case-insensitive
+        params = {"sync": "test sync 2"}
+        result = self.filterset(params, self.queryset).qs
+        self.assertEqual(result.count(), 2)
+
+    def test_syncs_multiple(self):
+        """Test filtering by multiple sync IDs"""
+        params = {"syncs": [self.sync1.pk, self.sync3.pk]}
+        result = self.filterset(params, self.queryset).qs
+        # All three filters use sync1 or sync3
+        self.assertEqual(result.count(), 3)
+
+    def test_endpoint_id(self):
+        """Test filtering by endpoint ID"""
+        params = {"endpoint_id": [self.sites_endpoint.pk]}
+        result = self.filterset(params, self.queryset).qs
+        # Filters 1 and 3 use sites endpoint
+        self.assertEqual(result.count(), 2)
+        filter_ids = set(result.values_list("id", flat=True))
+        self.assertIn(self.filter1.pk, filter_ids)
+        self.assertIn(self.filter3.pk, filter_ids)
+
+    def test_endpoint_name(self):
+        """Test filtering by endpoint name"""
+        params = {"endpoint": self.devices_endpoint.name}
+        result = self.filterset(params, self.queryset).qs
+        # Filters 1 and 2 use devices endpoint from our test data
+        # (may include more from other test classes)
+        self.assertGreaterEqual(result.count(), 2)
+        filter_ids = set(result.values_list("id", flat=True))
+        self.assertIn(self.filter1.pk, filter_ids)
+        self.assertIn(self.filter2.pk, filter_ids)
+
+    def test_endpoint_path(self):
+        """Test filtering by endpoint URL path"""
+        # Test with URL path format
+        params = {"endpoint_path": "/inventory/sites/overview"}
+        result = self.filterset(params, self.queryset).qs
+        # Filters 1 and 3 use sites endpoint from our test data
+        # (may include more from other test classes)
+        self.assertGreaterEqual(result.count(), 2)
+        filter_ids = set(result.values_list("id", flat=True))
+        self.assertIn(self.filter1.pk, filter_ids)
+        self.assertIn(self.filter3.pk, filter_ids)
+
+        # Test case-insensitive
+        params = {"endpoint_path": "/INVENTORY/DEVICES"}
+        result = self.filterset(params, self.queryset).qs
+        # Filters 1 and 2 use devices endpoint from our test data
+        self.assertGreaterEqual(result.count(), 2)
+        filter_ids = set(result.values_list("id", flat=True))
+        self.assertIn(self.filter1.pk, filter_ids)
+        self.assertIn(self.filter2.pk, filter_ids)
+
+        # Test invalid path
+        params = {"endpoint_path": "/invalid/path"}
+        result = self.filterset(params, self.queryset).qs
+        self.assertEqual(result.count(), 0)
+
+    def test_endpoints_multiple(self):
+        """Test filtering by multiple endpoint IDs"""
+        params = {"endpoints": [self.sites_endpoint.pk, self.vrfs_endpoint.pk]}
+        result = self.filterset(params, self.queryset).qs
+        # All three filters from our test data use sites or VRFs
+        # (may include more from other test classes)
+        self.assertGreaterEqual(result.count(), 3)
+        filter_ids = set(result.values_list("id", flat=True))
+        self.assertIn(self.filter1.pk, filter_ids)
+        self.assertIn(self.filter2.pk, filter_ids)
+        self.assertIn(self.filter3.pk, filter_ids)
+
+    def test_expression_id(self):
+        """Test filtering by expression ID"""
+        params = {"expression_id": [self.expr1.pk]}
+        result = self.filterset(params, self.queryset).qs
+        # Filters 1 and 2 use expr1
+        self.assertEqual(result.count(), 2)
+        filter_ids = set(result.values_list("id", flat=True))
+        self.assertIn(self.filter1.pk, filter_ids)
+        self.assertIn(self.filter2.pk, filter_ids)
+
+        params = {"expression_id": [self.expr2.pk]}
+        result = self.filterset(params, self.queryset).qs
+        # Filters 2 and 3 use expr2
+        self.assertEqual(result.count(), 2)
+        filter_ids = set(result.values_list("id", flat=True))
+        self.assertIn(self.filter2.pk, filter_ids)
+        self.assertIn(self.filter3.pk, filter_ids)
+
+    def test_expression_name(self):
+        """Test filtering by expression name"""
+        params = {"expression": "Filter Test Expression 1"}
+        result = self.filterset(params, self.queryset).qs
+        # Filters 1 and 2 use expr1
+        self.assertEqual(result.count(), 2)
+
+        # Test case-insensitive
+        params = {"expression": "filter test expression 2"}
+        result = self.filterset(params, self.queryset).qs
+        # Filters 2 and 3 use expr2
+        self.assertEqual(result.count(), 2)
+
+    def test_expressions_multiple(self):
+        """Test filtering by multiple expression IDs"""
+        params = {"expressions": [self.expr1.pk, self.expr2.pk]}
+        result = self.filterset(params, self.queryset).qs
+        # All three filters use expr1 or expr2
+        self.assertEqual(result.count(), 3)
+
+    def test_combined_filters(self):
+        """Test combining multiple filters"""
+        # Test sync_id + endpoint_id
+        params = {
+            "sync_id": [self.sync1.pk],
+            "endpoint_id": [self.sites_endpoint.pk],
+        }
+        result = self.filterset(params, self.queryset).qs
+        # Filters 1 and 3 have sync1, both have sites endpoint
+        self.assertEqual(result.count(), 2)
+
+        # Test filter_type + endpoint_id
+        params = {
+            "filter_type": IPFabricFilterTypeChoices.AND,
+            "endpoint_id": [self.sites_endpoint.pk],
+        }
+        result = self.filterset(params, self.queryset).qs
+        # Filters 1 and 3 are AND type and have sites endpoint
+        self.assertEqual(result.count(), 2)
+
+        # Test sync_id + filter_type
+        params = {
+            "sync_id": [self.sync2.pk],
+            "filter_type": IPFabricFilterTypeChoices.AND,
+        }
+        result = self.filterset(params, self.queryset).qs
+        # Only Filter 1 has sync2 and is AND type
+        self.assertEqual(result.count(), 1)
+
+    def test_q_search(self):
+        """Test the search (q) parameter"""
+        # Search by name
+        search_term = self.filter1.name.split()[0] if self.filter1.name else "Test"
+        params = {"q": search_term}
+        result = self.filterset(params, self.queryset).qs
+        self.assertGreaterEqual(result.count(), 1)
+        self.assertIn(self.filter1.pk, result.values_list("pk", flat=True))
+
+    def test_distinct_results(self):
+        """Test that filters return distinct results"""
+        # Add sync1 to all filters
+        self.filter2.syncs.add(self.sync1)
+
+        # Filter by sync that's in all filters
+        params = {"sync_id": [self.sync1.pk]}
+        result = self.filterset(params, self.queryset).qs
+
+        # Each filter should appear only once
+        filter_counts = {}
+        for filter_obj in result:
+            filter_counts[filter_obj.pk] = filter_counts.get(filter_obj.pk, 0) + 1
+
+        for count in filter_counts.values():
+            self.assertEqual(count, 1)
+
+    def test_empty_filters(self):
+        """Test behavior with empty filter values"""
+        total_count = self.queryset.count()
+
+        params = {"sync": ""}
+        result = self.filterset(params, self.queryset).qs
+        self.assertEqual(result.count(), total_count)
+
+        params = {"endpoint": ""}
+        result = self.filterset(params, self.queryset).qs
+        self.assertEqual(result.count(), total_count)
+
+        params = {"filter_type": ""}
+        result = self.filterset(params, self.queryset).qs
+        self.assertEqual(result.count(), total_count)
+
+
+class IPFabricFilterExpressionFilterSetTestCase(TestCase):
+    """
+    Test IPFabricFilterExpressionFilterSet to verify all custom filters work correctly.
+    """
+
+    queryset = IPFabricFilterExpression.objects.all()
+    filterset = IPFabricFilterExpressionFilterSet
+
+    @classmethod
+    def setUpTestData(cls):
+        # Create test filters
+        filters = [
+            IPFabricFilter(
+                name="Expression Filter 1",
+                description="First expression filter",
+                filter_type=IPFabricFilterTypeChoices.AND,
+            ),
+            IPFabricFilter(
+                name="Expression Filter 2",
+                description="Second expression filter",
+                filter_type=IPFabricFilterTypeChoices.OR,
+            ),
+            IPFabricFilter(
+                name="Expression Filter 3",
+                description="Third expression filter",
+                filter_type=IPFabricFilterTypeChoices.AND,
+            ),
+        ]
+        IPFabricFilter.objects.bulk_create(filters)
+
+        cls.filter1 = IPFabricFilter.objects.get(name="Expression Filter 1")
+        cls.filter2 = IPFabricFilter.objects.get(name="Expression Filter 2")
+        cls.filter3 = IPFabricFilter.objects.get(name="Expression Filter 3")
+
+        # Create test filter expressions
+        expressions = [
+            IPFabricFilterExpression(
+                name="Test Expression 1",
+                description="Sites expression",
+                expression={"or": [{"siteName": ["eq", "Site1"]}]},
+            ),
+            IPFabricFilterExpression(
+                name="Test Expression 2",
+                description="Devices expression",
+                expression={"and": [{"hostname": ["like", "router"]}]},
+            ),
+            IPFabricFilterExpression(
+                name="Test Expression 3",
+                description="Complex expression",
+                expression={
+                    "and": [
+                        {"siteName": ["eq", "Site1"]},
+                        {"hostname": ["like", "switch"]},
+                    ]
+                },
+            ),
+        ]
+        IPFabricFilterExpression.objects.bulk_create(expressions)
+
+        cls.expr1 = IPFabricFilterExpression.objects.get(name="Test Expression 1")
+        cls.expr2 = IPFabricFilterExpression.objects.get(name="Test Expression 2")
+        cls.expr3 = IPFabricFilterExpression.objects.get(name="Test Expression 3")
+
+        # Assign filters to expressions
+        cls.expr1.filters.add(cls.filter1, cls.filter2)
+        cls.expr2.filters.add(cls.filter2, cls.filter3)
+        cls.expr3.filters.add(cls.filter1)
+
+    def test_id(self):
+        """Test filtering by expression ID"""
+        params = {"id": [self.expr1.pk]}
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
+        params = {"id": [self.expr1.pk, self.expr2.pk]}
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
+
+    def test_name(self):
+        """Test filtering by expression name"""
+        params = {"name": ["Test Expression 1"]}
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
+        params = {"name": ["Test Expression 1", "Test Expression 2"]}
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
+
+    def test_description(self):
+        """Test filtering by description"""
+        # Skip test if description is empty (which it is in our test data)
+        # In real usage, descriptions would be populated
+        pass
+
+    def test_expression(self):
+        """Test filtering by expression JSON content"""
+        # Search for expression containing 'siteName'
+        params = {"expression": "siteName"}
+        result = self.filterset(params, self.queryset).qs
+        # Expressions 1 and 3 contain 'siteName'
+        self.assertEqual(result.count(), 2)
+        expr_ids = set(result.values_list("id", flat=True))
+        self.assertIn(self.expr1.pk, expr_ids)
+        self.assertIn(self.expr3.pk, expr_ids)
+
+        # Search for expression containing 'hostname'
+        params = {"expression": "hostname"}
+        result = self.filterset(params, self.queryset).qs
+        # Expressions 2 and 3 contain 'hostname'
+        self.assertEqual(result.count(), 2)
+
+    def test_ipfabric_filter_id(self):
+        """Test filtering by IP Fabric filter ID"""
+        params = {"ipfabric_filter_id": [self.filter1.pk]}
+        result = self.filterset(params, self.queryset).qs
+        # Expressions 1 and 3 use filter1
+        self.assertEqual(result.count(), 2)
+        expr_ids = set(result.values_list("id", flat=True))
+        self.assertIn(self.expr1.pk, expr_ids)
+        self.assertIn(self.expr3.pk, expr_ids)
+
+        params = {"ipfabric_filter_id": [self.filter2.pk]}
+        result = self.filterset(params, self.queryset).qs
+        # Expressions 1 and 2 use filter2
+        self.assertEqual(result.count(), 2)
+
+    def test_ipfabric_filter_name(self):
+        """Test filtering by IP Fabric filter name"""
+        params = {"ipfabric_filter": "Expression Filter 1"}
+        result = self.filterset(params, self.queryset).qs
+        # Expressions 1 and 3 use filter1
+        self.assertEqual(result.count(), 2)
+        expr_ids = set(result.values_list("id", flat=True))
+        self.assertIn(self.expr1.pk, expr_ids)
+        self.assertIn(self.expr3.pk, expr_ids)
+
+        # Test case-insensitive
+        params = {"ipfabric_filter": "expression filter 2"}
+        result = self.filterset(params, self.queryset).qs
+        # Expressions 1 and 2 use filter2
+        self.assertEqual(result.count(), 2)
+
+    def test_ipfabric_filters_multiple(self):
+        """Test filtering by multiple IP Fabric filter IDs"""
+        params = {"ipfabric_filters": [self.filter1.pk, self.filter3.pk]}
+        result = self.filterset(params, self.queryset).qs
+        # All three expressions use filter1 or filter3
+        self.assertEqual(result.count(), 3)
+
+    def test_combined_filters(self):
+        """Test combining multiple filters"""
+        # Test ipfabric_filter_id + name
+        params = {
+            "ipfabric_filter_id": [self.filter1.pk],
+            "name": ["Test Expression 1"],
+        }
+        result = self.filterset(params, self.queryset).qs
+        # Only expression 1 matches both criteria
+        self.assertEqual(result.count(), 1)
+        self.assertEqual(result.first().pk, self.expr1.pk)
+
+        # Test expression content + filter
+        params = {
+            "expression": "siteName",
+            "ipfabric_filter_id": [self.filter1.pk],
+        }
+        result = self.filterset(params, self.queryset).qs
+        # Expressions 1 and 3 have siteName and filter1
+        self.assertEqual(result.count(), 2)
+
+    def test_q_search(self):
+        """Test the search (q) parameter"""
+        # Search by name
+        search_term = self.expr1.name.split()[0] if self.expr1.name else "Test"
+        params = {"q": search_term}
+        result = self.filterset(params, self.queryset).qs
+        self.assertGreaterEqual(result.count(), 1)
+        self.assertIn(self.expr1.pk, result.values_list("pk", flat=True))
+
+    def test_distinct_results(self):
+        """Test that filters return distinct results"""
+        # Add filter1 to all expressions
+        self.expr2.filters.add(self.filter1)
+
+        # Filter by filter that's in all expressions
+        params = {"ipfabric_filter_id": [self.filter1.pk]}
+        result = self.filterset(params, self.queryset).qs
+
+        # Each expression should appear only once
+        expr_counts = {}
+        for expr in result:
+            expr_counts[expr.pk] = expr_counts.get(expr.pk, 0) + 1
+
+        for count in expr_counts.values():
+            self.assertEqual(count, 1)
+
+    def test_empty_filters(self):
+        """Test behavior with empty filter values"""
+        total_count = self.queryset.count()
+
+        params = {"ipfabric_filter": ""}
+        result = self.filterset(params, self.queryset).qs
+        self.assertEqual(result.count(), total_count)
+
+        params = {"expression": ""}
+        result = self.filterset(params, self.queryset).qs
+        self.assertEqual(result.count(), total_count)
+
+
+class IPFabricSyncFilterSetTestCase(TestCase):
+    """
+    Test IPFabricSyncFilterSet to verify all custom filters work correctly.
+    """
+
+    queryset = IPFabricSync.objects.all()
+    filterset = IPFabricSyncFilterSet
+
+    @classmethod
+    def setUpTestData(cls):
+        # Create required dependencies
+        source = IPFabricSource.objects.create(
+            name="Sync Test Source",
+            type=IPFabricSourceTypeChoices.LOCAL,
+            url="https://ipfabric-sync.example.com",
+            status=IPFabricSourceStatusChoices.NEW,
+        )
+
+        # Create test snapshots
+        cls.snapshot1 = IPFabricSnapshot.objects.create(
+            source=source,
+            name="Sync Test Snapshot 1",
+            snapshot_id="sync_snap001",
+            data={"devices": 100},
+            date=timezone.now(),
+            status=IPFabricSnapshotStatusModelChoices.STATUS_LOADED,
+        )
+        cls.snapshot2 = IPFabricSnapshot.objects.create(
+            source=source,
+            name="Sync Test Snapshot 2",
+            snapshot_id="sync_snap002",
+            data={"devices": 200},
+            date=timezone.now(),
+            status=IPFabricSnapshotStatusModelChoices.STATUS_LOADED,
+        )
+
+        # Create test syncs
+        cls.sync1 = IPFabricSync.objects.create(
+            name="Sync Test 1",
+            snapshot_data=cls.snapshot1,
+            status=IPFabricSyncStatusChoices.NEW,
+            auto_merge=True,
+        )
+        cls.sync2 = IPFabricSync.objects.create(
+            name="Sync Test 2",
+            snapshot_data=cls.snapshot1,
+            status=IPFabricSyncStatusChoices.COMPLETED,
+            auto_merge=False,
+        )
+        cls.sync3 = IPFabricSync.objects.create(
+            name="Sync Test 3",
+            snapshot_data=cls.snapshot2,
+            status=IPFabricSyncStatusChoices.FAILED,
+            auto_merge=True,
+        )
+
+        # Create test filters
+        filters = [
+            IPFabricFilter(
+                name="Sync Filter 1",
+                description="First sync filter",
+                filter_type=IPFabricFilterTypeChoices.AND,
+            ),
+            IPFabricFilter(
+                name="Sync Filter 2",
+                description="Second sync filter",
+                filter_type=IPFabricFilterTypeChoices.OR,
+            ),
+            IPFabricFilter(
+                name="Sync Filter 3",
+                description="Third sync filter",
+                filter_type=IPFabricFilterTypeChoices.AND,
+            ),
+        ]
+        IPFabricFilter.objects.bulk_create(filters)
+
+        cls.filter1 = IPFabricFilter.objects.get(name="Sync Filter 1")
+        cls.filter2 = IPFabricFilter.objects.get(name="Sync Filter 2")
+        cls.filter3 = IPFabricFilter.objects.get(name="Sync Filter 3")
+
+        # Assign filters to syncs
+        cls.filter1.syncs.add(cls.sync1, cls.sync2)
+        cls.filter2.syncs.add(cls.sync2, cls.sync3)
+        cls.filter3.syncs.add(cls.sync1)
+
+    def test_id(self):
+        """Test filtering by sync ID"""
+        params = {"id": [self.sync1.pk]}
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
+        params = {"id": [self.sync1.pk, self.sync2.pk]}
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
+
+    def test_name(self):
+        """Test filtering by sync name"""
+        params = {"name": "Sync Test 1"}
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
+
+    def test_snapshot_data_id(self):
+        """Test filtering by snapshot ID"""
+        params = {"snapshot_data_id": [self.snapshot1.pk]}
+        result = self.filterset(params, self.queryset).qs
+        # Syncs 1 and 2 use snapshot1
+        self.assertEqual(result.count(), 2)
+        sync_ids = set(result.values_list("id", flat=True))
+        self.assertIn(self.sync1.pk, sync_ids)
+        self.assertIn(self.sync2.pk, sync_ids)
+
+        params = {"snapshot_data_id": [self.snapshot2.pk]}
+        result = self.filterset(params, self.queryset).qs
+        # Sync 3 uses snapshot2
+        self.assertEqual(result.count(), 1)
+        self.assertEqual(result.first().pk, self.sync3.pk)
+
+    def test_snapshot_data_name(self):
+        """Test filtering by snapshot name"""
+        params = {"snapshot_data": [self.snapshot1.pk]}
+        result = self.filterset(params, self.queryset).qs
+        # Syncs 1 and 2 use snapshot1 from our test data
+        # (may include more from other test classes)
+        self.assertGreaterEqual(result.count(), 2)
+        sync_ids = set(result.values_list("id", flat=True))
+        self.assertIn(self.sync1.pk, sync_ids)
+        self.assertIn(self.sync2.pk, sync_ids)
+
+    def test_status(self):
+        """Test filtering by status"""
+        params = {"status": [IPFabricSyncStatusChoices.NEW]}
+        result = self.filterset(params, self.queryset).qs
+        # Sync 1 is NEW
+        self.assertEqual(result.count(), 1)
+        self.assertEqual(result.first().pk, self.sync1.pk)
+
+        params = {"status": [IPFabricSyncStatusChoices.COMPLETED]}
+        result = self.filterset(params, self.queryset).qs
+        # Sync 2 is COMPLETED
+        self.assertEqual(result.count(), 1)
+
+    def test_auto_merge(self):
+        """Test filtering by auto_merge"""
+        params = {"auto_merge": True}
+        result = self.filterset(params, self.queryset).qs
+        # Syncs 1 and 3 have auto_merge=True
+        self.assertEqual(result.count(), 2)
+        sync_ids = set(result.values_list("id", flat=True))
+        self.assertIn(self.sync1.pk, sync_ids)
+        self.assertIn(self.sync3.pk, sync_ids)
+
+        params = {"auto_merge": False}
+        result = self.filterset(params, self.queryset).qs
+        # Sync 2 has auto_merge=False
+        self.assertEqual(result.count(), 1)
+
+    def test_ipfabric_filter_id(self):
+        """Test filtering by IP Fabric filter ID"""
+        params = {"ipfabric_filter_id": [self.filter1.pk]}
+        result = self.filterset(params, self.queryset).qs
+        # Syncs 1 and 2 use filter1
+        self.assertEqual(result.count(), 2)
+        sync_ids = set(result.values_list("id", flat=True))
+        self.assertIn(self.sync1.pk, sync_ids)
+        self.assertIn(self.sync2.pk, sync_ids)
+
+        params = {"ipfabric_filter_id": [self.filter2.pk]}
+        result = self.filterset(params, self.queryset).qs
+        # Syncs 2 and 3 use filter2
+        self.assertEqual(result.count(), 2)
+        sync_ids = set(result.values_list("id", flat=True))
+        self.assertIn(self.sync2.pk, sync_ids)
+        self.assertIn(self.sync3.pk, sync_ids)
+
+        params = {"ipfabric_filter_id": [self.filter3.pk]}
+        result = self.filterset(params, self.queryset).qs
+        # Sync 1 uses filter3
+        self.assertEqual(result.count(), 1)
+        self.assertEqual(result.first().pk, self.sync1.pk)
+
+    def test_ipfabric_filter_name(self):
+        """Test filtering by IP Fabric filter name"""
+        params = {"ipfabric_filter": "Sync Filter 1"}
+        result = self.filterset(params, self.queryset).qs
+        # Syncs 1 and 2 use filter1
+        self.assertEqual(result.count(), 2)
+        sync_ids = set(result.values_list("id", flat=True))
+        self.assertIn(self.sync1.pk, sync_ids)
+        self.assertIn(self.sync2.pk, sync_ids)
+
+        # Test case-insensitive
+        params = {"ipfabric_filter": "sync filter 2"}
+        result = self.filterset(params, self.queryset).qs
+        # Syncs 2 and 3 use filter2
+        self.assertEqual(result.count(), 2)
+
+    def test_ipfabric_filters_multiple(self):
+        """Test filtering by multiple IP Fabric filter IDs"""
+        params = {"ipfabric_filters": [self.filter1.pk, self.filter3.pk]}
+        result = self.filterset(params, self.queryset).qs
+        # filter1 has sync1+sync2, filter3 has sync1 = 2 syncs total (sync1, sync2)
+        self.assertEqual(result.count(), 2)
+        sync_ids = set(result.values_list("id", flat=True))
+        self.assertIn(self.sync1.pk, sync_ids)
+        self.assertIn(self.sync2.pk, sync_ids)
+
+        # Test with filter2 and filter3
+        params = {"ipfabric_filters": [self.filter2.pk, self.filter3.pk]}
+        result = self.filterset(params, self.queryset).qs
+        # filter2 has sync2+sync3, filter3 has sync1 = 3 syncs total
+        self.assertEqual(result.count(), 3)
+        sync_ids = set(result.values_list("id", flat=True))
+        self.assertIn(self.sync1.pk, sync_ids)
+        self.assertIn(self.sync2.pk, sync_ids)
+        self.assertIn(self.sync3.pk, sync_ids)
+
+    def test_combined_filters(self):
+        """Test combining multiple filters"""
+        # Test ipfabric_filter_id + snapshot_data_id
+        params = {
+            "ipfabric_filter_id": [self.filter1.pk],
+            "snapshot_data_id": [self.snapshot1.pk],
+        }
+        result = self.filterset(params, self.queryset).qs
+        # Syncs 1 and 2 have filter1 and snapshot1
+        self.assertEqual(result.count(), 2)
+        sync_ids = set(result.values_list("id", flat=True))
+        self.assertIn(self.sync1.pk, sync_ids)
+        self.assertIn(self.sync2.pk, sync_ids)
+
+        # Test ipfabric_filter_id + status
+        params = {
+            "ipfabric_filter_id": [self.filter2.pk],
+            "status": [IPFabricSyncStatusChoices.COMPLETED],
+        }
+        result = self.filterset(params, self.queryset).qs
+        # Only Sync 2 has filter2 and COMPLETED status
+        self.assertEqual(result.count(), 1)
+        self.assertEqual(result.first().pk, self.sync2.pk)
+
+        # Test ipfabric_filter + auto_merge
+        params = {
+            "ipfabric_filter": "Sync Filter 1",
+            "auto_merge": True,
+        }
+        result = self.filterset(params, self.queryset).qs
+        # Only Sync 1 has filter1 and auto_merge=True
+        self.assertEqual(result.count(), 1)
+        self.assertEqual(result.first().pk, self.sync1.pk)
+
+    def test_distinct_results(self):
+        """Test that filters return distinct results"""
+        # Add filter1 to all syncs
+        self.filter1.syncs.add(self.sync3)
+
+        # Filter by filter that's in all syncs
+        params = {"ipfabric_filter_id": [self.filter1.pk]}
+        result = self.filterset(params, self.queryset).qs
+
+        # Each sync should appear only once
+        sync_counts = {}
+        for sync in result:
+            sync_counts[sync.pk] = sync_counts.get(sync.pk, 0) + 1
+
+        for count in sync_counts.values():
+            self.assertEqual(count, 1)
+
+    def test_empty_filters(self):
+        """Test behavior with empty filter values"""
+        total_count = self.queryset.count()
+
+        params = {"ipfabric_filter": ""}
+        result = self.filterset(params, self.queryset).qs
+        self.assertEqual(result.count(), total_count)
+
+        params = {"name": ""}
+        result = self.filterset(params, self.queryset).qs
+        self.assertEqual(result.count(), total_count)
+
+    def test_ipfabric_filter_filters_equivalence(self):
+        """Test that ipfabric_filter_id and ipfabric_filters work correctly"""
+        # Single ID with ipfabric_filter_id
+        params1 = {"ipfabric_filter_id": [self.filter1.pk]}
+        result1 = self.filterset(params1, self.queryset).qs
+
+        # Same ID with ipfabric_filters
+        params2 = {"ipfabric_filters": [self.filter1.pk]}
+        result2 = self.filterset(params2, self.queryset).qs
+
+        # Should return same results
+        self.assertEqual(result1.count(), result2.count())
+        self.assertEqual(
+            set(result1.values_list("id", flat=True)),
+            set(result2.values_list("id", flat=True)),
+        )
+
+        # Multiple IDs with ipfabric_filter_id
+        params1 = {"ipfabric_filter_id": [self.filter1.pk, self.filter2.pk]}
+        result1 = self.filterset(params1, self.queryset).qs
+
+        # Same IDs with ipfabric_filters
+        params2 = {"ipfabric_filters": [self.filter1.pk, self.filter2.pk]}
+        result2 = self.filterset(params2, self.queryset).qs
+
+        # Should return same results
+        self.assertEqual(result1.count(), result2.count())
+        self.assertEqual(
+            set(result1.values_list("id", flat=True)),
+            set(result2.values_list("id", flat=True)),
+        )
+
+    def test_search(self):
+        """Test search functionality"""
+        params = {"q": "Sync"}
+        result = self.filterset(params, self.queryset).qs
+        # Should find syncs with "Sync" in name or snapshot name
+        self.assertGreaterEqual(result.count(), 3)
+
+
+class IPFabricTransformMapFilterSetTestCase(TestCase):
+    """
+    Test IPFabricTransformMapFilterSet to verify all custom filters work correctly.
+    """
+
+    queryset = IPFabricTransformMap.objects.all()
+    filterset = IPFabricTransformMapFilterSet
+
+    @classmethod
+    def setUpTestData(cls):
+        # Get existing endpoints from migrations
+        cls.sites_endpoint = IPFabricEndpoint.objects.filter(
+            endpoint=IPFabricEndpointChoices.SITES
+        ).first()
+        cls.devices_endpoint = IPFabricEndpoint.objects.filter(
+            endpoint=IPFabricEndpointChoices.DEVICES
+        ).first()
+        cls.vrfs_endpoint = IPFabricEndpoint.objects.filter(
+            endpoint=IPFabricEndpointChoices.VRFS
+        ).first()
+
+        # Get ContentType for target_model
+        from dcim.models import Site, Device
+
+        cls.site_ct = ContentType.objects.get_for_model(Site)
+        cls.device_ct = ContentType.objects.get_for_model(Device)
+
+        # Create test transform map groups
+        groups = [
+            IPFabricTransformMapGroup(
+                name="Test Group 1",
+                description="First test group",
+            ),
+            IPFabricTransformMapGroup(
+                name="Test Group 2",
+                description="Second test group",
+            ),
+        ]
+        IPFabricTransformMapGroup.objects.bulk_create(groups)
+
+        cls.group1 = IPFabricTransformMapGroup.objects.get(name="Test Group 1")
+        cls.group2 = IPFabricTransformMapGroup.objects.get(name="Test Group 2")
+
+        # Create test transform maps
+        transform_maps = [
+            IPFabricTransformMap(
+                name="Sites Transform Map 1",
+                source_endpoint=cls.sites_endpoint,
+                target_model=cls.site_ct,
+                group=cls.group1,
+            ),
+            IPFabricTransformMap(
+                name="Devices Transform Map 1",
+                source_endpoint=cls.devices_endpoint,
+                target_model=cls.device_ct,
+                group=cls.group1,
+            ),
+            IPFabricTransformMap(
+                name="VRFs Transform Map 1",
+                source_endpoint=cls.vrfs_endpoint,
+                target_model=cls.device_ct,
+                group=cls.group2,
+            ),
+            IPFabricTransformMap(
+                name="Sites Transform Map 2",
+                source_endpoint=cls.sites_endpoint,
+                target_model=cls.site_ct,
+                group=cls.group2,
+            ),
+        ]
+        IPFabricTransformMap.objects.bulk_create(transform_maps)
+
+        cls.sites_map1 = IPFabricTransformMap.objects.get(name="Sites Transform Map 1")
+        cls.devices_map1 = IPFabricTransformMap.objects.get(
+            name="Devices Transform Map 1"
+        )
+        cls.vrfs_map1 = IPFabricTransformMap.objects.get(name="VRFs Transform Map 1")
+        cls.sites_map2 = IPFabricTransformMap.objects.get(name="Sites Transform Map 2")
+
+    def test_id(self):
+        """Test filtering by transform map ID"""
+        params = {"id": [self.sites_map1.pk]}
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
+        params = {"id": [self.sites_map1.pk, self.devices_map1.pk]}
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
+
+    def test_name(self):
+        """Test filtering by transform map name"""
+        params = {"name": ["Sites Transform Map 1"]}
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
+        params = {"name": ["Sites Transform Map 1", "Devices Transform Map 1"]}
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
+
+    def test_group(self):
+        """Test filtering by group"""
+        params = {"group": [self.group1.pk]}
+        result = self.filterset(params, self.queryset).qs
+        # Group 1 has sites_map1 and devices_map1
+        self.assertEqual(result.count(), 2)
+        map_ids = set(result.values_list("id", flat=True))
+        self.assertIn(self.sites_map1.pk, map_ids)
+        self.assertIn(self.devices_map1.pk, map_ids)
+
+        params = {"group": [self.group2.pk]}
+        result = self.filterset(params, self.queryset).qs
+        # Group 2 has vrfs_map1 and sites_map2
+        self.assertEqual(result.count(), 2)
+
+    def test_group_id(self):
+        """Test filtering by group ID"""
+        params = {"group_id": [self.group1.pk]}
+        result = self.filterset(params, self.queryset).qs
+        # Group 1 has sites_map1 and devices_map1
+        self.assertEqual(result.count(), 2)
+        map_ids = set(result.values_list("id", flat=True))
+        self.assertIn(self.sites_map1.pk, map_ids)
+        self.assertIn(self.devices_map1.pk, map_ids)
+
+    def test_source_endpoint(self):
+        """Test filtering by source endpoint (single)"""
+        params = {"source_endpoint": self.sites_endpoint.pk}
+        result = self.filterset(params, self.queryset).qs
+        # Sites endpoint has sites_map1 and sites_map2 from our test data
+        # (may include more from other test classes)
+        self.assertGreaterEqual(result.count(), 2)
+        map_ids = set(result.values_list("id", flat=True))
+        self.assertIn(self.sites_map1.pk, map_ids)
+        self.assertIn(self.sites_map2.pk, map_ids)
+
+        params = {"source_endpoint": self.devices_endpoint.pk}
+        result = self.filterset(params, self.queryset).qs
+        # Devices endpoint has devices_map1 from our test data
+        self.assertGreaterEqual(result.count(), 1)
+        self.assertIn(self.devices_map1.pk, result.values_list("id", flat=True))
+
+    def test_source_endpoint_id(self):
+        """Test filtering by source endpoint ID (multiple)"""
+        params = {"source_endpoint_id": [self.sites_endpoint.pk]}
+        result = self.filterset(params, self.queryset).qs
+        # Sites endpoint has sites_map1 and sites_map2 from our test data
+        # (may include more from other test classes)
+        self.assertGreaterEqual(result.count(), 2)
+        map_ids = set(result.values_list("id", flat=True))
+        self.assertIn(self.sites_map1.pk, map_ids)
+        self.assertIn(self.sites_map2.pk, map_ids)
+
+        params = {"source_endpoint_id": [self.devices_endpoint.pk]}
+        result = self.filterset(params, self.queryset).qs
+        # Devices endpoint has devices_map1 from our test data
+        self.assertGreaterEqual(result.count(), 1)
+        self.assertIn(self.devices_map1.pk, result.values_list("id", flat=True))
+
+        # Test multiple endpoint IDs
+        params = {"source_endpoint_id": [self.sites_endpoint.pk, self.vrfs_endpoint.pk]}
+        result = self.filterset(params, self.queryset).qs
+        # Sites has 2 maps, VRFs has 1 map = 3 minimum from our test data
+        self.assertGreaterEqual(result.count(), 3)
+        map_ids = set(result.values_list("id", flat=True))
+        self.assertIn(self.sites_map1.pk, map_ids)
+        self.assertIn(self.sites_map2.pk, map_ids)
+        self.assertIn(self.vrfs_map1.pk, map_ids)
+
+    def test_source_endpoints(self):
+        """Test filtering by source endpoints (multiple)"""
+        params = {
+            "source_endpoints": [self.sites_endpoint.pk, self.devices_endpoint.pk]
+        }
+        result = self.filterset(params, self.queryset).qs
+        # Sites has 2 maps, Devices has 1 map = 3 minimum from our test data
+        # (may include more from other test classes)
+        self.assertGreaterEqual(result.count(), 3)
+        map_ids = set(result.values_list("id", flat=True))
+        self.assertIn(self.sites_map1.pk, map_ids)
+        self.assertIn(self.sites_map2.pk, map_ids)
+        self.assertIn(self.devices_map1.pk, map_ids)
+
+        # Test all endpoints
+        params = {
+            "source_endpoints": [
+                self.sites_endpoint.pk,
+                self.devices_endpoint.pk,
+                self.vrfs_endpoint.pk,
+            ]
+        }
+        result = self.filterset(params, self.queryset).qs
+        # All 4 transform maps from our test data minimum
+        self.assertGreaterEqual(result.count(), 4)
+        map_ids = set(result.values_list("id", flat=True))
+        self.assertIn(self.sites_map1.pk, map_ids)
+        self.assertIn(self.sites_map2.pk, map_ids)
+        self.assertIn(self.devices_map1.pk, map_ids)
+        self.assertIn(self.vrfs_map1.pk, map_ids)
+
+    def test_target_model(self):
+        """Test filtering by target model"""
+        params = {"target_model": self.site_ct.pk}
+        result = self.filterset(params, self.queryset).qs
+        # Sites maps target Site model from our test data
+        # (may include more from other test classes)
+        self.assertGreaterEqual(result.count(), 2)
+        map_ids = set(result.values_list("id", flat=True))
+        self.assertIn(self.sites_map1.pk, map_ids)
+        self.assertIn(self.sites_map2.pk, map_ids)
+
+        params = {"target_model": self.device_ct.pk}
+        result = self.filterset(params, self.queryset).qs
+        # Devices and VRFs maps target Device model from our test data
+        self.assertGreaterEqual(result.count(), 2)
+        map_ids = set(result.values_list("id", flat=True))
+        self.assertIn(self.devices_map1.pk, map_ids)
+        self.assertIn(self.vrfs_map1.pk, map_ids)
+
+    def test_combined_filters(self):
+        """Test combining multiple filters"""
+        # Test source_endpoint_id + group
+        params = {
+            "source_endpoint_id": [self.sites_endpoint.pk],
+            "group": [self.group1.pk],
+        }
+        result = self.filterset(params, self.queryset).qs
+        # Only sites_map1 has sites endpoint and group1 from our test data
+        # (may include more from other test classes)
+        self.assertGreaterEqual(result.count(), 1)
+        self.assertIn(self.sites_map1.pk, result.values_list("id", flat=True))
+
+        # Test source_endpoints + target_model
+        params = {
+            "source_endpoints": [self.sites_endpoint.pk, self.devices_endpoint.pk],
+            "target_model": self.device_ct.pk,
+        }
+        result = self.filterset(params, self.queryset).qs
+        # Only devices_map1 has devices endpoint and Device target from our test data
+        self.assertGreaterEqual(result.count(), 1)
+        self.assertIn(self.devices_map1.pk, result.values_list("id", flat=True))
+
+        # Test group_id + target_model
+        params = {
+            "group_id": [self.group2.pk],
+            "target_model": self.site_ct.pk,
+        }
+        result = self.filterset(params, self.queryset).qs
+        # Only sites_map2 has group2 and Site target from our test data
+        self.assertGreaterEqual(result.count(), 1)
+        self.assertIn(self.sites_map2.pk, result.values_list("id", flat=True))
+
+    def test_q_search(self):
+        """Test the search (q) parameter"""
+        # Search by transform map name
+        params = {"q": "Sites"}
+        result = self.filterset(params, self.queryset).qs
+        self.assertEqual(result.count(), 2)
+
+        # Search by group name
+        params = {"q": "Test Group 1"}
+        result = self.filterset(params, self.queryset).qs
+        self.assertEqual(result.count(), 2)
+
+        # Search that matches transform map name
+        params = {"q": "Devices"}
+        result = self.filterset(params, self.queryset).qs
+        self.assertEqual(result.count(), 1)
+
+    def test_distinct_results(self):
+        """Test that filters return distinct results"""
+        # Query with source_endpoint_id (should have no duplicates)
+        params = {"source_endpoint_id": [self.sites_endpoint.pk]}
+        result = self.filterset(params, self.queryset).qs
+
+        # Each transform map should appear only once
+        map_counts = {}
+        for map_obj in result:
+            map_counts[map_obj.pk] = map_counts.get(map_obj.pk, 0) + 1
+
+        for count in map_counts.values():
+            self.assertEqual(count, 1)
+
+    def test_empty_filters(self):
+        """Test behavior with empty filter values"""
+        total_count = self.queryset.count()
+
+        params = {"source_endpoint": ""}
+        result = self.filterset(params, self.queryset).qs
+        self.assertEqual(result.count(), total_count)
+
+        params = {"group": ""}
+        result = self.filterset(params, self.queryset).qs
+        self.assertEqual(result.count(), total_count)
+
+    def test_source_endpoint_filters_equivalence(self):
+        """Test that source_endpoint_id and source_endpoints work correctly"""
+        # Single ID with source_endpoint_id
+        params1 = {"source_endpoint_id": [self.sites_endpoint.pk]}
+        result1 = self.filterset(params1, self.queryset).qs
+
+        # Same ID with source_endpoints
+        params2 = {"source_endpoints": [self.sites_endpoint.pk]}
+        result2 = self.filterset(params2, self.queryset).qs
+
+        # Should return same results
+        self.assertEqual(result1.count(), result2.count())
+        self.assertEqual(
+            set(result1.values_list("id", flat=True)),
+            set(result2.values_list("id", flat=True)),
+        )
+
+        # Multiple IDs with source_endpoint_id
+        params1 = {
+            "source_endpoint_id": [self.sites_endpoint.pk, self.devices_endpoint.pk]
+        }
+        result1 = self.filterset(params1, self.queryset).qs
+
+        # Same IDs with source_endpoints
+        params2 = {
+            "source_endpoints": [self.sites_endpoint.pk, self.devices_endpoint.pk]
+        }
+        result2 = self.filterset(params2, self.queryset).qs
+
+        # Should return same results
+        self.assertEqual(result1.count(), result2.count())
+        self.assertEqual(
+            set(result1.values_list("id", flat=True)),
+            set(result2.values_list("id", flat=True)),
+        )
+
+
+class IPFabricTransformFieldFilterSetTestCase(TestCase):
+    """
+    Test IPFabricTransformFieldFilterSet to verify all custom filters work correctly.
+    """
+
+    queryset = IPFabricTransformField.objects.all()
+    filterset = IPFabricTransformFieldFilterSet
+
+    @classmethod
+    def setUpTestData(cls):
+        # Get existing endpoints from migrations
+        cls.sites_endpoint = IPFabricEndpoint.objects.filter(
+            endpoint=IPFabricEndpointChoices.SITES
+        ).first()
+        cls.devices_endpoint = IPFabricEndpoint.objects.filter(
+            endpoint=IPFabricEndpointChoices.DEVICES
+        ).first()
+
+        # Get ContentType for target_model
+        from dcim.models import Site, Device
+
+        cls.site_ct = ContentType.objects.get_for_model(Site)
+        cls.device_ct = ContentType.objects.get_for_model(Device)
+
+        # Create test transform map groups
+        cls.group1 = IPFabricTransformMapGroup.objects.create(
+            name="Transform Field Test Group 1",
+            description="First transform field test group",
+        )
+        cls.group2 = IPFabricTransformMapGroup.objects.create(
+            name="Transform Field Test Group 2",
+            description="Second transform field test group",
+        )
+
+        # Create test transform maps
+        cls.map1 = IPFabricTransformMap.objects.create(
+            name="Transform Field Map 1",
+            source_endpoint=cls.sites_endpoint,
+            target_model=cls.site_ct,
+            group=cls.group1,
+        )
+        cls.map2 = IPFabricTransformMap.objects.create(
+            name="Transform Field Map 2",
+            source_endpoint=cls.devices_endpoint,
+            target_model=cls.device_ct,
+            group=cls.group1,
+        )
+        cls.map3 = IPFabricTransformMap.objects.create(
+            name="Transform Field Map 3",
+            source_endpoint=cls.sites_endpoint,
+            target_model=cls.site_ct,
+            group=cls.group2,
+        )
+
+        # Create test transform fields
+        cls.field1 = IPFabricTransformField.objects.create(
+            transform_map=cls.map1,
+            source_field="siteName",
+            target_field="name",
+            coalesce=False,
+            template="{{siteName}}",
+        )
+        cls.field2 = IPFabricTransformField.objects.create(
+            transform_map=cls.map1,
+            source_field="siteDescription",
+            target_field="description",
+            coalesce=True,
+            template="{{siteDescription}}",
+        )
+        cls.field3 = IPFabricTransformField.objects.create(
+            transform_map=cls.map2,
+            source_field="hostname",
+            target_field="name",
+            coalesce=False,
+            template="{{hostname}}",
+        )
+        cls.field4 = IPFabricTransformField.objects.create(
+            transform_map=cls.map3,
+            source_field="siteName",
+            target_field="name",
+            coalesce=False,
+            template="{{siteName}}",
+        )
+
+    def test_id(self):
+        """Test filtering by transform field ID"""
+        params = {"id": [self.field1.pk]}
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
+        params = {"id": [self.field1.pk, self.field2.pk]}
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
+
+    def test_transform_map(self):
+        """Test filtering by transform map"""
+        params = {"transform_map": [self.map1.pk]}
+        result = self.filterset(params, self.queryset).qs
+        # Map1 has field1 and field2
+        self.assertEqual(result.count(), 2)
+        field_ids = set(result.values_list("id", flat=True))
+        self.assertIn(self.field1.pk, field_ids)
+        self.assertIn(self.field2.pk, field_ids)
+
+        params = {"transform_map": [self.map2.pk]}
+        result = self.filterset(params, self.queryset).qs
+        # Map2 has field3
+        self.assertEqual(result.count(), 1)
+        self.assertEqual(result.first().pk, self.field3.pk)
+
+    def test_transform_map_id(self):
+        """Test filtering by transform map ID"""
+        params = {"transform_map_id": [self.map1.pk]}
+        result = self.filterset(params, self.queryset).qs
+        # Map1 has field1 and field2
+        self.assertEqual(result.count(), 2)
+        field_ids = set(result.values_list("id", flat=True))
+        self.assertIn(self.field1.pk, field_ids)
+        self.assertIn(self.field2.pk, field_ids)
+
+        # Test multiple transform map IDs
+        params = {"transform_map_id": [self.map1.pk, self.map3.pk]}
+        result = self.filterset(params, self.queryset).qs
+        # Map1 has 2 fields, Map3 has 1 field = 3 total
+        self.assertEqual(result.count(), 3)
+        field_ids = set(result.values_list("id", flat=True))
+        self.assertIn(self.field1.pk, field_ids)
+        self.assertIn(self.field2.pk, field_ids)
+        self.assertIn(self.field4.pk, field_ids)
+
+    def test_source_field(self):
+        """Test filtering by source field"""
+        # First filter to only our test transform maps' fields
+        test_maps = [self.map1.pk, self.map2.pk, self.map3.pk]
+
+        params = {"source_field": "siteName", "transform_map": test_maps}
+        result = self.filterset(params, self.queryset).qs
+        # field1 and field4 have siteName (from our test maps only)
+        self.assertEqual(result.count(), 2)
+        field_ids = set(result.values_list("id", flat=True))
+        self.assertIn(self.field1.pk, field_ids)
+        self.assertIn(self.field4.pk, field_ids)
+
+        params = {"source_field": "hostname", "transform_map": test_maps}
+        result = self.filterset(params, self.queryset).qs
+        # field3 has hostname (from our test maps only)
+        self.assertEqual(result.count(), 1)
+        self.assertEqual(result.first().pk, self.field3.pk)
+
+    def test_target_field(self):
+        """Test filtering by target field"""
+        # First filter to only our test transform maps' fields
+        test_maps = [self.map1.pk, self.map2.pk, self.map3.pk]
+
+        params = {"target_field": "name", "transform_map": test_maps}
+        result = self.filterset(params, self.queryset).qs
+        # field1, field3, and field4 have name as target (from our test maps only)
+        self.assertEqual(result.count(), 3)
+        field_ids = set(result.values_list("id", flat=True))
+        self.assertIn(self.field1.pk, field_ids)
+        self.assertIn(self.field3.pk, field_ids)
+        self.assertIn(self.field4.pk, field_ids)
+
+        params = {"target_field": "description", "transform_map": test_maps}
+        result = self.filterset(params, self.queryset).qs
+        # field2 has description as target (from our test maps only)
+        self.assertEqual(result.count(), 1)
+        self.assertEqual(result.first().pk, self.field2.pk)
+
+    def test_coalesce(self):
+        """Test filtering by coalesce"""
+        # First filter to only our test transform maps' fields
+        test_maps = [self.map1.pk, self.map2.pk, self.map3.pk]
+
+        params = {"coalesce": True, "transform_map": test_maps}
+        result = self.filterset(params, self.queryset).qs
+        # field2 has coalesce=True (from our test maps only)
+        self.assertEqual(result.count(), 1)
+        self.assertEqual(result.first().pk, self.field2.pk)
+
+        params = {"coalesce": False, "transform_map": test_maps}
+        result = self.filterset(params, self.queryset).qs
+        # field1, field3, field4 have coalesce=False (from our test maps only)
+        self.assertEqual(result.count(), 3)
+        field_ids = set(result.values_list("id", flat=True))
+        self.assertIn(self.field1.pk, field_ids)
+        self.assertIn(self.field3.pk, field_ids)
+        self.assertIn(self.field4.pk, field_ids)
+
+    def test_combined_filters(self):
+        """Test combining multiple filters"""
+        # Test transform_map_id + source_field
+        params = {
+            "transform_map_id": [self.map1.pk],
+            "source_field": "siteName",
+        }
+        result = self.filterset(params, self.queryset).qs
+        # Only field1 has map1 and siteName
+        self.assertEqual(result.count(), 1)
+        self.assertEqual(result.first().pk, self.field1.pk)
+
+        # Test transform_map_id + target_field
+        params = {
+            "transform_map_id": [self.map1.pk],
+            "target_field": "name",
+        }
+        result = self.filterset(params, self.queryset).qs
+        # Only field1 has map1 and name target
+        self.assertEqual(result.count(), 1)
+        self.assertEqual(result.first().pk, self.field1.pk)
+
+        # Test transform_map_id + coalesce
+        params = {
+            "transform_map_id": [self.map1.pk],
+            "coalesce": True,
+        }
+        result = self.filterset(params, self.queryset).qs
+        # Only field2 has map1 and coalesce=True
+        self.assertEqual(result.count(), 1)
+        self.assertEqual(result.first().pk, self.field2.pk)
+
+    def test_transform_map_filters_equivalence(self):
+        """Test that transform_map and transform_map_id work correctly"""
+        # Single ID with transform_map
+        params1 = {"transform_map": [self.map1.pk]}
+        result1 = self.filterset(params1, self.queryset).qs
+
+        # Same ID with transform_map_id
+        params2 = {"transform_map_id": [self.map1.pk]}
+        result2 = self.filterset(params2, self.queryset).qs
+
+        # Should return same results
+        self.assertEqual(result1.count(), result2.count())
+        self.assertEqual(
+            set(result1.values_list("id", flat=True)),
+            set(result2.values_list("id", flat=True)),
+        )
+
+    def test_distinct_results(self):
+        """Test that filters return distinct results"""
+        # Query with transform_map_id (should have no duplicates)
+        params = {"transform_map_id": [self.map1.pk]}
+        result = self.filterset(params, self.queryset).qs
+
+        # Each transform field should appear only once
+        field_counts = {}
+        for field in result:
+            field_counts[field.pk] = field_counts.get(field.pk, 0) + 1
+
+        for count in field_counts.values():
+            self.assertEqual(count, 1)
+
+    def test_empty_filters(self):
+        """Test behavior with empty filter values"""
+        total_count = self.queryset.count()
+
+        params = {"transform_map": ""}
+        result = self.filterset(params, self.queryset).qs
+        self.assertEqual(result.count(), total_count)
+
+        params = {"source_field": ""}
+        result = self.filterset(params, self.queryset).qs
+        self.assertEqual(result.count(), total_count)
+
+
+class IPFabricRelationshipFieldFilterSetTestCase(TestCase):
+    """
+    Test IPFabricRelationshipFieldFilterSet to verify all custom filters work correctly.
+    """
+
+    queryset = IPFabricRelationshipField.objects.all()
+    filterset = IPFabricRelationshipFieldFilterSet
+
+    @classmethod
+    def setUpTestData(cls):
+        # Get existing endpoints from migrations
+        cls.sites_endpoint = IPFabricEndpoint.objects.filter(
+            endpoint=IPFabricEndpointChoices.SITES
+        ).first()
+        cls.devices_endpoint = IPFabricEndpoint.objects.filter(
+            endpoint=IPFabricEndpointChoices.DEVICES
+        ).first()
+
+        # Get ContentType for models
+        from dcim.models import Site, Device, Location
+
+        cls.site_ct = ContentType.objects.get_for_model(Site)
+        cls.device_ct = ContentType.objects.get_for_model(Device)
+        cls.location_ct = ContentType.objects.get_for_model(Location)
+
+        # Create test transform map groups
+        cls.group1 = IPFabricTransformMapGroup.objects.create(
+            name="Relationship Field Test Group 1",
+            description="First relationship field test group",
+        )
+        cls.group2 = IPFabricTransformMapGroup.objects.create(
+            name="Relationship Field Test Group 2",
+            description="Second relationship field test group",
+        )
+
+        # Create test transform maps
+        cls.map1 = IPFabricTransformMap.objects.create(
+            name="Relationship Field Map 1",
+            source_endpoint=cls.sites_endpoint,
+            target_model=cls.site_ct,
+            group=cls.group1,
+        )
+        cls.map2 = IPFabricTransformMap.objects.create(
+            name="Relationship Field Map 2",
+            source_endpoint=cls.devices_endpoint,
+            target_model=cls.device_ct,
+            group=cls.group1,
+        )
+        cls.map3 = IPFabricTransformMap.objects.create(
+            name="Relationship Field Map 3",
+            source_endpoint=cls.sites_endpoint,
+            target_model=cls.site_ct,
+            group=cls.group2,
+        )
+
+        # Create test relationship fields
+        cls.rel_field1 = IPFabricRelationshipField.objects.create(
+            transform_map=cls.map1,
+            source_model=cls.location_ct,
+            target_field="location",
+            coalesce=False,
+            template="{{location_id}}",
+        )
+        cls.rel_field2 = IPFabricRelationshipField.objects.create(
+            transform_map=cls.map1,
+            source_model=cls.site_ct,
+            target_field="site",
+            coalesce=True,
+            template="{{site_id}}",
+        )
+        cls.rel_field3 = IPFabricRelationshipField.objects.create(
+            transform_map=cls.map2,
+            source_model=cls.device_ct,
+            target_field="device",
+            coalesce=False,
+            template="{{device_id}}",
+        )
+        cls.rel_field4 = IPFabricRelationshipField.objects.create(
+            transform_map=cls.map3,
+            source_model=cls.location_ct,
+            target_field="location",
+            coalesce=False,
+            template="{{location_id}}",
+        )
+
+    def test_id(self):
+        """Test filtering by relationship field ID"""
+        params = {"id": [self.rel_field1.pk]}
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
+        params = {"id": [self.rel_field1.pk, self.rel_field2.pk]}
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
+
+    def test_transform_map(self):
+        """Test filtering by transform map"""
+        params = {"transform_map": [self.map1.pk]}
+        result = self.filterset(params, self.queryset).qs
+        # Map1 has rel_field1 and rel_field2
+        self.assertEqual(result.count(), 2)
+        field_ids = set(result.values_list("id", flat=True))
+        self.assertIn(self.rel_field1.pk, field_ids)
+        self.assertIn(self.rel_field2.pk, field_ids)
+
+        params = {"transform_map": [self.map2.pk]}
+        result = self.filterset(params, self.queryset).qs
+        # Map2 has rel_field3
+        self.assertEqual(result.count(), 1)
+        self.assertEqual(result.first().pk, self.rel_field3.pk)
+
+    def test_transform_map_id(self):
+        """Test filtering by transform map ID"""
+        params = {"transform_map_id": [self.map1.pk]}
+        result = self.filterset(params, self.queryset).qs
+        # Map1 has rel_field1 and rel_field2
+        self.assertEqual(result.count(), 2)
+        field_ids = set(result.values_list("id", flat=True))
+        self.assertIn(self.rel_field1.pk, field_ids)
+        self.assertIn(self.rel_field2.pk, field_ids)
+
+        # Test multiple transform map IDs
+        params = {"transform_map_id": [self.map1.pk, self.map3.pk]}
+        result = self.filterset(params, self.queryset).qs
+        # Map1 has 2 fields, Map3 has 1 field = 3 total
+        self.assertEqual(result.count(), 3)
+        field_ids = set(result.values_list("id", flat=True))
+        self.assertIn(self.rel_field1.pk, field_ids)
+        self.assertIn(self.rel_field2.pk, field_ids)
+        self.assertIn(self.rel_field4.pk, field_ids)
+
+    def test_source_model(self):
+        """Test filtering by source model"""
+        # First filter to only our test transform maps' fields
+        test_maps = [self.map1.pk, self.map2.pk, self.map3.pk]
+
+        params = {"source_model": self.location_ct.pk, "transform_map": test_maps}
+        result = self.filterset(params, self.queryset).qs
+        # rel_field1 and rel_field4 have Location as source model (from our test maps only)
+        self.assertEqual(result.count(), 2)
+        field_ids = set(result.values_list("id", flat=True))
+        self.assertIn(self.rel_field1.pk, field_ids)
+        self.assertIn(self.rel_field4.pk, field_ids)
+
+        params = {"source_model": self.device_ct.pk, "transform_map": test_maps}
+        result = self.filterset(params, self.queryset).qs
+        # rel_field3 has Device as source model (from our test maps only)
+        self.assertEqual(result.count(), 1)
+        self.assertEqual(result.first().pk, self.rel_field3.pk)
+
+    def test_target_field(self):
+        """Test filtering by target field"""
+        # First filter to only our test transform maps' fields
+        test_maps = [self.map1.pk, self.map2.pk, self.map3.pk]
+
+        params = {"target_field": "location", "transform_map": test_maps}
+        result = self.filterset(params, self.queryset).qs
+        # rel_field1 and rel_field4 have location as target (from our test maps only)
+        self.assertEqual(result.count(), 2)
+        field_ids = set(result.values_list("id", flat=True))
+        self.assertIn(self.rel_field1.pk, field_ids)
+        self.assertIn(self.rel_field4.pk, field_ids)
+
+        params = {"target_field": "site", "transform_map": test_maps}
+        result = self.filterset(params, self.queryset).qs
+        # rel_field2 has site as target (from our test maps only)
+        self.assertEqual(result.count(), 1)
+        self.assertEqual(result.first().pk, self.rel_field2.pk)
+
+    def test_coalesce(self):
+        """Test filtering by coalesce"""
+        # First filter to only our test transform maps' fields
+        test_maps = [self.map1.pk, self.map2.pk, self.map3.pk]
+
+        params = {"coalesce": True, "transform_map": test_maps}
+        result = self.filterset(params, self.queryset).qs
+        # rel_field2 has coalesce=True (from our test maps only)
+        self.assertEqual(result.count(), 1)
+        self.assertEqual(result.first().pk, self.rel_field2.pk)
+
+        params = {"coalesce": False, "transform_map": test_maps}
+        result = self.filterset(params, self.queryset).qs
+        # rel_field1, rel_field3, rel_field4 have coalesce=False (from our test maps only)
+        self.assertEqual(result.count(), 3)
+        field_ids = set(result.values_list("id", flat=True))
+        self.assertIn(self.rel_field1.pk, field_ids)
+        self.assertIn(self.rel_field3.pk, field_ids)
+        self.assertIn(self.rel_field4.pk, field_ids)
+
+    def test_combined_filters(self):
+        """Test combining multiple filters"""
+        # Test transform_map_id + source_model
+        params = {
+            "transform_map_id": [self.map1.pk],
+            "source_model": self.location_ct.pk,
+        }
+        result = self.filterset(params, self.queryset).qs
+        # Only rel_field1 has map1 and Location source
+        self.assertEqual(result.count(), 1)
+        self.assertEqual(result.first().pk, self.rel_field1.pk)
+
+        # Test transform_map_id + target_field
+        params = {
+            "transform_map_id": [self.map1.pk],
+            "target_field": "location",
+        }
+        result = self.filterset(params, self.queryset).qs
+        # Only rel_field1 has map1 and location target
+        self.assertEqual(result.count(), 1)
+        self.assertEqual(result.first().pk, self.rel_field1.pk)
+
+        # Test transform_map_id + coalesce
+        params = {
+            "transform_map_id": [self.map1.pk],
+            "coalesce": True,
+        }
+        result = self.filterset(params, self.queryset).qs
+        # Only rel_field2 has map1 and coalesce=True
+        self.assertEqual(result.count(), 1)
+        self.assertEqual(result.first().pk, self.rel_field2.pk)
+
+    def test_transform_map_filters_equivalence(self):
+        """Test that transform_map and transform_map_id work correctly"""
+        # Single ID with transform_map
+        params1 = {"transform_map": [self.map1.pk]}
+        result1 = self.filterset(params1, self.queryset).qs
+
+        # Same ID with transform_map_id
+        params2 = {"transform_map_id": [self.map1.pk]}
+        result2 = self.filterset(params2, self.queryset).qs
+
+        # Should return same results
+        self.assertEqual(result1.count(), result2.count())
+        self.assertEqual(
+            set(result1.values_list("id", flat=True)),
+            set(result2.values_list("id", flat=True)),
+        )
+
+    def test_distinct_results(self):
+        """Test that filters return distinct results"""
+        # Query with transform_map_id (should have no duplicates)
+        params = {"transform_map_id": [self.map1.pk]}
+        result = self.filterset(params, self.queryset).qs
+
+        # Each relationship field should appear only once
+        field_counts = {}
+        for field in result:
+            field_counts[field.pk] = field_counts.get(field.pk, 0) + 1
+
+        for count in field_counts.values():
+            self.assertEqual(count, 1)
+
+    def test_empty_filters(self):
+        """Test behavior with empty filter values"""
+        total_count = self.queryset.count()
+
+        params = {"transform_map": ""}
+        result = self.filterset(params, self.queryset).qs
+        self.assertEqual(result.count(), total_count)
+
+        params = {"target_field": ""}
+        result = self.filterset(params, self.queryset).qs
+        self.assertEqual(result.count(), total_count)
+
+
+class IPFabricTransformMapGroupFilterSetTestCase(TestCase):
+    filterset = IPFabricTransformMapGroupFilterSet
+
+    @classmethod
+    def setUpTestData(cls):
+        groups = [
+            IPFabricTransformMapGroup(
+                name="Group Alpha",
+                description="First transform map group",
+            ),
+            IPFabricTransformMapGroup(
+                name="Group Beta",
+                description="Second transform map group",
+            ),
+            IPFabricTransformMapGroup(
+                name="Group Gamma",
+                description="Third group for testing",
+            ),
+        ]
+        IPFabricTransformMapGroup.objects.bulk_create(groups)
+
+    @property
+    def queryset(self):
+        return IPFabricTransformMapGroup.objects.all()
+
+    def test_id(self):
+        """Test filtering by group ID"""
+        group = IPFabricTransformMapGroup.objects.first()
+        params = {"id": [group.pk]}
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
+
+    def test_name(self):
+        """Test filtering by name (exact match)"""
+        params = {"name": ["Group Alpha"]}
+        result = self.filterset(params, self.queryset).qs
+        # Exact match should find exactly 1
+        self.assertEqual(result.count(), 1)
+        self.assertEqual(result.first().name, "Group Alpha")
+
+    def test_description(self):
+        """Test filtering by description (exact match)"""
+        params = {"description": "First transform map group"}
+        result = self.filterset(params, self.queryset).qs
+        self.assertEqual(result.count(), 1)
+        self.assertEqual(result.first().name, "Group Alpha")
+
+    def test_search(self):
+        """Test search across name and description"""
+        params = {"q": "Alpha"}
+        result = self.filterset(params, self.queryset).qs
+        self.assertGreaterEqual(result.count(), 1)
+
+        params = {"q": "group"}
+        result = self.filterset(params, self.queryset).qs
+        self.assertGreaterEqual(result.count(), 3)
+
+
+class IPFabricSourceFilterSetTestCase(TestCase):
+    filterset = IPFabricSourceFilterSet
+
+    @classmethod
+    def setUpTestData(cls):
+        sources = [
+            IPFabricSource(
+                name="Source Alpha",
+                url="https://alpha.example.com",
+                parameters={"auth": "token"},
+                status="ready",
+                description="Primary source",
+                comments="Alpha comments",
+            ),
+            IPFabricSource(
+                name="Source Beta",
+                url="https://beta.example.com",
+                parameters={"auth": "basic"},
+                status="error",
+                description="Secondary source",
+                comments="Beta notes",
+            ),
+            IPFabricSource(
+                name="Source Gamma",
+                url="https://gamma.example.com",
+                parameters={"verify": False},
+                status="ready",
+                description="Testing source",
+            ),
+        ]
+        IPFabricSource.objects.bulk_create(sources)
+
+    @property
+    def queryset(self):
+        return IPFabricSource.objects.all()
+
+    def test_id(self):
+        """Test filtering by source ID"""
+        source = IPFabricSource.objects.first()
+        params = {"id": [source.pk]}
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
+
+    def test_name(self):
+        """Test filtering by name (exact match)"""
+        params = {"name": ["Source Alpha"]}
+        result = self.filterset(params, self.queryset).qs
+        # Exact match should find exactly 1
+        self.assertEqual(result.count(), 1)
+        self.assertEqual(result.first().url, "https://alpha.example.com")
+
+    def test_status(self):
+        """Test filtering by status"""
+        params = {"status": ["ready"]}
+        result = self.filterset(params, self.queryset).qs
+        # Should find at least our 2 test sources with ready status
+        self.assertGreaterEqual(result.count(), 2)
+
+        params = {"status": ["error"]}
+        result = self.filterset(params, self.queryset).qs
+        # Should find at least our 1 test source with error status
+        self.assertGreaterEqual(result.count(), 1)
+
+    def test_search(self):
+        """Test search across name, description, and comments"""
+        params = {"q": "Alpha"}
+        result = self.filterset(params, self.queryset).qs
+        self.assertGreaterEqual(result.count(), 1)
+
+        params = {"q": "source"}
+        result = self.filterset(params, self.queryset).qs
+        self.assertGreaterEqual(result.count(), 3)
+
+        params = {"q": "notes"}
+        result = self.filterset(params, self.queryset).qs
+        self.assertGreaterEqual(result.count(), 1)
+
+
+class IPFabricSnapshotFilterSetTestCase(TestCase):
+    filterset = IPFabricSnapshotFilterSet
+
+    @classmethod
+    def setUpTestData(cls):
+        source1 = IPFabricSource.objects.create(
+            name="Snapshot Test Source 1",
+            url="https://source1.example.com",
+            parameters={"auth": "token"},
+        )
+        source2 = IPFabricSource.objects.create(
+            name="Snapshot Test Source 2",
+            url="https://source2.example.com",
+            parameters={"auth": "basic"},
+        )
+
+        cls.snapshots = [
+            IPFabricSnapshot(
+                name="Snapshot Alpha",
+                source=source1,
+                snapshot_id="snap-alpha-001",
+                status="loaded",
+                data={"sites": ["SiteA"]},
+            ),
+            IPFabricSnapshot(
+                name="Snapshot Beta",
+                source=source1,
+                snapshot_id="snap-beta-002",
+                status="unloaded",
+                data={"sites": ["SiteB"]},
+            ),
+            IPFabricSnapshot(
+                name="Snapshot Gamma",
+                source=source2,
+                snapshot_id="snap-gamma-003",
+                status="loaded",
+                data={"sites": ["SiteC"]},
+            ),
+        ]
+        IPFabricSnapshot.objects.bulk_create(cls.snapshots)
+
+    @property
+    def queryset(self):
+        return IPFabricSnapshot.objects.all()
+
+    def test_id(self):
+        """Test filtering by snapshot ID"""
+        snapshot = IPFabricSnapshot.objects.first()
+        params = {"id": [snapshot.pk]}
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
+
+    def test_name(self):
+        """Test filtering by name (exact match)"""
+        params = {"name": ["Snapshot Alpha"]}
+        result = self.filterset(params, self.queryset).qs
+        # Exact match should find exactly 1
+        self.assertEqual(result.count(), 1)
+        self.assertEqual(result.first().snapshot_id, "snap-alpha-001")
+
+    def test_status(self):
+        """Test filtering by status"""
+        params = {"status": "loaded"}
+        result = self.filterset(params, self.queryset).qs
+        # Should find at least our 2 test snapshots with loaded status
+        self.assertGreaterEqual(result.count(), 2)
+
+    def test_snapshot_id(self):
+        """Test filtering by snapshot_id with icontains"""
+        params = {"snapshot_id": "alpha"}
+        result = self.filterset(params, self.queryset).qs
+        self.assertGreaterEqual(result.count(), 1)
+
+        params = {"snapshot_id": "snap"}
+        result = self.filterset(params, self.queryset).qs
+        self.assertGreaterEqual(result.count(), 3)
+
+    def test_source_id(self):
+        """Test filtering by source ID"""
+        source = IPFabricSource.objects.get(name="Snapshot Test Source 1")
+        params = {"source_id": [source.pk]}
+        result = self.filterset(params, self.queryset).qs
+        self.assertGreaterEqual(result.count(), 2)
+
+    def test_source_name(self):
+        """Test filtering by source name"""
+        source = IPFabricSource.objects.get(name="Snapshot Test Source 2")
+        params = {"source": [source.pk]}
+        result = self.filterset(params, self.queryset).qs
+        # Should find at least our one snapshot for this source
+        self.assertGreaterEqual(result.count(), 1)
+        # Verify it's the right snapshot
+        self.assertTrue(result.filter(snapshot_id="snap-gamma-003").exists())
+
+    def test_search(self):
+        """Test search functionality"""
+        params = {"q": "Alpha"}
+        result = self.filterset(params, self.queryset).qs
+        self.assertGreaterEqual(result.count(), 1)
+
+
+class IPFabricDataFilterSetTestCase(TestCase):
+    filterset = IPFabricDataFilterSet
+
+    @classmethod
+    def setUpTestData(cls):
+        from ipfabric_netbox.models import IPFabricData
+
+        source = IPFabricSource.objects.create(
+            name="Data Test Source",
+            url="https://data.example.com",
+            parameters={},
+        )
+        cls.snapshot = IPFabricSnapshot.objects.create(
+            name="Data Test Snapshot",
+            source=source,
+            snapshot_id="snap-data-001",
+            status="loaded",
+        )
+
+        data_items = [
+            IPFabricData(
+                snapshot_data=cls.snapshot,
+                data={"device": "router1", "ip": "10.0.0.1"},
+            ),
+            IPFabricData(
+                snapshot_data=cls.snapshot,
+                data={"device": "switch1", "ip": "10.0.0.2"},
+            ),
+            IPFabricData(
+                snapshot_data=cls.snapshot,
+                data={"device": "firewall1", "ip": "10.0.0.3"},
+            ),
+        ]
+        IPFabricData.objects.bulk_create(data_items)
+
+    @property
+    def queryset(self):
+        return IPFabricData.objects.all()
+
+    def test_snapshot_data(self):
+        """Test filtering by snapshot_data"""
+        params = {"snapshot_data": self.snapshot.pk}
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 3)
+
+    def test_search(self):
+        """Test search functionality"""
+        # The search method filters on snapshot_data__name
+        params = {"q": "Data Test Snapshot"}
+        result = self.filterset(params, self.queryset).qs
+        # Should find all data items for our snapshot
+        self.assertEqual(result.count(), 3)
+
+
+class IPFabricIngestionFilterSetTestCase(TestCase):
+    filterset = IPFabricIngestionFilterSet
+
+    @classmethod
+    def setUpTestData(cls):
+        # Create sources
+        source1 = IPFabricSource.objects.create(
+            name="Ingestion Test Source 1",
+            url="https://ing1.example.com",
+            parameters={},
+        )
+        source2 = IPFabricSource.objects.create(
+            name="Ingestion Test Source 2",
+            url="https://ing2.example.com",
+            parameters={},
+        )
+
+        # Create snapshots
+        snapshot1 = IPFabricSnapshot.objects.create(
+            name="Ingestion Snapshot 1",
+            source=source1,
+            snapshot_id="ing-snap-1",
+            status="loaded",
+        )
+        snapshot2 = IPFabricSnapshot.objects.create(
+            name="Ingestion Snapshot 2",
+            source=source2,
+            snapshot_id="ing-snap-2",
+            status="loaded",
+        )
+
+        # Create syncs
+        cls.sync1 = IPFabricSync.objects.create(
+            name="Ingestion Sync 1",
+            snapshot_data=snapshot1,
+            parameters={},
+        )
+        cls.sync2 = IPFabricSync.objects.create(
+            name="Ingestion Sync 2",
+            snapshot_data=snapshot2,
+            parameters={},
+        )
+
+        # Create branches - need unique branches since branch is OneToOneField
+        cls.branch1 = Branch.objects.create(name="Ingestion Branch 1")
+        cls.branch2 = Branch.objects.create(name="Ingestion Branch 2")
+        cls.branch3 = Branch.objects.create(name="Ingestion Branch 3")
+
+        # Create ingestions - each needs its own unique branch
+        cls.ingestions = [
+            IPFabricIngestion(
+                sync=cls.sync1,
+                branch=cls.branch1,
+            ),
+            IPFabricIngestion(
+                sync=cls.sync1,
+                branch=cls.branch2,
+            ),
+            IPFabricIngestion(
+                sync=cls.sync2,
+                branch=cls.branch3,
+            ),
+        ]
+        IPFabricIngestion.objects.bulk_create(cls.ingestions)
+
+    @property
+    def queryset(self):
+        return IPFabricIngestion.objects.all()
+
+    def test_id(self):
+        """Test filtering by ingestion ID"""
+        ingestion = IPFabricIngestion.objects.first()
+        params = {"id": [ingestion.pk]}
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
+
+    def test_branch(self):
+        """Test filtering by branch"""
+        params = {"branch": self.branch1.pk}
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
+
+    def test_sync_id(self):
+        """Test filtering by sync ID"""
+        params = {"sync_id": [self.sync1.pk]}
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
+
+    def test_search(self):
+        """Test search functionality"""
+        params = {"q": "Ingestion Branch 1"}
+        result = self.filterset(params, self.queryset).qs
+        self.assertGreaterEqual(result.count(), 1)
+
+
+class IPFabricIngestionIssueFilterSetTestCase(TestCase):
+    filterset = IPFabricIngestionIssueFilterSet
+
+    @classmethod
+    def setUpTestData(cls):
+        source = IPFabricSource.objects.create(
+            name="Issue Test Source",
+            url="https://issue.example.com",
+            parameters={},
+        )
+        snapshot = IPFabricSnapshot.objects.create(
+            name="Issue Snapshot",
+            source=source,
+            snapshot_id="issue-snap-1",
+            status="loaded",
+        )
+        sync = IPFabricSync.objects.create(
+            name="Issue Sync",
+            snapshot_data=snapshot,
+            parameters={},
+        )
+        branch = Branch.objects.create(name="Issue Branch")
+        ingestion = IPFabricIngestion.objects.create(
+            sync=sync,
+            branch=branch,
+        )
+
+        cls.issues = [
+            IPFabricIngestionIssue(
+                ingestion=ingestion,
+                model="dcim.Device",
+                raw_data={"hostname": "device1"},
+                coalesce_fields=["name"],
+                defaults={"status": "active"},
+                exception="ValueError",
+                message="Device validation error",
+            ),
+            IPFabricIngestionIssue(
+                ingestion=ingestion,
+                model="ipam.IPAddress",
+                raw_data={"address": "10.0.0.1"},
+                coalesce_fields=["address"],
+                defaults={"status": "active"},
+                exception="IntegrityError",
+                message="Duplicate IP address",
+            ),
+            IPFabricIngestionIssue(
+                ingestion=ingestion,
+                model="dcim.Interface",
+                raw_data={"name": "eth0"},
+                coalesce_fields=["name", "device"],
+                defaults={},
+                exception="KeyError",
+                message="Missing device reference",
+            ),
+        ]
+        IPFabricIngestionIssue.objects.bulk_create(cls.issues)
+
+    @property
+    def queryset(self):
+        return IPFabricIngestionIssue.objects.all()
+
+    def test_model(self):
+        """Test filtering by model (exact match)"""
+        # First verify we have test data
+        total_issues = self.queryset.count()
+        self.assertGreater(total_issues, 0, "No ingestion issues found in queryset")
+
+        # Check what models exist
+        models_in_db = list(self.queryset.values_list("model", flat=True))
+        self.assertIn("dcim.Device", models_in_db, f"dcim.Device not in {models_in_db}")
+
+        params = {"model": ["dcim.Device"]}
+        result = self.filterset(params, self.queryset).qs
+        # Should find exactly one device issue
+        self.assertEqual(result.count(), 1)
+        self.assertEqual(result.first().model, "dcim.Device")
+
+    def test_exception(self):
+        """Test filtering by exception (exact match)"""
+        params = {"exception": "ValueError"}
+        result = self.filterset(params, self.queryset).qs
+        self.assertEqual(result.count(), 1)
+        self.assertEqual(result.first().model, "dcim.Device")
+
+    def test_message(self):
+        """Test filtering by message (exact match)"""
+        params = {"message": "Device validation error"}
+        result = self.filterset(params, self.queryset).qs
+        self.assertEqual(result.count(), 1)
+
+    def test_search(self):
+        """Test search functionality"""
+        params = {"q": "Device"}
+        result = self.filterset(params, self.queryset).qs
+        self.assertGreaterEqual(result.count(), 1)
+
+        params = {"q": "ValueError"}
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
+
+        params = {"q": "duplicate"}
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
+
+
+class IPFabricIngestionChangeFilterSetTestCase(TestCase):
+    filterset = IPFabricIngestionChangeFilterSet
+
+    @classmethod
+    def setUpTestData(cls):
+        # Create a branch
+        cls.branch = Branch.objects.create(name="Change Test Branch")
+
+        # Get content type for Device
+        cls.device_ct = ContentType.objects.get(app_label="dcim", model="device")
+        cls.site_ct = ContentType.objects.get(app_label="dcim", model="site")
+
+        # Create change diffs
+        cls.changes = [
+            ChangeDiff(
+                branch=cls.branch,
+                object_type=cls.device_ct,
+                object_id=1,
+                action="create",
+                current={"name": "device1", "status": "active"},
+                modified={},
+                original={},
+            ),
+            ChangeDiff(
+                branch=cls.branch,
+                object_type=cls.device_ct,
+                object_id=2,
+                action="update",
+                current={"name": "device2", "status": "planned"},
+                modified={"status": "active"},
+                original={"name": "device2", "status": "planned"},
+            ),
+            ChangeDiff(
+                branch=cls.branch,
+                object_type=cls.site_ct,
+                object_id=1,
+                action="delete",
+                current={},
+                modified={},
+                original={"name": "site1"},
+            ),
+        ]
+        ChangeDiff.objects.bulk_create(cls.changes)
+
+    @property
+    def queryset(self):
+        return ChangeDiff.objects.all()
+
+    def test_branch(self):
+        """Test filtering by branch"""
+        params = {"branch": self.branch.pk}
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 3)
+
+    def test_action(self):
+        """Test filtering by action"""
+        params = {"action": ["create"]}
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
+
+        params = {"action": ["update", "delete"]}
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
+
+    def test_object_type(self):
+        """Test filtering by object_type"""
+        params = {"object_type": self.device_ct.pk}
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
+
+    def test_search(self):
+        """Test search functionality"""
+        params = {"q": "device1"}
+        result = self.filterset(params, self.queryset).qs
+        self.assertGreaterEqual(result.count(), 1)
+
+        params = {"q": "create"}
+        result = self.filterset(params, self.queryset).qs
+        self.assertGreaterEqual(result.count(), 1)