Merge lp:~ltrager/maas/lp1685361_2.1 into lp:maas/2.1

[Lee Trager]

Fix 00-maas-07-block-devices to run on Trusty.

[Lee Trager (ltrager)]

Approved in https://code.launchpad.net/~ltrager/maas/lp1685361/+merge/322993

review: Approve

=== modified file 'src/provisioningserver/refresh/node_info_scripts.py'
--- src/provisioningserver/refresh/node_info_scripts.py	2017-03-22 21:46:10 +0000
+++ src/provisioningserver/refresh/node_info_scripts.py	2017-04-25 09:25:16 +0000
@@ -294,7 +294,7 @@
     blockdevs = []
     block_list = check_output((
         "lsblk", "--exclude", "1,2,7", "-d", "-P",
-        "-o", "NAME,RO,RM,MODEL,ROTA,MAJ:MIN", "-x", "MAJ:MIN"))
+        "-o", "NAME,RO,RM,MODEL,ROTA,MAJ:MIN"))
     block_list = block_list.decode("utf-8")
     for blockdev in block_list.splitlines():
         tokens = shlex.split(blockdev)
@@ -304,6 +304,13 @@
             current_block[k] = v.strip()
         blockdevs.append(current_block)
 
+    # Sort drives by MAJ:MIN so MAAS picks the correct boot drive.
+    # lsblk -x MAJ:MIN can't be used as the -x flag only appears in
+    # lsblk 2.71.1 or newer which is unavailable on Trusty. See LP:1673724
+    blockdevs = sorted(
+        blockdevs,
+        key=lambda blockdev: [int(i) for i in blockdev['MAJ:MIN'].split(':')])
+
     # Grab the device path, serial number, and sata connection.
     UDEV_MAPPINGS = {
         "DEVNAME": "PATH",
 
=== modified file 'src/provisioningserver/refresh/tests/test_node_info_scripts.py'
--- src/provisioningserver/refresh/tests/test_node_info_scripts.py	2017-03-22 21:46:10 +0000
+++ src/provisioningserver/refresh/tests/test_node_info_scripts.py	2017-04-25 09:25:16 +0000
@@ -5,7 +5,6 @@
 
 __all__ = []
 
-from functools import partial
 from inspect import getsource
 from io import StringIO
 import json
@@ -18,6 +17,7 @@
     check_output,
     STDOUT,
 )
+import sys
 from textwrap import dedent
 import time
 from unittest.mock import call
@@ -338,16 +338,19 @@
     @typed
     def make_lsblk_output(
             self, name=None, read_only=False, removable=False,
-            model=None, rotary=True) -> bytes:
+            model=None, rotary=True, maj_min=None) -> bytes:
         if name is None:
             name = factory.make_name('name')
         if model is None:
             model = factory.make_name('model')
+        if maj_min is None:
+            maj_min = (random.randint(0, 255), random.randint(0, 255))
         read_only = "1" if read_only else "0"
         removable = "1" if removable else "0"
         rotary = "1" if rotary else "0"
-        output = 'NAME="%s" RO="%s" RM="%s" MODEL="%s" ROTA="%s"' % (
-            name, read_only, removable, model, rotary)
+        output = (
+            'NAME="%s" RO="%s" RM="%s" MODEL="%s" ROTA="%s" MAJ:MIN="%s"' % (
+                name, read_only, removable, model, rotary, '%s:%s' % maj_min))
         return output.encode("ascii")
 
     @typed
@@ -373,21 +376,54 @@
         return output.encode("ascii")
 
     def call_gather_physical_block_devices(
-            self, dev_disk_byid='/dev/disk/by-id/'):
+            self, dev_disk_byid='/dev/disk/by-id/', file_path=None):
         output = StringIO()
-        namespace = {"print": partial(print, file=output)}
+
+        def neutered_print(*args, **kwargs):
+            file = kwargs.pop('file', None)
+            if file is not None and file == sys.stderr:
+                return
+            return print(*args, **kwargs, file=output)
+
+        namespace = {"print": neutered_print}
+        if file_path is not None:
+            namespace['__file__'] = file_path
         gather_physical_block_devices = isolate_function(
             node_info_module.gather_physical_block_devices, namespace)
         gather_physical_block_devices(dev_disk_byid=dev_disk_byid)
         return json.loads(output.getvalue())
 
