Merge ~bjornt/maas:api-better-tests into maas:master

[Björn Tillenius]

Add some more tests for the API handlers.

This is in preparation for changing the way we generate the JSON
representation.

[MAAS Lander (maas-lander)]

UNIT TESTS
-b api-better-tests lp:~bjornt/maas/+git/maas into -b master lp:~maas-committers/maas

STATUS: FAILED
LOG: http://maas-ci.internal:8080/job/maas/job/branch-tester/12366/console
COMMIT: e91fd87abc9b6a05657fd1db21c32373ea32b9d7

review: Needs Fixing

[Adam Collard (adam-collard)]

review: Approve

6cea490... by Björn Tillenius on 2022-04-14

Fix test failures.

diff --git a/src/maasserver/api/tests/test_interfaces.py b/src/maasserver/api/tests/test_interfaces.py
index 89c6171..5b17370 100644
--- a/src/maasserver/api/tests/test_interfaces.py
+++ b/src/maasserver/api/tests/test_interfaces.py
@@ -26,6 +26,7 @@ from maasserver.enum import (
     NODE_TYPE,
 )
 from maasserver.models import Interface
+from maasserver.models.vlan import DEFAULT_MTU
 from maasserver.testing.api import APITestCase, APITransactionTestCase
 from maasserver.testing.factory import factory
 from maasserver.utils.converters import json_load_bytes
@@ -60,6 +61,44 @@ def get_interface_uri(interface, node=None):
     return reverse("interface_handler", args=[node.system_id, interface])
 
 
+def serialize_vlan(vlan):
+    return {
+        "id": vlan.id,
+        "dhcp_on": vlan.dhcp_on,
+        "external_dhcp": vlan.external_dhcp,
+        "fabric": vlan.fabric.get_name(),
+        "fabric_id": vlan.fabric_id,
+        "mtu": vlan.mtu,
+        "primary_rack": None,
+        "secondary_rack": None,
+        "space": "undefined" if not vlan.space else vlan.space.get_name(),
+        "vid": vlan.vid,
+        "name": vlan.get_name(),
+        "relay_vlan": None,
+        "resource_uri": f"/MAAS/api/2.0/vlans/{vlan.id}/",
+    }
+
+
+def serialize_subnet(subnet):
+    return {
+        "name": subnet.name,
+        "id": subnet.id,
+        "vlan": serialize_vlan(subnet.vlan),
+        "description": "",
+        "cidr": subnet.cidr,
+        "rdns_mode": subnet.rdns_mode,
+        "gateway_ip": subnet.gateway_ip,
+        "dns_servers": subnet.dns_servers,
+        "allow_dns": subnet.allow_dns,
+        "allow_proxy": subnet.allow_proxy,
+        "active_discovery": subnet.active_discovery,
+        "managed": subnet.managed,
+        "disabled_boot_architectures": subnet.disabled_boot_architectures,
+        "space": "undefined" if not subnet.space else subnet.space.get_name(),
+        "resource_uri": f"/MAAS/api/2.0/subnets/{subnet.id}/",
+    }
+
+
 def make_complex_interface(node, name=None):
     """Makes interface with parents and children."""
     fabric = factory.make_Fabric()
@@ -887,14 +926,113 @@ class TestNodeInterfaceAPI(APITransactionTestCase.ForUser):
             get_interface_uri(interface, node=node),
         )
 
