class TestOrganizationAddForm(TestCase): """ Tests for adding new organizations """ def setUp(self): self.factory = RequestFactory() def test_expected_valid_data_validates(self): """Test our happy path""" request = self.factory.request() form = OrganizationAddForm( request, data={ "slug": "new_org", "name": "New Org", "email": "*****@*****.**" }, ) self.assertTrue(form.is_valid()) def test_add_organization_for_existing_user(self): user = User.objects.create_user("timmy", password="******", email="*****@*****.**") request = self.factory.request() form = OrganizationAddForm(request, data={ "slug": "new_org", "name": "New Org", "email": user.email }) self.assertTrue(form.is_valid()) new_org = form.save() self.assertTrue(new_org.is_active) self.assertEqual(new_org.name, "New Org") def test_add_organization_for_new_user(self): user = User.objects.create_user("timmy", password="******", email="*****@*****.**") request = request_factory_login(self.factory, user) form = OrganizationAddForm( request, data={ "slug": "new_org", "name": "New Org", "email": "*****@*****.**", }, ) self.assertTrue(form.is_valid()) new_org = form.save() self.assertFalse(new_org.is_active) # Inactive until confirmation
def test_send_mail(self, fake_messages): """Test EmailRepsForm email sending functionality.""" fake_messages.expects('success') data = { 'subject': 'Test email subject', 'body': 'Test email body', 'functional_area': self.functional_area.id } form = EmailRepsForm(data=data) ok_(form.is_valid()) area = self.functional_area UserFactory.create_batch(20, userprofile__functional_areas=[area]) factory = RequestFactory() request = factory.request() request.user = UserFactory.create() reps = User.objects.filter(userprofile__functional_areas__name=area) form.send_email(request, reps) eq_(len(mail.outbox), 1) address = lambda u: '%s %s <%s>' % (u.first_name, u.last_name, u.email) recipients = map(address, reps) eq_(set(mail.outbox[0].to), set(recipients)) eq_(mail.outbox[0].subject, data['subject']) eq_(mail.outbox[0].body, data['body'])
def test_send_mail(self, fake_messages): """Test EmailRepsForm email sending functionality.""" data = {"subject": "Test email subject", "body": "Test email body", "functional_area": self.functional_area.id} form = EmailRepsForm(data=data) ok_(form.is_valid()) area = self.functional_area UserFactory.create_batch(20, userprofile__functional_areas=[area]) factory = RequestFactory() request = factory.request() request.user = UserFactory.create() reps = User.objects.filter(userprofile__functional_areas__name=area) form.send_email(request, reps) eq_(len(mail.outbox), 20) address = lambda u: "%s %s <%s>" % (u.first_name, u.last_name, u.email) recipients = map(address, reps) receivers = [] for i in range(0, len(mail.outbox)): eq_(mail.outbox[i].subject, data["subject"]) eq_(mail.outbox[i].body, data["body"]) receivers.append(mail.outbox[i].to[0]) eq_(set(receivers), set(recipients)) fake_messages.assert_called_with(ANY, "Email sent successfully.")
def test_send_mail(self, fake_messages): """Test EmailRepsForm email sending functionality.""" data = {'subject': 'Test email subject', 'body': 'Test email body', 'functional_area': self.functional_area.id} form = EmailRepsForm(data=data) ok_(form.is_valid()) area = self.functional_area UserFactory.create_batch(20, userprofile__functional_areas=[area]) factory = RequestFactory() request = factory.request() request.user = UserFactory.create() reps = User.objects.filter(userprofile__functional_areas__name=area) form.send_email(request, reps) eq_(len(mail.outbox), 20) def format_name(user): return '%s %s <%s>' % (user.first_name, user.last_name, user.email) recipients = map(format_name, reps) receivers = [] for i in range(0, len(mail.outbox)): eq_(mail.outbox[i].subject, data['subject']) eq_(mail.outbox[i].body, data['body']) receivers.append(mail.outbox[i].to[0]) eq_(set(receivers), set(recipients)) fake_messages.assert_called_with(ANY, 'Email sent successfully.')
class AddDecisionTest(DecisionTestCase): fixtures = ['organizations.json', 'users.json'] def setUp(self): self.betty = User.objects.get(username="******") self.bettysorg = Organization.objects.get_for_user(self.betty)[0] self.factory = RequestFactory() def test_jquery_javascript_included_in_page(self): response = self.load_add_decision_and_return_response() self.assertContains(response, "jquery.min.js") self.assertContains(response, "jquery-ui.min.js") def test_jquery_css_included_in_page(self): response = self.load_add_decision_and_return_response() self.assertContains(response, "jquery-ui.css") def test_add_description_form_doesnt_ask_for_name(self): response = self.load_add_decision_and_return_response() self.assertNotContains(response, "id_short_name") def load_add_decision_and_return_response(self): request = self.factory.request() request.user = self.betty kwargs = {'org_slug':self.bettysorg.slug} response = DecisionCreate(template_name='decision_update_page.html').dispatch(request, **kwargs) rendered_response = response.render() return rendered_response
def request(self, **request_args): """Constructs a generic request object, INCLUDING middleware modifications.""" from django.core import urlresolvers request = RequestFactory.request(self, **request_args) ###pprint.pprint(request) handler = BaseHandler() handler.load_middleware() for middleware_method in handler._request_middleware: #print("APPLYING REQUEST MIDDLEWARE ", middleware_method, file=sys.stderr) if middleware_method(request): raise Exception("Couldn't create request mock object - " "request middleware returned a response") urlconf = settings.ROOT_URLCONF urlresolvers.set_urlconf(urlconf) resolver = urlresolvers.RegexURLResolver(r'^/', urlconf) callback, callback_args, callback_kwargs = resolver.resolve( request.path_info) # Apply view middleware for middleware_method in handler._view_middleware: #print("APPLYING VIEW MIDDLEWARE ", middleware_method, file=sys.stderr) response = middleware_method(request, callback, callback_args, callback_kwargs) if response: raise Exception("Couldn't create request mock object - " "view middleware returned a response") return request
def handle(self, *args, **options): base_url = options.get('base_url', '') if base_url is '': # compress all found themes, without touching database, as database is not ready normally. site = Site(domain='example.com') all_sitethemes = [SiteTheme(theme_slug=slug, site=site) for slug in os.listdir(settings.THEMING_ROOT) if os.path.isdir(os.path.join(settings.THEMING_ROOT, slug))] else: factory = RequestFactory() self.request = request = factory.request() request.META['SERVER_NAME'] = urlparse(base_url).netloc request.user = User(is_superuser=False) try: from aliassite.middleware import AliasSiteMiddleware AliasSiteMiddleware().process_request(request) except ImportError: pass ThemingMiddleware().process_request(request) sitetheme = get_thread_variable('sitetheme') all_sitethemes = [sitetheme, ] for sitetheme in all_sitethemes: if sitetheme is None: print('# cannot find any sitetheme, fall back to pure compress command') else: print('# Run compress command for Site:%s Theme:%s' % (sitetheme.site, sitetheme.theme)) set_thread_variable('sitetheme', sitetheme) super(Command, self).handle(*args, **options)
def test_send_mail(self, fake_messages): """Test EmailRepsForm email sending functionality.""" data = {'subject': 'Test email subject', 'body': 'Test email body', 'functional_area': self.functional_area.id} form = EmailRepsForm(data=data) ok_(form.is_valid()) area = self.functional_area UserFactory.create_batch(20, userprofile__functional_areas=[area]) factory = RequestFactory() request = factory.request() request.user = UserFactory.create() reps = User.objects.filter(userprofile__functional_areas__name=area) form.send_email(request, reps) eq_(len(mail.outbox), 1) address = lambda u: '%s %s <%s>' % (u.first_name, u.last_name, u.email) recipients = map(address, reps) eq_(set(mail.outbox[0].to), set(recipients)) eq_(mail.outbox[0].subject, data['subject']) eq_(mail.outbox[0].body, data['body']) fake_messages.assert_called_with(ANY, 'Email sent successfully.')
def test_cookie_monitoring_no_groups(self, mock_set_custom_attribute, mock_capture_cookie_sizes): mock_capture_cookie_sizes.is_enabled.return_value = True middleware = CookieMonitoringMiddleware() cookies_dict = { "a": "." * 10, "b": "." * 15, } factory = RequestFactory() for name, value in cookies_dict.items(): factory.cookies[name] = value mock_request = factory.request() middleware.process_request(mock_request) mock_set_custom_attribute.assert_has_calls([ call('cookies.max.name', 'b'), call('cookies.max.size', 15), call('cookies.1.name', 'b'), call('cookies.1.size', 15), call('cookies.2.name', 'a'), call('cookies.2.size', 10), call('cookies_total_size', 25), ], any_order=True)
def test_begin_login_with_xrds_url(self): # the provider URL must be converted to an absolute URL in order to be # used as an openid provider. provider_url = reverse('openid-provider-xrds') factory = RequestFactory() request = factory.request() abs_provider_url = request.build_absolute_uri(location=provider_url) # In order for this absolute URL to work (i.e. to get xrds, then authentication) # in the test environment, we either need a live server that works with the default # fetcher (i.e. urlopen2), or a test server that is reached through a custom fetcher. # Here we do the latter: fetcher = MyFetcher(self.client) openid.fetchers.setDefaultFetcher(fetcher, wrap_exceptions=False) # now we can begin the login process by invoking a local openid client, # with a pointer to the (also-local) openid provider: with self.settings(OPENID_SSO_SERVER_URL=abs_provider_url): url = reverse('openid-login') resp = self.client.post(url) code = 200 self.assertEqual( resp.status_code, code, "got code {0} for url '{1}'. Expected code {2}".format( resp.status_code, url, code))
class LoginViewTestCase(unittest.TestCase): def setUp(self): self.factory = RequestFactory() def test_get(self): request = self.factory.get(reverse("account_login")) request.user = AnonymousUser() response = LoginView.as_view()(request) self.assertEqual(response.status_code, 200) self.assertEqual(response.template_name, ["account/login.html"]) def test_get_disabled(self): request = self.factory.get(reverse("account_login")) request.user = AnonymousUser() response = LoginDisabledView.as_view()(request) self.assertEqual(response.status_code, 200) def test_post_disabled(self): request = self.factory.post(reverse("account_login")) request.user = AnonymousUser() response = LoginDisabledView.as_view()(request) self.assertEqual(response.status_code, 403) def test_custom_redirect_field(self): request = self.factory.request() request.GET = {"next_page": "/profile/"} form = LoginUsernameForm({"username": "******", "password": "******"}) view = LoginRedirectView(request=request, redirect_field_name="next_page") self.assertEqual("/profile/", view.form_valid(form)["Location"])
def test_begin_login_with_xrds_url(self): # the provider URL must be converted to an absolute URL in order to be # used as an openid provider. provider_url = reverse('openid-provider-xrds') factory = RequestFactory() request = factory.request() abs_provider_url = request.build_absolute_uri(location=provider_url) # In order for this absolute URL to work (i.e. to get xrds, then authentication) # in the test environment, we either need a live server that works with the default # fetcher (i.e. urlopen2), or a test server that is reached through a custom fetcher. # Here we do the latter: fetcher = MyFetcher(self.client) openid.fetchers.setDefaultFetcher(fetcher, wrap_exceptions=False) # now we can begin the login process by invoking a local openid client, # with a pointer to the (also-local) openid provider: with self.settings(OPENID_SSO_SERVER_URL=abs_provider_url): url = reverse('openid-login') resp = self.client.post(url) code = 200 self.assertEqual(resp.status_code, code, "got code {0} for url '{1}'. Expected code {2}" .format(resp.status_code, url, code))
def testGetSubdomainMiddleware5(self): "Test GetSubdomainMiddleware.process_request populates the variables we need correctly" rf = RequestFactory(domain = 'boox.notfoo.tld') request = rf.request() middleware = GetSubdomainMiddleware() middleware.process_request(request) self.assertEqual(request.META['domain'], 'boox.notfoo.tld')
def setUp(self): site_navbars._registry = {} self.user = User.objects.create_superuser("user_login", "*****@*****.**", "pass") rf = RequestFactory() self.request = rf.request() self.request.user = self.user
def testGetSubdomainMiddleware2(self): "Test GetSubdomainMiddleware.process_request populates the variables we need correctly" rf = RequestFactory(subdomain = 'www') request = rf.request() middleware = GetSubdomainMiddleware() middleware.process_request(request) self.assertEqual(request.META['subdomain'], 'www') self.assertEqual(request.subdomain, None)
def get_mock_request(self, cookies_dict): """ Return mock request with the provided cookies in the header. """ factory = RequestFactory() for name, value in cookies_dict.items(): factory.cookies[name] = value return factory.request()
def request(self, **request): request = RequestFactory.request(self, **request) handler = BaseHandler() handler.load_middleware() for mw in handler._request_middleware: if mw(request): raise Exception('middleware returned a reponse') return request
def test_cookie_monitoring(self, mock_set_custom_attribute, mock_capture_cookie_sizes): mock_capture_cookie_sizes.is_enabled.return_value = True middleware = CookieMonitoringMiddleware() cookies_dict = { "a": "." * 100, "_b": "." * 13, "_c_": "." * 13, "a.b": "." * 10, "a.c": "." * 10, "b.": "." * 13, "b_a": "." * 15, "b_c": "." * 15, "d": "." * 3, } factory = RequestFactory() for name, value in cookies_dict.items(): factory.cookies[name] = value mock_request = factory.request() middleware.process_request(mock_request) mock_set_custom_attribute.assert_has_calls([ call('cookies.1.name', 'a'), call('cookies.1.size', 100), call('cookies.2.name', 'b_a'), call('cookies.2.size', 15), call('cookies.3.name', 'b_c'), call('cookies.3.size', 15), call('cookies.4.name', '_b'), call('cookies.4.size', 13), call('cookies.5.name', '_c_'), call('cookies.5.size', 13), call('cookies.6.name', 'b.'), call('cookies.6.size', 13), call('cookies.7.name', 'a.b'), call('cookies.7.size', 10), call('cookies.8.name', 'a.c'), call('cookies.8.size', 10), call('cookies.group.1.name', 'b'), call('cookies.group.1.size', 43), call('cookies.group.2.name', 'a'), call('cookies.group.2.size', 20), call('cookies.max.name', 'a'), call('cookies.max.size', 100), call('cookies.max.group.name', 'a'), call('cookies.max.group.size', 100), call('cookies_total_size', 192), call('cookies_unaccounted_size', 3), call('cookies_total_num', 9), call('cookies.header.size', 238) ], any_order=True)
def testGetSubdomainMiddleware3(self): "Test GetSubdomainMiddleware.process_request populates the variables we need correctly" user = User.objects.create_user(username = '******', password = '******', email = '*****@*****.**') subdomain = Subdomain.objects.register_new_subdomain(subdomain_text = 'foo4', name='Foo, the subdomain', description = 'Foo has not description', user = user) rf = RequestFactory(subdomain = 'foo4') request = rf.request() middleware = GetSubdomainMiddleware() middleware.process_request(request) self.assertEqual(request.META['subdomain'], 'foo4')
def request(self, **request): "Construct a generic request object." request = RequestFactory.request(self, **request) handler = BaseHandler() handler.load_middleware() for middleware_method in handler._request_middleware: if middleware_method(request): raise Exception("Couldn't create request mock object - " "request middleware returned a response") return request
def test_replace_parameters(self): from django_boost.templatetags.boost_url import replace_parameters cases = [ ("", ('p', 'p'), ("p=p", )), ("q=q", ('p', 'p'), ("q=q", "p=p")), ("q=q", ('q', 'x', 'p', 'p'), ("q=x", "p=p")), ] factory = RequestFactory() for qs, args, expected in cases: request = factory.request(**{'QUERY_STRING': qs}) actual = replace_parameters(request, *args) for e in expected: self.assertIn(e, actual) with self.assertRaises(LookupError): request = factory.request() replace_parameters(request, 'q')
class InvitationTests(TestCase): fixtures = ['users.json', 'orgs.json'] def setUp(self): mail.outbox = [] self.factory = RequestFactory() self.tokenizer = RegistrationTokenGenerator() self.user = User.objects.get(username="******") self.pending_user = User.objects.create_user(username="******", email="*****@*****.**", password="******") self.pending_user.is_active = False self.pending_user.save() def test_backend_definition(self): from organizations.backends import invitation_backend self.assertTrue(isinstance(invitation_backend(), InvitationBackend)) def test_create_user(self): invited = InvitationBackend().invite_by_email("*****@*****.**") self.assertTrue(isinstance(invited, User)) self.assertFalse(invited.is_active) self.assertEqual(1, len(mail.outbox)) mail.outbox = [] def test_create_existing_user(self): invited = InvitationBackend().invite_by_email(self.user.email) self.assertEqual(self.user, invited) self.assertEqual(0, len(mail.outbox)) # User is active def test_send_reminder(self): InvitationBackend().send_reminder(self.pending_user) self.assertEqual(1, len(mail.outbox)) InvitationBackend().send_reminder(self.user) self.assertEqual(1, len(mail.outbox)) # User is active mail.outbox = [] def test_urls(self): """Ensure no error is raised""" reverse('invitations_register', kwargs={ 'user_id': self.pending_user.id, 'token': self.tokenizer.make_token(self.pending_user) }) def test_activate_user(self): request = self.factory.request() with self.assertRaises(Http404): InvitationBackend().activate_view( request, self.user.id, self.tokenizer.make_token(self.user)) self.assertEqual( 200, InvitationBackend().activate_view( request, self.pending_user.id, self.tokenizer.make_token(self.pending_user)).status_code)
def test_begin_login_with_login_url(self): # the provider URL must be converted to an absolute URL in order to be # used as an openid provider. provider_url = reverse('openid-provider-login') factory = RequestFactory() request = factory.request() abs_provider_url = request.build_absolute_uri(location=provider_url) # In order for this absolute URL to work (i.e. to get xrds, then authentication) # in the test environment, we either need a live server that works with the default # fetcher (i.e. urlopen2), or a test server that is reached through a custom fetcher. # Here we do the latter: fetcher = MyFetcher(self.client) openid.fetchers.setDefaultFetcher(fetcher, wrap_exceptions=False) # now we can begin the login process by invoking a local openid client, # with a pointer to the (also-local) openid provider: with self.settings(OPENID_SSO_SERVER_URL=abs_provider_url): url = reverse('openid-login') resp = self.client.post(url) code = 200 self.assertEqual( resp.status_code, code, "got code {0} for url '{1}'. Expected code {2}".format( resp.status_code, url, code)) for expected_input in ( '<input name="openid.ns" type="hidden" value="http://specs.openid.net/auth/2.0" />', '<input name="openid.ns.ax" type="hidden" value="http://openid.net/srv/ax/1.0" />', '<input name="openid.ax.type.fullname" type="hidden" value="http://axschema.org/namePerson" />', '<input type="submit" value="Continue" />', '<input name="openid.ax.type.email" type="hidden" value="http://axschema.org/contact/email" />', '<input name="openid.ax.type.lastname" ' 'type="hidden" value="http://axschema.org/namePerson/last" />', '<input name="openid.ax.type.firstname" ' 'type="hidden" value="http://axschema.org/namePerson/first" />', '<input name="openid.ax.required" type="hidden" ' 'value="email,fullname,old_email,firstname,old_nickname,lastname,old_fullname,nickname" />', '<input name="openid.ax.type.nickname" ' 'type="hidden" value="http://axschema.org/namePerson/friendly" />', '<input name="openid.ax.type.old_email" ' 'type="hidden" value="http://schema.openid.net/contact/email" />', '<input name="openid.ax.type.old_nickname" ' 'type="hidden" value="http://schema.openid.net/namePerson/friendly" />', '<input name="openid.ax.type.old_fullname" ' 'type="hidden" value="http://schema.openid.net/namePerson" />', '<input name="openid.identity" ' 'type="hidden" value="http://specs.openid.net/auth/2.0/identifier_select" />', '<input name="openid.claimed_id" ' 'type="hidden" value="http://specs.openid.net/auth/2.0/identifier_select" />', # should work on the test server as well '<input name="openid.realm" ' 'type="hidden" value="http://testserver/" />', ): self.assertContains(resp, expected_input, html=True)
def request(self, **request): """Construct a generic request object.""" request = RequestFactory.request(self, **request) handler = BaseHandler() handler.load_middleware() for middleware_method in handler._request_middleware: if middleware_method(request): raise Exception("Couldn't create request mock object - " "request middleware returned a response") return request
def request(self, **request): # https://gist.github.com/tschellenbach/925270 request = RequestFactory.request(self, **request) handler = BaseHandler() handler.load_middleware() for middleware_method in handler._request_middleware: if middleware_method(request): raise Exception("Couldn't create request mock object - " "request middleware returned a response") return request
def request(self, **request): #https://gist.github.com/tschellenbach/925270 request = RequestFactory.request(self, **request) handler = BaseHandler() handler.load_middleware() for middleware_method in handler._request_middleware: if middleware_method(request): raise Exception("Couldn't create request mock object - " "request middleware returned a response") return request
def request(self, **request_args): """Constructs a generic request object, INCLUDING middleware modifications.""" from django.core import urlresolvers request = RequestFactory.request(self, **request_args) ###pprint.pprint(request) utilities.make_request_querydicts_mutable(request) request.session = DJANGO_TEST_CLIENT.session # hack # we mimick django authentication middleware from django.contrib.auth.models import AnonymousUser request.user = AnonymousUser() # default # we mimick messages middleware from django.contrib.messages.storage import default_storage request._messages = default_storage(request) # we mimick ZODB middleware datamanager = retrieve_game_instance( game_instance_id=TEST_GAME_INSTANCE_ID, request=request, update_timestamp=False) request.datamanager = datamanager # for template tags and the likes """ Old version, before Django2.0 middlewares handler = BaseHandler() handler.load_middleware() for middleware_method in handler._request_middleware: #print("APPLYING REQUEST MIDDLEWARE ", middleware_method, file=sys.stderr) if middleware_method(request): raise Exception("Couldn't create request mock object - " "request middleware returned a response") urlconf = settings.ROOT_URLCONF urlresolvers.set_urlconf(urlconf) resolver = urlresolvers.RegexURLResolver(r'^/', urlconf) callback, callback_args, callback_kwargs = resolver.resolve( request.path_info) # Apply view middleware for middleware_method in handler._view_middleware: #print("APPLYING VIEW MIDDLEWARE ", middleware_method, file=sys.stderr) response = middleware_method(request, callback, callback_args, callback_kwargs) if response: raise Exception("Couldn't create request mock object - " "view middleware returned a response") """ return request
def testensure_is_main_subdomain2(self): def view_func(request): "Dummy view function to decorate" return HttpResponse('hello') view_func = ensure_is_main_subdomain(view_func) rf = RequestFactory(subdomain = 'bar') request = rf.request() middleware = GetSubdomainMiddleware() middleware.process_request(request) response = view_func(request) self.assertEqual(HttpResponseRedirect, response.__class__)
def testpopulate_subdomain(self): user = User.objects.create_user(username = '******', password = '******', email = '*****@*****.**') subdomain = Subdomain.objects.register_new_subdomain(subdomain_text = 'foo5', name='Foo, the subdomain', description = 'Foo has not description', user = user) rf = RequestFactory(subdomain = 'foo5', main_site = False) request = rf.request() middleware = GetSubdomainMiddleware() middleware.process_request(request) context = populate_subdomain(request) self.assertEqual(context['subdomain_text'], 'testserver') self.assertEqual(context['main_site'], False) self.assertEqual(context['subdomain'], None)
def request(self, **request): request = RequestFactory.request(self, **request) handler = BaseHandler() handler.load_middleware() # call each middleware in turn and throw away any responses that they might return for middleware_path in settings.MIDDLEWARE: middleware = import_string(middleware_path)(handler) if hasattr(middleware, 'process_request'): middleware.process_request(request) return request
def test_get_querystring(self): from django_boost.templatetags.boost_url import get_querystring cases = [ ("", "q", None), ("q=q", "q", "q"), ("q=q&q=j&q=k", "q", "k"), ] factory = RequestFactory() for qs, key, value in cases: request = factory.request(**{'QUERY_STRING': qs}) self.assertEqual(get_querystring(request, key), value)
def CreatePreparedExistentEntityAuthRequest(): factory = RequestFactory() data = '[{"type":"dbModel.shape.DBTable","id":"465bf0b2-a50f-f6cb-fdf0-0cbf142d239b","x":20,"y":20,"width":99,"height":57.84375,"userData":{},"cssClass":"DBTable","bgColor":"#DBDDDE","color":"#D7D7D7","stroke":1,"alpha":1,"radius":3,"tableName":"TableName10","tablePorts":[],"attributes":[{"text":"new attribute0","id":"b3177ad1-b220-805e-e748-be12434e578d","datatype":"string","pk":true,"fk":false,"isRequired":true,"isNullable":false}]}]' auth = authenticate(username='******', password='******') request = factory.request() request._body = data request._get = {"projectID":1, "diagramID":1} request.user = auth return request
def request(self, **request): from django.core.handlers.base import BaseHandler "Construct a generic request object." request['REQUEST'] = dict() request = RequestFactory.request(self, **request) handler = BaseHandler() handler.load_middleware() for middleware_method in handler._request_middleware: if middleware_method(request): raise Exception("Couldn't create request mock object - " "request middleware returned a response") return request
def CreatePreparedExistentEntityAuthRequest(): factory = RequestFactory() data = '[{"type":"dbModel.shape.DBTable","id":"465bf0b2-a50f-f6cb-fdf0-0cbf142d239b","x":20,"y":20,"width":99,"height":57.84375,"userData":{},"cssClass":"DBTable","bgColor":"#DBDDDE","color":"#D7D7D7","stroke":1,"alpha":1,"radius":3,"tableName":"TableName10","tablePorts":[],"attributes":[{"text":"new attribute0","id":"b3177ad1-b220-805e-e748-be12434e578d","datatype":"string","pk":true,"fk":false,"isRequired":true,"isNullable":false}]}]' auth = authenticate(username='******', password='******') request = factory.request() request._body = data request._get = {"projectID": 1, "diagramID": 1} request.user = auth return request
class InvitationTests(TestCase): fixtures = ['users.json', 'orgs.json'] def setUp(self): mail.outbox = [] self.factory = RequestFactory() self.tokenizer = RegistrationTokenGenerator() self.user = User.objects.get(username="******") self.pending_user = User.objects.create_user(username="******", email="*****@*****.**", password="******") self.pending_user.is_active = False self.pending_user.save() def test_backend_definition(self): from organizations.backends import invitation_backend self.assertTrue(isinstance(invitation_backend(), InvitationBackend)) def test_create_user(self): invited = InvitationBackend().invite_by_email("*****@*****.**") self.assertTrue(isinstance(invited, User)) self.assertFalse(invited.is_active) self.assertEqual(1, len(mail.outbox)) mail.outbox = [] def test_create_existing_user(self): invited = InvitationBackend().invite_by_email(self.user.email) self.assertEqual(self.user, invited) self.assertEqual(0, len(mail.outbox)) # User is active def test_send_reminder(self): InvitationBackend().send_reminder(self.pending_user) self.assertEqual(1, len(mail.outbox)) InvitationBackend().send_reminder(self.user) self.assertEqual(1, len(mail.outbox)) # User is active mail.outbox = [] def test_urls(self): """Ensure no error is raised""" reverse('invitations_register', kwargs={ 'user_id': self.pending_user.id, 'token': self.tokenizer.make_token(self.pending_user)}) def test_activate_user(self): request = self.factory.request() with self.assertRaises(Http404): InvitationBackend().activate_view(request, self.user.id, self.tokenizer.make_token(self.user)) self.assertEqual(200, InvitationBackend().activate_view(request, self.pending_user.id, self.tokenizer.make_token( self.pending_user)).status_code)
def testensure_has_subdomain2(self): def view_func(request): "Dummy view function to decorate" return HttpResponse('hello') view_func = ensure_has_subdomain(view_func) user = User.objects.create_user(username = '******', password = '******', email = '*****@*****.**') subdomain = Subdomain.objects.register_new_subdomain(subdomain_text = 'foo7', name='Foo, the subdomain', description = 'Foo has not description', user = user) rf = RequestFactory(subdomain = 'doesnotexistxx') request = rf.request() middleware = GetSubdomainMiddleware() middleware.process_request(request) response = view_func(request) self.assertEqual(HttpResponseRedirect, response.__class__)
def request(self, **request): "Construct a generic request object." request = RequestFactory.request(self, **request) handler = BaseHandler() handler.load_middleware() # BaseHandler_request_middleware is not set in Django2.0 # and removed in Django2.1 if sys.version_info[0] < 2: for middleware_method in handler._request_middleware: if middleware_method(request): raise Exception("Couldn't create request mock object - " "request middleware returned a response") return request
class SignupViewTestCase(unittest.TestCase): def setUp(self): self.factory = RequestFactory() def test_get(self): request = self.factory.get(reverse("account_signup")) request.user = AnonymousUser() response = SignupEnabledView.as_view()(request) self.assertEqual(response.status_code, 200) def test_get_disabled(self): request = self.factory.get(reverse("account_signup")) request.user = AnonymousUser() response = SignupDisabledView.as_view()(request) self.assertEqual(response.status_code, 200) self.assertEqual(response.template_name, "account/signup_closed.html") def test_post_disabled(self): request = self.factory.post(reverse("account_signup")) request.user = AnonymousUser() response = SignupDisabledView.as_view()(request) self.assertEqual(response.status_code, 200) self.assertEqual(response.template_name, "account/signup_closed.html") def test_post_successful(self): post = { "username": "******", "password": "******", "password_confirm": "pwd", "email": "*****@*****.**" } request = self.factory.post(reverse("account_signup"), post) request.user = AnonymousUser() response = SignupEnabledView.as_view()(request) self.assertEqual(response.status_code, 302) user = User.objects.get(username="******") self.asserEqual(user.email, "*****@*****.**") def test_custom_redirect_field(self): request = self.factory.request() request.GET = {"next_page": "/profile/"} form = SignupForm({ "username": "******", "password": "******", "password_confirm": "password", "email": "*****@*****.**", }) view = SignupRedirectView(request=request, redirect_field_name="next_page") self.assertEqual("/profile/", view.form_valid(form)["Location"])
def test_basic_cookie_monitoring(self, mock_set_custom_attribute, mock_capture_cookie_sizes): mock_capture_cookie_sizes.is_enabled.return_value = False middleware = CookieMonitoringMiddleware() cookies_dict = {'a': 'b'} factory = RequestFactory() for name, value in cookies_dict.items(): factory.cookies[name] = value mock_request = factory.request() middleware.process_request(mock_request) mock_set_custom_attribute.assert_called_once_with('cookies.header.size', 3)
def _send_bad_redirection_login(self): """ Attempt to log in to the provider with setup parameters Intentionally fail the login to force a redirect """ user = UserFactory() factory = RequestFactory() post_params = {"email": user.email, "password": "******"} fake_url = "fake url" request = factory.post(reverse("openid-provider-login"), post_params) openid_setup = {"request": factory.request(), "url": fake_url, "post_params": {}} request.session = {"openid_setup": openid_setup} response = provider_login(request) return response
class TestElasticstack(TestCase): def setUp(self): self.factory = RequestFactory() def test_form_kwargs(self): """Ensure request data updates the form kwargs""" request = self.factory.request() request.GET = {'q': "whoami"} mixin = views.SearchMixin() mixin.request = request mixin.queryset = [] # An EmptySearchQuerySet is basically an empty list self.assertEqual(mixin.get_form_kwargs(), {'initial': {}, 'data': request.GET, 'searchqueryset': []})
def simulate_login(username, password, headers=None): rf = RequestFactory() request = rf.request(**headers) engine = import_module(settings.SESSION_ENGINE) request.session = engine.SessionStore() # TODO remove when we don't support Django 1.10 anymore # request passed in to authenticate only after Django 1.10 # Also the middleware saving the request to thread local can be dropped try: user = authenticate(request, username=username, password=password) except TypeError: middleware.thread_data.request = request user = authenticate(username=username, password=password) if user: login(request, user)
def _send_bad_redirection_login(self): """ Attempt to log in to the provider with setup parameters Intentionally fail the login to force a redirect """ user = UserFactory() factory = RequestFactory() post_params = {'email': user.email, 'password': '******'} fake_url = 'fake url' request = factory.post(reverse('openid-provider-login'), post_params) openid_setup = {'request': factory.request(), 'url': fake_url} request.session = {'openid_setup': openid_setup} response = provider_login(request) return response
class SignupViewTestCase(unittest.TestCase): def setUp(self): self.factory = RequestFactory() def test_get(self): request = self.factory.get(reverse("account_signup")) request.user = AnonymousUser() response = SignupEnabledView.as_view()(request) self.assertEqual(response.status_code, 200) def test_get_disabled(self): request = self.factory.get(reverse("account_signup")) request.user = AnonymousUser() response = SignupDisabledView.as_view()(request) self.assertEqual(response.status_code, 200) self.assertEqual(response.template_name, "account/signup_closed.html") def test_post_disabled(self): request = self.factory.post(reverse("account_signup")) request.user = AnonymousUser() response = SignupDisabledView.as_view()(request) self.assertEqual(response.status_code, 200) self.assertEqual(response.template_name, "account/signup_closed.html") def test_post_successful(self): post = {"username": "******", "password": "******", "password_confirm": "pwd", "email": "*****@*****.**"} request = self.factory.post(reverse("account_signup"), post) request.user = AnonymousUser() response = SignupEnabledView.as_view()(request) self.assertEqual(response.status_code, 302) user = User.objects.get(username="******") self.asserEqual(user.email, "*****@*****.**") def test_custom_redirect_field(self): request = self.factory.request() request.GET = {"next_page": "/profile/"} form = SignupForm({ "username": "******", "password": "******", "password_confirm": "password", "email": "*****@*****.**", }) view = SignupRedirectView(request=request, redirect_field_name="next_page") form.is_valid() self.assertEqual("/profile/", view.form_valid(form)["Location"])
def test_begin_login(self): # the provider URL must be converted to an absolute URL in order to be # used as an openid provider. provider_url = reverse('openid-provider-xrds') factory = RequestFactory() request = factory.request() abs_provider_url = request.build_absolute_uri(location=provider_url) # now we can begin the login process by invoking a local openid client, # with a pointer to the (also-local) openid provider: with self.settings(OPENID_SSO_SERVER_URL=abs_provider_url): url = reverse('openid-login') resp = self.client.post(url) code = 200 self.assertEqual(resp.status_code, code, "got code {0} for url '{1}'. Expected code {2}" .format(resp.status_code, url, code))
def testBeginLoginWithLoginUrl(self): # skip the test if openid is not enabled (as in cms.envs.test): if not settings.MITX_FEATURES.get('AUTH_USE_OPENID') or not settings.MITX_FEATURES.get('AUTH_USE_OPENID_PROVIDER'): return # the provider URL must be converted to an absolute URL in order to be # used as an openid provider. provider_url = reverse('openid-provider-login') factory = RequestFactory() request = factory.request() abs_provider_url = request.build_absolute_uri(location=provider_url) # In order for this absolute URL to work (i.e. to get xrds, then authentication) # in the test environment, we either need a live server that works with the default # fetcher (i.e. urlopen2), or a test server that is reached through a custom fetcher. # Here we do the latter: fetcher = MyFetcher(self.client) openid.fetchers.setDefaultFetcher(fetcher, wrap_exceptions=False) # now we can begin the login process by invoking a local openid client, # with a pointer to the (also-local) openid provider: with self.settings(OPENID_SSO_SERVER_URL=abs_provider_url): url = reverse('openid-login') resp = self.client.post(url) code = 200 self.assertEqual(resp.status_code, code, "got code {0} for url '{1}'. Expected code {2}" .format(resp.status_code, url, code)) self.assertContains(resp, '<input name="openid.mode" type="hidden" value="checkid_setup" />', html=True) self.assertContains(resp, '<input name="openid.ns" type="hidden" value="http://specs.openid.net/auth/2.0" />', html=True) self.assertContains(resp, '<input name="openid.identity" type="hidden" value="http://specs.openid.net/auth/2.0/identifier_select" />', html=True) self.assertContains(resp, '<input name="openid.claimed_id" type="hidden" value="http://specs.openid.net/auth/2.0/identifier_select" />', html=True) self.assertContains(resp, '<input name="openid.ns.ax" type="hidden" value="http://openid.net/srv/ax/1.0" />', html=True) self.assertContains(resp, '<input name="openid.ax.mode" type="hidden" value="fetch_request" />', html=True) self.assertContains(resp, '<input name="openid.ax.required" type="hidden" value="email,fullname,old_email,firstname,old_nickname,lastname,old_fullname,nickname" />', html=True) self.assertContains(resp, '<input name="openid.ax.type.fullname" type="hidden" value="http://axschema.org/namePerson" />', html=True) self.assertContains(resp, '<input name="openid.ax.type.lastname" type="hidden" value="http://axschema.org/namePerson/last" />', html=True) self.assertContains(resp, '<input name="openid.ax.type.firstname" type="hidden" value="http://axschema.org/namePerson/first" />', html=True) self.assertContains(resp, '<input name="openid.ax.type.nickname" type="hidden" value="http://axschema.org/namePerson/friendly" />', html=True) self.assertContains(resp, '<input name="openid.ax.type.email" type="hidden" value="http://axschema.org/contact/email" />', html=True) self.assertContains(resp, '<input name="openid.ax.type.old_email" type="hidden" value="http://schema.openid.net/contact/email" />', html=True) self.assertContains(resp, '<input name="openid.ax.type.old_nickname" type="hidden" value="http://schema.openid.net/namePerson/friendly" />', html=True) self.assertContains(resp, '<input name="openid.ax.type.old_fullname" type="hidden" value="http://schema.openid.net/namePerson" />', html=True) self.assertContains(resp, '<input type="submit" value="Continue" />', html=True) # this should work on the server: self.assertContains(resp, '<input name="openid.realm" type="hidden" value="http://testserver/" />', html=True)
def test_log_encrypted_cookies_no_key(self, mock_encrypt, mock_capture_cookie_sizes): middleware = CookieMonitoringMiddleware() cookies_dict = { "a": "." * 10, "b": "." * 15, } factory = RequestFactory() for name, value in cookies_dict.items(): factory.cookies[name] = value mock_request = factory.request() middleware.process_request(mock_request) mock_encrypt.assert_not_called()
class TestElasticstack(TestCase): def setUp(self): self.factory = RequestFactory() def test_form_kwargs(self): """Ensure request data updates the form kwargs""" request = self.factory.request() request.GET = {"q": "whoami"} mixin = views.SearchMixin() mixin.request = request mixin.queryset = [] # An EmptySearchQuerySet is basically an empty list self.assertEqual( mixin.get_form_kwargs(), {"initial": {}, "data": request.GET, "searchqueryset": []}, )
def test_log_encrypted_cookies(self, mock_encrypt, mock_capture_cookie_sizes): middleware = CookieMonitoringMiddleware() cookies_dict = { "a": "." * 10, "b": "." * 15, } factory = RequestFactory() for name, value in cookies_dict.items(): factory.cookies[name] = value mock_request = factory.request() cookie_header = str(mock_request.META.get('HTTP_COOKIE', '')) middleware.process_request(mock_request) mock_encrypt.assert_has_calls([call(cookie_header, "fake-key")])
def testBeginLogin(self): # skip the test if openid is not enabled (as in cms.envs.test): if not settings.MITX_FEATURES.get('AUTH_USE_OPENID') or not settings.MITX_FEATURES.get('AUTH_USE_OPENID_PROVIDER'): return # the provider URL must be converted to an absolute URL in order to be # used as an openid provider. provider_url = reverse('openid-provider-xrds') factory = RequestFactory() request = factory.request() abs_provider_url = request.build_absolute_uri(location=provider_url) # now we can begin the login process by invoking a local openid client, # with a pointer to the (also-local) openid provider: with self.settings(OPENID_SSO_SERVER_URL=abs_provider_url): url = reverse('openid-login') resp = self.client.post(url) code = 200 self.assertEqual(resp.status_code, code, "got code {0} for url '{1}'. Expected code {2}" .format(resp.status_code, url, code))
def _send_bad_redirection_login(self): """ Attempt to log in to the provider with setup parameters Intentionally fail the login to force a redirect """ user = UserFactory() factory = RequestFactory() post_params = {'email': user.email, 'password': '******'} fake_url = 'fake url' request = factory.post(reverse('openid-provider-login'), post_params) openid_setup = { 'request': factory.request(), 'url': fake_url } request.session = { 'openid_setup': openid_setup } response = provider_login(request) return response
def test_safe_get_host(self): """ Tests that the safe_get_host function returns the desired host """ settings.SITE_NAME = 'siteName.com' factory = RequestFactory() request = factory.request() request.META['HTTP_HOST'] = 'www.userProvidedHost.com' # If ALLOWED_HOSTS is not set properly, safe_get_host should return SITE_NAME settings.ALLOWED_HOSTS = None self.assertEqual(safe_get_host(request), "siteName.com") settings.ALLOWED_HOSTS = ["*"] self.assertEqual(safe_get_host(request), "siteName.com") settings.ALLOWED_HOSTS = ["foo.com", "*"] self.assertEqual(safe_get_host(request), "siteName.com") # If ALLOWED_HOSTS is set properly, and the host is valid, we just return the user-provided host settings.ALLOWED_HOSTS = [request.META['HTTP_HOST']] self.assertEqual(safe_get_host(request), request.META['HTTP_HOST']) # If ALLOWED_HOSTS is set properly but the host is invalid, we should get a SuspiciousOperation settings.ALLOWED_HOSTS = ["the_valid_website.com"] with self.assertRaises(SuspiciousOperation): safe_get_host(request)
def test_context_processor(self): f = RequestFactory() c = RequestContext(f.request()) self.assertTrue(c.get('settings') is settings)
def request(self, path, action, data=None): """ Make an internal API request. """ # Make sure an API user and token are defined if not self.api_user or not self.api_token: return self.log.error('Failed to make API request, API user and/or token not set') # Define the full endpoint endpoint = '%s/%s' % (path, action) # If data is supplied, make sure it is valid if data and not isinstance(data, dict): return self.log.error('Failed to make API request, request data must be in dictionary format') # Make sure the endpoint is valid if not endpoint in self.endpoints: return self.log.error('Failed to make API request, endpoint not found: %s/%s' % (path, action)) # Log the request details self.log.info('Submitting API request: endpoint=%s, api_user=%s, data=%s' % (endpoint, self.api_user, ('None' if not data else json.dumps(data)))) # Attempt to construct a new request object try: # Define the request defaults defaults = { 'REQUEST_METHOD': self.endpoints[endpoint]['method'], 'SERVER_NAME': self.conf.server.host, 'PATH_INFO': '/%s' % path, 'REQUEST_URI': '/cloudscape-api/%s' % path, 'SCRIPT_NAME': '/cloudscape-api', 'SERVER_PORT': '10550', 'CONTENT_TYPE': 'application/json' } # Create a new instance of the request factory rf = RequestFactory(**defaults) # Construct the request object request_obj = rf.request() # Define the request body body = { 'api_user': self.api_user, 'api_token': self.api_token, 'api_group': self.api_group, 'action': action } # If any request data if data: body['_data'] = data # Set the request body request_obj._body = json.dumps(body) # Critical error when constructing request object except Exception as e: self.log.exception('Failed to construct request object: %s' % str(e)) # Dispatch the request and get the response response = parse_response(request.dispatch(request_obj)) # Load the response body def load_body(body): try: return json.loads(body) except: return body # Return the response return { 'code': response['code'], 'body': load_body(response['body']) }
def testGetSubdomainMiddleware1(self): "Test GetSubdomainMiddleware.process_request succeds without exceptions on a request." rf = RequestFactory(subdomain = 'foo') request = rf.request() middleware = GetSubdomainMiddleware() middleware.process_request(request)