+    def make_output(
+            self, name, maj_min, model, serial, size, block_size,
+            drive_path=None, device_id_path=None, rotary=True,
+            removable=False, read_only=False, sata=True):
+        if drive_path is None:
+            drive_path = '/dev/%s' % name
+        ret = {
+            'NAME': name,
+            'PATH': drive_path,
+            'MAJ:MIN': '%s:%s' % maj_min,
+            'RO': '1' if read_only else '0',
+            'RM': '1' if removable else '0',
+            'MODEL': model,
+            'ROTA': '1' if rotary else '0',
+            'SATA': '1' if sata else '0',
+            'SERIAL': serial,
+            'SIZE': str(size),
+            'BLOCK_SIZE': str(block_size),
+            'RPM': '5400',
+        }
+        if device_id_path is not None:
+            ret['ID_PATH'] = device_id_path
+        return ret
+
     def test__calls_lsblk(self):
         check_output = self.patch(subprocess, "check_output")
         check_output.return_value = b""
         self.call_gather_physical_block_devices()
         self.assertThat(check_output, MockCalledOnceWith((
             "lsblk", "--exclude", "1,2,7", "-d", "-P",
-            "-o", "NAME,RO,RM,MODEL,ROTA,MAJ:MIN", "-x", "MAJ:MIN")))
+            "-o", "NAME,RO,RM,MODEL,ROTA,MAJ:MIN")))
 
     def test__returns_empty_list_when_no_disks(self):
         check_output = self.patch(subprocess, "check_output")
@@ -407,7 +443,7 @@
         self.assertThat(check_output, MockCallsMatch(
             call((
                 "lsblk", "--exclude", "1,2,7", "-d", "-P",
-                "-o", "NAME,RO,RM,MODEL,ROTA,MAJ:MIN", "-x", "MAJ:MIN")),
+                "-o", "NAME,RO,RM,MODEL,ROTA,MAJ:MIN")),
             call(("udevadm", "info", "-q", "all", "-n", name))))
 
     def test__returns_empty_list_when_cdrom_only(self):
@@ -439,128 +475,52 @@
         self.assertThat(check_output, MockCallsMatch(
             call((
                 "lsblk", "--exclude", "1,2,7", "-d", "-P",
-                "-o", "NAME,RO,RM,MODEL,ROTA,MAJ:MIN", "-x", "MAJ:MIN")),
+                "-o", "NAME,RO,RM,MODEL,ROTA,MAJ:MIN")),
             call(("udevadm", "info", "-q", "all", "-n", name)),
             call(("sudo", "blockdev", "--getsize64", "/dev/%s" % name)),
             call(("sudo", "blockdev", "--getbsz", "/dev/%s" % name))))
 
