def test_adds_boot_resource_set_to_existing_uploaded_boot_resource(self):
os = factory.make_name('os')
series = factory.make_name('series')
OperatingSystemRegistry.register_item(os, CustomOS())
self.addCleanup(OperatingSystemRegistry.unregister_item, os)
name = '%s/%s' % (os, series)
architecture = make_usable_architecture(self)
resource = factory.make_usable_boot_resource(
rtype=BOOT_RESOURCE_TYPE.UPLOADED,
name=name,
architecture=architecture)
upload_type, filetype = self.pick_filetype()
size = random.randint(1024, 2048)
content = factory.make_string(size).encode('utf-8')
upload_name = factory.make_name('filename')
uploaded_file = SimpleUploadedFile(content=content, name=upload_name)
data = {
'name': name,
'architecture': architecture,
'filetype': upload_type,
'keep_old': True,
}
form = BootResourceForm(data=data, files={'content': uploaded_file})
self.assertTrue(form.is_valid(), form._errors)
form.save()
resource = reload_object(resource)
resource_set = resource.sets.order_by('id').last()
rfile = resource_set.files.first()
self.assertTrue(filetype, rfile.filetype)
self.assertTrue(filetype, rfile.filename)
self.assertTrue(size, rfile.largefile.total_size)
with rfile.largefile.content.open('rb') as stream:
written_content = stream.read()
self.assertEqual(content, written_content)
self.assertEqual(resource.rtype, BOOT_RESOURCE_TYPE.UPLOADED)
def test_removes_old_bootresourcefiles(self):
# Regression test for LP:1660418
os = factory.make_name('os')
series = factory.make_name('series')
OperatingSystemRegistry.register_item(os, CustomOS())
self.addCleanup(OperatingSystemRegistry.unregister_item, os)
name = '%s/%s' % (os, series)
architecture = make_usable_architecture(self)
resource = factory.make_usable_boot_resource(
rtype=BOOT_RESOURCE_TYPE.UPLOADED,
name=name,
architecture=architecture)
upload_type, filetype = self.pick_filetype()
size = random.randint(1024, 2048)
content = factory.make_string(size).encode('utf-8')
upload_name = factory.make_name('filename')
uploaded_file = SimpleUploadedFile(content=content, name=upload_name)
data = {
'name': name,
'architecture': architecture,
'filetype': upload_type,
}
form = BootResourceForm(data=data, files={'content': uploaded_file})
self.assertTrue(form.is_valid(), form._errors)
form.save()
self.assertEqual(
1,
BootResourceFile.objects.filter(
resource_set__resource=resource).count())
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 test_creates_boot_resoures_with_uploaded_rtype(self):
os = factory.make_name("os")
series = factory.make_name("series")
OperatingSystemRegistry.register_item(os, CustomOS())
self.addCleanup(OperatingSystemRegistry.unregister_item, os)
name = "%s/%s" % (os, series)
architecture = make_usable_architecture(self)
upload_type, filetype = self.pick_filetype()
size = random.randint(1024, 2048)
content = factory.make_string(size).encode("utf-8")
upload_name = factory.make_name("filename")
uploaded_file = SimpleUploadedFile(content=content, name=upload_name)
data = {
"name": name,
"architecture": architecture,
"filetype": upload_type,
}
form = BootResourceForm(data=data, files={"content": uploaded_file})
self.assertTrue(form.is_valid(), form._errors)
form.save()
resource = BootResource.objects.get(
rtype=BOOT_RESOURCE_TYPE.UPLOADED,
name=name,
architecture=architecture,
)
resource_set = resource.sets.first()
rfile = resource_set.files.first()
self.assertTrue(filetype, rfile.filetype)
self.assertTrue(filetype, rfile.filename)
self.assertTrue(size, rfile.largefile.total_size)
with rfile.largefile.content.open("rb") as stream:
written_content = stream.read()
self.assertEqual(content, written_content)
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 make_osystem_requiring_license_key(testcase, osystem=None, release=None):
if osystem is None:
osystem = factory.make_name("osystem")
if release is None:
release = random.choice(REQUIRE_LICENSE_KEY)
distro_series = "%s/%s" % (osystem, release)
drv = WindowsOS()
drv.title = osystem
OperatingSystemRegistry.register_item(osystem, drv)
factory.make_BootResource(
name=distro_series,
rtype=BOOT_RESOURCE_TYPE.UPLOADED,
extra={"title": drv.get_release_title(release)},
)
testcase.addCleanup(OperatingSystemRegistry.unregister_item, osystem)
return {
"name":
osystem,
"title":
osystem,
"default_release":
release,
"default_commissioning_release":
None,
"releases": [{
"name": distro_series,
"title": drv.get_release_title(release),
"requires_license_key": True,
"can_commission": False,
}],
}
def make_osystem_requiring_license_key(testcase, osystem=None, release=None):
if osystem is None:
osystem = factory.make_name('osystem')
if release is None:
release = random.choice(REQUIRE_LICENSE_KEY)
distro_series = '%s/%s' % (osystem, release)
drv = WindowsOS()
drv.title = osystem
OperatingSystemRegistry.register_item(osystem, drv)
factory.make_BootResource(
name=distro_series, rtype=BOOT_RESOURCE_TYPE.UPLOADED,
extra={'title': drv.get_release_title(release)})
testcase.addCleanup(
OperatingSystemRegistry.unregister_item, osystem)
return {
'name': osystem,
'title': osystem,
'default_release': release,
'default_commissioning_release': None,
'releases': [{
'name': distro_series,
'title': drv.get_release_title(release),
'requires_license_key': True,
'can_commission': False,
}]
}
def make_os(testcase):
osystem = factory.make_name('osystem')
release = random.choice(REQUIRE_LICENSE_KEY)
distro_series = '%s/%s' % (osystem, release)
drv = WindowsOS()
drv.title = osystem
OperatingSystemRegistry.register_item(osystem, drv)
factory.make_BootResource(
name=distro_series, rtype=BOOT_RESOURCE_TYPE.UPLOADED,
extra={'title': drv.get_release_title(release)})
testcase.addCleanup(
OperatingSystemRegistry.unregister_item, osystem)
return osystem, release
def test_prevents_reversed_osystem_from_driver(self):
reserved_name = factory.make_name('name')
OperatingSystemRegistry.register_item(reserved_name, CustomOS())
upload_type, filetype = self.pick_filetype()
size = random.randint(1024, 2048)
content = factory.make_string(size).encode('utf-8')
upload_name = factory.make_name('filename')
uploaded_file = SimpleUploadedFile(content=content, name=upload_name)
data = {
'name': reserved_name,
'title': factory.make_name('title'),
'architecture': make_usable_architecture(self),
'filetype': upload_type,
}
form = BootResourceForm(data=data, files={'content': uploaded_file})
self.assertFalse(form.is_valid())
def test_settings_shows_license_keys_if_OS_supporting_keys(self):
self.client.login(user=factory.make_admin())
osystem = factory.make_name('osystem')
release = random.choice(REQUIRE_LICENSE_KEY)
distro_series = '%s/%s' % (osystem, release)
drv = WindowsOS()
drv.title = osystem
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)
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 make_osystem(testcase, osystem, purpose=None, releases=None):
"""Makes the operating system class and registers it."""
if osystem not in OperatingSystemRegistry:
fake = FakeOS(osystem, purpose, releases)
OperatingSystemRegistry.register_item(fake.name, fake)
testcase.addCleanup(OperatingSystemRegistry.unregister_item, osystem)
return fake
else:
obj = OperatingSystemRegistry[osystem]
old_func = obj.get_boot_image_purposes
testcase.patch(obj, "get_boot_image_purposes").return_value = purpose
def reset_func(obj, old_func):
obj.get_boot_image_purposes = old_func
testcase.addCleanup(reset_func, obj, old_func)
return obj
def test_operating_system_registry(self):
self.assertItemsEqual([], OperatingSystemRegistry)
OperatingSystemRegistry.register_item("resource", sentinel.resource)
self.assertIn(sentinel.resource,
(item for name, item in OperatingSystemRegistry))
