Merge lp:~lamont/maas/bug-1642033 into lp:~maas-committers/maas/trunk

[LaMont Jones]

When generating DNS for IP addresses attached to DNSResource objects, only do so if we are generating an appropriate Domain's DNS.

When generating DNS for IP addresses attached to DNSResource objects, only do so if we are generating an appropriate Domain's DNS.

[Gavin Panella (allenap)]

Looks good. One thing does need fixing but I trust you'll do it before landing. I can't say that I follow the query changes fully, but they don't appear to be insane, and the tests do kind of make sense to me.

review: Approve

[LaMont Jones (lamont)]

> Looks good. One thing does need fixing but I trust you'll do it before
> landing. I can't say that I follow the query changes fully, but they don't
> appear to be insane, and the tests do kind of make sense to me.

Given the major refactor in 5549, I'm going to request a new review.

[Mike Pontillo (mpontillo)]

So this function is just scary. I think it's difficult to know whether our current test cases are sufficient. I have a lot of comments below. It was hard to make sense of this for review purposes; I had to go through line by line. Long story short:

 - Needs better comments, docstrings, and general code readability. See comments below.

 - It would probably be cleaner (and, more importantly, easier to support this code in the field) if we separate the logic encapsulated in this function to a set of a few cleanly written SQL views (maybe one to three).

 - I would remove the parameter that special-cases the TTL and just have the query return both versions. Again, this approach would be easier to support if/when we move to a view-based approach. (And, worst case, if you want to keep it for performance reasons, you just don't select that column from the view.)

In a follow-on commit, we might look at exposing the output of this function via the API (again, for easier supportability).

[Mike Pontillo (mpontillo)]

Oh yeah, review result. I'm on the fence. I guess this is a Needs Fixing. But I almost want to say "Approve", because assuming the code basically works, I don't want to look at it again. ;-)

So I'll settle on Needs Information. Since you pretty much ripped and replaced this entire function, what's your confidence level in the previous unit tests? Do they cover everything this [monster of a] query could do?

review: Needs Information

[Mike Pontillo (mpontillo)]

Looking better, thanks for the fixes. I'm going to approve this now since they should be easy to address.

We'll think about moving this to a view-based approach in a future branch.

Things I'd still like to see fixed: we could use a properly-renamed helper function (so we can drop the comment about the awfulness of the name) and proper docstrings to explain the parameters.

Also, it's weird that we use "domain_or_subnet" after we know it's actually a Domain. See my suggested fix below.

review: Approve

[Mike Pontillo (mpontillo)]

Looks like this needs a little more cleanup. See comments below on the function parameters. Also, we have a raw_ttl parameter to the function that isn't used by any caller. Coincidentally, there is a skipped test case in test_staticipaddress.py as follows:

@skip("XXX: GavinPanella 2016-02-24 bug=1549397: Fails spuriously.")
def test_get_hostname_ip_mapping_returns_raw_ttl(self):
    # ...

Let's take this opportunity to either remove raw_ttl or fix this test case.

review: Needs Fixing

[Mike Pontillo (mpontillo)]

Looks good. Let's move on.

review: Approve

=== modified file 'src/maasserver/models/staticipaddress.py'
--- src/maasserver/models/staticipaddress.py	2016-11-09 08:20:11 +0000
+++ src/maasserver/models/staticipaddress.py	2016-11-17 18:03:27 +0000
@@ -28,7 +28,6 @@
     IntegerField,
     Manager,
     PROTECT,
