def test__renders_with_hosts(self):
params = make_sample_params(self, ipv6=self.ipv6)
self.assertThat(
params["hosts"], AfterPreprocessing(len, GreaterThanOrEqual(1))
)
config_output = config.get_config(self.template, **params)
validate_dhcpd_configuration(self, config_output, self.ipv6)
self.assertThat(
config_output,
ContainsAll([host["host"] for host in params["hosts"]]),
)
self.assertThat(
config_output,
ContainsAll([host["mac"] for host in params["hosts"]]),
)
self.assertThat(
config_output,
ContainsAll([host["ip"] for host in params["hosts"]]),
)
def test_GET_returns_boot_resource(self):
resource = factory.make_usable_boot_resource()
response = self.client.get(get_boot_resource_uri(resource))
self.assertEqual(http.client.OK, response.status_code)
returned_resource = json_load_bytes(response.content)
# The returned object contains a 'resource_uri' field.
self.assertEqual(reverse('boot_resource_handler', args=[resource.id]),
returned_resource['resource_uri'])
self.assertThat(returned_resource,
ContainsAll(['id', 'type', 'name', 'architecture']))
def test_compose_rootfs_over_http_ipv6(self):
params = make_kernel_parameters(fs_host=factory.make_ipv6_address())
self.assertThat(
compose_kernel_command_line(params),
ContainsAll([
"ro",
"root=squash:http://[%s]:5248/images/%s/%s/%s/%s/%s/squashfs" %
(params.fs_host, params.osystem, params.arch, params.subarch,
params.release, params.label)
]))
def test_settings_contains_links_to_edit(self):
self.client.login(user=factory.make_admin())
keys, _ = self.make_license_keys(3)
links = get_content_links(
self.client.get(reverse("settings_license_keys")))
license_key_delete_links = [
reverse("license-key-edit", args=[key.osystem, key.distro_series])
for key in keys
]
self.assertThat(links, ContainsAll(license_key_delete_links))
def test__includes_other_class_attributes(self):
class Example:
alice = "is the first"
bob = lambda self: "just bob"
dave = property(lambda self: "or david")
example = Example()
self.assertThat(list(dir_instance(example)),
ContainsAll(["alice", "bob", "dave"]))
def test_GET_lists_users(self):
users = [factory.make_User() for counter in range(2)]
response = self.client.get(reverse('users_handler'))
self.assertEqual(http.client.OK, response.status_code,
response.content)
listing = json.loads(response.content.decode(settings.DEFAULT_CHARSET))
self.assertThat([user['username'] for user in listing],
ContainsAll([user.username for user in users]))
def test__includes_other_class_attributes(self):
class Example:
alice = "is the first"
bob = lambda self: "just bob"
carol = classmethod(lambda cls: "carol")
dave = property(lambda self: "dave or david")
erin = staticmethod(lambda: "or eve?")
self.assertThat(list(dir_class(Example)),
ContainsAll(["alice", "bob", "carol", "dave", "erin"]))
def test_settings_contains_osystem_and_distro_series(self):
self.client.login(user=factory.make_admin())
keys, _ = self.make_license_keys(3)
response = self.client.get(reverse("settings_license_keys"))
os_titles = [key.osystem for key in keys]
series_titles = [key.distro_series for key in keys]
self.assertThat(
response.content.decode(settings.DEFAULT_CHARSET),
ContainsAll([title for title in os_titles + series_titles]),
)
def test_get_reader_scenarios(self):
# The commissioning config uses an extra PXELINUX module to auto
# select between i386 and amd64.
method = PXEBootMethod()
get_ephemeral_name = self.patch(kernel_opts, "get_ephemeral_name")
get_ephemeral_name.return_value = factory.make_name("ephemeral")
osystem = factory.make_name('osystem')
options = {
"backend":
None,
"kernel_params":
make_kernel_parameters(testcase=self,
osystem=osystem,
subarch="generic",
purpose='enlist'),
}
fs_host = 'http://%s:5248/images' % (convert_host_to_uri_str(
options['kernel_params'].fs_host))
output = method.get_reader(**options).read(10000).decode("utf-8")
config = parse_pxe_config(output)
# The default section is defined.
default_section_label = config.header["DEFAULT"]
self.assertThat(config, Contains(default_section_label))
default_section = config[default_section_label]
# The default section uses the ifcpu64 module, branching to the "i386"
# or "amd64" labels accordingly.
self.assertEqual("ifcpu64.c32", default_section["KERNEL"])
self.assertEqual(["amd64", "--", "i386"],
default_section["APPEND"].split())
# Both "i386" and "amd64" sections exist.
self.assertThat(config, ContainsAll(("i386", "amd64")))
# Each section defines KERNEL, INITRD, and APPEND settings. The
# KERNEL and INITRD ones contain paths referring to their
# architectures.
for section_label in ("i386", "amd64"):
section = config[section_label]
self.assertThat(section, ContainsAll(
("KERNEL", "INITRD", "APPEND")))
contains_arch_path = StartsWith("%s/%s/%s/" %
(fs_host, osystem, section_label))
self.assertThat(section["KERNEL"], contains_arch_path)
self.assertThat(section["INITRD"], contains_arch_path)
self.assertIn("APPEND", section)
def test_settings_contains_names_and_content_of_scripts(self):
self.client.login(user=factory.make_admin())
scripts = [
factory.make_Script(script_type=SCRIPT_TYPE.TESTING),
factory.make_Script(script_type=SCRIPT_TYPE.TESTING),
factory.make_Script(script_type=SCRIPT_TYPE.TESTING, default=True),
]
response = self.client.get(reverse("settings_scripts"))
names = [script.name for script in scripts[:-1]]
contents = [script.script.data for script in scripts[:-1]]
self.assertThat(
response.content,
ContainsAll(
[name.encode(settings.DEFAULT_CHARSET) for name in names]),
)
self.assertThat(
response.content,
ContainsAll([content.encode() for content in contents]),
)
def test__renders_global_dhcp_snippets(self):
params = make_sample_params(self, ipv6=self.ipv6)
config_output = config.get_config(self.template, **params)
validate_dhcpd_configuration(self, config_output, self.ipv6)
self.assertThat(
config_output,
ContainsAll([
dhcp_snippet['value']
for dhcp_snippet in params['global_dhcp_snippets']
]))
def test_opencv(self):
snap_path = self.build_snap(self.snap_content_dir)
bin_path = os.path.join(os.path.dirname(snap_path), 'prime', 'bin',
'example')
self.assertThat(bin_path, FileExists())
interpreter = subprocess.check_output(
['patchelf', '--print-interpreter', bin_path]).decode()
expected_interpreter = r'^/snap/core/current/.*'
self.assertThat(interpreter, MatchesRegex(expected_interpreter))
arch_triplet = snapcraft.ProjectOptions().arch_triplet
# test $ORIGIN in action
rpath = subprocess.check_output(
['patchelf', '--print-rpath', bin_path]).decode()
expected_rpath = '$ORIGIN/../usr/lib/{}:'.format(arch_triplet)
self.assertThat(rpath, Contains(expected_rpath))
# test $ORIGIN applied
ldd = subprocess.check_output(['ldd', bin_path]).decode()
expected_opencv_path = (
'/prime/bin/../usr/lib/{}/libopencv_core'.format(arch_triplet))
self.assertThat(ldd, Contains(expected_opencv_path))
self.install_snap(snap_path, 'opencv-example', '1.0', classic=True)
if not snaps_tests.config.get('skip-install', False):
output = self.run_command_in_snappy_testbed(
'/snap/bin/opencv-example.example').splitlines()
# Depending on opencv the result is now displayed differently
# so let's do a lazy match.
# On artful you see:
# [ 1, 3;
# 2, 4]
# And on others:
# [1, 3;
# 2, 4]
expected_in_first_line = ['[', '1', ',', '3', ';']
self.assertThat(output[0], ContainsAll(expected_in_first_line))
expected_in_second_line = ['2', ',', '4', ']']
self.assertThat(output[1], ContainsAll(expected_in_second_line))
def test__generate_pod_types_doc_generates_describes_types(self):
pod_driver = random.choice([
driver
for _, driver in PodDriverRegistry
])
doc = generate_pod_types_doc()
self.assertThat(
doc,
ContainsAll([
pod_driver.name,
pod_driver.description]))
def test_settings_contains_links_to_delete_scripts(self):
self.client.login(user=factory.make_admin())
scripts = {
factory.make_Script(script_type=SCRIPT_TYPE.TESTING),
factory.make_Script(script_type=SCRIPT_TYPE.TESTING),
}
links = get_content_links(self.client.get(reverse('settings_scripts')))
script_delete_links = [
reverse('test-script-delete', args=[script.id])
for script in scripts]
self.assertThat(links, ContainsAll(script_delete_links))
def test__loads_yaml_embedded_attributes(self):
embedded_yaml = {
'name': factory.make_name('name'),
'title': factory.make_name('title'),
'description': factory.make_name('description'),
'tags': [factory.make_name('tag') for _ in range(3)],
'script_type': factory.pick_choice(SCRIPT_TYPE_CHOICES),
'hardware_type': factory.pick_choice(HARDWARE_TYPE_CHOICES),
'parallel': factory.pick_choice(SCRIPT_PARALLEL_CHOICES),
'results': ['write_speed'],
'parameters': [{'type': 'storage'}, {'type': 'runtime'}],
'packages': {'apt': [factory.make_name('package')]},
'timeout': random.randint(0, 1000),
'destructive': factory.pick_bool(),
'may_reboot': factory.pick_bool(),
}
if embedded_yaml['script_type'] == SCRIPT_TYPE.COMMISSIONING:
embedded_yaml['for_hardware'] = [
'modalias:%s' % factory.make_name('mod_alias'),
'pci:%04X:%04x' % (
random.randint(0, 9999), random.randint(0, 9999)),
'usb:%04X:%04x' % (
random.randint(0, 9999), random.randint(0, 9999)),
]
embedded_yaml['recommission'] = factory.pick_bool()
script_content = factory.make_script_content(embedded_yaml)
form = ScriptForm(data={'script': script_content})
self.assertTrue(form.is_valid(), form.errors)
script = form.save()
self.assertEquals(embedded_yaml['name'], script.name)
self.assertEquals(embedded_yaml['title'], script.title)
self.assertEquals(embedded_yaml['description'], script.description)
self.assertThat(script.tags, ContainsAll(embedded_yaml['tags']))
self.assertEquals(embedded_yaml['script_type'], script.script_type)
self.assertEquals(embedded_yaml['hardware_type'], script.hardware_type)
self.assertEquals(embedded_yaml['parallel'], script.parallel)
self.assertItemsEqual(embedded_yaml['results'], script.results)
self.assertItemsEqual(embedded_yaml['parameters'], script.parameters)
self.assertDictEqual(embedded_yaml['packages'], script.packages)
self.assertEquals(
timedelta(0, embedded_yaml['timeout']), script.timeout)
self.assertEquals(embedded_yaml['destructive'], script.destructive)
self.assertEquals(embedded_yaml['may_reboot'], script.may_reboot)
if embedded_yaml['script_type'] == SCRIPT_TYPE.COMMISSIONING:
self.assertItemsEqual(
embedded_yaml['for_hardware'], script.for_hardware)
self.assertEquals(
embedded_yaml['recommission'], script.recommission)
else:
self.assertItemsEqual([], script.for_hardware)
self.assertFalse(script.recommission)
self.assertFalse(script.default)
self.assertEquals(script_content, script.script.data)
def test_enlist_compose_kernel_command_line_inc_purpose_opts6(self):
# The result of compose_kernel_command_line includes the purpose
# options for a non "commissioning" node.
params = self.make_kernel_parameters(
purpose="enlist", fs_host=factory.make_ipv6_address())
cmdline = compose_kernel_command_line(params)
self.assertThat(
cmdline,
ContainsAll([
"root=squash:http://", "overlayroot=tmpfs", "ip=off",
"ip6=dhcp"
]))
def test_enlist_compose_kernel_command_line_inc_cc_datasource(self):
# The result of compose_kernel_command_line includes the cloud-init
# options for the datasource and cloud-config-url
params = self.make_kernel_parameters(
purpose="enlist", fs_host=factory.make_ipv4_address())
cmdline = compose_kernel_command_line(params)
self.assertThat(
cmdline,
ContainsAll([
"cc:{'datasource_list': ['MAAS']}end_cc",
"cloud-config-url=%s" % params.preseed_url
]))
def test_renders_node_dhcp_snippets(self):
params = make_sample_params(self, ipv6=self.ipv6)
config_output = config.get_config(self.template, **params)
validate_dhcpd_configuration(self, config_output, self.ipv6)
for host in params["hosts"]:
self.assertThat(
config_output,
ContainsAll([
dhcp_snippet["value"]
for dhcp_snippet in host["dhcp_snippets"]
]),
)
def test_volume_busy_error_on_busy_state(self, logger):
"""
A ``VolumeBusy`` is raised if a volume's attachment state is "busy"
when attempting to detach the volume. This can occur if an attempt
is made to detach a volume that has not been unmounted.
"""
try:
config = get_blockdevice_config()
except InvalidConfig as e:
self.skipTest(str(e))
# Create a volume
dataset_id = uuid4()
flocker_volume = self.api.create_volume(
dataset_id=dataset_id,
size=self.minimum_allocatable_size,
)
ec2_client = get_ec2_client_for_test(config)
# Attach the volume.
instance_id = self.api.compute_instance_id()
self.api.attach_volume(flocker_volume.blockdevice_id, instance_id)
volume = ec2_client.connection.Volume(flocker_volume.blockdevice_id)
def clean_volume(volume):
volume.detach_from_instance()
_wait_for_volume_state_change(VolumeOperations.DETACH, volume)
volume.delete()
self.addCleanup(clean_volume, volume)
# Artificially set the volume's attachment state to "busy", by
# monkey-patching the EBS driver's ``_get_ebs_volume`` method.
def busy_ebs_volume(volume_id):
busy_volume = ec2_client.connection.Volume(volume_id)
busy_volume.load()
if busy_volume.attachments:
busy_volume.attachments[0]['State'] = "busy"
return busy_volume
self.patch(self.api, "_get_ebs_volume", busy_ebs_volume)
# Try to detach and get the VolumeBusy exception.
self.assertRaises(VolumeBusy, self.api.detach_volume,
flocker_volume.blockdevice_id)
expected_keys = set(["volume_id", "attachments"])
messages = [
message.message for message in LoggedMessage.of_type(
logger.messages, VOLUME_BUSY_MESSAGE)
]
self.assertThat(messages, AllMatch(ContainsAll(expected_keys)))
def test_xinstall_compose_kernel_command_line_inc_purpose_opts4(self):
# The result of compose_kernel_command_line includes the purpose
# options for a non "xinstall" node.
params = self.make_kernel_parameters(
purpose="xinstall", fs_host=factory.make_ipv4_address())
cmdline = compose_kernel_command_line(params)
self.assertThat(
cmdline,
ContainsAll([
"root=squash:http://", "overlayroot=tmpfs", "ip6=off",
"ip=::::%s:BOOTIF" % params.hostname
]))
def test__renders_subnet_dhcp_snippets(self):
params = make_sample_params(self, ipv6=self.ipv6)
config_output = config.get_config(self.template, **params)
validate_dhcpd_configuration(self, config_output, self.ipv6)
for shared_network in params['shared_networks']:
for subnet in shared_network['subnets']:
self.assertThat(
config_output,
ContainsAll([
dhcp_snippet['value']
for dhcp_snippet in subnet['dhcp_snippets']
]))
def test_settings_contains_links_to_delete_scripts(self):
self.client.login(user=factory.make_admin())
scripts = {
factory.make_Script(script_type=SCRIPT_TYPE.COMMISSIONING),
factory.make_Script(script_type=SCRIPT_TYPE.COMMISSIONING),
}
links = get_content_links(self.client.get(reverse("settings_scripts")))
script_delete_links = [
reverse("commissioning-script-delete", args=[script.id])
for script in scripts
]
self.assertThat(links, ContainsAll(script_delete_links))
def test__update(self):
script = factory.make_Script()
name = factory.make_name('name')
title = factory.make_name('title')
description = factory.make_name('description')
tags = [factory.make_name('tag') for _ in range(3)]
script_type = factory.pick_choice(SCRIPT_TYPE_CHOICES)
hardware_type = factory.pick_choice(HARDWARE_TYPE_CHOICES)
parallel = factory.pick_choice(SCRIPT_PARALLEL_CHOICES)
packages = {'apt': [factory.make_name('package')]}
timeout = random.randint(0, 1000)
destructive = factory.pick_bool()
script_content = factory.make_script_content()
comment = factory.make_name('comment')
orig_script_content = script.script.data
form = ScriptForm(data={
'name': name,
'title': title,
'description': description,
'tags': ','.join(tags),
'type': script_type,
'hardware_type': hardware_type,
'parallel': parallel,
'packages': json.dumps(packages),
'timeout': str(timeout),
'destructive': destructive,
'script': script_content,
'comment': comment,
},
instance=script)
self.assertTrue(form.is_valid(), form.errors)
script = form.save()
self.assertEquals(name, script.name)
self.assertEquals(title, script.title)
self.assertEquals(description, script.description)
self.assertThat(script.tags, ContainsAll(tags))
self.assertEquals(script_type, script.script_type)
self.assertEquals(hardware_type, script.hardware_type)
self.assertEquals(parallel, script.parallel)
self.assertDictEqual({}, script.results)
self.assertDictEqual({}, script.parameters)
self.assertDictEqual(packages, script.packages)
self.assertEquals(timedelta(0, timeout), script.timeout)
self.assertEquals(destructive, script.destructive)
self.assertEquals(script_content, script.script.data)
self.assertEquals(comment, script.script.comment)
self.assertEquals(orig_script_content,
script.script.previous_version.data)
self.assertEquals(None, script.script.previous_version.comment)
self.assertFalse(script.default)
def test_PUT(self):
self.become_admin()
script = factory.make_Script()
name = factory.make_name("script")
title = factory.make_name("title")
description = factory.make_name("description")
tags = [factory.make_name("tag") for _ in range(3)]
script_type = factory.pick_choice(SCRIPT_TYPE_CHOICES)
script_type = factory.pick_choice(SCRIPT_TYPE_CHOICES)
hardware_type = factory.pick_choice(HARDWARE_TYPE_CHOICES)
parallel = factory.pick_choice(SCRIPT_PARALLEL_CHOICES)
packages = {"apt": [factory.make_name("apt_pkg")]}
timeout = random.randint(0, 1000)
destructive = factory.pick_bool()
script_content = factory.make_script_content()
comment = factory.make_name("comment")
response = self.client.put(
self.get_script_uri(script),
{
"name": name,
"title": title,
"description": description,
"tags": ",".join(tags),
"type": script_type,
"hardware_type": hardware_type,
"parallel": parallel,
"packages": json.dumps(packages),
"timeout": timeout,
"destructive": destructive,
"script": factory.make_file_upload(
content=script_content.encode()
),
"comment": comment,
},
)
self.assertThat(response, HasStatusCode(http.client.OK))
script = reload_object(script)
self.assertEquals(name, script.name)
self.assertEquals(title, script.title)
self.assertEquals(description, script.description)
self.assertThat(script.tags, ContainsAll(tags))
self.assertEquals(script_type, script.script_type)
self.assertEquals(hardware_type, script.hardware_type)
self.assertEquals(parallel, script.parallel)
self.assertDictEqual(packages, script.packages)
self.assertEquals(timeout, script.timeout.seconds)
self.assertEquals(destructive, script.destructive)
self.assertEquals(script_content, script.script.data)
self.assertEquals(comment, script.script.comment)
self.assertIsNotNone(script.script.previous_version)
def tests_yaml_tags_can_be_list_of_strings(self):
tags = [factory.make_name("tag") for _ in range(3)]
form = ScriptForm(
data={
"script":
factory.make_script_content({
"name": factory.make_name("name"),
"tags": tags
})
})
self.assertTrue(form.is_valid(), form.errors)
script = form.save()
self.assertThat(script.tags, ContainsAll(tags))
def test_update_volume_metadata(self):
# Update metadata for the volume
metadata = {"key1": "value1", "key2": "value2", "key3": "value3"}
update = {"key4": "value4", "key1": "value1_update"}
# Create metadata for the volume
resp, body = self.volumes_client.create_volume_metadata(
self.volume_id, metadata)
self.assertEqual(200, resp.status)
# Get the metadata of the volume
resp, body = self.volumes_client.get_volume_metadata(self.volume_id)
self.assertEqual(200, resp.status)
self.assertThat(body.items(), ContainsAll(metadata.items()))
# Update metadata
resp, body = self.volumes_client.update_volume_metadata(
self.volume_id, update)
self.assertEqual(200, resp.status)
# Get the metadata of the volume
resp, body = self.volumes_client.get_volume_metadata(self.volume_id)
self.assertEqual(200, resp.status)
self.assertThat(body.items(), ContainsAll(update.items()))
def test_writes_dns_zone_config_with_NS_record(self):
target_dir = patch_dns_config_path(self)
addr_ttl = random.randint(10, 100)
ns_host_name = factory.make_name("ns")
dns_zone_config = DNSForwardZoneConfig(factory.make_string(),
serial=random.randint(1, 100),
ns_host_name=ns_host_name,
ipv4_ttl=addr_ttl,
ipv6_ttl=addr_ttl)
dns_zone_config.write_config()
self.assertThat(
os.path.join(target_dir, 'zone.%s' % dns_zone_config.domain),
FileContains(matcher=ContainsAll(['30 IN NS %s.' % ns_host_name])))
def tests_yaml_tags_can_be_list_of_strings(self):
tags = [factory.make_name('tag') for _ in range(3)]
form = ScriptForm(
data={
'script':
factory.make_script_content({
'name': factory.make_name('name'),
'tags': tags,
})
})
self.assertTrue(form.is_valid(), form.errors)
script = form.save()
self.assertThat(script.tags, ContainsAll(tags))
def test__generate_power_types_doc_generates_describes_power_type(self):
power_driver = random.choice([
driver for _, driver in PowerDriverRegistry
if len(driver.settings) > 0
])
doc = generate_power_types_doc()
self.assertThat(
doc,
ContainsAll([
power_driver.name, power_driver.description,
power_driver.settings[0]['name'],
power_driver.settings[0]['label']
]))
def test_update_script(self):
load_builtin_scripts()
update_script_values = random.choice(BUILTIN_SCRIPTS)
script = Script.objects.get(name=update_script_values.name)
# Fields which we can update
orig_title = script.title
orig_description = script.description
orig_script_type = script.script_type
orig_results = script.results
orig_parameters = script.parameters
script.title = factory.make_string()
script.description = factory.make_string()
script.script_type = factory.pick_choice(SCRIPT_TYPE_CHOICES)
script.results = [factory.make_name("result")]
script.script.parameters = {
factory.make_name("param"): {
"type": "storage"
}
}
# Put fake old data in to simulate updating a script.
old_script = VersionedTextFile.objects.create(
data=factory.make_string())
script.script = old_script
# User changeable fields.
user_tags = [factory.make_name("tag") for _ in range(3)]
script.tags = copy.deepcopy(user_tags)
user_timeout = timedelta(random.randint(0, 1000))
script.timeout = user_timeout
script.save()
load_builtin_scripts()
script = reload_object(script)
self.assertEquals(orig_title, script.title, script.name)
self.assertEquals(orig_description, script.description, script.name)
self.assertEquals(orig_script_type, script.script_type, script.name)
self.assertDictEqual(orig_results, script.results, script.name)
self.assertDictEqual(orig_parameters, script.parameters, script.name)
self.assertThat(script.tags, ContainsAll(user_tags))
self.assertEquals(user_timeout, script.timeout)
self.assertEquals(old_script, script.script.previous_version)
self.assertEquals("Updated by maas-%s" % get_maas_version(),
script.script.comment)
self.assertTrue(script.default)
