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

[Lee Trager]

Filter out unsupported products from BootSourceCache.

This prevents Ubuntu Core from being shown in the boot images page in MAAS 2.1

[Blake Rouse (blake-rouse)]

Looks good.

review: Approve

=== modified file 'Makefile'
--- Makefile	2016-10-17 06:38:56 +0000
+++ Makefile	2017-04-26 00:29:21 +0000
@@ -587,8 +587,8 @@
 # this.
 
 # Old names.
-PACKAGING := $(abspath ../packaging.trunk)
-PACKAGING_BRANCH := lp:~maas-maintainers/maas/packaging
+PACKAGING := $(abspath ../packaging.2.1)
+PACKAGING_BRANCH := lp:~maas-maintainers/maas/packaging-2.1
 
 packaging-tree = $(PACKAGING)
 packaging-branch = $(PACKAGING_BRANCH)

=== modified file 'src/maasserver/bootresources.py'
--- src/maasserver/bootresources.py	2016-10-28 15:58:32 +0000
+++ src/maasserver/bootresources.py	2017-04-26 00:29:21 +0000
@@ -18,7 +18,6 @@
 from datetime import timedelta
 from operator import itemgetter
 import os
-import re
 from subprocess import CalledProcessError
 from textwrap import dedent
 import threading
@@ -81,6 +80,7 @@
 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,12 +1019,6 @@
             # 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`."""
@@ -1038,59 +1032,6 @@
         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)
@@ -1107,9 +1048,7 @@
         elif item['ftype'] not in dict(BOOT_RESOURCE_FILE_TYPE_CHOICES).keys():
             # Skip filetypes that we don't know about.
             return
-        elif not self._validate_ubuntu(item, product_name):
-            return
-        elif not self._validate_bootloader(item, product_name):
+        elif not validate_product(item, product_name):
             return
         else:
             self.store.insert(item, contentsource)

=== modified file 'src/maasserver/tests/test_bootresources.py'
--- src/maasserver/tests/test_bootresources.py	2016-10-12 15:26:17 +0000
+++ src/maasserver/tests/test_bootresources.py	2017-04-26 00:29:21 +0000
@@ -2103,7 +2103,7 @@
 class TestBootResourceRepoWriter(MAASServerTestCase):
     """Tests for `BootResourceRepoWriter`."""
 
-    def create_simplestream(self, ftypes, stream_version=None):
+    def create_ubuntu_simplestream(self, ftypes, stream_version=None):
         version = '16.04'
         arch = 'amd64'
         subarch = 'hwe-x'
