def test_invalid_version_format(self):
arc = GCab.Cabinet.new()
_archive_add(arc, 'firmware.bin', _get_valid_firmware())
_archive_add(arc, 'firmware.metainfo.xml', _get_valid_metainfo(version_format='foo'))
with self.assertRaises(MetadataInvalid):
ufile = UploadedFile()
ufile.parse('foo.cab', _archive_to_contents(arc))
def test_metainfo_invalid(self):
arc = GCab.Cabinet.new()
_archive_add(arc, 'firmware.bin', _get_valid_firmware())
_archive_add(arc, 'firmware.metainfo.xml', '<compoXXXXnent/>')
with self.assertRaises(MetadataInvalid):
ufile = UploadedFile()
ufile.parse('foo.cab', _archive_to_contents(arc))
def archive_finalize(self, arc, metadata):
# get settings
settings = _get_settings('info_readme')
if settings['info_readme_enable'] != 'enabled':
return None
if not settings['info_readme_filename']:
raise PluginError('No filename set')
if not settings['info_readme_template']:
raise PluginError('No template set')
# does the readme file already exist?
if _archive_get_files_from_glob(arc, settings['info_readme_filename']):
print("archive already has %s" % settings['info_readme_filename'])
return
# read in the file and do substititons
try:
template = open(settings['info_readme_template'], 'rb').read()
except IOError as e:
raise PluginError(e)
for key in metadata:
template = template.replace(key, metadata[key])
# add it to the archive
_archive_add(arc, settings['info_readme_filename'],
template.encode('utf-8'))
def archive_copy(self, arc, firmware_cff):
settings = _get_settings('wu_copy')
fn = _get_basename_safe(firmware_cff.get_name())
if fn.endswith('.inf') and settings['wu_copy_inf'] == 'enabled':
_archive_add(arc, fn, firmware_cff.get_bytes().get_data())
if fn.endswith('.cat') and settings['wu_copy_cat'] == 'enabled':
_archive_add(arc, fn, firmware_cff.get_bytes().get_data())
def test_valid_path_back(self):
arc = GCab.Cabinet.new()
_archive_add(arc, 'DriverPackage\\firmware.bin', _get_valid_firmware())
_archive_add(arc, 'DriverPackage\\firmware.metainfo.xml', _get_valid_metainfo())
ufile = UploadedFile()
ufile.parse('foo.cab', _archive_to_contents(arc))
arc2 = ufile.get_repacked_cabinet()
self.assertTrue(_archive_get_files_from_glob(arc2, 'firmware.bin'))
self.assertTrue(_archive_get_files_from_glob(arc2, 'firmware.metainfo.xml'))
def test_metadata(self):
arc = GCab.Cabinet.new()
_archive_add(arc, 'firmware.bin', _get_valid_firmware())
_archive_add(arc, 'firmware.metainfo.xml', _get_valid_metainfo())
ufile = UploadedFile()
ufile.parse('foo.cab', _archive_to_contents(arc))
metadata = ufile.get_components()[0].get_metadata()
self.assertTrue('foo' in metadata)
self.assertTrue('LVFS::InhibitDownload' in metadata)
self.assertTrue(metadata['foo'] == 'bar')
self.assertFalse('NotGoingToExist' in metadata)
def archive_sign(self, arc, firmware_cff):
# already signed
detached_fn = _get_basename_safe(firmware_cff.get_name() + '.p7b')
if _archive_get_files_from_glob(arc, detached_fn):
return
# create the detached signature
blob = firmware_cff.get_bytes().get_data()
blob_p7b = self._sign_blob(blob)
if not blob_p7b:
return
# add it to the archive
_archive_add(arc, detached_fn, blob_p7b.encode('utf-8'))
def archive_sign(self, arc, firmware_cff):
# plugin not enabled
settings = _get_settings('sign_sigul')
if settings['sign_sigul_enable'] != 'enabled':
return
# already signed
detached_fn = _get_basename_safe(firmware_cff.get_name() + '.asc')
if _archive_get_files_from_glob(arc, detached_fn):
return
# create the detached signature
blob_asc = _sigul_detached_sign_data(firmware_cff.get_bytes().get_data(),
settings['sign_sigul_config_file'],
settings['sign_sigul_firmware_key'])
# add it to the archive
_archive_add(arc, detached_fn, blob_asc.encode('utf-8'))
def test_release_mentions_file(self):
arc = GCab.Cabinet.new()
_archive_add(arc, 'firmware.bin', _get_valid_firmware())
_archive_add(arc, 'README.txt', _get_valid_firmware())
_archive_add(arc, 'firmware.metainfo.xml',
_get_valid_metainfo(release_description='See README.txt for details.'))
with self.assertRaises(MetadataInvalid):
ufile = UploadedFile()
ufile.parse('foo.cab', _archive_to_contents(arc))
def archive_sign(self, arc, firmware_cff):
# plugin not enabled
settings = _get_settings('sign_gpg')
if settings['sign_gpg_enable'] != 'enabled':
return
# already signed
detached_fn = _get_basename_safe(firmware_cff.get_name() + '.asc')
if _archive_get_files_from_glob(arc, detached_fn):
return
# create the detached signature
if not settings['sign_gpg_keyring_dir']:
raise PluginError('No keyring directory set')
if not settings['sign_gpg_firmware_uid']:
raise PluginError('No firmware signing UID set')
affidavit = Affidavit(settings['sign_gpg_firmware_uid'],
settings['sign_gpg_keyring_dir'])
contents = firmware_cff.get_bytes().get_data()
contents_asc = affidavit.create(contents)
# add it to the archive
_archive_add(arc, detached_fn, contents_asc.encode('utf-8'))
def test_extra_files(self):
arc = GCab.Cabinet.new()
_archive_add(arc, 'firmware.bin', _get_valid_firmware())
_archive_add(arc, 'firmware.metainfo.xml', _get_valid_metainfo())
_archive_add(arc, 'README.txt', 'fubar')
ufile = UploadedFile()
ufile.parse('foo.cab', _archive_to_contents(arc))
arc2 = ufile.get_repacked_cabinet()
self.assertTrue(_archive_get_files_from_glob(arc2, 'firmware.bin'))
self.assertTrue(_archive_get_files_from_glob(arc2, 'firmware.metainfo.xml'))
self.assertFalse(_archive_get_files_from_glob(arc2, 'README.txt'))
def test_invalid_type(self):
arc = GCab.Cabinet.new()
_archive_add(arc, 'firmware.bin', _get_valid_firmware())
with self.assertRaises(FileNotSupported):
ufile = UploadedFile()
ufile.parse('foo.doc', _archive_to_contents(arc))
