def testResubmitProposal(self): """Tests that a proposal is successfully resubmitted if possible.""" old_number_of_proposals = self.profile.student_data.number_of_proposals self.kwargs = { 'sponsor': self.sponsor.link_id, 'program': self.program.program_id, 'user': self.profile.profile_id, 'id': self.proposal.key().id() } request = http.HttpRequest() data = request_data.RequestData(request, None, self.kwargs) handler = proposal_review_view.ResubmitProposalHandler(None) with mock.patch.object(proposal_logic, 'canProposalBeResubmitted', return_value=True): response = handler.handle(data, None, None) self.assertEqual(response.status_code, httplib.OK) # check that the proposal is withdrawn proposal = GSoCProposal.all().get() self.assertEqual(proposal.status, proposal_model.STATUS_PENDING) # check that number of proposals is updated profile = self.profile.key.get() self.assertEqual(old_number_of_proposals, profile.student_data.number_of_proposals - 1)
def test_get_allowed_origin_is_string(self): middleware = self.load_middleware() request = http.HttpRequest() allowed_origin = middleware._get_allowed_origin(request) self.assertEqual(allowed_origin, 'localhost:8080')
def testEmailIsSent(self): """Tests that acceptance and rejection emails are sent.""" # seed a couple of organization administrators for both organizations addresses_for_accept_email = [] addresses_for_reject_email = [] for _ in range(_NUMBER_OF_ORG_ADMINS): profile = profile_utils.seedNDBProfile( self.program.key(), admin_for=[self.pre_accepted_org.key]) addresses_for_accept_email.append(profile.contact.email) profile = profile_utils.seedNDBProfile( self.program.key(), admin_for=[self.pre_rejected_org.key]) addresses_for_reject_email.append(profile.contact.email) # finalize decision and execute all MapReduce jobs kwargs = { 'sponsor': self.sponsor.key().name(), 'program': self.program.program_id, } request = http.HttpRequest() data = request_data.RequestData(request, None, kwargs) handler = org_app_view.ApplyOrgAdmissionDecisionHandler(_MockView()) handler.handle(data, None, None) self.executeMapReduceJobs() # check that emails have been sent for email_address in addresses_for_accept_email: self.assertEmailSent(bcc=email_address) for email_address in addresses_for_reject_email: self.assertEmailSent(bcc=email_address)
def test_response_without_messages(self): """ MessageMiddleware is tolerant of messages not existing on request. """ request = http.HttpRequest() response = http.HttpResponse() self.middleware.process_response(request, response)
def test_update_user_pin_unlock(self, client): email = '*****@*****.**' req = http.HttpRequest() req.session = {'last_pin_success': datetime.now()} user = get_uuid(email) eq_(set_user(req, email), user) assert req.session['last_pin_success'] is None
def default_prefixer(sender, **kwargs): """Make sure each test starts with a default URL prefixer.""" request = http.HttpRequest() request.META['SCRIPT_NAME'] = '' prefixer = urlresolvers.Prefixer(request) prefixer.locale = settings.LANGUAGE_CODE urlresolvers.set_url_prefix(prefixer)
def as_request(self): assert self.request_data, 'Could not construct an empty TestCase object' request = http.HttpRequest() data = self.request_data_dict request.path = data['path'] request.method = data['method'] request.path_info = data['path_info'] request._body = data['body'] request.META = data['headers'] request._encoding = data['encoding'] request._stream = StringIO() request._read_started = False request._post_parse_error = False request.resolver_match = None request._load_post_and_files() query_string = '%s&%s=1' % (data['query_string'], TEST_REQUEST_PARAM) request.GET = http.QueryDict(query_string, encoding=request.encoding) request.POST = getattr(request, '_post') request.FILES = getattr(request, '_files') request.COOKIES = http.parse_cookie( request.META.get('HTTP_COOKIE', b'')) request.REQUEST = datastructures.MergeDict(request.POST, request.GET) # extra attributes added by middlewares from django.contrib.auth.middleware import get_user engine = import_module(settings.SESSION_ENGINE) request.session = engine.SessionStore( request.COOKIES.get(settings.SESSION_COOKIE_NAME, None)) request.user = SimpleLazyObject(lambda: get_user(request)) return request
def test_timezone(self): import datetime http_request = http.HttpRequest() self.executed = False td = datetime.timedelta(hours=-5) now = datetime.datetime.utcnow() def echo(d): self.assertEqual(d, now + td) self.executed = True return d gw = django.DjangoGateway({'test.test': echo}, timezone_offset=-18000, expose_request=False) msg = remoting.Envelope(amfVersion=pyamf.AMF0) msg['/1'] = remoting.Request(target='test.test', body=[now]) http_request.method = 'POST' http_request.raw_post_data = remoting.encode(msg).getvalue() res = remoting.decode(gw(http_request).content) self.assertTrue(self.executed) self.assertEqual(res['/1'].body, now)
def clean_content(self): content = self.cleaned_data['content'] if not content and self.cleaned_data['is_custom']: template_name = self.cleaned_data['template_name'] for template_loader in loader.template_source_loaders: try: content = template_loader.load_template_source( template_name)[0] break except Exception: continue if django_version() >= '1.5': from django.test.client import RequestFactory request = RequestFactory().get('/') else: request = http.HttpRequest() request.session = {} context = template.RequestContext(request, { 'page_slug': self.instance.title, 'page': self.instance }) if content: try: template.Template(content).render(context) except Exception: import traceback traceback.print_exc() raise forms.ValidationError(_("Template error detected")) return content
def test_really_bad_decode(self): self.old_method = remoting.decode remoting.decode = lambda *args, **kwargs: self._raiseException( Exception, *args, **kwargs) http_request = http.HttpRequest() http_request.method = 'POST' http_request.raw_post_data = '' gw = django.DjangoGateway() try: http_response = gw(http_request) except: remoting.decode = self.old_method raise remoting.decode = self.old_method self.assertTrue(isinstance(http_response, http.HttpResponseServerError)) self.assertEqual(http_response.status_code, 500) self.assertEqual( http_response.content, '500 Internal Server Error\n\nAn unexpected error occurred.')
def test_get(self): storage = UserMessagesStorage(http.HttpRequest()) storage.request.user = self.user self.user.message_set.create(message='test message') self.assertEqual(len(storage), 1) self.assertEqual(list(storage)[0].message, 'test message')
def testOrganizationStatusIsUpdated(self): """Tests that organization admission decisions are applied correctly.""" kwargs = { 'sponsor': self.sponsor.key().name(), 'program': self.program.program_id, } request = http.HttpRequest() data = request_data.RequestData(request, None, kwargs) handler = org_app_view.ApplyOrgAdmissionDecisionHandler(_MockView()) handler.handle(data, None, None) self.executeMapReduceJobs() # check that status have been changed for pre_accepted and pre_rejected orgs self.assertEqual( self.pre_accepted_org.key.get().status, org_model.Status.ACCEPTED) self.assertEqual( self.pre_rejected_org.key.get().status, org_model.Status.REJECTED) # check that status for other orgs have not changed self.assertEqual( self.accepted_org.key.get().status, org_model.Status.ACCEPTED) self.assertEqual( self.rejected_org.key.get().status, org_model.Status.REJECTED) self.assertEqual( self.applying_org.key.get().status, org_model.Status.APPLYING)
def setUp(self): self.mox = mox.Mox() self.factory = RequestFactoryWithMessages() def fake_conn_request(*args, **kwargs): raise Exception("An external URI request tried to escape through " "an httplib2 client. Args: %s, kwargs: %s" % (args, kwargs)) self._real_conn_request = httplib2.Http._conn_request httplib2.Http._conn_request = fake_conn_request self._real_horizon_context_processor = context_processors.horizon context_processors.horizon = lambda request: self.TEST_CONTEXT self._real_get_user_from_request = users.get_user_from_request tenants = self.TEST_CONTEXT['authorized_tenants'] self.setActiveUser(token=self.TEST_TOKEN, username=self.TEST_USER, tenant_id=self.TEST_TENANT, service_catalog=self.TEST_SERVICE_CATALOG, authorized_tenants=tenants) self.request = http.HttpRequest() self.request.session = self.client._session() middleware.HorizonMiddleware().process_request(self.request)
def setUp(self): self.request = http.HttpRequest() self.request.session = { 'uuid': 'some uuid', 'uuid_has_pin': True, 'uuid_has_confirmed_pin': True }
def setUp(self): mock_user = user.User(id=1, roles=self._roles) patcher = mock.patch('openstack_auth.utils.get_user', return_value=mock_user) self.MockClass = patcher.start() self.addCleanup(patcher.stop) self.request = http.HttpRequest()
def setUp(self): load_test_data(self) self.mox = mox.Mox() self.factory = RequestFactoryWithMessages() self.context = {'authorized_tenants': self.tenants.list()} def fake_conn_request(*args, **kwargs): raise Exception("An external URI request tried to escape through " "an httplib2 client. Args: %s, kwargs: %s" % (args, kwargs)) self._real_conn_request = httplib2.Http._conn_request httplib2.Http._conn_request = fake_conn_request self._real_horizon_context_processor = context_processors.horizon context_processors.horizon = lambda request: self.context self._real_get_user = utils.get_user tenants = self.context['authorized_tenants'] self.setActiveUser(id=self.user.id, token=self.token, username=self.user.name, tenant_id=self.tenant.id, service_catalog=self.service_catalog, authorized_tenants=tenants) self.request = http.HttpRequest() self.request.session = self.client._session() self.request.session['token'] = self.token.id middleware.HorizonMiddleware().process_request(self.request) AuthenticationMiddleware().process_request(self.request) os.environ["HORIZON_TEST_RUN"] = "True"
def test_get_current_user(self): # Set up a test user. email = '*****@*****.**' user = User(email=email) user.save() # Create some security tokens. expired_token = auth._create_security_token(user) self.now += 0.75 * auth._TOKEN_TIMEOUT_S stale_token = auth._create_security_token(user) self.now += 0.75 * auth._TOKEN_TIMEOUT_S good_token = auth._create_security_token(user) # Create a test HttpRequest, and test using it against our # various tokens. request = http.HttpRequest() request.COOKIES[auth._CHIRP_SECURITY_TOKEN_COOKIE] = expired_token self.assertEqual(None, auth.get_current_user(request)) request.COOKIES[auth._CHIRP_SECURITY_TOKEN_COOKIE] = stale_token user = auth.get_current_user(request) self.assertEqual(email, user.email) self.assertTrue(user._credentials.security_token_is_stale) request.COOKIES[auth._CHIRP_SECURITY_TOKEN_COOKIE] = good_token user = auth.get_current_user(request) self.assertEqual(email, user.email) self.assertFalse(user._credentials.security_token_is_stale) # Test that a password reset token can be used to authenticate # when POSTed in a variable named CHIRP_Auth. request = http.HttpRequest() request.method = "POST" self.assertEqual(None, auth.get_current_user(request)) request.POST["CHIRP_Auth"] = base64.urlsafe_b64encode(expired_token) self.assertEqual(None, auth.get_current_user(request)) request.POST["CHIRP_Auth"] = "bogus!!!" self.assertEqual(None, auth.get_current_user(request)) request.POST["CHIRP_Auth"] = base64.urlsafe_b64encode(good_token) user = auth.get_current_user(request) self.assertEqual(email, user.email) # Check that we will reject an inactive user. user.is_active = False user.save() self.assertRaises(auth.UserNotAllowedError, auth.get_current_user, request) user.is_active = True user.save()
def setUp(self): self.mox = mox.Mox() self._real_get_user_from_request = keystone.get_user_from_request self.setActiveUser(self.TEST_TOKEN, self.TEST_USER, self.TEST_TENANT, True, self.TEST_SERVICE_CATALOG) self.request = http.HttpRequest() keystone.AuthenticationMiddleware().process_request(self.request)
def test_get_allowed_origin_is_list(self): middleware = self.load_middleware() request = http.HttpRequest() request.META['HTTP_ORIGIN'] = 'localhost:9090' allowed_origin = middleware._get_allowed_origin(request) self.assertEqual(allowed_origin, 'localhost:9090')
def test_process_request(self): pre_handler = CookiePreHandlerMiddleware() request = http.HttpRequest() request.COOKIES['cookie1'] = 'cookie_value1' pre_handler.process_request(request) self.assertEquals('cookie_value1', request.COOKIES.get('cookie1'))
def default_prefixer(): """Make sure each test starts with a default URL prefixer.""" request = http.HttpRequest() request.META['SCRIPT_NAME'] = '' prefixer = amo.urlresolvers.Prefixer(request) prefixer.app = settings.DEFAULT_APP prefixer.locale = settings.LANGUAGE_CODE amo.urlresolvers.set_url_prefix(prefixer)
def test_request_method(self): gw = django.DjangoGateway() http_request = http.HttpRequest() http_request.method = 'GET' http_response = gw(http_request) self.assertEqual(http_response.status_code, 405)
def test_get_allowed_origin_lambda_return_false(self): middleware = self.load_middleware() request = http.HttpRequest() request.META['HTTP_ORIGIN'] = 'localhost:9999' allowed_origin = middleware._get_allowed_origin(request) self.assertEqual(allowed_origin, '')
def test_process_template_response_with_error(self): """ The middleware should NOT process error responses. """ response = http.HttpResponseServerError() request = http.HttpRequest() response = self.middleware.process_template_response(request, response) self.assertFalse(hasattr(response, 'context_data'))
def test_simple(django_assert_num_queries): reporter1 = models.Reporter.objects.create( first_name='reporter1', ) reporter2 = models.Reporter.objects.create( first_name='reporter2', ) class Reporter(gdtools.Resolver): schema = { 'type': {'first_name': 'String!'}, } model = models.Reporter class GetReporter(gdtools.Resolver): schema = { 'args': { 'id': 'ID' }, 'type': 'Reporter' } def resolve(self, **kwargs): return self.resolve_gid(kwargs['id']) class Query(graphene.ObjectType): get_reporter = GetReporter.as_field() schema = graphene.Schema( query=Query, ) with django_assert_num_queries(1): result = schema.execute( '''\ query getReporters($id1: ID, $id2: ID){ reporter1: getReporter(id: $id1) { firstName } reporter2: getReporter(id: $id2) { firstName } } ''', context=http.HttpRequest(), variables={ 'id1': gdtools.GlobalID.from_object(reporter1), 'id2': gdtools.GlobalID.from_object(reporter2), } ) assert not result.errors assert result.data == { 'reporter1': { 'firstName': 'reporter1' }, 'reporter2': { 'firstName': 'reporter2' } }
def test_create_new_user_has_permission(self): http_request = http.HttpRequest() http_request.method = api_util.HTTPMethod.POST.name rest_request = request.Request(http_request) expected_permission = self.user_permissions.has_permission( request=rest_request) self.assertTrue(expected_permission)
def test_get_user_fails_no_authentication(self): http_request = http.HttpRequest() http_request.method = api_util.HTTPMethod.GET rest_request = request.Request(http_request) expected_permission = self.user_permissions.has_permission( request=rest_request) self.assertFalse(expected_permission)
def testInitializer(self): """Tests that per-request objects are created.""" request = http.HttpRequest() data, check, mutator = initialize.MELANGE_INITIALIZER.initialize( request, [], {}) self.assertEqual(request, data.request) self.assertEqual(data, check.data) self.assertEqual(data, mutator.data)
def test_response_without_notifications(self): """ A higher middleware layer may return a request directly before notifications get applied, so the response middleware is tolerant of notifications not existing on request. """ request = http.HttpRequest() response = http.HttpResponse() self.middleware.process_response(request, response)
def test_search_no_permission(self): http_request = http.HttpRequest() http_request.method = api_util.HTTPMethod.POST.name rest_request = request.Request(http_request) expected_permission = self.search_permission.has_permission( request=rest_request) self.assertFalse(expected_permission)