Merge ~cgrabowski/maas:expanded_text_filter into maas:master

[Christian Grabowski]

move websocket handler node constraint form to child class

substring match multiple substrings

add substring filter

[MAAS Lander (maas-lander)]

UNIT TESTS
-b expanded_text_filter lp:~cgrabowski/maas/+git/maas into -b master lp:~maas-committers/maas

STATUS: FAILED
LOG: http://maas-ci.internal:8080/job/maas/job/branch-tester/13161/console
COMMIT: 84ff165ae2cac6a41cd9bd8074aa949594e62ef0

review: Needs Fixing

[Alexsander de Souza (alexsander-souza)]

Some testcases broke (see TestFilterNodeForm)

also a few nits inline

review: Needs Fixing

[MAAS Lander (maas-lander)]

UNIT TESTS
-b expanded_text_filter lp:~cgrabowski/maas/+git/maas into -b master lp:~maas-committers/maas

STATUS: FAILED
LOG: http://maas-ci.internal:8080/job/maas/job/branch-tester/13172/console
COMMIT: 221e8b8f94a6bf54f8b2095193b9fe92846aae50

review: Needs Fixing

[Christian Grabowski (cgrabowski)]

jenkins: !test

[Alexsander de Souza (alexsander-souza)]

+1

review: Approve

[MAAS Lander (maas-lander)]

UNIT TESTS
-b expanded_text_filter lp:~cgrabowski/maas/+git/maas into -b master lp:~maas-committers/maas

STATUS: SUCCESS
COMMIT: 221e8b8f94a6bf54f8b2095193b9fe92846aae50

review: Approve

[MAAS Lander (maas-lander)]

UNIT TESTS
-b expanded_text_filter lp:~cgrabowski/maas/+git/maas into -b master lp:~maas-committers/maas

STATUS: SUCCESS
COMMIT: 5c01b76229dc726321269b724e59fec9fc6ba7d4

review: Approve

[MAAS Lander (maas-lander)]

LANDING
-b expanded_text_filter lp:~cgrabowski/maas/+git/maas into -b master lp:~maas-committers/maas

STATUS: FAILED BUILD
LOG: http://maas-ci.internal:8080/job/maas/job/branch-tester/13178/consoleText

[MAAS Lander (maas-lander)]

LANDING
-b expanded_text_filter lp:~cgrabowski/maas/+git/maas into -b master lp:~maas-committers/maas

STATUS: FAILED BUILD
LOG: http://maas-ci.internal:8080/job/maas/job/branch-tester/13179/consoleText

diff --git a/src/maasserver/node_constraint_filter_forms.py b/src/maasserver/node_constraint_filter_forms.py
index bfdee5e..1a4a765 100644
--- a/src/maasserver/node_constraint_filter_forms.py
+++ b/src/maasserver/node_constraint_filter_forms.py
@@ -29,6 +29,7 @@ from maasserver.forms import (
 )
 from maasserver.models import (
     BlockDevice,
+    BootResource,
     Filesystem,
     Interface,
     Node,
@@ -876,6 +877,13 @@ class FilterNodeForm(RenamableFieldsForm):
             )
         return None
 
+    def _set_clean_tags_error(self, tag_names, db_tag_names):
+        unknown_tags = tag_names.difference(db_tag_names)
+        error_msg = "No such tag(s): %s." % ", ".join(
+            "'%s'" % tag for tag in unknown_tags
+        )
+        set_form_error(self, self.get_field_name("tags"), error_msg)
+
     def clean_tags(self):
         value = self.cleaned_data[self.get_field_name("tags")]
         if value:
@@ -888,22 +896,24 @@ class FilterNodeForm(RenamableFieldsForm):
                 )
             )
             if len(tag_names) != len(db_tag_names):
-                unknown_tags = tag_names.difference(db_tag_names)
-                error_msg = "No such tag(s): %s." % ", ".join(
-                    "'%s'" % tag for tag in unknown_tags
-                )
-                set_form_error(self, self.get_field_name("tags"), error_msg)
+                self._set_clean_tags_error(tag_names, db_tag_names)
                 return None
             return tag_names
         return None
 