+    def test_read_basic(self):
+        node = factory.make_Node()
+        interface = factory.make_Interface(
+            node=node,
+            name="eno1",
+            iftype=INTERFACE_TYPE.PHYSICAL,
+            mac_address="11:11:11:11:11:11",
+            enabled=False,
+            vendor="my-vendor",
+            product="my-product",
+            firmware_version="1.2.3",
+            link_connected=False,
+            vlan=None,
+            interface_speed=100,
+            sriov_max_vf=0,
+            tags=[],
+        )
+
+        uri = get_interface_uri(interface)
+        response = self.client.get(uri)
+        self.assertEqual(
+            http.client.OK, response.status_code, response.content
+        )
+        parsed_interface = json_load_bytes(response.content)
+        self.maxDiff = None
+        self.assertEqual(
+            {
+                "system_id": node.system_id,
+                "id": interface.id,
+                "name": "eno1",
+                "type": INTERFACE_TYPE.PHYSICAL,
+                "vlan": None,
+                "mac_address": "11:11:11:11:11:11",
+                "parents": [],
+                "children": [],
+                "tags": [],
+                "enabled": False,
+                "links": [],
+                "params": "",
+                "discovered": None,
+                "effective_mtu": DEFAULT_MTU,
+                "vendor": "my-vendor",
+                "product": "my-product",
+                "firmware_version": "1.2.3",
+                "link_connected": False,
+                "interface_speed": 100,
+                "link_speed": 0,
+                "numa_node": 0,
+                "sriov_max_vf": 0,
+                "resource_uri": (
+                    f"/MAAS/api/2.0/nodes/{node.system_id}/interfaces/{interface.id}/"
+                ),
+            },
+            parsed_interface,
+        )
+
+    def test_read_connected(self):
+        vlan = factory.make_VLAN(name="my-vlan", mtu=1234)
+        interface = factory.make_Interface(
+            enabled=True,
+            link_connected=True,
+            vlan=vlan,
+            interface_speed=100,
+            link_speed=10,
+            tags=["foo", "bar"],
+        )
+
+        uri = get_interface_uri(interface)
+        response = self.client.get(uri)
+        self.assertEqual(
+            http.client.OK, response.status_code, response.content
+        )
+        parsed_interface = json_load_bytes(response.content)
+        expected_parts = {
+            "id": interface.id,
+            "tags": ["foo", "bar"],
+            "enabled": True,
+            "discovered": None,
+            "effective_mtu": 1234,
+            "link_connected": True,
+            "interface_speed": 100,
+            "link_speed": 10,
+            "vlan": {
+                "id": vlan.id,
+                "dhcp_on": vlan.dhcp_on,
+                "external_dhcp": vlan.external_dhcp,
+                "fabric": vlan.fabric.get_name(),
+                "fabric_id": vlan.fabric_id,
+                "mtu": vlan.mtu,
+                "primary_rack": None,
+                "secondary_rack": None,
+                "space": "undefined",
+                "vid": vlan.vid,
+                "name": vlan.get_name(),
+                "relay_vlan": None,
+                "resource_uri": f"/MAAS/api/2.0/vlans/{vlan.id}/",
+            },
+        }
+        for key, value in expected_parts.items():
+            self.assertEqual(parsed_interface[key], value)
+
     def test_read(self):
         node = factory.make_Node()
         bond, parents, children = make_complex_interface(node)
-        # Add some known links to the bond interface.
 
-        # First link is a DHCP link.
-        links = []
-        dhcp_subnet = factory.make_Subnet()
+        # Add some known links to the bond interface.
+        dhcp_subnet = factory.make_Subnet(vlan=bond.vlan)
         dhcp_ip = factory.make_StaticIPAddress(
             alloc_type=IPADDRESS_TYPE.DHCP,
             ip="",
@@ -908,19 +1046,9 @@ class TestNodeInterfaceAPI(APITransactionTestCase.ForUser):
             subnet=dhcp_subnet,
             interface=bond,
         )
-        links.append(
-            MatchesDict(
-                {
-                    "id": Equals(dhcp_ip.id),
-                    "mode": Equals(INTERFACE_LINK_TYPE.DHCP),
-                    "subnet": ContainsDict({"id": Equals(dhcp_subnet.id)}),
-                    "ip_address": Equals(discovered_ip),
-                }
-            )
-        )
 
         # Second link is a STATIC ip link.
-        static_subnet = factory.make_Subnet()
+        static_subnet = factory.make_Subnet(vlan=bond.vlan)
         static_ip = factory.pick_ip_in_network(static_subnet.get_ipnetwork())
         sip = factory.make_StaticIPAddress(
             alloc_type=IPADDRESS_TYPE.STICKY,
@@ -928,40 +1056,21 @@ class TestNodeInterfaceAPI(APITransactionTestCase.ForUser):
             subnet=static_subnet,
             interface=bond,
         )
