def test_starts_with_default_distro_series(self):
self.client_log_in()
node = factory.make_Node(owner=self.logged_in_user)
osystems = [make_osystem_with_releases(self) for _ in range(5)]
patch_usable_osystems(self, osystems)
form = MachineForm(instance=node)
self.assertEqual('', form.fields['distro_series'].initial)
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_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 test_starts_with_default_osystem(self):
user = factory.make_User()
self.client.login(user=user)
node = factory.make_Node(owner=user)
osystems = [make_osystem_with_releases(self) for _ in range(5)]
patch_usable_osystems(self, osystems)
form = MachineForm(instance=node)
self.assertEqual('', form.fields['osystem'].initial)
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_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_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 make_license_keys(self, count):
keys = []
osystems = []
for _ in range(count):
key, osystem = self.make_license_key_with_os()
keys.append(key)
osystems.append(osystem)
patch_usable_osystems(self, osystems=osystems)
self.patch(settings_view,
'gen_all_known_operating_systems').return_value = osystems
return keys, osystems
def test_rejects_invalid_osystem(self):
self.client_log_in()
node = factory.make_Node(owner=self.logged_in_user)
patch_usable_osystems(self)
form = MachineForm(data={
'hostname': factory.make_name('host'),
'architecture': make_usable_architecture(self),
'osystem': factory.make_name('os'),
},
instance=node)
self.assertFalse(form.is_valid())
self.assertItemsEqual(['osystem'], form._errors.keys())
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_set_config_only_default_osystem_are_valid_for_distro_series(self):
self.become_admin()
default_osystem = make_osystem_with_releases(self)
other_osystem = make_osystem_with_releases(self)
patch_usable_osystems(self, [default_osystem, other_osystem])
Config.objects.set_config("default_osystem", default_osystem['name'])
invalid_release = other_osystem['releases'][0]['name']
response = self.client.post(
reverse('maas_handler'), {
"op": "set_config",
"name": "default_distro_series",
"value": invalid_release,
})
self.assertEqual(http.client.BAD_REQUEST, response.status_code,
response.content)
def test_rejects_invalid_osystem(self):
user = factory.make_User()
self.client.login(user=user)
node = factory.make_Node(owner=user)
patch_usable_osystems(self)
form = MachineForm(
data={
"hostname": factory.make_name("host"),
"architecture": make_usable_architecture(self),
"osystem": factory.make_name("os"),
},
instance=node,
)
self.assertFalse(form.is_valid())
self.assertItemsEqual(["osystem"], form._errors.keys())
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 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())
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_can_create_license_key(self):
self.client.login(user=factory.make_admin())
osystem = make_osystem_requiring_license_key()
patch_usable_osystems(self, osystems=[osystem])
self.patch(forms, 'validate_license_key').return_value = True
series = osystem['default_release']
key = factory.make_name('key')
add_link = reverse('license-key-add')
definition = {
'osystem': osystem['name'],
'distro_series': "%s/%s" % (osystem['name'], series),
'license_key': key,
}
response = self.client.post(add_link, definition)
self.assertEqual((http.client.FOUND, reverse('settings_license_keys')),
(response.status_code, extract_redirect(response)))
new_license_key = LicenseKey.objects.get(osystem=osystem['name'],
distro_series=series)
expected_result = {
'osystem': osystem['name'],
'distro_series': series,
'license_key': key,
}
self.assertAttributes(new_license_key, expected_result)
def test_can_update_license_key(self):
self.client.login(user=factory.make_admin())
key = factory.make_LicenseKey()
osystem = make_osystem_requiring_license_key(key.osystem,
key.distro_series)
patch_usable_osystems(self, osystems=[osystem])
self.patch(forms, 'validate_license_key').return_value = True
new_key = factory.make_name('key')
edit_link = reverse('license-key-edit',
args=[key.osystem, key.distro_series])
definition = {
'osystem': key.osystem,
'distro_series': "%s/%s" % (key.osystem, key.distro_series),
'license_key': new_key,
}
response = self.client.post(edit_link, definition)
self.assertEqual((http.client.FOUND, reverse('settings_license_keys')),
(response.status_code, extract_redirect(response)))
expected_result = {
'osystem': key.osystem,
'distro_series': key.distro_series,
'license_key': new_key,
}
self.assertAttributes(reload_object(key), expected_result)