+    def _set_zone_error(self, value, field):
+        if type(value) == list:
+            error_msg = "No such zone(s): %s." % ", ".join(value)
+        else:
+            error_msg = "No such zone: '%s'." % value
+        set_form_error(self, self.get_field_name(field), error_msg)
+
     def clean_zone(self):
         value = self.cleaned_data[self.get_field_name("zone")]
         if value:
             nonexistent_names = detect_nonexistent_names(Zone, [value])
             if nonexistent_names:
-                error_msg = "No such zone: '%s'." % value
-                set_form_error(self, self.get_field_name("zone"), error_msg)
+                self._set_zone_error(value, "zone")
                 return None
             return value
         return None
@@ -914,18 +924,23 @@ class FilterNodeForm(RenamableFieldsForm):
             return None
         nonexistent_names = detect_nonexistent_names(Zone, value)
         if nonexistent_names:
-            error_msg = "No such zone(s): %s." % ", ".join(nonexistent_names)
-            set_form_error(self, self.get_field_name("not_in_zone"), error_msg)
+            self._set_zone_error(nonexistent_names, "not_in_zone")
             return None
         return value
 
+    def _set_pool_error(self, value, field):
+        if type(value) == list:
+            error_msg = "No such pool(s): %s." % ", ".join(value)
+        else:
+            error_msg = "No such pool: '%s'." % value
+        set_form_error(self, self.get_field_name(field), error_msg)
+
     def clean_pool(self):
         value = self.cleaned_data[self.get_field_name("pool")]
         if value:
             nonexistent_names = detect_nonexistent_names(ResourcePool, [value])
             if nonexistent_names:
-                error_msg = "No such pool: '%s'." % value
-                set_form_error(self, self.get_field_name("pool"), error_msg)
+                self._set_pool_error(value, "pool")
                 return None
             return value
         return None
@@ -936,8 +951,7 @@ class FilterNodeForm(RenamableFieldsForm):
             return None
         nonexistent_names = detect_nonexistent_names(ResourcePool, value)
         if nonexistent_names:
-            error_msg = "No such pool(s): %s." % ", ".join(nonexistent_names)
-            set_form_error(self, self.get_field_name("not_in_pool"), error_msg)
+            self._set_pool_error(nonexistent_names, "not_in_pool")
             return None
         return value
 
@@ -1407,3 +1421,278 @@ class ReadNodesForm(FilterNodeForm):
             status_id = getattr(NODE_STATUS, status.upper())
             filtered_nodes = filtered_nodes.filter(status=status_id)
         return filtered_nodes