-        links.append(
-            MatchesDict(
-                {
-                    "id": Equals(sip.id),
-                    "mode": Equals(INTERFACE_LINK_TYPE.STATIC),
-                    "ip_address": Equals(static_ip),
-                    "subnet": ContainsDict({"id": Equals(static_subnet.id)}),
-                }
-            )
-        )
 
         # Third link is just a LINK_UP. In reality this cannot exist while the
         # other two links exist but for testing we allow it. If validation of
         # the StaticIPAddress model ever included this check, which it
         # probably should then this will fail and cause this test to break.
-        link_subnet = factory.make_Subnet()
+        link_subnet = factory.make_Subnet(vlan=bond.vlan)
         link_ip = factory.make_StaticIPAddress(
             alloc_type=IPADDRESS_TYPE.STICKY,
             ip="",
             subnet=link_subnet,
             interface=bond,
         )
-        links.append(
-            MatchesDict(
-                {
-                    "id": Equals(link_ip.id),
-                    "mode": Equals(INTERFACE_LINK_TYPE.LINK_UP),
-                    "subnet": ContainsDict({"id": Equals(link_subnet.id)}),
-                }
-            )
-        )
 
         # Add MTU parameter.
-        bond.params = {"mtu": random.randint(800, 2000)}
+        bond.params = {"mtu": 1234}
         bond.save()
 
         uri = get_interface_uri(bond)
@@ -970,33 +1079,77 @@ class TestNodeInterfaceAPI(APITransactionTestCase.ForUser):
             http.client.OK, response.status_code, response.content
         )
         parsed_interface = json_load_bytes(response.content)
-        self.assertThat(
-            parsed_interface,
-            ContainsDict(
-                {
-                    "id": Equals(bond.id),
-                    "name": Equals(bond.name),
-                    "type": Equals(bond.type),
-                    "vlan": ContainsDict({"id": Equals(bond.vlan.id)}),
-                    "mac_address": Equals("%s" % bond.mac_address),
-                    "tags": Equals(bond.tags),
-                    "resource_uri": Equals(get_interface_uri(bond)),
-                    "params": Equals(bond.params),
-                    "effective_mtu": Equals(bond.get_effective_mtu()),
-                    "system_id": Equals(node.system_id),
-                }
-            ),
-        )
+
+        expected_parts = {
+            "id": bond.id,
+            "name": bond.name,
+            "type": bond.type,
+            "mac_address": str(bond.mac_address),
+            "vlan": serialize_vlan(bond.vlan),
+            "tags": bond.tags,
+            "resource_uri": get_interface_uri(bond),
+            "params": {"mtu": 1234},
+            "effective_mtu": 1500,
+            "system_id": node.system_id,
+        }
+        for key, value in expected_parts.items():
+            self.assertEqual(parsed_interface[key], value)
         self.assertEqual(
             sorted(nic.name for nic in parents), parsed_interface["parents"]
         )
         self.assertEqual(
             sorted(nic.name for nic in children), parsed_interface["children"]
         )
-        self.assertThat(parsed_interface["links"], MatchesSetwise(*links))
-        json_discovered = parsed_interface["discovered"][0]
-        self.assertEqual(dhcp_subnet.id, json_discovered["subnet"]["id"])
-        self.assertEqual(discovered_ip, json_discovered["ip_address"])
+
+        self.assertEqual(
+            [
+                {
+                    "id": dhcp_ip.id,
+                    "mode": "dhcp",
+                    "ip_address": discovered_ip,
+                    "subnet": serialize_subnet(dhcp_subnet),
+                },
+                {
+                    "id": sip.id,
+                    "mode": "static",
+                    "ip_address": static_ip,
+                    "subnet": serialize_subnet(static_subnet),
+                },
+                {
+                    "id": link_ip.id,
+                    "mode": "link_up",
+                    "subnet": serialize_subnet(link_subnet),
+                },
+            ],
+            parsed_interface["links"],
+        )
+        self.assertEqual(
+            [
+                {
+                    "ip_address": discovered_ip,
+                    "subnet": serialize_subnet(dhcp_subnet),
+                },
+            ],
+            parsed_interface["discovered"],
+        )
+
+    def test_read_effective_mtu(self):
+        node = factory.make_Node()
+        bond, parents, children = make_complex_interface(node)
+        bond.params = {"mtu": 1000}
+        bond.save()
+        children[0].params = {"mtu": 2000}
+        children[0].save()
+
+        uri = get_interface_uri(bond)
+        response = self.client.get(uri)
+        self.assertEqual(
+            http.client.OK, response.status_code, response.content
+        )
+        parsed_interface = json_load_bytes(response.content)
+
+        self.assertEqual(bond.id, parsed_interface["id"])
+        self.assertEqual(2000, parsed_interface["effective_mtu"])
 
     def test_read_by_specifier(self):
         node = factory.make_Node(hostname="tasty-biscuits")
