def test_installed_pagination(self):
ins1 = Installed.objects.create(user=self.user, addon=app_factory())
ins1.update(created=self.days_ago(1))
ins2 = Installed.objects.create(user=self.user, addon=app_factory())
ins2.update(created=self.days_ago(2))
ins3 = Installed.objects.create(user=self.user, addon=app_factory())
ins3.update(created=self.days_ago(3))
res = self.client.get(self.list_url, {'limit': 2})
eq_(res.status_code, 200)
data = json.loads(res.content)
eq_(len(data['objects']), 2)
eq_(data['objects'][0]['id'], ins1.addon.id)
eq_(data['objects'][1]['id'], ins2.addon.id)
eq_(data['meta']['total_count'], 3)
eq_(data['meta']['limit'], 2)
eq_(data['meta']['previous'], None)
eq_(data['meta']['offset'], 0)
next = urlparse(data['meta']['next'])
eq_(next.path, self.list_url)
eq_(QueryDict(next.query).dict(), {u'limit': u'2', u'offset': u'2'})
res = self.client.get(self.list_url, {'limit': 2, 'offset': 2})
eq_(res.status_code, 200)
data = json.loads(res.content)
eq_(len(data['objects']), 1)
eq_(data['objects'][0]['id'], ins3.addon.id)
eq_(data['meta']['total_count'], 3)
eq_(data['meta']['limit'], 2)
prev = urlparse(data['meta']['previous'])
eq_(next.path, self.list_url)
eq_(QueryDict(prev.query).dict(), {u'limit': u'2', u'offset': u'0'})
eq_(data['meta']['offset'], 2)
eq_(data['meta']['next'], None)
def test_installed_pagination(self):
ins1 = Installed.objects.create(user=self.user, addon=app_factory())
ins1.update(created=self.days_ago(1))
ins2 = Installed.objects.create(user=self.user, addon=app_factory())
ins2.update(created=self.days_ago(2))
ins3 = Installed.objects.create(user=self.user, addon=app_factory())
ins3.update(created=self.days_ago(3))
res = self.client.get(self.list_url, {"limit": 2})
eq_(res.status_code, 200)
data = json.loads(res.content)
eq_(len(data["objects"]), 2)
eq_(data["objects"][0]["id"], ins1.addon.id)
eq_(data["objects"][1]["id"], ins2.addon.id)
eq_(data["meta"]["total_count"], 3)
eq_(data["meta"]["limit"], 2)
eq_(data["meta"]["previous"], None)
eq_(data["meta"]["offset"], 0)
next = urlparse(data["meta"]["next"])
eq_(next.path, self.list_url)
eq_(QueryDict(next.query).dict(), {u"limit": u"2", u"offset": u"2"})
res = self.client.get(self.list_url, {"limit": 2, "offset": 2})
eq_(res.status_code, 200)
data = json.loads(res.content)
eq_(len(data["objects"]), 1)
eq_(data["objects"][0]["id"], ins3.addon.id)
eq_(data["meta"]["total_count"], 3)
eq_(data["meta"]["limit"], 2)
prev = urlparse(data["meta"]["previous"])
eq_(next.path, self.list_url)
eq_(QueryDict(prev.query).dict(), {u"limit": u"2", u"offset": u"0"})
eq_(data["meta"]["offset"], 2)
eq_(data["meta"]["next"], None)
def test_installed_pagination(self):
ins1 = Installed.objects.create(user=self.user, addon=app_factory())
ins1.update(created=self.days_ago(1))
ins2 = Installed.objects.create(user=self.user, addon=app_factory())
ins2.update(created=self.days_ago(2))
ins3 = Installed.objects.create(user=self.user, addon=app_factory())
ins3.update(created=self.days_ago(3))
res = self.client.get(self.list_url, {'limit': 2})
eq_(res.status_code, 200)
data = json.loads(res.content)
eq_(len(data['objects']), 2)
eq_(data['objects'][0]['id'], ins1.addon.id)
eq_(data['objects'][1]['id'], ins2.addon.id)
eq_(data['meta']['total_count'], 3)
eq_(data['meta']['limit'], 2)
eq_(data['meta']['previous'], None)
eq_(data['meta']['offset'], 0)
next = urlparse(data['meta']['next'])
eq_(next.path, self.list_url)
eq_(QueryDict(next.query).dict(), {u'limit': u'2', u'offset': u'2'})
res = self.client.get(self.list_url, {'limit': 2, 'offset': 2})
eq_(res.status_code, 200)
data = json.loads(res.content)
eq_(len(data['objects']), 1)
eq_(data['objects'][0]['id'], ins3.addon.id)
eq_(data['meta']['total_count'], 3)
eq_(data['meta']['limit'], 2)
prev = urlparse(data['meta']['previous'])
eq_(next.path, self.list_url)
eq_(QueryDict(prev.query).dict(), {u'limit': u'2', u'offset': u'0'})
eq_(data['meta']['offset'], 2)
eq_(data['meta']['next'], None)
def setUp(self):
# Add a public, reviewed app for measure. It took 4 days for this app
# to get reviewed.
self.public_app = app_factory(
version_kw={
'created': self.days_ago(7),
'nomination': self.days_ago(7),
'reviewed': self.days_ago(3)
})
# Took 8 days for another public app to get reviewed.
app_factory(version_kw={
'nomination': self.days_ago(10),
'reviewed': self.days_ago(2)
})
# Add to the queue 2 pending apps for good measure.
app_factory(status=mkt.STATUS_PENDING,
file_kw={'status': mkt.STATUS_PENDING},
version_kw={'nomination': self.days_ago(3)})
app_factory(status=mkt.STATUS_PENDING,
file_kw={'status': mkt.STATUS_PENDING},
version_kw={'nomination': self.days_ago(1)})
# A deleted app that shouldn't change calculations.
app_factory(status=mkt.STATUS_DELETED,
file_kw={'status': mkt.STATUS_PENDING},
version_kw={'nomination': self.days_ago(1)})
def setUp(self):
# Add a public, reviewed app for measure. It took 4 days for this app
# to get reviewed.
self.public_app = app_factory(
version_kw={'created': self.days_ago(7),
'nomination': self.days_ago(7),
'reviewed': self.days_ago(3)})
# Took 8 days for another public app to get reviewed.
app_factory(
version_kw={'nomination': self.days_ago(10),
'reviewed': self.days_ago(2)})
# Add to the queue 2 pending apps for good measure.
app_factory(
status=mkt.STATUS_PENDING,
file_kw={'status': mkt.STATUS_PENDING},
version_kw={'nomination': self.days_ago(3)})
app_factory(
status=mkt.STATUS_PENDING,
file_kw={'status': mkt.STATUS_PENDING},
version_kw={'nomination': self.days_ago(1)})
# A deleted app that shouldn't change calculations.
app_factory(
status=mkt.STATUS_DELETED,
file_kw={'status': mkt.STATUS_PENDING},
version_kw={'nomination': self.days_ago(1)})
def test_removed(self):
# At least one public app must exist for dump_apps to run.
app_factory(name='second app', status=mkt.STATUS_PUBLIC)
app_path = os.path.join(self.export_directory, self.app_path)
app = Webapp.objects.get(pk=337141)
app.update(status=mkt.STATUS_PUBLIC)
self.create_export('tarball-name')
assert private_storage.exists(app_path)
app.update(status=mkt.STATUS_PENDING)
self.create_export('tarball-name')
assert not private_storage.exists(app_path)
def test_removed(self):
# At least one public app must exist for dump_apps to run.
app_factory(name='second app', status=mkt.STATUS_PUBLIC)
app_path = os.path.join(self.export_directory, self.app_path)
app = Webapp.objects.get(pk=337141)
app.update(status=mkt.STATUS_PUBLIC)
self.create_export('tarball-name')
assert private_storage.exists(app_path)
app.update(status=mkt.STATUS_PENDING)
self.create_export('tarball-name')
assert not private_storage.exists(app_path)
def test_all_results(self):
for x in range(4):
app_factory(name='chr' + str(x))
self.refresh('webapp')
# Test search limit.
data = self.search(q='chr')
eq_(len(data['objects']), 2)
# Test maximum search result.
data = self.search(q='chr', limit='max')
eq_(len(data['objects']), 3)
def test_installed_order(self):
# Should be reverse chronological order.
ins1 = Installed.objects.create(user=self.user, addon=app_factory())
ins1.update(created=self.days_ago(1))
ins2 = Installed.objects.create(user=self.user, addon=app_factory())
ins2.update(created=self.days_ago(2))
res = self.client.get(self.list_url)
eq_(res.status_code, 200)
data = json.loads(res.content)
eq_(len(data['objects']), 2)
eq_(data['objects'][0]['id'], ins1.addon.id)
eq_(data['objects'][1]['id'], ins2.addon.id)
def test_removed(self):
# At least one public app must exist for dump_apps to run.
app_factory(name="second app", status=mkt.STATUS_PUBLIC)
app_path = os.path.join(settings.DUMPED_APPS_PATH, "apps", "337", "337141.json")
app = Webapp.objects.get(pk=337141)
app.update(status=mkt.STATUS_PUBLIC)
call_command("process_addons", task="dump_apps")
assert os.path.exists(app_path)
app.update(status=mkt.STATUS_PENDING)
call_command("process_addons", task="dump_apps")
assert not os.path.exists(app_path)
def test_installed_order(self):
# Should be reverse chronological order.
ins1 = Installed.objects.create(user=self.user, addon=app_factory())
ins1.update(created=self.days_ago(1))
ins2 = Installed.objects.create(user=self.user, addon=app_factory())
ins2.update(created=self.days_ago(2))
res = self.client.get(self.list_url)
eq_(res.status_code, 200)
data = json.loads(res.content)
eq_(len(data['objects']), 2)
eq_(data['objects'][0]['id'], ins1.addon.id)
eq_(data['objects'][1]['id'], ins2.addon.id)
def test_relevant_apps(self, purchase_ids):
profile = UserProfile.objects.create(email="*****@*****.**", fxa_uid="fake-uid")
purchased_app = app_factory()
purchase_ids.return_value = [purchased_app.pk]
developed_app = app_factory()
developed_app.addonuser_set.create(user=profile)
installed_app = app_factory()
installed_app.installed.create(user=profile)
data = self._test_login()
eq_(data["apps"]["installed"], [installed_app.pk])
eq_(data["apps"]["purchased"], [purchased_app.pk])
eq_(data["apps"]["developed"], [developed_app.pk])
def test_relevant_apps(self, purchase_ids):
profile = UserProfile.objects.create(email='*****@*****.**')
purchased_app = app_factory()
purchase_ids.return_value = [purchased_app.pk]
developed_app = app_factory()
developed_app.addonuser_set.create(user=profile)
installed_app = app_factory()
installed_app.installed.create(user=profile)
data = self._test_login()
eq_(data['apps']['installed'], [installed_app.pk])
eq_(data['apps']['purchased'], [purchased_app.pk])
eq_(data['apps']['developed'], [developed_app.pk])
def test_relevant_apps(self, purchase_ids):
profile = UserProfile.objects.create(email='*****@*****.**')
purchased_app = app_factory()
purchase_ids.return_value = [purchased_app.pk]
developed_app = app_factory()
developed_app.addonuser_set.create(user=profile)
installed_app = app_factory()
installed_app.installed.create(user=profile)
data = self._test_login()
eq_(data['apps']['installed'], [installed_app.pk])
eq_(data['apps']['purchased'], [purchased_app.pk])
eq_(data['apps']['developed'], [developed_app.pk])
def setUp(self):
(app_factory(), app_factory())
# Need queryset to initialize form.
self.apps = Webapp.objects.all()
self.data = {
'app': self.apps[0].id,
'transaction_type': 1,
'transaction_id': 1,
'date_from_day': '1',
'date_from_month': '1',
'date_from_year': '2012',
'date_to_day': '1',
'date_to_month': '1',
'date_to_year': '2013',
}
def setUp(self):
(app_factory(), app_factory())
# Need queryset to initialize form.
self.apps = Webapp.objects.all()
self.data = {
'app': self.apps[0].id,
'transaction_type': 1,
'transaction_id': 1,
'date_from_day': '1',
'date_from_month': '1',
'date_from_year': '2012',
'date_to_day': '1',
'date_to_month': '1',
'date_to_year': '2013',
}
def setUp(self):
self.app = app_factory()
self.app_url = get_url('app', self.app.pk)
self.version = self.app.current_version
self.file = self.version.all_files[0]
self.request = RequestFactory()
super(TestVersionStatusViewSet, self).setUp()
def test_parse_as_slugs_many(self):
app2 = app_factory(app_slug='foo')
field = SlugOrPrimaryKeyRelatedField(queryset=Webapp.objects.all(),
slug_field='app_slug',
many=True)
eq_(field.to_internal_value([self.app.app_slug, app2.app_slug]),
[self.app, app2])
def test_installed_remove_app_not_user_installed(self):
Installed.objects.create(user=self.user, addon_id=337141)
app = app_factory()
Installed.objects.create(user=self.user, addon=app, install_type=INSTALL_TYPE_REVIEWER)
data = {"app": app.pk}
res = self.client.post(self.remove_app_url, json.dumps(data))
eq_(res.status_code, 400)
def generate_hosted_app(name, categories, developer_name,
privacy_policy=None, device_types=(), status=4,
rated=True, uses_flash=False, default_locale='en-US',
**spec):
generated_url = 'http://%s.testmanifest.com/fake-data/manifest.webapp' % (
slugify(name),)
a = app_factory(categories=categories, name=name, complete=False,
privacy_policy=spec.get('privacy_policy'),
file_kw={'status': status, 'uses_flash': uses_flash},
default_locale=default_locale, rated=rated,
manifest_url=spec.get('manifest_url', generated_url))
if device_types:
for dt in device_types:
a.webappdevicetype_set.create(device_type=DEVICE_CHOICES_IDS[dt])
else:
a.webappdevicetype_set.create(device_type=1)
a.versions.latest().update(reviewed=datetime.datetime.now(),
_developer_name=developer_name)
if 'manifest_file' in spec:
AppManifest.objects.create(
version=a._latest_version,
manifest=open(spec['manifest_file']).read())
else:
generate_hosted_manifest(a)
return a
def test_update_existing_product(self):
account = self.make_account()
app = app_factory()
generic_product_uri = '/generic/product/1/'
self.generic_patcher.product.get_object_or_404.return_value = {
'resource_pk': 1,
'resource_uri': generic_product_uri,
}
existing_boku_product_uri = '/boku/product/1/'
self.boku_patcher.product.get_object_or_404.return_value = {
'resource_uri': existing_boku_product_uri
}
patch_mock = Mock()
patch_mock.patch.return_value = {
'resource_uri': existing_boku_product_uri,
'seller_product': generic_product_uri,
'seller_boku': account.uri,
}
self.boku_patcher.by_url.return_value = patch_mock
product = self.boku.product_create(account, app)
eq_(product, existing_boku_product_uri)
self.boku_patcher.by_url.assert_called_with(existing_boku_product_uri)
patch_mock.patch.assert_called_with(data={
'seller_boku': account.uri,
'seller_product': generic_product_uri,
})
def test_min(self):
pending_app = app_factory(
status=mkt.STATUS_PENDING,
file_kw={'status': mkt.STATUS_PENDING},
version_kw={'nomination': self.days_ago(42)})
pos = helpers.get_position(pending_app)
eq_(pos['days'], 1)
def test_rereview_flag_adult(self):
mkt.set_user(user_factory())
app = app_factory()
app.set_content_ratings({
mkt.ratingsbodies.ESRB: mkt.ratingsbodies.ESRB_E,
mkt.ratingsbodies.CLASSIND: mkt.ratingsbodies.CLASSIND_18,
})
_flag_rereview_adult(app, mkt.ratingsbodies.ESRB,
mkt.ratingsbodies.ESRB_T)
assert not app.rereviewqueue_set.count()
assert not ActivityLog.objects.filter(
action=mkt.LOG.CONTENT_RATING_TO_ADULT.id).exists()
# Adult should get flagged to rereview.
_flag_rereview_adult(app, mkt.ratingsbodies.ESRB,
mkt.ratingsbodies.ESRB_A)
eq_(app.rereviewqueue_set.count(), 1)
eq_(ActivityLog.objects.filter(
action=mkt.LOG.CONTENT_RATING_TO_ADULT.id).count(), 1)
# Test things same same if rating stays the same as adult.
app.set_content_ratings({
mkt.ratingsbodies.ESRB: mkt.ratingsbodies.ESRB_A,
})
_flag_rereview_adult(app, mkt.ratingsbodies.ESRB,
mkt.ratingsbodies.ESRB_A)
eq_(app.rereviewqueue_set.count(), 1)
eq_(ActivityLog.objects.filter(
action=mkt.LOG.CONTENT_RATING_TO_ADULT.id).count(), 1)
def generate_hosted_app(name, categories, developer_name,
privacy_policy=None, device_types=(), status=4,
rated=True, uses_flash=False, default_locale='en-US',
**spec):
generated_url = 'http://%s.testmanifest.com/fake-data/manifest.webapp' % (
slugify(name),)
a = app_factory(categories=categories, name=name, complete=False,
privacy_policy=spec.get('privacy_policy'),
file_kw={'status': status, 'uses_flash': uses_flash},
default_locale=default_locale, rated=rated,
manifest_url=spec.get('manifest_url', generated_url))
if device_types:
for dt in device_types:
a.addondevicetype_set.create(device_type=DEVICE_CHOICES_IDS[dt])
else:
a.addondevicetype_set.create(device_type=1)
a.versions.latest().update(reviewed=datetime.datetime.now(),
_developer_name=developer_name)
if 'manifest_file' in spec:
AppManifest.objects.create(
version=a._latest_version,
manifest=open(spec['manifest_file']).read())
else:
generate_hosted_manifest(a)
return a
def test_filter_by_app_pk(self):
self.app2 = app_factory()
Review.objects.create(addon=self.app2, user=self.user, body="no")
Review.objects.create(addon=self.app, user=self.user, body="yes")
res, data = self._get_filter(app=self.app.pk)
eq_(data["info"]["slug"], self.app.app_slug)
eq_(data["info"]["current_version"], self.app.current_version.version)
def test_save_success(self):
"""Like test_save_success_mocked() above, but more of an integration
test with no mocks, to make sure the whole process works."""
# Start by making an "almost" complete app, that has everything set up
# except ratings.
app = app_factory(categories=['games'],
status=STATUS_NULL,
support_email='*****@*****.**')
app.addondevicetype_set.create(device_type=DEVICE_GAIA.id)
app.previews.create()
eq_(app.is_fully_complete(ignore_ratings=True), True)
# Then validate and save normally.
serializer = self.test_validate_multiple_bodies_with_redundant_info()
serializer.object = app
serializer.save()
# Now check that everything went ok.
app.reload()
eq_(app.status, STATUS_PENDING)
eq_(app.is_fully_complete(), True)
eq_(UUID(app.iarc_cert.cert_id), serializer.validated_data['cert_id'])
eq_(app.get_content_ratings_by_body(), {
'generic': '12',
'esrb': '13',
'pegi': '12'
})
self.assertSetEqual(
app.rating_descriptors.to_keys(),
['has_pegi_violence', 'has_generic_violence', 'has_pegi_online'])
self.assertSetEqual(app.rating_interactives.to_keys(), [
'has_shares_location', 'has_digital_purchases',
'has_users_interact'
])
def setUp(self):
self.app = app_factory(status=mkt.STATUS_PENDING)
self.version = self.app.latest_version
self.thread = CommunicationThread.objects.create(
_addon=self.app, _version=self.version)
self.user = user_factory()
self.app.addonuser_set.create(user=self.user)
def generate_hosted_app(
name,
categories,
developer_name,
privacy_policy=None,
device_types=(),
status=4,
rated=True,
default_locale="en-US",
**spec
):
generated_url = "http://%s.testmanifest.com/fake-data/manifest.webapp" % (slugify(name),)
a = app_factory(
categories=categories,
name=name,
complete=False,
privacy_policy=spec.get("privacy_policy"),
file_kw={"status": status},
default_locale=default_locale,
rated=rated,
manifest_url=spec.get("manifest_url", generated_url),
)
if device_types:
for dt in device_types:
a.addondevicetype_set.create(device_type=DEVICE_CHOICES_IDS[dt])
else:
a.addondevicetype_set.create(device_type=1)
a.versions.latest().update(reviewed=datetime.datetime.now(), _developer_name=developer_name)
if "manifest_file" in spec:
AppManifest.objects.create(version=a._latest_version, manifest=open(spec["manifest_file"]).read())
else:
generate_hosted_manifest(a)
return a
def test_filter_by_app_pk(self):
self.app2 = app_factory()
Review.objects.create(addon=self.app2, user=self.user, body='no')
Review.objects.create(addon=self.app, user=self.user, body='yes')
res, data = self._get_filter(app=self.app.pk)
eq_(data['info']['slug'], self.app.app_slug)
eq_(data['info']['current_version'], self.app.current_version.version)
def test_rereview_flag_adult(self):
mkt.set_user(user_factory())
app = app_factory()
app.set_content_ratings({
mkt.ratingsbodies.ESRB:
mkt.ratingsbodies.ESRB_E,
mkt.ratingsbodies.CLASSIND:
mkt.ratingsbodies.CLASSIND_18,
})
_flag_rereview_adult(app, mkt.ratingsbodies.ESRB,
mkt.ratingsbodies.ESRB_T)
assert not app.rereviewqueue_set.count()
assert not ActivityLog.objects.filter(
action=mkt.LOG.CONTENT_RATING_TO_ADULT.id).exists()
# Adult should get flagged to rereview.
_flag_rereview_adult(app, mkt.ratingsbodies.ESRB,
mkt.ratingsbodies.ESRB_A)
eq_(app.rereviewqueue_set.count(), 1)
eq_(
ActivityLog.objects.filter(
action=mkt.LOG.CONTENT_RATING_TO_ADULT.id).count(), 1)
# Test things same same if rating stays the same as adult.
app.set_content_ratings({
mkt.ratingsbodies.ESRB:
mkt.ratingsbodies.ESRB_A,
})
_flag_rereview_adult(app, mkt.ratingsbodies.ESRB,
mkt.ratingsbodies.ESRB_A)
eq_(app.rereviewqueue_set.count(), 1)
eq_(
ActivityLog.objects.filter(
action=mkt.LOG.CONTENT_RATING_TO_ADULT.id).count(), 1)
def test_create_new_product(self):
account = self.make_account()
app = app_factory()
generic_product_uri = '/generic/product/1/'
boku_product_uri = '/boku/product/1/'
self.generic_patcher.product.get_object_or_404.return_value = {
'resource_pk': 1,
'resource_uri': generic_product_uri,
}
self.boku_patcher.product.get_object_or_404.side_effect = (
ObjectDoesNotExist)
self.boku_patcher.product.post.return_value = {
'resource_uri': boku_product_uri,
'seller_product': generic_product_uri,
'seller_boku': account.uri,
}
product = self.boku.product_create(account, app)
eq_(product, boku_product_uri)
self.boku_patcher.product.post.assert_called_with(data={
'seller_boku': account.uri,
'seller_product': generic_product_uri,
})
def test_get(self, client=None):
first_version = self.app.current_version
rev = Review.objects.create(
addon=self.app, user=self.user, version=first_version, body=u"I lôve this app", rating=5
)
rev.update(created=self.days_ago(2))
rev2 = Review.objects.create(
addon=self.app, user=self.user2, version=first_version, body=u"I also lôve this app", rating=4
)
# Extra review for another app, should be ignored.
extra_app = app_factory()
Review.objects.create(
addon=extra_app, user=self.user, version=extra_app.current_version, body=u"I häte this extra app", rating=1
)
self.app.total_reviews = 2
ver = version_factory(addon=self.app, version="2.0", file_kw=dict(status=mkt.STATUS_PUBLIC))
self.app.update_version()
reset_queries()
res, data = self._get_url(self.list_url, app=self.app.pk, client=client)
eq_(len(data["objects"]), 2)
self._compare_review_data(client, data["objects"][0], rev2)
self._compare_review_data(client, data["objects"][1], rev)
eq_(data["info"]["average"], self.app.average_rating)
eq_(data["info"]["slug"], self.app.app_slug)
eq_(data["info"]["current_version"], ver.version)
if client != self.anon:
eq_(data["user"]["can_rate"], True)
eq_(data["user"]["has_rated"], True)
return res
def test_save_success(self):
"""Like test_save_success_mocked() above, but more of an integration
test with no mocks, to make sure the whole process works."""
# Start by making an "almost" complete app, that has everything set up
# except ratings.
app = app_factory(categories=['games'], status=STATUS_NULL,
support_email='*****@*****.**')
app.addondevicetype_set.create(device_type=DEVICE_GAIA.id)
app.previews.create()
eq_(app.is_fully_complete(ignore_ratings=True), True)
# Then validate and save normally.
serializer = self.test_validate_multiple_bodies_with_redundant_info()
serializer.object = app
serializer.save()
# Now check that everything went ok.
app.reload()
eq_(app.status, STATUS_PENDING)
eq_(app.is_fully_complete(), True)
eq_(UUID(app.iarc_cert.cert_id), serializer.validated_data['cert_id'])
eq_(app.get_content_ratings_by_body(),
{'generic': '12', 'esrb': '13', 'pegi': '12'})
self.assertSetEqual(
app.rating_descriptors.to_keys(),
['has_pegi_violence', 'has_generic_violence', 'has_pegi_online'])
self.assertSetEqual(
app.rating_interactives.to_keys(),
['has_shares_location', 'has_digital_purchases',
'has_users_interact'])
def setUp(self):
self.app = app_factory()
self.app_url = get_url('app', self.app.pk)
self.version = self.app.current_version
self.file = self.version.all_files[0]
self.request = RequestFactory()
super(TestVersionStatusViewSet, self).setUp()
def setUp(self):
self.app = app_factory(status=mkt.STATUS_PUBLIC, is_packaged=True)
self.ver1 = self.app.current_version
self.ver1.update(created=self.days_ago(1))
self.ver2 = version_factory(addon=self.app, version='2.0',
file_kw=dict(status=mkt.STATUS_APPROVED))
self.app.update(_latest_version=self.ver2)
self.form = forms.PublishForm
def setUp(self):
self.request = mock.Mock()
self.app = app_factory(publish_type=mkt.PUBLISH_IMMEDIATE,
version_kw={'version': '1.0',
'created': self.days_ago(5)})
version_factory(addon=self.app, version='2.0',
file_kw=dict(status=mkt.STATUS_PENDING))
self.app.reload()
def setUp(self):
self.request = mock.Mock()
self.app = app_factory(publish_type=mkt.PUBLISH_IMMEDIATE,
version_kw={'version': '1.0',
'created': self.days_ago(5)})
version_factory(addon=self.app, version='2.0',
file_kw=dict(status=mkt.STATUS_PENDING))
self.app.reload()
def test_new_category(self):
app_id = 424184
# `complete=True` adds the 'utilities' category.
app = app_factory(id=app_id, name='second', status=mkt.STATUS_PUBLIC,
complete=True)
adjust_categories([app_id])
self.assertSetEqual(app.reload().categories,
['food-drink', 'health-fitness'])
def setUp(self):
self.app = app_factory(status=mkt.STATUS_PUBLIC, is_packaged=True)
self.ver1 = self.app.current_version
self.ver1.update(created=self.days_ago(1))
self.ver2 = version_factory(addon=self.app, version='2.0',
file_kw=dict(status=mkt.STATUS_APPROVED))
self.app.update(_latest_version=self.ver2)
self.form = forms.PublishForm
def test_ordering(self):
self.user.installed_set.create(addon=self.app,
install_type=apps.INSTALL_TYPE_USER)
app2 = app_factory()
self.user.installed_set.create(addon=app2,
install_type=apps.INSTALL_TYPE_USER)
eq_(list(purchase_list(self.req, self.user).object_list),
[app2, self.app])
def setUp(self):
super(TestAcctSummary, self).setUp()
self.user = UserProfile.objects.get(email='*****@*****.**')
self.steamcube = Webapp.objects.get(pk=337141)
self.otherapp = app_factory(app_slug='otherapp')
self.reg_user = UserProfile.objects.get(email='*****@*****.**')
self.summary_url = reverse('lookup.user_summary', args=[self.user.pk])
self.login(UserProfile.objects.get(email='*****@*****.**'))
def test_patch_new_not_allowed(self):
# Trying to patch to a new object you do not have access to.
self.create_upsell()
self.create_allowed()
another = app_factory(premium_type=mkt.ADDON_PREMIUM)
res = self.client.patch(self.upsell_url, data=json.dumps(
{'free': self.free_url, 'premium': self.url(another)}))
eq_(res.status_code, 403)
def test_cdn_icon(self, save, fetch, json):
response = mock.Mock()
response.read.return_value = ''
webapp = app_factory()
url = 'http://foo.com/bar'
json.return_value = {'icons': {'128': url}}
tasks.fetch_icon(webapp.pk, webapp.latest_version.all_files[0].pk)
assert url in fetch.call_args[0][0]
def test_parse_as_pks_many(self):
app2 = app_factory()
into = {}
field = SlugOrPrimaryKeyRelatedField(queryset=Webapp.objects.all(),
many=True)
field.field_from_native({'apps': [self.app.pk, app2.pk]}, None, 'apps',
into)
eq_(into, {'apps': [self.app, app2]})
def test_patch(self):
self.create_upsell()
self.create_allowed()
another = app_factory(premium_type=mkt.ADDON_PREMIUM)
AddonUser.objects.create(addon=another, user=self.profile)
res = self.client.patch(self.upsell_url, data=json.dumps(
{'free': self.free_url, 'premium': self.url(another)}))
eq_(res.status_code, 200)
def test_installed_remove_app_not_user_installed(self):
Installed.objects.create(user=self.user, addon_id=337141)
app = app_factory()
Installed.objects.create(user=self.user, addon=app,
install_type=INSTALL_TYPE_REVIEWER)
data = {'app': app.pk}
res = self.client.post(self.remove_app_url, json.dumps(data))
eq_(res.status_code, 400)
def test_patch(self):
self.create_upsell()
self.create_allowed()
another = app_factory(premium_type=mkt.ADDON_PREMIUM)
AddonUser.objects.create(addon=another, user=self.profile)
res = self.client.patch(self.upsell_url, data=json.dumps(
{'free': self.free_url, 'premium': self.url(another)}))
eq_(res.status_code, 200)
def setUp(self):
super(BaseAddVersionTest, self).setUp()
self.app = app_factory(complete=True, is_packaged=True,
app_domain='app://hy.fr',
version_kw=dict(version='1.0'))
self.url = self.app.get_dev_url('versions')
self.user = UserProfile.objects.get(email='*****@*****.**')
AddonUser.objects.create(user=self.user, addon=self.app)
def test_cdn_icon(self, save, fetch, json):
response = mock.Mock()
response.read.return_value = ''
webapp = app_factory()
url = 'http://foo.com/bar'
json.return_value = {'icons': {'128': url}}
tasks.fetch_icon(webapp.pk, webapp.latest_version.all_files[0].pk)
assert url in fetch.call_args[0][0]
def setUp(self):
super(BaseAddVersionTest, self).setUp()
self.app = app_factory(complete=True, is_packaged=True,
app_domain='app://hy.fr',
version_kw=dict(version='1.0'))
self.url = self.app.get_dev_url('versions')
self.user = UserProfile.objects.get(email='*****@*****.**')
AddonUser.objects.create(user=self.user, addon=self.app)
def test_filter_by_app_pk(self):
self.app2 = app_factory()
Review.objects.create(addon=self.app2, user=self.user, body='no',
rating=5)
Review.objects.create(addon=self.app, user=self.user, body='yes',
rating=5)
res, data = self._get_filter(app=self.app.pk)
eq_(data['info']['slug'], self.app.app_slug)
eq_(data['info']['current_version'], self.app.current_version.version)
def test_parse_as_slugs_many(self):
app2 = app_factory(app_slug='foo')
into = {}
field = SlugOrPrimaryKeyRelatedField(queryset=Webapp.objects.all(),
slug_field='app_slug',
many=True)
field.field_from_native({'apps': [self.app.app_slug, app2.app_slug]},
None, 'apps', into)
eq_(into, {'apps': [self.app, app2]})
def test_patch_old_not_allowed(self):
# Trying to patch an old object you do not have access to.
self.create_upsell()
AddonUser.objects.create(addon=self.free, user=self.profile)
# We did not give you access to patch away from self.premium.
another = app_factory(premium_type=mkt.ADDON_PREMIUM)
AddonUser.objects.create(addon=another, user=self.profile)
res = self.client.patch(self.upsell_url, data=json.dumps(
{'free': self.free_url, 'premium': self.url(another)}))
eq_(res.status_code, 403)
def test_no_author(self):
app = app_factory()
thread, note = create_comm_note(app, app.current_version, None, 'hue')
data = serializers.NoteSerializer(note,
context={
'request': req_factory_factory()
}).data
eq_(data['author_meta']['name'], 'Mozilla')
eq_(data['author_meta']['gravatar_hash'], '')
def test_dump_exludes_deleted(self):
"""We can't recommend deleted apps, so don't include them."""
app = app_factory()
app.installed.create(user=self.user)
app.delete()
data = self.dump_and_load()
eq_(len(data['installed_apps']), 1)
installed = data['installed_apps'][0]
eq_(installed['id'], self.app.id)
def setUp(self):
self.data = {
'slug': 'yolo',
'manifest_url': 'https://omg.org/yes.webapp',
'description': 'You Only Live Once'
}
self.user = mkt.site.tests.user_factory()
self.request = mkt.site.tests.req_factory_factory(user=self.user)
self.app = app_factory(name='YOLO',
manifest_url='https://omg.org/yes.webapp')
def test_save_success_already_had_cert(self):
app = app_factory()
cert = IARCCert.objects.create(app=app, modified=self.days_ago(42))
serializer = self.test_validate_multiple_bodies_with_redundant_info()
serializer.object = app
serializer.validated_data['cert_id'] = UUID(cert.cert_id)
serializer.save()
cert.reload()
self.assertCloseToNow(cert.modified)
eq_(IARCCert.objects.count(), 1)
def test_iarc_cert_already_used(self):
# Test okay to use on self.
self.app.set_iarc_info(1, 'a')
eq_(IARCInfo.objects.count(), 1)
some_app = app_factory()
form = self._get_form(app=some_app)
ok_(not form.is_valid())
form = self._get_form(app=some_app, submission_id=2)
ok_(form.is_valid())
