Merge lp:~mpontillo/maas/netplan--part2--tests into lp:~maas-committers/maas/trunk

[Mike Pontillo]

Support netplan (v2 YAML) rendering in the network preseed generator.

Implement tests for Netplan YAML.Support netplan (v2 YAML) rendering in the network preseed generator.

Drive-by fix to allow preseed YAML to be rendered for nodes with NULL IP addresses (such as AUTO addresses that have not been assigned yet) to be rendered (without those addresses). It would be nice if a special syntax existed for "TBD" addresses, so we could show these for debugging purposes.

[Blake Rouse (blake-rouse)]

Looks good.

review: Approve

[Mike Pontillo (mpontillo)]

Approved by Blake (landing this as one branch).

review: Approve

[MAAS Lander (maas-lander)]

The attempt to merge lp:~mpontillo/maas/netplan--part2--tests into lp:maas failed. Below is the output from the failed tests.

Hit:1 http://prodstack-zone-2.clouds.archive.ubuntu.com/ubuntu xenial InRelease
Get:2 http://security.ubuntu.com/ubuntu xenial-security InRelease [102 kB]
Get:3 http://prodstack-zone-2.clouds.archive.ubuntu.com/ubuntu xenial-updates InRelease [102 kB]
Get:4 http://prodstack-zone-2.clouds.archive.ubuntu.com/ubuntu xenial-backports InRelease [102 kB]
Fetched 306 kB in 0s (602 kB/s)
Reading package lists...
sudo DEBIAN_FRONTEND=noninteractive apt-get -y \
    --no-install-recommends install apache2 archdetect-deb authbind avahi-utils bash bind9 bind9utils build-essential bzr bzr-builddeb chromium-browser chromium-chromedriver curl daemontools debhelper dh-apport dh-systemd distro-info dnsutils firefox freeipmi-tools git gjs ipython isc-dhcp-common isc-dhcp-server libjs-angularjs libjs-jquery libjs-jquery-hotkeys libjs-yui3-full libjs-yui3-min libnss-wrapper libpq-dev make nodejs-legacy npm postgresql psmisc pxelinux python3-all python3-apt python3-attr python3-bson python3-convoy python3-crochet python3-cssselect python3-curtin python3-dev python3-distro-info python3-django python3-django-nose python3-django-piston3 python3-dnspython python3-docutils python3-formencode python3-hivex python3-httplib2 python3-jinja2 python3-jsonschema python3-lxml python3-netaddr python3-netifaces python3-novaclient python3-oauth python3-oauthlib python3-openssl python3-paramiko python3-petname python3-pexpect python3-psycopg2 python3-pyinotify python3-pyparsing python3-pyvmomi python3-requests python3-seamicroclient python3-setuptools python3-simplestreams python3-sphinx python3-tempita python3-twisted python3-txtftp python3-tz python3-yaml python3-zope.interface python-bson python-crochet python-django python-django-piston python-djorm-ext-pgarray python-formencode python-lxml python-netaddr python-netifaces python-pocket-lint python-psycopg2 python-simplejson python-tempita python-twisted python-yaml socat syslinux-common tgt ubuntu-cloudimage-keyring wget xvfb
Reading package lists...
Building dependency tree...
Reading state information...
authbind is already the newest version (2.1.1+nmu1).
avahi-utils is already the newest version (0.6.32~rc+dfsg-1ubuntu2).
build-essential is already the newest version (12.1ubuntu2).
debhelper is already the newest version (9.20160115ubuntu3).
distro-info is already the newest version (0.14build1).
git is already the newest version (1:2.7.4-0ubuntu1).
libjs-angularjs is already the newest version (1.2.28-1ubuntu2).
libjs-jquery is already the newest version (1.11.3+dfsg-4).
libjs-yui3-full is already the newest version (3.5.1-1ubuntu3).
libjs-yui3-min is already the newest version (3.5.1-1ubuntu3).
make is already the newest version (4.1-6).
postgresql is already the newest version (9.5+173).
psmisc is already the newest version (22.21-2.1build1).
pxelinux is already the newest version (3:6.03+dfsg-11ubuntu1).
python-formencode is already the newest version (1.3.0-0ubuntu5).
python-lxml is already the newest version (3.5.0-1build1).
python-netaddr is already the newest version (0.7.18-1).
python-net...

