Merge ~blake-rouse/maas:clone-interfaces into maas:master

[Blake Rouse]

Add ability to clone interfaces from a source node to a destination node.

Uses similar logic to how cloning the storage layout works. Each clone occurs in a layer until the parent layer is cloned, only then can the child layer be cloned. This must take special care to be ensure that the MAC addresses are from the destination node and not MAC address from the source node.

[MAAS Lander (maas-lander)]

UNIT TESTS
-b clone-interfaces lp:~blake-rouse/maas/+git/maas into -b master lp:~maas-committers/maas

STATUS: SUCCESS
COMMIT: d9fa8688a26b16f647f85793f4fa9df7bded1e0d

review: Approve

[Mike Pontillo (mpontillo)]

Looks like a good start; see one comment below about an existing method that may be helpful to yield interfaces in a parents-first order.

What about subnet links? Should we create similar ones, such as AUTO for AUTO and DHCP for DHCP? If a static IP exists, should we try to assign one on the same subnet? (I wasn't sure if that was left out on purpose and/or planned for a later branch, so that makes this branch "Needs Information".)

Nice job on the unit tests. Should we add a test for something even more complex, such as a bridge on a VLAN on a bond?

review: Needs Information

[Mike Pontillo (mpontillo)]

Ah, I missed the part that tries to allocate a new IP address.

Have you tested that this correctly handles all types of subnet links? What about AUTO addresses on a DEPLOYED node that have been assigned, vs. an AUTO address on a READY node?

0b16378... by Blake Rouse on 2019-02-20

Be more deligent on the cloning of IP address. Add unit tests for better coverage of IP address cloning.

[Blake Rouse (blake-rouse)]

Thanks for the review.

I added more tests to cover the IP address cloning. The code also need to be improved to handle more cases with regards to IP address cloning. So thanks for pointing that out.

I didn't the same level of complexity for interface configuration as the preseed generation does. I don't think we need to expand it here, when that seems to be providing good coverage in the preseed generation.

[Andres Rodriguez (andreserl)]

FWIW, this branch nor the storage were attached to this: https://bugs.launchpad.net/maas/+bug/1814901

Please make sure this is the case.

[Blake Rouse (blake-rouse)]

I do not want the branch attached yet, or the lander will mark the bug fixed. This is just steps to fix the bug. The final API branch will link to the bug.

Once this lands I will link the branch.

[MAAS Lander (maas-lander)]

UNIT TESTS
-b clone-interfaces lp:~blake-rouse/maas/+git/maas into -b master lp:~maas-committers/maas

STATUS: SUCCESS
COMMIT: 0b1637898334806f396f8daea037c5c92a75d958

review: Approve

[Mike Pontillo (mpontillo)]

Looks good. Thanks for cleaning up the IP allocation code.

review: Approve

diff --git a/src/maasserver/models/node.py b/src/maasserver/models/node.py
index 95f3353..9a680f0 100644
--- a/src/maasserver/models/node.py
+++ b/src/maasserver/models/node.py
@@ -114,6 +114,7 @@ from maasserver.models.interface import (
     BondInterface,
     BridgeInterface,
     Interface,
+    InterfaceRelationship,
     PhysicalInterface,
     VLANInterface,
 )
@@ -3665,6 +3666,151 @@ class Node(CleanSave, TimestampedModel):
             if interface.enabled:
                 interface.ensure_link_up()
 
+    def set_networking_configuration_from_node(self, source_node):
+        """Set the networking configuration for this node from the source
+        node."""
+        mapping = self._get_interface_mapping_between_nodes(source_node)
+        self._clear_networking_configuration()
+
+        # Get all none physical interface for the source node. This
+        # is used to do the cloning in layers, only cloning the interfaces
+        # that have already been cloned to make up the next layer of
+        # interfaces.
+        source_interfaces = [
+            interface
+            for interface in source_node.interface_set.all()
+            if interface.type != INTERFACE_TYPE.PHYSICAL
+        ]
+
+        # Clone the model at the physical level.
+        exclude_addresses = self._copy_between_interface_mappings(mapping)
+        mapping = {
+            source_interface.id: self_interface
+            for self_interface, source_interface in mapping.items()
+        }
+
+        # Continue through each layer until no more interfaces exist.
+        source_interfaces, layer_interfaces = (
+            self._get_interface_layers_for_copy(source_interfaces, mapping))
+        while source_interfaces or layer_interfaces:
+            if not layer_interfaces:
+                raise ValueError(
+                    "Copying the next layer of interfaces has failed.")
+            for source_interface, dest_parents in layer_interfaces.items():
+                dest_mapping = self._copy_interface(
+                    source_interface, dest_parents)
+                exclude_addresses += (
+                    self._copy_between_interface_mappings(
+                        dest_mapping, exclude_addresses=exclude_addresses))
+                mapping.update({
+                    source_interface.id: self_interface
+                    for self_interface, source_interface in (
+                        dest_mapping.items())
+                })
+            # Load the next layer.
+            source_interfaces, layer_interfaces = (
+                self._get_interface_layers_for_copy(
+                    source_interfaces, mapping))
+
+    def _get_interface_mapping_between_nodes(self, source_node):
+        """Return the mapping between which interface from this node map to
+        interfaces on the source node.
+
+        Mapping between the nodes is done by the name of the interface. This
+        node must have the same names as the names from `source_node`.
+
+        Raises a `ValidationError` when interfaces cannot be matched.
+        """
+        self_interfaces = {
+            interface.name: interface
+            for interface in self.interface_set.all()
+            if interface.type == INTERFACE_TYPE.PHYSICAL
+        }
+        missing = []
+        mapping = {}
+        for interface in source_node.interface_set.all():
+            if interface.type == INTERFACE_TYPE.PHYSICAL:
+                self_interface = self_interfaces.get(interface.name, None)
+                if self_interface is not None:
+                    mapping[self_interface] = interface
+                else:
+                    missing.append(interface.name)
+        if missing:
+            raise ValidationError(
+                "destination node physical interfaces do not match the "
+                "source nodes physical interfaces: %s" % ', '.join(missing))
+        return mapping
+
+    def _copy_between_interface_mappings(
+            self, mapping, exclude_addresses=None):
+        """Copy the source onto the destination interfaces in the mapping."""
+        if exclude_addresses is None:
+            exclude_addresses = []
+        for self_interface, source_interface in mapping.items():
+            self_interface.vlan = source_interface.vlan
+            self_interface.params = source_interface.params
+            self_interface.ipv4_params = source_interface.ipv4_params
+            self_interface.ipv6_params = source_interface.ipv6_params
+            self_interface.enabled = source_interface.enabled
+            self_interface.acquired = source_interface.acquired
+            self_interface.save()
+
+            for ip_address in source_interface.ip_addresses.all():
+                if ip_address.ip and ip_address.alloc_type in [
+                        IPADDRESS_TYPE.AUTO, IPADDRESS_TYPE.STICKY,
+                        IPADDRESS_TYPE.USER_RESERVED]:
+                    new_ip = StaticIPAddress.objects.allocate_new(
+                        subnet=ip_address.subnet,
+                        alloc_type=ip_address.alloc_type,
+                        user=ip_address.user,
+                        exclude_addresses=exclude_addresses)
+                    self_interface.ip_addresses.add(new_ip)
+                    exclude_addresses.append(new_ip.id)
+                elif ip_address.alloc_type != IPADDRESS_TYPE.DISCOVERED:
+                    self_ip_address = copy.deepcopy(ip_address)
+                    self_ip_address.id = None
+                    self_ip_address.pk = None
+                    self_ip_address.ip = None
+                    self_ip_address.save(force_insert=True)
+                    self_interface.ip_addresses.add(self_ip_address)
+        return exclude_addresses
+
+    def _get_interface_layers_for_copy(
+            self, source_interfaces, interface_mapping):
+        """Pops the interface from the `source_interfaces` when all interfaces
+        that make it up exist in `interface_mapping`."""
+        layer = {}
+        for interface in source_interfaces[:]:  # Iterate on copy
+            contains_all = True
+            dest_parents = []
+            for parent_interface in interface.parents.all():
+                dest_interface = interface_mapping.get(
+                    parent_interface.id, None)
+                if dest_interface:
+                    dest_parents.append(dest_interface)
+                else:
+                    contains_all = False
+                    break
+            if contains_all:
+                layer[interface] = dest_parents
+                source_interfaces.remove(interface)
+        return source_interfaces, layer
+
+    def _copy_interface(self, source_interface, dest_parents):
+        """Copy the `source_interface` linking to the `dest_parents`."""
+        self_interface = copy.copy(source_interface)
+        self_interface.id = None
+        self_interface.pk = None
+        self_interface.node = self
+        self_interface._prefetched_objects_cache = {}
+        self_interface.save(force_insert=True)
+        for parent in dest_parents:
+            InterfaceRelationship.objects.create(
+                child=self_interface, parent=parent)
+        self_interface.mac_address = dest_parents[0].mac_address
+        self_interface.save()
+        return {self_interface: source_interface}
+
     def get_gateways_by_priority(self):
         """Return all possible default gateways for the Node, by priority.
 
diff --git a/src/maasserver/models/tests/test_node.py b/src/maasserver/models/tests/test_node.py
index 93e78e7..ca0dac3 100644
--- a/src/maasserver/models/tests/test_node.py
+++ b/src/maasserver/models/tests/test_node.py
@@ -130,6 +130,7 @@ from maasserver.node_status import (
 )
 from maasserver.permissions import NodePermission
 from maasserver.preseed import CURTIN_INSTALL_LOG
+from maasserver.preseed_network import compose_curtin_network_config
 from maasserver.preseed_storage import compose_curtin_storage_config
 from maasserver.rbac import (
     FakeRBACClient,
@@ -153,6 +154,7 @@ from maasserver.testing.testcase import (
     MAASServerTestCase,
     MAASTransactionServerTestCase,
 )
+from maasserver.tests.test_preseed_network import AssertNetworkConfigMixin
 from maasserver.tests.test_preseed_storage import AssertStorageConfigMixin
 from maasserver.utils.orm import (
     get_one,
@@ -244,6 +246,7 @@ from testtools.matchers import (
 )
 from twisted.internet import defer
 from twisted.internet.error import ConnectionDone
+import yaml
 
 
 wait_for_reactor = wait_for(30)  # 30 seconds.
@@ -11914,3 +11917,272 @@ class TestNodeStorageClone_SpecialFilesystems(
         self.assertStorageConfig(
             self.STORAGE_CONFIG, compose_curtin_storage_config(dest_node),
             strip_uuids=True)
+
+
+class TestNodeInterfaceClone__MappingBetweenNodes(MAASServerTestCase):
+
+    def test__match_by_name(self):
+        node1 = factory.make_Node()
+        node1_eth0 = factory.make_Interface(node=node1, name='eth0')
+        node1_ens3 = factory.make_Interface(node=node1, name='ens3')
+        node1_br0 = factory.make_Interface(node=node1, name='br0')
+        node2 = factory.make_Node()
+        node2_eth0 = factory.make_Interface(node=node2, name='eth0')
+        node2_ens3 = factory.make_Interface(node=node2, name='ens3')
+        node2_br0 = factory.make_Interface(node=node2, name='br0')
+        factory.make_Interface(node=node2, name='other')
+        self.assertEqual({
+            node2_eth0: node1_eth0,
+            node2_ens3: node1_ens3,
+            node2_br0: node1_br0,
+        }, node2._get_interface_mapping_between_nodes(node1))
+
+    def test__fail_when_source_no_match(self):
+        node1 = factory.make_Node()
+        factory.make_Interface(node=node1, name='eth0')
+        factory.make_Interface(node=node1, name='ens3')
+        factory.make_Interface(node=node1, name='br0')
+        factory.make_Interface(node=node1, name='other')
+        factory.make_Interface(node=node1, name='match')
+        node2 = factory.make_Node()
+        factory.make_Interface(node=node2, name='eth0')
+        factory.make_Interface(node=node2, name='ens3')
+        factory.make_Interface(node=node2, name='br0')
+        error = self.assertRaises(
+            ValidationError, node2._get_interface_mapping_between_nodes, node1)
+        self.assertEquals(
+            'destination node physical interfaces do not match the '
+            'source nodes physical interfaces: other, match', error.message)
+
+
+class TestNodeInterfaceClone__IPCloning(MAASServerTestCase):
+
+    def test__auto_ip_assigned_on_clone_when_source_has_ip(self):
+        node = factory.make_Node()
+        node_eth0 = factory.make_Interface(node=node, name='eth0')
+        node_ip = factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.AUTO, interface=node_eth0)
+        self.assertIsNotNone(node_ip.ip)
+
+        dest_node = factory.make_Node()
+        dest_node_eth0 = factory.make_Interface(node=dest_node, name='eth0')
+        dest_node.set_networking_configuration_from_node(node)
+        dest_ip = dest_node_eth0.ip_addresses.first()
+        self.assertIsNotNone(dest_ip.ip)
+        self.assertNotEqual(node_ip.ip, dest_ip.ip)
+
+    def test__auto_ip_unassigned_on_clone_when_source_has_no_ip(self):
+        node = factory.make_Node()
+        node_eth0 = factory.make_Interface(node=node, name='eth0')
+        node_ip = factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.AUTO, interface=node_eth0, ip=None)
+        self.assertIsNone(node_ip.ip)
+
+        dest_node = factory.make_Node()
+        dest_node_eth0 = factory.make_Interface(node=dest_node, name='eth0')
+        dest_node.set_networking_configuration_from_node(node)
+        dest_ip = dest_node_eth0.ip_addresses.first()
+        self.assertIsNone(dest_ip.ip)
+
+    def test__sticky_ip_assigned_on_clone(self):
+        node = factory.make_Node()
+        node_eth0 = factory.make_Interface(node=node, name='eth0')
+        node_ip = factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.STICKY, interface=node_eth0)
+        self.assertIsNotNone(node_ip.ip)
+
+        dest_node = factory.make_Node()
+        dest_node_eth0 = factory.make_Interface(node=dest_node, name='eth0')
+        dest_node.set_networking_configuration_from_node(node)
+        dest_ip = dest_node_eth0.ip_addresses.first()
+        self.assertIsNotNone(dest_ip.ip)
+        self.assertNotEqual(node_ip.ip, dest_ip.ip)
+
+    def test__user_reserved_ip_assigned_on_clone(self):
+        user = factory.make_User()
+        subnet = factory.make_Subnet()
+        node = factory.make_Node()
+        node_eth0 = factory.make_Interface(node=node, name='eth0')
+        node_ip = factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.USER_RESERVED, interface=node_eth0,
+            user=user, subnet=subnet)
+        self.assertIsNotNone(node_ip.ip)
+
+        dest_node = factory.make_Node()
+        dest_node_eth0 = factory.make_Interface(node=dest_node, name='eth0')
+        dest_node.set_networking_configuration_from_node(node)
+        dest_ip = dest_node_eth0.ip_addresses.first()
+        self.assertIsNotNone(dest_ip.ip)
+        self.assertNotEqual(node_ip.ip, dest_ip.ip)
+        self.assertEqual(user, dest_ip.user)
+
+    def test__dhcp_assigned_on_clone(self):
+        node = factory.make_Node()
+        node_eth0 = factory.make_Interface(node=node, name='eth0')
+        factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.DHCP, interface=node_eth0, ip=None)
+
+        dest_node = factory.make_Node()
+        dest_node_eth0 = factory.make_Interface(node=dest_node, name='eth0')
+        dest_node.set_networking_configuration_from_node(node)
+        dest_ip = dest_node_eth0.ip_addresses.first()
+        self.assertEqual(IPADDRESS_TYPE.DHCP, dest_ip.alloc_type)
+
+    def test__discovered_not_assigned_on_clone(self):
+        node = factory.make_Node()
+        node_eth0 = factory.make_Interface(node=node, name='eth0')
+        factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.DISCOVERED, interface=node_eth0)
+
+        dest_node = factory.make_Node()
+        dest_node_eth0 = factory.make_Interface(node=dest_node, name='eth0')
+        dest_node.set_networking_configuration_from_node(node)
+        dest_ip = dest_node_eth0.ip_addresses.first()
+        self.assertIsNone(dest_ip)
+
+
+class TestNodeInterfaceClone_SimpleNetworkLayout(
+        MAASServerTestCase, AssertNetworkConfigMixin):
+
+    def create_staticipaddresses(self, node):
+        for iface in node.interface_set.filter(enabled=True):
+            factory.make_StaticIPAddress(
+                interface=iface,
+                subnet=iface.vlan.subnet_set.first())
+            iface.params = {
+                "mtu": random.randint(600, 1400),
+                "accept_ra": factory.pick_bool(),
+                "autoconf": factory.pick_bool(),
+            }
+            iface.save()
+        extra_interface = node.interface_set.all()[1]
+        sip = factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.STICKY, ip="",
+            subnet=None, interface=extra_interface)
+        sip.subnet = None
+        sip.save()
+
+    def test__copy(self):
+        # Keep them in the same domain to make the checking of configuraton
+        # easy. A copy to destination doesn't move the destinations nodes
+        # domain.
+        domain = factory.make_Domain('bbb')
+        node = factory.make_Node_with_Interface_on_Subnet(
+            interface_count=2, ifname='eth0', extra_ifnames=['eth1'],
+            domain=domain)
+        self.create_staticipaddresses(node)
+        node_config = self.collect_interface_config(node)
+        node_config += self.collect_dns_config(node)
+
+        dest_node = factory.make_Node_with_Interface_on_Subnet(
+            interface_count=2, ifname='eth0', extra_ifnames=['eth1'],
+            domain=domain)
+        dest_node.set_networking_configuration_from_node(node)
+        dest_config = self.collect_interface_config(dest_node)
+        dest_config += self.collect_dns_config(dest_node)
+
+        node_composed_config = compose_curtin_network_config(node)
+        dest_composed_config = compose_curtin_network_config(dest_node)
+        self.assertNetworkConfig(
+            node_config, dest_composed_config, strip_macs=True, strip_ips=True)
+        self.assertNetworkConfig(
+            dest_config, node_composed_config, strip_macs=True, strip_ips=True)
+
+
+class TestNodeInterfaceClone_VLANOnBondNetworkLayout(
+        MAASServerTestCase, AssertNetworkConfigMixin):
+
+    def test__copy(self):
+        domain = factory.make_Domain('bbb')
+        node = factory.make_Node_with_Interface_on_Subnet(
+            interface_count=2, ifname='eth0', extra_ifnames=['eth1'],
+            domain=domain)
+        phys_ifaces = list(node.interface_set.all())
+        phys_vlan = node.interface_set.first().vlan
+        bond_iface = factory.make_Interface(iftype=INTERFACE_TYPE.BOND,
+                                            node=node, vlan=phys_vlan,
+                                            parents=phys_ifaces)
+        bond_iface.params = {
+            "bond_mode": "balance-rr",
+        }
+        bond_iface.save()
+        vlan_iface = factory.make_Interface(
+            iftype=INTERFACE_TYPE.VLAN, node=node, parents=[bond_iface])
+        subnet = factory.make_Subnet(vlan=vlan_iface.vlan)
+        factory.make_StaticIPAddress(interface=vlan_iface, subnet=subnet)
+        node_config = self.collect_interface_config(node, filter="physical")
+        node_config += self.collect_interface_config(node, filter="bond")
+        node_config += self.collect_interface_config(node, filter="vlan")
+        node_config += self.collect_dns_config(node)
+
+        dest_node = factory.make_Node_with_Interface_on_Subnet(
+            interface_count=2, ifname='eth0', extra_ifnames=['eth1'],
+            domain=domain)
+        dest_node.set_networking_configuration_from_node(node)
+        dest_config = self.collect_interface_config(
+            dest_node, filter="physical")
+        dest_config += self.collect_interface_config(dest_node, filter="bond")
+        dest_config += self.collect_interface_config(dest_node, filter="vlan")
+        dest_config += self.collect_dns_config(dest_node)
+
+        node_composed_config = compose_curtin_network_config(node)
+        dest_composed_config = compose_curtin_network_config(dest_node)
+        self.assertNetworkConfig(
+            node_config, dest_composed_config, strip_macs=True, strip_ips=True)
+        self.assertNetworkConfig(
+            dest_config, node_composed_config, strip_macs=True, strip_ips=True)
+
+        # Bond configuration should have different MAC addresses.
+        node_bond = yaml.safe_load(
+            self.collect_interface_config(node, filter="bond"))
+        dest_bond = yaml.safe_load(
+            self.collect_interface_config(dest_node, filter="bond"))
+        self.assertNotEqual(
+            node_bond[0]['mac_address'], dest_bond[0]['mac_address'])
+
+
+class TestNodeInterfaceClone_BridgeNetworkLayout(
+        MAASServerTestCase, AssertNetworkConfigMixin):
+
+    def test__renders_expected_output(self):
+        node = factory.make_Node_with_Interface_on_Subnet(ifname='eth0')
+        boot_interface = node.get_boot_interface()
+        vlan = boot_interface.vlan
+        mac_address = factory.make_mac_address()
+        bridge_iface = factory.make_Interface(
+            iftype=INTERFACE_TYPE.BRIDGE, node=node, vlan=vlan,
+            parents=[boot_interface], mac_address=mac_address)
+        bridge_iface.params = {
+            "bridge_fd": 0,
+            "bridge_stp": True,
+        }
+        bridge_iface.save()
+        factory.make_StaticIPAddress(
+            interface=bridge_iface, alloc_type=IPADDRESS_TYPE.STICKY,
+            subnet=bridge_iface.vlan.subnet_set.first())
+        node_config = self.collect_interface_config(node, filter="physical")
+        node_config += self.collect_interface_config(node, filter="bridge")
+        node_config += self.collect_dns_config(node)
+
+        dest_node = factory.make_Node_with_Interface_on_Subnet(ifname='eth0')
+        dest_node.set_networking_configuration_from_node(node)
+        dest_config = self.collect_interface_config(
+            dest_node, filter="physical")
+        dest_config += self.collect_interface_config(
+            dest_node, filter="bridge")
+        dest_config += self.collect_dns_config(dest_node)
+
+        node_composed_config = compose_curtin_network_config(node)
+        dest_composed_config = compose_curtin_network_config(dest_node)
+        self.assertNetworkConfig(
+            node_config, dest_composed_config, strip_macs=True, strip_ips=True)
+        self.assertNetworkConfig(
+            dest_config, node_composed_config, strip_macs=True, strip_ips=True)
+
+        # Bridge configuration should have different MAC addresses.
+        node_bridge = yaml.safe_load(
+            self.collect_interface_config(node, filter="bridge"))
+        dest_bridge = yaml.safe_load(
+            self.collect_interface_config(dest_node, filter="bridge"))
+        self.assertNotEqual(
+            node_bridge[0]['mac_address'], dest_bridge[0]['mac_address'])
diff --git a/src/maasserver/testing/factory.py b/src/maasserver/testing/factory.py
index e59a190..3671d61 100644
--- a/src/maasserver/testing/factory.py
+++ b/src/maasserver/testing/factory.py
@@ -855,7 +855,8 @@ class Factory(maastesting.factory.Factory):
 
     def make_Node_with_Interface_on_Subnet(
             self, interface_count=1, vlan=None, subnet=None,
-            cidr=None, fabric=None, ifname=None, unmanaged=False,
+            cidr=None, fabric=None, ifname=None, extra_ifnames=None,
+            unmanaged=False,
             with_dhcp_rack_primary=True, with_dhcp_rack_secondary=False,
             primary_rack=None, secondary_rack=None,
             **kwargs):
@@ -908,8 +909,12 @@ class Factory(maastesting.factory.Factory):
                 alloc_type=IPADDRESS_TYPE.AUTO, ip="",
                 subnet=subnet, interface=boot_interface)
         for _ in range(1, interface_count):
+            ifname = None
+            if extra_ifnames:
+                ifname = extra_ifnames[0]
+                extra_ifnames = extra_ifnames[1:]
             interface = self.make_Interface(
-                INTERFACE_TYPE.PHYSICAL, node=node, vlan=vlan)
+                INTERFACE_TYPE.PHYSICAL, name=ifname, node=node, vlan=vlan)
             self.make_StaticIPAddress(
                 alloc_type=IPADDRESS_TYPE.DISCOVERED, ip="",
                 subnet=subnet, interface=interface)
diff --git a/src/maasserver/tests/test_preseed_network.py b/src/maasserver/tests/test_preseed_network.py
index 714ba49..a15cd34 100644
--- a/src/maasserver/tests/test_preseed_network.py
+++ b/src/maasserver/tests/test_preseed_network.py
@@ -87,7 +87,21 @@ class AssertNetworkConfigMixin:
           metric: %(metric)s
         """)
 
-    def assertNetworkConfig(self, expected, output):
+    def stripMACs(self, config):
+        for entry in config:
+            if 'mac_address' in entry:
+                entry['mac_address'] = '*match*'
+        return config
+
+    def stripIPs(self, config):
+        for entry in config:
+            for subnet in entry.get('subnets', []):
+                if 'address' in subnet:
+                    subnet['address'] = '*match*'
+        return config
+
+    def assertNetworkConfig(
+            self, expected, output, strip_macs=False, strip_ips=False):
         output = output[0]
         output = yaml.safe_load(output)
         self.assertThat(output, ContainsDict({
@@ -101,6 +115,12 @@ class AssertNetworkConfigMixin:
         }))
         expected_network = yaml.safe_load(expected)
         output_network = output["network"]["config"]
+        if strip_macs:
+            expected_network = self.stripMACs(expected_network)
+            output_network = self.stripMACs(output_network)
+        if strip_ips:
+            expected_network = self.stripIPs(expected_network)
+            output_network = self.stripIPs(output_network)
         expected_equals = list(map(Equals, expected_network))
         self.assertThat(output_network, MatchesListwise(expected_equals))