Merge lp:~jderose/dmedia/drives-plus into lp:dmedia

[Jason Gerard DeRose]

For background, please see this bug:
https://bugs.launchpad.net/dmedia/+bug/1247699

Despite a fairly large diff, there is no functionality change here. This is simply a cleanup and refactoring in order to make it easier to write unit tests, plus providing said unit tests.

Currently the only two consumers of the `dmedia.drives` module are the `dmedia-provision-drive` script and the `dmedia-service` script.

[David Jordan (dmj726)]

looks fine

review: Approve

=== modified file 'dmedia-provision-drive'
--- dmedia-provision-drive	2013-08-04 14:03:47 +0000
+++ dmedia-provision-drive	2013-11-04 01:28:24 +0000
@@ -44,11 +44,12 @@
 
 import argparse
 import os
+import tempfile
 
 from filestore import _dumps
 from dbase32 import random_id, isdb32
 
-from dmedia.drives import Drive, VALID_DRIVE
+from dmedia.drives import Drive, Devices, VALID_DRIVE
 
 
 parser = argparse.ArgumentParser()
@@ -90,7 +91,14 @@
 
 if os.getuid() != 0:
     raise SystemExit('Error: must be run as root')
+
 drive = Drive(args.dev)
-doc = drive.provision(args.label, args.id)
-print(_dumps(doc))
-
+partition = drive.provision(args.label, args.id)
+devices = Devices()
+info = devices.get_partition_info(partition.dev)
+tmpdir = tempfile.mkdtemp(prefix='dmedia.')
+try:
+    doc = partition.create_filestore(tmpdir, args.id, 1, **info)
+    print(_dumps(doc))
+finally:
+    os.rmdir(tmpdir)

=== modified file 'dmedia-service'
--- dmedia-service	2013-10-29 03:31:24 +0000
+++ dmedia-service	2013-11-04 01:28:24 +0000
@@ -51,7 +51,7 @@
 from dmedia.service.background import Snapshots, LazyAccess, Downloads
 from dmedia.service.avahi import Avahi
 from dmedia.service.peers import Browser, Publisher
-from dmedia.drives import get_parentdir_info
+from dmedia.drives import Devices
 
 
 BUS = dmedia.BUS
@@ -60,6 +60,7 @@
 session = dbus.SessionBus()
 mainloop = GLib.MainLoop()
 VolumeMonitor = Gio.VolumeMonitor.get()
+devices = Devices()
 
 
 def on_sighup(signum, frame):
@@ -206,7 +207,7 @@
             if isfilestore(self.couch.basedir):
                 self.core.connect_filestore(self.couch.basedir)
             else:
-                info = get_parentdir_info(self.couch.basedir)
+                info = devices.get_parentdir_info(self.couch.basedir)
                 self.core.create_filestore(self.couch.basedir, **info)
         VolumeMonitor.connect('mount-added', self.on_mount_added)
         VolumeMonitor.connect('mount-pre-unmount', self.on_mount_pre_unmount)

=== modified file 'dmedia/drives.py'
--- dmedia/drives.py	2013-11-02 19:06:33 +0000
+++ dmedia/drives.py	2013-11-04 01:28:24 +0000
@@ -24,10 +24,9 @@
 """
 
 from uuid import UUID
-from subprocess import check_call, check_output
+import subprocess
 import re
 import time
-import tempfile
 import os
 from os import path
 
@@ -38,9 +37,20 @@
 from .units import bytes10
 
 
-udev_client = GUdev.Client.new(['block'])
 VALID_DRIVE = re.compile('^/dev/[sv]d[a-z]$')
-VALID_PARTITION = re.compile('^/dev/[sv]d[a-z][1-9]$')
+VALID_PARTITION = re.compile('^(/dev/[sv]d[a-z])([1-9])$')
+
+
+def check_drive_dev(dev):
+    if not VALID_DRIVE.match(dev):
+        raise ValueError('Invalid drive device file: {!r}'.format(dev))
+    return dev
+
+
+def check_partition_dev(dev):
+    if not VALID_PARTITION.match(dev):
+        raise ValueError('Invalid partition device file: {!r}'.format(dev))
+    return dev
 
 
 def db32_to_uuid(store_id):
@@ -91,17 +101,6 @@
     return string.replace('\\x20', ' ').strip()
 
 
-class NoSuchDevice(Exception):
-    pass
-
-
-def get_device(dev):
-    device = udev_client.query_by_device_file(dev)
-    if device is None:
-        raise NoSuchDevice('No such device: {!r}'.format(dev))  
-    return device
-
-
 def get_drive_info(device):
     physical = device.get_sysfs_attr_as_uint64('queue/physical_block_size')
     logical = device.get_sysfs_attr_as_uint64('queue/logical_block_size')
@@ -110,15 +109,20 @@
     return {
         'drive_block_physical': physical,
         'drive_block_logical': logical,
+        'drive_alignment_offset': device.get_sysfs_attr_as_int('alignment_offset'),
+        'drive_discard_alignment': device.get_sysfs_attr_as_int('discard_alignment'),
         'drive_bytes': drive_bytes,
         'drive_size': bytes10(drive_bytes),
-        'drive_model': device.get_property('ID_MODEL'),
+        'drive_model': unfuck(device.get_property('ID_MODEL_ENC')),
         'drive_model_id': device.get_property('ID_MODEL_ID'),
         'drive_revision': device.get_property('ID_REVISION'),
         'drive_serial': device.get_property('ID_SERIAL_SHORT'),
         'drive_wwn': device.get_property('ID_WWN_WITH_EXTENSION'),
-        'drive_vendor': device.get_property('ID_VENDOR'),
+        'drive_vendor': unfuck(device.get_property('ID_VENDOR_ENC')),
+        'drive_vendor_id': device.get_property('ID_VENDOR_ID'),
         'drive_removable': bool(device.get_sysfs_attr_as_int('removable')),
+        'drive_bus': device.get_property('ID_BUS'),
+        'drive_rpm': device.get_property('ID_ATA_ROTATION_RATE_RPM'),
     }
 
 
@@ -151,8 +155,8 @@
         'partition_scheme': device.get_property('ID_PART_ENTRY_SCHEME'),
         'partition_number': device.get_property_as_int('ID_PART_ENTRY_NUMBER'),
         'partition_bytes': part_bytes,
+        'partition_start_bytes': part_start_sector * logical,
         'partition_size': bytes10(part_bytes),
-        'partition_start_bytes': part_start_sector * logical,
 
         'filesystem_type': device.get_property('ID_FS_TYPE'),
         'filesystem_uuid': device.get_property('ID_FS_UUID'),
@@ -169,22 +173,68 @@
     raise ValueError('Could not find disk size with unit=MiB')
 
 
-class Drive:
-    def __init__(self, dev):
-        if not VALID_DRIVE.match(dev):
-            raise ValueError('Invalid drive device file: {!r}'.format(dev))
-        self.dev = dev
+def parse_mounts(procdir='/proc'):
+    text = open(path.join(procdir, 'mounts'), 'r').read()
+    mounts = {}
+    for line in text.splitlines():
+        (dev, mount, type_, options, dump, pass_) = line.split()
+        mounts[mount.replace('\\040', ' ')] = dev
+    return mounts
+
+
+class Mockable:
+    """
+    Mock calls to `subprocess.check_call()`, `subprocess.check_output()`.
+    """
+
+    def __init__(self, mocking=False):
+        assert isinstance(mocking, bool)
+        self.mocking = mocking
+        self.calls = []
+        self.outputs = []
+
+    def reset(self, mocking=False, outputs=None):
+        assert isinstance(mocking, bool)
+        self.mocking = mocking
+        self.calls.clear()
+        self.outputs.clear()
+        if outputs:
+            assert mocking is True
+            for value in outputs:
+                assert isinstance(value, bytes)
+                self.outputs.append(value)
+
+    def check_call(self, cmd):
+        assert isinstance(cmd, list)
+        if self.mocking:
+            self.calls.append(('check_call', cmd))
+        else:
+            subprocess.check_call(cmd)
+
+    def check_output(self, cmd):
+        assert isinstance(cmd, list)
+        if self.mocking:
+            self.calls.append(('check_output', cmd))
+            return self.outputs.pop(0)
+        else:
+            return subprocess.check_output(cmd)
+
+
+class Drive(Mockable):
+    def __init__(self, dev, mocking=False):
+        super().__init__(mocking)
+        self.dev = check_drive_dev(dev)
 
     def get_partition(self, index):
         assert isinstance(index, int)
         assert index >= 1
-        return Partition('{}{}'.format(self.dev, index))
+        return Partition('{}{}'.format(self.dev, index), mocking=self.mocking)
 
     def rereadpt(self):
-        check_call(['blockdev', '--rereadpt', self.dev])
+        self.check_call(['blockdev', '--rereadpt', self.dev])
 
     def zero(self):
-        check_call(['dd',
+        self.check_call(['dd',
             'if=/dev/zero',
             'of={}'.format(self.dev),
             'bs=4M',
@@ -201,37 +251,34 @@
         return cmd
 
     def mklabel(self):
-        check_call(self.parted('mklabel', 'gpt'))
+        self.check_call(self.parted('mklabel', 'gpt'))
 
     def print(self):
         cmd = self.parted('print')
-        return check_output(cmd).decode('utf-8')
+        return self.check_output(cmd).decode('utf-8')
 
     def init_partition_table(self):
         self.rereadpt()  # Make sure existing partitions aren't mounted
         self.zero()
-        time.sleep(2)
+        time.sleep(1)
         self.rereadpt()
         self.mklabel()
-
-        text = self.print()
-        print(text)
-        self.size = parse_drive_size(text)
+        self.size = parse_drive_size(self.print())
         self.index = 0
         self.start = 1
         self.stop = self.size - 1
         assert self.start < self.stop
 
-    @property
-    def remaining(self):
-        return self.stop - self.start
-
     def mkpart(self, start, stop):
         assert isinstance(start, int)
         assert isinstance(stop, int)
         assert 1 <= start < stop <= self.stop
         cmd = self.parted('mkpart', 'primary', 'ext2', str(start), str(stop))
-        check_call(cmd)
+        self.check_call(cmd)
+
+    @property
+    def remaining(self):
+        return self.stop - self.start
 
     def add_partition(self, size):
         assert isinstance(size, int)
@@ -246,19 +293,14 @@
         self.init_partition_table()
         partition = self.add_partition(self.remaining)
         partition.mkfs_ext4(label, store_id)
-        time.sleep(2)
-        doc = partition.create_filestore(store_id)
-        return doc
-
-
-class Partition:
-    def __init__(self, dev):
-        if not VALID_PARTITION.match(dev):
-            raise ValueError('Invalid partition device file: {!r}'.format(dev))
-        self.dev = dev
-
-    def get_info(self):
-        return get_partition_info(get_device(self.dev))
+        time.sleep(1)
+        return partition
+
+
+class Partition(Mockable):
+    def __init__(self, dev, mocking=False):
+        super().__init__(mocking)
+        self.dev = check_partition_dev(dev)
 
     def mkfs_ext4(self, label, store_id):
         cmd = ['mkfs.ext4', self.dev,
@@ -266,97 +308,101 @@
             '-U', db32_to_uuid(store_id),
             '-m', '0',  # 0% reserved blocks
         ]
-        check_call(cmd)
+        self.check_call(cmd)
 
-    def create_filestore(self, store_id, copies=1):
-        kw = self.get_info()
-        tmpdir = tempfile.mkdtemp(prefix='dmedia.')
+    def create_filestore(self, mount, store_id=None, copies=1, **kw):
         fs = None
-        check_call(['mount', self.dev, tmpdir])
+        self.check_call(['mount', self.dev, mount])
         try:
-            fs = FileStore.create(tmpdir, store_id, 1, **kw)
-            check_call(['chmod', '0777', tmpdir])
+            fs = FileStore.create(mount, store_id, copies, **kw)
+            self.check_call(['chmod', '0777', mount])
             return fs.doc
         finally:
             del fs
-            check_call(['umount', tmpdir])
-            os.rmdir(tmpdir)
+            self.check_call(['umount', self.dev])
+
+
+class DeviceNotFound(Exception):
+    def __init__(self, dev):
+        self.dev = dev
+        super().__init__('No such device: {!r}'.format(dev))
 
 
 class Devices:
+    """
+    Gather disk and partition info using udev.
+    """
+
     def __init__(self):
-        self.client = GUdev.Client.new(['block'])
-        self.partitions = {}
-
-    def run(self):
-        self.client.connect('uevent', self.on_uevent)
-        for device in self.client.query_by_subsystem('block'):
-            self.on_uevent(None, 'add', device)
-
-    def on_uevent(self, client, action, device):
-        _type = device.get_devtype()
-        dev = device.get_device_file()
-        if _type == 'partition':
-            print(action, _type, dev)
-            if action == 'add':
-                self.add_partition(device)
-            elif action == 'remove':
-                self.remove_partition(device)
-
-    def add_partition(self, device):
-        dev = device.get_device_file()
-        print('add_partition({!r})'.format(dev))
-
-    def remove_partition(self, device):
-        dev = device.get_device_file()
-        print('add_partition({!r})'.format(dev))
-
-
-def parse_mounts(procdir='/proc'):
-    text = open(path.join(procdir, 'mounts'), 'r').read()
-    mounts = {}
-    for line in text.splitlines():
-        (dev, mount, type_, options, dump, pass_) = line.split()
-        mounts[mount.replace('\\040', ' ')] = dev
-    return mounts
-
-
-def get_homedir_info(homedir):
-    mounts = parse_mounts()
-    mountdir = homedir
-    while True:
-        if mountdir in mounts:
-            try:
-                device = get_device(mounts[mountdir])
-                return get_partition_info(device)
-            except NoSuchDevice:
-                pass
-        if mountdir == '/':
-            return {}
-        mountdir = path.dirname(mountdir)
-
-
-def get_parentdir_info(parentdir):
-    mounts = parse_mounts()
-    mountdir = parentdir
-    while True:
-        if mountdir in mounts:
-            try:
-                device = get_device(mounts[mountdir])
-                return get_partition_info(device)
-            except NoSuchDevice:
-                pass
-        if mountdir == '/':
-            return {}
-        mountdir = path.dirname(mountdir)
-
-
-def get_mountdir_info(mountdir):
-    mounts = parse_mounts()
-    if mountdir in mounts:
-        try:
-            device = get_device(mounts[mountdir])
-            return get_partition_info(device)
-        except NoSuchDevice:
-            pass
-    return {}
+        self.udev_client = self.get_udev_client()
+
+    def get_udev_client(self):
+        """
+        Making this easy to override for mocking purposes.
+        """
+        return GUdev.Client.new(['block'])
+
+    def get_device(self, dev):
+        """
+        Get a device object by its dev path (eg, ``'/dev/sda'``).
+        """
+        device = self.udev_client.query_by_device_file(dev)
+        if device is None:
+            raise DeviceNotFound(dev)
+        return device
+
+    def get_drive_info(self, dev):
+        device = self.get_device(check_drive_dev(dev))
+        return get_drive_info(device)
+
+    def get_partition_info(self, dev):
+        device = self.get_device(check_partition_dev(dev))
+        return get_partition_info(device)
+
+    def iter_drives(self):
+        for device in self.udev_client.query_by_subsystem('block'):
+            if device.get_devtype() != 'disk':
+                continue
+            if VALID_DRIVE.match(device.get_device_file()):
+                yield device
+
+    def iter_partitions(self):
+        for device in self.udev_client.query_by_subsystem('block'):
+            if device.get_devtype() != 'partition':
+                continue
+            if VALID_PARTITION.match(device.get_device_file()):
+                yield device
+
+    def get_parentdir_info(self, parentdir):
+        assert path.abspath(parentdir) == parentdir
+        mounts = parse_mounts()
+        mountdir = parentdir
+        while True:
+            if mountdir in mounts:
+                try:
+                    device = self.get_device(mounts[mountdir])
+                    return get_partition_info(device)
+                except DeviceNotFound:
+                    pass
+            if mountdir == '/':
+                return {}
+            mountdir = path.dirname(mountdir)
+
+    def get_info(self):
+        return {
+            'drives': dict(
+                (drive.get_device_file(), get_drive_info(drive))
+                for drive in self.iter_drives()
+            ),
+            'partitions': dict(
+                (partition.get_device_file(), get_drive_info(partition))
+                for partition in self.iter_partitions()
+            ),
+        }
+
+
+if __name__ == '__main__':
+    d = Devices()
+    print(_dumps(d.get_info()))
+    print(_dumps(parse_mounts()))
+    print(_dumps(d.get_parentdir_info('/')))

=== modified file 'dmedia/tests/test_drives.py'
--- dmedia/tests/test_drives.py	2013-07-21 20:04:46 +0000
+++ dmedia/tests/test_drives.py	2013-11-04 01:28:24 +0000
@@ -26,12 +26,21 @@
 from unittest import TestCase
 import uuid
 import os
-
-from dbase32 import db32enc
-
+import string
+import re
+import subprocess
+from random import SystemRandom
+
+from filestore import FileStore
+from dbase32 import db32enc, random_id
+from gi.repository import GUdev
+
+from .base import TempDir
 from dmedia import drives
 
 
+random = SystemRandom()
+
 PARTED_PRINT = """
 Model: ATA WDC WD30EZRX-00D (scsi)
 Disk /dev/sdd: 2861588MiB
@@ -42,6 +51,76 @@
  1      1.00MiB  2861587MiB  2861586MiB  ext4         primary
 """
 
+EXPECTED_DRIVE_KEYS = (
+    'drive_block_physical',
+    'drive_block_logical',
+    'drive_alignment_offset',
+    'drive_discard_alignment',
+    'drive_bytes',
+    'drive_size',
+    'drive_model',
+    'drive_model_id',
+    'drive_revision',
+    'drive_serial',
+    'drive_wwn',
+    'drive_vendor',
+    'drive_vendor_id',
+    'drive_removable',
+    'drive_bus',
+    'drive_rpm',
+)
+
+EXPECTED_PARTITION_KEYS = EXPECTED_DRIVE_KEYS + (
+    'partition_scheme',
+    'partition_number',
+    'partition_bytes',
+    'partition_start_bytes',
+    'partition_size',
+    'partition_size',
+    'filesystem_type',
+    'filesystem_uuid',
+    'filesystem_label',
+)
+
+
+def random_drive_dev():
+    base = random.choice(['/dev/sd', '/dev/vd'])
+    letter = random.choice(string.ascii_lowercase)
+    dev = '{}{}'.format(base, letter)
+    assert drives.VALID_DRIVE.match(dev)
+    return dev
+
+
+def random_partition_dev():
+    drive_dev = random_drive_dev()
+    number = random.randint(1, 9)
+    dev = '{}{:d}'.format(drive_dev, number)
+    assert drives.VALID_PARTITION.match(dev)
+    return dev
+
+
+class TestConstants(TestCase):
+    def test_VALID_DRIVE(self):
+        self.assertIsInstance(drives.VALID_DRIVE, re._pattern_type)
+        for base in ('/dev/sd', '/dev/vd'):
+            for letter in string.ascii_lowercase:
+                dev = base + letter
+                m = drives.VALID_DRIVE.match(dev)
+                self.assertIsNotNone(m)
+                self.assertEqual(m.group(0), dev)
+
+    def test_VALID_PARTITION(self):
+        self.assertIsInstance(drives.VALID_PARTITION, re._pattern_type)
+        for base in ('/dev/sd', '/dev/vd'):
+            for letter in string.ascii_lowercase:
+                for number in range(1, 10):
+                    dev = '{}{}{:d}'.format(base, letter, number)
+                    m = drives.VALID_PARTITION.match(dev)
+                    self.assertIsNotNone(m)
+                    self.assertEqual(m.group(0), dev)
+                    self.assertEqual(m.group(1), base + letter)
+                    self.assertEqual(m.group(2), str(number))
+
 
 class TestFunctions(TestCase):
     def test_db32_to_uuid(self):
@@ -60,7 +139,7 @@
                 drives.uuid_to_db32(str(uuid.UUID(bytes=data))),
                 db32enc(data[:15])
             )
-            
+
     def test_unfuck(self):
         self.assertIsNone(drives.unfuck(None))
         fucked = 'WDC\\x20WD30EZRX-00DC0B0\\x20\\x20\\x20\\x20\\x20\\x20\\x20\\x20\\x20\\x20\\x20\\x20\\x20\\x20\\x20\\x20\\x20\\x20\\x20\\x20'
@@ -69,12 +148,144 @@
     def test_parse_drive_size(self):
         self.assertEqual(drives.parse_drive_size(PARTED_PRINT), 2861588)
 
+    def test_get_drive_info(self):
+        d = drives.Devices()
+        for device in d.iter_drives():
+            info = drives.get_drive_info(device)
+            self.assertEqual(set(info), set(EXPECTED_DRIVE_KEYS))
+
+    def test_get_partition_info(self):
+        d = drives.Devices()
+        for device in d.iter_partitions():
+            info = drives.get_partition_info(device)
+            self.assertEqual(set(info), set(EXPECTED_PARTITION_KEYS))
+            m = drives.VALID_PARTITION.match(device.get_device_file())
+            self.assertIsNotNone(m)
+            drive_device = d.get_device(m.group(1))
+            sub = dict(
+                (key, info[key]) for key in EXPECTED_DRIVE_KEYS
+            )
+            self.assertEqual(sub, drives.get_drive_info(drive_device))
+
+    def test_parse_mounts(self):
+        mounts = drives.parse_mounts()
+        self.assertIsInstance(mounts, dict)
+        for (key, value) in mounts.items():
+            self.assertIsInstance(key, str)
+            self.assertIsInstance(value, str)
+
+
+class TestMockable(TestCase):
+    def test_init(self):
+        inst = drives.Mockable()
+        self.assertIs(inst.mocking, False)
+        self.assertEqual(inst.calls, [])
+        self.assertEqual(inst.outputs, [])
+
+        inst = drives.Mockable(mocking=True)
+        self.assertIs(inst.mocking, True)
+        self.assertEqual(inst.calls, [])
+        self.assertEqual(inst.outputs, [])
+
+    def test_reset(self):
+        inst = drives.Mockable()
+        calls = inst.calls
+        outputs = inst.outputs
+        self.assertIsNone(inst.reset())
+        self.assertIs(inst.mocking, False)
+        self.assertIs(inst.calls, calls)
+        self.assertEqual(inst.calls, [])
+        self.assertIs(inst.outputs, outputs)
+        self.assertEqual(inst.outputs, [])
+
+        inst = drives.Mockable(mocking=True)
+        calls = inst.calls
+        outputs = inst.outputs
+        inst.calls.extend(
+            [('check_call', ['stuff']), ('check_output', ['junk'])]
+        )
+        inst.outputs.extend([b'foo', b'bar'])
+        self.assertIsNone(inst.reset())
+        self.assertIs(inst.mocking, False)
+        self.assertIs(inst.calls, calls)
+        self.assertEqual(inst.calls, [])
+        self.assertIs(inst.outputs, outputs)
+        self.assertEqual(inst.outputs, [])
+
+        inst = drives.Mockable(mocking=True)
+        calls = inst.calls
+        outputs = inst.outputs
+        inst.calls.extend(
+            [('check_call', ['stuff']), ('check_output', ['junk'])]
+        )
+        inst.outputs.extend([b'foo', b'bar'])
+        self.assertIsNone(inst.reset(mocking=True, outputs=[b'aye', b'bee']))
+        self.assertIs(inst.mocking, True)
+        self.assertIs(inst.calls, calls)
+        self.assertEqual(inst.calls, [])
+        self.assertIs(inst.outputs, outputs)
+        self.assertEqual(inst.outputs, [b'aye', b'bee'])
+
+    def test_check_call(self):
+        inst = drives.Mockable()
+        self.assertIsNone(inst.check_call(['/bin/true']))
+        self.assertEqual(inst.calls, [])
+        self.assertEqual(inst.outputs, [])
+        with self.assertRaises(subprocess.CalledProcessError) as cm:
+            inst.check_call(['/bin/false'])
+        self.assertEqual(cm.exception.cmd, ['/bin/false'])
+        self.assertEqual(cm.exception.returncode, 1)
+        self.assertEqual(inst.calls, [])
+        self.assertEqual(inst.outputs, [])
+
+        inst = drives.Mockable(mocking=True)
+        self.assertIsNone(inst.check_call(['/bin/true']))
+        self.assertEqual(inst.calls, [
+            ('check_call', ['/bin/true']),
+        ])
+        self.assertEqual(inst.outputs, [])
+        self.assertIsNone(inst.check_call(['/bin/false']))
+        self.assertEqual(inst.calls, [
+            ('check_call', ['/bin/true']),
+            ('check_call', ['/bin/false']),
+        ])
+        self.assertEqual(inst.outputs, [])
+
+    def test_check_output(self):
+        inst = drives.Mockable()
+        self.assertEqual(inst.check_output(['/bin/echo', 'foobar']), b'foobar\n')
+        self.assertEqual(inst.calls, [])
+        self.assertEqual(inst.outputs, [])
+        with self.assertRaises(subprocess.CalledProcessError) as cm:
+            inst.check_output(['/bin/false', 'stuff'])
+        self.assertEqual(cm.exception.cmd, ['/bin/false', 'stuff'])
+        self.assertEqual(cm.exception.returncode, 1)
+        self.assertEqual(inst.calls, [])
+        self.assertEqual(inst.outputs, [])
+
+        inst.reset(mocking=True, outputs=[b'foo', b'bar'])
+        self.assertEqual(inst.check_output(['/bin/echo', 'stuff']), b'foo')
+        self.assertEqual(inst.calls, [
+            ('check_output', ['/bin/echo', 'stuff']),
+        ])
+        self.assertEqual(inst.outputs, [b'bar'])
+        self.assertEqual(inst.check_output(['/bin/false', 'stuff']), b'bar')
+        self.assertEqual(inst.calls, [
+            ('check_output', ['/bin/echo', 'stuff']),
+            ('check_output', ['/bin/false', 'stuff']),
+        ])
+        self.assertEqual(inst.outputs, [])
+
 
 class TestDrive(TestCase):
     def test_init(self):
         for dev in ('/dev/sda', '/dev/sdz', '/dev/vda', '/dev/vdz'):
             inst = drives.Drive(dev)
             self.assertIs(inst.dev, dev)
+            self.assertIs(inst.mocking, False)
+            inst = drives.Drive(dev, mocking=True)
+            self.assertIs(inst.dev, dev)
+            self.assertIs(inst.mocking, True)
         with self.assertRaises(ValueError) as cm:
             drives.Drive('/dev/sda1')
         self.assertEqual(str(cm.exception),
@@ -92,31 +303,157 @@
         )
 
     def test_get_partition(self):
-        inst = drives.Drive('/dev/sdb')
-        part = inst.get_partition(1)
-        self.assertIsInstance(part, drives.Partition)
-        self.assertEqual(part.dev, '/dev/sdb1')
-        part = inst.get_partition(2)
-        self.assertIsInstance(part, drives.Partition)
-        self.assertEqual(part.dev, '/dev/sdb2')
-
-        inst = drives.Drive('/dev/vdz')
-        part = inst.get_partition(8)
-        self.assertIsInstance(part, drives.Partition)
-        self.assertEqual(part.dev, '/dev/vdz8')
-        part = inst.get_partition(9)
-        self.assertIsInstance(part, drives.Partition)
-        self.assertEqual(part.dev, '/dev/vdz9')
+        for base in ('/dev/sd', '/dev/vd'):
+            for letter in string.ascii_lowercase:
+                dev = base + letter
+                for number in range(1, 10):
+                    # mocking=True
+                    inst = drives.Drive(dev)
+                    part = inst.get_partition(number)
+                    self.assertIsInstance(part, drives.Partition)
+                    self.assertEqual(part.dev, '{}{:d}'.format(dev, number))
+                    self.assertIs(part.mocking, False)
+                    # mocking=False
+                    inst = drives.Drive(dev, mocking=True)
+                    part = inst.get_partition(number)
+                    self.assertIsInstance(part, drives.Partition)
+                    self.assertEqual(part.dev, '{}{:d}'.format(dev, number))
+                    self.assertIs(part.mocking, True)
+
+    def test_rereadpt(self):
+        dev = random_drive_dev()
+        inst = drives.Drive(dev, mocking=True)
+        self.assertIsNone(inst.rereadpt())
+        self.assertEqual(inst.calls, [
+            ('check_call', ['blockdev', '--rereadpt', dev]),
+        ])
+
+    def test_zero(self):
+        dev = random_drive_dev()
+        inst = drives.Drive(dev, mocking=True)
+        self.assertIsNone(inst.zero())
+        self.assertEqual(inst.calls, [
+            ('check_call', ['dd', 'if=/dev/zero', 'of={}'.format(dev), 'bs=4M', 'count=1', 'oflag=sync']),
+        ])
+
+    def test_parted(self):
+        dev = random_drive_dev()
+        inst = drives.Drive(dev, mocking=True)
+        self.assertEqual(inst.parted(),
+            ['parted', '-s', dev, 'unit', 'MiB']
+        )
+        self.assertEqual(inst.calls, [])
+        self.assertEqual(inst.parted('print'),
+            ['parted', '-s', dev, 'unit', 'MiB', 'print']
+        )
+        self.assertEqual(inst.calls, [])
+        self.assertEqual(inst.parted('mklabel', 'gpt'),
+            ['parted', '-s', dev, 'unit', 'MiB', 'mklabel', 'gpt']
+        )
+        self.assertEqual(inst.calls, [])
+
+    def test_mklabel(self):
+        dev = random_drive_dev()
+        inst = drives.Drive(dev, mocking=True)
+        self.assertIsNone(inst.mklabel())
+        self.assertEqual(inst.calls, [
+            ('check_call',  ['parted', '-s', dev, 'unit', 'MiB', 'mklabel', 'gpt']),
+        ])
+
+    def test_print(self):
+        dev = random_drive_dev()
+        inst = drives.Drive(dev)
+        marker = random_id()
+        inst.reset(mocking=True, outputs=[marker.encode('utf-8')])
+        self.assertEqual(inst.print(), marker)
+        self.assertEqual(inst.calls, [
+            ('check_output',  ['parted', '-s', dev, 'unit', 'MiB', 'print']),
+        ])
+        self.assertEqual(inst.outputs, [])
+
+    def test_init_partition_table(self):
+        dev = random_drive_dev()
+        inst = drives.Drive(dev)
+        inst.reset(mocking=True, outputs=[PARTED_PRINT.encode('utf-8')])
+        self.assertIsNone(inst.init_partition_table())
+        self.assertEqual(inst.calls, [
+            ('check_call', ['blockdev', '--rereadpt', dev]),
+            ('check_call', ['dd', 'if=/dev/zero', 'of={}'.format(dev), 'bs=4M', 'count=1', 'oflag=sync']),
+            ('check_call', ['blockdev', '--rereadpt', dev]),
+            ('check_call',  ['parted', '-s', dev, 'unit', 'MiB', 'mklabel', 'gpt']),
+            ('check_output',  ['parted', '-s', dev, 'unit', 'MiB', 'print']),
+        ])
+        self.assertEqual(inst.outputs, [])
+        self.assertEqual(inst.size, 2861588)
+        self.assertEqual(inst.index, 0)
+        self.assertEqual(inst.start, 1)
+        self.assertEqual(inst.stop, 2861587)
+
+    def test_mkpart(self):
+        dev = random_drive_dev()
+        inst = drives.Drive(dev, mocking=True)
+        inst.start = 1
+        inst.stop = 2861587
+        self.assertIsNone(inst.mkpart(1, 2861587))
+        self.assertEqual(inst.calls, [
+            ('check_call', ['parted', '-s', dev, 'unit', 'MiB', 'mkpart', 'primary', 'ext2', '1', '2861587']),
+        ])
+
+    def test_remaining(self):
+        dev = random_drive_dev()
+        inst = drives.Drive(dev, mocking=True)
+        inst.start = 1
+        inst.stop = 2861587
+        self.assertEqual(inst.remaining, 2861586)
+        inst.start = 12345
+        self.assertEqual(inst.remaining, 2849242)
+        inst.stop = 1861587
+        self.assertEqual(inst.remaining, 1849242)
+        self.assertEqual(inst.calls, [])
+
+    def test_add_partition(self):
+        dev = random_drive_dev()
+        inst = drives.Drive(dev, mocking=True)
+        inst.index = 0
+        inst.start = 1
+        inst.stop = 2861587
+
+        part = inst.add_partition(123456)
+        self.assertIsInstance(part, drives.Partition)
+        self.assertIs(part.mocking, True)
+        self.assertEqual(part.dev, '{}{:d}'.format(dev, 1))
+        self.assertEqual(part.calls, [])
+        self.assertEqual(inst.index, 1)
+        self.assertEqual(inst.calls, [
+            ('check_call', ['parted', '-s', dev, 'unit', 'MiB', 'mkpart', 'primary', 'ext2', '1', '123457']),
+        ])
+        self.assertEqual(inst.remaining, 2738130)
+
+        part = inst.add_partition(2738130)
+        self.assertIsInstance(part, drives.Partition)
+        self.assertIs(part.mocking, True)
+        self.assertEqual(part.dev, '{}{:d}'.format(dev, 2))
+        self.assertEqual(part.calls, [])
+        self.assertEqual(inst.index, 2)
+        self.assertEqual(inst.calls, [
+            ('check_call', ['parted', '-s', dev, 'unit', 'MiB', 'mkpart', 'primary', 'ext2', '1', '123457']),
+            ('check_call', ['parted', '-s', dev, 'unit', 'MiB', 'mkpart', 'primary', 'ext2', '123457', '2861587']),
+        ])
+        self.assertEqual(inst.remaining, 0)
 
 
 class TestPartition(TestCase):
     def test_init(self):
-        for dev in ('/dev/sda1', '/dev/sda9', '/dev/sdz1', '/dev/sdz9'):
-            part = drives.Partition(dev)
-            self.assertIs(part.dev, dev)
-        for dev in ('/dev/vda1', '/dev/vda9', '/dev/vdz1', '/dev/vdz9'):
-            part = drives.Partition(dev)
-            self.assertIs(part.dev, dev)
+        for base in ('/dev/sd', '/dev/vd'):
+            for letter in string.ascii_lowercase:
+                for number in range(1, 10):
+                    dev = '{}{}{:d}'.format(base, letter, number)
+                    inst = drives.Partition(dev)
+                    self.assertIs(inst.dev, dev)
+                    self.assertIs(inst.mocking, False)
+                    inst = drives.Partition(dev, mocking=True)
+                    self.assertIs(inst.dev, dev)
+                    self.assertIs(inst.mocking, True)
 
         with self.assertRaises(ValueError) as cm:
             drives.Partition('/dev/sda11')
@@ -130,3 +467,148 @@
             "Invalid partition device file: '/dev/sda0'"
         )
 
+    def test_mkfs_ext4(self):
+        dev = random_partition_dev()
+        inst = drives.Partition(dev, mocking=True)
+        label = random_id(5)
+        store_id = random_id()
+        ext4_uuid = drives.db32_to_uuid(store_id)
+        self.assertIsNone(inst.mkfs_ext4(label, store_id))
+        self.assertEqual(inst.calls, [
+            ('check_call', ['mkfs.ext4', dev, '-L', label, '-U', ext4_uuid, '-m', '0']),
+        ])
+
+    def test_create_filestore(self):
+        dev = random_partition_dev()
+        inst = drives.Partition(dev, mocking=True)
+        tmp = TempDir()
+        store_id = random_id()
+        ext4_uuid = drives.db32_to_uuid(store_id)
+        label = random_id(5)
+        serial = random_id(10)
+        kw = {
+            'drive_serial': serial,
+            'filesystem_type': 'ext4',
+            'filesystem_uuid': ext4_uuid,
+            'filesystem_label': label,
+        }
+        doc = inst.create_filestore(tmp.dir, store_id, 1, **kw)
+        self.assertIsInstance(doc, dict)
+        self.assertEqual(set(doc), set([
+            '_id',
+            'time',
+            'type',
+            'plugin',
+            'copies',
+            'drive_serial',
+            'filesystem_type',
+            'filesystem_uuid',
+            'filesystem_label',
+        ]))
+        self.assertEqual(doc, {
+            '_id': store_id,
+            'time': doc['time'],
+            'type': 'dmedia/store',
+            'plugin': 'filestore',
+            'copies': 1,
+            'drive_serial': serial,
+            'filesystem_type': 'ext4',
+            'filesystem_uuid': ext4_uuid,
+            'filesystem_label': label,
+        })
+        fs = FileStore(tmp.dir, store_id)
+        self.assertEqual(fs.doc, doc)
+        del fs
+        self.assertEqual(inst.calls, [
+            ('check_call', ['mount', dev, tmp.dir]),
+            ('check_call', ['chmod', '0777', tmp.dir]),
+            ('check_call', ['umount', dev]),
+        ])
+
+
+class TestDeviceNotFound(TestCase):
+    def test_init(self):
+        dev = '/dev/{}'.format(random_id())
+        inst = drives.DeviceNotFound(dev)
+        self.assertIs(inst.dev, dev)
+        self.assertEqual(str(inst), 'No such device: {!r}'.format(dev))
+
+
+class TestDevices(TestCase):
+    def test_init(self):
+        inst = drives.Devices()
+        self.assertIsInstance(inst.udev_client, GUdev.Client)
+
+        marker = random_id()
+
+        class Subclass(drives.Devices):
+            def get_udev_client(self):
+                return marker
+
+        inst = Subclass()
+        self.assertIs(inst.udev_client, marker)
+
+    def test_get_device(self):
+        inst = drives.Devices()
+        dev = '/dev/nopenopenope'
+        with self.assertRaises(drives.DeviceNotFound) as cm:
+            inst.get_device(dev)
+        self.assertIs(cm.exception.dev, dev)
+        self.assertEqual(str(cm.exception),
+            "No such device: '/dev/nopenopenope'"
+        )
+
+    def test_get_drive_info(self):
+        inst = drives.Devices()
+        for device in inst.iter_drives():
+            dev = device.get_device_file()
+            self.assertEqual(
+                inst.get_drive_info(dev),
+                drives.get_drive_info(device),
+            )
+        with self.assertRaises(ValueError) as cm:
+            inst.get_drive_info('/dev/sdaa')
+        self.assertEqual(str(cm.exception),
+            "Invalid drive device file: '/dev/sdaa'"
+        )
+
+    def test_get_partition_info(self):
+        inst = drives.Devices()
+        for device in inst.iter_partitions():
+            dev = device.get_device_file()
+            self.assertEqual(
+                inst.get_partition_info(dev),
+                drives.get_partition_info(device),
+            )
+        with self.assertRaises(ValueError) as cm:
+            inst.get_partition_info('/dev/sda11')
+        self.assertEqual(str(cm.exception),
+            "Invalid partition device file: '/dev/sda11'"
+        )
+
+    def test_iter_drives(self):
+        inst = drives.Devices()
+        for drive in inst.iter_drives():
+            self.assertIsInstance(drive, GUdev.Device)
+            self.assertEqual(drive.get_devtype(), 'disk')
+            self.assertTrue(drives.VALID_DRIVE.match(drive.get_device_file()))
+
+    def test_iter_partitions(self):
+        inst = drives.Devices()
+        for drive in inst.iter_partitions():
+            self.assertIsInstance(drive, GUdev.Device)
+            self.assertEqual(drive.get_devtype(), 'partition')
+            self.assertTrue(drives.VALID_PARTITION.match(drive.get_device_file()))
+
+    def test_get_parentdir_info(self):
+        inst = drives.Devices()
+        info = inst.get_parentdir_info('/')
+        self.assertIsInstance(info, dict)
+        if info != {}:
+            self.assertEqual(set(info), set(EXPECTED_PARTITION_KEYS))
+
+    def test_get_info(self):
+        inst = drives.Devices()
+        info = inst.get_info()
+        self.assertIsInstance(info, dict)
+        self.assertEqual(set(info), set(['drives', 'partitions']))