=== modified file 'src/maasserver/preseed_network.py'
--- src/maasserver/preseed_network.py	2017-02-17 14:23:04 +0000
+++ src/maasserver/preseed_network.py	2017-03-06 11:48:26 +0000
@@ -17,7 +17,7 @@
 )
 from maasserver.models import Interface
 from maasserver.models.staticroute import StaticRoute
-from netaddr import IPAddress
+from netaddr import IPNetwork
 import yaml
 
 
@@ -45,21 +45,29 @@
         return value
 
 
-def _generate_route_operation(route):
+def _generate_route_operation(route, version=1):
     """Generate route operation place in `network_config`."""
-    route_operation = {
-        "id": route.id,
-        "type": "route",
-        "destination": route.destination.cidr,
-        "gateway": route.gateway_ip,
-        "metric": route.metric,
-    }
-    return route_operation
+    if version == 1:
+        route_operation = {
+            "id": route.id,
+            "type": "route",
+            "destination": route.destination.cidr,
+            "gateway": route.gateway_ip,
+            "metric": route.metric,
+        }
+        return route_operation
+    elif version == 2:
+        route_operation = {
+            "to": route.destination.cidr,
+            "via": route.gateway_ip,
+            "metric": route.metric,
+        }
+        return route_operation
 
 
 class InterfaceConfiguration:
 