+
+
+class FreeTextFilterNodeForm(ReadNodesForm):
+
+    mac_address = UnconstrainedMultipleChoiceField(
+        label="MAC addresses to filter on",
+        required=False,
+    )
+
+    def _substring_filter(self, queryset, field, substring, exclude=False):
+        if type(substring) != str:  # assume substring is a list of substrings
+            query = Q()
+            for substr in substring:
+                substring_filter = {f"{field}__contains": substr}
+                query = query | Q(**substring_filter)
+            if exclude:
+                return queryset.exclude(query)
+            return queryset.filter(query)
+
+        substring_filter = {f"{field}__contains": substring}
+        if exclude:
+            return queryset.exclude(**substring_filter)
+        return queryset.filter(**substring_filter)
+
+    def clean_tags(self):
+        value = self.cleaned_data[self.get_field_name("tags")]
+        if value:
+            tag_names = parse_legacy_tags(value)
+            # Validate tags.
+            tag_names = set(tag_names)
+            db_tag_names = set(
+                self._substring_filter(
+                    Tag.objects, "name", tag_names
+                ).values_list("name", flat=True)
+            )
+            if len(tag_names) < len(db_tag_names):
+                self._set_clean_tags_error(tag_names, db_tag_names)
+                return None
+            return db_tag_names
+
+    def clean_arch(self):
+        value = self.cleaned_data[self.get_field_name("arch")]
+        if value:
+            archs = self._substring_filter(
+                BootResource.objects, "architecture", value
+            ).values_list("architecture", flat=True)
+            if not archs:
+                set_form_error(
+                    self,
+                    self.get_field_name("arch"),
+                    "Architecture not recognised.",
+                )
+                return None
+            return archs
+
+    def _clean_zones(self, value, field):
+        zones = self._substring_filter(Zone.objects, "name", value)
+        if not zones:
+            self._set_zone_error(value + "*", field)
+            return None
+        return zones
+
+    def clean_zone(self):
+        value = self.cleaned_data[self.get_field_name("zone")]
+        if value:
+            return self._clean_zones(value, "zone")
+
+    def clean_not_in_zone(self):
+        value = self.cleaned_data[self.get_field_name("not_in_zone")]
+        if value:
+            return self._clean_zones(value, "not_in_zone")
+
+    def filter_by_zone(self, filtered_nodes):
+        zones = self.cleaned_data.get(self.get_field_name("zone"))
+        if zones:
+            filtered_nodes = filtered_nodes.filter(zone__in=zones)
+        not_in_zones = self.cleaned_data.get(
+            self.get_field_name("not_in_zone")
+        )
+        if not_in_zones:
+            filtered_nodes = filtered_nodes.exclude(zone__in=not_in_zones)
+        return filtered_nodes
+
+    def _clean_pools(self, value, field):
+        pool = self._substring_filter(ResourcePool.objects, "name", value)
+        if not pool:
+            self._set_pool_error(value + "*", field)
+            return None
+        return pool
+
+    def clean_pool(self):
+        value = self.cleaned_data[self.get_field_name("pool")]
+        if value:
+            return self._clean_pools(value, "pool")
+
+    def clean_not_in_pool(self):
+        value = self.cleaned_data[self.get_field_name("not_in_pool")]
+        if value:
+            return self._clean_pools(value, "not_in_pool")
+
+    def filter_by_pool(self, filtered_nodes):
+        pools = self.cleaned_data.get(self.get_field_name("pool"))
+        if pools:
+            filtered_nodes = filtered_nodes.filter(pool__in=pools)
+        not_in_pools = self.cleaned_data.get(
+            self.get_field_name("not_in_pool")
+        )
+        if not_in_pools:
+            filtered_nodes = filtered_nodes.exclude(pool__in=not_in_pools)
+        return filtered_nodes
+
+    def filter_by_pod_or_pod_type(self, filtered_nodes):
+        pod_name = self.cleaned_data[self.get_field_name("pod")]
+        not_pod_name = self.cleaned_data[self.get_field_name("not_pod")]
+        pod_type = self.cleaned_data[self.get_field_name("pod_type")]
+        not_pod_type = self.cleaned_data[self.get_field_name("not_pod_type")]
+        if pod_name:
+            filtered_nodes = self._substring_filter(
+                filtered_nodes, "bmc__name", pod_name
+            )
+        if not_pod_name:
+            filtered_nodes = self._substring_filter(
+                filtered_nodes, "bmc__name", not_pod_name, exclude=True
+            )
+        if pod_type:
+            filtered_nodes = self._substring_filter(
+                filtered_nodes, "bmc__type", pod_type
+            )
+        if not_pod_type:
+            filtered_nodes = self._substring_filter(
+                Pod.objects, "bmc__type", not_pod_type, exclude=True
+            )
+        return filtered_nodes
+
+    def filter_by_fabric_classes(self, filtered_nodes):
+        fabric_classes = self.cleaned_data.get(
+            self.get_field_name("fabric_classes")
+        )
+        if fabric_classes:
+            filtered_nodes = self._substring_filter(
+                filtered_nodes,
+                "current_config__interface__vlan__fabric__class_type",
+                fabric_classes,
+            )
+        not_fabric_classes = self.cleaned_data.get(
+            self.get_field_name("not_fabric_classes")
+        )
+        if not_fabric_classes:
+            filtered_nodes = self._substring_filter(
+                filtered_nodes,
+                "current_config__interface__vlan__fabric__class_type",
+                not_fabric_classes,
+                exclude=True,
+            )
+        return filtered_nodes
+
+    def filter_by_fabrics(self, filtered_nodes):
+        fabrics = self.cleaned_data.get(self.get_field_name("fabrics"))
+        if fabrics:
+            filtered_nodes = self._substring_filter(
+                filtered_nodes,
+                "current_config__interface__vlan__fabric__name",
+                fabrics,
+            )
+        not_fabrics = self.cleaned_data.get(self.get_field_name("not_fabrics"))
+        if not_fabrics:
+            filtered_nodes = self._substring_filter(
+                filtered_nodes,
+                "current_config__interface__vlan__fabric__name",
+                not_fabrics,
+                exclude=True,
+            )
+        return filtered_nodes
+
+    def clean_vlans(self):
+        value = self.cleaned_data.get(self.get_field_name("vlans"))
+        if value:
+            vlans = self._substring_filter(VLAN.objects, "name", value)
+            if not vlans:
+                set_form_error(
+                    self,
+                    self.get_field_name("vlans"),
+                    "no vlan found for %s" % value,
+                )
+                return None
+            return value
+
+    def filter_by_vlans(self, filtered_nodes):
+        vlans = self.cleaned_data.get(self.get_field_name("vlans"))
+        if vlans:
+            filtered_nodes = self._substring_filter(
+                filtered_nodes, "current_config__interface__vlan__name", vlans
+            )
+        not_vlans = self.cleaned_data.get(self.get_field_name("not_vlans"))
+        if not_vlans:
+            filtered_nodes = self._substring_filter(
+                filtered_nodes,
+                "current_config__interface__vlan__name",
+                vlans,
+                exclude=True,
+            )
+        return filtered_nodes
+
+    def clean_subnets(self):
+        value = self.cleaned_data.get(self.get_field_name("subnets"))
+        if value:
+            subnets = self._substring_filter(Subnet.objects, "cidr", value)
+            if not subnets:
+                set_form_error(
+                    self,
+                    self.get_field_name("subnets"),
+                    "no subnet found for %s" % value,
+                )
+                return None
+            return value
+
+    def filter_by_subnets(self, filtered_nodes):
+        subnets = self.cleaned_data.get(self.get_field_name("subnets"))
+        if subnets:
+            filtered_nodes = self._substring_filter(
+                filtered_nodes,
+                "current_config__interface__ip_addresses__subnet__cidr",
+                subnets,
+            )
+        not_subnets = self.cleaned_data.get(self.get_field_name("not_subnets"))
+        if not_subnets:
+            filtered_nodes = self._substring_filter(
+                filtered_nodes,
+                "current_config__interface__ip_addresses__subnet__cidr",
+                not_subnets,
+                exclude=True,
+            )
+        return filtered_nodes
+
+    def filter_by_hostnames(self, filtered_nodes):
+        hostnames = self.cleaned_data.get(self.get_field_name("hostname"))
+        if hostnames:
+            filtered_nodes = self._substring_filter(
+                filtered_nodes, "hostname", hostnames
+            )
+        return filtered_nodes
+
+    def clean_mac_address(self):
+        value = self.cleaned_data.get(self.get_field_name("mac_address"))
+        if value:
+            interfaces = self._substring_filter(
+                Interface.objects, "mac_address", value
+            )
+            if not interfaces:
+                set_form_error(
+                    self,
+                    self.get_field_name("mac_address"),
+                    "no mac address found for %s" % value,
+                )
+                return None
+            return value
+
+    def filter_by_mac_addresses(self, filtered_nodes):
+        value = self.cleaned_data.get(self.get_field_name("mac_address"))
+        if value:
+            interfaces = self._substring_filter(
+                Interface.objects, "mac_address", value
+            )
+            filtered_nodes = filtered_nodes.filter(
+                current_config__interface__in=interfaces
+            )
+        return filtered_nodes
+
+    def filter_by_agent_name(self, filtered_nodes):
+        agent_name = self.cleaned_data[self.get_field_name("agent_name")]
+        if agent_name:
+            filtered_nodes = self._substring_filter(
+                filtered_nodes, "agent_name", agent_name
+            )
+        return filtered_nodes
diff --git a/src/maasserver/tests/test_node_constraint_filter_forms.py b/src/maasserver/tests/test_node_constraint_filter_forms.py
index 9df891b..df67c69 100644
--- a/src/maasserver/tests/test_node_constraint_filter_forms.py
+++ b/src/maasserver/tests/test_node_constraint_filter_forms.py
@@ -24,11 +24,12 @@ from maasserver.enum import (
     NODE_STATUS,
     POWER_STATE,
 )
