Merge lp:~andreserl/maas/revert_rev5602_lp1686169_2.1 into lp:maas/2.1

[Andres Rodriguez]

Revert rev5602, which fixed LP: #1686169. This causes rack controllers to fail importing images

=== modified file 'src/maasserver/bootresources.py'
--- src/maasserver/bootresources.py	2017-04-26 00:27:23 +0000
+++ src/maasserver/bootresources.py	2017-04-26 19:10:13 +0000
@@ -18,6 +18,7 @@
 from datetime import timedelta
 from operator import itemgetter
 import os
+import re
 from subprocess import CalledProcessError
 from textwrap import dedent
 import threading
@@ -80,7 +81,6 @@
 from provisioningserver.import_images.download_descriptions import (
     download_all_image_descriptions,
     image_passes_filter,
-    validate_product,
 )
 from provisioningserver.import_images.helpers import (
     get_os_from_product,
@@ -1019,6 +1019,12 @@
             # will be downloaded from simplestreams.
             'max_items': 1,
             })
+        # Compile a regex to validate bootloader product names. This only
+        # allows V1 bootloaders.
+        self.bootloader_regex = re.compile('.*:1:.*', re.IGNORECASE)
+        # Compile a regex to validate Ubuntu product names. This only allows
+        # V2 and V3 Ubuntu products.
+        self.ubuntu_regex = re.compile('.*:v[23]:.*', re.IGNORECASE)
 
     def load_products(self, path=None, content_id=None):
         """Overridable from `BasicMirrorWriter`."""
@@ -1032,6 +1038,59 @@
         return self.product_mapping.contains(
             sutil.products_exdata(src, pedigree))
 
+    def _validate_ubuntu(self, data, product_name):
+        osystem = data.get('os')
+        if 'ubuntu' not in osystem.lower():
+            # It's not an Ubuntu product, nothing to validate.
+            return True
+        elif self.ubuntu_regex.search(product_name) is None:
+            # Only insert v2 or v3 Ubuntu products.
+            return False
+        else:
+            return True
+
+    def _validate_bootloader(self, data, product_name):
+        bootloader_type = data.get('bootloader-type')
+        if bootloader_type is None:
+            # It's not a bootloader, nothing to validate
+            return True
+        if self.bootloader_regex.search(product_name) is None:
+            # Only insert V1 bootloaders from the stream
+            return False
+        # Validate MAAS supports the specific bootloader_type, os, arch
+        # combination.
+        SUPPORTED_BOOTLOADERS = {
+            'pxe': [
+                {
+                    'os': 'pxelinux',
+                    'arch': 'i386',
+                }
+            ],
+            'uefi': [
+                {
+                    'os': 'grub-efi-signed',
+                    'arch': 'amd64',
+                },
+                {
+                    'os': 'grub-efi',
+                    'arch': 'arm64',
+                }
+            ],
+            'open-firmware': [
+                {
+                    'os': 'grub-ieee1275',
+                    'arch': 'ppc64el',
+                }
+            ],
+        }
+        for bootloader in SUPPORTED_BOOTLOADERS.get(bootloader_type, []):
+            if (
+                    data.get('os') == bootloader['os'] and
+                    data.get('arch') == bootloader['arch']):
+                return True
+        # Bootloader not supported, ignore
+        return False
+
     def insert_item(self, data, src, target, pedigree, contentsource):
         """Overridable from `BasicMirrorWriter`."""
         item = sutil.products_exdata(src, pedigree)
@@ -1048,7 +1107,9 @@
         elif item['ftype'] not in dict(BOOT_RESOURCE_FILE_TYPE_CHOICES).keys():
             # Skip filetypes that we don't know about.
             return
-        elif not validate_product(item, product_name):
+        elif not self._validate_ubuntu(item, product_name):
+            return
+        elif not self._validate_bootloader(item, product_name):
             return
         else:
             self.store.insert(item, contentsource)

=== modified file 'src/maasserver/tests/test_bootresources.py'
--- src/maasserver/tests/test_bootresources.py	2017-04-26 00:27:23 +0000
+++ src/maasserver/tests/test_bootresources.py	2017-04-26 19:10:13 +0000
@@ -2103,7 +2103,7 @@
 class TestBootResourceRepoWriter(MAASServerTestCase):
     """Tests for `BootResourceRepoWriter`."""
 
