def make_filter_from_image(self, image_spec=None):
"""Create a filter dict that matches the given `ImageSpec`.
If `image_spec` is not given, creates a random value.
"""
if image_spec is None:
image_spec = make_image_spec()
return {
"os": image_spec.os,
"arches": [image_spec.arch],
"subarches": [image_spec.subarch],
"release": image_spec.release,
"labels": [image_spec.label],
}
def test_filter_checks_labels(self):
image = make_image_spec()
self.assertFalse(
download_descriptions.image_passes_filter(
[
self.make_filter_from_image(
image._replace(label=factory.make_name("other-label")))
],
image.os,
image.arch,
image.subarch,
image.release,
image.label,
))
def test_maps_boot_resource_by_content_id_product_name_and_version(self):
image = make_image_spec()
resource = make_boot_resource()
boot_dict = set_resource(resource=resource.copy(), image_spec=image)
self.assertEqual(
{
(
resource["content_id"],
resource["product_name"],
resource["version_name"],
): [image.subarch]
},
map_products(boot_dict).mapping,
)
def test_image_passes_if_one_filter_matches(self):
image = make_image_spec()
self.assertTrue(
download_descriptions.image_passes_filter(
[
self.make_filter_from_image(),
self.make_filter_from_image(image),
self.make_filter_from_image(),
],
image.os,
image.arch,
image.subarch,
image.release,
image.label,
))
def setUp(self):
super(TestMain, self).setUp()
self.useFixture(ClusterConfigurationFixture())
self.storage = self.make_dir()
current_dir = os.path.join(self.storage, 'current') + os.sep
os.makedirs(current_dir)
with ClusterConfiguration.open_for_update() as config:
config.tftp_root = current_dir
os.rmdir(current_dir)
# Forcing arch to amd64 causes pxelinux.0 to be installed, giving more
# test coverage.
self.image = make_image_spec(arch='amd64')
self.os, self.arch, self.subarch, self.kflavor, \
self.release, self.label = self.image
self.repo = self.make_simplestreams_repo(self.image)
def test_insert_item_sets_generic_to_release_item_for_hwe_version(self):
boot_images_dict = BootImageMapping()
dumper = RepoDumper(boot_images_dict)
os = "ubuntu"
release = "xenial"
arch = "amd64"
label = "release"
hwep_subarch = "hwe-16.04"
hwep_subarches = ["generic", "hwe-16.04", "hwe-16.10"]
hwes_subarch = "hwe-16.10"
hwes_subarches = ["generic", "hwe-16.04", "hwe-16.10"]
hwep_item, compat_item = self.make_item(
os=os,
release=release,
arch=arch,
subarch=hwep_subarch,
subarches=hwep_subarches,
label=label,
)
hwes_item, _ = self.make_item(
os=os,
release=release,
arch=arch,
subarch=hwes_subarch,
subarches=hwes_subarches,
label=label,
)
self.patch(download_descriptions, "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,
)
image_spec = make_image_spec(os=os,
release=release,
arch=arch,
subarch="generic",
label=label)
self.assertEqual(compat_item, boot_images_dict.mapping[image_spec])
def test_dump_json_represents_entry(self):
image = make_image_spec()
resource = factory.make_name('resource')
image_dict = set_resource(image_spec=image, resource=resource)
self.assertEqual(
{
image.os: {
image.arch: {
image.subarch: {
image.kflavor: {
image.release: {image.label: resource},
},
},
},
},
},
json.loads(image_dict.dump_json()))
def test_extract_metadata_handles_missing_subarch(self):
resource = dict(other_item=factory.make_name("other"), )
image = make_image_spec()
mapping = set_resource(image_spec=image, resource=resource)
metadata = mapping.dump_json()
# Lack of consistency across maas in naming arch vs architecture
# and subarch vs subarchitecture means I can't just do a simple
# dict parameter expansion here.
params = {
"osystem": image.os,
"architecture": image.arch,
"subarchitecture": image.subarch,
"release": image.release,
"label": image.label,
}
self.assertEqual({}, extract_metadata(metadata, params))
def test_insert_item_adds_item_per_subarch(self):
boot_images_dict = BootImageMapping()
dumper = RepoDumper(boot_images_dict)
subarches = [factory.make_name('subarch') for _ in range(3)]
item, _ = self.make_item(subarch=subarches.pop(), subarches=subarches)
self.patch(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)
image_specs = [
make_image_spec(os=item['os'],
release=item['release'],
arch=item['arch'],
subarch=subarch,
label=item['label']) for subarch in subarches
]
self.assertItemsEqual(image_specs, list(boot_images_dict.mapping))
def test_insert_item_doesnt_validate_when_instructed(self):
boot_images_dict = BootImageMapping()
dumper = RepoDumper(boot_images_dict, validate_products=False)
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)
image_specs = [
make_image_spec(os=item['os'],
release=item['release'],
arch=item['arch'],
subarch=subarch,
label=item['label'])
for subarch in item['subarches'].split(',')
]
self.assertItemsEqual(image_specs, list(boot_images_dict.mapping))
def test_dump_json_combines_similar_entries(self):
image = make_image_spec()
other_release = factory.make_name('other-release')
resource1 = factory.make_name('resource')
resource2 = factory.make_name('other-resource')
image_dict = BootImageMapping()
set_resource(image_dict, image, resource1)
set_resource(
image_dict, image._replace(release=other_release), resource2)
self.assertEqual(
{
image.os: {
image.arch: {
image.subarch: {
image.kflavor: {
image.release: {image.label: resource1},
other_release: {image.label: resource2},
},
},
},
},
},
json.loads(image_dict.dump_json()))
def test_insert_item_sets_compat_item_specific_to_subarch(self):
boot_images_dict = BootImageMapping()
dumper = RepoDumper(boot_images_dict)
subarches = [factory.make_name("subarch") for _ in range(5)]
compat_subarch = subarches.pop()
item, _ = self.make_item(subarch=subarches.pop(), subarches=subarches)
second_item, compat_item = self.make_item(
os=item["os"],
release=item["release"],
arch=item["arch"],
subarch=compat_subarch,
subarches=[compat_subarch],
label=item["label"],
)
self.patch(download_descriptions, "products_exdata").side_effect = [
item,
second_item,
]
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,
)
image_spec = make_image_spec(
os=item["os"],
release=item["release"],
arch=item["arch"],
subarch=compat_subarch,
label=item["label"],
)
self.assertEqual(compat_item, boot_images_dict.mapping[image_spec])
def test_insert_item_sets_generic_to_release_item_for_hwe_version(self):
boot_images_dict = BootImageMapping()
dumper = RepoDumper(boot_images_dict)
os = 'ubuntu'
release = 'xenial'
arch = 'amd64'
label = 'release'
hwep_subarch = 'hwe-16.04'
hwep_subarches = ['generic', 'hwe-16.04', 'hwe-16.10']
hwes_subarch = 'hwe-16.10'
hwes_subarches = ['generic', 'hwe-16.04', 'hwe-16.10']
hwep_item, compat_item = self.make_item(os=os,
release=release,
arch=arch,
subarch=hwep_subarch,
subarches=hwep_subarches,
label=label)
hwes_item, _ = self.make_item(os=os,
release=release,
arch=arch,
subarch=hwes_subarch,
subarches=hwes_subarches,
label=label)
self.patch(download_descriptions,
'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)
image_spec = make_image_spec(os=os,
release=release,
arch=arch,
subarch='generic',
label=label)
self.assertEqual(compat_item, boot_images_dict.mapping[image_spec])
def test_extract_metadata(self):
resource = dict(
subarches=factory.make_name("subarch"),
other_item=factory.make_name("other"),
)
image = make_image_spec(kflavor='generic')
mapping = set_resource(image_spec=image, resource=resource)
metadata = mapping.dump_json()
# Lack of consistency across maas in naming arch vs architecture
# and subarch vs subarchitecture means I can't just do a simple
# dict parameter expansion here.
params = {
"osystem": image.os,
"architecture": image.arch,
"subarchitecture": image.subarch,
"release": image.release,
"label": image.label,
}
extracted_data = extract_metadata(metadata, params)
# We only expect the supported_subarches key from the resource data.
expected = dict(supported_subarches=resource["subarches"])
self.assertEqual(expected, extracted_data)
def test_setdefault_sets_unset_item(self):
image_dict = BootImageMapping()
image = make_image_spec()
resource = factory.make_name("resource")
image_dict.setdefault(image, resource)
self.assertItemsEqual([(image, resource)], image_dict.items())
def test_image_does_not_pass_nonmatching_filter(self):
image = make_image_spec()
self.assertFalse(
download_descriptions.image_passes_filter(
[self.make_filter_from_image()], image.os, image.arch,
image.subarch, image.release, image.label))
def test_any_image_passes_empty_filter(self):
os, arch, subarch, kflavor, release, label = make_image_spec()
self.assertTrue(
download_descriptions.image_passes_filter([], os, arch, subarch,
release, label))
def test_any_image_passes_none_filter(self):
os, arch, subarch, _, release, label = make_image_spec()
self.assertTrue(
download_descriptions.image_passes_filter(None, os, arch, subarch,
release, label))
def test_dump_json_is_consistent(self):
image = make_image_spec()
resource = factory.make_name("resource")
image_dict_1 = set_resource(image_spec=image, resource=resource)
image_dict_2 = set_resource(image_spec=image, resource=resource)
self.assertEqual(image_dict_1.dump_json(), image_dict_2.dump_json())
def test_setdefault_leaves_set_item_unchanged(self):
image = make_image_spec()
old_resource = factory.make_name("resource")
image_dict = set_resource(image_spec=image, resource=old_resource)
image_dict.setdefault(image, factory.make_name("newresource"))
self.assertItemsEqual([(image, old_resource)], image_dict.items())
def test_is_empty_returns_False_if_not_empty(self):
mapping = BootImageMapping()
mapping.setdefault(make_image_spec(), factory.make_name("resource"))
self.assertFalse(mapping.is_empty())
def test_items_returns_items(self):
image = make_image_spec()
resource = factory.make_name("resource")
image_dict = set_resource(image_spec=image, resource=resource)
self.assertItemsEqual([(image, resource)], image_dict.items())