@@ -2145,10 +2145,47 @@
         }
         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_simplestream([
+        src, product, version = self.create_ubuntu_simplestream([
             BOOT_RESOURCE_FILE_TYPE.ROOT_IMAGE,
             BOOT_RESOURCE_FILE_TYPE.SQUASHFS_IMAGE,
         ])
@@ -2162,7 +2199,7 @@
     def test_insert_allows_squashfs(self):
         boot_resource_repo_writer = BootResourceRepoWriter(
             BootResourceStore(), None)
-        src, product, version = self.create_simplestream([
+        src, product, version = self.create_ubuntu_simplestream([
             BOOT_RESOURCE_FILE_TYPE.SQUASHFS_IMAGE,
         ])
         data = src['products'][product]['versions'][version]['items'][
@@ -2175,7 +2212,7 @@
     def test_insert_allows_root_image(self):
         boot_resource_repo_writer = BootResourceRepoWriter(
             BootResourceStore(), None)
-        src, product, version = self.create_simplestream([
+        src, product, version = self.create_ubuntu_simplestream([
             BOOT_RESOURCE_FILE_TYPE.ROOT_IMAGE,
         ])
         data = src['products'][product]['versions'][version]['items'][
@@ -2188,9 +2225,7 @@
     def test_insert_allows_bootloader(self):
         boot_resource_repo_writer = BootResourceRepoWriter(
             BootResourceStore(), None)
-        src, product, version = self.create_simplestream([
-            BOOT_RESOURCE_FILE_TYPE.BOOTLOADER,
-        ])
+        src, product, version = self.create_bootloader_simplestream()
         data = src['products'][product]['versions'][version]['items'][
             BOOT_RESOURCE_FILE_TYPE.BOOTLOADER]
         pedigree = (product, version, BOOT_RESOURCE_FILE_TYPE.BOOTLOADER)
@@ -2201,7 +2236,7 @@
     def test_insert_allows_archive_tar_xz(self):
         boot_resource_repo_writer = BootResourceRepoWriter(
             BootResourceStore(), None)
-        src, product, version = self.create_simplestream([
+        src, product, version = self.create_ubuntu_simplestream([
             BOOT_RESOURCE_FILE_TYPE.ARCHIVE_TAR_XZ,
         ])
         data = src['products'][product]['versions'][version]['items'][
@@ -2215,7 +2250,7 @@
         boot_resource_repo_writer = BootResourceRepoWriter(
             BootResourceStore(), None)
         unknown_ftype = factory.make_name('ftype')
-        src, product, version = self.create_simplestream([
+        src, product, version = self.create_ubuntu_simplestream([
             unknown_ftype,
         ])
         data = src['products'][product]['versions'][version]['items'][
@@ -2228,105 +2263,43 @@
     def test_insert_validates_bootloader(self):
         boot_resource_repo_writer = BootResourceRepoWriter(
             BootResourceStore(), None)
-        src, product, version = self.create_simplestream([
-            BOOT_RESOURCE_FILE_TYPE.BOOTLOADER,
-        ])
+        src, product, version = self.create_bootloader_simplestream()
         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())
-        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_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())
 
     def test_insert_validates_ubuntu(self):
         boot_resource_repo_writer = BootResourceRepoWriter(
             BootResourceStore(), None)
-        src, product, version = self.create_simplestream([
+        src, product, version = self.create_ubuntu_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_simplestream(
+        src, product, version = self.create_ubuntu_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-01-25 16:13:42 +0000
+++ src/provisioningserver/import_images/download_descriptions.py	2017-04-26 00:29:21 +0000
@@ -10,8 +10,10 @@
 
 __all__ = [
     'download_all_image_descriptions',
+    'validate_product',
     ]
 
+import re
 
 from provisioningserver.import_images.boot_image_mapping import (
     BootImageMapping,
@@ -31,6 +33,13 @@
     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."""
@@ -46,6 +55,67 @@
     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.
 
@@ -79,6 +149,8 @@
     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-01-25 16:13:42 +0000
+++ src/provisioningserver/import_images/tests/test_download_descriptions.py	2017-04-26 00:29:21 +0000
@@ -6,6 +6,7 @@
 __all__ = []
 
 import logging
+import random
 from unittest.mock import (
     ANY,
     call,
@@ -27,6 +28,7 @@
 from provisioningserver.import_images.download_descriptions import (
     clean_up_repo_item,
     RepoDumper,
+    validate_product,
 )
 from provisioningserver.import_images.testing.factory import (
     make_image_spec,
@@ -34,6 +36,78 @@
 )
 
 
+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`."""
 
@@ -280,7 +354,10 @@
             download_descriptions, 'products_exdata').return_value = item
         dumper.insert_item(
             sentinel.data, sentinel.src, sentinel.target,
-            sentinel.pedigree, sentinel.contentsource)
+            (
+                factory.make_name('product_name'),
+                factory.make_name('product_version')
+            ), sentinel.contentsource)
         image_specs = [
             make_image_spec(
                 os=item['os'], release=item['release'],
@@ -306,7 +383,10 @@
         for _ in range(2):
             dumper.insert_item(
                 sentinel.data, sentinel.src, sentinel.target,
-                sentinel.pedigree, sentinel.contentsource)
+                (
+                    factory.make_name('product_name'),
+                    factory.make_name('product_version')
+                ), sentinel.contentsource)
         image_spec = make_image_spec(
             os=item['os'], release=item['release'],
             arch=item['arch'], subarch=compat_subarch,
@@ -337,8 +417,11 @@
             'products_exdata').side_effect = [hwep_item, hwes_item]
         for _ in range(2):
             dumper.insert_item(
-                sentinel.data, sentinel.src, sentinel.target,
-                sentinel.pedigree, sentinel.contentsource)
+                {'os': 'ubuntu'}, sentinel.src, sentinel.target,
+                (
+                    'com.ubuntu.maas.daily:v3:boot:12.04:amd64:hwe-p',
+                    factory.make_name('product_version'),
+                ), sentinel.contentsource)
         image_spec = make_image_spec(
             os=os, release=release, arch=arch, subarch='generic',
             label=label)
@@ -368,8 +451,11 @@
             'products_exdata').side_effect = [hwep_item, hwes_item]
         for _ in range(2):
             dumper.insert_item(
-                sentinel.data, sentinel.src, sentinel.target,
-                sentinel.pedigree, sentinel.contentsource)
+                {'os': 'ubuntu'}, sentinel.src, sentinel.target,
+                (
+                    'com.ubuntu.maas.daily:v3:boot:12.04:amd64:hwe-p',
+                    factory.make_name('product_version'),
+                ), sentinel.contentsource)
         image_spec = make_image_spec(
             os=os, release=release, arch=arch, subarch='generic',
             label=label)
@@ -378,21 +464,42 @@
     def test_insert_item_sets_release_to_bootloader_type(self):
         boot_images_dict = BootImageMapping()
         dumper = RepoDumper(boot_images_dict)
-        bootloader_type = factory.make_name('bootloader-type')
-        item, _ = self.make_item(bootloader_type=bootloader_type)
+        item, _ = self.make_item(
+            arch='amd64', bootloader_type='uefi', os='grub-efi-signed')
         self.patch(
             download_descriptions, 'products_exdata').return_value = item
         dumper.insert_item(
-            sentinel.data, sentinel.src, sentinel.target,
-            sentinel.pedigree, sentinel.contentsource)
+            {
+                '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)
         image_specs = [
             make_image_spec(
-                os=item['os'], release=bootloader_type, arch=item['arch'],
+                os=item['os'], release='uefi', 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,))