def test_manager_filtering(self):
Package(author=self.author, type='a').save()
Package(author=self.author, type='a').save()
Package(author=self.author, type='l').save()
self.assertEqual(Package.objects.addons().count(), 2)
self.assertEqual(Package.objects.libraries().count(), 3)
def test_duplicate_packages_integrity_error(self):
# duplicate packages are denied on MySQL level
author = User.objects.get(username='******')
addon = Package(full_name='Integrity Error', author=author, type='a')
addon.save()
backup = Package.full_clean
Package.full_clean = Mock()
addon2 = Package(full_name='Integrity Error', author=author, type='a')
self.assertRaises(IntegrityError, addon2.save)
Package.full_clean = backup
def test_first_addon_template(self):
author = User.objects.create(username='******')
addon = Package(full_name='First Addon', author=author, type='a')
addon.save()
mod = addon.latest.modules.all()[0]
assert 'id: "first-addon-widget' in mod.code
addon2 = Package(full_name='Second Addon', author=author, type='a')
addon2.save()
mod2 = addon2.latest.modules.all()[0]
assert 'id: "second-addon-widget' not in mod2.code
def test_ordering(self):
" Newest is first "
addon1 = Package(author=self.author, type='a')
addon1.save()
addon2 = Package(author=self.author, type='a')
addon2.save()
# My Addon should be second
# but because in the test these are so close and we're testing in
# mutithreaded MySQL it could be different. It would be fair to assume
# one of these will be (1) and the other not
names = (addon1.full_name, addon2.full_name)
self.failUnless('%s (1)' % self.author.username in names)
self.failUnless('%s' % self.author.username in names)
def test_dashboard_with_broken_package(self):
# fixable add-on - no latest given
author = User.objects.get(username='******')
addon = Package(full_name='NOLATEST', author=author, type='a')
addon.save()
# adding a new version
addon.latest.save()
eq_(addon.revisions.count(), 2)
addon.latest.set_version('1.0')
latest = addon.latest
# removing addon.latest
addon.latest = None
addon.version = None
addon.save()
assert not addon.latest
self.assertRaises(UndefinedError, self.client.get,
author.get_profile().get_profile_url())
# fix latest will assign last revision to latest
addon.fix_latest()
response = self.client.get(author.get_profile().get_profile_url())
eq_(response.status_code, 200)
addon = Package.objects.get(full_name='NOLATEST')
assert addon.latest
eq_(addon.latest, latest)
self.assertRaises(AttributeError, addon.latest.get_absolute_url)
# fix version will assign revision with a highest version_name to
# version
addon.fix_version()
eq_(response.status_code, 200)
addon = Package.objects.get(full_name='NOLATEST')
assert addon.version
eq_(addon.version.version_name, '1.0')
# package with no version at all
post_save.disconnect(save_first_revision, sender=Package)
addon = Package(full_name='NOREVISION',
name='broken',
author=author,
type='a')
addon.save()
post_save.connect(save_first_revision, sender=Package)
assert not addon.latest
self.assertRaises(UndefinedError, self.client.get,
author.get_profile().get_profile_url())
# fix latest (it will remove the package)
addon.fix_latest()
response = self.client.get(author.get_profile().get_profile_url())
eq_(response.status_code, 200)
self.assertRaises(Package.DoesNotExist,
Package.objects.get,
full_name='NOREVISION')
def test_save(self):
# system should create new revision on save
addon = Package(author=self.author, type='a')
addon.save()
revisions = PackageRevision.objects.filter(package__name=addon.name)
first = revisions[0]
first.save()
revisions = PackageRevision.objects.filter(package__name=addon.name)
eq_(2, revisions.count())
# first is not the same package anymore and it does not have
# the version_name parameter
eq_(None, first.version_name)
# "old" addon doesn't know about the changes
self.assertNotEqual(addon.latest.revision_number,
first.revision_number)
# reloading addon to update changes
addon = first.package
# first is the latest
eq_(addon.latest.revision_number,
first.revision_number)
self.assertNotEqual(addon.version.revision_number,
addon.latest.revision_number)
def test_package_jid_change(self):
jid = 'somejid'
author = self._login()
addon1 = Package(author=author, type='a')
addon1.save()
response = self.client.post(addon1.latest.get_save_url(), {'jid': jid})
eq_(response.status_code, 200)
addon2 = Package.objects.get(pk=addon1.pk)
# no change in revision
eq_(len(addon2.revisions.all()), 1)
eq_(addon2.jid, jid)
# check adding an existing JID
addon3 = Package(author=author, type='a')
addon3.save()
response = self.client.post(addon1.latest.get_save_url(), {'jid': jid})
eq_(response.status_code, 403)
def test_duplicate_packages_name_interation(self):
# duplicate packages are denied on MySQL level
author = User.objects.get(username='******')
addon = Package(full_name='Integrity Error', author=author, type='a')
addon.save()
eq_(addon.latest.name, 'integrity-error')
addon2 = Package(full_name='Integrity Error', author=author, type='a')
addon2.save()
eq_(addon2.latest.name, 'john')
addon3 = Package(full_name='Integrity Error', author=author, type='a')
addon3.save()
eq_(addon3.latest.name, 'john-1')
def test_addon_creation(self):
package = Package(author=self.author, type='a')
package.save()
# all packages have assigned an incremental id_number
assert package.id_number
eq_(int(package.id_number), settings.MINIMUM_PACKAGE_ID + 1)
# all add-ons have PackageRevision created
assert package.version
assert package.latest
eq_(package.version.id, package.latest.id)
# name is created automtically if no given
assert package.full_name
assert package.name
eq_(package.full_name, self.author.username)
# test preventing inserting duplicates
assert Package.objects.get(author=self.author,
type='a',
full_name=package.name)
p = Package.objects.create(author=self.author,
type='a',
full_name=package.name)
#test package name iteration
eq_('john-1', p.name)
eq_('john', package.name)
def test_adding_extra_package_properties(self):
addon = Package(type='a', author=self.author)
addon.save()
pk = addon.pk
rev = addon.latest
rev.set_extra_json('''
{
"preferences": [{
"name": "example",
"type": "string",
"title": "foo",
"value": "bar"
}],
"id": "baz"
}
''')
addon = Package.objects.get(pk=pk) # breaking cache
manifest = addon.latest.get_manifest()
assert 'preferences' in manifest
eq_(manifest['preferences'][0]['name'], 'example')
# user-provide values don't override our generated ones
self.assertNotEqual(manifest['id'], 'baz')
assert 'Extra JSON' in addon.latest.commit_message
def test_outdated_dependencies_with_conflicts(self):
addon = Package.objects.create(author=self.author, type='a')
lib = Package.objects.create(author=self.author, type='l')
addon.latest.dependency_add(lib.latest)
jan = User.objects.get(username='******')
jan_lib = Package(author=jan, type='l', full_name='janjanjan')
jan_lib.save()
dupe_lib = Package(author=jan, type='l', full_name=lib.full_name)
dupe_lib.save()
addon.latest.dependency_add(jan_lib.latest)
jan_lib.latest.dependency_add(dupe_lib.latest)
out_of_date = addon.latest.get_outdated_dependency_versions()
eq_(len(out_of_date), 0)
def test_prepare_zip_file(self):
author = User.objects.get(username='******')
addon = Package(author=author, type='a')
addon.save()
prepare_url = addon.latest.get_prepare_zip_url()
response = self.client.post(prepare_url, {'hashtag': self.hashtag})
eq_(response.status_code, 200)
eq_(response.content, '{"delayed": true}')
def test_library_creation_with_nickname(self):
profile = self.author.get_profile()
profile.nickname = 'Samuel'
profile.save()
package = Package(author=self.author, type='l')
package.save()
eq_(package.full_name, 'Samuel-lib')
def test_adding_libs_with_common_dependency(self):
# if B and C both depend on D, at the same version, then it should
# be able to add both to A
addon = Package(author=self.author, type='a')
addon.save()
lib1 = Package(author=self.author, type='l')
lib1.save()
lib2 = Package(author=self.author, type='l')
lib2.save()
lib3 = Package(author=self.author, type='l')
lib3.save()
lib1.latest.dependency_add(lib3.latest)
lib2.latest.dependency_add(lib3.latest)
addon.latest.dependency_add(lib1.latest)
addon.latest.dependency_add(lib2.latest)
assert True
def test_download_zip_file(self):
author = User.objects.get(username='******')
addon = Package(author=author, type='a')
addon.save()
addon.latest.zip_source(hashtag=self.hashtag)
download_url = reverse('jp_revision_download_zip',
args=[self.hashtag, 'x'])
response = self.client.get(download_url)
eq_(response.status_code, 200)
eq_(response['Content-Disposition'], 'attachment; filename="x.zip"')
def test_package_invalid_extra_json(self):
author = self._login()
addon = Package(author=author, type='a')
addon.save()
extra_json = '{ foo: bar }'
response = self.client.post(addon.latest.get_save_url(),
{'package_extra_json': extra_json})
eq_(response.status_code, 400)
assert 'invalid JSON' in response.content
def test_manager_sort_recently_active(self):
p1 = Package(author=self.author, type='a')
p1.save()
p2 = Package(author=self.author, type='a')
p2.save()
Package(author=self.author, type='l').save()
p1rev2 = PackageRevision(author=self.author, revision_number=2)
p1.revisions.add(p1rev2)
p1rev2.created_at = datetime.datetime.now() - datetime.timedelta(60)
super(PackageRevision, p1rev2).save()
p2rev = p2.revisions.all()[0]
p2rev.save() #makes a new revision
qs = Package.objects.sort_recently_active().filter(type='a')
eq_(qs.count(), 2)
eq_(p2.id, qs[0].id)
eq_(qs[0].rev_count, 2)
eq_(qs[1].rev_count, 1)
def test_addon_creation_with_nickname(self):
"""In production if you log in with an AMO user, the username
is set to a number and the nickname on the profile is set to the
real username."""
profile = self.author.get_profile()
profile.nickname = 'Gordon'
profile.save()
package = Package(author=self.author, type='a')
package.save()
eq_(package.full_name, 'Gordon')
def test_revision_list_contains_added_modules(self):
author = User.objects.get(username='******')
addon = Package(author=author, type='a')
addon.save()
mod = Module.objects.create(filename='test_filename',
author=author,
code='// test')
rev = addon.latest
rev.module_add(mod)
r = self.client.get(
reverse('jp_revisions_list_html', args=[addon.latest.pk]))
assert 'test_filename' in r.content
def test_check_zip_file(self):
author = User.objects.get(username='******')
addon = Package(author=author, type='a')
addon.save()
check_url = reverse('jp_revision_check_zip', args=[
self.hashtag,
])
response = self.client.get(check_url)
eq_(response.content, '{"ready": false}')
addon.latest.zip_source(hashtag=self.hashtag)
response = self.client.get(check_url)
eq_(response.status_code, 200)
eq_(response.content, '{"ready": true}')
def test_package_name_change(self):
author = self._login()
addon1 = Package(author=author, type='a')
addon1.save()
rev1 = addon1.latest
log.debug(addon1.latest.get_save_url())
response = self.client.post(addon1.latest.get_save_url(),
{'full_name': 'FULL NAME'})
eq_(response.status_code, 200)
addon2 = Package.objects.get(pk=addon1.pk)
eq_(len(addon2.revisions.all()), 2)
eq_(addon2.full_name, addon2.latest.full_name)
assert rev1.name != addon2.latest.name
def test_first_revision_creation(self):
addon = Package(author=self.author, type='a')
addon.save()
revisions = PackageRevision.objects.filter(package__pk=addon.pk)
eq_(1, revisions.count())
revision = revisions[0]
eq_(revision.full_name, addon.full_name)
eq_(revision.name, addon.name)
eq_(revision.author.username, addon.author.username)
eq_(revision.revision_number, 0)
eq_(revision.pk, addon.latest.pk)
eq_(revision.pk, addon.version.pk)
eq_(revision.name, addon.name)
def test_package_extra_json_change(self):
author = self._login()
addon = Package(author=author, type='a')
addon.save()
pk = addon.pk
homepage = 'https://builder.addons.mozilla.org'
extra_json = '{"homepage": "%s"}' % homepage
response = self.client.post(addon.latest.get_save_url(),
{'package_extra_json': extra_json})
addon = Package.objects.get(pk=pk) # old one is cached
eq_(addon.latest.extra_json, extra_json)
def test_name_change(self):
addon = Package(author=self.author, type='a')
addon.save()
revisionA = PackageRevision.objects.filter(package__pk=addon.pk)[0]
addon.latest.set_full_name("TEST NAME CHANGE")
addon.save()
addon.latest.save()
revisionB = PackageRevision.objects.filter(package__pk=addon.pk)[0]
log.debug(revisionB.name)
log.debug(addon.name)
eq_(revisionB.name, addon.name)
assert revisionA.pk != revisionB.pk
assert revisionA.name != revisionB.name
eq_(len(addon.revisions.all()), 2)
def test_adding_library_naming_conflict(self):
" Check recurrent dependency (all levels) "
john_lib = self.library
john_lib2 = Package(author=self.author, type='l')
john_lib2.save()
jan = User.objects.get(username='******')
jan_lib = Package(author=jan, type='l')
jan_lib.save()
jan_conflict = Package(author=jan, type='l', full_name=john_lib.full_name)
jan_conflict.save()
john_lib.latest.dependency_add(jan_lib.latest)
addon = self.addon.latest
addon.dependency_add(john_lib.latest)
addon.dependency_add(jan_lib.latest)
self.assertRaises(DependencyException, addon.dependency_add, jan_conflict.latest)
john_lib2.latest.dependency_add(jan_conflict.latest)
self.assertRaises(DependencyException, addon.dependency_add, john_lib2.latest)
def test_add_commit_message(self):
author = User.objects.all()[0]
addon = Package(type='a', author=author)
addon.save()
rev = addon.latest
rev.add_commit_message('one')
rev.add_commit_message('two')
rev.save()
eq_(rev.commit_message, 'one, two')
# revision has been saved, so we should be building up a new commit message
rev.add_commit_message('three')
rev.save()
eq_(rev.commit_message, 'three')
def test_package_sanitization(self):
bad_text = u'Te$tąć"><script src="google.com"></script>!#'
good_text = 'Te$tscript srcgoogle.com/script!#'
good_text_utf8 = u'Te$tąćscript srcgoogle.com/script!#'
package = Package(author=self.author,
type='a',
full_name=bad_text,
description=bad_text,
version_name=bad_text)
package.save()
eq_(package.full_name, good_text)
eq_(package.description, good_text_utf8)
eq_(package.version_name, good_text)
def test_set_version(self):
addon = Package(author=self.author, type='a')
addon.save()
first = addon.latest
old_id = first.id
first.set_version('test')
# setting version does not make new revision
eq_(first.id, old_id)
# setting version sets it for revision, package
# and assigns revision to package
eq_(first.version_name, 'test')
eq_(first.package.version_name, 'test')
eq_(first.package.version.pk, first.pk)
def test_copy_revision(self):
author = User.objects.get(username='******')
addon = Package(author=author, type='a')
addon.save()
# unauthenticated
response = self.client.get(addon.latest.get_copy_url())
eq_(response.status_code, 302)
# authenticated
author.set_password('secure')
author.save()
self.client.login(username=author.username, password='******')
log.debug(addon.latest.get_copy_url())
response = self.client.get(addon.latest.get_copy_url())
eq_(response.status_code, 200)
assert 'Add-on' in response.content
assert 'copied' in response.content
def test_folder_added_when_attachments_removed(self):
" EmptyDir's should be added if all attachments in a 'dir' are removed "
addon = Package(author=self.author, type='a')
addon.save()
revision = PackageRevision.objects.filter(package__name=addon.name)[0]
att = Attachment(filename='/'.join([self.path, 'helpers']),
author=self.author,
ext='js')
att.save()
revision.attachment_add(att)
self.assertEqual(0, revision.folders.count())
revision.attachment_remove(att)
self.assertEqual(1, revision.folders.count())
self.assertEqual(self.path, revision.folders.all()[0].name)