-    def create_ubuntu_simplestream(self, ftypes, stream_version=None):
+    def create_simplestream(self, ftypes, stream_version=None):
         version = '16.04'
         arch = 'amd64'
         subarch = 'hwe-x'
@@ -2145,47 +2145,10 @@
         }
         return src, product, version
 
-    def create_bootloader_simplestream(self, stream_version=None):
-        if stream_version is None:
-            stream_version = '1'
-        product = (
-            'com.ubuntu.maas:daily:%s:bootloader-download' % stream_version)
-        version = datetime.now().date().strftime('%Y%m%d.0')
-        versions = {
-            version: {
-                'items': {
-                    BOOT_RESOURCE_FILE_TYPE.BOOTLOADER: {
-                        'sha256': factory.make_name('sha256'),
-                        'path': factory.make_name('path'),
-                        'ftype': BOOT_RESOURCE_FILE_TYPE.BOOTLOADER,
-                        'size': random.randint(0, 2**64),
-                    }
-                }
-            }
-        }
-        products = {
-            product: {
-                'label': 'daily',
-                'os': 'grub-efi-signed',
-                'arch': 'amd64',
-                'bootloader-type': 'uefi',
-                'version': version,
-                'versions': versions,
-            }
-        }
-        src = {
-            'datatype': 'image-downloads',
-            'format': 'products:1.0',
-            'updated': format_datetime(datetime.now()),
-            'products': products,
-            'content_id': 'com.ubuntu.maas:daily:1:bootloader-download'
-        }
-        return src, product, version
-
     def test_insert_prefers_squashfs_over_root_image(self):
         boot_resource_repo_writer = BootResourceRepoWriter(
             BootResourceStore(), None)