diff --git a/src/maasserver/api/tests/test_subnets.py b/src/maasserver/api/tests/test_subnets.py
index c85dede..2fc8cad 100644
--- a/src/maasserver/api/tests/test_subnets.py
+++ b/src/maasserver/api/tests/test_subnets.py
@@ -8,12 +8,18 @@ import random
 
 from django.conf import settings
 from django.urls import reverse
-from testtools.matchers import Contains, ContainsDict, Equals
-
-from maasserver.enum import IPADDRESS_TYPE, NODE_STATUS, RDNS_MODE_CHOICES
+from testtools.matchers import Contains, Equals
+
+from maasserver.enum import (
+    IPADDRESS_TYPE,
+    NODE_STATUS,
+    RDNS_MODE,
+    RDNS_MODE_CHOICES,
+)
 from maasserver.testing.api import APITestCase, explain_unexpected_response
-from maasserver.testing.factory import factory, RANDOM
+from maasserver.testing.factory import factory
 from maasserver.utils.orm import reload_object
+from maastesting.djangotestcase import CountQueries
 from provisioningserver.boot import BootMethodRegistry
 from provisioningserver.utils.network import inet_ntop, IPRangeStatistics
 
@@ -36,21 +42,58 @@ class TestSubnetsAPI(APITestCase.ForUser):
         self.assertEqual("/MAAS/api/2.0/subnets/", get_subnets_uri())
 
     def test_read(self):
-        subnets = [factory.make_Subnet() for _ in range(3)]
+        def make_subnet():
+            space = factory.make_Space()
+            subnet = factory.make_Subnet(space=space)
+            primary_rack = factory.make_RackController(subnet=subnet)
+            secondary_rack = factory.make_RackController(subnet=subnet)
+            relay_vlan = factory.make_VLAN()
+            vlan = subnet.vlan
+            vlan.dhcp_on = True
+            vlan.primary_rack = primary_rack
+            vlan.secondary_rack = secondary_rack
+            vlan.relay_vlan = relay_vlan
+            vlan.save()
+            return subnet
+
+        subnets = [make_subnet()]
         uri = get_subnets_uri()
-        response = self.client.get(uri)
+        with CountQueries() as counter:
+            response = self.client.get(uri)
+        base_count = counter.count
 
         self.assertEqual(
             http.client.OK, response.status_code, response.content
         )
-        expected_ids = [subnet.id for subnet in subnets]
+
         result_ids = [
             subnet["id"]
             for subnet in json.loads(
                 response.content.decode(settings.DEFAULT_CHARSET)
             )
         ]
-        self.assertCountEqual(expected_ids, result_ids)
+        self.assertCountEqual(
+            [subnet.id for subnet in subnets],
+            result_ids,
+            json.loads(response.content.decode(settings.DEFAULT_CHARSET)),
+        )
+
+        subnets.append(make_subnet())
+        with CountQueries() as counter:
+            response = self.client.get(uri)
+        # XXX: These should be the same.
+        self.assertEqual(base_count + 7, counter.count)
+
+        self.assertEqual(
+            http.client.OK, response.status_code, response.content
+        )
+        result_ids = [
+            subnet["id"]
+            for subnet in json.loads(
+                response.content.decode(settings.DEFAULT_CHARSET)
+            )
+        ]
+        self.assertCountEqual([subnet.id for subnet in subnets], result_ids)
 
     def test_create(self):
         self.become_admin()
