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)