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

ipfabric_netbox/tests/test_forms.py

@@ -1,16 +1,25 @@
+import json
 from datetime import timedelta
 from unittest.mock import patch
 
 from dcim.models import Device
+from dcim.models import Interface
 from dcim.models import Site
+from django import forms
 from django.contrib.contenttypes.models import ContentType
 from django.test import TestCase
+from ipam.models import IPAddress
+from ipam.models import VRF
 from utilities.datetime import local_now
+from utilities.forms.rendering import FieldSet
 
+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.forms import IPFabricFilterExpressionForm
+from ipfabric_netbox.forms import IPFabricFilterForm
 from ipfabric_netbox.forms import IPFabricIngestionFilterForm
 from ipfabric_netbox.forms import IPFabricIngestionMergeForm
 from ipfabric_netbox.forms import IPFabricRelationshipFieldForm
@@ -22,6 +31,9 @@ from ipfabric_netbox.forms import IPFabricTransformFieldForm
 from ipfabric_netbox.forms import IPFabricTransformMapCloneForm
 from ipfabric_netbox.forms import IPFabricTransformMapForm
 from ipfabric_netbox.forms import IPFabricTransformMapGroupForm
+from ipfabric_netbox.models import IPFabricEndpoint
+from ipfabric_netbox.models import IPFabricFilter
+from ipfabric_netbox.models import IPFabricFilterExpression
 from ipfabric_netbox.models import IPFabricRelationshipField
 from ipfabric_netbox.models import IPFabricSnapshot
 from ipfabric_netbox.models import IPFabricSource
@@ -148,7 +160,6 @@ class IPFabricSourceFormTestCase(TestCase):
 
     def test_remote_source_creates_last_snapshot(self):
         """Check that $last snapshot is created for remote sources"""
-        from ipfabric_netbox.models import IPFabricSnapshot
 
         self.assertEqual(IPFabricSnapshot.objects.count(), 0)
 
@@ -350,10 +361,14 @@ class IPFabricRelationshipFieldFormTestCase(TestCase):
         cls.device_content_type = ContentType.objects.get_for_model(Device)
         cls.site_content_type = ContentType.objects.get_for_model(Site)
 
+        cls.device_endpoint = IPFabricEndpoint.objects.get(
+            endpoint="/inventory/devices"
+        )
+
         cls.transform_map = IPFabricTransformMap.objects.create(
             name="Test Transform Map",
             group=cls.transform_map_group,
-            source_model="device",
+            source_endpoint=cls.device_endpoint,
             target_model=cls.device_content_type,
         )
 
@@ -463,10 +478,14 @@ class IPFabricTransformFieldFormTestCase(TestCase):
 
         cls.device_content_type = ContentType.objects.get_for_model(Device)
 
+        cls.device_endpoint = IPFabricEndpoint.objects.get(
+            endpoint="/inventory/devices"
+        )
+
         cls.transform_map = IPFabricTransformMap.objects.create(
             name="Test Transform Map",
             group=cls.transform_map_group,
-            source_model="device",
+            source_endpoint=cls.device_endpoint,
             target_model=cls.device_content_type,
         )
 
@@ -587,12 +606,15 @@ class IPFabricTransformMapFormTestCase(TestCase):
             name="Test Group", description="Test group description"
         )
         cls.device_content_type = ContentType.objects.get_for_model(Device)
+        cls.device_endpoint = IPFabricEndpoint.objects.get(
+            endpoint="/inventory/devices"
+        )
 
     def test_fields_are_required(self):
         form = IPFabricTransformMapForm(data={})
         self.assertFalse(form.is_valid(), form.errors)
         self.assertIn("name", form.errors)
-        self.assertIn("source_model", form.errors)
+        self.assertIn("source_endpoint", form.errors)
         self.assertIn("target_model", form.errors)
 
     def test_group_is_optional(self):
@@ -603,7 +625,7 @@ class IPFabricTransformMapFormTestCase(TestCase):
         form = IPFabricTransformMapForm(
             data={
                 "name": "Test Transform Map",
-                "source_model": "device",
+                "source_endpoint": self.device_endpoint.pk,
                 "target_model": self.device_content_type.pk,
             }
         )
@@ -614,7 +636,7 @@ class IPFabricTransformMapFormTestCase(TestCase):
             data={
                 "name": "Test Transform Map",
                 "group": self.transform_map_group.pk,
-                "source_model": "device",
+                "source_endpoint": self.device_endpoint.pk,
                 "target_model": self.device_content_type.pk,
             }
         )
@@ -623,6 +645,301 @@ class IPFabricTransformMapFormTestCase(TestCase):
         self.assertEqual(instance.name, "Test Transform Map")
         self.assertEqual(instance.group, self.transform_map_group)
 