-        src, product, version = self.create_ubuntu_simplestream([
+        src, product, version = self.create_simplestream([
             BOOT_RESOURCE_FILE_TYPE.ROOT_IMAGE,
             BOOT_RESOURCE_FILE_TYPE.SQUASHFS_IMAGE,
         ])
@@ -2199,7 +2162,7 @@
     def test_insert_allows_squashfs(self):
         boot_resource_repo_writer = BootResourceRepoWriter(
             BootResourceStore(), None)
-        src, product, version = self.create_ubuntu_simplestream([
+        src, product, version = self.create_simplestream([
             BOOT_RESOURCE_FILE_TYPE.SQUASHFS_IMAGE,
         ])
         data = src['products'][product]['versions'][version]['items'][
@@ -2212,7 +2175,7 @@
     def test_insert_allows_root_image(self):
         boot_resource_repo_writer = BootResourceRepoWriter(
             BootResourceStore(), None)
-        src, product, version = self.create_ubuntu_simplestream([
+        src, product, version = self.create_simplestream([
             BOOT_RESOURCE_FILE_TYPE.ROOT_IMAGE,
         ])
         data = src['products'][product]['versions'][version]['items'][
@@ -2225,7 +2188,9 @@
     def test_insert_allows_bootloader(self):
         boot_resource_repo_writer = BootResourceRepoWriter(
             BootResourceStore(), None)
-        src, product, version = self.create_bootloader_simplestream()
+        src, product, version = self.create_simplestream([
+            BOOT_RESOURCE_FILE_TYPE.BOOTLOADER,
+        ])
         data = src['products'][product]['versions'][version]['items'][
             BOOT_RESOURCE_FILE_TYPE.BOOTLOADER]
         pedigree = (product, version, BOOT_RESOURCE_FILE_TYPE.BOOTLOADER)
@@ -2236,7 +2201,7 @@
     def test_insert_allows_archive_tar_xz(self):
         boot_resource_repo_writer = BootResourceRepoWriter(
             BootResourceStore(), None)
-        src, product, version = self.create_ubuntu_simplestream([
+        src, product, version = self.create_simplestream([
             BOOT_RESOURCE_FILE_TYPE.ARCHIVE_TAR_XZ,
         ])
         data = src['products'][product]['versions'][version]['items'][
@@ -2250,7 +2215,7 @@
         boot_resource_repo_writer = BootResourceRepoWriter(
             BootResourceStore(), None)
         unknown_ftype = factory.make_name('ftype')
-        src, product, version = self.create_ubuntu_simplestream([
+        src, product, version = self.create_simplestream([
             unknown_ftype,
         ])
         data = src['products'][product]['versions'][version]['items'][
@@ -2263,43 +2228,105 @@
     def test_insert_validates_bootloader(self):
         boot_resource_repo_writer = BootResourceRepoWriter(
             BootResourceStore(), None)
-        src, product, version = self.create_bootloader_simplestream()
+        src, product, version = self.create_simplestream([
+            BOOT_RESOURCE_FILE_TYPE.BOOTLOADER,
+        ])
         data = src['products'][product]['versions'][version]['items'][
             BOOT_RESOURCE_FILE_TYPE.BOOTLOADER]
         pedigree = (product, version, BOOT_RESOURCE_FILE_TYPE.BOOTLOADER)
         mock_insert = self.patch(boot_resource_repo_writer.store, 'insert')
+        mock_validate_bootloader = self.patch(
+            boot_resource_repo_writer, '_validate_bootloader')
         boot_resource_repo_writer.insert_item(data, src, None, pedigree, None)
         self.assertThat(mock_insert, MockCalledOnce())
-
-    def test_insert_validates_rejects_unknown_version(self):
-        boot_resource_repo_writer = BootResourceRepoWriter(
-            BootResourceStore(), None)
-        src, product, version = self.create_bootloader_simplestream(
-            factory.make_name('stream_version'))
-        data = src['products'][product]['versions'][version]['items'][
-            BOOT_RESOURCE_FILE_TYPE.BOOTLOADER]
-        pedigree = (product, version, BOOT_RESOURCE_FILE_TYPE.BOOTLOADER)
-        mock_insert = self.patch(boot_resource_repo_writer.store, 'insert')
-        boot_resource_repo_writer.insert_item(data, src, None, pedigree, None)
-        self.assertThat(mock_insert, MockNotCalled())
+        self.assertThat(mock_validate_bootloader, MockCalledOnce())
+
+    def test_validate_bootloader_ignores_non_bootloaders(self):
+        boot_resource_repo_writer = BootResourceRepoWriter(
+            BootResourceStore(), None)
+        self.assertTrue(
+            boot_resource_repo_writer._validate_bootloader(
+                {}, 'com.ubuntu.maas.daily:v3:boot:16.04:amd64:hwe-16.04'))
+
+    def test_validate_bootloader_checks_version(self):
+        boot_resource_repo_writer = BootResourceRepoWriter(
+            BootResourceStore(), None)
+        version = random.randint(2, 100)
+        product_name = "com.ubuntu.maas.daily:%d:pxelinux:pxe:i386" % version
+        self.assertFalse(
+            boot_resource_repo_writer._validate_bootloader(
+                {'bootloader-type': factory.make_name('bootloader-type')},
+                product_name))
+
+    def test_validate_bootloader_allows_acceptable_bootloaders(self):
+        acceptable_bootloaders = [
+            {
+                'os': 'pxelinux',
+                'arch': 'i386',
+                'bootloader-type': 'pxe',
+            },
+            {
+                'os': 'grub-efi-signed',
+                'arch': 'amd64',
+                'bootloader-type': 'uefi',
+            },
+            {
+                'os': 'grub-efi',
+                'arch': 'arm64',
+                'bootloader-type': 'uefi',
+            },
+            {
+                'os': 'grub-ieee1275',
+                'arch': 'ppc64el',
+                'bootloader-type': 'open-firmware',
+            },
+        ]
+        boot_resource_repo_writer = BootResourceRepoWriter(
+            BootResourceStore(), None)
+        for bootloader in acceptable_bootloaders:
+            product_name = "com.ubuntu.maas.daily:1:%s:%s:%s" % (
+                bootloader['os'], bootloader['bootloader-type'],
+                bootloader['arch'])
+            self.assertTrue(
+                boot_resource_repo_writer._validate_bootloader(
+                    bootloader, product_name),
+                "Failed to validate %s" % product_name)
+
+    def test_validate_bootloader_denies_unacceptable_bootloader(self):
+        bootloader = {
+            'os': factory.make_name('os'),
+            'arch': factory.make_name('arch'),
+            'bootloader-type': factory.make_name('bootloader_type'),
+        }
+        product_name = "com.ubuntu.maas.daily:1:%s:%s:%s" % (
+            bootloader['os'], bootloader['bootloader-type'],
+            bootloader['arch'])
+        boot_resource_repo_writer = BootResourceRepoWriter(
+            BootResourceStore(), None)
+        self.assertFalse(
+            boot_resource_repo_writer._validate_bootloader(
+                bootloader, product_name))
 
     def test_insert_validates_ubuntu(self):
         boot_resource_repo_writer = BootResourceRepoWriter(
             BootResourceStore(), None)
-        src, product, version = self.create_ubuntu_simplestream([
+        src, product, version = self.create_simplestream([
             BOOT_RESOURCE_FILE_TYPE.SQUASHFS_IMAGE,
         ])
         data = src['products'][product]['versions'][version]['items'][
             BOOT_RESOURCE_FILE_TYPE.SQUASHFS_IMAGE]
         pedigree = (product, version, BOOT_RESOURCE_FILE_TYPE.SQUASHFS_IMAGE)
         mock_insert = self.patch(boot_resource_repo_writer.store, 'insert')
+        mock_validate_bootloader = self.patch(
+            boot_resource_repo_writer, '_validate_ubuntu')
         boot_resource_repo_writer.insert_item(data, src, None, pedigree, None)
         self.assertThat(mock_insert, MockCalledOnce())
+        self.assertThat(mock_validate_bootloader, MockCalledOnce())
 
     def test_validate_ubuntu_rejects_unknown_version(self):
         boot_resource_repo_writer = BootResourceRepoWriter(
             BootResourceStore(), None)
-        src, product, version = self.create_ubuntu_simplestream(
+        src, product, version = self.create_simplestream(
             [BOOT_RESOURCE_FILE_TYPE.SQUASHFS_IMAGE],
             factory.make_name('stream_version'))
         data = src['products'][product]['versions'][version]['items'][

=== modified file 'src/provisioningserver/import_images/download_descriptions.py'
--- src/provisioningserver/import_images/download_descriptions.py	2017-04-26 00:27:23 +0000
+++ src/provisioningserver/import_images/download_descriptions.py	2017-04-26 19:10:13 +0000
@@ -10,10 +10,8 @@
 
 __all__ = [
     'download_all_image_descriptions',
-    'validate_product',
     ]
 
-import re
 
 from provisioningserver.import_images.boot_image_mapping import (
     BootImageMapping,
@@ -33,13 +31,6 @@
     products_exdata,
 )
 
-# Compile a regex to validate Ubuntu product names. This only allows V2 and V3
-# Ubuntu images.
-UBUNTU_REGEX = re.compile('.*:v[23]:.*', re.IGNORECASE)
-# Compile a regex to validate bootloader product names. This only allows V1
-# bootloaders.
-BOOTLOADER_REGEX = re.compile('.*:1:.*', re.IGNORECASE)
-
 
 def clean_up_repo_item(item):
     """Return a subset of dict `item` for storing in a boot images dict."""
@@ -55,67 +46,6 @@
     return compact_item
 
 
-def validate_ubuntu(data, product_name):
-    osystem = data.get('os', '')
-    if 'ubuntu' not in osystem.lower():
-        # It's not an Ubuntu product, nothing to validate.
-        return True
-    elif UBUNTU_REGEX.search(product_name) is None:
-        # Only insert v2 or v3 Ubuntu products.
-        return False
-    else:
-        return True
-
-
-def validate_bootloader(data, product_name):
-    bootloader_type = data.get('bootloader-type')
-    if bootloader_type is None:
-        # It's not a bootloader, nothing to validate
-        return True
-    if BOOTLOADER_REGEX.search(product_name) is None:
-        # Only insert V1 bootloaders from the stream
-        return False
-    # Validate MAAS supports the specific bootloader_type, os, arch
-    # combination.
-    SUPPORTED_BOOTLOADERS = {
-        'pxe': [
-            {
-                'os': 'pxelinux',
-                'arch': 'i386',
-            }
-        ],
-        'uefi': [
-            {
-                'os': 'grub-efi-signed',
-                'arch': 'amd64',
-            },
-            {
-                'os': 'grub-efi',
-                'arch': 'arm64',
-            }
-        ],
-        'open-firmware': [
-            {
-                'os': 'grub-ieee1275',
-                'arch': 'ppc64el',
-            }
-        ],
-    }
-    for bootloader in SUPPORTED_BOOTLOADERS.get(bootloader_type, []):
-        if (
-                data.get('os') == bootloader['os'] and
-                data.get('arch') == bootloader['arch']):
-            return True
-
-    # Bootloader not supported, ignore
-    return False
-
-
-def validate_product(data, product_name):
-    return (validate_ubuntu(data, product_name) and
-            validate_bootloader(data, product_name))
-
-
 class RepoDumper(BasicMirrorWriter):
     """Gather metadata about boot images available in a Simplestreams repo.
 
@@ -149,8 +79,6 @@
     def insert_item(self, data, src, target, pedigree, contentsource):
         """Overridable from `BasicMirrorWriter`."""
         item = products_exdata(src, pedigree)
-        if not validate_product(item, pedigree[0]):
-            return
         os = get_os_from_product(item)
         arch = item['arch']
         subarches = item.get('subarches', 'generic')

=== modified file 'src/provisioningserver/import_images/tests/test_download_descriptions.py'
--- src/provisioningserver/import_images/tests/test_download_descriptions.py	2017-04-26 00:27:23 +0000
+++ src/provisioningserver/import_images/tests/test_download_descriptions.py	2017-04-26 19:10:13 +0000
@@ -6,7 +6,6 @@
 __all__ = []
 
 import logging
-import random
 from unittest.mock import (
     ANY,
     call,
@@ -28,7 +27,6 @@
 from provisioningserver.import_images.download_descriptions import (
     clean_up_repo_item,
     RepoDumper,
-    validate_product,
 )
 from provisioningserver.import_images.testing.factory import (
     make_image_spec,
@@ -36,78 +34,6 @@
 )
 
 
-class TestValidateProduct(MAASTestCase):
-    """Tests for `validate_product`."""
-
-    def test__ignores_random(self):
-        self.assertTrue(
-            validate_product({}, factory.make_name('product_name')))
-
-    def test__validates_ubuntu(self):
-        self.assertTrue(validate_product(
-            {'os': 'ubuntu'},
-            'com.ubuntu.maas.daily:v%d:boot:%s:%s:%s' % (
-                random.choice([2, 3]), factory.make_name('version'),
-                factory.make_name('arch'), factory.make_name('sub_arch'))))
-
-    def test__rejects_unknown_ubuntu_version(self):
-        self.assertFalse(validate_product(
-            {'os': 'ubuntu'},
-            'com.ubuntu.maas.daily:v%d:boot:%s:%s:%s' % (
-                random.randint(4, 100), factory.make_name('version'),
-                factory.make_name('arch'), factory.make_name('sub_arch'))))
-
-    def test__validates_bootloaders(self):
-        acceptable_bootloaders = [
-            {
-                'os': 'pxelinux',
-                'arch': 'i386',
-                'bootloader-type': 'pxe',
-            },
-            {
-                'os': 'grub-efi-signed',
-                'arch': 'amd64',
-                'bootloader-type': 'uefi',
-            },
-            {
-                'os': 'grub-efi',
-                'arch': 'arm64',
-                'bootloader-type': 'uefi',
-            },
-            {
-                'os': 'grub-ieee1275',
-                'arch': 'ppc64el',
-                'bootloader-type': 'open-firmware',
-            },
-        ]
-        for bootloader in acceptable_bootloaders:
-            product_name = "com.ubuntu.maas.daily:1:%s:%s:%s" % (
-                bootloader['os'], bootloader['bootloader-type'],
-                bootloader['arch'])
-            self.assertTrue(
-                validate_product(bootloader, product_name),
-                "Failed to validate %s" % product_name)
-
-    def test__rejects_unknown_bootloader_version(self):
-        version = random.randint(2, 100)
-        product_name = "com.ubuntu.maas.daily:%d:pxelinux:pxe:i386" % version
-        self.assertFalse(
-            validate_product(
-                {'bootloader-type': factory.make_name('bootloader-type')},
-                product_name))
-
-    def test__rejects_unknown_bootloader(self):
-        bootloader = {
-            'os': factory.make_name('os'),
-            'arch': factory.make_name('arch'),
-            'bootloader-type': factory.make_name('bootloader_type'),
-        }
-        product_name = "com.ubuntu.maas.daily:1:%s:%s:%s" % (
-            bootloader['os'], bootloader['bootloader-type'],
-            bootloader['arch'])
-        self.assertFalse(validate_product(bootloader, product_name))
-
-
 class TestValuePassesFilterList(MAASTestCase):
     """Tests for `value_passes_filter_list`."""
 
@@ -354,10 +280,7 @@
             download_descriptions, 'products_exdata').return_value = item
         dumper.insert_item(
             sentinel.data, sentinel.src, sentinel.target,
-            (
-                factory.make_name('product_name'),
-                factory.make_name('product_version')
-            ), sentinel.contentsource)
+            sentinel.pedigree, sentinel.contentsource)
         image_specs = [
             make_image_spec(
                 os=item['os'], release=item['release'],
@@ -383,10 +306,7 @@
         for _ in range(2):
             dumper.insert_item(
                 sentinel.data, sentinel.src, sentinel.target,
-                (
-                    factory.make_name('product_name'),
-                    factory.make_name('product_version')
-                ), sentinel.contentsource)
+                sentinel.pedigree, sentinel.contentsource)
         image_spec = make_image_spec(
             os=item['os'], release=item['release'],
             arch=item['arch'], subarch=compat_subarch,
@@ -417,11 +337,8 @@
             'products_exdata').side_effect = [hwep_item, hwes_item]
         for _ in range(2):
             dumper.insert_item(
-                {'os': 'ubuntu'}, sentinel.src, sentinel.target,
-                (
-                    'com.ubuntu.maas.daily:v3:boot:12.04:amd64:hwe-p',
-                    factory.make_name('product_version'),
-                ), sentinel.contentsource)
+                sentinel.data, sentinel.src, sentinel.target,
+                sentinel.pedigree, sentinel.contentsource)
         image_spec = make_image_spec(
             os=os, release=release, arch=arch, subarch='generic',
             label=label)
@@ -451,11 +368,8 @@
             'products_exdata').side_effect = [hwep_item, hwes_item]
         for _ in range(2):
             dumper.insert_item(
-                {'os': 'ubuntu'}, sentinel.src, sentinel.target,
-                (
-                    'com.ubuntu.maas.daily:v3:boot:12.04:amd64:hwe-p',
-                    factory.make_name('product_version'),
-                ), sentinel.contentsource)
+                sentinel.data, sentinel.src, sentinel.target,
+                sentinel.pedigree, sentinel.contentsource)
         image_spec = make_image_spec(
             os=os, release=release, arch=arch, subarch='generic',
             label=label)
@@ -464,42 +378,21 @@
     def test_insert_item_sets_release_to_bootloader_type(self):
         boot_images_dict = BootImageMapping()
         dumper = RepoDumper(boot_images_dict)
-        item, _ = self.make_item(
-            arch='amd64', bootloader_type='uefi', os='grub-efi-signed')
+        bootloader_type = factory.make_name('bootloader-type')
+        item, _ = self.make_item(bootloader_type=bootloader_type)
         self.patch(
             download_descriptions, 'products_exdata').return_value = item
         dumper.insert_item(
-            {
-                'bootloader_type': 'uefi',
-                'os': 'grub-efi-signed',
-                'arch': 'amd64',
-            }, sentinel.src, sentinel.target,
-            (
-                'com.ubuntu.maas.daily:1:grub-efi-signed:uefi:amd64',
-                factory.make_name('product_version'),
-            ), sentinel.contentsource)
+            sentinel.data, sentinel.src, sentinel.target,
+            sentinel.pedigree, sentinel.contentsource)
         image_specs = [
             make_image_spec(
-                os=item['os'], release='uefi', arch=item['arch'],
+                os=item['os'], release=bootloader_type, arch=item['arch'],
                 subarch=subarch, kflavor='bootloader', label=item['label'])
             for subarch in item['subarches'].split(',')
         ]
         self.assertItemsEqual(image_specs, list(boot_images_dict.mapping))
 
-    def test_insert_item_validates(self):
-        boot_images_dict = BootImageMapping()
-        dumper = RepoDumper(boot_images_dict)
-        item, _ = self.make_item(os='ubuntu')
-        self.patch(
-            download_descriptions, 'products_exdata').return_value = item
-        dumper.insert_item(
-            {'os': 'ubuntu'}, sentinel.src, sentinel.target,
-            (
-                factory.make_name('product_name'),
-                factory.make_name('product_version'),
-            ), sentinel.contentsource)
-        self.assertItemsEqual([], list(boot_images_dict.mapping))
-
     def test_sync_does_propagate_ioerror(self):
         io_error = factory.make_exception_type(bases=(IOError,))