def test_name_with_translations_fallback(self, get_json_data):
get_json_data.return_value = {
'name': 'Blah',
'description': 'Blah Description',
'developer': {
'name': 'Mozilla Marketplace Testing'
},
'default_locale': 'en-US',
'locales': {
'fr': {
'description': 'Blah Description (fr)',
},
'es': {
'name': 'Blah (es)',
}
}
}
# The argument to parse() is supposed to be a filename, it doesn't
# matter here though since we are mocking get_json_data().
parsed_results = WebAppParser().parse('')
eq_(parsed_results['name'].get('fr'), 'Blah') # Falls back to default.
eq_(parsed_results['name'].get('es'), 'Blah (es)')
eq_(parsed_results['name'].get('en-US'), 'Blah')
eq_(parsed_results['name'].get('de'), None)
eq_(parsed_results['default_locale'], 'en-US')
def test_no_manifest_at_root(self):
with self.assertRaises(forms.ValidationError) as exc:
WebAppParser().parse(
self.packaged_app_path('no-manifest-at-root.zip'))
m = exc.exception.messages[0]
assert m.startswith('The file "manifest.webapp" was not found'), (
'Unexpected: %s' % m)
def test_non_ascii(self):
wm = json.dumps(dict(name=u'まつもとゆきひろ',
version='1.0',
developer=dict(name=u'まつもとゆきひろ')),
encoding='shift-jis')
wp = WebAppParser().parse(self.webapp(contents=wm))
eq_(wp['name'], {'en-US': u'まつもとゆきひろ'})
def clean_upload(self):
upload = self.cleaned_data["upload"]
errors = []
if upload.size > self.max_size:
errors.append(
{
"type": "error",
"message": _(
"Packaged app too large for submission. Packages "
"must be less than %s." % filesizeformat(self.max_size)
),
"tier": 1,
}
)
manifest = None
try:
# Be careful to keep this as in-memory zip reading.
manifest = ZipFile(upload, "r").read("manifest.webapp")
except Exception as e:
errors.append({"type": "error", "message": _("Error extracting manifest from zip file."), "tier": 1})
origin = None
if manifest:
try:
origin = WebAppParser.decode_manifest(manifest).get("origin")
except forms.ValidationError as e:
errors.append({"type": "error", "message": "".join(e.messages), "tier": 1})
if origin:
try:
verify_app_domain(origin, packaged=True, exclude=self.addon)
except forms.ValidationError, e:
errors.append({"type": "error", "message": "".join(e.messages), "tier": 1})
def _update_developer_name(id):
try:
webapp = Webapp.objects.get(pk=id)
except Webapp.DoesNotExist:
_log(id, u'Webapp does not exist')
return
version = webapp.current_version
# If the app doesn't have a current_version, don't bother.
if not version:
_log(id, u'Webapp does not have a current_version')
return
# If the current_version already has a non-empty developer_name set, don't
# touch it and bail.
if version._developer_name:
_log(id, u'Webapp already has a non-empty developer_name')
return
try:
data = WebAppParser().parse(webapp.get_latest_file().file_path)
except ValidationError:
_log(id, u'Webapp manifest can not be parsed')
return
max_len = version._meta.get_field_by_name('_developer_name')[0].max_length
version.update(_developer_name=data['developer_name'][:max_len])
def test_non_ascii(self):
wm = json.dumps({
'name': u'まつもとゆきひろ',
'version': '1.0'
},
encoding='shift-jis')
wp = WebAppParser().parse(self.webapp(contents=wm))
eq_(wp['name'], {'en-US': u'まつもとゆきひろ'})
def test_no_locales(self):
wp = WebAppParser().parse(
self.webapp(
dict(name='foo',
version='1.0',
description='description',
developer=dict(name='bar'))))
eq_(wp['description']['en-US'], u'description')
def get_manifest_json(self, file_obj=None):
file_ = file_obj or self.get_latest_file()
if not file_:
return
if self.status == amo.STATUS_REJECTED:
file_path = file_.guarded_file_path
else:
file_path = file_.file_path
return WebAppParser().get_json_data(file_path)
def test_parse_packaged_BOM(self):
wp = WebAppParser().parse(self.packaged_app_path('mozBOM.zip'))
eq_(wp['guid'], None)
eq_(wp['type'], amo.ADDON_WEBAPP)
eq_(wp['name']['en-US'], u'Packaged MozBOM ょ')
eq_(wp['summary']['en-US'], u'Exciting BOM action!')
eq_(wp['summary']['es'], u'¡Acción BOM!')
eq_(wp['summary']['it'], u'Azione BOM!')
eq_(wp['version'], '1.0')
eq_(wp['default_locale'], 'en-US')
def test_no_developer_name(self, get_json_data):
get_json_data.return_value = {
'name': 'Blah'
}
with self.assertRaises(forms.ValidationError) as e:
# The argument to parse() is supposed to be a filename, it doesn't
# matter here though since we are mocking get_json_data().
WebAppParser().parse('')
eq_(e.exception.messages, ["Developer name is required in the manifest"
" in order to display it on the app's "
"listing."])
def test_parse(self):
wp = WebAppParser().parse(self.webapp_path)
eq_(wp['guid'], None)
eq_(wp['type'], amo.ADDON_WEBAPP)
eq_(wp['summary']['en-US'], u'Exciting Open Web development action!')
eq_(wp['summary']['es'],
u'\u9686Acci\u8d38n abierta emocionante del desarrollo del Web!')
eq_(wp['summary']['it'],
u'Azione aperta emozionante di sviluppo di fotoricettore!')
eq_(wp['version'], '1.0')
eq_(wp['default_locale'], 'en-US')
def test_developer_name(self, get_json_data):
get_json_data.return_value = {
'name': 'Blah',
'developer': {
'name': 'Mozilla Marketplace Testing'
}
}
# The argument to parse() is supposed to be a filename, it doesn't
# matter here though since we are mocking get_json_data().
parsed_results = WebAppParser().parse('')
eq_(parsed_results['developer_name'], 'Mozilla Marketplace Testing')
def test_parse_packaged(self):
wp = WebAppParser().parse(self.packaged_app_path('mozball.zip'))
eq_(wp['guid'], None)
eq_(wp['type'], amo.ADDON_WEBAPP)
eq_(wp['name']['en-US'], u'Packaged MozillaBall ょ')
eq_(wp['summary']['en-US'], u'Exciting Open Web development action!')
eq_(wp['summary']['es'],
u'¡Acción abierta emocionante del desarrollo del Web!')
eq_(wp['summary']['it'],
u'Azione aperta emozionante di sviluppo di fotoricettore!')
eq_(wp['version'], '1.0')
eq_(wp['default_locale'], 'en-US')
def clean_upload(self):
upload = self.cleaned_data['upload']
errors = []
if upload.size > self.max_size:
errors.append({
'type':
'error',
'message':
_('Packaged app too large for submission. Packages '
'must be smaller than %s.' % filesizeformat(self.max_size)),
'tier':
1,
})
# Immediately raise an error, do not process the rest of the view,
# which would read the file.
raise self.persist_errors(errors, upload)
manifest = None
try:
# Be careful to keep this as in-memory zip reading.
manifest = ZipFile(upload, 'r').read('manifest.webapp')
except Exception as e:
errors.append({
'type':
'error',
'message':
_('Error extracting manifest from zip file.'),
'tier':
1,
})
origin = None
if manifest:
try:
origin = WebAppParser.decode_manifest(manifest).get('origin')
except forms.ValidationError as e:
errors.append({
'type': 'error',
'message': ''.join(e.messages),
'tier': 1,
})
if origin:
try:
verify_app_domain(origin, packaged=True, exclude=self.addon)
except forms.ValidationError, e:
errors.append({
'type': 'error',
'message': ''.join(e.messages),
'tier': 1,
})
def test_parse(self):
wp = WebAppParser().parse(self.webapp_path)
eq_(wp['guid'], None)
eq_(wp['type'], amo.ADDON_WEBAPP)
eq_(wp['description']['en-US'],
u'Exciting Open Web development action!')
# UTF-8 byte string decoded to unicode.
eq_(wp['description']['es'],
u'\xa1Acci\xf3n abierta emocionante del desarrollo del Web!')
eq_(wp['description']['it'],
u'Azione aperta emozionante di sviluppo di fotoricettore!')
eq_(wp['version'], '1.0')
eq_(wp['default_locale'], 'en-US')
def clean_upload(self):
upload = self.cleaned_data['upload']
errors = []
if upload.size > self.max_size:
errors.append({
'type': 'error',
'message': _('Packaged app too large for submission. Packages '
'must be smaller than %s.' % filesizeformat(
self.max_size)),
'tier': 1,
})
# Immediately raise an error, do not process the rest of the view,
# which would read the file.
raise self.persist_errors(errors, upload)
manifest = None
try:
# Be careful to keep this as in-memory zip reading.
manifest = ZipFile(upload, 'r').read('manifest.webapp')
except Exception as e:
errors.append({
'type': 'error',
'message': _('Error extracting manifest from zip file.'),
'tier': 1,
})
origin = None
if manifest:
try:
origin = WebAppParser.decode_manifest(manifest).get('origin')
except forms.ValidationError as e:
errors.append({
'type': 'error',
'message': ''.join(e.messages),
'tier': 1,
})
if origin:
try:
verify_app_domain(origin, packaged=True, exclude=self.addon)
except forms.ValidationError, e:
errors.append({
'type': 'error',
'message': ''.join(e.messages),
'tier': 1,
})
def import_manifests(ids, **kw):
for app in Webapp.objects.filter(id__in=ids):
for version in app.versions.all():
try:
file_ = version.files.latest()
if file_.status == amo.STATUS_DISABLED:
file_path = file_.guarded_file_path
else:
file_path = file_.file_path
manifest = WebAppParser().get_json_data(file_path)
m, c = AppManifest.objects.get_or_create(
version=version, manifest=json.dumps(manifest))
if c:
task_log.info(
'[Webapp:%s] Imported manifest for version %s' % (
app.id, version.id))
else:
task_log.info(
'[Webapp:%s] App manifest exists for version %s' % (
app.id, version.id))
except Exception as e:
task_log.info('[Webapp:%s] Error loading manifest for version '
'%s: %s' % (app.id, version.id, e))
def test_packaged_with_BOM(self):
# Exercise separate code paths to loading the packaged app manifest.
self.setup_files('mozBOM.zip')
assert WebAppParser().parse(self.file.file_path)
self.assertTrue(self.app.has_icon_in_manifest())
def test_no_description(self):
wp = WebAppParser().parse(
self.webapp(
dict(name='foo', version='1.0', developer=dict(name='bar'))))
eq_(wp['description'], {})
def test_utf32_bom(self):
data = json.dumps(self.manifest, encoding='utf8')
wm = data.decode('utf8').encode('utf32') # BOM added automatically
wp = WebAppParser().parse(self.webapp(contents=wm))
eq_(wp['version'], '1.0')
def test_utf8_bom(self):
wm = codecs.BOM_UTF8 + json.dumps(self.manifest, encoding='utf8')
wp = WebAppParser().parse(self.webapp(contents=wm))
eq_(wp['version'], '1.0')
def test_syntax_error(self):
with self.assertRaises(forms.ValidationError) as exc:
WebAppParser().parse(self.webapp(contents='}]'))
m = exc.exception.messages[0]
assert m.startswith('Could not parse webapp manifest'), (
'Unexpected: %s' % m)
def test_no_description(self):
wp = WebAppParser().parse(self.webapp(dict(name='foo', version='1.0')))
eq_(wp['summary'], {})
def test_no_locales(self):
wp = WebAppParser().parse(
self.webapp(dict(name='foo', version='1.0',
description='summary')))
eq_(wp['summary']['en-US'], u'summary')