-    def test__returns_block_device(self):
-        name = factory.make_name('name')
-        model = factory.make_name('model')
-        serial = factory.make_name('serial')
-        size = random.randint(3000 * 1000, 1000 * 1000 * 1000)
-        block_size = random.choice([512, 1024, 4096])
-        check_output = self.patch(subprocess, "check_output")
-
-        # Create simulated /dev tree
-        devroot = self.make_dir()
-        os.mkdir(os.path.join(devroot, 'disk'))
-        byidroot = os.path.join(devroot, 'disk', 'by_id')
-        os.mkdir(byidroot)
-        os.mknod(os.path.join(devroot, name))
-        os.symlink(os.path.join(devroot, name),
-                   os.path.join(byidroot, 'deviceid'))
-
-        check_output.side_effect = [
-            self.make_lsblk_output(name=name, model=model),
-            self.make_udevadm_output(name, serial=serial, dev=devroot),
-            b'%d' % size,
-            b'%d' % block_size,
-            ]
-        self.assertEqual([{
-            "NAME": name,
-            "PATH": os.path.join(devroot, name),
-            "ID_PATH": os.path.join(byidroot, 'deviceid'),
-            "RO": "0",
-            "RM": "0",
-            "MODEL": model,
-            "ROTA": "1",
-            "SATA": "1",
-            "SERIAL": serial,
-            "SIZE": "%s" % size,
-            "BLOCK_SIZE": "%s" % block_size,
-            "RPM": "5400",
-            }], self.call_gather_physical_block_devices(byidroot))
-
-    def test__returns_block_device_with_shortest_byidpath_long_first(self):
-        name = factory.make_name('name')
-        model = factory.make_name('model')
-        serial = factory.make_name('serial')
-        size = random.randint(3000 * 1000, 1000 * 1000 * 1000)
-        block_size = random.choice([512, 1024, 4096])
-        check_output = self.patch(subprocess, "check_output")
-
-        # Create simulated /dev tree
-        devroot = self.make_dir()
-        os.mkdir(os.path.join(devroot, 'disk'))
-        byidroot = os.path.join(devroot, 'disk', 'by_id')
-        os.mkdir(byidroot)
-        os.mknod(os.path.join(devroot, name))
-        os.symlink(os.path.join(devroot, name),
-                   os.path.join(byidroot, 'deviceid-long'))
-        os.symlink(os.path.join(devroot, name),
-                   os.path.join(byidroot, 'deviceid'))
-
-        check_output.side_effect = [
-            self.make_lsblk_output(name=name, model=model),
-            self.make_udevadm_output(name, serial=serial, dev=devroot),
-            b'%d' % size,
-            b'%d' % block_size,
-            ]
-        self.assertEqual([{
-            "NAME": name,
-            "PATH": os.path.join(devroot, name),
-            "ID_PATH": os.path.join(byidroot, 'deviceid'),
-            "RO": "0",
-            "RM": "0",
-            "MODEL": model,
-            "ROTA": "1",
-            "SATA": "1",
-            "SERIAL": serial,
-            "SIZE": "%s" % size,
-            "BLOCK_SIZE": "%s" % block_size,
-            "RPM": "5400",
-            }], self.call_gather_physical_block_devices(byidroot))
-
-    def test__returns_block_device_with_first_byidpath_long_second(self):
-        name = factory.make_name('name')
-        model = factory.make_name('model')
-        serial = factory.make_name('serial')
-        size = random.randint(3000 * 1000, 1000 * 1000 * 1000)
-        block_size = random.choice([512, 1024, 4096])
-        check_output = self.patch(subprocess, "check_output")
-
-        # Create simulated /dev tree
-        devroot = self.make_dir()
-        os.mkdir(os.path.join(devroot, 'disk'))
-        byidroot = os.path.join(devroot, 'disk', 'by_id')
-        os.mkdir(byidroot)
-        os.mknod(os.path.join(devroot, name))
-        os.symlink(os.path.join(devroot, name),
-                   os.path.join(byidroot, 'deviceid'))
-        os.symlink(os.path.join(devroot, name),
-                   os.path.join(byidroot, 'deviceid-longest'))
-
-        check_output.side_effect = [
-            self.make_lsblk_output(name=name, model=model),
-            self.make_udevadm_output(name, serial=serial, dev=devroot),
-            b'%d' % size,
-            b'%d' % block_size,
-            ]
-        self.assertEqual([{
-            "NAME": name,
-            "PATH": os.path.join(devroot, name),
-            "ID_PATH": os.path.join(byidroot, 'deviceid'),
-            "RO": "0",
-            "RM": "0",
-            "MODEL": model,
-            "ROTA": "1",
-            "SATA": "1",
-            "SERIAL": serial,
-            "SIZE": "%s" % size,
-            "BLOCK_SIZE": "%s" % block_size,
-            "RPM": "5400",
-            }], self.call_gather_physical_block_devices(byidroot))
+    def test__returns_sorted_block_devices(self):
+        output = []
+        check_output_side_effects = []
+        # Create simulated /dev tree
+        devroot = self.make_dir()
+        os.mkdir(os.path.join(devroot, 'disk'))
+        byidroot = os.path.join(devroot, 'disk', 'by_id')
+        os.mkdir(byidroot)
+        for _ in range(3):
+            name = factory.make_name('name')
+            model = factory.make_name('model')
+            serial = factory.make_name('serial')
+            size = random.randint(3000 * 1000, 1000 * 1000 * 1000)
+            block_size = random.choice([512, 1024, 4096])
+            maj_min = (random.randint(0, 255), random.randint(0, 255))
+
+            # Create simulated /dev tree
+            drive_path = os.path.join(devroot, name)
+            os.mknod(drive_path)
+            device_id_path = os.path.join(
+                byidroot, factory.make_name('deviceid'))
+            os.symlink(drive_path, device_id_path)
+
+            check_output_side_effects += [
+                self.make_lsblk_output(
+                    name=name, model=model, maj_min=maj_min),
+                self.make_udevadm_output(name, serial=serial, dev=devroot),
+                b'%d' % size,
+                b'%d' % block_size,
+            ]
+            output.append(
+                self.make_output(
+                    name, maj_min, model, serial, size, block_size,
+                    drive_path, device_id_path))
+
+        check_output = self.patch(subprocess, "check_output")
+        check_output.side_effect = check_output_side_effects
+
+        for ref, out in zip(
+                output, self.call_gather_physical_block_devices(byidroot)):
+            self.assertDictEqual(ref, out)
 
     def test__removes_duplicate_block_device_same_serial_and_model(self):
         """Multipath disks get multiple IDs, but same serial/model is same
@@ -570,107 +530,51 @@
         serial = factory.make_name('serial')
         size = random.randint(3000 * 1000, 1000 * 1000 * 1000)
         block_size = random.choice([512, 1024, 4096])
-        check_output = self.patch(subprocess, "check_output")
-
-        name2 = factory.make_name('name')
-
-        # Create simulated /dev tree.
-        devroot = self.make_dir()
-        os.mkdir(os.path.join(devroot, 'disk'))
-        byidroot = os.path.join(devroot, 'disk', 'by_id')
-        os.mkdir(byidroot)
-
-        os.mknod(os.path.join(devroot, name))
-        os.symlink(os.path.join(devroot, name),
-                   os.path.join(byidroot, 'deviceid'))
-
-        os.mknod(os.path.join(devroot, name2))
-        os.symlink(os.path.join(devroot, name2),
-                   os.path.join(byidroot, 'deviceid2'))
-
-        check_output.side_effect = [
-            b"\n".join([
-                self.make_lsblk_output(name=name, model=model),
-                self.make_lsblk_output(name=name2, model=model)]),
-            self.make_udevadm_output(name, serial=serial, dev=devroot),
-            self.make_udevadm_output(name2, serial=serial, dev=devroot),
-            b'%d' % size,
-            b'%d' % block_size,
-            b'%d' % size,
-            b'%d' % block_size,
-        ]
-
-        self.assertEqual([{
-            "NAME": name,
-            "PATH": os.path.join(devroot, name),
-            "ID_PATH": os.path.join(byidroot, 'deviceid'),
-            "RO": "0",
-            "RM": "0",
-            "MODEL": model,
-            "ROTA": "1",
-            "SATA": "1",
-            "SERIAL": serial,
-            "SIZE": "%s" % size,
-            "BLOCK_SIZE": "%s" % block_size,
-            "RPM": "5400",
-            }], self.call_gather_physical_block_devices(byidroot))
-
-    def test__removes_duplicate_block_device_same_serial_blank_model(self):
-        """Multipath disks get multiple IDs, but same serial is same device."""
-        name = factory.make_name('name')
-        model = ""
-        serial = factory.make_name('serial')
-        size = random.randint(3000 * 1000, 1000 * 1000 * 1000)
-        block_size = random.choice([512, 1024, 4096])
-        check_output = self.patch(subprocess, "check_output")
-
-        name2 = factory.make_name('name')
-
-        # Create simulated /dev tree.
-        devroot = self.make_dir()
-        os.mkdir(os.path.join(devroot, 'disk'))
-        byidroot = os.path.join(devroot, 'disk', 'by_id')
-        os.mkdir(byidroot)
-
-        os.mknod(os.path.join(devroot, name))
-        os.symlink(os.path.join(devroot, name),
-                   os.path.join(byidroot, 'deviceid'))
-
-        os.mknod(os.path.join(devroot, name2))
-        os.symlink(os.path.join(devroot, name2),
-                   os.path.join(byidroot, 'deviceid2'))
-
-        check_output.side_effect = [
-            b"\n".join([
-                self.make_lsblk_output(name=name, model=model),
-                self.make_lsblk_output(name=name2, model=model)]),
-            self.make_udevadm_output(name, serial=serial, dev=devroot),
-            self.make_udevadm_output(name2, serial=serial, dev=devroot),
-            b'%d' % size,
-            b'%d' % block_size,
-            b'%d' % size,
-            b'%d' % block_size,
-        ]
-
-        self.assertEqual([{
-            "NAME": name,
-            "PATH": os.path.join(devroot, name),
-            "ID_PATH": os.path.join(byidroot, 'deviceid'),
-            "RO": "0",
-            "RM": "0",
-            "MODEL": model,
-            "ROTA": "1",
-            "SATA": "1",
-            "SERIAL": serial,
-            "SIZE": "%s" % size,
-            "BLOCK_SIZE": "%s" % block_size,
-            "RPM": "5400",
-            }], self.call_gather_physical_block_devices(byidroot))
+        maj_min = (random.randint(0, 255), random.randint(0, 255))
+        check_output = self.patch(subprocess, "check_output")
+
+        name2 = factory.make_name('name')
+
+        # Create simulated /dev tree.
+        devroot = self.make_dir()
+        os.mkdir(os.path.join(devroot, 'disk'))
+        byidroot = os.path.join(devroot, 'disk', 'by_id')
+        os.mkdir(byidroot)
+
+        drive_path = os.path.join(devroot, name)
+        os.mknod(drive_path)
+        device_id_path = os.path.join(byidroot, 'deviceid')
+        os.symlink(os.path.join(devroot, name), device_id_path)
+
+        os.mknod(os.path.join(devroot, name2))
+        device_id_path2 = os.path.join(byidroot, 'deviceid2')
+        os.symlink(os.path.join(devroot, name2), device_id_path2)
+
+        check_output.side_effect = [
+            b"\n".join([
+                self.make_lsblk_output(
+                    name=name, model=model, maj_min=maj_min),
+                self.make_lsblk_output(
+                    name=name2, model=model, maj_min=maj_min)]),
+            self.make_udevadm_output(name, serial=serial, dev=devroot),
+            self.make_udevadm_output(name2, serial=serial, dev=devroot),
+            b'%d' % size,
+            b'%d' % block_size,
+            b'%d' % size,
+            b'%d' % block_size,
+        ]
+
+        self.assertItemsEqual(
+            [self.make_output(
+                name, maj_min, model, serial, size, block_size, drive_path,
+                device_id_path)],
+            self.call_gather_physical_block_devices(byidroot))
 
     def test__keeps_block_device_same_serial_different_model(self):
         """Multipath disks get multiple IDs, but same serial is same device."""
         name = factory.make_name('name')
         model = factory.make_name('model')
+        maj_min = (0, 0)
         serial = factory.make_name('serial')
         size = random.randint(3000 * 1000, 1000 * 1000 * 1000)
         block_size = random.choice([512, 1024, 4096])
@@ -678,6 +582,7 @@
 
         name2 = factory.make_name('name')
         model2 = factory.make_name('model')
+        maj_min2 = (1, 1)
 
         # Create simulated /dev tree.
         devroot = self.make_dir()
@@ -685,18 +590,23 @@
         byidroot = os.path.join(devroot, 'disk', 'by_id')
         os.mkdir(byidroot)
 
-        os.mknod(os.path.join(devroot, name))
-        os.symlink(os.path.join(devroot, name),
-                   os.path.join(byidroot, 'deviceid'))
+        drive_path = os.path.join(devroot, name)
+        os.mknod(drive_path)
+        device_id_path = os.path.join(byidroot, 'deviceid')
+        os.symlink(os.path.join(devroot, name), device_id_path)
 
-        os.mknod(os.path.join(devroot, name2))
-        os.symlink(os.path.join(devroot, name2),
-                   os.path.join(byidroot, 'deviceid2'))
+        drive_path2 = os.path.join(devroot, name2)
+        os.mknod(drive_path2)
+        device_id_path2 = os.path.join(byidroot, 'deviceid2')
+        os.symlink(os.path.join(devroot, name2), device_id_path2)
 
         check_output.side_effect = [
             b"\n".join([
-                self.make_lsblk_output(name=name, model=model),
-                self.make_lsblk_output(name=name2, model=model2)]),
+                self.make_lsblk_output(
+                    name=name, model=model, maj_min=maj_min),
+                self.make_lsblk_output(
+                    name=name2, model=model2, maj_min=maj_min2)
+                ]),
             self.make_udevadm_output(name, serial=serial, dev=devroot),
             self.make_udevadm_output(name2, serial=serial, dev=devroot),
             b'%d' % size,
@@ -705,44 +615,29 @@
             b'%d' % block_size,
         ]
 
-        self.assertEqual([{
-            "NAME": name,
-            "PATH": os.path.join(devroot, name),
-            "ID_PATH": os.path.join(byidroot, 'deviceid'),
-            "RO": "0",
-            "RM": "0",
-            "MODEL": model,
-            "ROTA": "1",
-            "SATA": "1",
-            "SERIAL": serial,
-            "SIZE": "%s" % size,
-            "BLOCK_SIZE": "%s" % block_size,
-            "RPM": "5400",
-        }, {
-            "NAME": name2,
-            "PATH": os.path.join(devroot, name2),
-            "ID_PATH": os.path.join(byidroot, 'deviceid2'),
-            "RO": "0",
-            "RM": "0",
-            "MODEL": model2,
-            "ROTA": "1",
-            "SATA": "1",
-            "SERIAL": serial,
-            "SIZE": "%s" % size,
-            "BLOCK_SIZE": "%s" % block_size,
-            "RPM": "5400",
-        }], self.call_gather_physical_block_devices(byidroot))
+        for ref, out in zip(
+                [
+                    self.make_output(
+                        name, maj_min, model, serial, size, block_size,
+                        drive_path, device_id_path),
+                    self.make_output(
+                        name2, maj_min2, model2, serial, size, block_size,
+                        drive_path2, device_id_path2),
+                ], self.call_gather_physical_block_devices(byidroot)):
+            self.assertDictEqual(ref, out)
 
     def test__keeps_block_device_blank_serial_same_model(self):
         """Multipath disks get multiple IDs, but same serial is same device."""
         name = factory.make_name('name')
         model = factory.make_name('model')
+        maj_min = (0, 0)
         serial = ''
         size = random.randint(3000 * 1000, 1000 * 1000 * 1000)
         block_size = random.choice([512, 1024, 4096])
         check_output = self.patch(subprocess, "check_output")
 
         name2 = factory.make_name('name')
+        maj_min2 = (1, 1)
 
         # Create simulated /dev tree.
         devroot = self.make_dir()
@@ -750,18 +645,22 @@
         byidroot = os.path.join(devroot, 'disk', 'by_id')
         os.mkdir(byidroot)
 
-        os.mknod(os.path.join(devroot, name))
-        os.symlink(os.path.join(devroot, name),
-                   os.path.join(byidroot, 'deviceid'))
+        drive_path = os.path.join(devroot, name)
+        os.mknod(drive_path)
+        device_id_path = os.path.join(byidroot, 'deviceid')
+        os.symlink(os.path.join(devroot, name), device_id_path)
 
-        os.mknod(os.path.join(devroot, name2))
-        os.symlink(os.path.join(devroot, name2),
-                   os.path.join(byidroot, 'deviceid2'))
+        drive_path2 = os.path.join(devroot, name2)
+        os.mknod(drive_path2)
+        device_id_path2 = os.path.join(byidroot, 'deviceid2')
+        os.symlink(os.path.join(devroot, name2), device_id_path2)
 
         check_output.side_effect = [
             b"\n".join([
-                self.make_lsblk_output(name=name, model=model),
-                self.make_lsblk_output(name=name2, model=model)]),
+                self.make_lsblk_output(
+                    name=name, model=model, maj_min=maj_min),
+                self.make_lsblk_output(
+                    name=name2, model=model, maj_min=maj_min2)]),
             self.make_udevadm_output(name, serial=serial, dev=devroot),
             self.make_udevadm_output(name2, serial=serial, dev=devroot),
             b'%d' % size,
@@ -770,38 +669,22 @@
             b'%d' % block_size,
         ]
 
-        self.assertEqual([{
-            "NAME": name,
-            "PATH": os.path.join(devroot, name),
-            "ID_PATH": os.path.join(byidroot, 'deviceid'),
-            "RO": "0",
-            "RM": "0",
-            "MODEL": model,
-            "ROTA": "1",
-            "SATA": "1",
-            "SERIAL": serial,
-            "SIZE": "%s" % size,
-            "BLOCK_SIZE": "%s" % block_size,
-            "RPM": "5400",
-        }, {
-            "NAME": name2,
-            "PATH": os.path.join(devroot, name2),
-            "ID_PATH": os.path.join(byidroot, 'deviceid2'),
-            "RO": "0",
-            "RM": "0",
-            "MODEL": model,
-            "ROTA": "1",
-            "SATA": "1",
-            "SERIAL": serial,
-            "SIZE": "%s" % size,
-            "BLOCK_SIZE": "%s" % block_size,
-            "RPM": "5400",
-        }], self.call_gather_physical_block_devices(byidroot))
+        for ref, out in zip(
+                [
+                    self.make_output(
+                        name, maj_min, model, serial, size, block_size,
+                        drive_path, device_id_path),
+                    self.make_output(
+                        name2, maj_min2, model, serial, size, block_size,
+                        drive_path2, device_id_path2),
+                ], self.call_gather_physical_block_devices(byidroot)):
+            self.assertDictEqual(ref, out)
 
     def test__returns_block_device_without_id_path(self):
         """Block devices without by-id links should not have ID_PATH key"""
         name = factory.make_name('name')
         model = factory.make_name('model')
+        maj_min = (random.randint(0, 255), random.randint(0, 255))
         serial = factory.make_name('serial')
         size = random.randint(3000 * 1000, 1000 * 1000 * 1000)
         block_size = random.choice([512, 1024, 4096])
@@ -812,158 +695,113 @@
         os.mkdir(os.path.join(devroot, 'disk'))
         byidroot = os.path.join(devroot, 'disk', 'by_id')
         os.mkdir(byidroot)
-        os.mknod(os.path.join(devroot, name))
+        drive_path = os.path.join(devroot, name)
+        os.mknod(drive_path)
 
         check_output.side_effect = [
-            self.make_lsblk_output(name=name, model=model),
+            self.make_lsblk_output(name=name, model=model, maj_min=maj_min),
             self.make_udevadm_output(name, serial=serial, dev=devroot),
             b'%d' % size,
             b'%d' % block_size,
             ]
-        self.assertEqual([{
-            "NAME": name,
-            "PATH": os.path.join(devroot, name),
-            "RO": "0",
-            "RM": "0",
-            "MODEL": model,
-            "ROTA": "1",
-            "SATA": "1",
-            "SERIAL": serial,
-            "SIZE": "%s" % size,
-            "BLOCK_SIZE": "%s" % block_size,
-            "RPM": "5400",
-            }], self.call_gather_physical_block_devices(byidroot))
+        for ref, out in zip(
+                [
+                    self.make_output(
+                        name, maj_min, model, serial, size, block_size,
+                        drive_path),
+                ], self.call_gather_physical_block_devices(byidroot)):
+            self.assertDictEqual(ref, out)
 
     def test__returns_block_device_readonly(self):
         name = factory.make_name('name')
         model = factory.make_name('model')
+        maj_min = (random.randint(0, 255), random.randint(0, 255))
         serial = factory.make_name('serial')
         size = random.randint(3000 * 1000, 1000 * 1000 * 1000)
         block_size = random.choice([512, 1024, 4096])
         check_output = self.patch(subprocess, "check_output")
         check_output.side_effect = [
-            self.make_lsblk_output(name=name, model=model, read_only=True),
+            self.make_lsblk_output(
+                name=name, model=model, read_only=True, maj_min=maj_min),
             self.make_udevadm_output(name, serial=serial),
             b'%d' % size,
             b'%d' % block_size,
             ]
-        self.assertEqual([{
-            "NAME": name,
-            "PATH": "/dev/%s" % name,
-            "RO": "1",
-            "RM": "0",
-            "MODEL": model,
-            "ROTA": "1",
-            "SATA": "1",
-            "SERIAL": serial,
-            "SIZE": "%s" % size,
-            "BLOCK_SIZE": "%s" % block_size,
-            "RPM": "5400",
-            }], self.call_gather_physical_block_devices())
+        for ref, out in zip(
+                [
+                    self.make_output(
+                        name, maj_min, model, serial, size,
+                        block_size, read_only=True),
+                ], self.call_gather_physical_block_devices()):
+            self.assertDictEqual(ref, out)
 
     def test__returns_block_device_ssd(self):
         name = factory.make_name('name')
         model = factory.make_name('model')
+        maj_min = (random.randint(0, 255), random.randint(0, 255))
         serial = factory.make_name('serial')
         size = random.randint(3000 * 1000, 1000 * 1000 * 1000)
         block_size = random.choice([512, 1024, 4096])
         check_output = self.patch(subprocess, "check_output")
         check_output.side_effect = [
-            self.make_lsblk_output(name=name, model=model, rotary=False),
+            self.make_lsblk_output(
+                name=name, model=model, rotary=False, maj_min=maj_min),
             self.make_udevadm_output(name, serial=serial),
             b'%d' % size,
             b'%d' % block_size,
             ]
-        self.assertEqual([{
-            "NAME": name,
-            "PATH": "/dev/%s" % name,
-            "RO": "0",
-            "RM": "0",
-            "MODEL": model,
-            "ROTA": "0",
-            "SATA": "1",
-            "SERIAL": serial,
-            "SIZE": "%s" % size,
-            "BLOCK_SIZE": "%s" % block_size,
-            "RPM": "5400",
-            }], self.call_gather_physical_block_devices())
+        for ref, out in zip(
+                [
+                    self.make_output(
+                        name, maj_min, model, serial, size, block_size,
+                        rotary=False),
+                ], self.call_gather_physical_block_devices()):
+            self.assertDictEqual(ref, out)
 
     def test__returns_block_device_not_sata(self):
         name = factory.make_name('name')
         model = factory.make_name('model')
+        maj_min = (random.randint(0, 255), random.randint(0, 255))
         serial = factory.make_name('serial')
         size = random.randint(3000 * 1000, 1000 * 1000 * 1000)
         block_size = random.choice([512, 1024, 4096])
         check_output = self.patch(subprocess, "check_output")
         check_output.side_effect = [
-            self.make_lsblk_output(name=name, model=model),
+            self.make_lsblk_output(name=name, model=model, maj_min=maj_min),
             self.make_udevadm_output(name, serial=serial, sata=False),
             b'%d' % size,
             b'%d' % block_size,
             ]
-        self.assertEqual([{
-            "NAME": name,
-            "PATH": "/dev/%s" % name,
-            "RO": "0",
-            "RM": "0",
-            "MODEL": model,
-            "ROTA": "1",
-            "SATA": "0",
-            "SERIAL": serial,
-            "SIZE": "%s" % size,
-            "BLOCK_SIZE": "%s" % block_size,
-            "RPM": "5400",
-            }], self.call_gather_physical_block_devices())
+        for ref, out in zip(
+                [
+                    self.make_output(
+                        name, maj_min, model, serial, size, block_size,
+                        sata=False),
+                ], self.call_gather_physical_block_devices()):
+            self.assertDictEqual(ref, out)
 
     def test__returns_block_device_removable(self):
         name = factory.make_name('name')
         model = factory.make_name('model')
+        maj_min = (random.randint(0, 255), random.randint(0, 255))
         serial = factory.make_name('serial')
         size = random.randint(3000 * 1000, 1000 * 1000 * 1000)
         block_size = random.choice([512, 1024, 4096])
         check_output = self.patch(subprocess, "check_output")
         check_output.side_effect = [
-            self.make_lsblk_output(name=name, model=model, removable=True),
+            self.make_lsblk_output(
+                name=name, model=model, removable=True, maj_min=maj_min),
             self.make_udevadm_output(name, serial=serial),
             b'%d' % size,
             b'%d' % block_size,
             ]
-        self.assertEqual([{
-            "NAME": name,
-            "PATH": "/dev/%s" % name,
-            "RO": "0",
-            "RM": "1",
-            "MODEL": model,
-            "ROTA": "1",
-            "SATA": "1",
-            "SERIAL": serial,
-            "SIZE": "%s" % size,
-            "BLOCK_SIZE": "%s" % block_size,
-            "RPM": "5400",
-            }], self.call_gather_physical_block_devices())
-
-    def test__returns_multiple_block_devices_in_order(self):
-        names = [factory.make_name('name') for _ in range(3)]
-        lsblk = [
-            self.make_lsblk_output(name=name)
-            for name in names
-            ]
-        call_outputs = []
-        call_outputs.append(b"\n".join(lsblk))
-        for name in names:
-            call_outputs.append(self.make_udevadm_output(name))
-        for name in names:
-            call_outputs.append(
-                b"%d" % random.randint(1000 * 1000, 1000 * 1000 * 1000))
-            call_outputs.append(
-                b"%d" % random.choice([512, 1024, 4096]))
-        check_output = self.patch(subprocess, "check_output")
-        check_output.side_effect = call_outputs
-        device_names = [
-            block_info['NAME']
-            for block_info in self.call_gather_physical_block_devices()
-            ]
-        self.assertEqual(names, device_names)
+        for ref, out in zip(
+                [
+                    self.make_output(
+                        name, maj_min, model, serial, size, block_size,
+                        removable=True),
+                ], self.call_gather_physical_block_devices()):
+            self.assertDictEqual(ref, out)
 
 
 class TestVirtualityScript(MAASTestCase):