def render_email(template, context):
"""Renders a template in the currently set locale."""
req = RequestFactory()
req.META = {}
req.locale = translation.get_language()
return jingo.render_to_string(req, template, context)
def get_request(self, data=None):
if data is None:
data = {}
request = RequestFactory().get("/", data)
request.REGION = mkt.regions.RESTOFWORLD
request.API = True
return request
class TestAddSubmissionView(TestCase):
def __init__(self, *args, **kwargs):
super(TestAddSubmissionView, self).__init__(*args, **kwargs)
# Add context and template to the response
on_template_render = curry(store_rendered_templates, {})
signals.template_rendered.connect(on_template_render,
dispatch_uid="template-render")
def setUp(self):
self.factory = RequestFactory()
self.ideation = MagicMock()
def test_add_submission_get(self):
request = self.factory.get('/')
request.user = AnonymousUser()
request.development = development_mock
response = views.add_submission(request, self.ideation)
eq_(response.status_code, 200)
def test_invalid_form(self):
request = self.factory.post('/', BLANK_EXTERNALS)
request.user = AnonymousUser()
request.development = development_mock
response = views.add_submission(request, self.ideation)
eq_(response.status_code, 200)
def check_appver_filters(self, appver, expected):
request = RequestFactory()
request.APP = amo.FIREFOX
facets = {
u'platforms': [{
u'count': 58,
u'term': 1
}],
u'appversions': [{
u'count': 58,
u'term': 5000000200100
}],
u'categories': [{
u'count': 55,
u'term': 1
}],
u'tags': []
}
versions = version_sidebar(request, {'appver': floor_version(appver)},
facets)
all_ = versions.pop(0)
eq_(all_.text, 'Any %s' % unicode(request.APP.pretty))
eq_(all_.selected, not expected)
return [v.__dict__ for v in versions]
def dump_app(id, **kw):
# Because @robhudson told me to.
from mkt.api.resources import AppResource
# Note: not using storage because all these operations should be local.
target_dir = os.path.join(settings.DUMPED_APPS_PATH, 'apps',
str(id / 1000))
target_file = os.path.join(target_dir, str(id) + '.json')
try:
obj = Webapp.objects.get(pk=id)
except Webapp.DoesNotExist:
task_log.info(u'Webapp does not exist: {0}'.format(id))
return
req = RequestFactory().get('/')
req.user = AnonymousUser()
req.REGION = WORLDWIDE
if not os.path.exists(target_dir):
os.makedirs(target_dir)
task_log.info('Dumping app {0} to {1}'.format(id, target_file))
res = AppResource().dehydrate_objects([obj], request=req)
json.dump(res[0], open(target_file, 'w'), cls=JSONEncoder)
return target_file
def test_multiple_shared_works(self):
request = RequestFactory().post(
"/api",
HTTP_AUTHORIZATION="mkt-shared-secret "
"[email protected],56b6f1a3dd735d962c56"
"ce7d8f46e02ec1d4748d2c00c407d75f0969d08bb"
"9c68c31b3371aa8130317815c89e5072e31bb94b4"
"121c5c165f3515838d4d6c60c4,165d631d3c3045"
"458b4516242dad7ae",
)
drf_request = Request(request)
# Start with an AnonymousUser on the request, because that's a classic
# situation: we already went through a middleware, it didn't find a
# session cookie, if set request.user = AnonymousUser(), and now we
# are going through the authentication code in the API.
request.user = AnonymousUser()
# Call middleware as they would normally be called.
RedirectPrefixedURIMiddleware().process_request(request)
RestSharedSecretMiddleware().process_request(request)
RestOAuthMiddleware().process_request(request)
drf_request.authenticators = (
authentication.RestSharedSecretAuthentication(),
authentication.RestOAuthAuthentication(),
)
eq_(drf_request.user, self.profile.user)
eq_(drf_request._request.user, self.profile.user)
eq_(drf_request.user.is_authenticated(), True)
eq_(drf_request._request.user.is_authenticated(), True)
eq_(drf_request.amo_user.pk, self.profile.pk)
eq_(drf_request._request.amo_user.pk, self.profile.pk)
class TestProfileMiddleware(TestCase):
def setUp(self):
self.factory = RequestFactory()
def test_safe_view_request(self):
request = self.factory.get(reverse("users_edit"))
middleware = ProfileMiddleware()
response = middleware.process_request(request)
self.assertFalse(response)
def test_safe_path_request(self):
request = self.factory.get("/admin/something/")
middleware = ProfileMiddleware()
response = middleware.process_request(request)
self.assertFalse(response)
def test_authed_user_request(self):
request = self.factory.get(reverse("users_dashboard"))
request.user = complete_user
middleware = ProfileMiddleware()
response = middleware.process_request(request)
self.assertFalse(response)
def test_anon_user_request(self):
request = self.factory.get(reverse("users_dashboard"))
request.user = incomplete_user
middleware = ProfileMiddleware()
response = middleware.process_request(request)
self.assertEqual(response.status_code, 302)
self.assertEqual(response["Location"], reverse("users_edit"))
def _make_resp(mw_cls, secure=False):
mw = mw_cls()
req = RequestFactory().get('/')
if secure:
req.is_secure = lambda: True
resp = mw.process_response(req, HttpResponse())
return resp
def test_session_auth_no_post(self):
req = RequestFactory().post('/api/')
req.user = AnonymousUser()
for m in self.middlewares:
m().process_request(req)
ok_(not self.auth.authenticate(Request(req)))
ok_(not req.user.is_authenticated())
class TestDRFSwitch(TestCase):
def setUp(self):
self.factory = RequestFactory()
def test_responses(self):
view = SwitchToDRF('LanguageView')
request = self.factory.get(reverse('api.language', args=['1.5']))
request.APP = Mock(id=1)
request.user = AnonymousUser()
eq_(view(request, api_version=1.5).__module__, 'django.http')
piston_response = view(request, api_version=1.5).content
self.create_switch('drf', db=True)
eq_(view(request, api_version=1.5).__module__,
'rest_framework.response')
drf_response = view(request, api_version=1.5).render().content
eq_(piston_response, drf_response)
def test_wrong_format_exceptions(self):
view = SwitchToDRF('LanguageView')
request = self.factory.get(reverse('api.language', args=['1.5']))
request.APP = Mock(id=1)
request.GET = {'format': 'foo'}
request.user = AnonymousUser()
response = view(request, api_version=1.5)
eq_(response.content, '{"msg": "Not implemented yet."}')
eq_(response.status_code, 200)
self.create_switch('drf', db=True)
response = view(request, api_version=1.5)
self.assertTrue('<error>Not found</error>'
in response.render().content)
eq_(response.status_code, 404)
def dump_app(id, **kw):
from mkt.webapps.api import AppSerializer
# Because @robhudson told me to.
# Note: not using storage because all these operations should be local.
target_dir = os.path.join(settings.DUMPED_APPS_PATH, 'apps',
str(id / 1000))
target_file = os.path.join(target_dir, str(id) + '.json')
try:
obj = Webapp.objects.get(pk=id)
except Webapp.DoesNotExist:
task_log.info(u'Webapp does not exist: {0}'.format(id))
return
req = RequestFactory().get('/')
req.user = AnonymousUser()
req.REGION = RESTOFWORLD
if not os.path.exists(target_dir):
os.makedirs(target_dir)
task_log.info('Dumping app {0} to {1}'.format(id, target_file))
res = AppSerializer(obj, context={'request': req}).data
json.dump(res, open(target_file, 'w'), cls=JSONEncoder)
return target_file
def render(self, name, value, attrs=None):
topics_and_subtopics = Topic.objects.all()
topics = [t for t in topics_and_subtopics if t.parent_id is None]
for topic in topics:
self.process_topic(value, topic)
topic.my_subtopics = [t for t in topics_and_subtopics
if t.parent_id == topic.id]
for subtopic in topic.my_subtopics:
self.process_topic(value, subtopic)
# Create a fake request to make jingo happy.
req = RequestFactory()
req.META = {}
req.locale = settings.WIKI_DEFAULT_LANGUAGE
return jingo.render_to_string(
req,
'wiki/includes/topics_widget.html',
{
'topics': topics,
'name': name,
})
def _create_mocked_tweet_request(self):
request = RequestFactory().post(
reverse('customercare.twitter_post'),
{'reply_to': 1,
'content': '@foobar try Aurora! #fxhelp'})
request.session = {}
request.twitter = Mock()
request.twitter.authed = True
request.twitter.api = Mock()
return_value = {
'id': 123456790,
'text': '@foobar try Aurora! #fxhelp',
'created_at': datetime.strftime(datetime.utcnow(),
'%a %b %d %H:%M:%S +0000 %Y'),
'user': {
'lang': 'en',
'id': 42,
'screen_name': 'r1cky',
'profile_image_url': 'http://example.com/profile.jpg',
'profile_image_url_https': 'https://example.com/profile.jpg',
}
}
request.twitter.api.update_status.return_value = return_value
credentials = {'screen_name': 'r1cky'}
request.twitter.api.verify_credentials.return_value = credentials
request.user = Mock()
request.user.is_authenticated.return_value = False
return request
def req_factory_factory(url, user=None):
"""Creates a request factory, logged in with the user."""
req = RequestFactory().get(url)
if user:
req.user = user.user
req.groups = req.user.get_profile().groups.all()
return req
def test_session_auth(self):
req = RequestFactory().get('/')
req.COOKIES['user'] = ('[email protected],56b6f1a3dd735d962c56ce7d8f46e02ec'
'1d4748d2c00c407d75f0969d08bb9c68c31b3371aa8130'
'317815c89e5072e31bb94b4121c5c165f3515838d4d6c6'
'0c4,165d631d3c3045458b4516242dad7ae')
ok_(self.auth.is_authenticated(req))
def test_multiple_shared_works(self):
request = RequestFactory().post(
'/',
HTTP_AUTHORIZATION='mkt-shared-secret '
'[email protected],56b6f1a3dd735d962c56'
'ce7d8f46e02ec1d4748d2c00c407d75f0969d08bb'
'9c68c31b3371aa8130317815c89e5072e31bb94b4'
'121c5c165f3515838d4d6c60c4,165d631d3c3045'
'458b4516242dad7ae')
drf_request = Request(request)
# Start with an AnonymousUser on the request, because that's a classic
# situation: we already went through a middleware, it didn't find a
# session cookie, if set request.user = AnonymousUser(), and now we
# are going through the authentication code in the API.
request.user = AnonymousUser()
drf_request.authenticators = (
authentication.RestSharedSecretAuthentication(),
authentication.RestOAuthAuthentication())
eq_(drf_request.user, self.profile.user)
eq_(drf_request._request.user, self.profile.user)
eq_(drf_request.user.is_authenticated(), True)
eq_(drf_request._request.user.is_authenticated(), True)
eq_(drf_request.amo_user.pk, self.profile.pk)
eq_(drf_request._request.amo_user.pk, self.profile.pk)
def test_only_code(self):
"""GeoIP code is included when the country name is missing."""
req = RequestFactory()
req.COOKIES = {
'geoip_country_code': 'US',
}
val = geoip_cache_detector(req)
eq_(val['include_geoip'], True)
def test_authenticated(self, unread_count_for):
"""Test authenticated user with flag active."""
unread_count_for.return_value = 3
rf = RequestFactory()
request = rf.get("/")
request.user = user(save=True)
eq_(3, unread_message_count(request)["unread_message_count"])
assert unread_count_for.called
def test_authenticated(self, unread_count_for):
"""Test authenticated user with flag active."""
unread_count_for.return_value = 3
rf = RequestFactory()
request = rf.get('/')
request.user = get_user('rrosario')
eq_(3, unread_message_count(request)['unread_message_count'])
assert unread_count_for.called
def get_request(self, profile):
request = RequestFactory().post('/')
if not profile:
request.user = AnonymousUser()
else:
request.user = profile.user
request.amo_user = profile
return request
def test_anonymous(self, unread_count_for):
"""Test anonymous user with flag active."""
unread_count_for.return_value = 3
rf = RequestFactory()
request = rf.get('/')
request.user = AnonymousUser()
eq_(0, unread_message_count(request)['unread_message_count'])
assert not unread_count_for.called
def test_get_username_with_username_field(self):
req = RequestFactory().get('/')
req.user = mock.Mock()
req.user.USERNAME_FIELD = 'myfield'
req.user.myfield = 'my-new-username'
eq_(get_username(), '<anon>')
self.middleware.process_request(req)
eq_(get_username(), 'my-new-username')
def test_get_username_no_username_field(self):
req = RequestFactory().get('/')
req.user = mock.Mock()
del req.user.USERNAME_FIELD
req.user.username = '******'
eq_(get_username(), '<anon>')
self.middleware.process_request(req)
eq_(get_username(), 'my-username')
def test_multiple_passes(self):
req = RequestFactory().get('/')
req.user = AnonymousUser()
self.resource._meta.authentication = (
authentication.SharedSecretAuthentication(),
# Optional auth passes because there are not auth headers.
authentication.OptionalOAuthAuthentication())
eq_(self.resource.is_authenticated(req), None)
def process(self, authenticated, view=None, lang='en-US', app='firefox'):
if not view:
view = normal_view
request = RequestFactory().get('/', HTTP_X_PJAX=True)
request.user = Mock()
request.APP = amo.APPS[app]
request.LANG = lang
request.user.is_authenticated.return_value = authenticated
return LoginRequiredMiddleware().process_view(request, view, [], {})
def test_stub_aurora_installer_disabled_en_us(self):
rf = RequestFactory()
get_request = rf.get("/fake")
get_request.locale = "en-US"
doc = pq(render("{{ download_firefox('aurora') }}", {"request": get_request}))
links = doc("li a")[:3]
for link in links:
ok_("stub" not in pq(link).attr("href"))
def test_when_both(self):
"""GeoIP code is not included when both name and code already exist."""
req = RequestFactory()
req.COOKIES = {
'geoip_country_name': 'United States',
'geoip_country_code': 'US',
}
val = geoip_cache_detector(req)
eq_(val['include_geoip'], False)
def test_failed_session_auth(self):
req = RequestFactory().post(
'/api/',
HTTP_AUTHORIZATION='mkt-shared-secret bogus')
req.user = AnonymousUser()
for m in self.middlewares:
m().process_request(req)
ok_(not self.auth.authenticate(Request(req)))
ok_(not req.user.is_authenticated())
def check_permissions(self):
req = RequestFactory().get(reverse('comm-thread-detail',
kwargs={'pk': self.thread.pk}))
req.user = self.user
req.amo_user = self.profile
req.groups = req.amo_user.groups.all()
return ThreadPermission().has_object_permission(
req, 'comm-thread-detail', self.thread)
def test_stub_aurora_installer_override_locale(self):
rf = RequestFactory()
get_request = rf.get("/fake")
get_request.locale = "fr"
doc = pq(render("{{ download_firefox('aurora', " "force_full_installer=True) }}", {"request": get_request}))
links = doc(".download-list a")[:3]
for link in links:
ok_("stub" not in pq(link).attr("href"))
def setUp(self):
self.resource = ThrottleResource()
self.request = RequestFactory().post('/')
self.user = User.objects.get(pk=2519)
self.request.user = self.user
self.throttle = self.resource._meta.throttle
self.request.META['CONTENT_TYPE'] = 'application/x-www-form-urlencoded'
self.mocked_sbt = patch.object(self.throttle, 'should_be_throttled')
def call(self, client=None):
url = ('api_dispatch_list', {'resource_name': 'app'})
client = client or OAuthClient(self.access)
url = client.get_absolute_url(url)
return RequestFactory().get(url,
HTTP_HOST='api',
HTTP_AUTHORIZATION=client.header(
'GET', url))
def check(self, ua, should_be_mobile):
request = RequestFactory().get('/en-US/home', HTTP_USER_AGENT=ua)
DetectMobileMiddleware().process_request(request)
if should_be_mobile:
self.assertEqual(request.META['HTTP_X_MOBILE'], '1')
else:
assert 'HTTP_X_MOBILE' not in request.META
def response(self, url):
req = RequestFactory().get(url)
self.prefix_middleware.process_request(req)
resp = self.api_version_middleware.process_request(req)
if resp:
return resp
return self.api_version_middleware.process_response(
req, HttpResponse())
def setUp(self):
super(TestCategoryForm, self).setUp()
self.user = UserProfile.objects.get(username='******')
self.app = Webapp.objects.get(pk=337141)
self.request = RequestFactory()
self.request.user = self.user
self.request.groups = ()
self.cat = 'social'
def setUp(self):
super(TestAdminSettingsForm, self).setUp()
self.data = {'position': 1}
self.user = UserProfile.objects.get(username='******')
self.request = RequestFactory()
self.request.user = self.user
self.request.groups = ()
self.kwargs = {'instance': self.webapp, 'request': self.request}
def call(self, client=None):
url = ('api_dispatch_list', {'resource_name': 'app'})
client = client or OAuthClient(self.access)
url = client.get_absolute_url(url)
return RequestFactory().get(url,
HTTP_HOST='testserver',
HTTP_AUTHORIZATION=client.sign(
'GET', url)[1]['Authorization'])
def call(self, client=None):
client = client or OAuthClient(self.access)
# Make a fake POST somewhere. We use POST in order to properly test db
# pinning after auth.
url = absolutify('/api/whatever')
return RequestFactory().post(url,
HTTP_HOST='testserver',
HTTP_AUTHORIZATION=client.sign('POST', url)[1]['Authorization'])
def test_session_auth(self):
req = RequestFactory().get('/[email protected],56b6f1a3dd735d962c56'
'ce7d8f46e02ec1d4748d2c00c407d75f0969d08bb'
'9c68c31b3371aa8130317815c89e5072e31bb94b4'
'121c5c165f3515838d4d6c60c4,165d631d3c3045'
'458b4516242dad7ae')
ok_(self.auth.is_authenticated(req))
eq_(self.profile.user.pk, req.amo_user.pk)
def setUp(self):
self.app = Webapp.objects.get(pk=337141)
self.permission = AllowRelatedAppOwner()
self.anonymous = AnonymousUser()
self.owner = self.app.authors.all()[0]
self.request = RequestFactory().get('/')
self.request.user = self.anonymous
self.request.amo_user = None
def test_multiple_fails(self):
client = OAuthClient(Mock(key='foo', secret='bar'))
req = RequestFactory().get('/',
HTTP_HOST='api',
HTTP_AUTHORIZATION=client.header(
'GET', 'http://foo/'))
req.user = AnonymousUser()
next_auth = Mock()
self.resource._meta.authentication = (
# OAuth fails because there are bogus auth headers.
authentication.OAuthAuthentication(),
next_auth)
with self.assertRaises(ImmediateHttpResponse):
eq_(self.resource.is_authenticated(req), None)
# This never even got called.
ok_(not next_auth.is_authenticated.called)
def test_has_object_permission(self):
request = RequestFactory().get('/')
ok_(
AnyOf(AllowNone,
AllowAny)().has_object_permission(request, 'myview', None))
ok_(
AnyOf(AllowAny,
AllowNone)().has_object_permission(request, 'myview', None))
def _wrapped_resp(decorator, fn, mw_cls=None):
req = RequestFactory().get('/')
_wrapped = decorator(fn)
resp = _wrapped(req)
if mw_cls is not None:
mw = mw_cls()
resp = mw.process_response(req, resp)
return resp
def req_factory_factory(url, user=None, post=False, data=None):
"""Creates a request factory, logged in with the user."""
req = RequestFactory()
if post:
req = req.post(url, data or {})
else:
req = req.get(url, data or {})
if user:
req.amo_user = RequestUser.objects.get(id=user.id)
req.user = user.user
req.groups = req.user.get_profile().groups.all()
req.APP = None
req.check_ownership = partial(check_ownership, req)
return req
def test_post_reply(self):
# Create a Tweet to reply to.
Tweet.objects.create(
pk=1,
raw_json='{}',
locale='en',
created=datetime.now())
# Create a request and mock all the required properties and methods.
request = RequestFactory().post(
reverse('customercare.twitter_post'),
{'reply_to': 1,
'content': '@foobar try Aurora! #fxhelp'})
request.session = {}
request.twitter = Mock()
request.twitter.authed = True
request.twitter.api = Mock()
return_value = {
'id': 123456790,
'text': '@foobar try Aurora! #fxhelp',
'created_at': datetime.strftime(datetime.utcnow(),
'%a %b %d %H:%M:%S +0000 %Y'),
'user': {
'lang': 'en',
'id': 42,
'screen_name': 'r1cky',
'profile_image_url': 'http://example.com/profile.jpg',
'profile_image_url_https': 'https://example.com/profile.jpg',
}
}
request.twitter.api.update_status.return_value = return_value
credentials = {'screen_name': 'r1cky'}
request.twitter.api.verify_credentials.return_value = credentials
request.user = Mock()
request.user.is_authenticated = lambda: False
# Pass the request to the view and verify response.
response = twitter_post(request)
eq_(200, response.status_code)
# Verify the reply was inserted with the right data.
reply = Reply.objects.all()[0]
eq_('r1cky', reply.twitter_username)
eq_(1, reply.reply_to_tweet_id)
eq_('@foobar try Aurora! #fxhelp', json.loads(reply.raw_json)['text'])
def test_version_sidebar(self):
request = RequestFactory()
request.GET = {}
request.APP = amo.FIREFOX
request.get(reverse('search.search'))
facets = {
u'platforms': [{u'count': 58, u'term': 1}],
u'appversions': [{u'count': 58, u'term': 5000000200100}],
u'categories': [{u'count': 55, u'term': 1}],
u'tags': [],
}
versions = version_sidebar(request, {}, facets)
assert versions[0].selected
versions = version_sidebar(request, {'appver': '5.0'}, facets)
assert versions[1].selected
# We're not storing the version in the session anymore: no memories.
versions = version_sidebar(request, {}, facets)
assert versions[0].selected
# We read the appver from the cleaned form data.
request.GET['appver'] = '123.4'
# No form data, fallback to default (first entry).
versions = version_sidebar(request, {}, facets)
assert versions[0].selected
# Form data has the proper version, use it.
versions = version_sidebar(request, {'appver': '5.0'}, facets)
assert versions[1].selected
# Form data has the proper version, which is new: add it.
versions = version_sidebar(request, {'appver': '123.4'}, facets)
assert versions[1].selected
eq_(len(versions), 3)
def request(self, verb, qs=None, **data):
if not qs:
qs = ''
request = getattr(RequestFactory(), verb.lower())
request = request('/?' + qs, content_type='application/json',
data=json.dumps(data) if data else '')
request.user = self.user
ACLMiddleware().process_request(request)
return Request(request)
def test_button_has_data_attr_if_not_direct(self):
"""
If the button points to the thank you page, it should have a
`data-direct-link` attribute that contains the direct url.
"""
rf = RequestFactory()
get_request = rf.get('/fake')
get_request.locale = 'fr'
doc = pq(render("{{ download_button('button') }}",
{'request': get_request}))
# The first 3 links should be for desktop.
links = doc('.download-list a')
for link in links[:3]:
ok_(pq(link).attr('data-direct-link')
.startswith('https://download.mozilla.org'))
# The fourth link is mobile and should not have the attr
ok_(pq(links[3]).attr('data-direct-link') is None)
class RebuildTestCase(TestCase):
fixtures = ['users.json', 'wiki/documents.json']
rf = RequestFactory()
ALWAYS_EAGER = celery.conf.ALWAYS_EAGER
def setUp(self):
self.old_settings = deepcopy(settings._wrapped.__dict__)
celery.conf.ALWAYS_EAGER = True
def tearDown(self):
cache.delete(settings.WIKI_REBUILD_TOKEN)
settings._wrapped.__dict__ = self.old_settings
celery.conf.ALWAYS_EAGER = self.ALWAYS_EAGER
@mock.patch.object(rebuild_kb, 'delay')
@mock.patch.object(waffle, 'switch_is_active')
def test_eager_queue(self, switch_is_active, delay):
switch_is_active.return_value = True
schedule_rebuild_kb()
assert not cache.get(settings.WIKI_REBUILD_TOKEN)
assert not delay.called
@mock.patch.object(rebuild_kb, 'delay')
@mock.patch.object(waffle, 'switch_is_active')
def test_task_queue(self, switch_is_active, delay):
switch_is_active.return_value = True
celery.conf.ALWAYS_EAGER = False
schedule_rebuild_kb()
assert cache.get(settings.WIKI_REBUILD_TOKEN)
assert delay.called
@mock.patch.object(rebuild_kb, 'delay')
@mock.patch.object(waffle, 'switch_is_active')
def test_already_queued(self, switch_is_active, delay):
switch_is_active.return_value = True
cache.set(settings.WIKI_REBUILD_TOKEN, True)
schedule_rebuild_kb()
assert cache.get(settings.WIKI_REBUILD_TOKEN)
assert not delay.called
@mock.patch.object(rebuild_kb, 'delay')
@mock.patch.object(cache, 'get')
@mock.patch.object(waffle, 'switch_is_active')
def test_dont_queue(self, switch_is_active, get, delay):
switch_is_active.return_value = False
schedule_rebuild_kb()
assert not get.called
assert not delay.called
@mock.patch.object(_rebuild_kb_chunk, 'apply_async')
def test_rebuild_chunk(self, apply_async):
cache.set(settings.WIKI_REBUILD_TOKEN, True)
rebuild_kb()
assert not cache.get(settings.WIKI_REBUILD_TOKEN)
data = set((1, 2, 4, 5))
assert 'args' in apply_async.call_args[1]
eq_(data, set(apply_async.call_args[1]['args'][0]))
def setUp(self):
super(TestCategoryForm, self).setUp()
self.user = UserProfile.objects.get(username='******')
self.app = Webapp.objects.get(pk=337141)
self.request = RequestFactory()
self.request.user = self.user
self.request.groups = ()
self.cat = Category.objects.create(type=amo.ADDON_WEBAPP)
def test_get_obj(self):
obj = Mock()
self.request = RequestFactory().get('/')
self.set_object_permission_mock('get', True)
eq_(self.permission.has_object_permission(self.request, 'myview', obj),
True)
self.set_object_permission_mock('get', False)
eq_(self.permission.has_object_permission(self.request, 'myview', obj),
False)
def test_serialize(self):
# Just a smoke test that we can serialize this correctly.
self.create()
request = Request(RequestFactory().get('/'))
res = AddonPaymentAccountSerializer(self.payment,
context={
'request': request
}).data
eq_(res['url'], self.app_payment_detail)
def setUp(self):
self.SerializerClass.Meta = type('Meta', (self.Struct, ), {
'model': User,
'url_basename': self.url_basename
})
self.serializer = self.SerializerClass(
context={'request': RequestFactory().get('/')})
self.obj = self.Struct()
self.obj.pk = 42
def test_session_auth_query(self):
req = RequestFactory().post(
'/api/[email protected],56b6f1a3dd735d962c56ce7d8f46e02ec1d4748d'
'2c00c407d75f0969d08bb9c68c31b3371aa8130317815c89e5072e31bb94b4121'
'c5c165f3515838d4d6c60c4,165d631d3c3045458b4516242dad7ae')
for m in self.middlewares:
m().process_request(req)
ok_(self.auth.authenticate(Request(req)))
eq_(self.profile.user.pk, req.amo_user.pk)
def test_cors(self):
@cors_api_view(['GET', 'PATCH'])
@authentication_classes([])
@permission_classes([])
def foo(request):
return Response()
request = RequestFactory().get('/')
foo(request)
eq_(request.CORS, ['GET', 'PATCH'])
def test_release_notes(self):
version = self.app.current_version
version.releasenotes = u'These are nötes.'
version.save()
res = self.serialize(self.app)
eq_(res['release_notes'], {u'en-US': unicode(version.releasenotes)})
self.request = RequestFactory().get('/?lang=whatever')
res = self.serialize(self.app)
eq_(res['release_notes'], unicode(version.releasenotes))
def test_single(self):
req = RequestFactory().get('/[email protected],56b6f1a3dd735d962c56'
'ce7d8f46e02ec1d4748d2c00c407d75f0969d08bb'
'9c68c31b3371aa8130317815c89e5072e31bb94b4'
'121c5c165f3515838d4d6c60c4,165d631d3c3045'
'458b4516242dad7ae')
self.resource._meta.authentication = (
authentication.SharedSecretAuthentication())
eq_(self.resource.is_authenticated(req), None)
eq_(self.profile.user.pk, req.amo_user.pk)
def setUp(self):
self.permission = AllowReadOnlyIfPublic()
self.anonymous = AnonymousUser()
self.request_factory = RequestFactory()
# 'patch' is missing because it's absent from RequestFactory in
# django < 1.5. Usually we don't special case 'put' vs 'patch' in
# permissions code though, so it's fine.
self.unsafe_methods = ('post', 'put', 'delete')
self.safe_methods = ('get', 'options', 'head')
def request(self, method, url, resource_name, data=''):
api = getattr(RequestFactory(), method)
req = api(url,
data and json.dumps(data) or '',
content_type='application/json')
res = ProxyView().dispatch(req,
reference_name='reference',
resource_name=resource_name)
res.render() # Useful to access content later on.
return res
def test_use_access_token(self):
url = absolutify(reverse('app-list'))
t = Token.generate_new(ACCESS_TOKEN,
creds=self.access,
user=self.user2)
url, auth_header = self._oauth_request_info(
url,
client_key=self.access.key,
client_secret=self.access.secret,
resource_owner_key=t.key,
resource_owner_secret=t.secret)
auth = authentication.RestOAuthAuthentication()
req = RequestFactory().get(url,
HTTP_HOST='testserver',
HTTP_AUTHORIZATION=auth_header)
req.API = True
RestOAuthMiddleware().process_request(req)
assert auth.authenticate(Request(req))
eq_(req.user, self.user2)