-    def __init__(self, iface, node_config):
+    def __init__(self, iface, node_config, version=1):
         """
 
         :param iface: The interface whose configuration to generate.
@@ -73,32 +81,45 @@
         self.gateways = node_config.gateways
         self.matching_routes = set()
         self.addr_family_present = defaultdict(bool)
+        self.version = version
         self.config = None
+        self.name = self.iface.get_name()
 
         if self.type == INTERFACE_TYPE.PHYSICAL:
-            self.config = self._generate_physical_operation()
+            self.config = self._generate_physical_operation(version=version)
         elif self.type == INTERFACE_TYPE.VLAN:
-            self.config = self._generate_vlan_operation()
+            self.config = self._generate_vlan_operation(version=version)
         elif self.type == INTERFACE_TYPE.BOND:
-            self.config = self._generate_bond_operation()
+            self.config = self._generate_bond_operation(version=version)
         elif self.type == INTERFACE_TYPE.BRIDGE:
-            self.config = self._generate_bridge_operation()
+            self.config = self._generate_bridge_operation(version=version)
         else:
             raise ValueError("Unknown interface type: %s" % self.type)
 
-    def _generate_physical_operation(self):
+    def _generate_physical_operation(self, version=1):
         """Generate physical interface operation for `interface` and place in
         `network_config`."""
-        addrs = self._generate_addresses()
+        addrs = self._generate_addresses(version=version)
         physical_operation = self._get_initial_params()
-        physical_operation.update({
-            "id": self.iface.get_name(),
-            "type": "physical",
-            "name": self.iface .get_name(),
-            "mac_address": str(self.iface .mac_address),
-        })
-        if addrs:
-            physical_operation["subnets"] = addrs
+        if version == 1:
+            physical_operation.update({
+                "id": self.name,
+                "type": "physical",
+                "name": self.name,
+                "mac_address": str(self.iface.mac_address),
+            })
+            if addrs:
+                physical_operation["subnets"] = addrs
+        elif version == 2:
+            physical_operation.update({
+                "match": {
+                    "macaddress": str(self.iface.mac_address),
+                },
+                # Unclear what we want, so just let it be the default.
+                # "wakeonlan": True,
+                "set-name": self.name,
+            })
+            physical_operation.update(addrs)
         return physical_operation
 
     def _get_dhcp_type(self):
@@ -141,7 +162,7 @@
                         return subnet.gateway_ip
         return None
 
-    def _set_default_gateway(self, subnet, subnet_operation):
+    def _set_default_gateway(self, subnet, config, version=1):
         """Set the default gateway on the `subnet_operation` if it should
         be set."""
         family = subnet.get_ipnetwork().version
@@ -152,11 +173,16 @@
             return
         gateway = self._get_default_gateway(subnet)
         if gateway is not None:
+            if version == 1:
+                config["gateway"] = str(gateway)
             if family == IPADDRESS_FAMILY.IPv4:
                 node_config.gateway_ipv4_set = True
+                if version == 2:
+                    config["gateway4"] = str(gateway)
             elif family == IPADDRESS_FAMILY.IPv6:
                 node_config.gateway_ipv6_set = True
-            subnet_operation["gateway"] = str(gateway)
+                if version == 2:
+                    config["gateway6"] = str(gateway)
 
     def _get_matching_routes(self, source):
         """Return all route objects matching `source`."""
@@ -166,9 +192,12 @@
             if route.source == source
         }
 
-    def _generate_addresses(self):
+    def _generate_addresses(self, version=1):
         """Generate the various addresses needed for this interface."""
-        addrs = []
+        v1_config = []
+        v2_cidrs = []
+        v2_config = {}
+        v2_nameservers = {}
         addresses = list(
             self.iface.ip_addresses.exclude(
                 alloc_type__in=[
@@ -177,83 +206,162 @@
                 ]).order_by('id'))
         dhcp_type = self._get_dhcp_type()
         if _is_link_up(addresses) and not dhcp_type:
-            addrs.append({"type": "manual"})
+            if version == 1:
+                v1_config.append({"type": "manual"})
         else:
             for address in addresses:
                 subnet = address.subnet
                 if subnet is not None:
                     subnet_len = subnet.cidr.split('/')[1]
-                    subnet_operation = {
+                    cidr = "%s/%s" % (str(address.ip), subnet_len)
+                    v1_subnet_operation = {
                         "type": "static",
-                        "address": "%s/%s" % (str(address.ip), subnet_len)
+                        "address": cidr
                     }
+                    if address.ip is not None:
+                        # If the address is None, that means we're generating a
+                        # preseed for a Node that is not (or is no longer) in
+                        # the READY state; so it might have auto-assigned IP
+                        # addresses which have not yet been determined. It
+                        # would be nice if there was a way to express this, if
+                        # only for debugging purposes. For now, just ignore
+                        # such addresses.
+                        v1_subnet_operation['address'] = cidr
+                        v2_cidrs.append(cidr)
+                        if "addresses" not in v2_config:
+                            v2_config["addresses"] = v2_cidrs
+                    v1_config.append(v1_subnet_operation)
                     self.addr_family_present[
-                        IPAddress(address.ip).version] = True
+                        IPNetwork(subnet.cidr).version] = True
+                    # The default gateway is set on the subnet operation for
+                    # the v1 YAML, but it's per-interface for the v2 YAML.
                     self._set_default_gateway(
-                        subnet, subnet_operation)
+                        subnet,
+                        v1_subnet_operation if version == 1 else v2_config)
                     if subnet.dns_servers is not None:
-                        subnet_operation["dns_nameservers"] = (
+                        v1_subnet_operation["dns_nameservers"] = (
                             subnet.dns_servers)
-                    addrs.append(subnet_operation)
+                        if "nameservers" not in v2_config:
+                            v2_config["nameservers"] = v2_nameservers
+                            # XXX should also support search paths.
+                            if "addresses" not in v2_nameservers:
+                                v2_nameservers["addresses"] = []
+                        v2_nameservers["addresses"].extend(
+                            [server for server in subnet.dns_servers])
                     self.matching_routes.update(
                         self._get_matching_routes(subnet))
             if dhcp_type:
-                addrs.append(
+                v1_config.append(
                     {"type": dhcp_type}
                 )
-        return addrs
+                if dhcp_type == "dhcp":
+                    v2_config.update({
+                        "dhcp4": True,
+                        "dhcp6": True,
+                    })
+                elif dhcp_type == "dhcp4":
+                    v2_config.update({
+                        "dhcp4": True,
+                    })
+                elif dhcp_type == "dhcp6":
+                    v2_config.update({
+                        "dhcp6": True,
+                    })
+        if version == 1:
+            return v1_config
+        elif version == 2:
+            return v2_config
 
-    def _generate_vlan_operation(self):
+    def _generate_vlan_operation(self, version=1):
         """Generate vlan operation for `iface` and place in
         `network_config`."""
         vlan = self.iface.vlan
-        name = self.iface.get_name()
-        addrs = self._generate_addresses()
+        name = self.name
+        addrs = self._generate_addresses(version=version)
         vlan_operation = self._get_initial_params()
-        vlan_operation.update({
-            "id": name,
-            "type": "vlan",
-            "name": name,
-            "vlan_link": self.iface.parents.first().get_name(),
-            "vlan_id": vlan.vid,
-        })
-        if addrs:
-            vlan_operation["subnets"] = addrs
+        if version == 1:
+            vlan_operation.update({
+                "id": name,
+                "type": "vlan",
+                "name": name,
+                "vlan_link": self.iface.parents.first().get_name(),
+                "vlan_id": vlan.vid,
+            })
+            if addrs:
+                vlan_operation["subnets"] = addrs
+        elif version == 2:
+            vlan_operation.update({
+                "id": vlan.vid,
+                "link": self.iface.parents.first().get_name(),
+            })
+            vlan_operation.update(addrs)
         return vlan_operation
 
-    def _generate_bond_operation(self):
+    def _generate_bond_operation(self, version=1):
         """Generate bond operation for `iface` and place in
         `network_config`."""
-        addrs = self._generate_addresses()
+        addrs = self._generate_addresses(version=version)
         bond_operation = self._get_initial_params()
-        bond_operation.update({
-            "id": self.iface.get_name(),
-            "type": "bond",
-            "name": self.iface.get_name(),
-            "mac_address": str(self.iface.mac_address),
-            "bond_interfaces": [parent.get_name() for parent in
-                                self.iface.parents.order_by('name')],
-            "params": self._get_bond_params(),
-        })
-        if addrs:
-            bond_operation["subnets"] = addrs
+        if version == 1:
+            bond_operation.update({
+                "id": self.name,
+                "type": "bond",
+                "name": self.name,
+                "mac_address": str(self.iface.mac_address),
+                "bond_interfaces": [parent.get_name() for parent in
+                                    self.iface.parents.order_by('name')],
+                "params": self._get_bond_params(),
+            })
+            if addrs:
+                bond_operation["subnets"] = addrs
+        else:
+            bond_operation.update({
+                # XXX mpontillo 2017-02-17: netplan does not yet support
+                # specifying the MAC that should be used for a bond.
+                # See launchpad bug #1664698.
+                # "macaddress": str(self.iface.mac_address),
+                "interfaces": [
+                    parent.get_name()
+                    for parent in self.iface.parents.order_by('name')
+                    ],
+                # XXX mpontillo 2017-02-17: netplan does not yet support
+                # specifying bond parameters. See launchpad bug #1664702.
+                # "params": self._get_bond_params(),
+            })
+            bond_operation.update(addrs)
         return bond_operation
 
-    def _generate_bridge_operation(self):
+    def _generate_bridge_operation(self, version=1):
         """Generate bridge operation for this interface."""
-        addrs = self._generate_addresses()
+        addrs = self._generate_addresses(version=version)
         bridge_operation = self._get_initial_params()
-        bridge_operation.update({
-            "id": self.iface.get_name(),
-            "type": "bridge",
-            "name": self.iface.get_name(),
-            "mac_address": str(self.iface.mac_address),
-            "bridge_interfaces": [parent.get_name() for parent in
-                                  self.iface.parents.order_by('name')],
-            "params": self._get_bridge_params(),
-        })
-        if addrs:
-            bridge_operation["subnets"] = addrs
+        if version == 1:
+            bridge_operation.update({
+                "id": self.name,
+                "type": "bridge",
+                "name": self.name,
+                "mac_address": str(self.iface.mac_address),
+                "bridge_interfaces": [parent.get_name() for parent in
+                                      self.iface.parents.order_by('name')],
+                "params": self._get_bridge_params(),
+            })
+            if addrs:
+                bridge_operation["subnets"] = addrs
+        elif version == 2:
+            bridge_operation.update({
+                # XXX mpontillo 2017-02-17: netplan does not yet support
+                # specifying the MAC that should be used for a bond.
+                # See launchpad bug #1664698.
+                # "macaddress": str(self.iface.mac_address),
+                "interfaces": [
+                    parent.get_name()
+                    for parent in self.iface.parents.order_by('name')
+                ],
+                # XXX mpontillo 2017-02-17: netplan does not yet support
+                # specifying bridge parameters. See launchpad bug #1664702.
+                # "params": self._get_bridge_params(),
+            })
+            bridge_operation.update(addrs)
         return bridge_operation
 
     def _get_initial_params(self):
@@ -299,13 +407,20 @@
 class NodeNetworkConfiguration:
     """Generator for the YAML network configuration for curtin."""
 
-    def __init__(self, node):
+    def __init__(self, node, version=1):
         """Create the YAML network configuration for the specified node, and
         store it in the `config` ivar.
         """
         self.node = node
         self.matching_routes = set()
-        self.network_config = []
+        self.v1_config = []
+        self.v2_config = {
+            "version": 2
+        }
+        self.v2_ethernets = {}
+        self.v2_vlans = {}
+        self.v2_bonds = {}
+        self.v2_bridges = {}
         self.gateway_ipv4_set = False
         self.gateway_ipv6_set = False
         # The default value is False: expected keys are 4 and 6.
@@ -318,13 +433,21 @@
         for iface in interfaces:
             if not iface.is_enabled():
                 continue
-            generator = InterfaceConfiguration(iface, self)
+            generator = InterfaceConfiguration(iface, self, version=version)
             self.matching_routes.update(generator.matching_routes)
             self.addr_family_present.update(generator.addr_family_present)
-            self.network_config.append(generator.config)
-
-        # Generate each YAML operation in the network_config.
-        self._generate_route_operations()
+            if version == 1:
+                self.v1_config.append(generator.config)
+            elif version == 2:
+                v2_config = {generator.name: generator.config}
+                if generator.type == INTERFACE_TYPE.PHYSICAL:
+                    self.v2_ethernets.update(v2_config)
+                elif generator.type == INTERFACE_TYPE.VLAN:
+                    self.v2_vlans.update(v2_config)
+                elif generator.type == INTERFACE_TYPE.BOND:
+                    self.v2_bonds.update(v2_config)
+                elif generator.type == INTERFACE_TYPE.BRIDGE:
+                    self.v2_bridges.update(v2_config)
 
         # If we have no IPv6 addresses present, make sure we claim IPv4, so
         # that we at least get some address.
@@ -336,31 +459,65 @@
             name
             for name in sorted(get_dns_search_paths())
             if name != self.node.domain.name]
-        self.network_config.append({
+        self._generate_route_operations(version=version)
+        self.v1_config.append({
             "type": "nameserver",
             "address": default_dns_servers,
             "search": search_list,
         })
-
-        network_config = {
-            "network_commands": {
-                "builtin": ["curtin", "net-meta", "custom"],
-            },
-            "network": {
-                "version": 1,
-                "config": self.network_config,
-            },
-        }
-        # Render the resulting YAML.
-        self.config = yaml.safe_dump(network_config, default_flow_style=False)
-
-    def _generate_route_operations(self):
+        if version == 1:
+            network_config = {
+                "network": {
+                    "version": 1,
+                    "config": self.v1_config,
+                },
+            }
+        else:
+            network_config = {
+                "network": self.v2_config,
+            }
+            v2_config = network_config['network']
+            if len(self.v2_ethernets) > 0:
+                v2_config.update({"ethernets": self.v2_ethernets})
+            if len(self.v2_vlans) > 0:
+                v2_config.update({"vlans": self.v2_vlans})
+            if len(self.v2_bonds) > 0:
+                v2_config.update({"bonds": self.v2_bonds})
+            if len(self.v2_bridges) > 0:
+                v2_config.update({"bridges": self.v2_bridges})
+            # XXX mpontillo 2017-02-17: netplan has no concept of "default"
+            # DNS servers. Need to define how to convey this.
+            # See launchpad bug #1664806.
+            # if len(default_dns_servers) > 0 or len(search_list) > 0:
+            #     nameservers = {}
+            #     if len(search_list) > 0:
+            #         nameservers.update({"search": search_list})
+            #     if len(default_dns_servers) > 0:
+            #         nameservers.update({"addresses": default_dns_servers})
+            #     v2_config.update({"nameservers": nameservers})
+        self.config = network_config
+
+    def _generate_route_operations(self, version=1):
         """Generate all route operations."""
+        routes = []
         for route in sorted(self.matching_routes, key=attrgetter("id")):
-            self.network_config.append(_generate_route_operation(route))
-
-
-def compose_curtin_network_config(node):
+            routes.append(_generate_route_operation(route, version=version))
+        if version == 1:
+            self.v1_config.extend(routes)
+        elif version == 2 and len(routes) > 0:
+            self.v2_config["routes"] = routes
+
+
+def compose_curtin_network_config(node, version=1):
     """Compose the network configuration for curtin."""
-    generator = NodeNetworkConfiguration(node)
-    return [generator.config]
+    generator = NodeNetworkConfiguration(node, version=version)
+    curtin_config = {
+        "network_commands": {
+            "builtin": ["curtin", "net-meta", "custom"],
+        }
+    }
+    curtin_config.update(generator.config)
+    # Render the resulting YAML.
+    curtin_config_yaml = yaml.safe_dump(
+        curtin_config, default_flow_style=False)
+    return [curtin_config_yaml]

=== modified file 'src/maasserver/tests/test_preseed_network.py'
--- src/maasserver/tests/test_preseed_network.py	2017-02-22 14:55:09 +0000
+++ src/maasserver/tests/test_preseed_network.py	2017-03-06 11:48:26 +0000
@@ -16,7 +16,10 @@
     IPADDRESS_TYPE,
 )
 from maasserver.models.staticroute import StaticRoute
-from maasserver.preseed_network import compose_curtin_network_config
+from maasserver.preseed_network import (
+    compose_curtin_network_config,
+    NodeNetworkConfiguration,
+)
 from maasserver.testing.factory import factory
 from maasserver.testing.testcase import MAASServerTestCase
 from netaddr import IPNetwork
@@ -461,3 +464,168 @@
         net_config += self.collectDNSConfig(node)
         config = compose_curtin_network_config(node)
         self.assertNetworkConfig(net_config, config)
+
+
+class TestNetplan(MAASServerTestCase):
+
+    def _render_netplan_dict(self, node):
+        return NodeNetworkConfiguration(node, version=2).config
+
+    def test__single_ethernet_interface(self):
+        node = factory.make_Node()
+        factory.make_Interface(
+            node=node, name='eth0', mac_address="00:01:02:03:04:05")
+        netplan = self._render_netplan_dict(node)
+        expected_netplan = {
+            'network': {
+                'version': 2,
+                'ethernets': {
+                    'eth0': {
+                        'match': {'macaddress': '00:01:02:03:04:05'},
+                        'mtu': 1500,
+                        'set-name': 'eth0'
+                    },
+                },
+            }
+        }
+        self.expectThat(netplan, Equals(expected_netplan))
+
+    def test__multiple_ethernet_interfaces(self):
+        node = factory.make_Node()
+        factory.make_Interface(
+            node=node, name='eth0', mac_address="00:01:02:03:04:05")
+        factory.make_Interface(
+            node=node, name='eth1', mac_address="02:01:02:03:04:05")
+        netplan = self._render_netplan_dict(node)
+        expected_netplan = {
+            'network': {
+                'version': 2,
+                'ethernets': {
+                    'eth0': {
+                        'match': {'macaddress': '00:01:02:03:04:05'},
+                        'mtu': 1500,
+                        'set-name': 'eth0'
+                    },
+                    'eth1': {
+                        'match': {'macaddress': '02:01:02:03:04:05'},
+                        'mtu': 1500,
+                        'set-name': 'eth1'
+                    },
+                },
+            },
+        }
+        self.expectThat(netplan, Equals(expected_netplan))
+
+    def test__bond(self):
+        node = factory.make_Node()
+        eth0 = factory.make_Interface(
+            node=node, name='eth0', mac_address="00:01:02:03:04:05")
+        eth1 = factory.make_Interface(
+            node=node, name='eth1', mac_address="02:01:02:03:04:05")
+        factory.make_Interface(
+            INTERFACE_TYPE.BOND,
+            node=node, name='bond0', parents=[eth0, eth1])
+        netplan = self._render_netplan_dict(node)
+        expected_netplan = {
+            'network': {
+                'version': 2,
+                'ethernets': {
+                    'eth0': {
+                        'match': {'macaddress': '00:01:02:03:04:05'},
+                        'mtu': 1500,
+                        'set-name': 'eth0'
+                    },
+                    'eth1': {
+                        'match': {'macaddress': '02:01:02:03:04:05'},
+                        'mtu': 1500,
+                        'set-name': 'eth1'
+                    },
+                },
+                'bonds': {
+                    'bond0': {
+                        'interfaces': ['eth0', 'eth1'],
+                        'mtu': 1500
+                    },
+                },
+            }
+        }
+        self.expectThat(netplan, Equals(expected_netplan))
+
+    def test__bridge(self):
+        node = factory.make_Node()
+        eth0 = factory.make_Interface(
+            node=node, name='eth0', mac_address="00:01:02:03:04:05")
+        eth1 = factory.make_Interface(
+            node=node, name='eth1', mac_address="02:01:02:03:04:05")
+        factory.make_Interface(
+            INTERFACE_TYPE.BRIDGE,
+            node=node, name='br0', parents=[eth0, eth1])
+        netplan = self._render_netplan_dict(node)
+        expected_netplan = {
+            'network': {
+                'version': 2,
+                'ethernets': {
+                    'eth0': {
+                        'match': {'macaddress': '00:01:02:03:04:05'},
+                        'mtu': 1500,
+                        'set-name': 'eth0'
+                    },
+                    'eth1': {
+                        'match': {'macaddress': '02:01:02:03:04:05'},
+                        'mtu': 1500,
+                        'set-name': 'eth1'
+                    },
+                },
+                'bridges': {
+                    'br0': {
+                        'interfaces': ['eth0', 'eth1'],
+                        'mtu': 1500
+                    },
+                },
+            }
+        }
+        self.expectThat(netplan, Equals(expected_netplan))
+
+    def test__bridged_bond(self):
+        node = factory.make_Node()
+        eth0 = factory.make_Interface(
+            node=node, name='eth0', mac_address="00:01:02:03:04:05")
+        eth1 = factory.make_Interface(
+            node=node, name='eth1', mac_address="02:01:02:03:04:05")
+        bond0 = factory.make_Interface(
+            INTERFACE_TYPE.BOND,
+            node=node, name='bond0', parents=[eth0, eth1])
+        factory.make_Interface(
+            INTERFACE_TYPE.BRIDGE,
+            node=node, name='br0', parents=[bond0])
+        netplan = self._render_netplan_dict(node)
+        expected_netplan = {
+            'network': {
+                'version': 2,
+                'ethernets': {
+                    'eth0': {
+                        'match': {'macaddress': '00:01:02:03:04:05'},
+                        'mtu': 1500,
+                        'set-name': 'eth0'
+                    },
+                    'eth1': {
+                        'match': {'macaddress': '02:01:02:03:04:05'},
+                        'mtu': 1500,
+                        'set-name': 'eth1'
+                    },
+                },
+                'bonds': {
+                    'bond0': {
+                        'interfaces': ['eth0', 'eth1'],
+                        'mtu': 1500
+                    },
+                },
+                'bridges': {
+                    'br0': {
+                        'interfaces': ['bond0'],
+                        'mtu': 1500
+                    },
+                },
+            }
+        }
+        self.expectThat(netplan, Equals(expected_netplan))