def test_list_all_usable_releases(self): custom_os = factory.make_BootResource( rtype=BOOT_RESOURCE_TYPE.UPLOADED, extra={"title": factory.make_name("title")}, ) factory.make_default_ubuntu_release_bootable() # Bootloader to be ignored. factory.make_BootResource( rtype=BOOT_RESOURCE_TYPE.SYNCED, bootloader_type="uefi" ) self.assertDictEqual( { "custom": [ { "name": custom_os.name, "title": custom_os.extra["title"], "can_commission": False, "requires_license_key": False, } ], "ubuntu": [ { "name": "bionic", "title": 'Ubuntu 18.04 LTS "Bionic Beaver"', "can_commission": True, "requires_license_key": False, } ], }, dict(list_all_usable_releases()), )
def test_list_all_usable_osystems(self): custom_os = factory.make_BootResource( rtype=BOOT_RESOURCE_TYPE.UPLOADED, extra={'title': factory.make_name('title')}) factory.make_default_ubuntu_release_bootable() # Bootloader to be ignored. factory.make_BootResource( rtype=BOOT_RESOURCE_TYPE.SYNCED, bootloader_type='uefi') self.assertItemsEqual([ { 'name': 'custom', 'title': 'Custom', 'default_commissioning_release': None, 'default_release': '', 'releases': [{ 'name': custom_os.name, 'title': custom_os.extra['title'], 'can_commission': False, 'requires_license_key': False, }], }, { 'name': 'ubuntu', 'title': 'Ubuntu', 'default_commissioning_release': 'bionic', 'default_release': 'bionic', 'releases': [{ 'name': 'bionic', 'title': 'Ubuntu 18.04 LTS "Bionic Beaver"', 'can_commission': True, 'requires_license_key': False, }], }], list_all_usable_osystems())
def make_osystem_with_releases(testcase, osystem_name=None, releases=None): """Generate an arbitrary operating system. :param osystem_name: The operating system name. Useful in cases where we need to test that not supplying an os works correctly. :param releases: The list of releases name. Useful in cases where we need to test that not supplying a release works correctly. """ if osystem_name is None: osystem_name = factory.make_name('os') if releases is None: releases = [factory.make_name('release') for _ in range(3)] rpc_releases = [make_rpc_release(release) for release in releases] if osystem_name not in OperatingSystemRegistry: OperatingSystemRegistry.register_item(osystem_name, CustomOS()) testcase.addCleanup(OperatingSystemRegistry.unregister_item, osystem_name) # Make sure the commissioning Ubuntu release and all created releases # are available to all architectures. architectures = [ node.architecture for node in Node.objects.distinct('architecture') ] if len(architectures) == 0: architectures.append('%s/generic' % factory.make_name('arch')) for arch in architectures: factory.make_default_ubuntu_release_bootable(arch.split('/')[0]) for release in releases: factory.make_BootResource(rtype=BOOT_RESOURCE_TYPE.UPLOADED, name=('%s/%s' % (osystem_name, release)), architecture=arch) return make_rpc_osystem(osystem_name, releases=rpc_releases)
def test__uses_present_boot_image(self): rack_controller = factory.make_RackController() local_ip = factory.make_ip_address() remote_ip = factory.make_ip_address() factory.make_default_ubuntu_release_bootable('amd64') observed_config = get_config( rack_controller.system_id, local_ip, remote_ip) self.assertEqual("amd64", observed_config["arch"])
def test__has_enlistment_preseed_url_for_default(self): rack_controller = factory.make_RackController() local_ip = factory.make_ip_address() remote_ip = factory.make_ip_address() factory.make_default_ubuntu_release_bootable() observed_config = get_config( rack_controller.system_id, local_ip, remote_ip) self.assertEqual( compose_enlistment_preseed_url(), observed_config["preseed_url"])
def test__returns_success_for_detailed_but_unknown_node(self): rack_controller = factory.make_RackController() local_ip = factory.make_ip_address() remote_ip = factory.make_ip_address() architecture = make_usable_architecture(self) arch = architecture.split('/')[0] factory.make_default_ubuntu_release_bootable(arch) mac = factory.make_mac_address(delimiter='-') # Should not raise BootConfigNoResponse. get_config( rack_controller.system_id, local_ip, remote_ip, arch=arch, subarch='generic', mac=mac)
def test__has_enlistment_preseed_url_with_local_ip_subnet_with_dns(self): rack_controller = factory.make_RackController() subnet = factory.make_Subnet() local_ip = factory.pick_ip_in_Subnet(subnet) remote_ip = factory.make_ip_address() factory.make_default_ubuntu_release_bootable() observed_config = get_config( rack_controller.system_id, local_ip, remote_ip) self.assertEqual( compose_enlistment_preseed_url( base_url='http://%s:5248/' % local_ip), observed_config["preseed_url"])
def test__has_enlistment_preseed_url_with_region_ip(self): rack_controller = factory.make_RackController() local_ip = factory.make_ip_address() remote_ip = factory.make_ip_address() factory.make_default_ubuntu_release_bootable() Config.objects.set_config('use_rack_proxy', False) observed_config = get_config( rack_controller.system_id, local_ip, remote_ip) self.assertEqual( compose_enlistment_preseed_url( default_region_ip=get_source_address(remote_ip)), observed_config["preseed_url"])
def test__enlistment_checks_default_min_hwe_kernel(self): rack_controller = factory.make_RackController() local_ip = factory.make_ip_address() remote_ip = factory.make_ip_address() arch = 'armhf' Config.objects.set_config('default_min_hwe_kernel', 'hwe-x') self.patch(boot_module, 'get_boot_filenames').return_value = ( None, None, None) factory.make_default_ubuntu_release_bootable(arch) observed_config = get_config( rack_controller.system_id, local_ip, remote_ip, arch=arch) self.assertEqual('hwe-18.04', observed_config['subarch'])
def test__enlistment_return_generic_when_none(self): rack_controller = factory.make_RackController() local_ip = factory.make_ip_address() remote_ip = factory.make_ip_address() arch = 'armhf' self.patch(boot_module, 'get_boot_filenames').return_value = ( None, None, None) self.patch(boot_module, 'validate_hwe_kernel').return_value = None factory.make_default_ubuntu_release_bootable(arch) observed_config = get_config( rack_controller.system_id, local_ip, remote_ip, arch=arch) self.assertEqual('generic', observed_config['subarch'])
def test__commissioning_node_uses_min_hwe_kernel(self): rack_controller = factory.make_RackController() local_ip = factory.make_ip_address() remote_ip = factory.make_ip_address() node = factory.make_Node_with_Interface_on_Subnet( status=NODE_STATUS.COMMISSIONING, min_hwe_kernel="hwe-18.04") arch = node.split_arch()[0] factory.make_default_ubuntu_release_bootable(arch) mac = node.get_boot_interface().mac_address observed_config = get_config( rack_controller.system_id, local_ip, remote_ip, mac=mac, query_count=23) self.assertEqual("hwe-18.04", observed_config["subarch"])
def patch_usable_osystems(testcase, osystems=None, allow_empty=True): """Set a fixed list of usable operating systems. A usable operating system is one for which boot images are available. :param testcase: A `TestCase` whose `patch` this function can use. :param osystems: Optional list of operating systems. If omitted, defaults to a list (which may be empty) of random operating systems. """ start = 0 if allow_empty is False: start = 1 if osystems is None: osystems = [ make_osystem_with_releases(testcase) for _ in range(randint(start, 2)) ] os_releases = [] for osystem in osystems: for release in osystem['releases']: os_releases.append({ 'osystem': osystem['name'], 'release': release['name'], 'purpose': 'xinstall', }) # Make sure the Commissioning release is always available. ubuntu = factory.make_default_ubuntu_release_bootable() os_releases.append({ 'osystem': ubuntu.name.split('/')[0], 'release': ubuntu.name.split('/')[1], 'purpose': 'xinstall', }) testcase.patch( boot_images, 'get_common_available_boot_images').return_value = os_releases
def test_list_all_usable_osystems(self): custom_os = factory.make_BootResource( rtype=BOOT_RESOURCE_TYPE.UPLOADED, extra={"title": factory.make_name("title")}, ) factory.make_default_ubuntu_release_bootable() # Bootloader to be ignored. factory.make_BootResource(rtype=BOOT_RESOURCE_TYPE.SYNCED, bootloader_type="uefi") self.assertItemsEqual( [ { "name": "custom", "title": "Custom", "default_commissioning_release": None, "default_release": "", "releases": [{ "name": custom_os.name, "title": custom_os.extra["title"], "can_commission": False, "requires_license_key": False, }], }, { "name": "ubuntu", "title": "Ubuntu", "default_commissioning_release": "focal", "default_release": "focal", "releases": [{ "name": "focal", "title": 'Ubuntu 20.04 LTS "Focal Fossa"', "can_commission": True, "requires_license_key": False, }], }, ], list_all_usable_osystems(), )
def make_arch( with_subarch=True, arch_name=None, subarch_name=None, extra=None ): """Generate an arbitrary architecture name. :param with_subarch: Should the architecture include a slash and a sub-architecture name? Defaults to `True`. """ if arch_name is None: arch_name = factory.make_name("arch") factory.make_default_ubuntu_release_bootable(arch_name, extra=extra) if with_subarch: if subarch_name is None: subarch_name = factory.make_name("sub") return "%s/%s" % (arch_name, subarch_name) else: return arch_name
def test__has_enlistment_preseed_url_internal_domain(self): rack_controller = factory.make_RackController() vlan = factory.make_VLAN(dhcp_on=True, primary_rack=rack_controller) subnet = factory.make_Subnet(vlan=vlan) subnet.dns_servers = [] subnet.save() local_ip = factory.pick_ip_in_Subnet(subnet) remote_ip = factory.make_ip_address() factory.make_default_ubuntu_release_bootable() observed_config = get_config( rack_controller.system_id, local_ip, remote_ip) self.assertEqual( compose_enlistment_preseed_url( base_url='http://%s.%s:5248/' % ( get_resource_name_for_subnet(subnet), Config.objects.get_config('maas_internal_domain'))), observed_config["preseed_url"])
def test__returns_global_kernel_params_for_enlisting_node(self): # An 'enlisting' node means it looks like a node with details but we # don't know about it yet. It should still receive the global # kernel options. rack_controller = factory.make_RackController() local_ip = factory.make_ip_address() remote_ip = factory.make_ip_address() value = factory.make_string() Config.objects.set_config("kernel_opts", value) architecture = make_usable_architecture(self) arch = architecture.split('/')[0] factory.make_default_ubuntu_release_bootable(arch) mac = factory.make_mac_address(delimiter='-') observed_config = get_config( rack_controller.system_id, local_ip, remote_ip, arch=arch, subarch='generic', mac=mac) self.assertEqual(value, observed_config['extra_opts'])
def make_osystem_with_releases(testcase, osystem_name=None, releases=None): """Generate an arbitrary operating system. :param osystem_name: The operating system name. Useful in cases where we need to test that not supplying an os works correctly. :param releases: The list of releases name. Useful in cases where we need to test that not supplying a release works correctly. """ if osystem_name is None: osystem_name = factory.make_name('os') if releases is None: releases = [factory.make_name('release') for _ in range(3)] rpc_releases = [make_rpc_release(release) for release in releases] # If this is being used to test commissioning make sure the default # Ubuntu release is bootable for every known architecture. for node in Node.objects.all(): factory.make_default_ubuntu_release_bootable(node.split_arch()[0]) return make_rpc_osystem(osystem_name, releases=rpc_releases)
def setUp(self): super().setUp() self.patch(Node, 'get_effective_power_info').return_value = ( PowerInfo(False, False, False, None, None)) ubuntu = factory.make_default_ubuntu_release_bootable() osystem, release = ubuntu.name.split('/') self.patch( boot_images, 'get_common_available_boot_images').return_value = [{ 'osystem': osystem, 'release': release, 'purpose': 'xinstall', }]
def setUp(self): super().setUp() self.patch(Node, "get_effective_power_info").return_value = PowerInfo( False, False, False, None, None ) ubuntu = factory.make_default_ubuntu_release_bootable() osystem, release = ubuntu.name.split("/") self.patch( boot_images, "get_common_available_boot_images" ).return_value = [ {"osystem": osystem, "release": release, "purpose": "xinstall"} ]
def test_allows_no_boot_dtb(self): release = factory.make_default_ubuntu_release_bootable() arch, subarch = release.architecture.split('/') osystem, series = release.name.split('/') boot_resource_set = release.get_latest_complete_set() kernel, initrd, boot_dbt = get_boot_filenames(arch, subarch, osystem, series) self.assertEquals( boot_resource_set.files.get( filetype=BOOT_RESOURCE_FILE_TYPE.BOOT_KERNEL).filename, kernel) self.assertEquals( boot_resource_set.files.get( filetype=BOOT_RESOURCE_FILE_TYPE.BOOT_INITRD).filename, initrd) self.assertIsNone(boot_dbt)
def test__commissioning_node_uses_min_hwe_kernel(self): rack_controller = factory.make_RackController() local_ip = factory.make_ip_address() remote_ip = factory.make_ip_address() node = factory.make_Node_with_Interface_on_Subnet( status=NODE_STATUS.COMMISSIONING, min_hwe_kernel="hwe-16.10") arch = node.split_arch()[0] ubuntu = factory.make_default_ubuntu_release_bootable(arch) factory.make_usable_boot_resource( name=ubuntu.name, architecture="%s/hwe-16.10" % arch, kflavor='generic', rtype=BOOT_RESOURCE_TYPE.SYNCED) mac = node.get_boot_interface().mac_address observed_config = get_config( rack_controller.system_id, local_ip, remote_ip, mac=mac) self.assertEqual("hwe-16.10", observed_config["subarch"])
def test_settings_commissioning_POST(self): self.client.login(user=factory.make_admin()) ubuntu = factory.make_default_ubuntu_release_bootable() new_commissioning = ubuntu.name.split('/')[1] response = self.client.post( reverse('settings_general'), get_prefixed_form_data(prefix='commissioning', data={ 'commissioning_distro_series': (new_commissioning), })) self.assertEqual(http.client.FOUND, response.status_code) self.assertEqual( (new_commissioning, ), (Config.objects.get_config('commissioning_distro_series'), ))
def test_get_filenames_finds_subarch_when_generic(self): release = factory.make_default_ubuntu_release_bootable() arch = release.architecture.split('/')[0] osystem, series = release.name.split('/') boot_resource_set = release.get_latest_complete_set() factory.make_boot_resource_file_with_content( boot_resource_set, filetype=BOOT_RESOURCE_FILE_TYPE.BOOT_DTB) kernel, initrd, boot_dbt = get_boot_filenames(arch, 'generic', osystem, series) self.assertEquals( boot_resource_set.files.get( filetype=BOOT_RESOURCE_FILE_TYPE.BOOT_KERNEL).filename, kernel) self.assertEquals( boot_resource_set.files.get( filetype=BOOT_RESOURCE_FILE_TYPE.BOOT_INITRD).filename, initrd) self.assertEquals( boot_resource_set.files.get( filetype=BOOT_RESOURCE_FILE_TYPE.BOOT_DTB).filename, boot_dbt)