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_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_includes_only_distro_series_that_require_license_keys(self):
releases = [
make_rpc_release(requires_license_key=True) for _ in range(3)
]
no_key_release = make_rpc_release()
osystem = make_rpc_osystem(releases=releases + [no_key_release])
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_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_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_list_release_with_missing_title(self):
releases = [make_rpc_release(name="xenial"), make_rpc_release()]
# Simulate missing title
releases[-1]["title"] = None
bogus_release_name = releases[-1]["name"]
for release in releases:
factory.make_BootResource(
name="ubuntu/" + release["name"],
rtype=BOOT_RESOURCE_TYPE.SYNCED,
)
self.assertEqual(
[
("ubuntu/xenial", 'Ubuntu 16.04 LTS "Xenial Xerus"'),
("ubuntu/" + bogus_release_name, bogus_release_name),
],
list_release_choices(list_all_usable_releases(),
include_default=False),
)
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_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_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_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_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_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_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_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_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_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_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())