-    Q,
 )
 from maasserver import DefaultMeta
 from maasserver.enum import (
@@ -235,56 +234,152 @@
             return self._attempt_allocation(
                 requested_address, alloc_type, user=user, subnet=subnet)
 
-    def _get_user_reserved_mappings(self, domain_or_subnet, raw_ttl=False):
-        # A poorly named routine these days, since it actually returns
-        # addresses for anything with any DNSResource records as well.
-        default_ttl = Config.objects.get_config('default_dns_ttl')
-        qs = self.filter(
-            Q(alloc_type=IPADDRESS_TYPE.USER_RESERVED) |
-            Q(dnsresource__isnull=False))
-        # If this is a subnet, we need to ignore subnet.id, as per
-        # get_hostname_ip_mapping().  LP#1600259
-        if isinstance(domain_or_subnet, Subnet):
-            pass
-        elif isinstance(domain_or_subnet, Domain):
-            qs = qs.filter(dnsresource__domain_id=domain_or_subnet.id)
-        qs = qs.prefetch_related("dnsresource_set")
-        mappings = defaultdict(HostnameIPMapping)
-        for instance in qs:
-            ip = instance.ip
-            rrset = instance.dnsresource_set.all()
-            # 2016-01-20 LaMontJones N.B.:
-            # Empirically, for dnsrr in instance.dnsresource_set.all(): ...
-            # else: with a non-empty rrset yields both the for loop AND the
-            # else clause.  Wrapping it all in a if/else: avoids that issue.
-            if rrset.count() > 0:
-                for dnsrr in rrset:
-                    if dnsrr.name is None or dnsrr.name == '':
-                        hostname = get_ip_based_hostname(ip)
-                        hostname = "%s.%s" % (
-                            get_ip_based_hostname(ip),
-                            Domain.objects.get_default_domain().name)
-                    else:
-                        hostname = '%s.%s' % (dnsrr.name, dnsrr.domain.name)
-                    if raw_ttl or dnsrr.address_ttl is not None:
-                        ttl = dnsrr.address_ttl
-                    elif dnsrr.domain.ttl is not None:
-                        ttl = dnsrr.domain.ttl
-                    else:
-                        ttl = default_ttl
-                    mappings[hostname].ttl = ttl
-                    mappings[hostname].ips.add(ip)
-            else:
-                # No DNSResource, but it's USER_RESERVED.
-                domain = Domain.objects.get_default_domain()
-                hostname = "%s.%s" % (get_ip_based_hostname(ip), domain.name)
-                if raw_ttl or domain.ttl is not None:
-                    ttl = domain.ttl
-                else:
-                    ttl = default_ttl
-                mappings[hostname].ttl = ttl
-                mappings[hostname].ips.add(ip)
-        return mappings
+    def _get_special_mappings(self, domain, raw_ttl=False):
+        """Get the special mappings, possibly limited to a single Domain.
+
+        This function is responsible for creating these mappings:
+        - any USER_RESERVED IP,
+        - any IP not associated with a Node,
+        - any IP associated with a DNSResource.
+        The caller is responsible for addresses otherwise derived from nodes.
+
+        Because of how the get hostname_ip_mapping code works, we actually need
+        to fetch ALL of the entries for subnets, but forward mappings need to
+        be domain-specific.
+
+        :param domain: limit return to just the given Domain.  If anything
+            other than a Domain is passed in (e.g., a Subnet or None), we
+            return all of the reverse mappings.
+        :param raw_ttl: Boolean, if True then just return the address_ttl,
+            otherwise, coalesce the address_ttl to be the correct answer for
+            zone generation.
+        :return: a (default) dict of hostname: HostnameIPMapping entries.
+        """
+        default_ttl = "%d" % Config.objects.get_config('default_dns_ttl')
+        if isinstance(domain, Domain):
+            # Domains are special in that we only want to have entries for the
+            # domain that we were asked about.  And they can possibly come from
+            # either the child or the parent for glue.
+            where_clause = """
+                AND (
+                    dnsrr.dom2_id = %s OR
+                    node.dom2_id = %s OR
+                    dnsrr.domain_id = %s OR
+                    node.domain_id = %s
+            """
+            query_parms = [domain.id, domain.id, domain.id, domain.id]
+            # And the default domain is extra special, since it needs to have
+            # A/AAAA RRs for any USER_RESERVED addresses that have no name
+            # otherwise attached to them.
+            if domain.is_default():
+                where_clause += """ OR (
+                    dnsrr.fqdn IS NULL AND
+                    node.fqdn IS NULL)
+                """
+            where_clause += ")"
+        else:
+            # There is nothing special about the query for subnets.
+            domain = None
+            where_clause = ""
+            query_parms = []
+        # raw_ttl says that we don't coalesce, but we need to pick one, so we
+        # go with DNSResource if it is involved.
+        if raw_ttl:
+            ttl_clause = """COALESCE(dnsrr.address_ttl, node.address_ttl)"""
+        else:
+            ttl_clause = """
+                COALESCE(
+                    dnsrr.address_ttl,
+                    dnsrr.ttl,
+                    node.address_ttl,
+                    node.ttl,
+                    %s)""" % default_ttl
+        # And here is the SQL query of doom.  Build up inner selects to get the
+        # view of a DNSResource (and Node) that we need, and finally use
+        # domain2 to handle the case where an FQDN is also the name of a domain
+        # that we know.
+        sql_query = """
+            SELECT
+                COALESCE(dnsrr.fqdn, node.fqdn) AS fqdn,
+                node.system_id,
+                node.node_type,
+                """ + ttl_clause + """ AS ttl,
+                staticip.ip
+            FROM
+                maasserver_staticipaddress AS staticip
+            LEFT JOIN (
+                /* Create a dnsrr that has what we need. */
+                SELECT
+                    CASE WHEN dnsrr.name = '@' THEN
+                        dom.name
+                    ELSE
+                        CONCAT(dnsrr.name, '.', dom.name)
+                    END AS fqdn,
+                    dom.name as dom_name,
+                    dnsrr.domain_id,
+                    dnsrr.address_ttl,
+                    dom.ttl,
+                    dia.staticipaddress_id AS dnsrr_sip_id,
+                    dom2.id AS dom2_id
+                FROM maasserver_dnsresource_ip_addresses AS dia
+                JOIN maasserver_dnsresource AS dnsrr ON
+                    dia.dnsresource_id = dnsrr.id
+                JOIN maasserver_domain AS dom ON
+                    dnsrr.domain_id = dom.id
+                LEFT JOIN maasserver_domain AS dom2 ON
+                    CONCAT(dnsrr.name, '.', dom.name) = dom2.name OR (
+                        dnsrr.name = '@' AND
+                        dom.name SIMILAR TO CONCAT('[-A-Za-z0-9]*.', dom2.name)
+                    )
+                ) AS dnsrr ON
+                    dnsrr_sip_id = staticip.id
+            LEFT JOIN (
+                /* Create a node that has what we need. */
+                SELECT
+                    CONCAT(nd.hostname, '.', dom.name) AS fqdn,
+                    dom.name as dom_name,
+                    nd.system_id,
+                    nd.node_type,
+                    nd.domain_id,
+                    nd.address_ttl,
+                    dom.ttl,
+                    iia.staticipaddress_id AS node_sip_id,
+                    dom2.id AS dom2_id
+                FROM maasserver_interface_ip_addresses AS iia
+                JOIN maasserver_interface AS iface ON
+                    iia.interface_id = iface.id
+                JOIN maasserver_node AS nd ON
+                    iface.node_id = nd.id
+                JOIN maasserver_domain AS dom ON
+                    nd.domain_id = dom.id
+                LEFT JOIN maasserver_domain AS dom2 ON
+                    CONCAT(nd.hostname, '.', dom.name) = dom2.name
+                ) AS node ON
+                    node_sip_id = staticip.id
+            WHERE
+                staticip.ip IS NOT NULL AND
+                host(staticip.ip) != '' AND
+                (
+                    staticip.alloc_type = %s OR
+                    node.fqdn IS NULL OR
+                    dnsrr IS NOT NULL
+                )""" + where_clause + """
+        """
+        default_domain = Domain.objects.get_default_domain()
+        mapping = defaultdict(HostnameIPMapping)
+        cursor = connection.cursor()
+        query_parms = [IPADDRESS_TYPE.USER_RESERVED] + query_parms
+        cursor.execute(sql_query, query_parms)
+        for (fqdn, system_id, node_type, ttl,
+                ip) in cursor.fetchall():
+            if fqdn is None or fqdn == '':
+                fqdn = "%s.%s" % (
+                    get_ip_based_hostname(ip), default_domain.name)
+            mapping[fqdn].node_type = node_type
+            mapping[fqdn].system_id = system_id
+            mapping[fqdn].ttl = ttl
+            mapping[fqdn].ips.add(ip)
+        return mapping
 
     def get_hostname_ip_mapping(self, domain_or_subnet, raw_ttl=False):
         """Return hostname mappings for `StaticIPAddress` entries.
@@ -326,7 +421,7 @@
                         node.boot_interface_id = parent.id
                     ),
                     False
-                ) as is_boot
+                ) AS is_boot
             FROM
                 maasserver_interface AS interface
             LEFT OUTER JOIN maasserver_interfacerelationship AS rel ON
@@ -335,7 +430,7 @@
                 rel.parent_id = parent.id
             JOIN maasserver_node AS node ON
                 node.id = interface.node_id
-            JOIN maasserver_domain as domain ON
+            JOIN maasserver_domain AS domain ON
                 domain.id = node.domain_id
             JOIN maasserver_interface_ip_addresses AS link ON
                 link.interface_id = interface.id
@@ -349,15 +444,14 @@
             # domains. domain2.name will be non-null if this host's fqdn is the
             # name of a domain in MAAS.
             sql_query += """
-            LEFT JOIN maasserver_domain as domain2 ON
+            LEFT JOIN maasserver_domain AS domain2 ON
                 /* Pick up another copy of domain looking for instances of
                  * nodes a the top of a domain.
-                 */
-                domain2.name = CONCAT(node.hostname, '.', domain.name)
+                 */ domain2.name = CONCAT(node.hostname, '.', domain.name)
             WHERE
-                (domain2.name IS NOT NULL OR node.domain_id = %s) AND
+                (domain2.id = %s OR node.domain_id = %s) AND
             """
-            query_parms = [domain_or_subnet.id, ]
+            query_parms = [domain_or_subnet.id, domain_or_subnet.id, ]
         else:
             # For subnets, we need ALL the names, so that we can correctly
             # identify which ones should have the FQDN.  dns/zonegenerator.py
@@ -418,7 +512,7 @@
                 maasserver_interface AS interface
             JOIN maasserver_node AS node ON
                 node.id = interface.node_id
-            JOIN maasserver_domain as domain ON
+            JOIN maasserver_domain AS domain ON
                 domain.id = node.domain_id
             JOIN maasserver_interface_ip_addresses AS link ON
                 link.interface_id = interface.id
@@ -428,14 +522,14 @@
         if isinstance(domain_or_subnet, Domain):
             # This logic is similar to the logic in sql_query above.
             iface_sql_query += """
-            LEFT JOIN maasserver_domain as domain2 ON
+            LEFT JOIN maasserver_domain AS domain2 ON
                 /* Pick up another copy of domain looking for instances of
                  * the name as the top of a domain.
                  */
                 domain2.name = CONCAT(
                     interface.name, '.', node.hostname, '.', domain.name)
             WHERE
-                (domain2.name IS NOT NULL OR node.domain_id = %s) AND
+                (domain2.id = %s OR node.domain_id = %s) AND
             """
         else:
             # For subnets, we need ALL the names, so that we can correctly
@@ -455,7 +549,7 @@
             """
         # We get user reserved et al mappings first, so that we can overwrite
         # TTL as we process the return from the SQL horror above.
-        mapping = self._get_user_reserved_mappings(domain_or_subnet)
+        mapping = self._get_special_mappings(domain_or_subnet, raw_ttl)
         # All of the mappings that we got mean that we will only want to add
         # addresses for the boot interface (is_boot == True).
         iface_is_boot = defaultdict(bool, {
@@ -482,7 +576,7 @@
         # Next, get all the addresses, on all the interfaces, and add the ones
         # that are not already present on the FQDN as $IFACE.$FQDN.  Exclude
         # any discovered addresses once there are any non-discovered addresses.
-        cursor.execute(iface_sql_query, (domain_or_subnet.id,))
+        cursor.execute(iface_sql_query, query_parms)
         for (fqdn, system_id, node_type, ttl,
                 ip, iface_name, assigned) in cursor.fetchall():
             if assigned:

=== modified file 'src/maasserver/models/tests/test_staticipaddress.py'
--- src/maasserver/models/tests/test_staticipaddress.py	2016-11-09 08:14:00 +0000
+++ src/maasserver/models/tests/test_staticipaddress.py	2016-11-17 18:03:27 +0000
@@ -40,6 +40,7 @@
     MAASServerTestCase,
     MAASTransactionServerTestCase,
 )
+from maasserver.utils.dns import get_ip_based_hostname
 from maasserver.utils.orm import (
     reload_object,
     transactional,
@@ -447,7 +448,6 @@
             actual = StaticIPAddress.objects.get_hostname_ip_mapping(dom)
             self.assertItemsEqual(expected_mapping, actual)
 
-    @skip("XXX: GavinPanella 2016-02-24 bug=1549397: Fails spuriously.")
     def test_get_hostname_ip_mapping_returns_raw_ttl(self):
         # We create 2 domains, one with a ttl, one withoout.
         # Within each domain, create a node with an address_ttl, and one
@@ -941,6 +941,7 @@
 class TestUserReservedStaticIPAddress(MAASServerTestCase):
 
     def test_user_reserved_addresses_have_default_hostnames(self):
+        # Reserved IPs get default hostnames when none are given.
         subnet = factory.make_Subnet()
         num_ips = randint(3, 5)
         ips = [
@@ -948,11 +949,13 @@
                 subnet=subnet, alloc_type=IPADDRESS_TYPE.USER_RESERVED)
             for _ in range(num_ips)
         ]
-        mappings = StaticIPAddress.objects._get_user_reserved_mappings(
+        mappings = StaticIPAddress.objects._get_special_mappings(
             subnet)
         self.expectThat(mappings, HasLength(len(ips)))
 
     def test_user_reserved_addresses_included_in_get_hostname_ip_mapping(self):
+        # Generate several IPs, with names in domain0, and make sure they don't
+        # show up in domain1.
         num_ips = randint(3, 5)
         domain0 = Domain.objects.get_default_domain()
         domain1 = factory.make_Domain()
@@ -968,6 +971,8 @@
         self.expectThat(mappings, HasLength(0))
 
     def test_user_reserved_addresses_included_in_correct_domains(self):
+        # Generate addresses in two domains, and make sure that they wind up in
+        # the right domains, and not in other domains.
         domain0 = Domain.objects.get_default_domain()
         domain1 = factory.make_Domain()
         domain2 = factory.make_Domain()
@@ -992,6 +997,138 @@
         mappings = StaticIPAddress.objects.get_hostname_ip_mapping(domain2)
         self.expectThat(mappings, HasLength(len(ips2)))
 
+    def test_dns_resources_only_have_correct_domain(self):
+        # Create two DNS resources pointing to the same IP, and make sure that
+        # they only get the forward mapping that they should have, but get both
+        # reverse mappings, as is proper.
+        domain0 = Domain.objects.get_default_domain()
+        domain1 = factory.make_Domain()
+        domain2 = factory.make_Domain()
+        subnet = factory.make_Subnet()
+        ip = factory.make_StaticIPAddress(subnet=subnet)
+        name1 = factory.make_name('label')
+        name2 = factory.make_name('label')
+        factory.make_DNSResource(name=name1, ip_addresses=[ip], domain=domain1)
+        factory.make_DNSResource(name=name2, ip_addresses=[ip], domain=domain2)
+        mappings = StaticIPAddress.objects.get_hostname_ip_mapping(domain0)
+        self.expectThat(mappings, HasLength(0))
+        mappings = StaticIPAddress.objects.get_hostname_ip_mapping(domain1)
+        self.expectThat(mappings, HasLength(1))
+        self.assertEqual(
+            mappings.get('%s.%s' % (name1, domain1.name)),
+            HostnameIPMapping(None, 30, {ip.ip}, None))
+        mappings = StaticIPAddress.objects.get_hostname_ip_mapping(domain2)
+        self.expectThat(mappings, HasLength(1))
+        self.assertEqual(
+            mappings.get('%s.%s' % (name2, domain2.name)),
+            HostnameIPMapping(None, 30, {ip.ip}, None))
+        mappings = StaticIPAddress.objects.get_hostname_ip_mapping(subnet)
+        self.assertEqual(
+            mappings, {
+                "%s.%s" % (name1, domain1.name): HostnameIPMapping(
+                    None, 30, {ip.ip}, None),
+                "%s.%s" % (name2, domain2.name): HostnameIPMapping(
+                    None, 30, {ip.ip}, None)})
+
+    def test_user_reserved_IP_on_node_or_default_domain_not_both(self):
+        # ip1 gets assigned to an interface on a node in domain1
+        # ip2 is not assigned to anything.
+        # ip1 should show up for the node, in domain1, and the subnet.
+        # ip2 should show up in the default domain, and the subnet.
+        domain0 = Domain.objects.get_default_domain()
+        domain1 = factory.make_Domain()
+        subnet = factory.make_Subnet()
+        ip1 = factory.make_StaticIPAddress(subnet=subnet)
+        ip2 = factory.make_StaticIPAddress(subnet=subnet)
+        name2 = "%s.%s" % (get_ip_based_hostname(ip2.ip), domain0.name)
+        node = factory.make_Node(
+            interface=True,
+            domain=domain1,
+            vlan=subnet.vlan)
+        node.interface_set.first().ip_addresses.add(ip1)
+        mappings = StaticIPAddress.objects.get_hostname_ip_mapping(domain0)
+        self.expectThat(mappings, HasLength(1))
+        self.assertEqual(
+            mappings, {
+                name2: HostnameIPMapping(None, 30, {ip2.ip}, None)})
+        mappings = StaticIPAddress.objects.get_hostname_ip_mapping(domain1)
+        self.expectThat(mappings, HasLength(1))
+        self.assertEqual(
+            mappings.get(node.fqdn),
+            HostnameIPMapping(node.system_id, 30, {ip1.ip}, node.node_type))
+        mappings = StaticIPAddress.objects.get_hostname_ip_mapping(subnet)
+        self.assertEqual(
+            mappings, {
+                node.fqdn: HostnameIPMapping(
+                    node.system_id, 30, {ip1.ip}, node.node_type),
+                name2: HostnameIPMapping(None, 30, {ip2.ip}, None)})
+
+    def test_node_glue_correctly_generated(self):
+        # Given node "foo.bar.com" and a "foo.bar.com" domain (in addition to
+        # "bar.com"), with an IP associated with it, make sure that both
+        # domains are correctly populated.
+        domain0 = Domain.objects.get_default_domain()
+        parent = factory.make_Domain(name=factory.make_name('parent'))
+        name = factory.make_name('child')
+        domain = factory.make_Domain(name="%s.%s" % (name, parent.name))
+        subnet = factory.make_Subnet()
+        ip = factory.make_StaticIPAddress(subnet=subnet)
+        node = factory.make_Node(
+            interface=True,
+            domain=parent,
+            hostname=name,
+            vlan=subnet.vlan)
+        node.interface_set.first().ip_addresses.add(ip)
+        mappings = StaticIPAddress.objects.get_hostname_ip_mapping(domain0)
+        self.expectThat(mappings, HasLength(0))
+        mappings = StaticIPAddress.objects.get_hostname_ip_mapping(parent)
+        self.expectThat(mappings, HasLength(1))
+        self.assertEqual(
+            mappings.get(node.fqdn),
+            HostnameIPMapping(node.system_id, 30, {ip.ip}, node.node_type))
+        mappings = StaticIPAddress.objects.get_hostname_ip_mapping(domain)
+        self.expectThat(mappings, HasLength(1))
+        self.assertEqual(
+            mappings.get(node.fqdn),
+            HostnameIPMapping(node.system_id, 30, {ip.ip}, node.node_type))
+        mappings = StaticIPAddress.objects.get_hostname_ip_mapping(subnet)
+        self.assertEqual(
+            mappings, {
+                node.fqdn: HostnameIPMapping(
+                    node.system_id, 30, {ip.ip}, node.node_type)})
+
+    def test_dnsrr_glue_correctly_generated(self):
+        # Given DNSResource "foo.bar.com" and a "foo.bar.com" domain (in
+        # addition to "bar.com"), with an IP associated with it, make sure that
+        # both domains are correctly populated.
+        domain0 = Domain.objects.get_default_domain()
+        parent = factory.make_Domain(name=factory.make_name('parent'))
+        name = factory.make_name('child')
+        domain = factory.make_Domain(name="%s.%s" % (name, parent.name))
+        subnet = factory.make_Subnet()
+        ip = factory.make_StaticIPAddress(subnet=subnet)
+        dnsrr = factory.make_DNSResource(
+            domain=domain,
+            name='@',
+            ip_addresses=[ip])
+        mappings = StaticIPAddress.objects.get_hostname_ip_mapping(domain0)
+        self.expectThat(mappings, HasLength(0))
+        mappings = StaticIPAddress.objects.get_hostname_ip_mapping(parent)
+        self.expectThat(mappings, HasLength(1))
+        self.assertEqual(
+            mappings.get(dnsrr.fqdn),
+            HostnameIPMapping(None, 30, {ip.ip}, None))
+        mappings = StaticIPAddress.objects.get_hostname_ip_mapping(domain)
+        self.expectThat(mappings, HasLength(1))
+        self.assertEqual(
+            mappings.get(dnsrr.fqdn),
+            HostnameIPMapping(None, 30, {ip.ip}, None))
+        mappings = StaticIPAddress.objects.get_hostname_ip_mapping(subnet)
+        self.assertEqual(
+            mappings, {
+                dnsrr.fqdn: HostnameIPMapping(
+                    None, 30, {ip.ip}, None)})
+
 
 class TestRenderJSON(MAASServerTestCase):
 

=== modified file 'src/maasserver/websockets/handlers/tests/test_domain.py'
--- src/maasserver/websockets/handlers/tests/test_domain.py	2016-09-06 17:02:03 +0000
+++ src/maasserver/websockets/handlers/tests/test_domain.py	2016-11-17 18:03:27 +0000
@@ -86,6 +86,7 @@
     def test_list(self):
         user = factory.make_User()
         handler = DomainHandler(user, {})
+        Domain.objects.get_default_domain()
         factory.make_Domain()
         expected_domains = [
             self.dehydrate_domain(domain, for_list=True)