def test_redirect(self):
url = '/developers/'
res = self.client.get(urlparams(reverse('users.logout'), to=url),
follow=True)
self.assert3xx(res, url, status_code=302)
# Test that we don't follow domains
url = urlparams(reverse('users.logout'), to='http://ev.il/developers/')
res = self.client.get(url, follow=True)
self.assert3xx(res, '/', status_code=302)
def authorize(request):
if request.method == 'GET' and 'oauth_token' in request.GET:
try:
t = Token.objects.get(token_type=REQUEST_TOKEN,
key=request.GET['oauth_token'])
except Token.DoesNotExist:
log.error('Invalid OAuth request for obtaining user authorization')
return HttpResponse(status=401)
return render(request, 'developers/oauth_authorize.html',
{'app_name': t.creds.app_name,
'oauth_token': request.GET['oauth_token']})
elif request.method == 'POST':
token = request.POST.get('oauth_token')
try:
t = Token.objects.get(token_type=REQUEST_TOKEN,
key=token)
except Token.DoesNotExist:
return HttpResponse(status=401)
if 'grant' in request.POST:
t.user = request.user
t.save()
return HttpResponseRedirect(
urlparams(t.creds.redirect_uri, oauth_token=token,
oauth_verifier=t.verifier))
elif 'deny' in request.POST:
t.delete()
return HttpResponse(status=200)
else:
log.error('Invalid OAuth request for user access authorization')
return HttpResponse(status=401)
def test_get_content_ratings_since(self):
cr = ContentRating.objects.create(addon=self.app, ratings_body=0,
rating=0)
cr.update(modified=self.days_ago(100))
res = self.client.get(urlparams(
reverse('content-ratings-list', args=[self.app.app_slug]),
since=self.days_ago(5)))
eq_(res.status_code, 404)
cr.update(modified=self.days_ago(1))
res = self.client.get(urlparams(
reverse('content-ratings-list', args=[self.app.id]),
since=self.days_ago(5)))
eq_(res.status_code, 200)
eq_(len(json.loads(res.content)['objects']), 1)
def _mini_manifest(addon, version_id, token=None):
if not addon.is_packaged:
raise http.Http404
version = get_object_or_404(addon.versions, pk=version_id)
file_ = version.all_files[0]
manifest = addon.get_manifest_json(file_)
package_path = absolutify(
reverse('reviewers.signed', args=[addon.app_slug, version.id]))
if token:
# Generate a fresh token.
token = Token(data={'app_id': addon.id})
token.save()
package_path = urlparams(package_path, token=token.token)
data = {
'name': manifest['name'],
'version': version.version,
'size': file_.size,
'release_notes': version.releasenotes,
'package_path': package_path,
}
for key in ['developer', 'icons', 'locales']:
if key in manifest:
data[key] = manifest[key]
return json.dumps(data, cls=JSONEncoder)
def test_logout(self):
data = self._test_login()
r = self.client.delete(
urlparams(self.logout_url, _user=data['token']),
content_type='application/json')
eq_(r.status_code, 204)
def redirect(request, viewer, key):
new = Token(data=[viewer.file.id, key])
new.save()
url = urljoin(settings.STATIC_URL,
reverse('mkt.files.serve', args=[viewer, key]))
url = urlparams(url, token=new.token)
return http.HttpResponseRedirect(url)
def url(viewname, *args, **kwargs):
"""Helper for Django's ``reverse`` in templates."""
host = kwargs.pop('host', '')
src = kwargs.pop('src', '')
url = '%s%s' % (host, reverse(viewname, args=args, kwargs=kwargs))
if src:
url = urlparams(url, src=src)
return url
def test_logout(self):
UserProfile.objects.create(email='*****@*****.**')
data = self._test_login()
r = self.client.delete(
urlparams(self.logout_url, _user=data['token']),
content_type='application/json')
eq_(r.status_code, 204)
def get_absolute_url(url, api_name='apps', absolute=True):
# Gets an absolute url, except where you don't want that.
url[1]['api_name'] = api_name
res = reverse(url[0], kwargs=url[1])
if absolute:
res = urlparse.urljoin(settings.SITE_URL, res)
if len(url) > 2:
res = urlparams(res, **url[2])
return res
def test_list_translation(self):
res = self.anon.get(urlparams(reverse('regions-list'), lang='fr'))
eq_(res.status_code, 200)
data = json.loads(res.content)
for row in data['objects']:
region = mkt.regions.REGIONS_DICT.get(row['slug'])
eq_(row['name'], region.name)
eq_(row['slug'], region.slug)
eq_(row['id'], region.id)
eq_(len(data['objects']), len(mkt.regions.REGIONS_DICT))
eq_(data['meta']['total_count'], len(mkt.regions.REGIONS_DICT))
eq_(data['objects'][0]['name'], 'Afrique du Sud')
def media(context, url, key='MEDIA_URL'):
"""Get a MEDIA_URL link with a cache buster querystring."""
if 'BUILD_ID' in context:
build = context['BUILD_ID']
else:
if url.endswith('.js'):
build = context['BUILD_ID_JS']
elif url.endswith('.css'):
build = context['BUILD_ID_CSS']
else:
build = context['BUILD_ID_IMG']
return urljoin(context[key], urlparams(url, b=build))
def test_list(self):
res = self.anon.get(urlparams(reverse('regions-list')))
eq_(res.status_code, 200)
data = json.loads(res.content)
for row in data['objects']:
region = mkt.regions.REGIONS_DICT.get(row['slug'])
eq_(row['name'], region.name)
eq_(row['slug'], region.slug)
eq_(row['id'], region.id)
eq_(row['default_currency'], region.default_currency)
eq_(len(data['objects']), len(mkt.regions.REGIONS_DICT))
eq_(data['meta']['total_count'], len(mkt.regions.REGIONS_DICT))
def patch(self, request, *args, **kwargs):
form = FailureForm(request.DATA)
if not form.is_valid():
return Response(form.errors, status=status.HTTP_400_BAD_REQUEST)
obj = self.get_object()
data = {
'transaction_id': obj,
'transaction_url': absolutify(
urlparams(reverse('mkt.developers.transactions'),
transaction_id=obj.uuid)),
'url': form.cleaned_data['url'],
'retries': form.cleaned_data['attempts']}
owners = obj.addon.authors.values_list('email', flat=True)
send_mail_jinja('Payment notification failure.',
'webpay/failure.txt',
data, recipient_list=owners)
return Response(status=status.HTTP_202_ACCEPTED)
def product_as_dict(request, product, purchased=None, receipt_type=None,
src=''):
receipt_url = (reverse('receipt.issue', args=[product.app_slug]) if
receipt_type else product.get_detail_url('record'))
token_url = reverse('generate-reviewer-token', args=[product.app_slug])
src = src or request.GET.get('src', '')
reviewer = receipt_type == 'reviewer'
# This is the only info. we need to render the app buttons on the
# Reviewer Tools pages.
ret = {
'id': product.id,
'name': product.name,
'categories': product.categories,
'manifest_url': product.get_manifest_url(reviewer),
'recordUrl': urlparams(receipt_url, src=src),
'tokenUrl': token_url,
'is_packaged': product.is_packaged,
'src': src
}
if product.premium:
ret.update({
'price': product.get_price(region=request.REGION.id),
'priceLocale': product.get_price_locale(region=request.REGION.id),
})
if request.user.is_authenticated():
ret['isPurchased'] = purchased
# Jinja2 escape everything except this list so that bool is retained
# for the JSON encoding.
wl = ('categories', 'currencies', 'isPurchased', 'is_packaged', 'previews',
'price', 'priceLocale')
return dict([k, jinja2.escape(v) if k not in wl else v]
for k, v in ret.items())
def manifest(request):
ctx = RequestContext(request)
data = {
'name': getattr(settings, 'WEBAPP_MANIFEST_NAME',
'Firefox Marketplace'),
'description': 'The Firefox Marketplace',
'developer': {
'name': 'Mozilla',
'url': 'http://mozilla.org',
},
'icons': {
# Using the default addon image until we get a marketplace logo.
'128': media(ctx, 'img/mkt/logos/128.png'),
'64': media(ctx, 'img/mkt/logos/64.png'),
'32': media(ctx, 'img/mkt/logos/32.png'),
},
'activities': {
'marketplace-app': {'href': '/'},
'marketplace-app-rating': {'href': '/'},
'marketplace-category': {'href': '/'},
'marketplace-search': {'href': '/'},
}
}
if get_carrier():
data['launch_path'] = urlparams('/', carrier=get_carrier())
manifest_content = json.dumps(data)
manifest_etag = hashlib.sha256(manifest_content).hexdigest()
@etag(lambda r: manifest_etag)
def _inner_view(request):
response = HttpResponse(
manifest_content,
content_type='application/x-web-app-manifest+json')
return response
return _inner_view(request)
def get_refund_url(self):
return urlparams(self.addon.get_dev_url('issue_refund'),
transaction_id=self.transaction_id)
def get_url_path(self, src):
url = os.path.join(reverse('downloads.file', args=[self.id]),
self.filename)
# Firefox's Add-on Manager needs absolute urls.
return absolutify(urlparams(url, src=src))
def test_urlparams_unicode():
url = u'/xx?evil=reco\ufffd\ufffd\ufffd\u02f5'
urlparams(url)
