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())
