def test_complete_returns_true_for_complete_files(self): resource = factory.make_BootResource() resource_set = factory.make_BootResourceSet(resource) types = [ BOOT_RESOURCE_FILE_TYPE.ROOT_IMAGE, BOOT_RESOURCE_FILE_TYPE.BOOT_KERNEL, BOOT_RESOURCE_FILE_TYPE.BOOT_INITRD, ] for _ in range(3): filetype = types.pop() factory.make_boot_resource_file_with_content( resource_set, filename=filetype, filetype=filetype) self.assertTrue(resource_set.complete)
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) osystem = factory.make_name('osystem') release = factory.make_name('release') distro_series = '%s/%s' % (osystem, release) make_osystem(self, osystem, [release]) factory.make_BootResource(name=distro_series) 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, 'distro_series': distro_series, 'license_key': license_key, }, instance=node) self.assertFalse(form.is_valid()) self.assertItemsEqual(['license_key'], form._errors.keys())
def test_commissionable_returns_true_when_all_filetypes_present(self): resource = factory.make_BootResource() resource_set = factory.make_BootResourceSet(resource) commissionable_set = { BOOT_RESOURCE_FILE_TYPE.BOOT_KERNEL, BOOT_RESOURCE_FILE_TYPE.BOOT_INITRD, random.choice([ BOOT_RESOURCE_FILE_TYPE.SQUASHFS_IMAGE, BOOT_RESOURCE_FILE_TYPE.ROOT_IMAGE, ]), } self.make_all_boot_resource_files(resource_set, commissionable_set) self.assertTrue(resource_set.commissionable)
def test_boot_resource_to_dict_without_sets(self): resource = factory.make_BootResource() factory.make_BootResourceSet(resource) dict_representation = boot_resource_to_dict(resource, with_sets=False) self.assertEqual(resource.id, dict_representation['id']) self.assertEqual(BOOT_RESOURCE_TYPE_CHOICES_DICT[resource.rtype], dict_representation['type']) self.assertEqual(resource.name, dict_representation['name']) self.assertEqual(resource.architecture, dict_representation['architecture']) self.assertEqual(get_boot_resource_uri(resource), dict_representation['resource_uri']) self.assertFalse('sets' in dict_representation)
def test_get_commissionable_resource_returns_only_commissionable(self): os = factory.make_name('os') series = factory.make_name('series') name = '%s/%s' % (os, series) resource = factory.make_usable_boot_resource( rtype=BOOT_RESOURCE_TYPE.SYNCED, name=name) factory.make_incomplete_boot_resource(rtype=BOOT_RESOURCE_TYPE.SYNCED, name=name) not_commissionable = factory.make_BootResource( rtype=BOOT_RESOURCE_TYPE.SYNCED, name=name) factory.make_BootResourceSet(not_commissionable) commissionables = BootResource.objects.get_commissionable_resource( os, series) self.assertItemsEqual([resource], commissionables)
def make_os_with_license_key( self, osystem=None, osystem_title=None, release=None): """Makes a fake operating system that has a release that requires a license key.""" if osystem is None: osystem = factory.make_name('osystem') if osystem_title is None: osystem_title = osystem + '_title' if release is None: release = random.choice(REQUIRE_LICENSE_KEY) distro_series = '%s/%s' % (osystem, release) drv = WindowsOS() drv.title = osystem_title OperatingSystemRegistry.register_item(osystem, drv) factory.make_BootResource( name=distro_series, rtype=BOOT_RESOURCE_TYPE.UPLOADED, extra={'title': drv.get_release_title(release)}) self.addCleanup( OperatingSystemRegistry.unregister_item, osystem) return ( {'name': osystem, 'title': osystem_title}, {'name': release, 'title': drv.get_release_title(release)}, )
def test_rejects_when_validate_license_key_for_raise_no_os(self): user = factory.make_User() self.client.login(user=user) node = factory.make_Node(owner=user) osystem = factory.make_name("osystem") release = factory.make_name("release") distro_series = "%s/%s" % (osystem, release) make_osystem(self, osystem, [release]) factory.make_BootResource(name=distro_series) 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, "distro_series": distro_series, "license_key": license_key, }, instance=node, ) self.assertFalse(form.is_valid()) self.assertItemsEqual(["license_key"], form._errors.keys())
def test__returns_kpackage(self): resource = factory.make_BootResource( name="ubuntu/trusty", architecture="amd64/hwe-t", rtype=BOOT_RESOURCE_TYPE.SYNCED) resource_set = factory.make_BootResourceSet(resource) factory.make_boot_resource_file_with_content( resource_set, filename="boot-kernel", filetype="boot-kernel", extra={"kpackage": "linux-image-generic-lts-trusty"}) node = factory.make_Node( interface=True, power_type='manual', osystem='ubuntu', distro_series='trusty', architecture='amd64/generic', hwe_kernel='hwe-t') self.assertEqual( "linux-image-generic-lts-trusty", BootResource.objects.get_kpackage_for_node(node))
def test_boot_resource_set_to_dict(self): resource = factory.make_BootResource() resource_set = factory.make_BootResourceSet(resource) total_size = random.randint(1024, 2048) content = factory.make_bytes(random.randint(512, 1023)) largefile = factory.make_LargeFile(content=content, size=total_size) rfile = factory.make_BootResourceFile(resource_set, largefile) dict_representation = boot_resource_set_to_dict(resource_set) self.assertEqual(resource_set.version, dict_representation['version']) self.assertEqual(resource_set.label, dict_representation['label']) self.assertEqual(resource_set.total_size, dict_representation['size']) self.assertEqual(False, dict_representation['complete']) self.assertEqual(resource_set.progress, dict_representation['progress']) self.assertEqual(boot_resource_file_to_dict(rfile), dict_representation['files'][rfile.filename])
def test_total_size(self): resource = factory.make_BootResource() resource_set = factory.make_BootResourceSet(resource) total_size = 0 sizes = [random.randint(512, 1024) for _ in range(3)] types = [ BOOT_RESOURCE_FILE_TYPE.ROOT_IMAGE, BOOT_RESOURCE_FILE_TYPE.BOOT_KERNEL, BOOT_RESOURCE_FILE_TYPE.BOOT_INITRD, ] for size in sizes: total_size += size filetype = types.pop() largefile = factory.make_LargeFile(size=size) factory.make_BootResourceFile( resource_set, largefile, filename=filetype, filetype=filetype) self.assertEqual(total_size, resource_set.total_size)
def test_boot_resource_to_dict_without_sets(self): resource = factory.make_BootResource() factory.make_BootResourceSet(resource) dict_representation = boot_resource_to_dict(resource, with_sets=False) self.assertEqual(resource.id, dict_representation["id"]) self.assertEqual( BOOT_RESOURCE_TYPE_CHOICES_DICT[resource.rtype], dict_representation["type"], ) self.assertEqual(resource.name, dict_representation["name"]) self.assertEqual(resource.architecture, dict_representation["architecture"]) self.assertEqual( get_boot_resource_uri(resource), dict_representation["resource_uri"], ) self.assertFalse("sets" in dict_representation)
def test_get_resource_for_returns_matching_resource(self): resources = [ factory.make_BootResource( rtype=random.choice(RTYPE_REQUIRING_OS_SERIES_NAME)) for _ in range(3) ] resource = resources.pop() subarches = [factory.make_name('subarch') for _ in range(3)] subarch = random.choice(subarches) resource.extra['subarches'] = ','.join(subarches) resource.save() osystem, series = resource.name.split('/') arch, _ = resource.split_arch() self.assertEqual( resource, BootResource.objects.get_resource_for(osystem, arch, subarch, series))
def test_complete_returns_false_for_one_incomplete_file(self): resource = factory.make_BootResource() resource_set = factory.make_BootResourceSet(resource) types = [ BOOT_RESOURCE_FILE_TYPE.ROOT_IMAGE, BOOT_RESOURCE_FILE_TYPE.BOOT_KERNEL, BOOT_RESOURCE_FILE_TYPE.BOOT_INITRD, ] for _ in range(2): filetype = types.pop() factory.make_boot_resource_file_with_content( resource_set, filename=filetype, filetype=filetype) size = random.randint(512, 1024) total_size = random.randint(1025, 2048) filetype = types.pop() content = factory.make_bytes(size=size) largefile = factory.make_LargeFile(content=content, size=total_size) factory.make_BootResourceFile( resource_set, largefile, filename=filetype, filetype=filetype) self.assertFalse(resource_set.complete)
def test_progress_increases_from_0_to_100(self): resource = factory.make_BootResource() resource_set = factory.make_BootResourceSet(resource) filetype = BOOT_RESOURCE_FILE_TYPE.ROOT_IMAGE total_size = 100 current_size = 0 largefile = factory.make_LargeFile(content=b"", size=total_size) factory.make_BootResourceFile( resource_set, largefile, filename=filetype, filetype=filetype) stream = largefile.content.open() self.addCleanup(stream.close) self.assertEqual(0, resource_set.progress) for _ in range(total_size): stream.write(b"a") largefile.size += 1 largefile.save() current_size += 1 self.assertAlmostEqual( 100.0 * current_size / float(total_size), resource_set.progress)
def test_boot_resource_file_to_dict(self): size = random.randint(512, 1023) total_size = random.randint(1024, 2048) content = factory.make_bytes(size) largefile = factory.make_LargeFile(content=content, size=total_size) resource = factory.make_BootResource(rtype=BOOT_RESOURCE_TYPE.UPLOADED) resource_set = factory.make_BootResourceSet(resource) rfile = factory.make_BootResourceFile(resource_set, largefile) dict_representation = boot_resource_file_to_dict(rfile) self.assertEqual(rfile.filename, dict_representation['filename']) self.assertEqual(rfile.filetype, dict_representation['filetype']) self.assertEqual(rfile.largefile.sha256, dict_representation['sha256']) self.assertEqual(total_size, dict_representation['size']) self.assertEqual(False, dict_representation['complete']) self.assertEqual(rfile.largefile.progress, dict_representation['progress']) self.assertEqual( reverse('boot_resource_file_upload_handler', args=[resource.id, rfile.id]), dict_representation['upload_uri'])
def test_returns_boot_images_matching_subarches_in_boot_resources(self): rack = factory.make_RackController() self.useFixture(RunningClusterRPCFixture()) params = self.make_boot_images() param = params.pop() subarches = [factory.make_name('subarch') for _ in range(3)] resource_name = '%s/%s' % (param['osystem'], param['release']) resource_arch = '%s/%s' % (param['architecture'], param['subarchitecture']) resource = factory.make_BootResource(rtype=BOOT_RESOURCE_TYPE.SYNCED, name=resource_name, architecture=resource_arch) extra = resource.extra.copy() extra['subarches'] = ','.join(subarches) resource.extra = extra resource.save() subarch = subarches.pop() self.assertItemsEqual( self.make_rpc_boot_images(param), get_boot_images_for(rack, param['osystem'], param['architecture'], subarch, param['release']))
def test_progress_accumulates_all_files(self): resource = factory.make_BootResource() resource_set = factory.make_BootResourceSet(resource) final_size = 0 final_total_size = 0 sizes = [random.randint(512, 1024) for _ in range(3)] total_sizes = [random.randint(1025, 2048) for _ in range(3)] types = [ BOOT_RESOURCE_FILE_TYPE.ROOT_IMAGE, BOOT_RESOURCE_FILE_TYPE.BOOT_KERNEL, BOOT_RESOURCE_FILE_TYPE.BOOT_INITRD, ] for size in sizes: final_size += size total_size = total_sizes.pop() final_total_size += total_size filetype = types.pop() content = factory.make_bytes(size=size) largefile = factory.make_LargeFile( content=content, size=total_size) factory.make_BootResourceFile( resource_set, largefile, filename=filetype, filetype=filetype) progress = 100.0 * final_size / float(final_total_size) self.assertAlmostEqual(progress, resource_set.progress)
def test__returns_False_if_no_images(self): factory.make_BootResource() self.assertFalse(BootResource.objects.boot_images_are_in_sync([]))
def test_DELETE_requires_admin(self): resource = factory.make_BootResource() response = self.client.delete(get_boot_resource_uri(resource)) self.assertEqual(http.client.FORBIDDEN, response.status_code)
def test_DELETE_deletes_boot_resource(self): self.become_admin() resource = factory.make_BootResource() response = self.client.delete(get_boot_resource_uri(resource)) self.assertEqual(http.client.NO_CONTENT, response.status_code) self.assertIsNone(reload_object(resource))
def test_complete_returns_false_for_no_files(self): resource = factory.make_BootResource() resource_set = factory.make_BootResourceSet(resource) self.assertFalse(resource_set.complete)
def test_supports_subarch_returns_False_if_subarch_not_in_subarches(self): subarches = [factory.make_name('subarch') for _ in range(3)] resource = factory.make_BootResource( extra={'subarches': ','.join(subarches)}) self.assertFalse( resource.supports_subarch(factory.make_name('subarch')))
def test_supports_subarch_returns_True_if_subarch_in_subarches(self): subarches = [factory.make_name('subarch') for _ in range(3)] subarch = random.choice(subarches) resource = factory.make_BootResource( extra={'subarches': ','.join(subarches)}) self.assertTrue(resource.supports_subarch(subarch))
def test_supports_subarch_returns_False_if_subarches_is_missing(self): resource = factory.make_BootResource() self.assertFalse( resource.supports_subarch(factory.make_name('subarch')))
def test_supports_subarch_returns_True_if_subarch_in_name_matches(self): arch = factory.make_name('arch') subarch = factory.make_name('subarch') architecture = '%s/%s' % (arch, subarch) resource = factory.make_BootResource(architecture=architecture) self.assertTrue(resource.supports_subarch(subarch))
def test_get_next_version_name_returns_first_revision(self): expected_version = '%s.1' % self.configure_now() resource = factory.make_BootResource() factory.make_BootResourceSet(resource, version=resource.get_next_version_name()) self.assertEqual(expected_version, resource.get_next_version_name())
def test_get_next_version_name_returns_current_date(self): expected_version = self.configure_now() resource = factory.make_BootResource() self.assertEqual(expected_version, resource.get_next_version_name())
def test_get_latest_set(self): resource = factory.make_BootResource() factory.make_BootResourceSet(resource) latest_two = factory.make_BootResourceSet(resource) self.assertEqual(latest_two, resource.get_latest_set())
def test_boot_resource_to_dict_with_sets(self): resource = factory.make_BootResource() resource_set = factory.make_BootResourceSet(resource) dict_representation = boot_resource_to_dict(resource, with_sets=True) self.assertEqual(boot_resource_set_to_dict(resource_set), dict_representation['sets'][resource_set.version])
def test_split_arch(self): arch = factory.make_name('arch') subarch = factory.make_name('subarch') architecture = '%s/%s' % (arch, subarch) resource = factory.make_BootResource(architecture=architecture) self.assertEqual([arch, subarch], resource.split_arch())