+    def test_existing_instance_excludes_self_from_parents_choices(self):
+        """Test that when editing an existing transform map, it excludes itself from parents choices"""
+        # Create a transform map instance
+        transform_map = IPFabricTransformMap.objects.create(
+            name="Test Transform Map",
+            group=self.transform_map_group,
+            source_endpoint=self.device_endpoint,
+            target_model=self.device_content_type,
+        )
+
+        # Create another transform map that could be a parent
+        other_transform_map = IPFabricTransformMap.objects.create(
+            name="Other Transform Map",
+            group=self.transform_map_group,
+            source_endpoint=self.device_endpoint,
+            target_model=ContentType.objects.get_for_model(Site),
+        )
+
+        # Initialize form with the existing instance
+        form = IPFabricTransformMapForm(instance=transform_map)
+
+        # Verify that the instance itself is excluded from parents choices
+        parents_queryset = form.fields["parents"].queryset
+        self.assertNotIn(transform_map, parents_queryset)
+
+        # Verify that other transform maps are still available as parent options
+        self.assertIn(other_transform_map, parents_queryset)
+
+        # Verify help text is set
+        self.assertIn(
+            "must be processed before this one", form.fields["parents"].help_text
+        )
+
+    def test_circular_dependency_direct(self):
+        """Test that direct circular dependencies are detected (A → B, B → A)"""
+        # Create two transform maps
+        site_ct = ContentType.objects.get_for_model(Site)
+
+        tm_a = IPFabricTransformMap.objects.create(
+            name="Transform Map A",
+            group=self.transform_map_group,
+            source_endpoint=self.device_endpoint,
+            target_model=self.device_content_type,
+        )
+
+        tm_b = IPFabricTransformMap.objects.create(
+            name="Transform Map B",
+            group=self.transform_map_group,
+            source_endpoint=self.device_endpoint,
+            target_model=site_ct,
+        )
+
+        # Set B as parent of A
+        tm_a.parents.add(tm_b)
+
+        # Try to set A as parent of B (should fail)
+        form = IPFabricTransformMapForm(
+            instance=tm_b,
+            data={
+                "name": tm_b.name,
+                "group": self.transform_map_group.pk,
+                "source_endpoint": self.device_endpoint.pk,
+                "target_model": site_ct.pk,
+                "parents": [tm_a.pk],
+            },
+        )
+
+        self.assertFalse(form.is_valid())
+        self.assertIn("parents", form.errors)
+        self.assertIn("circular dependency", str(form.errors["parents"]).lower())
+
+    def test_circular_dependency_indirect(self):
+        """Test that indirect circular dependencies are detected (A → B → C → A)"""
+        # Create three transform maps with different content types
+
+        site_ct = ContentType.objects.get_for_model(Site)
+        vrf_ct = ContentType.objects.get_for_model(VRF)
+        interface_ct = ContentType.objects.get_for_model(Interface)
+
+        vrf_endpoint = IPFabricEndpoint.objects.get(
+            endpoint="/technology/routing/vrf/detail"
+        )
+        interface_endpoint = IPFabricEndpoint.objects.get(
+            endpoint="/inventory/interfaces"
+        )
+        site_endpoint = IPFabricEndpoint.objects.get(
+            endpoint="/inventory/sites/overview"
+        )
+
+        tm_a = IPFabricTransformMap.objects.create(
+            name="Transform Map A",
+            group=self.transform_map_group,
+            source_endpoint=site_endpoint,
+            target_model=site_ct,
+        )
+
+        tm_b = IPFabricTransformMap.objects.create(
+            name="Transform Map B",
+            group=self.transform_map_group,
+            source_endpoint=vrf_endpoint,
+            target_model=vrf_ct,
+        )
+
+        tm_c = IPFabricTransformMap.objects.create(
+            name="Transform Map C",
+            group=self.transform_map_group,
+            source_endpoint=interface_endpoint,
+            target_model=interface_ct,
+        )
+
+        # Create chain: A → B → C
+        tm_b.parents.add(tm_a)
+        tm_c.parents.add(tm_b)
+
+        # Try to add C as parent of A (completing the cycle: A → B → C → A)
+        form = IPFabricTransformMapForm(
+            instance=tm_a,
+            data={
+                "name": tm_a.name,
+                "group": self.transform_map_group.pk,
+                "source_endpoint": site_endpoint.pk,
+                "target_model": site_ct.pk,
+                "parents": [tm_c.pk],
+            },
+        )
+
+        self.assertFalse(form.is_valid())
+        self.assertIn("parents", form.errors)
+        self.assertIn("circular dependency", str(form.errors["parents"]).lower())
+
+    def test_valid_parent_assignment_no_cycle(self):
+        """Test that valid parent assignments without cycles are allowed"""
+        site_ct = ContentType.objects.get_for_model(Site)
+        vrf_ct = ContentType.objects.get_for_model(VRF)
+
+        vrf_endpoint = IPFabricEndpoint.objects.get(
+            endpoint="/technology/routing/vrf/detail"
+        )
+        site_endpoint = IPFabricEndpoint.objects.get(
+            endpoint="/inventory/sites/overview"
+        )
+
+        tm_site = IPFabricTransformMap.objects.create(
+            name="Site Transform Map",
+            group=self.transform_map_group,
+            source_endpoint=site_endpoint,
+            target_model=site_ct,
+        )
+
+        tm_vrf = IPFabricTransformMap.objects.create(
+            name="VRF Transform Map",
+            group=self.transform_map_group,
+            source_endpoint=vrf_endpoint,
+            target_model=vrf_ct,
+        )
+
+        # Set Site as parent of VRF (valid - no cycle)
+        form = IPFabricTransformMapForm(
+            instance=tm_vrf,
+            data={
+                "name": tm_vrf.name,
+                "group": self.transform_map_group.pk,
+                "source_endpoint": vrf_endpoint.pk,
+                "target_model": vrf_ct.pk,
+                "parents": [tm_site.pk],
+            },
+        )
+
+        self.assertTrue(form.is_valid(), form.errors)
+        form.save()
+        self.assertIn(tm_site, tm_vrf.parents.all())
+
+    def test_multiple_parents_no_cycle(self):
+        """Test that multiple parents can be assigned without creating cycles"""
+
+        site_ct = ContentType.objects.get_for_model(Site)
+        vrf_ct = ContentType.objects.get_for_model(VRF)
+        interface_ct = ContentType.objects.get_for_model(Interface)
+        ipaddress_ct = ContentType.objects.get_for_model(IPAddress)
+
+        vrf_endpoint = IPFabricEndpoint.objects.get(
+            endpoint="/technology/routing/vrf/detail"
+        )
+        interface_endpoint = IPFabricEndpoint.objects.get(
+            endpoint="/inventory/interfaces"
+        )
+        site_endpoint = IPFabricEndpoint.objects.get(
+            endpoint="/inventory/sites/overview"
+        )
+        ipaddress_endpoint = IPFabricEndpoint.objects.get(
+            endpoint="/technology/addressing/managed-ip/ipv4"
+        )
+
+        tm_site = IPFabricTransformMap.objects.create(
+            name="Site Transform Map",
+            group=self.transform_map_group,
+            source_endpoint=site_endpoint,
+            target_model=site_ct,
+        )
+
+        tm_vrf = IPFabricTransformMap.objects.create(
+            name="VRF Transform Map",
+            group=self.transform_map_group,
+            source_endpoint=vrf_endpoint,
+            target_model=vrf_ct,
+        )
+
+        tm_interface = IPFabricTransformMap.objects.create(
+            name="Interface Transform Map",
+            group=self.transform_map_group,
+            source_endpoint=interface_endpoint,
+            target_model=interface_ct,
+        )
+
+        tm_ipaddress = IPFabricTransformMap.objects.create(
+            name="IP Address Transform Map",
+            group=self.transform_map_group,
+            source_endpoint=ipaddress_endpoint,
+            target_model=ipaddress_ct,
+        )
+
+        # Set Site as parent of both VRF and Interface
+        tm_vrf.parents.add(tm_site)
+        tm_interface.parents.add(tm_site)
+
+        # Set both VRF and Interface as parents of IP Address (valid - no cycle)
+        form = IPFabricTransformMapForm(
+            instance=tm_ipaddress,
+            data={
+                "name": tm_ipaddress.name,
+                "group": self.transform_map_group.pk,
+                "source_endpoint": ipaddress_endpoint.pk,
+                "target_model": ipaddress_ct.pk,
+                "parents": [tm_vrf.pk, tm_interface.pk],
+            },
+        )
+
+        self.assertTrue(form.is_valid(), form.errors)
+        form.save()
+        self.assertEqual(tm_ipaddress.parents.count(), 2)
+        self.assertIn(tm_vrf, tm_ipaddress.parents.all())
+        self.assertIn(tm_interface, tm_ipaddress.parents.all())
+
+    def test_self_as_parent_prevented_by_form_init(self):
+        """Test that a transform map cannot be set as its own parent (prevented by form __init__)"""
+        tm = IPFabricTransformMap.objects.create(
+            name="Test Transform Map",
+            group=self.transform_map_group,
+            source_endpoint=self.device_endpoint,
+            target_model=self.device_content_type,
+        )
+
+        # The form should exclude self from parents queryset
+        form = IPFabricTransformMapForm(instance=tm)
+        parents_queryset = form.fields["parents"].queryset
+        self.assertNotIn(tm, parents_queryset)
+
+    def test_no_validation_for_new_instances(self):
+        """Test that circular dependency validation is skipped for new instances"""
+        # New instance (no pk) should not trigger circular dependency validation
+        form = IPFabricTransformMapForm(
+            data={
+                "name": "New Transform Map",
+                "group": self.transform_map_group.pk,
+                "source_endpoint": self.device_endpoint.pk,
+                "target_model": self.device_content_type.pk,
+                # parents field is optional and empty for new instances
+            }
+        )
+
+        self.assertTrue(form.is_valid(), form.errors)
+
+    def test_no_validation_when_parents_empty(self):
+        """Test that circular dependency validation is skipped when no parents are selected"""
+        tm = IPFabricTransformMap.objects.create(
+            name="Test Transform Map",
+            group=self.transform_map_group,
+            source_endpoint=self.device_endpoint,
+            target_model=self.device_content_type,
+        )
+
+        # Edit without setting any parents
+        form = IPFabricTransformMapForm(
+            instance=tm,
+            data={
+                "name": "Updated Transform Map",
+                "group": self.transform_map_group.pk,
+                "source_endpoint": self.device_endpoint.pk,
+                "target_model": self.device_content_type.pk,
+                "parents": [],  # Empty parents
+            },
+        )
+
+        self.assertTrue(form.is_valid(), form.errors)
+
 
 class IPFabricTransformMapCloneFormTestCase(TestCase):
     @classmethod