@@ -269,8 +312,15 @@ class TestSubnetAPI(APITestCase.ForUser):
             "/MAAS/api/2.0/subnets/%s/" % subnet.id, get_subnet_uri(subnet)
         )
 
-    def test_read(self):
-        subnet = factory.make_Subnet(space=RANDOM)
+    def test_read_basic(self):
+        subnet = factory.make_Subnet(
+            name="my-subnet",
+            cidr="10.10.10.0/24",
+            gateway_ip=None,
+            space=None,
+            dns_servers=[],
+            disabled_boot_architectures=[],
+        )
         uri = get_subnet_uri(subnet)
         response = self.client.get(uri)
 
@@ -280,34 +330,100 @@ class TestSubnetAPI(APITestCase.ForUser):
         parsed_subnet = json.loads(
             response.content.decode(settings.DEFAULT_CHARSET)
         )
-        self.assertThat(
+        self.assertEqual(
             parsed_subnet,
-            ContainsDict(
-                {
-                    "id": Equals(subnet.id),
-                    "name": Equals(subnet.name),
-                    "vlan": ContainsDict({"vid": Equals(subnet.vlan.vid)}),
-                    "space": Equals(subnet.space.get_name()),
-                    "cidr": Equals(subnet.cidr),
-                    "gateway_ip": Equals(subnet.gateway_ip),
-                    "dns_servers": Equals(subnet.dns_servers),
-                    "managed": Equals(subnet.managed),
-                    "disabled_boot_architectures": Equals(
-                        subnet.disabled_boot_architectures
-                    ),
-                }
-            ),
+            {
+                "id": subnet.id,
+                "name": "my-subnet",
+                "active_discovery": False,
+                "allow_dns": True,
+                "allow_proxy": True,
+                "description": "",
+                "space": "undefined",
+                "cidr": "10.10.10.0/24",
+                "gateway_ip": None,
+                "dns_servers": [],
+                "managed": True,
+                "disabled_boot_architectures": [],
+                "rdns_mode": RDNS_MODE.DEFAULT,
+                "resource_uri": f"/MAAS/api/2.0/subnets/{subnet.id}/",
+                "vlan": {
+                    "id": subnet.vlan_id,
+                    "dhcp_on": subnet.vlan.dhcp_on,
+                    "external_dhcp": subnet.vlan.external_dhcp,
+                    "fabric": subnet.vlan.fabric.get_name(),
+                    "fabric_id": subnet.vlan.fabric_id,
+                    "mtu": subnet.vlan.mtu,
+                    "primary_rack": None,
+                    "secondary_rack": None,
+                    "space": "undefined",
+                    "vid": subnet.vlan.vid,
+                    "name": subnet.vlan.get_name(),
+                    "relay_vlan": None,
+                    "resource_uri": f"/MAAS/api/2.0/vlans/{subnet.vlan_id}/",
+                },
+            },
         )
 
-    def test_read_includes_description(self):
-        description = factory.make_string()
-        subnet = factory.make_Subnet(space=RANDOM, description=description)
+    def test_read_full(self):
+        space = factory.make_Space(name="my-space")
+        subnet = factory.make_Subnet(
+            name="my-subnet",
+            cidr="10.20.20.0/24",
+            gateway_ip="10.20.20.1",
+            space=space,
+            dns_servers=["10.20.20.20"],
+            disabled_boot_architectures=["pxe"],
+            active_discovery=True,
+            allow_proxy=False,
+            allow_dns=False,
+            description="My subnet",
+            managed=False,
+            rdns_mode=RDNS_MODE.DISABLED,
+        )
         uri = get_subnet_uri(subnet)
         response = self.client.get(uri)
+
+        self.assertEqual(
+            http.client.OK, response.status_code, response.content
+        )
         parsed_subnet = json.loads(
             response.content.decode(settings.DEFAULT_CHARSET)
         )
-        self.assertEqual(description, parsed_subnet["description"])
+        self.assertEqual(
+            parsed_subnet,
+            {
+                "id": subnet.id,
+                "name": "my-subnet",
+                "active_discovery": True,
+                "allow_dns": False,
+                "allow_proxy": False,
+                "description": "My subnet",
+                "space": "my-space",
+                "cidr": "10.20.20.0/24",
+                "gateway_ip": "10.20.20.1",
+                "dns_servers": ["10.20.20.20"],
+                "managed": False,
+                "disabled_boot_architectures": ["pxe"],
+                "rdns_mode": RDNS_MODE.DISABLED,
+                "resource_uri": f"/MAAS/api/2.0/subnets/{subnet.id}/",
+                "vlan": {
+                    "id": subnet.vlan_id,
+                    "dhcp_on": subnet.vlan.dhcp_on,
+                    "external_dhcp": subnet.vlan.external_dhcp,
+                    "fabric": subnet.vlan.fabric.get_name(),
+                    "fabric_id": subnet.vlan.fabric_id,
+                    "mtu": subnet.vlan.mtu,
+                    "primary_rack": None,
+                    "secondary_rack": None,
+                    "space": "my-space",
+                    "vid": subnet.vlan.vid,
+                    "name": subnet.vlan.get_name(),
+                    "relay_vlan": None,
+                    "resource_uri": f"/MAAS/api/2.0/vlans/{subnet.vlan_id}/",
+                },
+            },
+        )
 
     def test_read_404_when_bad_id(self):
         uri = reverse("subnet_handler", args=[random.randint(100, 1000)])
diff --git a/src/maasserver/api/tests/test_vlans.py b/src/maasserver/api/tests/test_vlans.py
index 2296787..38665d2 100644
--- a/src/maasserver/api/tests/test_vlans.py
+++ b/src/maasserver/api/tests/test_vlans.py
@@ -10,12 +10,13 @@ import random
 
 from django.conf import settings
 from django.urls import reverse
-from testtools.matchers import ContainsDict, Equals, Is, Not
+from testtools.matchers import Equals, Is, Not
 
-from maasserver.models import Space
+from maasserver.models import Space, VLAN
 from maasserver.testing.api import APITestCase
 from maasserver.testing.factory import factory, RANDOM
 from maasserver.utils.orm import reload_object
+from maastesting.djangotestcase import CountQueries
 
 
 def get_vlans_uri(fabric):
@@ -41,23 +42,71 @@ class TestVlansAPI(APITestCase.ForUser):
         )
 
     def test_read(self):
