def populate():
"""Populate the database with some packages"""
from spkrepo.tests.common import BuildFactory, PackageFactory, VersionFactory
with db.session.no_autoflush:
# nzbget
nzbget_package = PackageFactory(name='nzbget')
nzbget_versions = [VersionFactory(package=nzbget_package, upstream_version='12.0', version=10,
dependencies=None, report_url=None,
install_wizard=True, upgrade_wizard=False),
VersionFactory(package=nzbget_package, upstream_version='13.0', version=11,
dependencies=None, report_url=None,
install_wizard=True, upgrade_wizard=False)]
nzbget_builds = []
for version in nzbget_versions:
builds = BuildFactory.create_batch(2, version=version, active=True)
nzbget_builds.extend(builds)
# sickbeard
sickbeard_package = PackageFactory(name='sickbeard')
sickbeard_versions = [VersionFactory(package=sickbeard_package, upstream_version='20140528', version=3,
dependencies='git', service_dependencies=[], report_url=None,
install_wizard=False, upgrade_wizard=False, startable=True),
VersionFactory(package=sickbeard_package, upstream_version='20140702', version=4,
dependencies='git', service_dependencies=[], report_url=None,
install_wizard=False, upgrade_wizard=False, startable=True)]
sickbeard_builds = []
for version in sickbeard_versions:
sickbeard_builds.append(BuildFactory(version=version, architectures=[Architecture.find('noarch')],
active=True))
# git
git_package = PackageFactory(name='git')
git_versions = [VersionFactory(package=git_package, upstream_version='1.8.4', version=3,
dependencies=None, service_dependencies=[], report_url=None,
install_wizard=False, upgrade_wizard=False, startable=False),
VersionFactory(package=git_package, upstream_version='2.1.2', version=4,
dependencies=None, service_dependencies=[], report_url=None,
install_wizard=False, upgrade_wizard=False, startable=False)]
git_builds = []
for version in git_versions:
builds = BuildFactory.create_batch(3, version=version, active=True)
git_builds.extend(builds)
# bitlbee
bitlbee_package = PackageFactory(name='bitlbee')
bitlbee_versions = [VersionFactory(package=bitlbee_package, upstream_version='3.2.2', version=9,
dependencies=None, service_dependencies=[], report_url=None,
install_wizard=False, upgrade_wizard=False, startable=True),
VersionFactory(package=bitlbee_package, upstream_version='3.2.3', version=10,
dependencies=None, service_dependencies=[], report_url=None,
install_wizard=False, upgrade_wizard=False, startable=True),
VersionFactory(package=bitlbee_package, upstream_version='3.3.0', version=11,
dependencies=None, service_dependencies=[],
install_wizard=False, upgrade_wizard=False, startable=True)]
bitlbee_builds = []
for version in bitlbee_versions:
builds = BuildFactory.create_batch(3, version=version, active=True)
bitlbee_builds.extend(builds)
db.session.commit()
def test_not_signed(self):
build = BuildFactory.build(version__upgrade_wizard=True)
with create_spk(build) as f:
spk = SPK(f)
with self.assertRaises(ValueError) as cm:
spk.unsign()
self.assertEqual('Not signed', str(cm.exception))
def test_invalid_info(self):
build = BuildFactory.build()
info = io.BytesIO('\n'.join(['%s=%s' % (k, v) for k, v in create_info(build).items()]).encode('utf-8'))
with create_spk(build, info=info) as f:
with self.assertRaises(SPKParseError) as cm:
SPK(f)
self.assertEqual('Invalid INFO', str(cm.exception))
def test_wrong_info_encoding(self):
build = BuildFactory.build()
info = create_info(build)
info['description'] = 'Description en français'
with create_spk(build, info=info, info_encoding='latin-1') as f:
with self.assertRaises(SPKParseError) as cm:
SPK(f)
self.assertEqual('Wrong INFO encoding', str(cm.exception))
def test_invalid_info_icon(self):
build = BuildFactory.build()
info = create_info(build)
info['package_icon_120'] = 'package_icon_120'
with create_spk(build, info=info) as f:
with self.assertRaises(SPKParseError) as cm:
SPK(f)
self.assertEqual('Invalid INFO icon: package_icon_120', str(cm.exception))
def test_invalid_info_boolean_startable(self):
build = BuildFactory.build()
info = create_info(build)
info['startable'] = 'Something'
with create_spk(build, info=info) as f:
with self.assertRaises(SPKParseError) as cm:
SPK(f)
self.assertEqual('Invalid INFO boolean: startable', str(cm.exception))
def test_missing_info_package(self):
build = BuildFactory.build()
info = create_info(build)
del info['package']
with create_spk(build, info=info) as f:
with self.assertRaises(SPKParseError) as cm:
SPK(f)
self.assertEqual('Missing INFO: package', str(cm.exception))
def test_checksum_mismatch(self):
build = BuildFactory.build()
info = create_info(build)
info['checksum'] = 'checksum'
with create_spk(build, info=info) as f:
with self.assertRaises(SPKParseError) as cm:
SPK(f)
self.assertEqual('Checksum mismatch', str(cm.exception))
def test_invalid_spk(self):
build = BuildFactory.build()
with create_spk(build) as f:
f.seek(50)
invalid_spk = io.BytesIO(f.read())
with self.assertRaises(SPKParseError) as cm:
SPK(invalid_spk)
self.assertEqual('Invalid SPK', str(cm.exception))
def test_empty_conf_folder(self):
build = BuildFactory.build(version__conf_dependencies=None, version__conf_conflicts=None)
info = create_info(build)
info['support_conf_folder'] = 'yes'
with create_spk(build, info=info, with_conf=True) as f:
with self.assertRaises(SPKParseError) as cm:
SPK(f)
self.assertEqual('Empty conf folder', str(cm.exception))
def test_already_signed(self):
build = BuildFactory.build(version__upgrade_wizard=True)
with create_spk(build, signature='signature') as f:
spk = SPK(f)
spk._generate_signature = Mock(return_value='timestamped signature')
with self.assertRaises(ValueError) as cm:
spk.sign('timestamp_url', 'gnupghome')
self.assertEqual('Already signed', str(cm.exception))
def test_generic(self):
build = BuildFactory.build(version__upgrade_wizard=True)
f = create_spk(build, signature='signature')
spk = SPK(f)
spk.unsign()
with tarfile.open(fileobj=f, mode='r:') as tar:
self.assertNotIn('syno_signature.asc', tar.getnames())
f.close()
def test_post_minimum(self):
user = UserFactory(roles=[Role.find('developer'), Role.find('package_admin')])
db.session.commit()
build = BuildFactory.build()
with create_spk(build) as spk:
self.assert201(self.client.post(url_for('api.packages'), headers=authorization_header(user),
data=spk.read()))
self.assertBuildInserted(Build.query.one(), build, user)
def test_post_new_package_not_author_not_maintainer_user(self):
user = UserFactory(roles=[Role.find('developer')])
db.session.commit()
with create_spk(BuildFactory.build()) as spk:
response = self.client.post(url_for('api.packages'), headers=authorization_header(user),
data=spk.read())
self.assert403(response)
self.assertIn('Insufficient permissions to create new packages', response.data.decode(response.charset))
def test_post_unknown_firmware(self):
user = UserFactory(roles=[Role.find('developer')])
db.session.commit()
build = BuildFactory.build(firmware=Firmware(version='1.0', build=421))
with create_spk(build) as spk:
response = self.client.post(url_for('api.packages'), headers=authorization_header(user),
data=spk.read())
self.assert422(response)
self.assertIn('Unknown firmware', response.data.decode(response.charset))
def test_get_active_stable(self):
build = BuildFactory(version__report_url=None, active=True)
db.session.commit()
response = self.client.get(url_for("frontend.packages"))
self.assert200(response)
self.assertIn(
build.version.displaynames["enu"].displayname,
response.data.decode(response.charset),
)
self.assertNotIn("beta", response.data.decode(response.charset))
def test_post_unknown_architecture(self):
user = UserFactory(roles=[Role.find('developer')])
db.session.commit()
build = BuildFactory.build(architectures=[Architecture(code='newarch')])
with create_spk(build) as spk:
response = self.client.post(url_for('api.packages'), headers=authorization_header(user),
data=spk.read())
self.assert422(response)
self.assertIn('Unknown architecture: newarch', response.data.decode(response.charset))
def test_post_signed(self):
user = UserFactory(roles=[Role.find('developer'), Role.find('package_admin')])
db.session.commit()
build = BuildFactory.build()
with create_spk(build, signature='signature') as spk:
response = self.client.post(url_for('api.packages'), headers=authorization_header(user),
data=spk.read())
self.assert422(response)
self.assertIn('Package contains a signature', response.data.decode(response.charset))
def test_post_existing_package_maintainer_user(self):
user = UserFactory(roles=[Role.find('developer')])
package = PackageFactory(maintainers=[user])
db.session.commit()
build = BuildFactory.build(version__package=package)
db.session.expire(package)
with create_spk(build) as spk:
self.assert201(self.client.post(url_for('api.packages'), headers=authorization_header(user),
data=spk.read()))
def test_stable_build_active_not_stable(self):
BuildFactory(active=True,
architectures=[Architecture.find('88f6281', syno=True)],
firmware=Firmware.find(1594))
db.session.commit()
data = dict(arch='88f6281', build='1594', language='enu')
response = self.client.post(url_for('nas.catalog'), data=data)
self.assert200(response)
self.assertHeader(response, 'Content-Type', 'application/json')
catalog = json.loads(response.data.decode(response.charset))
self.assertEqual(len(catalog), 0)
def test_missing_conf_folder(self):
build = BuildFactory.build(version__conf_dependencies=None,
version__conf_conflicts=None,
version__conf_privilege=None,
version__conf_resource=None)
info = create_info(build)
info['support_conf_folder'] = 'yes'
with create_spk(build, info=info, with_conf=False) as f:
with self.assertRaises(SPKParseError) as cm:
SPK(f)
self.assertEqual('Missing conf folder', str(cm.exception))
def test_invalid_info(self):
build = BuildFactory.build()
info = io.BytesIO(
"\n".join(["%s=%s" % (k, v) for k, v in create_info(build).items()]).encode(
"utf-8"
)
)
with create_spk(build, info=info) as f:
with self.assertRaises(SPKParseError) as cm:
SPK(f)
self.assertEqual("Invalid INFO", str(cm.exception))
def test_post_invalid_spk(self):
user = UserFactory(roles=[Role.find('developer'), Role.find('package_admin')])
db.session.commit()
build = BuildFactory.build()
with create_spk(build) as spk:
spk.seek(100)
response = self.client.post(url_for('api.packages'), headers=authorization_header(user),
data=spk.read())
self.assert422(response)
self.assertIn('Invalid SPK', response.data.decode(response.charset))
def test_post_new_package_not_author_not_maintainer_user(self):
user = UserFactory(roles=[Role.find('developer')])
db.session.commit()
with create_spk(BuildFactory.build()) as spk:
response = self.client.post(url_for('api.packages'),
headers=authorization_header(user),
data=spk.read())
self.assert403(response)
self.assertIn('Insufficient permissions to create new packages',
response.data.decode(response.charset))
def test_post_wrong_version(self):
user = UserFactory(roles=[Role.find('developer'), Role.find('package_admin')])
db.session.commit()
build = BuildFactory.build()
info = create_info(build)
info['version'] = '1.2.3~4'
with create_spk(build, info=info) as spk:
response = self.client.post(url_for('api.packages'), headers=authorization_header(user),
data=spk.read())
self.assert422(response)
self.assertIn('Invalid version', response.data.decode(response.charset))
def test_post_existing_package_maintainer_user(self):
user = UserFactory(roles=[Role.find('developer')])
package = PackageFactory(maintainers=[user])
db.session.commit()
build = BuildFactory.build(version__package=package)
db.session.expire(package)
with create_spk(build) as spk:
self.assert201(
self.client.post(url_for('api.packages'),
headers=authorization_header(user),
data=spk.read()))
def test_post_unknown_firmware(self):
user = UserFactory(roles=[Role.find('developer')])
db.session.commit()
build = BuildFactory.build(firmware=Firmware(version='1.0', build=421))
with create_spk(build) as spk:
response = self.client.post(url_for('api.packages'),
headers=authorization_header(user),
data=spk.read())
self.assert422(response)
self.assertIn('Unknown firmware',
response.data.decode(response.charset))
def test_action_deactivate(self):
with self.logged_user('package_admin'):
build = BuildFactory(active=True)
db.session.commit()
response = self.client.post(url_for('buildview.action_view'),
follow_redirects=True,
data=dict(action='deactivate',
rowid=[build.id]))
self.assert200(response)
self.assertIn('Build was successfully deactivated.',
response.data.decode(response.charset))
self.assertFalse(build.active)
def test_post_wrong_description_language(self):
user = UserFactory(roles=[Role.find('developer'), Role.find('package_admin')])
db.session.commit()
build = BuildFactory.build()
info = create_info(build)
info['description_zzz'] = 'description_zzz'
with create_spk(build, info=info) as spk:
response = self.client.post(url_for('api.packages'), headers=authorization_header(user),
data=spk.read())
self.assert422(response)
self.assertIn('Unknown INFO description language', response.data.decode(response.charset))
def test_generic(self):
build = BuildFactory.build(version__upgrade_wizard=True,
architectures=[Architecture.query.all()[0], Architecture.query.all()[1]])
with create_spk(build, signature='signature') as f:
spk = SPK(f)
# info
info_keys = ['arch', 'changelog', 'description', 'description_enu', 'displayname', 'displayname_enu',
'distributor', 'distributor_url', 'firmware', 'install_conflict_packages', 'install_dep_packages',
'install_dep_services', 'maintainer', 'maintainer_url', 'package', 'report_url',
'support_conf_folder', 'version']
self.assertEqual(set(info_keys), set(spk.info.keys()))
self.assertEqual({Architecture.from_syno.get(a, a) for a in spk.info['arch'].split()},
{a.code for a in build.architectures})
self.assertEqual(build.version.changelog, spk.info['changelog'])
self.assertEqual(build.version.descriptions['enu'].description, spk.info['description'])
self.assertEqual(build.version.descriptions['enu'].description, spk.info['description_enu'])
self.assertEqual(build.version.displaynames['enu'].displayname, spk.info['displayname'])
self.assertEqual(build.version.displaynames['enu'].displayname, spk.info['displayname_enu'])
self.assertEqual(build.version.distributor, spk.info['distributor'])
self.assertEqual(build.version.distributor_url, spk.info['distributor_url'])
self.assertEqual(build.firmware.firmware_string, spk.info['firmware'])
self.assertEqual(build.version.conflicts, spk.info['install_conflict_packages'])
self.assertEqual(build.version.dependencies, spk.info['install_dep_packages'])
self.assertEqual(' '.join(s.code for s in build.version.service_dependencies), spk.info['install_dep_services'])
self.assertEqual(build.version.maintainer, spk.info['maintainer'])
self.assertEqual(build.version.maintainer_url, spk.info['maintainer_url'])
self.assertEqual(build.version.package.name, spk.info['package'])
self.assertEqual(build.version.report_url, spk.info['report_url'])
self.assertEqual(build.version.conf_dependencies is not None or build.version.conf_conflicts is not None or \
build.version.conf_privilege is not None or build.version.conf_resource is not None,
spk.info['support_conf_folder'])
self.assertEqual(build.version.version_string, spk.info['version'])
# icons
self.assertEqual(set(build.version.icons.keys()), set(spk.icons.keys()))
# wizards
if not build.version.install_wizard:
self.assertNotIn('install', spk.wizards)
else:
self.assertIn('install', spk.wizards)
if not build.version.upgrade_wizard:
self.assertNotIn('upgrade', spk.wizards)
else:
self.assertIn('upgrade', spk.wizards)
# license
self.assertEqual(build.version.license, spk.license)
# signature
self.assertEqual('signature', spk.signature)
def test_post_not_startable(self):
user = UserFactory(
roles=[Role.find('developer'),
Role.find('package_admin')])
db.session.commit()
build = BuildFactory.build(version__startable=False)
with create_spk(build) as spk:
self.assert201(
self.client.post(url_for('api.packages'),
headers=authorization_header(user),
data=spk.read()))
self.assertBuildInserted(Build.query.one(), build, user)
def test_post_unknown_architecture(self):
user = UserFactory(roles=[Role.find('developer')])
db.session.commit()
build = BuildFactory.build(
architectures=[Architecture(code='newarch')])
with create_spk(build) as spk:
response = self.client.post(url_for('api.packages'),
headers=authorization_header(user),
data=spk.read())
self.assert422(response)
self.assertIn('Unknown architecture: newarch',
response.data.decode(response.charset))
def test_stable_build_active_not_stable(self):
BuildFactory(
active=True,
architectures=[Architecture.find("88f6281", syno=True)],
firmware=Firmware.find(1594),
)
db.session.commit()
data = dict(arch="88f6281", build="1594", language="enu")
response = self.client.post(url_for("nas.catalog"), data=data)
self.assert200(response)
self.assertHeader(response, "Content-Type", "application/json")
catalog = json.loads(response.data.decode(response.charset))
self.assertEqual(len(catalog), 0)
def test_empty_conf_folder(self):
build = BuildFactory.build(
version__conf_dependencies=None,
version__conf_conflicts=None,
version__conf_privilege=None,
version__conf_resource=None,
)
info = create_info(build)
info["support_conf_folder"] = "yes"
with create_spk(build, info=info, with_conf=True) as f:
with self.assertRaises(SPKParseError) as cm:
SPK(f)
self.assertEqual("Empty conf folder", str(cm.exception))
def test_generic(self):
build = BuildFactory.build(version__upgrade_wizard=True,
architectures=[Architecture.query.all()[0], Architecture.query.all()[1]])
with create_spk(build, signature='signature') as f:
spk = SPK(f)
# info
info_keys = ['arch', 'changelog', 'description', 'description_enu', 'displayname', 'displayname_enu',
'distributor', 'distributor_url', 'firmware', 'install_conflict_packages', 'install_dep_packages',
'install_dep_services', 'maintainer', 'maintainer_url', 'package', 'report_url',
'support_conf_folder', 'version']
self.assertEqual(set(info_keys), set(spk.info.keys()))
self.assertEqual({Architecture.from_syno.get(a, a) for a in spk.info['arch'].split()},
{a.code for a in build.architectures})
self.assertEqual(build.version.changelog, spk.info['changelog'])
self.assertEqual(build.version.descriptions['enu'].description, spk.info['description'])
self.assertEqual(build.version.descriptions['enu'].description, spk.info['description_enu'])
self.assertEqual(build.version.displaynames['enu'].displayname, spk.info['displayname'])
self.assertEqual(build.version.displaynames['enu'].displayname, spk.info['displayname_enu'])
self.assertEqual(build.version.distributor, spk.info['distributor'])
self.assertEqual(build.version.distributor_url, spk.info['distributor_url'])
self.assertEqual(build.firmware.firmware_string, spk.info['firmware'])
self.assertEqual(build.version.conflicts, spk.info['install_conflict_packages'])
self.assertEqual(build.version.dependencies, spk.info['install_dep_packages'])
self.assertEqual(' '.join(s.code for s in build.version.service_dependencies), spk.info['install_dep_services'])
self.assertEqual(build.version.maintainer, spk.info['maintainer'])
self.assertEqual(build.version.maintainer_url, spk.info['maintainer_url'])
self.assertEqual(build.version.package.name, spk.info['package'])
self.assertEqual(build.version.report_url, spk.info['report_url'])
self.assertEqual(build.version.conf_dependencies is not None or build.version.conf_conflicts is not None,
spk.info['support_conf_folder'])
self.assertEqual(build.version.version_string, spk.info['version'])
# icons
self.assertEqual(set(build.version.icons.keys()), set(spk.icons.keys()))
# wizards
if not build.version.install_wizard:
self.assertNotIn('install', spk.wizards)
else:
self.assertIn('install', spk.wizards)
if not build.version.upgrade_wizard:
self.assertNotIn('upgrade', spk.wizards)
else:
self.assertIn('upgrade', spk.wizards)
# license
self.assertEqual(build.version.license, spk.license)
# signature
self.assertEqual('signature', spk.signature)
def test_post_invalid_firmware(self):
user = UserFactory(roles=[Role.find("developer")])
db.session.commit()
build = BuildFactory.build(firmware=Firmware(version="1.0", build=42))
with create_spk(build) as spk:
response = self.client.post(
url_for("api.packages"),
headers=authorization_header(user),
data=spk.read(),
)
self.assert422(response)
self.assertIn("Invalid firmware",
response.data.decode(response.charset))
def test_generic(self):
build = BuildFactory.build(version__upgrade_wizard=True)
f = create_spk(build)
spk = SPK(f)
with tarfile.open(fileobj=f, mode='r:') as tar:
self.assertNotIn('syno_signature.asc', tar.getnames())
self.assertIsNone(spk.signature)
spk._generate_signature = Mock(return_value='timestamped signature')
spk.sign('timestamp_url', 'gnupghome')
with tarfile.open(fileobj=f, mode='r:') as tar:
self.assertIn('syno_signature.asc', tar.getnames())
self.assertEqual(tar.extractfile('syno_signature.asc').read(), b'timestamped signature')
self.assertEqual(spk.signature, 'timestamped signature')
f.close()
def test_post_signed(self):
user = UserFactory(
roles=[Role.find('developer'),
Role.find('package_admin')])
db.session.commit()
build = BuildFactory.build()
with create_spk(build, signature='signature') as spk:
response = self.client.post(url_for('api.packages'),
headers=authorization_header(user),
data=spk.read())
self.assert422(response)
self.assertIn('Package contains a signature',
response.data.decode(response.charset))
def test_generic(self):
build = BuildFactory.build(version__upgrade_wizard=True)
f = create_spk(build)
spk = SPK(f)
with tarfile.open(fileobj=f, mode='r:') as tar:
self.assertNotIn('syno_signature.asc', tar.getnames())
self.assertIsNone(spk.signature)
spk._generate_signature = Mock(return_value='timestamped signature')
spk.sign('timestamp_url', 'gnupghome')
with tarfile.open(fileobj=f, mode='r:') as tar:
self.assertIn('syno_signature.asc', tar.getnames())
self.assertEqual(tar.extractfile('syno_signature.asc').read(), b'timestamped signature')
self.assertEqual(spk.signature, 'timestamped signature')
f.close()
def test_post_icons_in_both(self):
user = UserFactory(
roles=[Role.find('developer'),
Role.find('package_admin')])
db.session.commit()
build = BuildFactory.build()
with create_spk(build, with_package_icons=True,
with_info_icons=True) as spk:
self.assert201(
self.client.post(url_for('api.packages'),
headers=authorization_header(user),
data=spk.read()))
self.assertBuildInserted(Build.query.one(), build, user)
def test_post_conflict(self):
user = UserFactory(roles=[Role.find('developer'), Role.find('package_admin')])
db.session.commit()
architectures = [Architecture.find('88f628x'), Architecture.find('cedarview')]
build = BuildFactory.build(architectures=architectures)
with create_spk(build) as spk:
self.assert201(self.client.post(url_for('api.packages'), headers=authorization_header(user),
data=spk.read()))
spk.seek(0)
response = self.client.post(url_for('api.packages'), headers=authorization_header(user),
data=spk.read())
self.assert409(response)
self.assertIn('Conflicting architectures: 88f628x, cedarview', response.data.decode(response.charset))
def test_post_invalid_spk(self):
user = UserFactory(
roles=[Role.find('developer'),
Role.find('package_admin')])
db.session.commit()
build = BuildFactory.build()
with create_spk(build) as spk:
spk.seek(100)
response = self.client.post(url_for('api.packages'),
headers=authorization_header(user),
data=spk.read())
self.assert422(response)
self.assertIn('Invalid SPK', response.data.decode(response.charset))
def test_incorrect_firmware_build(self):
architecture = Architecture.find('88f6281', syno=True)
build = BuildFactory(active=True,
version__report_url=None,
architectures=[architecture],
firmware=Firmware.find(1594))
db.session.commit()
self.assertEqual(Download.query.count(), 0)
response = self.client.get(
url_for('nas.download',
architecture_id=architecture.id,
firmware_build=1593,
build_id=build.id))
self.assert400(response)
self.assertEqual(Download.query.count(), 0)
def test_post_upgrade_wizard(self):
user = UserFactory(
roles=[Role.find("developer"),
Role.find("package_admin")])
db.session.commit()
build = BuildFactory.build(version__upgrade_wizard=True)
with create_spk(build) as spk:
self.assert201(
self.client.post(
url_for("api.packages"),
headers=authorization_header(user),
data=spk.read(),
))
self.assertBuildInserted(Build.query.one(), build, user)
def test_action_activate_one(self):
with self.logged_user("package_admin"):
build = BuildFactory(active=False)
db.session.commit()
response = self.client.post(
url_for("build.action_view"),
follow_redirects=True,
data=dict(action="activate", rowid=[build.id]),
)
self.assert200(response)
self.assertIn(
"Build was successfully activated.",
response.data.decode(response.charset),
)
self.assertTrue(build.active)
def test_post_wrong_version(self):
user = UserFactory(
roles=[Role.find('developer'),
Role.find('package_admin')])
db.session.commit()
build = BuildFactory.build()
info = create_info(build)
info['version'] = '1.2.3~4'
with create_spk(build, info=info) as spk:
response = self.client.post(url_for('api.packages'),
headers=authorization_header(user),
data=spk.read())
self.assert422(response)
self.assertIn('Invalid version',
response.data.decode(response.charset))
def test_post_existing_package_not_author_not_maintainer_user(self):
user = UserFactory(roles=[Role.find("developer")])
package = PackageFactory()
db.session.commit()
with create_spk(BuildFactory.build(version__package=package)) as spk:
response = self.client.post(
url_for("api.packages"),
headers=authorization_header(user),
data=spk.read(),
)
self.assert403(response)
self.assertIn(
"Insufficient permissions on this package",
response.data.decode(response.charset),
)
def test_get(self):
build = BuildFactory(version__package__author=UserFactory(),
version__report_url=None,
active=True)
db.session.commit()
response = self.client.get(
url_for('frontend.package', name=build.version.package.name))
self.assert200(response)
for a in build.architectures:
self.assertIn(a.code, response.data.decode(response.charset))
self.assertIn(build.version.package.author.username,
response.data.decode(response.charset))
self.assertIn(build.version.displaynames['enu'].displayname,
response.data.decode(response.charset))
self.assertIn(build.version.descriptions['enu'].description,
response.data.decode(response.charset))
def test_post_wrong_description_language(self):
user = UserFactory(
roles=[Role.find('developer'),
Role.find('package_admin')])
db.session.commit()
build = BuildFactory.build()
info = create_info(build)
info['description_zzz'] = 'description_zzz'
with create_spk(build, info=info) as spk:
response = self.client.post(url_for('api.packages'),
headers=authorization_header(user),
data=spk.read())
self.assert422(response)
self.assertIn('Unknown INFO description language',
response.data.decode(response.charset))
def test_generic(self):
build = BuildFactory.build(version__upgrade_wizard=True)
f = create_spk(build)
spk = SPK(f)
with tarfile.open(fileobj=f, mode="r:") as tar:
self.assertNotIn("syno_signature.asc", tar.getnames())
self.assertIsNone(spk.signature)
spk._generate_signature = Mock(return_value="timestamped signature")
spk.sign("timestamp_url", "gnupghome")
with tarfile.open(fileobj=f, mode="r:") as tar:
self.assertIn("syno_signature.asc", tar.getnames())
self.assertEqual(
tar.extractfile("syno_signature.asc").read(),
b"timestamped signature")
self.assertEqual(spk.signature, "timestamped signature")
f.close()
def test_stable_build_active_stable_qinst(self):
build = BuildFactory(
active=True,
version__report_url=None,
version__license=None,
version__install_wizard=False,
architectures=[Architecture.find('88f6281', syno=True)],
firmware=Firmware.find(1594))
db.session.commit()
data = dict(arch='88f6281', build='1594', language='enu')
response = self.client.post(url_for('nas.catalog'), data=data)
self.assert200(response)
self.assertHeader(response, 'Content-Type', 'application/json')
catalog = json.loads(response.data.decode(response.charset))
self.assertEqual(len(catalog), 1)
self.assertCatalogEntry(catalog[0], build, data,
dict(arch='88f628x', build='1594'))
def test_post_wrong_version(self):
user = UserFactory(
roles=[Role.find("developer"),
Role.find("package_admin")])
db.session.commit()
build = BuildFactory.build()
info = create_info(build)
info["version"] = "1.2.3~4"
with create_spk(build, info=info) as spk:
response = self.client.post(
url_for("api.packages"),
headers=authorization_header(user),
data=spk.read(),
)
self.assert422(response)
self.assertIn("Invalid version",
response.data.decode(response.charset))
def test_post_wrong_displayname_language(self):
user = UserFactory(
roles=[Role.find("developer"),
Role.find("package_admin")])
db.session.commit()
build = BuildFactory.build()
info = create_info(build)
info["displayname_zzz"] = "displayname_zzz"
with create_spk(build, info=info) as spk:
response = self.client.post(
url_for("api.packages"),
headers=authorization_header(user),
data=spk.read(),
)
self.assert422(response)
self.assertIn("Unknown INFO displayname language",
response.data.decode(response.charset))
def test_stable_build_active_stable_5004(self):
build = BuildFactory(
active=True,
version__report_url=None,
architectures=[Architecture.find("88f6281", syno=True)],
firmware=Firmware.find(1594),
)
db.session.commit()
data = dict(arch="88f6281", build="5004", language="enu")
response = self.client.post(url_for("nas.catalog"), data=data)
self.assert200(response)
self.assertHeader(response, "Content-Type", "application/json")
catalog = json.loads(response.data.decode(response.charset))
self.assertIn("packages", catalog)
self.assertIn("keyrings", catalog)
self.assertEqual(len(catalog["packages"]), 1)
self.assertCatalogEntry(catalog["packages"][0], build, data,
dict(arch="88f628x", build="5004"))
def test_info_blank_like(self):
build = BuildFactory.build()
info = io.BytesIO('\n'.join(['%s="%s"\n' % (k, v) for k, v in create_info(build).items()]).encode('utf-8'))
with create_spk(build, info=info) as f:
SPK(f)
def test_info_boolean_no(self):
build = BuildFactory.build(version__startable=False)
with create_spk(build) as f:
self.assertFalse(SPK(f).info['startable'])
def test_no_info(self):
build = BuildFactory.build()
with create_spk(build, with_info=False) as f:
with self.assertRaises(SPKParseError) as cm:
SPK(f)
self.assertEqual('Missing INFO file', str(cm.exception))
def test_wrong_license_encoding(self):
build = BuildFactory.build(version__license='License française')
with create_spk(build, license_encoding='latin-1') as f:
with self.assertRaises(SPKParseError) as cm:
SPK(f)
self.assertEqual('Wrong LICENSE encoding', str(cm.exception))
def test_no_package_tgz(self):
build = BuildFactory.build()
with create_spk(build, with_package=False) as f:
with self.assertRaises(SPKParseError) as cm:
SPK(f)
self.assertEqual('Missing package.tgz file', str(cm.exception))
def test_wrong_conf_conflicts_encoding(self):
build = BuildFactory.build(version__conf_conflicts=json.dumps({'déçu': {'dsm_min_ver': '5.0-4300'}}))
with create_spk(build, conf_conflicts_encoding='latin-1') as f:
with self.assertRaises(SPKParseError) as cm:
SPK(f)
self.assertEqual('Wrong conf/PKG_CONX encoding', str(cm.exception))
