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_does_not_overwrite_existing_entry(self):
image = make_image_spec()
total_resources = set_resource(resource="Original resource",
image_spec=image)
original_resources = total_resources.mapping.copy()
resources_from_repo = set_resource(resource="New resource",
image_spec=image)
download_descriptions.boot_merge(total_resources, resources_from_repo)
self.assertEqual(original_resources, total_resources.mapping)
def test_extract_metadata_parses_kflavor(self):
resource = dict(
subarches=factory.make_name("subarch"),
other_item=factory.make_name("other"),
)
image = make_image_spec(subarch='hwe-16.04-lowlatency',
kflavor='lowlatency')
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_integrates(self):
# End-to-end scenario for boot_merge: start with an empty boot
# resources dict, and receive one resource from Simplestreams.
total_resources = BootImageMapping()
resources_from_repo = set_resource()
download_descriptions.boot_merge(total_resources, resources_from_repo)
# Since we started with an empty dict, the result contains the same
# item that we got from Simplestreams, and nothing else.
self.assertEqual(resources_from_repo.mapping, total_resources.mapping)
def test_get_image_arches_gets_arches_from_imagespecs(self):
expected_arches = set()
mapping = None
for _ in range(0, 3):
image_spec = make_image_spec()
resource = factory.make_name("resource")
expected_arches.add(image_spec.arch)
mapping = set_resource(mapping, image_spec, resource)
self.assertEqual(expected_arches, mapping.get_image_arches())
def test_concatenates_similar_resources(self):
image1 = make_image_spec()
image2 = make_image_spec()
resource = make_boot_resource()
boot_dict = BootImageMapping()
# Create two images in boot_dict, both containing the same resource.
for image in [image1, image2]:
set_resource(
boot_dict=boot_dict, resource=resource.copy(), image_spec=image
)
products_mapping = map_products(boot_dict)
key = (
resource["content_id"],
resource["product_name"],
resource["version_name"],
)
self.assertEqual([key], list(products_mapping.mapping))
self.assertItemsEqual(
[image1.subarch, image2.subarch], products_mapping.get(resource)
)
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_obeys_filters(self):
filters = [{
"os": factory.make_name("os"),
"arches": [factory.make_name("other-arch")],
"subarches": [factory.make_name("other-subarch")],
"release": factory.make_name("other-release"),
"label": [factory.make_name("other-label")],
}]
total_resources = BootImageMapping()
resources_from_repo = set_resource()
download_descriptions.boot_merge(total_resources,
resources_from_repo,
filters=filters)
self.assertEqual({}, total_resources.mapping)
def test_obeys_filters(self):
filters = [
{
'os': factory.make_name('os'),
'arches': [factory.make_name('other-arch')],
'subarches': [factory.make_name('other-subarch')],
'release': factory.make_name('other-release'),
'label': [factory.make_name('other-label')],
},
]
total_resources = BootImageMapping()
resources_from_repo = set_resource()
download_descriptions.boot_merge(total_resources,
resources_from_repo,
filters=filters)
self.assertEqual({}, total_resources.mapping)
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_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_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_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())