+        def make_vlan():
+            space = factory.make_Space()
+            subnet = factory.make_Subnet(fabric=fabric, space=space)
+            primary_rack = factory.make_RackController()
+            factory.make_Interface(node=primary_rack, subnet=subnet)
+            secondary_rack = factory.make_RackController()
+            factory.make_Interface(node=secondary_rack, subnet=subnet)
+            relay_vlan = factory.make_VLAN()
+            vlan = subnet.vlan
+            vlan.dhcp_on = True
+            vlan.primary_rack = primary_rack
+            vlan.secondary_rack = secondary_rack
+            vlan.relay_vlan = relay_vlan
+            vlan.save()
+
+        def serialize_vlan(vlan):
+            return {
+                "id": vlan.id,
+                "name": vlan.get_name(),
+                "vid": vlan.vid,
+                "fabric": vlan.fabric.name,
+                "fabric_id": vlan.fabric_id,
+                "mtu": vlan.mtu,
+                "primary_rack": (
+                    vlan.primary_rack.system_id if vlan.primary_rack else None
+                ),
+                "secondary_rack": (
+                    vlan.secondary_rack.system_id
+                    if vlan.secondary_rack
+                    else None
+                ),
+                "dhcp_on": vlan.dhcp_on,
+                "external_dhcp": None,
+                "relay_vlan": serialize_vlan(vlan.relay_vlan)
+                if vlan.relay_vlan
+                else None,
+                "space": vlan.space.name if vlan.space else "undefined",
+                "resource_uri": f"/MAAS/api/2.0/vlans/{vlan.id}/",
+            }
+
         fabric = factory.make_Fabric()
-        for vid in range(1, 4):
-            factory.make_VLAN(vid=vid, fabric=fabric)
+        make_vlan()
+
         uri = get_vlans_uri(fabric)
