def test_includes_only_osystems_that_require_license_keys(self): osystems = [] for _ in range(2): release = make_rpc_release(requires_license_key=True) osystems.append(make_rpc_osystem(releases=[release])) patch_usable_osystems(self, osystems=osystems + [make_rpc_osystem()]) choices = [(osystem['name'], osystem['title']) for osystem in sorted(osystems, key=itemgetter('title'))] form = LicenseKeyForm() self.assertEqual(choices, form.fields['osystem'].choices)
def test_rejects_when_validate_license_key_returns_False(self): user = factory.make_User() self.client.login(user=user) node = factory.make_Node(owner=user) release = make_rpc_release(requires_license_key=True) osystem = make_rpc_osystem(releases=[release]) patch_usable_osystems(self, osystems=[osystem]) license_key = factory.make_name('key') mock_validate = self.patch(forms, 'validate_license_key') mock_validate.return_value = False form = MachineForm(data={ 'hostname': factory.make_name('host'), 'architecture': make_usable_architecture(self), 'osystem': osystem['name'], 'distro_series': '%s/%s*' % (osystem['name'], release['name']), 'license_key': license_key, }, instance=node) self.assertFalse(form.is_valid()) self.assertItemsEqual(['license_key'], form._errors.keys())
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 make_os_with_license_key(self): """Makes a fake operating system that has a release that requires a license key.""" release = make_rpc_release(requires_license_key=True) osystem = make_rpc_osystem(releases=[release]) patch_usable_osystems(self, osystems=[osystem]) return osystem, release
def make_osystem_requiring_license_key(osystem=None, distro_series=None): if osystem is None: osystem = factory.make_name('osystem') if distro_series is None: distro_series = factory.make_name('distro_series') rpc_release = make_rpc_release(distro_series, requires_license_key=True) rpc_osystem = make_rpc_osystem(osystem, releases=[rpc_release]) return rpc_osystem
def make_license_key_with_os(self, license_key=None): release = make_rpc_release(requires_license_key=True) osystem = make_rpc_osystem(releases=[release]) patch_usable_osystems(self, osystems=[osystem]) license_key = factory.make_LicenseKey(osystem=osystem['name'], distro_series=release['name'], license_key=license_key) return license_key
def test_includes_osystem_in_choices(self): osystems = [] for _ in range(3): release = make_rpc_release(requires_license_key=True) osystems.append(make_rpc_osystem(releases=[release])) patch_usable_osystems(self, osystems=osystems) choices = [(osystem['name'], osystem['title']) for osystem in osystems] form = LicenseKeyForm() self.assertItemsEqual(choices, form.fields['osystem'].choices)
def test_get_distro_series_initial(self): releases = [make_rpc_release() for _ in range(3)] osystem = make_rpc_osystem(releases=releases) release = random.choice(releases) node = factory.make_Node( osystem=osystem['name'], distro_series=release['name']) self.assertEqual( '%s/%s' % (osystem['name'], release['name']), get_distro_series_initial( [osystem], node, with_key_required=False))
def test_list_release_choices(self): releases = [make_rpc_release() for _ in range(3)] osystem = make_rpc_osystem(releases=releases) choices = [ self.make_release_choice(osystem, release) for release in releases ] self.assertItemsEqual( choices, list_release_choices(list_all_usable_releases([osystem]), include_default=False))
def test_includes_all_distro_series(self): releases = [ make_rpc_release(requires_license_key=True) for _ in range(3) ] osystem = make_rpc_osystem(releases=releases) patch_usable_osystems(self, osystems=[osystem]) choices = [('%s/%s' % (osystem['name'], release['name']), release['title']) for release in releases] form = LicenseKeyForm() self.assertItemsEqual(choices, form.fields['distro_series'].choices)
def test_list_all_releases_requiring_keys(self): releases = [ make_rpc_release(requires_license_key=True) for _ in range(3)] release_without_license_key = make_rpc_release( requires_license_key=False) osystem = make_rpc_osystem( releases=releases + [release_without_license_key]) self.assertItemsEqual( releases, list_all_releases_requiring_keys([osystem])[osystem['name']])
def test_list_release_choices_sorts(self): releases = [make_rpc_release() for _ in range(3)] osystem = make_rpc_osystem(releases=releases) choices = [ self.make_release_choice(osystem, release) for release in sorted(releases, key=itemgetter('title')) ] self.assertEqual( choices, list_release_choices(list_all_usable_releases([osystem]), include_default=False))
def test_list_all_usable_releases_finds_title_for_custom(self): # Regression test for LP:1683440 release = make_rpc_release() osystem = make_rpc_osystem(name='custom', releases=[release]) title = factory.make_name('title') factory.make_BootResource(rtype=BOOT_RESOURCE_TYPE.UPLOADED, name=release['name'], extra={'title': title}) self.assertEquals( title, list_all_usable_releases([osystem])[osystem['name']][0]['title'])
def test_list_all_usable_releases_finds_title_in_boot_resource_table(self): release = make_rpc_release() osystem = make_rpc_osystem(releases=[release]) title = factory.make_name('title') factory.make_BootResource(rtype=BOOT_RESOURCE_TYPE.GENERATED, name='%s/%s' % (osystem['name'], release['name']), extra={'title': title}) self.assertEquals( title, list_all_usable_releases([osystem])[osystem['name']][0]['title'])
def test_list_all_releases_requiring_keys_sorts(self): releases = [ make_rpc_release(requires_license_key=True) for _ in range(3)] release_without_license_key = make_rpc_release( requires_license_key=False) osystem = make_rpc_osystem( releases=releases + [release_without_license_key]) releases = sorted(releases, key=itemgetter('title')) self.assertEqual( releases, list_all_releases_requiring_keys([osystem])[osystem['name']])
def test_settings_shows_license_keys_if_OS_supporting_keys(self): self.client_log_in(as_admin=True) release = make_rpc_release(requires_license_key=True) osystem = make_rpc_osystem(releases=[release]) self.patch(settings_view, 'gen_all_known_operating_systems').return_value = [osystem] response = self.client.get(reverse('settings')) doc = fromstring(response.content) license_keys = doc.cssselect('#license_keys') self.assertEqual(1, len(license_keys), "Didn't show the license key section.")
def test_settings_shows_license_keys_if_OS_supporting_keys(self): self.client.login(user=factory.make_admin()) release = make_rpc_release(requires_license_key=True) osystem = make_rpc_osystem(releases=[release]) self.patch(settings_view, 'gen_all_known_operating_systems').return_value = [osystem] response = self.client.get(reverse('settings_general')) doc = fromstring(response.content) license_keys = doc.cssselect('a[href="/MAAS/settings/license-keys/"]') self.assertEqual(1, len(license_keys), "Didn't show the license key section.")
def test_get_distro_series_initial_with_key_required(self): releases = [ make_rpc_release(requires_license_key=True) for _ in range(3) ] osystem = make_rpc_osystem(releases=releases) release = random.choice(releases) node = factory.make_Node(osystem=osystem["name"], distro_series=release["name"]) self.assertEqual( "%s/%s*" % (osystem["name"], release["name"]), get_distro_series_initial([osystem], node, with_key_required=True), )
def test_get_distro_series_initial_works_around_conflicting_os(self): # Test for bug 1456892. releases = [ make_rpc_release(requires_license_key=True) for _ in range(3)] osystem = make_rpc_osystem(releases=releases) release = random.choice(releases) node = factory.make_Node( osystem=osystem['name'], distro_series=release['name']) self.assertEqual( '%s/%s' % (osystem['name'], release['name']), get_distro_series_initial( [], node, with_key_required=True))
def test_list_release_choices_includes_requires_key_asterisk(self): releases = [ make_rpc_release(requires_license_key=True) for _ in range(3) ] osystem = make_rpc_osystem(releases=releases) choices = [ self.make_release_choice(osystem, release, include_asterisk=True) for release in releases ] self.assertItemsEqual( choices, list_release_choices(list_all_usable_releases([osystem]), include_default=False))
def test_POST_requires_osystem(self): # If osystem is not specified and distro_series is not in the # osystem/release form, API call fails. self.become_admin() release = make_rpc_release(requires_license_key=True) osystem = make_rpc_osystem(releases=[release]) patch_usable_osystems(self, osystems=[osystem]) self.patch_autospec(forms, 'validate_license_key').return_value = True params = { 'distro_series': release['name'], 'license_key': factory.make_name('key'), } response = self.client.post(reverse('license_keys_handler'), params) self.assertEqual(http.client.BAD_REQUEST, response.status_code)
def test_list_commissioning_choices_returns_sorted(self): comm_releases = [ make_rpc_release(can_commission=True) for _ in range(3) ] comm_releases += [ make_rpc_release( Config.objects.get_config('commissioning_distro_series'), can_commission=True) ] osystem = make_rpc_osystem('ubuntu', releases=comm_releases) comm_releases = sorted(comm_releases, key=itemgetter('title')) choices = [(release['name'], release['title']) for release in comm_releases] self.assertEqual(choices, list_commissioning_choices([osystem]))
def test_list_commissioning_choices_returns_commissioning_releases(self): comm_releases = [ make_rpc_release(can_commission=True) for _ in range(3) ] comm_releases += [ make_rpc_release( Config.objects.get_config('commissioning_distro_series'), can_commission=True) ] no_comm_release = make_rpc_release() osystem = make_rpc_osystem('ubuntu', releases=comm_releases + [no_comm_release]) choices = [(release['name'], release['title']) for release in comm_releases] self.assertItemsEqual(choices, list_commissioning_choices([osystem]))
def test_list_commissioning_choices_returns_current_selection(self): comm_releases = [ make_rpc_release(can_commission=True) for _ in range(3) ] osystem = make_rpc_osystem("ubuntu", releases=comm_releases) comm_releases = sorted(comm_releases, key=itemgetter("title")) commissioning_series, _ = Config.objects.get_or_create( name="commissioning_distro_series") commissioning_series.value = factory.make_name("commissioning_series") commissioning_series.save() choices = [( commissioning_series.value, "%s (No image available)" % commissioning_series.value, )] + [(release["name"], release["title"]) for release in comm_releases] self.assertEqual(choices, list_commissioning_choices([osystem]))
def test_list_all_usable_releases_finds_uploaded_with_osystem(self): release = make_rpc_release() osystem = make_rpc_osystem(releases=[release]) title = factory.make_name('title') self.patch(osystems, 'gen_all_known_operating_systems').return_value = [{ 'name': osystem['name'] }] factory.make_BootResource(rtype=BOOT_RESOURCE_TYPE.UPLOADED, name='%s/%s' % (osystem['name'], release['name']), extra={'title': title}) self.assertEquals( title, list_all_usable_releases([osystem])[osystem['name']][0]['title'])
def test_POST_creates_license_key(self): self.become_admin() release = make_rpc_release(requires_license_key=True) osystem = make_rpc_osystem(releases=[release]) patch_usable_osystems(self, osystems=[osystem]) self.patch_autospec(forms, 'validate_license_key').return_value = True params = { 'osystem': osystem['name'], 'distro_series': release['name'], 'license_key': factory.make_name('key'), } response = self.client.post(reverse('license_keys_handler'), params) self.assertEqual(http.client.OK, response.status_code) license_key = LicenseKey.objects.get( osystem=params['osystem'], distro_series=params['distro_series']) self.assertAttributes(license_key, params)
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 test_settings_commissioning_POST(self): self.client_log_in(as_admin=True) release = make_rpc_release(can_commission=True) osystem = make_rpc_osystem('ubuntu', releases=[release]) patch_usable_osystems(self, [osystem]) new_commissioning = release['name'] response = self.client.post( reverse('settings'), 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_POST_supports_combined_distro_series(self): # API allows specifying only distro_series containing both # os and series in the "os/series" form. self.become_admin() release = make_rpc_release(requires_license_key=True) osystem = make_rpc_osystem(releases=[release]) patch_usable_osystems(self, osystems=[osystem]) self.patch_autospec(forms, 'validate_license_key').return_value = True params = { 'distro_series': "%s/%s" % (osystem['name'], release['name']), 'license_key': factory.make_name('key'), } response = self.client.post(reverse('license_keys_handler'), params) self.assertEqual(http.client.OK, response.status_code) license_key = LicenseKey.objects.get(osystem=osystem['name'], distro_series=release['name']) expected_params = { 'osystem': osystem['name'], 'distro_series': release['name'], 'license_key': params['license_key'], } self.assertAttributes(license_key, expected_params)
def test_rejects_when_validate_license_key_for_raise_no_os(self): self.client_log_in() node = factory.make_Node(owner=self.logged_in_user) release = make_rpc_release(requires_license_key=True) osystem = make_rpc_osystem(releases=[release]) patch_usable_osystems(self, osystems=[osystem]) license_key = factory.make_name('key') mock_validate_for = self.patch(forms, 'validate_license_key_for') mock_validate_for.side_effect = NoSuchOperatingSystem() form = MachineForm(data={ 'architecture': make_usable_architecture(self), 'osystem': osystem['name'], 'distro_series': '%s/%s*' % (osystem['name'], release['name']), 'license_key': license_key, }, instance=node) self.assertFalse(form.is_valid()) self.assertItemsEqual(['license_key'], form._errors.keys())