-from maasserver.models import Domain, Machine, NodeDevice, Zone
+from maasserver.models import Domain, Machine, NodeDevice, Tag, Zone
 from maasserver.node_constraint_filter_forms import (
     AcquireNodeForm,
     detect_nonexistent_names,
     FilterNodeForm,
+    FreeTextFilterNodeForm,
     generate_architecture_wildcards,
     get_architecture_wildcards,
     get_storage_constraints_from_string,
@@ -1592,6 +1593,242 @@ class TestFilterNodeForm(MAASServerTestCase, FilterConstraintsMixin):
         self.assertEqual(constraints.keys(), described_constraints)
 
 
+class TestFreeTextFilterNodeForm(MAASServerTestCase, FilterConstraintsMixin):
+    def test_substring_filter_one_substring(self):
+        name = factory.make_name("hostname")
+        node1 = factory.make_Node(hostname=name)
+        node2 = factory.make_Node()
+        form = FreeTextFilterNodeForm(data={})
+        result = form._substring_filter(
+            Machine.objects, "hostname", name[0 : len("hostname-") + 1]
+        )
+        self.assertIn(node1, list(result))
+        self.assertNotIn(node2, list(result))
+
+    def test_substring_filter_list_of_substrings(self):
+        tags = [
+            factory.make_Tag(name=factory.make_name("tag")) for _ in range(3)
+        ]
+        form = FreeTextFilterNodeForm(data={})
+        # +1 to include first letter in random suffix
+        result = form._substring_filter(
+            Tag.objects,
+            "name",
+            [tag.name[0 : len("tag-") + 1] for tag in tags],
+        )
+        self.assertCountEqual(tags, list(result))
+
+    def test_substring_filter_exact_match(self):
+        name = factory.make_name("hostname")
+        node1 = factory.make_Node(hostname=name)
+        node2 = factory.make_Node()
+        form = FreeTextFilterNodeForm(data={})
+        result = form._substring_filter(Machine.objects, "hostname", name)
+        self.assertIn(node1, list(result))
+        self.assertNotIn(node2, list(result))
+
+    def test_substring_arch_filter(self):
+        architecture = factory.make_name("arch")
+        subarch = factory.make_name()
+        arch = "/".join([architecture, subarch])
+        factory.make_usable_boot_resource(architecture=arch)
+        node1 = factory.make_Node(architecture=arch)
+        node2 = factory.make_Node()
+        constraints = {
+            "arch": arch[:2],
+        }
+        form = FreeTextFilterNodeForm(data=constraints)
+        self.assertTrue(form.is_valid())
+        filtered_nodes = form.filter_nodes(Machine.objects.all())[0]
+        self.assertIn(node1, filtered_nodes)
+        self.assertNotIn(node2, filtered_nodes)
+
+    def test_substring_tag_filter(self):
+        tags = [
+            factory.make_Tag(name=factory.make_name("tag")) for _ in range(3)
+        ]
+        node1 = factory.make_Node()
+        node2 = factory.make_Node()
+        [node1.tags.add(tag) for tag in tags]
+        constraints = {
+            "tags": [tag.name[: len("tag-") + 1] for tag in tags],
+        }
+        form = FreeTextFilterNodeForm(data=constraints)
+        self.assertTrue(form.is_valid())
+        filtered_nodes = form.filter_nodes(Machine.objects.all())[0]
+        self.assertIn(node1, filtered_nodes)
+        self.assertNotIn(node2, filtered_nodes)
+
+    def test_substring_zone_filter(self):
+        zone = factory.make_Zone()
+        node1 = factory.make_Node(zone=zone)
+        node2 = factory.make_Node()
+        constraints = {
+            "zone": zone.name[:2],
+        }
+        form = FreeTextFilterNodeForm(data=constraints)
+        self.assertTrue(form.is_valid())
+        filtered_nodes = form.filter_nodes(Machine.objects.all())[0]
+        self.assertIn(node1, filtered_nodes)
+        self.assertNotIn(node2, filtered_nodes)
+
+    def test_substring_not_in_zone_filter(self):
+        zone = factory.make_Zone()
+        node1 = factory.make_Node(zone=zone)
+        node2 = factory.make_Node()
+        constraints = {
+            "not_in_zone": [zone.name[:2]],
+        }
+        form = FreeTextFilterNodeForm(data=constraints)
+        self.assertTrue(form.is_valid())
+        filtered_nodes = form.filter_nodes(Machine.objects.all())[0]
+        self.assertNotIn(node1, filtered_nodes)
+        self.assertIn(node2, filtered_nodes)
+
+    def test_substring_pool_filter(self):
+        pool = factory.make_ResourcePool()
+        node1 = factory.make_Node(pool=pool)
+        node2 = factory.make_Node()
+        constraints = {
+            "pool": pool.name[: len("resourcepool-") + 1],
+        }
+        form = FreeTextFilterNodeForm(data=constraints)
+        self.assertTrue(form.is_valid())
+        filtered_nodes = form.filter_nodes(Machine.objects.all())[0]
+        self.assertIn(node1, filtered_nodes)
+        self.assertNotIn(node2, filtered_nodes)
+
+    def test_substring_not_in_pool_filter(self):
+        pool = factory.make_ResourcePool()
+        node1 = factory.make_Node(pool=pool)
+        node2 = factory.make_Node()
+        constraints = {
+            "not_in_pool": [pool.name[: len("resourcepool-") + 1]],
+        }
+        form = FreeTextFilterNodeForm(data=constraints)
+        self.assertTrue(form.is_valid())
+        filtered_nodes = form.filter_nodes(Machine.objects.all())[0]
+        self.assertNotIn(node1, filtered_nodes)
+        self.assertIn(node2, filtered_nodes)
+
+    def test_substring_pod_filter(self):
+        pod = factory.make_Pod()
+        node1 = factory.make_Node(bmc=pod.as_bmc())
+        node2 = factory.make_Node()
+        constraints = {"pod": pod.name[: len("pod-") + 1]}
+        form = FreeTextFilterNodeForm(data=constraints)
+        self.assertTrue(form.is_valid())
+        filtered_nodes = form.filter_nodes(Machine.objects.all())[0]
+        self.assertIn(node1, filtered_nodes)
+        self.assertNotIn(node2, filtered_nodes)
+
+    def test_substring_fabrics_filter(self):
+        fabric = factory.make_Fabric()
+        vlan = factory.make_VLAN(fabric=fabric)
+        interface = factory.make_Interface(vlan=vlan)
+        node1 = factory.make_Node()
+        node1.current_config.interface_set.add(interface)
+        node2 = factory.make_Node()
+        constraints = {
+            "fabrics": [fabric.name[:2]],
+        }
+        form = FreeTextFilterNodeForm(data=constraints)
+        self.assertTrue(form.is_valid())
+        filtered_nodes = form.filter_nodes(Machine.objects.all())[0]
+        self.assertIn(node1, filtered_nodes)
+        self.assertNotIn(node2, filtered_nodes)
+
+    def test_substring_fabric_classes_filter(self):
+        fabric_class = factory.make_name()
+        fabric = factory.make_Fabric(class_type=fabric_class)
+        vlan = factory.make_VLAN(fabric=fabric)
+        interface = factory.make_Interface(vlan=vlan)
+        node1 = factory.make_Node()
+        node1.current_config.interface_set.add(interface)
+        node2 = factory.make_Node()
+        constraints = {
+            "fabric_classes": [fabric_class[:2]],
+        }
+        form = FreeTextFilterNodeForm(data=constraints)
+        form.is_valid()
+        print(form.errors)
+        self.assertTrue(form.is_valid())
+        filtered_nodes = form.filter_nodes(Machine.objects.all())[0]
+        self.assertIn(node1, filtered_nodes)
+        self.assertNotIn(node2, filtered_nodes)
+
+    def test_substring_vlans_filter(self):
+        vlan = factory.make_VLAN(name=factory.make_name())
+        interface = factory.make_Interface(vlan=vlan)
+        node1 = factory.make_Node()
+        node1.current_config.interface_set.add(interface)
+        node2 = factory.make_Node()
+        constraints = {
+            "vlans": [vlan.name[:2]],
+        }
+        form = FreeTextFilterNodeForm(data=constraints)
+        self.assertTrue(form.is_valid())
+        filtered_nodes = form.filter_nodes(Machine.objects.all())[0]
+        self.assertIn(node1, filtered_nodes)
+        self.assertNotIn(node2, filtered_nodes)
+
+    def test_substring_subnet_filter(self):
+        subnet = factory.make_Subnet()
+        interface = factory.make_Interface(subnet=subnet)
+        node1 = factory.make_Node()
+        node1.current_config.interface_set.add(interface)
+        node2 = factory.make_Node()
+        constraints = {
+            "subnets": [str(subnet.cidr)[:3]],
+        }
+        form = FreeTextFilterNodeForm(data=constraints)
+        self.assertTrue(form.is_valid())
+        filtered_nodes = form.filter_nodes(Machine.objects.all())[0]
+        self.assertIn(node1, filtered_nodes)
+        self.assertNotIn(node2, filtered_nodes)
+
+    def test_substring_hostnames_filter(self):
+        hostname = factory.make_name()
+        node1 = factory.make_Node(hostname=hostname)
+        node2 = factory.make_Node()
+        constraints = {
+            "hostname": [hostname[:2]],
+        }
+        form = FreeTextFilterNodeForm(data=constraints)
+        self.assertTrue(form.is_valid())
+        filtered_nodes = form.filter_nodes(Machine.objects.all())[0]
+        self.assertIn(node1, filtered_nodes)
+        self.assertNotIn(node2, filtered_nodes)
+
+    def test_substring_mac_addresses_filter(self):
+        mac_address = factory.make_mac_address()
+        interface = factory.make_Interface(mac_address=mac_address)
+        node1 = factory.make_Node()
+        node1.current_config.interface_set.add(interface)
+        node2 = factory.make_Node()
+        constraints = {
+            "mac_address": [str(mac_address)[:4]],
+        }
+        form = FreeTextFilterNodeForm(data=constraints)
+        self.assertTrue(form.is_valid())
+        filtered_nodes = form.filter_nodes(Machine.objects.all())[0]
+        self.assertIn(node1, filtered_nodes)
+        self.assertNotIn(node2, filtered_nodes)
+
+    def test_substring_agent_name_filter(self):
+        name = factory.make_name()
+        node1 = factory.make_Node(agent_name=name)
+        node2 = factory.make_Node()
+        constraints = {
+            "agent_name": name,
+        }
+        form = FreeTextFilterNodeForm(data=constraints)
+        self.assertTrue(form.is_valid())
+        filtered_nodes = form.filter_nodes(Machine.objects.all())[0]
+        self.assertIn(node1, filtered_nodes)
+        self.assertNotIn(node2, filtered_nodes)
+
+
 class TestAcquireNodeForm(MAASServerTestCase, FilterConstraintsMixin):
 
     form_class = AcquireNodeForm
diff --git a/src/maasserver/websockets/handlers/node.py b/src/maasserver/websockets/handlers/node.py
index 15a4999..7a9fc53 100644
--- a/src/maasserver/websockets/handlers/node.py
+++ b/src/maasserver/websockets/handlers/node.py
@@ -45,8 +45,8 @@ from maasserver.models import (
 from maasserver.models.nodeprobeddetails import script_output_nsmap
 from maasserver.node_action import compile_node_actions
 from maasserver.node_constraint_filter_forms import (
+    FreeTextFilterNodeForm,
     GROUPABLE_FIELDS,
-    ReadNodesForm,
     STATIC_FILTER_FIELDS,
 )
 from maasserver.permissions import NodePermission
@@ -1200,7 +1200,7 @@ class NodeHandler(TimestampedModelHandler):
 
     def _filter(self, qs, action, params):
         qs = super()._filter(qs, action, params)
-        form = ReadNodesForm(data=params)
+        form = FreeTextFilterNodeForm(data=params)
         if not form.is_valid():
             raise HandlerValidationError(form.errors)
         qs, _, _ = form.filter_nodes(qs)
@@ -1215,7 +1215,7 @@ class NodeHandler(TimestampedModelHandler):
                 "dynamic": name not in STATIC_FILTER_FIELDS,
                 "for_grouping": name in GROUPABLE_FIELDS,
             }
-            for name, field in ReadNodesForm.declared_fields.items()
+            for name, field in FreeTextFilterNodeForm.declared_fields.items()
         ]
 
     def _get_dynamic_filter_options(self, key):
@@ -1316,7 +1316,7 @@ class NodeHandler(TimestampedModelHandler):
                 "a 'group_key' param must be provided for filter_options"
             )
         else:
-            if key not in ReadNodesForm.declared_fields.keys():
+            if key not in FreeTextFilterNodeForm.declared_fields.keys():
                 raise HandlerValidationError(
                     f"{key} is not a valid 'group_key' for filter_options"
                 )