-        response = self.client.get(uri)
+        with CountQueries() as counter:
+            response = self.client.get(uri)
+        base_count = counter.count
 
         self.assertEqual(
             http.client.OK, response.status_code, response.content
         )
-        expected_ids = [vlan.vid for vlan in fabric.vlan_set.all()]
-        result_ids = [
-            vlan["vid"]
-            for vlan in json.loads(
-                response.content.decode(settings.DEFAULT_CHARSET)
-            )
-        ]
-        self.assertCountEqual(expected_ids, result_ids)
+        result = json.loads(response.content.decode(settings.DEFAULT_CHARSET))
+        # It's three VLANs, since when creating a fabric, a default VLAN
+        # is always created.
+        vlans = {vlan.id: vlan for vlan in VLAN.objects.filter(fabric=fabric)}
+        self.assertEqual(2, len(result))
+        for serialized_vlan in result:
+            vlan = vlans[serialized_vlan["id"]]
+            self.assertEqual(serialize_vlan(vlan), serialized_vlan)
+
+        make_vlan()
+        with CountQueries() as counter:
+            response = self.client.get(uri)
+        # XXX: These really should be equal.
+        self.assertEqual(base_count + 5, counter.count)
 
     def test_create(self):
         self.become_admin()
@@ -187,9 +236,11 @@ class TestVlanAPI(APITestCase.ForUser):
             "/MAAS/api/2.0/vlans/%s/" % vlan.id, get_vlan_uri(vlan)
         )
 
-    def test_read(self):
-        fabric = factory.make_Fabric()
-        vlan = factory.make_VLAN(fabric=fabric)
+    def test_read_basic(self):
+        fabric = factory.make_Fabric(name="my-fabric")
+        vlan = factory.make_VLAN(
+            fabric=fabric, name="my-vlan", vid=123, mtu=1234
+        )
         uri = get_vlan_uri(vlan)
         response = self.client.get(uri)
 
@@ -199,24 +250,29 @@ class TestVlanAPI(APITestCase.ForUser):
         parsed_vlan = json.loads(
             response.content.decode(settings.DEFAULT_CHARSET)
         )