@@ -771,9 +1088,7 @@ class IPFabricSyncFormTestCase(TestCase):
             source=cls.source,
             snapshot_id="test-snapshot-id",
             status=IPFabricSnapshotStatusModelChoices.STATUS_LOADED,
-            data={
-                "sites": ["site1", "site2", "site3"]
-            },  # Store as list instead of comma-separated string
+            data={"sites": ["site1", "site2", "site3"]},
         )
 
         cls.transform_map_group = IPFabricTransformMapGroup.objects.create(
@@ -931,6 +1246,31 @@ class IPFabricSyncFormTestCase(TestCase):
         # But the provided initial value should be present
         self.assertEqual(form.initial.get("name"), "Override Name")
 
+    def test_htmx_boolean_field_list_values_handled(self):
+        """Test sanitizing HTMX BooleanField list values like ['', 'on']"""
+        # Simulate HTMX request where BooleanField values become lists
+        # This happens when `source` field value is changed and form is re-drawn via HTMX
+        form = IPFabricSyncForm(
+            initial={
+                "auto_merge": ["", "on"],  # HTMX sends BooleanField as list
+                "update_custom_fields": ["", "on"],  # Another BooleanField as list
+                "name": "Test Sync",  # Normal field (not affected)
+            },
+            data={
+                "name": "Test Sync HTMX",
+                "source": self.source.pk,
+                "snapshot_data": self.snapshot.pk,
+            },
+        )
+
+        # The last value from ['', 'on'] should be 'on' which evaluates to True for BooleanFields
+        self.assertEqual(form.initial["auto_merge"], "on")
+        self.assertEqual(form.initial["update_custom_fields"], "on")
+        self.assertEqual(form.initial["name"], "Test Sync")  # Normal field unchanged
+
+        # Verify the form is still valid and processes correctly
+        self.assertTrue(form.is_valid(), form.errors)
+
     def test_sites_initial_value_set_from_form_initial(self):
         """Test that sites field initial is set from self.initial["sites"]"""
         # Create an existing sync instance with sites in parameters
@@ -958,33 +1298,6 @@ class IPFabricSyncFormTestCase(TestCase):
         # Also verify that self.initial contains the expected sites
         self.assertEqual(form.initial["sites"], ["override_site1", "override_site2"])
 
-    def test_htmx_boolean_field_list_values_handled(self):
-        """Test sanitizing HTMX BooleanField list values like ['', 'on']"""
-        # Simulate HTMX request where BooleanField values become lists
-        # This happens when `source` field value is changed and form is re-drawn via HTMX
-        form = IPFabricSyncForm(
-            initial={
-                "auto_merge": ["", "on"],  # HTMX sends BooleanField as list
-                "update_custom_fields": ["", "on"],  # Another BooleanField as list
-                "ipf_site": ["", "on"],  # ipf_ prefixed field as list
-                "name": "Test Sync",  # Normal field (not affected)
-            },
-            data={
-                "name": "Test Sync HTMX",
-                "source": self.source.pk,
-                "snapshot_data": self.snapshot.pk,
-            },
-        )
-
-        # The last value from ['', 'on'] should be 'on' which evaluates to True for BooleanFields
-        self.assertEqual(form.initial["auto_merge"], "on")
-        self.assertEqual(form.initial["update_custom_fields"], "on")
-        self.assertEqual(form.initial["ipf_site"], "on")
-        self.assertEqual(form.initial["name"], "Test Sync")  # Normal field unchanged
-
-        # Verify the form is still valid and processes correctly
-        self.assertTrue(form.is_valid(), form.errors)
-
     def test_htmx_boolean_field_single_values_unchanged(self):
         """Test that normal single values are not affected by the HTMX list handling"""
         # Test with normal single values (not lists)
@@ -992,7 +1305,6 @@ class IPFabricSyncFormTestCase(TestCase):
             initial={
                 "auto_merge": True,  # Normal boolean value
                 "update_custom_fields": False,  # Normal boolean value
-                "ipf_site": "on",  # Normal string value
                 "name": "Test Sync",  # Normal string value
             },
             data={
@@ -1005,7 +1317,6 @@ class IPFabricSyncFormTestCase(TestCase):
         # Verify that single values are not processed by value sanitization
         self.assertEqual(form.initial["auto_merge"], True)
         self.assertEqual(form.initial["update_custom_fields"], False)
-        self.assertEqual(form.initial["ipf_site"], "on")
         self.assertEqual(form.initial["name"], "Test Sync")
 
         # Verify the form is still valid
@@ -1161,9 +1472,9 @@ class IPFabricSyncFormTestCase(TestCase):
         form = IPFabricSyncForm(
             data={
                 "name": "Test Sync Save",
+                "sites": ["site1", "site2"],
                 "source": self.source.pk,
                 "snapshot_data": self.snapshot.pk,
-                "sites": ["site1", "site2"],
                 "groups": [self.transform_map_group.pk],
                 "auto_merge": True,
                 "update_custom_fields": True,
@@ -1189,33 +1500,33 @@ class IPFabricSyncFormTestCase(TestCase):
         expected_parameters = {
             "sites": ["site1", "site2"],
             "groups": [self.transform_map_group.pk],
-            "site": False,
-            "manufacturer": False,
-            "devicetype": False,
-            "devicerole": False,
-            "platform": False,
-            "device": False,
-            "virtualchassis": False,
-            "interface": False,
-            "macaddress": False,
-            "inventoryitem": False,
-            "vlan": False,
-            "vrf": False,
-            "prefix": False,
-            "ipaddress": False,
+            "dcim.site": False,
+            "dcim.manufacturer": False,
+            "dcim.devicetype": False,
+            "dcim.devicerole": False,
+            "dcim.platform": False,
+            "dcim.device": False,
+            "dcim.virtualchassis": False,
+            "dcim.interface": False,
+            "dcim.macaddress": False,
+            "dcim.inventoryitem": False,
+            "ipam.vlan": False,
+            "ipam.vrf": False,
+            "ipam.prefix": False,
+            "ipam.ipaddress": False,
         }
         self.assertEqual(sync_instance.parameters, expected_parameters)
 
-    def test_save_method_with_ipf_parameters(self):
-        """Test save method properly handles ipf_ prefixed form fields"""
+    def test_save_method_with_model_parameters(self):
+        """Test save method properly handles model parameters form fields"""
         form = IPFabricSyncForm(
             data={
                 "name": "Test Sync IPF Params",
                 "source": self.source.pk,
                 "snapshot_data": self.snapshot.pk,
-                "ipf_site": True,
-                "ipf_interface": True,
-                "ipf_prefix": True,
+                "dcim.site": True,
+                "dcim.interface": True,
+                "ipam.prefix": True,
             }
         )
 
@@ -1223,25 +1534,25 @@ class IPFabricSyncFormTestCase(TestCase):
 
         sync_instance = form.save()
 
-        # Verify ipf_ parameters were stripped and stored correctly
+        # Verify parameters were stripped and stored correctly
         # All models are `False` since checkboxes must always default to False
         expected_parameters = {
             "sites": [],
             "groups": [],
-            "site": True,  # Explicitly set via ipf_site
-            "manufacturer": False,
-            "devicetype": False,
-            "devicerole": False,
-            "platform": False,
-            "device": False,
-            "virtualchassis": False,
-            "interface": True,  # Explicitly set via ipf_interface
-            "macaddress": False,
-            "inventoryitem": False,
-            "ipaddress": False,
-            "vlan": False,
-            "vrf": False,
-            "prefix": True,  # Explicitly set via ipf_prefix
+            "dcim.site": True,  # Explicitly set
+            "dcim.manufacturer": False,
+            "dcim.devicetype": False,
+            "dcim.devicerole": False,
+            "dcim.platform": False,
+            "dcim.device": False,
+            "dcim.virtualchassis": False,
+            "dcim.interface": True,  # Explicitly set
+            "dcim.macaddress": False,
+            "dcim.inventoryitem": False,
+            "ipam.ipaddress": False,
+            "ipam.vlan": False,
+            "ipam.vrf": False,
+            "ipam.prefix": True,  # Explicitly set
         }
         self.assertEqual(sync_instance.parameters, expected_parameters)
 
@@ -1487,7 +1798,6 @@ class IPFabricSyncFormTestCase(TestCase):
 
     def test_fieldsets_property_returns_correct_field_types(self):
         """Test that fieldsets property returns FieldSet objects with correct structure"""
-        from utilities.forms.rendering import FieldSet
 
         form = IPFabricSyncForm(
             data={
@@ -1532,3 +1842,875 @@ class IPFabricSyncFormTestCase(TestCase):
         fieldset_names1 = [fs.name for fs in fieldsets1]
         fieldset_names2 = [fs.name for fs in fieldsets2]
         self.assertEqual(fieldset_names1, fieldset_names2)
+
+
+class IPFabricFilterFormTestCase(TestCase):
+    """Test cases for IPFabricFilterForm"""
+
+    @classmethod
+    def setUpTestData(cls):
+        # Create endpoints for testing
+        cls.endpoint1 = IPFabricEndpoint.objects.get(endpoint="/inventory/devices")
+        cls.endpoint2 = IPFabricEndpoint.objects.get(endpoint="/inventory/interfaces")
+
+        # Create filter expressions for testing
+        cls.expression1 = IPFabricFilterExpression.objects.create(
+            name="Test Expression 1",
+            description="First test expression",
+            expression=[{"siteName": ["eq", "Site1"]}],
+        )
+        cls.expression2 = IPFabricFilterExpression.objects.create(
+            name="Test Expression 2",
+            description="Second test expression",
+            expression=[{"hostname": ["like", "router"]}],
+        )
+
+        # Create a sync object for testing
+        cls.source = IPFabricSource.objects.create(
+            name="Test Source",
+            type=IPFabricSourceTypeChoices.LOCAL,
+            url="https://test.ipfabric.local",
+            status=IPFabricSourceStatusChoices.NEW,
+        )
+        cls.snapshot = IPFabricSnapshot.objects.create(
+            name="Test Snapshot",
+            source=cls.source,
+            snapshot_id="test-snapshot-id",
+            status=IPFabricSnapshotStatusModelChoices.STATUS_LOADED,
+            data={"sites": ["site1", "site2"]},
+        )
+        cls.sync = IPFabricSync.objects.create(
+            name="Test Sync",
+            snapshot_data=cls.snapshot,
+        )
+
+    def test_fields_are_required(self):
+        """Test that required fields are validated"""
+        form = IPFabricFilterForm(data={})
+        self.assertFalse(form.is_valid(), form.errors)
+        self.assertIn("name", form.errors)
+        self.assertIn("filter_type", form.errors)
+
+    def test_fields_are_optional(self):
+        """Test that optional fields work correctly"""
+        form = IPFabricFilterForm(
+            data={
+                "name": "Test Filter",
+                "filter_type": IPFabricFilterTypeChoices.AND,
+            }
+        )
+        self.assertTrue(form.is_valid(), form.errors)
+
+    def test_valid_filter_form_with_all_fields(self):
+        """Test valid form submission with all fields"""
+        form = IPFabricFilterForm(
+            data={
+                "name": "Test Filter Complete",
+                "description": "A complete test filter",
+                "filter_type": IPFabricFilterTypeChoices.OR,
+                "endpoints": [self.endpoint1.pk, self.endpoint2.pk],
+                "syncs": [self.sync.pk],
+                "expressions": [self.expression1.pk, self.expression2.pk],
+            }
+        )
+        self.assertTrue(form.is_valid(), form.errors)
+        instance = form.save()
+
+        # Verify the instance was created correctly
+        self.assertEqual(instance.name, "Test Filter Complete")
+        self.assertEqual(instance.description, "A complete test filter")
+        self.assertEqual(instance.filter_type, IPFabricFilterTypeChoices.OR)
+
+        # Verify many-to-many relationships
+        self.assertEqual(
+            list(instance.endpoints.all()), [self.endpoint1, self.endpoint2]
+        )
+        self.assertEqual(list(instance.syncs.all()), [self.sync])
+        self.assertEqual(
+            list(instance.expressions.all().order_by("pk")),
+            [self.expression1, self.expression2],
+        )
+
+    def test_valid_filter_form_with_and_type(self):
+        """Test form with AND filter type"""
+        form = IPFabricFilterForm(
+            data={
+                "name": "AND Filter",
+                "filter_type": IPFabricFilterTypeChoices.AND,
+                "expressions": [self.expression1.pk],
+            }
+        )
+        self.assertTrue(form.is_valid(), form.errors)
+        instance = form.save()
+        self.assertEqual(instance.filter_type, IPFabricFilterTypeChoices.AND)
+
+    def test_valid_filter_form_with_or_type(self):
+        """Test form with OR filter type"""
+        form = IPFabricFilterForm(
+            data={
+                "name": "OR Filter",
+                "filter_type": IPFabricFilterTypeChoices.OR,
+                "expressions": [self.expression2.pk],
+            }
+        )
+        self.assertTrue(form.is_valid(), form.errors)
+        instance = form.save()
+        self.assertEqual(instance.filter_type, IPFabricFilterTypeChoices.OR)
+
+    def test_filter_type_must_be_valid_choice(self):
+        """Test that filter_type must be a valid choice"""
+        form = IPFabricFilterForm(
+            data={
+                "name": "Invalid Filter",
+                "filter_type": "invalid_type",
+            }
+        )
+        self.assertFalse(form.is_valid(), form.errors)
+        self.assertIn("filter_type", form.errors)
+
+    def test_form_initialization_with_existing_instance(self):
+        """Test that when editing an existing filter, expressions are properly initialized"""
+        # Create an existing filter with expressions
+        existing_filter = IPFabricFilter.objects.create(
+            name="Existing Filter",
+            filter_type=IPFabricFilterTypeChoices.AND,
+        )
+        existing_filter.expressions.set([self.expression1, self.expression2])
+
+        # Initialize form with the existing instance
+        form = IPFabricFilterForm(instance=existing_filter)
+
+        # Verify that expressions initial is set correctly
+        expected_ids = list(
+            existing_filter.expressions.all().values_list("id", flat=True)
+        )
+        actual_initial = (
+            list(form.fields["expressions"].initial)
+            if form.fields["expressions"].initial
+            else []
+        )
+        self.assertEqual(actual_initial, expected_ids)
+
+    def test_form_initialization_with_new_instance(self):
+        """Test form initialization for a new instance (no pk)"""
+        # Create a new instance without saving
+        new_filter = IPFabricFilter(
+            name="New Filter",
+            filter_type=IPFabricFilterTypeChoices.OR,
+        )
+
+        # Initialize form with new instance (no pk)
+        form = IPFabricFilterForm(instance=new_filter)
+
+        # Initial should not be set since instance.pk is None
+        self.assertIsNone(form.fields["expressions"].initial)
+
+    def test_save_method_sets_expressions(self):
+        """Test that save method properly sets the expressions relationship"""
+        form = IPFabricFilterForm(
+            data={
+                "name": "Filter with Expressions",
+                "filter_type": IPFabricFilterTypeChoices.AND,
+                "expressions": [self.expression1.pk, self.expression2.pk],
+            }
+        )
+        self.assertTrue(form.is_valid(), form.errors)
+
+        instance = form.save()
+
+        # Verify expressions were set correctly
+        expression_ids = list(instance.expressions.all().values_list("id", flat=True))
+        self.assertIn(self.expression1.pk, expression_ids)
+        self.assertIn(self.expression2.pk, expression_ids)
+        self.assertEqual(len(expression_ids), 2)
+
+    def test_save_method_updates_expressions(self):
+        """Test that save method properly updates expressions on existing instance"""
+        # Create an existing filter with one expression
+        existing_filter = IPFabricFilter.objects.create(
+            name="Existing Filter",
+            filter_type=IPFabricFilterTypeChoices.AND,
+        )
+        existing_filter.expressions.set([self.expression1])
+
+        # Update the filter to use different expressions
+        form = IPFabricFilterForm(
+            data={
+                "name": "Updated Filter",
+                "filter_type": IPFabricFilterTypeChoices.OR,
+                "expressions": [self.expression2.pk],
+            },
+            instance=existing_filter,
+        )
+        self.assertTrue(form.is_valid(), form.errors)
+
+        updated_instance = form.save()
+
+        # Verify expressions were updated
+        expression_ids = list(
+            updated_instance.expressions.all().values_list("id", flat=True)
+        )
+        self.assertEqual(expression_ids, [self.expression2.pk])
+        self.assertEqual(updated_instance.filter_type, IPFabricFilterTypeChoices.OR)
+
+    def test_save_method_clears_expressions(self):
+        """Test that save method can clear all expressions"""
+        # Create an existing filter with expressions
+        existing_filter = IPFabricFilter.objects.create(
+            name="Filter with Expressions",
+            filter_type=IPFabricFilterTypeChoices.AND,
+        )
+        existing_filter.expressions.set([self.expression1, self.expression2])
+
+        # Update the filter to have no expressions
+        form = IPFabricFilterForm(
+            data={
+                "name": "Filter without Expressions",
+                "filter_type": IPFabricFilterTypeChoices.AND,
+                "expressions": [],
+            },
+            instance=existing_filter,
+        )
+        self.assertTrue(form.is_valid(), form.errors)
+
+        updated_instance = form.save()
+
+        # Verify expressions were cleared
+        self.assertEqual(updated_instance.expressions.count(), 0)
+
+    def test_form_with_multiple_endpoints(self):
+        """Test form with multiple endpoints"""
+        form = IPFabricFilterForm(
+            data={
+                "name": "Multi-Endpoint Filter",
+                "filter_type": IPFabricFilterTypeChoices.AND,
+                "endpoints": [self.endpoint1.pk, self.endpoint2.pk],
+            }
+        )
+        self.assertTrue(form.is_valid(), form.errors)
+        instance = form.save()
+
+        self.assertEqual(instance.endpoints.count(), 2)
+        self.assertIn(self.endpoint1, instance.endpoints.all())
+        self.assertIn(self.endpoint2, instance.endpoints.all())
+
+    def test_form_with_multiple_syncs(self):
+        """Test form with multiple syncs"""
+        # Create another sync
+        sync2 = IPFabricSync.objects.create(
+            name="Test Sync 2",
+            snapshot_data=self.snapshot,
+        )
+
+        form = IPFabricFilterForm(
+            data={
+                "name": "Multi-Sync Filter",
+                "filter_type": IPFabricFilterTypeChoices.OR,
+                "syncs": [self.sync.pk, sync2.pk],
+            }
+        )
+        self.assertTrue(form.is_valid(), form.errors)
+        instance = form.save()
+
+        self.assertEqual(instance.syncs.count(), 2)
+        self.assertIn(self.sync, instance.syncs.all())
+        self.assertIn(sync2, instance.syncs.all())
+
+    def test_form_without_optional_fields(self):
+        """Test that form works without any optional fields"""
+        form = IPFabricFilterForm(
+            data={
+                "name": "Minimal Filter",
+                "filter_type": IPFabricFilterTypeChoices.AND,
+            }
+        )
+        self.assertTrue(form.is_valid(), form.errors)
+        instance = form.save()
+
+        self.assertEqual(instance.name, "Minimal Filter")
+        self.assertEqual(instance.endpoints.count(), 0)
+        self.assertEqual(instance.syncs.count(), 0)
+        self.assertEqual(instance.expressions.count(), 0)
+
+
+class IPFabricFilterExpressionFormTestCase(TestCase):
+    """Test cases for IPFabricFilterExpressionForm"""
+
+    @classmethod
+    def setUpTestData(cls):
+        # Create filters for testing
+        cls.filter1 = IPFabricFilter.objects.create(
+            name="Test Filter 1",
+            filter_type=IPFabricFilterTypeChoices.AND,
+        )
+        cls.filter2 = IPFabricFilter.objects.create(
+            name="Test Filter 2",
+            filter_type=IPFabricFilterTypeChoices.OR,
+        )
+
+    def test_fields_are_required(self):
+        """Test that required fields are validated"""
+        form = IPFabricFilterExpressionForm(data={})
+        self.assertFalse(form.is_valid(), form.errors)
+        self.assertIn("name", form.errors)
+        self.assertIn("expression", form.errors)
+
+    def test_fields_are_optional(self):
+        """Test that optional fields work correctly"""
+        form = IPFabricFilterExpressionForm(
+            data={
+                "name": "Test Expression",
+                "expression": [{"siteName": ["eq", "Site1"]}],
+            }
+        )
+        self.assertTrue(form.is_valid(), form.errors)
+
+    def test_valid_expression_form_with_all_fields(self):
+        """Test valid form submission with all fields"""
+        expression_data = [{"siteName": ["eq", "Site1"]}]
+        form = IPFabricFilterExpressionForm(
+            data={
+                "name": "Complete Expression",
+                "description": "A complete test expression",
+                "expression": expression_data,
+                "filters": [self.filter1.pk, self.filter2.pk],
+            }
+        )
+        self.assertTrue(form.is_valid(), form.errors)
+        instance = form.save()
+
+        # Verify the instance was created correctly
+        self.assertEqual(instance.name, "Complete Expression")
+        self.assertEqual(instance.description, "A complete test expression")
+        self.assertEqual(instance.expression, expression_data)
+
+        # Verify many-to-many relationships
+        self.assertEqual(instance.filters.count(), 2)
+        self.assertIn(self.filter1, instance.filters.all())
+        self.assertIn(self.filter2, instance.filters.all())
+
+    def test_valid_expression_with_simple_filter(self):
+        """Test form with a simple site name filter"""
+        form = IPFabricFilterExpressionForm(
+            data={
+                "name": "Site Filter",
+                "expression": [{"siteName": ["eq", "Site1"]}],
+            }
+        )
+        self.assertTrue(form.is_valid(), form.errors)
+        instance = form.save()
+        self.assertEqual(instance.expression, [{"siteName": ["eq", "Site1"]}])
+
+    def test_valid_expression_with_hostname_filter(self):
+        """Test form with hostname like filter"""
+        form = IPFabricFilterExpressionForm(
+            data={
+                "name": "Hostname Filter",
+                "expression": [{"hostname": ["like", "router"]}],
+            }
+        )
+        self.assertTrue(form.is_valid(), form.errors)
+        instance = form.save()
+        self.assertEqual(instance.expression, [{"hostname": ["like", "router"]}])
+
+    def test_valid_expression_with_complex_filter(self):
+        """Test form with complex nested filter expression"""
+        complex_expression = [
+            {
+                "or": [
+                    {"siteName": ["eq", "Site1"]},
+                    {"siteName": ["eq", "Site2"]},
+                ]
+            }
+        ]
+        form = IPFabricFilterExpressionForm(
+            data={
+                "name": "Complex Expression",
+                "expression": complex_expression,
+            }
+        )
+        self.assertTrue(form.is_valid(), form.errors)
+        instance = form.save()
+        self.assertEqual(instance.expression, complex_expression)
+
+    def test_valid_expression_with_multiple_conditions(self):
+        """Test form with multiple filter conditions"""
+        multi_condition_expression = [
+            {"siteName": ["eq", "Site1"]},
+            {"hostname": ["like", "switch"]},
+        ]
+        form = IPFabricFilterExpressionForm(
+            data={
+                "name": "Multi Condition",
+                "expression": multi_condition_expression,
+            }
+        )
+        self.assertTrue(form.is_valid(), form.errors)
+        instance = form.save()
+        self.assertEqual(instance.expression, multi_condition_expression)
+
+    def test_expression_must_be_valid_json(self):
+        """Test that expression field accepts valid JSON"""
+
+        # Valid JSON that will be parsed
+        valid_json_str = json.dumps([{"siteName": ["eq", "Site1"]}])
+        form = IPFabricFilterExpressionForm(
+            data={
+                "name": "JSON Expression",
+                "expression": json.loads(valid_json_str),  # Pass as Python object
+            }
+        )
+        self.assertTrue(form.is_valid(), form.errors)
+
+    def test_form_with_single_filter(self):
+        """Test form with a single filter"""
+        form = IPFabricFilterExpressionForm(
+            data={
+                "name": "Single Filter Expression",
+                "expression": [{"siteName": ["eq", "Site1"]}],
+                "filters": [self.filter1.pk],
+            }
+        )
+        self.assertTrue(form.is_valid(), form.errors)
+        instance = form.save()
+
+        self.assertEqual(instance.filters.count(), 1)
+        self.assertIn(self.filter1, instance.filters.all())
+
+    def test_form_with_multiple_filters(self):
+        """Test form with multiple filters"""
+        form = IPFabricFilterExpressionForm(
+            data={
+                "name": "Multi Filter Expression",
+                "expression": [{"hostname": ["like", "core"]}],
+                "filters": [self.filter1.pk, self.filter2.pk],
+            }
+        )
+        self.assertTrue(form.is_valid(), form.errors)
+        instance = form.save()
+
+        self.assertEqual(instance.filters.count(), 2)
+        self.assertIn(self.filter1, instance.filters.all())
+        self.assertIn(self.filter2, instance.filters.all())
+
+    def test_form_without_filters(self):
+        """Test that form works without any filters"""
+        form = IPFabricFilterExpressionForm(
+            data={
+                "name": "No Filter Expression",
+                "expression": [{"siteName": ["eq", "Site1"]}],
+            }
+        )
+        self.assertTrue(form.is_valid(), form.errors)
+        instance = form.save()
+
+        self.assertEqual(instance.filters.count(), 0)
+
+    def test_form_without_description(self):
+        """Test that description is optional"""
+        form = IPFabricFilterExpressionForm(
+            data={
+                "name": "No Description",
+                "expression": [{"siteName": ["eq", "Site1"]}],
+            }
+        )
+        self.assertTrue(form.is_valid(), form.errors)
+        instance = form.save()
+        self.assertEqual(instance.description, "")
+
+    def test_form_with_description(self):
+        """Test form with description field"""
+        description = "This is a detailed description of the filter expression"
+        form = IPFabricFilterExpressionForm(
+            data={
+                "name": "With Description",
+                "description": description,
+                "expression": [{"siteName": ["eq", "Site1"]}],
+            }
+        )
+        self.assertTrue(form.is_valid(), form.errors)
+        instance = form.save()
+        self.assertEqual(instance.description, description)
+
+    def test_form_update_existing_expression(self):
+        """Test updating an existing expression"""
+        # Create an existing expression
+        existing_expression = IPFabricFilterExpression.objects.create(
+            name="Existing Expression",
+            expression=[{"siteName": ["eq", "OldSite"]}],
+        )
+        existing_expression.filters.set([self.filter1])
+
+        # Update it
+        new_expression_data = [{"siteName": ["eq", "NewSite"]}]
+        form = IPFabricFilterExpressionForm(
+            data={
+                "name": "Updated Expression",
+                "description": "Updated description",
+                "expression": new_expression_data,
+                "filters": [self.filter2.pk],
+            },
+            instance=existing_expression,
+        )
+        self.assertTrue(form.is_valid(), form.errors)
+        updated_instance = form.save()
+
+        # Verify updates
+        self.assertEqual(updated_instance.name, "Updated Expression")
+        self.assertEqual(updated_instance.description, "Updated description")
+        self.assertEqual(updated_instance.expression, new_expression_data)
+        self.assertEqual(list(updated_instance.filters.all()), [self.filter2])
+
+    def test_form_clear_filters(self):
+        """Test clearing all filters from an existing expression"""
+        # Create an existing expression with filters
+        existing_expression = IPFabricFilterExpression.objects.create(
+            name="Expression with Filters",
+            expression=[{"siteName": ["eq", "Site1"]}],
+        )
+        existing_expression.filters.set([self.filter1, self.filter2])
+
+        # Clear filters
+        form = IPFabricFilterExpressionForm(
+            data={
+                "name": "Expression without Filters",
+                "expression": [{"siteName": ["eq", "Site1"]}],
+                "filters": [],
+            },
+            instance=existing_expression,
+        )
+        self.assertTrue(form.is_valid(), form.errors)
+        updated_instance = form.save()
+
+        # Verify filters were cleared
+        self.assertEqual(updated_instance.filters.count(), 0)
+
+    def test_name_must_be_unique(self):
+        """Test that name field must be unique"""
+        # Create first expression
+        IPFabricFilterExpression.objects.create(
+            name="Unique Name",
+            expression=[{"siteName": ["eq", "Site1"]}],
+        )
+
+        # Try to create another with same name
+        form = IPFabricFilterExpressionForm(
+            data={
+                "name": "Unique Name",
+                "expression": [{"siteName": ["eq", "Site2"]}],
+            }
+        )
+        self.assertFalse(form.is_valid())
+        self.assertIn("name", form.errors)
+
+    def test_textarea_widget_for_expression(self):
+        """Test that expression field uses Textarea widget with monospace class"""
+        form = IPFabricFilterExpressionForm()
+        expression_widget = form.fields["expression"].widget
+
+        # Check widget type
+        self.assertIsInstance(expression_widget, forms.Textarea)
+
+        # Check that it has the monospace class
+        self.assertIn("class", expression_widget.attrs)
+        self.assertIn("font-monospace", expression_widget.attrs["class"])
+
+    def test_form_with_various_operator_types(self):
+        """Test expressions with various operator types"""
+        operators = [
+            [{"siteName": ["eq", "Site1"]}],  # equals
+            [{"hostname": ["like", "%router%"]}],  # like
+            [{"hostname": ["reg", "^switch.*"]}],  # regex
+            [{"vlan": ["gt", 100]}],  # greater than
+            [{"vlan": ["lt", 200]}],  # less than
+        ]
+
+        for i, expression_data in enumerate(operators):
+            form = IPFabricFilterExpressionForm(
+                data={
+                    "name": f"Operator Test {i}",
+                    "expression": expression_data,
+                }
+            )
+            self.assertTrue(
+                form.is_valid(), f"Form invalid for {expression_data}: {form.errors}"
+            )
+            instance = form.save()
+            self.assertEqual(instance.expression, expression_data)
+
+    def test_form_minimal_required_fields(self):
+        """Test form with only minimal required fields"""
+        form = IPFabricFilterExpressionForm(
+            data={
+                "name": "Minimal Expression",
+                "expression": [{"siteName": ["eq", "Site1"]}],
+            }
+        )
+        self.assertTrue(form.is_valid(), form.errors)
+        instance = form.save()
+
+        self.assertEqual(instance.name, "Minimal Expression")
+        self.assertEqual(instance.expression, [{"siteName": ["eq", "Site1"]}])
+        self.assertEqual(instance.description, "")
+        self.assertEqual(instance.filters.count(), 0)
+
+    def test_expression_must_be_list(self):
+        """Test that expression must be a list (validation at model level)"""
+        # Try to save with a string instead of list
+        form = IPFabricFilterExpressionForm(
+            data={
+                "name": "Invalid String Expression",
+                "expression": "not a list",
+            }
+        )
+        self.assertFalse(form.is_valid())
+        self.assertIn("expression", form.errors)
+
+    def test_expression_cannot_be_empty_list(self):
+        """Test that expression cannot be an empty list (validation at model level)"""
+        form = IPFabricFilterExpressionForm(
+            data={
+                "name": "Empty List Expression",
+                "expression": [],
+            }
+        )
+        self.assertFalse(form.is_valid())
+        self.assertIn("expression", form.errors)
+
+    def test_expression_must_contain_dictionaries(self):
+        """Test that expression items must be dictionaries (validation at model level)"""
+        # Test with list containing strings
+        form = IPFabricFilterExpressionForm(
+            data={
+                "name": "Invalid List Items",
+                "expression": ["string1", "string2"],
+            }
+        )
+        self.assertFalse(form.is_valid())
+        self.assertIn("expression", form.errors)
+
+    def test_expression_with_mixed_types(self):
+        """Test that expression rejects mixed types in list (validation at model level)"""
+        form = IPFabricFilterExpressionForm(
+            data={
+                "name": "Mixed Types Expression",
+                "expression": [{"siteName": ["eq", "Site1"]}, "not a dict", 123],
+            }
+        )
+        self.assertFalse(form.is_valid())
+        self.assertIn("expression", form.errors)
+
+    def test_expression_with_list_of_integers(self):
+        """Test that expression rejects list of integers (validation at model level)"""
+        form = IPFabricFilterExpressionForm(
+            data={
+                "name": "Integer List Expression",
+                "expression": [1, 2, 3],
+            }
+        )
+        self.assertFalse(form.is_valid())
+        self.assertIn("expression", form.errors)
+
+    def test_expression_with_nested_structure(self):
+        """Test that expression accepts complex nested dictionary structures"""
+        complex_expr = [
+            {
+                "and": [
+                    {"siteName": ["eq", "Site1"]},
+                    {
+                        "or": [
+                            {"hostname": ["like", "router%"]},
+                            {"hostname": ["like", "switch%"]},
+                        ]
+                    },
+                ]
+            }
+        ]
+        form = IPFabricFilterExpressionForm(
+            data={
+                "name": "Nested Structure Expression",
+                "expression": complex_expr,
+            }
+        )
+        self.assertTrue(form.is_valid(), form.errors)
+        instance = form.save()
+        self.assertEqual(instance.expression, complex_expr)
+
+    def test_form_init_sets_test_source_initial_when_single_source(self):
+        """Test that form __init__ sets test_source initial value when only one LOCAL source exists"""
+
+        # Create a LOCAL source
+        source = IPFabricSource.objects.create(
+            name="Test Local Source",
+            type=IPFabricSourceTypeChoices.LOCAL,
+            url="https://test.local",
+        )
+
+        # Create snapshot and sync with LOCAL source
+        snapshot = IPFabricSnapshot.objects.create(
+            name="Test Snapshot",
+            source=source,
+        )
+        sync = IPFabricSync.objects.create(
+            name="Test Sync",
+            snapshot_data=snapshot,
+        )
+
+        # Create filter with endpoint
+        filter_obj = IPFabricFilter.objects.create(
+            name="Test Filter with Source",
+            filter_type=IPFabricFilterTypeChoices.AND,
+        )
+        filter_obj.syncs.add(sync)
+
+        # Create expression and associate with filter
+        expression = IPFabricFilterExpression.objects.create(
+            name="Expression with Single Source",
+            expression=[{"siteName": ["eq", "Site1"]}],
+        )
+        expression.filters.add(filter_obj)
+
+        # Create form with instance - should set test_source initial value
+        form = IPFabricFilterExpressionForm(instance=expression)
+
+        # Verify test_source initial value is set
+        self.assertEqual(form.fields["test_source"].initial, source)
+
+    def test_form_init_sets_test_endpoint_initial_when_single_endpoint(self):
+        """Test that form __init__ sets test_endpoint initial value when only one endpoint exists"""
+
+        # Get or create an endpoint
+        endpoint = IPFabricEndpoint.objects.first()
+        if not endpoint:
+            endpoint = IPFabricEndpoint.objects.create(
+                name="Test Endpoint", endpoint="/tables/devices"
+            )
+
+        # Create filter with endpoint
+        filter_obj = IPFabricFilter.objects.create(
+            name="Test Filter with Endpoint",
+            filter_type=IPFabricFilterTypeChoices.AND,
+        )
+        filter_obj.endpoints.add(endpoint)
+
+        # Create expression and associate with filter
+        expression = IPFabricFilterExpression.objects.create(
+            name="Expression with Single Endpoint",
+            expression=[{"siteName": ["eq", "Site1"]}],
+        )
+        expression.filters.add(filter_obj)
+
+        # Create form with instance - should set test_endpoint initial value
+        form = IPFabricFilterExpressionForm(instance=expression)
+
+        # Verify test_endpoint initial value is set
+        self.assertEqual(form.fields["test_endpoint"].initial, endpoint)
+
+    def test_form_init_does_not_set_initial_when_multiple_sources(self):
+        """Test that form __init__ does not set test_source when multiple LOCAL sources exist"""
+
+        # Create two LOCAL sources
+        source1 = IPFabricSource.objects.create(
+            name="Test Local Source 1",
+            type=IPFabricSourceTypeChoices.LOCAL,
+            url="https://test1.local",
+        )
+        source2 = IPFabricSource.objects.create(
+            name="Test Local Source 2",
+            type=IPFabricSourceTypeChoices.LOCAL,
+            url="https://test2.local",
+        )
+
+        # Create snapshots and syncs
+        snapshot1 = IPFabricSnapshot.objects.create(
+            name="Test Snapshot 1", source=source1
+        )
+        snapshot2 = IPFabricSnapshot.objects.create(
+            name="Test Snapshot 2", source=source2
+        )
+
+        sync1 = IPFabricSync.objects.create(
+            name="Test Sync 1",
+            snapshot_data=snapshot1,
+        )
+        sync2 = IPFabricSync.objects.create(
+            name="Test Sync 2",
+            snapshot_data=snapshot2,
+        )
+
+        # Create two filters with different syncs
+        filter1 = IPFabricFilter.objects.create(
+            name="Test Filter for Source 1",
+            filter_type=IPFabricFilterTypeChoices.AND,
+        )
+        filter1.syncs.add(sync1)
+
+        filter2 = IPFabricFilter.objects.create(
+            name="Test Filter for Source 2",
+            filter_type=IPFabricFilterTypeChoices.AND,
+        )
+        filter2.syncs.add(sync2)
+
+        # Create expression and associate with both filters
+        expression = IPFabricFilterExpression.objects.create(
+            name="Expression with Multiple Sources",
+            expression=[{"siteName": ["eq", "Site1"]}],
+        )
+        expression.filters.add(filter1, filter2)
+
+        # Create form with instance - should NOT set test_source initial value
+        form = IPFabricFilterExpressionForm(instance=expression)
+
+        # Verify test_source initial value is NOT set
+        self.assertIsNone(form.fields["test_source"].initial)
+
+    def test_form_init_does_not_set_initial_when_multiple_endpoints(self):
+        """Test that form __init__ does not set test_endpoint when multiple endpoints exist"""
+
+        # Get or create two endpoints
+        endpoint1 = IPFabricEndpoint.objects.filter(endpoint="/tables/devices").first()
+        endpoint2 = IPFabricEndpoint.objects.filter(endpoint="/tables/sites").first()
+
+        if not endpoint1:
+            endpoint1 = IPFabricEndpoint.objects.create(
+                name="Devices Endpoint", endpoint="/tables/devices"
+            )
+        if not endpoint2:
+            endpoint2 = IPFabricEndpoint.objects.create(
+                name="Sites Endpoint", endpoint="/tables/sites"
+            )
+
+        # Create two filters with different endpoints
+        filter1 = IPFabricFilter.objects.create(
+            name="Test Filter Devices",
+            filter_type=IPFabricFilterTypeChoices.AND,
+        )
+        filter1.endpoints.add(endpoint1)
+
+        filter2 = IPFabricFilter.objects.create(
+            name="Test Filter Sites",
+            filter_type=IPFabricFilterTypeChoices.AND,
+        )
+        filter2.endpoints.add(endpoint2)
+
+        # Create expression and associate with both filters
+        expression = IPFabricFilterExpression.objects.create(
+            name="Expression with Multiple Endpoints",
+            expression=[{"siteName": ["eq", "Site1"]}],
+        )
+        expression.filters.add(filter1, filter2)
+
+        # Create form with instance - should NOT set test_endpoint initial value
+        form = IPFabricFilterExpressionForm(instance=expression)
+
+        # Verify test_endpoint initial value is NOT set
+        self.assertIsNone(form.fields["test_endpoint"].initial)
+
+    def test_form_init_with_new_instance_does_not_set_initial(self):
+        """Test that form __init__ does not set initial values for new instances"""
+        # Create form without instance (new expression)
+        form = IPFabricFilterExpressionForm()
+
+        # Verify no initial values are set
+        self.assertIsNone(form.fields["test_source"].initial)
+        self.assertIsNone(form.fields["test_endpoint"].initial)