Merge ~dbungert/curtin:partition-arbitrary-types into curtin:master

[Dan Bungert]

block/v2: allow setting raw partition_type value

To preserve partition types that do not map to known flag values, we
must be able to capture that original type information and carry it
around in the storage config until used.

If we do not do this, preserved partitions get their type normalized to
another value (usually the equivalent of flags 'linux' or 'boot').

[Michael Hudson-Doyle (mwhudson)]

Seems basically fine but

1) needs documentation
2) it should work with gpt partition tables too?
3) is it ok that this only works with v2 configs? (probably...)

[Michael Hudson-Doyle (mwhudson)]

review: Needs Fixing

[Server Team CI bot (server-team-bot)]

PASSED: Continuous integration, rev:e627193eae750d4ccffa63cb344eaa6c254ab532
https://jenkins.ubuntu.com/server/job/curtin-ci/298/
Executed test runs:
    SUCCESS: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=metal-amd64/298/
    SUCCESS: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=metal-arm64/298/
    SUCCESS: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=metal-ppc64el/298/
    SUCCESS: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=metal-s390x/298/

Click here to trigger a rebuild:
https://jenkins.ubuntu.com/server/job/curtin-ci/298//rebuild

review: Approve (continuous-integration)

[Server Team CI bot (server-team-bot)]

PASSED: Continuous integration, rev:e627193eae750d4ccffa63cb344eaa6c254ab532
https://jenkins.ubuntu.com/server/job/curtin-ci/299/
Executed test runs:
    SUCCESS: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=metal-amd64/299/
    SUCCESS: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=metal-arm64/299/
    SUCCESS: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=metal-ppc64el/299/
    SUCCESS: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=metal-s390x/299/

Click here to trigger a rebuild:
https://jenkins.ubuntu.com/server/job/curtin-ci/299//rebuild

review: Approve (continuous-integration)

e0eb292... by Dan Bungert on 2022-04-29

block/v2: raw partition table codes for gpt

ac081b6... by Dan Bungert on 2022-04-29

block/v2: unit tests for partition_type

34d15bc... by Dan Bungert on 2022-04-29

block/v2: docs for partition_type

[Server Team CI bot (server-team-bot)]

PASSED: Continuous integration, rev:34d15bcc4d20899451cad006dc505896f0e24a9c
https://jenkins.ubuntu.com/server/job/curtin-ci/300/
Executed test runs:
    SUCCESS: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=metal-amd64/300/
    SUCCESS: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=metal-arm64/300/
    SUCCESS: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=metal-ppc64el/300/
    SUCCESS: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=metal-s390x/300/

Click here to trigger a rebuild:
https://jenkins.ubuntu.com/server/job/curtin-ci/300//rebuild

review: Approve (continuous-integration)

3d3f901... by Dan Bungert on 2022-04-29

block/v2: preserve disk label id

Windows will report a boot failure if the disk label ID changes and
nothing else.

[Dan Bungert (dbungert)]

> 1) needs documentation
Done. I debated leaving it undocumented on purpose as too obscure of a detail, but this is fine.

2) it should work with gpt partition tables too?
Done.

3) is it ok that this only works with v2 configs? (probably...)
That's my intention.

Also added disk label ID preservation, that's needed.

[Server Team CI bot (server-team-bot)]

PASSED: Continuous integration, rev:3d3f901afea2ffed5d1a105f2cc6d941bf09f052
https://jenkins.ubuntu.com/server/job/curtin-ci/301/
Executed test runs:
    SUCCESS: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=metal-amd64/301/
    SUCCESS: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=metal-arm64/301/
    SUCCESS: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=metal-ppc64el/301/
    SUCCESS: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=metal-s390x/301/

Click here to trigger a rebuild:
https://jenkins.ubuntu.com/server/job/curtin-ci/301//rebuild

review: Approve (continuous-integration)

[Michael Hudson-Doyle (mwhudson)]

Nice, this looks good. Just one question/suggestion but feel free to ignore it.

review: Approve

diff --git a/curtin/block/schemas.py b/curtin/block/schemas.py
index 1834343..92f88d0 100644
--- a/curtin/block/schemas.py
+++ b/curtin/block/schemas.py
@@ -304,6 +304,11 @@ PARTITION = {
                  'enum': ['bios_grub', 'boot', 'extended', 'home', 'linux',
                           'logical', 'lvm', 'mbr', 'prep', 'raid', 'swap',
                           '']},
+        'partition_type': {'type': 'string',
+                           'oneOf': [
+                               {'pattern': r'^0x[0-9a-fA-F]{1,2}$'},
+                               {'$ref': '#/definitions/uuid'},
+                               ]},
         'grub_device': {
             'type': ['boolean', 'integer'],
             'minimum': 0,
diff --git a/curtin/commands/block_meta_v2.py b/curtin/commands/block_meta_v2.py
index a095c8f..b4838f9 100644
--- a/curtin/commands/block_meta_v2.py
+++ b/curtin/commands/block_meta_v2.py
@@ -98,6 +98,7 @@ class SFDiskPartTable:
 
     def __init__(self, sector_bytes):
         self.entries = []
+        self.label_id = None
         self._sector_bytes = sector_bytes
         if ONE_MIB_BYTES % sector_bytes != 0:
             raise Exception(
@@ -112,7 +113,11 @@ class SFDiskPartTable:
         return amount * self._sector_bytes
 
     def render(self):
-        r = ['label: ' + self.label, ''] + [e.render() for e in self.entries]
+        r = ['label: ' + self.label]
+        if self.label_id:
+            r.extend(['label-id: ' + self.label_id])
+        r.extend([''])
+        r.extend([e.render() for e in self.entries])
         return '\n'.join(r)
 
     def apply(self, device):
@@ -150,7 +155,8 @@ class GPTPartTable(SFDiskPartTable):
                 start = self.one_mib_sectors
         size = self.bytes2sectors(action['size'])
         uuid = action.get('uuid')
-        type = FLAG_TO_GUID.get(action.get('flag'))
+        type = action.get('partition_type',
+                          FLAG_TO_GUID.get(action.get('flag')))
         entry = PartTableEntry(number, start, size, type, uuid)
         self.entries.append(entry)
         return entry
@@ -210,7 +216,7 @@ class DOSPartTable(SFDiskPartTable):
                         prev.start + prev.size,
                         self.one_mib_sectors)
         size = self.bytes2sectors(action['size'])
-        type = FLAG_TO_MBR_TYPE.get(flag)
+        type = action.get('partition_type', FLAG_TO_MBR_TYPE.get(flag))
         if flag == 'boot':
             bootable = True
         else:
@@ -364,6 +370,10 @@ def disk_handler_v2(info, storage_config, handlers):
             preserved_offsets.add(entry.start)
         wipes[entry.start] = _wipe_for_action(action)
 
+    # preserve disk label ids
+    if info.get('preserve') and sfdisk_info is not None:
+        table.label_id = sfdisk_info['id']
+
     for kname, nr, offset, size in block.sysfs_partition_data(disk):
         offset_sectors = table.bytes2sectors(offset)
         resize = resizes.get(offset_sectors)
diff --git a/curtin/storage_config.py b/curtin/storage_config.py
index 2ede996..e9e8991 100644
--- a/curtin/storage_config.py
+++ b/curtin/storage_config.py
@@ -800,6 +800,8 @@ class BlockdevParser(ProbertParser):
                 entry['size'] *= 512
 
             ptype = blockdev_data.get('ID_PART_ENTRY_TYPE')
+            if ptype is not None:
+                entry['partition_type'] = ptype
             flag_name, _flag_code = ptable_uuid_to_flag_entry(ptype)
 
             if ptable and ptable.get('label') == 'dos':
diff --git a/doc/topics/storage.rst b/doc/topics/storage.rst
index aa5ad13..bbff909 100644
--- a/doc/topics/storage.rst
+++ b/doc/topics/storage.rst
@@ -431,6 +431,18 @@ partition with the *bios_grub* flag is needed. This partition should be placed
 at the beginning of the disk and should be 1MB in size. It should not contain a
 filesystem or be mounted anywhere on the system.
 
+**partition_type**: *msdos: byte value in 0xnn style; gpt: GUID*
+
+Only applicable to v2 storage configuration.  If both ``partition_type`` and
+``flag`` are set, ``partition_type`` dictates the acutal type.
+
+The ``partition_type`` field allows for setting arbitrary partition type values
+that do not have a matching ``flag``, or cases that are not handled by the
+``flag`` system.  For example, since the *boot* flag results in both setting
+the bootable state for a MSDOS partition table and setting it to type *0xEF*,
+one can override this behavior and achieve a bootable partition of a different
+type by using ``flag``: *boot* and using ``partition_type``.
+
 **preserve**: *true, false*
 
 If the preserve flag is set to true, curtin will verify that the partition
diff --git a/test-requirements.txt b/test-requirements.txt
index f6404c1..1970d03 100644
--- a/test-requirements.txt
+++ b/test-requirements.txt
@@ -3,3 +3,4 @@ mock
 nose
 pyflakes
 coverage
+parameterized
diff --git a/tests/integration/test_block_meta.py b/tests/integration/test_block_meta.py
index 8322062..e542017 100644
--- a/tests/integration/test_block_meta.py
+++ b/tests/integration/test_block_meta.py
@@ -1,12 +1,15 @@
 # This file is part of curtin. See LICENSE file for copyright and license info.
 
-from collections import namedtuple
+import dataclasses
+from dataclasses import dataclass
 import contextlib
 import json
-import sys
-import yaml
 import os
+from parameterized import parameterized
 import re
+import sys
+from typing import Optional
+import yaml
 
 from curtin import block, udev, util
 
@@ -34,7 +37,28 @@ def loop_dev(image, sector_size=512):
         util.subp(['losetup', '--detach', dev])
 
 
-PartData = namedtuple("PartData", ('number', 'offset', 'size'))
+@dataclass(order=True)
+class PartData:
+    number: Optional[int] = None
+    offset: Optional[int] = None
+    size: Optional[int] = None
+    boot: Optional[bool] = None
+    partition_type: Optional[str] = None
+
+    # test cases may initialize the values they care about
+    # test utilities shall initialize all fields
+    def assertFieldsAreNotNone(self):
+        for field in dataclasses.fields(self):
+            assert getattr(self, field.name) is not None
+
+    def __eq__(self, other):
+        for field in dataclasses.fields(self):
+            myval = getattr(self, field.name)
+            otherval = getattr(other, field.name)
+            if myval is not None and otherval is not None \
+                    and myval != otherval:
+                return False
+        return True
 
 
 def _get_ext_size(dev, part_action):
@@ -92,10 +116,29 @@ def _get_extended_partition_size(dev, num):
     return partition['size'] * 512
 
 
+def _get_disk_label_id(dev):
+    ptable_json = util.subp(['sfdisk', '-J', dev], capture=True)[0]
+    ptable = json.loads(ptable_json)
+    # string in lowercase hex
+    return ptable['partitiontable']['id']
+
+
 def summarize_partitions(dev):
-    # We don't care about the kname
-    return sorted(
-        [PartData(*d[1:]) for d in block.sysfs_partition_data(dev)])
+    parts = []
+    ptable_json = util.subp(['sfdisk', '-J', dev], capture=True)[0]
+    ptable = json.loads(ptable_json)
+    partitions = ptable['partitiontable']['partitions']
+    for d in block.sysfs_partition_data(dev):
+        nodename = f'/dev/{d[0]}'
+        partition = [part for part in partitions
+                     if part['node'] == nodename][0]
+        ptype = partition['type']
+        boot = partition.get('bootable', False)
+        # We don't care about the kname
+        pd = PartData(*d[1:], partition_type=ptype, boot=boot)
+        pd.assertFieldsAreNotNone()
+        parts.append(pd)
+    return sorted(parts)
 
 
 class StorageConfigBuilder:
@@ -149,6 +192,10 @@ class TestBlockMeta(IntegrationTestCase):
     def setUp(self):
         self.data = self.random_string()
 
+    def assertPartitions(self, *args):
+        with loop_dev(self.img) as dev:
+            self.assertEqual([*args], summarize_partitions(dev))
+
     @contextlib.contextmanager
     def mount(self, dev, partition_cfg):
         mnt_point = self.tmp_dir()
@@ -860,5 +907,84 @@ class TestBlockMeta(IntegrationTestCase):
                 ])
             with self.mount(dev, p1) as mnt_point:
                 for i in range(5, 41, 5):
-                    with open(f'{mnt_point}/{str(i)}', 'rb') as fp:
+                    with open(f'{mnt_point}/{i}', 'rb') as fp:
                         self.assertEqual(bytes([i]) * (2 << 20), fp.read())
+
+    def test_parttype_dos(self):
+        # msdos partition table partitions shall retain their type
+        # create initial situation similar to this
+        # Device     Boot     Start       End   Sectors  Size Id Type
+        # /dev/sda1  *         2048    104447    102400   50M  7 HPFS/NTFS/exFA
+        # /dev/sda2          104448 208668781 208564334 99.5G  7 HPFS/NTFS/exFA
+        # /dev/sda3       208670720 209711103   1040384  508M 27 Hidden NTFS Wi
+        self.img = self.tmp_path('image.img')
+        config = StorageConfigBuilder(version=2)
+        config.add_image(path=self.img, size='200M', ptable='msdos')
+        config.add_part(size=50 << 20, offset=1 << 20, number=1,
+                        fstype='ntfs', flag='boot', partition_type='0x7')
+        config.add_part(size=100 << 20, offset=51 << 20, number=2,
+                        fstype='ntfs', partition_type='0x7')
+        config.add_part(size=48 << 20, offset=151 << 20, number=3,
+                        fstype='ntfs', partition_type='0x27')
+        self.run_bm(config.render())
+        self.assertPartitions(
+            PartData(number=1, offset=1 << 20, size=50 << 20,
+                     partition_type='7', boot=True),
+            PartData(number=2, offset=51 << 20, size=100 << 20,
+                     partition_type='7', boot=False),
+            PartData(number=3, offset=151 << 20, size=48 << 20,
+                     partition_type='27', boot=False))
+
+    def test_parttype_gpt(self):
+        # gpt partition table partitions shall retain their type
+        # create initial situation similar to this
+        # #  Start (sector)    End (sector)   Size        Code  Name
+        # 1            2048          206847   100.0 MiB   EF00  EFI system part
+        # 2          206848          239615   16.0 MiB    0C01  Microsoft reser
+        # 3          239616       103811181   49.4 GiB    0700  Basic data part
+        # 4       103813120       104853503   508.0 MiB   2700
+        esp = 'C12A7328-F81F-11D2-BA4B-00A0C93EC93B'
+        msreserved = 'E3C9E316-0B5C-4DB8-817D-F92DF00215AE'
+        msdata = 'EBD0A0A2-B9E5-4433-87C0-68B6B72699C7'
+        winre = 'DE94BBA4-06D1-4D40-A16A-BFD50179D6AC'
+        self.img = self.tmp_path('image.img')
+        config = StorageConfigBuilder(version=2)
+        config.add_image(path=self.img, size='100M', ptable='gpt')
+        config.add_part(number=1, offset=1 << 20, size=9 << 20,
+                        flag='boot', fstype='ntfs')
+        config.add_part(number=2, offset=10 << 20, size=20 << 20,
+                        partition_type=msreserved)
+        config.add_part(number=3, offset=30 << 20, size=50 << 20,
+                        partition_type=msdata, fstype='ntfs')
+        config.add_part(number=4, offset=80 << 20, size=19 << 20,
+                        partition_type=winre, fstype='ntfs')
+        self.run_bm(config.render())
+        self.assertPartitions(
+            PartData(number=1, offset=1 << 20, size=9 << 20,
+                     partition_type=esp),
+            PartData(number=2, offset=10 << 20, size=20 << 20,
+                     partition_type=msreserved),
+            PartData(number=3, offset=30 << 20, size=50 << 20,
+                     partition_type=msdata),
+            PartData(number=4, offset=80 << 20, size=19 << 20,
+                     partition_type=winre))
+
+    @parameterized.expand([('msdos',), ('gpt',)])
+    def test_disk_label_id_persistent(self, ptable):
+        # when the disk is preserved, the disk label id shall also be preserved
+        self.img = self.tmp_path('image.img')
+        config = StorageConfigBuilder(version=2)
+        config.add_image(path=self.img, size='20M', ptable=ptable)
+        config.add_part(number=1, offset=1 << 20, size=18 << 20)
+        self.run_bm(config.render())
+        self.assertPartitions(
+            PartData(number=1, offset=1 << 20, size=18 << 20))
+        with loop_dev(self.img) as dev:
+            orig_label_id = _get_disk_label_id(dev)
+
+        config.set_preserve()
+        self.run_bm(config.render())
+        self.assertPartitions(
+            PartData(number=1, offset=1 << 20, size=18 << 20))
+        with loop_dev(self.img) as dev:
+            self.assertEqual(orig_label_id, _get_disk_label_id(dev))
diff --git a/tests/unittests/test_commands_block_meta.py b/tests/unittests/test_commands_block_meta.py
index 0d73ab6..9185d4e 100644
--- a/tests/unittests/test_commands_block_meta.py
+++ b/tests/unittests/test_commands_block_meta.py
@@ -10,6 +10,7 @@ from mock import (
 )
 import os
 import random
+import uuid
 
 from curtin.block import dasd
 from curtin.commands import block_meta, block_meta_v2
@@ -17,6 +18,10 @@ from curtin import paths, util
 from .helpers import CiTestCase
 
 
+def random_uuid():
+    return uuid.uuid4()
+
+
 class TestGetPathToStorageVolume(CiTestCase):
 
     def setUp(self):
@@ -2669,6 +2674,73 @@ class TestPartitionVerifySfdiskV2(CiTestCase):
                 self.storage_config, self.table)
 
 
+class TestSfdiskV2(CiTestCase):
+    def test_gpt_basic(self):
+        table = block_meta_v2.GPTPartTable(512)
+        expected = '''\
+label: gpt
+'''
+        self.assertEqual(expected, table.render())
+
+    def test_gpt_boot(self):
+        table = block_meta_v2.GPTPartTable(512)
+        table.add(dict(number=1, offset=1 << 20, size=9 << 20, flag='boot'))
+        expected = '''\
+label: gpt
+
+1:  start=2048 size=18432 type=C12A7328-F81F-11D2-BA4B-00A0C93EC93B'''
+        self.assertEqual(expected, table.render())
+
+    def test_gpt_boot_raw_type(self):
+        esp = 'C12A7328-F81F-11D2-BA4B-00A0C93EC93B'
+        table = block_meta_v2.GPTPartTable(512)
+        table.add(dict(number=1, offset=1 << 20, size=9 << 20,
+                       partition_type=esp))
+        expected = '''\
+label: gpt
+
+1:  start=2048 size=18432 type=C12A7328-F81F-11D2-BA4B-00A0C93EC93B'''
+        self.assertEqual(expected, table.render())
+
+    def test_gpt_random_uuid(self):
+        ptype = str(random_uuid()).lower()
+        table = block_meta_v2.GPTPartTable(512)
+        table.add(dict(number=1, offset=1 << 20, size=9 << 20,
+                       flag='boot', partition_type=ptype))
+        expected = f'''\
+label: gpt
+
+1:  start=2048 size=18432 type={ptype}'''
+        self.assertEqual(expected, table.render())
+
+    def test_dos_basic(self):
+        table = block_meta_v2.DOSPartTable(512)
+        expected = '''\
+label: dos
+'''
+        self.assertEqual(expected, table.render())
+
+    def test_dos_boot(self):
+        table = block_meta_v2.DOSPartTable(512)
+        table.add(dict(number=1, offset=1 << 20, size=9 << 20, flag='boot'))
+        expected = '''\
+label: dos
+
+1:  start=2048 size=18432 type=EF bootable'''
+        self.assertEqual(expected, table.render())
+
+    def test_dos_random_code(self):
+        ptype = hex(random.randint(0, 0xff))[2:]
+        table = block_meta_v2.DOSPartTable(512)
+        table.add(dict(number=1, offset=1 << 20, size=9 << 20,
+                       flag='boot', partition_type=ptype))
+        expected = f'''\
+label: dos
+
+1:  start=2048 size=18432 type={ptype} bootable'''
+        self.assertEqual(expected, table.render())
+
+
 class TestPartitionNeedsResize(CiTestCase):
 
     def setUp(self):
diff --git a/tests/unittests/test_storage_config.py b/tests/unittests/test_storage_config.py
index d6b0a36..df48a4d 100644
--- a/tests/unittests/test_storage_config.py
+++ b/tests/unittests/test_storage_config.py
@@ -350,6 +350,7 @@ class TestBlockdevParser(CiTestCase):
             'offset': 1048576,
             'size': 499122176,
             'flag': 'linux',
+            'partition_type': '0fc63daf-8483-4772-8e79-3d69d8477de4',
         }
         self.assertDictEqual(expected_dict,
                              self.bdevp.asdict(blockdev))
@@ -394,6 +395,7 @@ class TestBlockdevParser(CiTestCase):
             'path': '/dev/vda1',
             'number': 1,
             'size': 784334848,
+            'partition_type': '0x0',
         }
         self.assertDictEqual(expected_dict, self.bdevp.asdict(test_value))
 
@@ -427,7 +429,7 @@ class TestBlockdevParser(CiTestCase):
         self.probe_data = _get_data('probert_storage_lvm.json')
         self.bdevp = BlockdevParser(self.probe_data)
         blockdev = self.bdevp.blockdev_data['/dev/vda2']
-        expected_dict = {
+        base_expected_dict = {
             'id': 'partition-vda2',
             'type': 'partition',
             'path': '/dev/vda2',
@@ -439,6 +441,8 @@ class TestBlockdevParser(CiTestCase):
         }
         for ext_part_entry in ['0xf', '0x5', '0x85', '0xc5']:
             blockdev['ID_PART_ENTRY_TYPE'] = ext_part_entry
+            expected_dict = base_expected_dict.copy()
+            expected_dict['partition_type'] = ext_part_entry
             self.assertDictEqual(expected_dict,
                                  self.bdevp.asdict(blockdev))
 
@@ -455,6 +459,7 @@ class TestBlockdevParser(CiTestCase):
             'offset': 3223322624,
             'size': 2147483648,
             'flag': 'logical',
+            'partition_type': '0x83',
         }
         self.assertDictEqual(expected_dict,
                              self.bdevp.asdict(blockdev))
@@ -473,6 +478,7 @@ class TestBlockdevParser(CiTestCase):
             'offset': 1048576,
             'size': 536870912,
             'flag': 'boot',
+            'partition_type': '0xb',
         }
         self.assertDictEqual(expected_dict,
                              self.bdevp.asdict(blockdev))
@@ -491,6 +497,7 @@ class TestBlockdevParser(CiTestCase):
             'offset': 3223322624,
             'size': 2147483648,
             'flag': 'boot',
+            'partition_type': '0x83',
         }
         self.assertDictEqual(expected_dict,
                              self.bdevp.asdict(blockdev))
@@ -551,6 +558,7 @@ class TestBlockdevParser(CiTestCase):
             'offset': 2097152,
             'size': 10734272512,
             'type': 'partition',
+            'partition_type': '0fc63daf-8483-4772-8e79-3d69d8477de4',
             }
         self.assertDictEqual(expected_dict, self.bdevp.asdict(blockdev))
 
@@ -1018,11 +1026,17 @@ class TestExtractStorageConfig(CiTestCase):
                           'raidlevel': 'raid1', 'name': 'md1',
                           'devices': ['partition-vdb1', 'partition-vdc1'],
                           'spare_devices': []}, raids[0])
-        self.assertEqual({'id': 'raid-md1p1', 'type': 'partition',
-                          'path': '/dev/md1p1',
-                          'size': 4285530112, 'flag': 'linux', 'number': 1,
-                          'device': 'raid-md1', 'offset': 1048576},
-                         raid_partitions[0])
+        self.assertEqual({
+            'id': 'raid-md1p1',
+            'type': 'partition',
+            'path': '/dev/md1p1',
+            'size': 4285530112,
+            'flag': 'linux',
+            'number': 1,
+            'partition_type': '0fc63daf-8483-4772-8e79-3d69d8477de4',
+            'device': 'raid-md1',
+            'offset': 1048576},
+            raid_partitions[0])
 
     @skipUnlessJsonSchema()
     def test_find_extended_partition(self):