-        self.assertThat(
+        self.assertEqual(
             parsed_vlan,
-            ContainsDict(
-                {
-                    "id": Equals(vlan.id),
-                    "name": Equals(vlan.get_name()),
-                    "vid": Equals(vlan.vid),
-                    "fabric": Equals(fabric.get_name()),
-                    "fabric_id": Equals(fabric.id),
-                    "resource_uri": Equals(get_vlan_uri(vlan)),
-                }
-            ),
-        )
-
-    def test_read_with_fabric(self):
-        fabric = factory.make_Fabric()
-        vlan = factory.make_VLAN(fabric=fabric)
-        uri = get_vlan_uri(vlan, fabric)
+            {
+                "id": vlan.id,
+                "name": "my-vlan",
+                "vid": 123,
+                "fabric": "my-fabric",
+                "fabric_id": fabric.id,
+                "mtu": 1234,
+                "primary_rack": None,
+                "secondary_rack": None,
+                "dhcp_on": False,
+                "external_dhcp": None,
+                "relay_vlan": None,
+                "space": "undefined",
+                "resource_uri": f"/MAAS/api/2.0/vlans/{vlan.id}/",
+            },
+        )
+
+    def test_read_with_space(self):
+        space = factory.make_Space(name="my-space")
+        vlan = factory.make_VLAN(space=space)
+        uri = get_vlan_uri(vlan, vlan.fabric)
         response = self.client.get(uri)
 
         self.assertEqual(
@@ -225,22 +281,19 @@ class TestVlanAPI(APITestCase.ForUser):
         parsed_vlan = json.loads(
             response.content.decode(settings.DEFAULT_CHARSET)
         )
-        self.assertThat(
-            parsed_vlan,
-            ContainsDict(
-                {
-                    "id": Equals(vlan.id),
-                    "name": Equals(vlan.get_name()),
-                    "vid": Equals(vlan.vid),
-                    "fabric": Equals(fabric.get_name()),
-                    "resource_uri": Equals(get_vlan_uri(vlan)),
-                }
-            ),
-        )
-
-    def test_read_with_space(self):
-        space = factory.make_Space()
-        vlan = factory.make_VLAN(space=space)
+        self.assertEqual(parsed_vlan["space"], "my-space")
+
+    def test_read_with_dhcp(self):
+        subnet = factory.make_Subnet()
+        primary_rack = factory.make_RackController()
+        factory.make_Interface(node=primary_rack, subnet=subnet)
+        secondary_rack = factory.make_RackController()
+        factory.make_Interface(node=secondary_rack, subnet=subnet)
+        vlan = subnet.vlan
+        vlan.dhcp_on = True
+        vlan.primary_rack = primary_rack
+        vlan.secondary_rack = secondary_rack
+        vlan.save()
         uri = get_vlan_uri(vlan, vlan.fabric)
         response = self.client.get(uri)
 
@@ -250,21 +303,15 @@ class TestVlanAPI(APITestCase.ForUser):
         parsed_vlan = json.loads(
             response.content.decode(settings.DEFAULT_CHARSET)
         )
-        self.assertThat(
-            parsed_vlan,
-            ContainsDict(
-                {
-                    "id": Equals(vlan.id),
-                    "name": Equals(vlan.get_name()),
-                    "vid": Equals(vlan.vid),
-                    "space": Equals(space.get_name()),
-                    "resource_uri": Equals(get_vlan_uri(vlan)),
-                }
-            ),
-        )
-
-    def test_read_without_space_returns_undefined_space(self):
-        vlan = factory.make_VLAN(space=None)
+        self.assertTrue(parsed_vlan["dhcp_on"])
+        self.assertEqual(primary_rack.system_id, parsed_vlan["primary_rack"])
+        self.assertEqual(
+            secondary_rack.system_id, parsed_vlan["secondary_rack"]
+        )
+
+    def test_read_with_relay_vlan(self):
+        relay_vlan = factory.make_VLAN(name="my-relay")
+        vlan = factory.make_VLAN(relay_vlan=relay_vlan)
         uri = get_vlan_uri(vlan, vlan.fabric)
         response = self.client.get(uri)
 
@@ -274,17 +321,23 @@ class TestVlanAPI(APITestCase.ForUser):
         parsed_vlan = json.loads(
             response.content.decode(settings.DEFAULT_CHARSET)
         )
-        self.assertThat(
-            parsed_vlan,
-            ContainsDict(
-                {
-                    "id": Equals(vlan.id),
-                    "name": Equals(vlan.get_name()),
-                    "vid": Equals(vlan.vid),
-                    "space": Equals(Space.UNDEFINED),
-                    "resource_uri": Equals(get_vlan_uri(vlan)),
-                }
-            ),
+        self.assertEqual(
+            {
+                "id": relay_vlan.id,
+                "name": "my-relay",
+                "vid": relay_vlan.vid,
+                "fabric": relay_vlan.fabric.name,
+                "fabric_id": relay_vlan.fabric_id,
+                "mtu": relay_vlan.mtu,
+                "primary_rack": None,
+                "secondary_rack": None,
+                "dhcp_on": False,
+                "external_dhcp": None,
+                "relay_vlan": None,
+                "space": "undefined",
+                "resource_uri": f"/MAAS/api/2.0/vlans/{relay_vlan.id}/",
+            },
+            parsed_vlan["relay_vlan"],
         )
 
     def test_read_404_when_bad_id(self):
diff --git a/src/maasserver/testing/factory.py b/src/maasserver/testing/factory.py
index afaabfe..99e5258 100644
--- a/src/maasserver/testing/factory.py
+++ b/src/maasserver/testing/factory.py
@@ -1617,6 +1617,7 @@ class Factory(maastesting.factory.Factory):
         primary_rack=None,
         secondary_rack=None,
         relay_vlan=None,
+        mtu=1500,
     ):
         assert vid != 0, "VID=0 VLANs are auto-created"
         if name is RANDOM:
@@ -1636,6 +1637,7 @@ class Factory(maastesting.factory.Factory):
             primary_rack=primary_rack,
             secondary_rack=secondary_rack,
             relay_vlan=relay_vlan,
+            mtu=mtu,
         )
         vlan.save()
         for rack in [primary_rack, secondary_rack]: