def test_errors_on_not_unique(self): osystem, release = self.make_os_with_license_key() self.patch_autospec(forms, "validate_license_key").return_value = True key = factory.make_name("key") factory.make_LicenseKey( osystem=osystem["name"], distro_series=release["name"], license_key=key, ) definition = { "osystem": osystem["name"], "distro_series": "%s/%s" % (osystem["name"], release["name"]), "license_key": key, } form = LicenseKeyForm(data=definition) self.assertFalse(form.is_valid(), form.errors) self.assertEqual( { "__all__": [ "%s %s" % ( "License key with this operating system and distro series", "already exists.", ) ] }, form.errors, )
def test_POST_is_prohibited(self): self.become_admin() license_key = factory.make_LicenseKey() response = self.client.post( self.get_url(license_key.osystem, license_key.distro_series), {'osystem': "New osystem"}) self.assertEqual(http.client.METHOD_NOT_ALLOWED, response.status_code)
def test_can_update_license_key(self): self.client.login(user=factory.make_admin()) key = factory.make_LicenseKey( distro_series=random.choice(REQUIRE_LICENSE_KEY)) make_osystem_requiring_license_key(self, key.osystem, key.distro_series) 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)
def test_DELETE_deletes_license_key(self): self.become_admin() license_key = factory.make_LicenseKey() response = self.client.delete( self.get_url(license_key.osystem, license_key.distro_series)) self.assertEqual(http.client.NO_CONTENT, response.status_code) self.assertIsNone(reload_object(license_key))
def test_errors_on_not_unique(self): key = factory.make_LicenseKey() new_key = factory.make_name('key') self.assertRaises(IntegrityError, LicenseKey.objects.create, osystem=key.osystem, distro_series=key.distro_series, license_key=new_key)
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_errors_on_not_unique(self): osystem, release = self.make_os_with_license_key() self.patch_autospec(forms, 'validate_license_key').return_value = True key = factory.make_name('key') factory.make_LicenseKey( osystem=osystem['name'], distro_series=release['name'], license_key=key) definition = { 'osystem': osystem['name'], 'distro_series': "%s/%s" % (osystem['name'], release['name']), 'license_key': key, } form = LicenseKeyForm(data=definition) self.assertFalse(form.is_valid(), form.errors) self.assertEqual({ '__all__': ['%s %s' % ( "License key with this operating system and distro series", "already exists.")]}, form.errors)
def make_license_key_with_os(self, osystem=None, distro_series=None, license_key=None): license_key = factory.make_LicenseKey(osystem=osystem, distro_series=distro_series, license_key=license_key) osystem = make_osystem_requiring_license_key(license_key.osystem, license_key.distro_series) return license_key, osystem
def make_license_key_with_os( self, osystem=None, release=None, license_key=None): if release is None: release = random.choice(REQUIRE_LICENSE_KEY) license_key = factory.make_LicenseKey( osystem=osystem, distro_series=release, license_key=license_key) osystem = make_osystem_requiring_license_key( self, license_key.osystem, license_key.distro_series) return license_key, osystem
def test_can_delete_license_key(self): self.client.login(user=factory.make_admin()) key = factory.make_LicenseKey() delete_link = reverse('license-key-delete', args=[key.osystem, key.distro_series]) response = self.client.post(delete_link, {'post': 'yes'}) self.assertEqual((http.client.FOUND, reverse('settings_license_keys')), (response.status_code, extract_redirect(response))) self.assertFalse( LicenseKey.objects.filter( osystem=key.osystem, distro_series=key.distro_series).exists())
def test_updates_license_key(self): osystem, release = self.make_os_with_license_key() self.patch_autospec(forms, 'validate_license_key').return_value = True license_key = factory.make_LicenseKey( osystem=osystem['name'], distro_series=release['name'], license_key=factory.make_name('key')) new_key = factory.make_name('key') form = LicenseKeyForm( data={'license_key': new_key}, instance=license_key) form.save() license_key = reload_object(license_key) self.assertEqual(new_key, license_key.license_key)
def test_validates_license_key(self): osystem, release = self.make_os_with_license_key() self.patch_autospec(forms, 'validate_license_key').return_value = False license_key = factory.make_LicenseKey( osystem=osystem['name'], distro_series=release['name'], license_key=factory.make_name('key')) new_key = factory.make_name('key') form = LicenseKeyForm(data={'license_key': new_key}, instance=license_key) self.assertFalse(form.is_valid(), form.errors) self.assertEqual({'__all__': ['Invalid license key.']}, form.errors)
def test_validates_license_key(self): osystem, release = self.make_os_with_license_key() self.patch_autospec(forms, "validate_license_key").return_value = False license_key = factory.make_LicenseKey( osystem=osystem["name"], distro_series=release["name"], license_key=factory.make_name("key"), ) new_key = factory.make_name("key") form = LicenseKeyForm(data={"license_key": new_key}, instance=license_key) self.assertFalse(form.is_valid(), form.errors) self.assertEqual({"__all__": ["Invalid license key."]}, form.errors)
def test_GET_returns_license_key(self): self.become_admin() license_key = factory.make_LicenseKey() response = self.client.get( self.get_url(license_key.osystem, license_key.distro_series)) self.assertEqual(http.client.OK, response.status_code) parsed_result = json_load_bytes(response.content) self.assertEqual(( license_key.osystem, license_key.distro_series, license_key.license_key, ), ( parsed_result['osystem'], parsed_result['distro_series'], parsed_result['license_key'], ))
def test_GET_returns_license_keys(self): self.become_admin() orig_license_key = factory.make_LicenseKey() response = self.client.get(reverse('license_keys_handler')) self.assertEqual(http.client.OK, response.status_code, response.content) parsed_result = json_load_bytes(response.content) self.assertEqual(1, len(parsed_result)) [returned_network] = parsed_result fields = {'osystem', 'distro_series', 'license_key'} self.assertItemsEqual(fields.union({'resource_uri'}), returned_network.keys()) expected_values = { field: getattr(orig_license_key, field) for field in fields if field != 'resource_uri' } expected_values['resource_uri'] = reverse( 'license_key_handler', args=[orig_license_key.osystem, orig_license_key.distro_series]) self.assertEqual(expected_values, returned_network)
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)
def test_get_license_key(self): key = factory.make_LicenseKey() license_key = LicenseKey.objects.get_license_key( key.osystem, key.distro_series ) self.assertEqual(key.license_key, license_key)
def test_GET_requires_admin(self): license_key = factory.make_LicenseKey() response = self.client.get( self.get_url(license_key.osystem, license_key.distro_series)) self.assertEqual(http.client.FORBIDDEN, response.status_code)
def make_license_key_with_os(self, license_key=None): osystem, release = make_os(self) license_key = factory.make_LicenseKey(osystem=osystem, distro_series=release, license_key=license_key) return license_key
def test_GET_requires_admin(self): factory.make_LicenseKey() response = self.client.get(reverse("license_keys_handler")) self.assertEqual(http.client.FORBIDDEN, response.status_code)
def test_DELETE_requires_admin(self): license_key = factory.make_LicenseKey() response = self.client.delete( self.get_url(license_key.osystem, license_key.distro_series)) self.assertEqual(http.client.FORBIDDEN, response.status_code) self.assertIsNotNone(reload_object(license_key))
def test_get_by_osystem_series(self): key = factory.make_LicenseKey() expected = LicenseKey.objects.get_by_osystem_series( key.osystem, key.distro_series ) self.assertEqual(key, expected)
def test_has_license_key_False(self): factory.make_LicenseKey() osystem = factory.make_name("osystem") series = factory.make_name("distro_series") self.assertFalse(LicenseKey.objects.has_license_key(osystem, series))
def test_has_license_key_True(self): key = factory.make_LicenseKey() self.assertTrue( LicenseKey.objects.has_license_key(key.osystem, key.distro_series) )