def test_error_view(self): from application.views import error from django.template import RequestContext, Context request = MagicMock() request.method(return_value='/x') # bad request error.bad_request(request) RequestContext.assert_called_with( request, ErrorViewModel(status=400, exception='Bad Request')) # permission denied error.permission_denied(request) RequestContext.assert_called_with( request, ErrorViewModel(status=403, exception='Permission Denied')) # page not found error.page_not_found(request) RequestContext.assert_called_with( request, ErrorViewModel(status=404, exception='%s Not Found' % request.path)) # method not allowed error.method_not_allowed(request) RequestContext.assert_called_with( request, ErrorViewModel(status=405, exception='%s Not Allowed' % request.method)) # server error error.server_error(request) Context.assert_called_with( ErrorViewModel(status=500, exception='這一定是宿命'))
def test_process(self): request = MagicMock() request.method = 'GET' step = SimpleStep(request) assert isinstance(step.process(), TemplateResponse) request.method = 'POST' assert step.process() is None
def test_process(self): request = MagicMock() request.method = 'GET' step = SimpleStep(request) self.assertEqual(type(step.process()), TemplateResponse) request.method = 'POST' self.assertEqual(step.process(), None)
def TestCommandParsing(self): request = MagicMock() request.path = "/test" request.query = "item1=value1" request.remote_ip = "1.2.3.4" request.method = "PUT" request.headers = { 'User': '******', 'Creation-Time': 'test_time', 'User-Agent': 'test_user_agent' } request.body="item2=value2&item2=value3&item2=value4" self.command = Command(request) self.assertEqual(self.command.command_name, 'test') self.assertEqual(self.command.command_type, 'PUT') self.assertEqual(self.command.has_param('item1'), True) self.assertEqual(self.command.has_param('item2'), True) self.assertEqual(self.command.has_param('item3'), False) self.assertEqual(self.command.get_param('item1'), 'value1') self.assertEqual('value2' in self.command.get_param('item2'), True) self.assertEqual('value3' in self.command.get_param('item2'), True) self.assertEqual('value4' in self.command.get_param('item2'), True) data = self.command.format_trace self.assertEqual(data['Username'], 'test_user') self.assertEqual(data['Created'], 'test_time') self.assertEqual(data['Source_Address'], '1.2.3.4') self.assertEqual(data['Source_ID'], 'test_user_agent')
def a_request(): request = MagicMock() request.method = "post" request.url = "http://{}.com".format(a_string()) request.headers = {a_string(): a_string()} request.body = a_string() return request
def _make_request( self, method, postpath, reqbody, resreadsreq, rescode, resbody): m_request = MagicMock(name='Request') m_request.method = method m_request.postpath = postpath if reqbody is None: readrv = '' elif reqbody == 'mangled JSON': readrv = reqbody else: readrv = json.dumps(reqbody, indent=2) m_request.content.read.return_value = readrv r = self.tar.render(m_request) self.assertEqual(r, server.NOT_DONE_YET) expected = [ call.setResponseCode(rescode), call.setHeader('Content-Type', 'application/json'), call.write(json.dumps(resbody, indent=2)), call.finish(), ] if resreadsreq: expected.insert(0, call.content.read()) check_mock(self, m_request, expected)
def assert_expire_in_extended(self, req_path, should_expire_in, should_extend, headers=None, query_string=None): request = MagicMock(path=req_path) request.method = "GET" request.user = MagicMock() request.user.is_authenticated.return_value = True thirty_mins_ago = (datetime.datetime.now() - datetime.timedelta(minutes=30)).strftime("%Y-%m-%dT%H:%M:%S.%f") request.session = {"_session_security": thirty_mins_ago} if headers: request.META = headers if query_string: request.REQUEST = query_string before_response = {} response = self.middleware.process_response(request, before_response) self.assertIsNotNone(response.get("Session-Expires-In")) self.assertIsAlmostEqualMinutes(response.get("Session-Expires-In"), should_expire_in - 30, delta=1.0) self.middleware.process_request(request) response2 = self.middleware.process_response(request, before_response) self.assertIsNotNone(response2.get("Session-Expires-In")) if should_extend: self.assertIsAlmostEqualMinutes(response.get("Session-Expires-In"), should_expire_in, delta=1.0) else: self.assertIsAlmostEqualMinutes(response.get("Session-Expires-In"), should_expire_in - 30, delta=1.0)
def test_sauthc1signer_query(self): # The plus sign in a url query must be replaced with %20 r = MagicMock() r.headers = {} r.url = 'https://api.stormpath.com/v1/directories?orderBy=name+asc' r.method = 'GET' r.body = None mock_dt = MagicMock() mock_dt.utcnow.return_value = datetime.datetime(2013, 7, 1, 0, 0, 0, 0) mock_uuid4 = MagicMock( return_value='a43a9d25-ab06-421e-8605-33fd1e760825') s = Sauthc1Signer(id='MyId', secret='Shush!') with patch('stormpath.auth.datetime', mock_dt): with patch('stormpath.auth.uuid4', mock_uuid4): r2 = s(r) self.assertEqual(r, r2) self.assertEqual( r.headers['Authorization'], 'SAuthc1 sauthc1Id=MyId/20130701/a43a9d25-ab06-421e-8605-33fd1e760825/sauthc1_request, ' + # noqa 'sauthc1SignedHeaders=host;x-stormpath-date, ' + 'sauthc1Signature=fc04c5187cc017bbdf9c0bb743a52a9487ccb91c0996267988ceae3f10314176' ) # noqa
def test_factory(self, mocked_get_item): data = deepcopy(TEST_AGREEMENT) agreement = MagicMock() agreement.id = data["agreementID"] agreement.title = "test_factory" request = MagicMock() request.url = "http://localhost/api/" + VERSION + "/agreements" request.matchdict = { "agreement_id": data["agreementID"], "document_id": "9a750db83cc64b34a879221513c13805" } request.agreement = agreement request.method = "POST" mocked_get_item.side_effect = ["test_item1", "test_item2"] res = factory(request) self.assertEqual(res, "test_item1") self.assertEqual(mocked_get_item.called, True) request.matchdict = { "agreement_id": data["agreementID"], "contract_id": "9a750db83cc64b34a879221513c13805" } res = factory(request) self.assertEqual(res, "test_item2") self.assertEqual(mocked_get_item.called, True) request.matchdict = {"agreement_id": data["agreementID"]} res = factory(request) self.assertEqual(res.id, data["agreementID"]) self.assertEqual(res.title, "test_factory")
def test_render_fail_disconnected(self): json = JSON() request = MagicMock() request.method = 'POST' request._disconnected = True # When disconnected, returns empty string self.assertEqual(json.render(request), '')
def test_unit_register_with_POST(self): """ We need to mock several things to make this unittest. 1. request 2. register_form() : For this, make seperate test. - request has **method** attribute that specifies the method of the form. 3. Need to mock RegisterForm because we are not testing the register function. - RegisterForm instance should have is_valid() method that returns boolean. 4. We need to mock HttpResponseRedirect. """ with patch('user_auth.views.RegisterForm') as form: with patch('user_auth.views.HttpResponseRedirect') as redir: request = MagicMock() request.method = "POST" ## this will pass if request.POST == "POST" part. request.POST = "some_input" form.return_value = Mock() form.return_value.is_valid = Mock(return_value=True) # mock register_form form.return_value.register_form = Mock(return_value=None) register(request) # make function call form.assert_called_with("some_input") # redir.assert_called_with('/') self.assertTrue(form.return_value.register_form.called)
def test_resolve_non_existing_endpoint(self): mock_http_request = MagicMock() mock_http_request.method = "DELETE" mock_api = MagicMock(spec_set=[]) action = action_resolver.resolve_action(mock_http_request, api=mock_api, url="foo") assert_that(action, equal_to(None))
def test_render_proc_ts(self): """ **test_render_proc_ts** * Test that items are grabbed correctly """ with patch('cr_hunt.views.add_hunt_its') as addf: with patch('cr_hunt.views.redirect') as red: request = MagicMock() request.method = "POST" def side_effect(*args): def second_call(*args): return 'test321' request.POST.get.side_effect = second_call return 'test123' request.POST.get = MagicMock(side_effect=side_effect) #request.POST.get('title', '').return_value = 'test123' #request.POST.get('start', '').return_value = 'test321' request.user = MagicMock() attrs = {'is_authenticated.return_value':True} request.user.configure_mock(**attrs) request.user.username = '******' views.render_proc_ts(request) assert addf.called addf.assert_called_with('111222', 'test123', 'test321', 'user1') assert red.called #test that redirect is called red.assert_called_with('cr_aitem') red.reset_mock() attrs = {'is_authenticated.return_value':False} request.user.configure_mock(**attrs) views.render_proc_ts(request) assert red.called red.assert_called_with('cr_error')
def test_unit_register_with_invalidPOST(self): """ This function tests the **register()** function with invalid post data. we should mock 1. request 2. RegisterForm - is_valid() 3. args """ with patch('user_auth.views.RegisterForm') as reg: request = MagicMock() request.method = "POST" request.POST = "some input" # make input to RegisterForm reg.return_value = Mock() reg.return_value.is_valid = Mock(return_value=False) # make it pass the if part. reg.return_value.register_form = Mock(return_value=None) with patch('user_auth.views.render_to_response') as render: render.return_value = "some value" register(request) # asserts reg.assert_called_with("some input") self.assertTrue(not reg.return_value.register_form.called) self.assertTrue(render.called)
def test_unit_login_user_with_post(self): """ This function tests **login_user()** with post data. We need to mock 1. request 2. LogInForm - is_valid - cleaned_data 3. authenticate - is_active 4. render_to_response """ with patch('user_auth.views.LogInForm') as form: request = MagicMock() request.method = "POST" request.POST = "some data" form.return_value = Mock() form.return_value.is_valid = Mock(return_value=True) form.return_value.login_process = Mock() with patch('user_auth.views.render_to_response') as render: login_user(request) form.return_value.login_process.assert_called_with(request) form.assert_called_with("some data") self.assertTrue(render.called)
def test_render_fail(self): json = JSON() request = MagicMock() request.method = 'POST' def compress(contents, request): return contents self.patch(deluge.ui.web.json_api, 'compress', compress) def write(response_str): request.write_was_called = True response = json_lib.loads(response_str) self.assertEqual(response['result'], None) self.assertEqual(response['id'], None) self.assertEqual( response['error']['message'], 'JSONException: JSON not decodable' ) self.assertEqual(response['error']['code'], 5) request.write = write request.write_was_called = False request._disconnected = False request.getHeader.return_value = 'application/json' self.assertEqual(json.render(request), server.NOT_DONE_YET) self.assertTrue(request.write_was_called)
def test_should_update_email_address_for_data_sender_and_send_mail(self): dbm = Mock(spec=DatabaseManager) request = MagicMock() request.POST = { 'post_data': json.dumps([{ 'email': 'data_sender_email', 'reporter_id': 'rep_id' }]) } request.method = 'POST' request.LANGUAGE_CODE = 'en' expected_contact_id_map = {'rep_id': 'data_sender_email'} contact = MagicMock(spec=Contact) contact.is_contact = False with patch('datawinners.entity.views.create_web_users' ) as create_web_users_mock: with patch('datawinners.entity.views.contact_by_short_code' ) as contact_by_short_code_mock: with patch('datawinners.entity.views.set_email_for_contact' ) as set_email_for_contact_mock: contact_by_short_code_mock.return_value = contact _set_email_for_contacts(dbm, 'org_id', request) self.assertFalse(set_email_for_contact_mock.called) create_web_users_mock.assert_called_with( 'org_id', expected_contact_id_map, 'en')
def test_process_response_works_not_logged_in(self): # this should not add header request = MagicMock(path="/") request.method = "GET" before_response = {} response = self.middleware.process_response(request, before_response) self.assertIsNone(response.get("Session-Expires-In"))
def test_upstream_xauth(self): req = MagicMock() req.headers = {} req.method = 'GET' req.path = '/v2/servers' req.env = {'REMOTE_USER': '******'} resp = MagicMock() validate_token(req, resp, {}) self.assertIsNone(req.env.get('auth'))
def test_resolve_non_existing_endpoint(self): mock_http_request = MagicMock() mock_http_request.method = 'DELETE' mock_api = MagicMock(spec_set=[]) action = action_resolver.resolve_action(mock_http_request, api=mock_api, url='foo') assert_that(action, equal_to(None))
def test_upstream_admin(self): req = MagicMock() req.headers = {} req.method = 'GET' req.path = '/v2/servers' req.env = {'is_admin': True} resp = MagicMock() validate_token(req, resp, {}) self.assertIsNone(req.env.get('auth'))
def test_resolve_non_existing_action_options(self): mock_http_request = MagicMock() mock_http_request.method = "OPTIONS" mock_api = MagicMock() mock_resource = object() mock_api.resolve_resource.return_value = mock_resource action = action_resolver.resolve_action(mock_http_request, api=mock_api, url="foo") assert_that(action, equal_to(None))
def test_resolve_post_on_list_as_create_detail(self): mock_http_request = MagicMock() mock_http_request.method = "POST" mock_api = MagicMock() mock_resource = MagicMock() mock_api.resolve_resource.return_value = mock_resource mock_resource.create_detail = expected_create_action = MagicMock() action = action_resolver.resolve_action(mock_http_request, api=mock_api, url="foo") assert_that(action, equal_to(expected_create_action))
def test_process_response_works_logged_in_but_without_session(self): # this should not add header request = MagicMock(path="/") request.method = "GET" request.user = MagicMock() request.user.is_authenticated.return_value = True before_response = {} response = self.middleware.process_response(request, before_response) self.assertIsNone(response.get("Session-Expires-In"))
def test_resolve_detail_action_on_api(self): mock_http_request = MagicMock() mock_http_request.method = "DELETE" mock_api = MagicMock() mock_resource = MagicMock() mock_api.resolve_resource.return_value = mock_resource mock_resource.delete_detail = expected_delete_action = MagicMock() action = action_resolver.resolve_action(mock_http_request, api=mock_api, url="foo/1") assert_that(action, equal_to(expected_delete_action))
def test_get_form_class(self): form_class = MagicMock() self.mixin.form_class['GET'] = form_class request = MagicMock() request.method = 'GET' self.mixin.request = request result = self.mixin.get_form_class() self.assertEqual(result, form_class)
def test_resolve_non_existing_action_put(self): mock_http_request = MagicMock() mock_http_request.method = 'PUT' mock_api = MagicMock() mock_resource = object() mock_api.resolve_resource.return_value = mock_resource action = action_resolver.resolve_action(mock_http_request, api=mock_api, url='foo') assert_that(action, equal_to(None))
def mock_request(self, authed, path='/'): mock_request = MagicMock() mock_request.method = 'GET' mock_request.user.is_authenticated.return_value = authed mock_request.POST = {} mock_request.META = {} mock_request.session = {} mock_request.build_absolute_uri.return_value = path mock_request.get_full_path.return_value = path return mock_request
def test_invalid_auth(self): req = MagicMock() req.headers = {'X-AUTH-TOKEN': 'IAMBAD'} req.method = 'GET' req.path = '/v2/servers' req.env = {} resp = MagicMock() with self.assertRaises(InvalidTokenError): validate_token(req, resp, {}) self.assertIsNone(req.env.get('auth'))
def test_upstream_preauth(self): req = MagicMock() auth = {'user': '******'} req.headers = {} req.method = 'GET' req.path = '/v2/servers' req.env = {'auth': auth} resp = MagicMock() validate_token(req, resp, {}) self.assertEquals(req.env.get('auth'), auth)
def test_resolve_non_existing_action_options(self): mock_http_request = MagicMock() mock_http_request.method = 'OPTIONS' mock_api = MagicMock() mock_resource = object() mock_api.resolve_resource.return_value = mock_resource action = action_resolver.resolve_action(mock_http_request, api=mock_api, url='foo') assert_that(action, equal_to(None))
def _get_mock_request(self, twofactor_required=False, devices=None): devices = devices or [] mock_request = MagicMock() mock_request.user.is_authenticated.return_value = True mock_request.user.preferredemail.email = '*****@*****.**' mock_request.user.twofactor_required = twofactor_required mock_request.method = 'GET' mock_request.POST = {} mock_request.META = {} mock_request.user.devices.all.return_value = devices return mock_request
def test_resolve_put_action_on_api(self): mock_http_request = MagicMock() mock_http_request.method = 'PUT' mock_api = MagicMock() mock_resource = MockResource() mock_api.resolve_resource.return_value = mock_resource mock_resource.create_or_update_detail = expected_action = MagicMock() action = action_resolver.resolve_action(mock_http_request, api=mock_api, url='foo/1') assert_that(action, equal_to(expected_action))
def test_process_response_logged_in_with_session_but_invalid_session_security_key(self): request = MagicMock(path="/") request.method = "GET" request.user = MagicMock() request.user.is_authenticated.return_value = True request.session = {"_session_security": u"cantp😺 😸 😻 😽 😼 🙀 😿 😹 😾arsethisasadate"} before_response = {} with self.assertRaises(UnicodeEncodeError): self.middleware.process_response(request, before_response)
def test_get_form_kwargs_get(self, get_initial_data_mock): request = MagicMock() request.method = 'GET' request.POST = 'foo' request.FILES = 'bar' self.mixin.request = request result = self.mixin.get_form_kwargs() self.assertIn('initial', result) self.assertIn('data', result)
def test_resolve_view_action(self): mock_http_request = MagicMock() mock_http_request.method = 'GET' mock_api = MagicMock() mock_resource = MockViewResource() mock_api.resolve_resource.return_value = mock_resource mock_resource.read = expected_read_action = MagicMock() action = action_resolver.resolve_action(mock_http_request, api=mock_api, url='foo') assert_that(action, equal_to(expected_read_action))
def test_log_request(self, log): req = MagicMock() req.method = 'GET' req.path = '/' req.query_string = 'something=value' req.env = {'REQUEST_ID': '123456'} resp = MagicMock() resp.status = '200 OK' log_request(req, resp) log.info.assert_called_with('%s %s %s %s [ReqId: %s]', 'GET', '/', 'something=value', '200 OK', '123456')
def test_process_response_logged_in_with_session_but_valid_session_security_key(self): request = MagicMock(path="/") request.method = "GET" request.user = MagicMock() request.user.is_authenticated.return_value = True request.session = {"_session_security": datetime.datetime.now().strftime("%Y-%m-%dT%H:%M:%S.%f")} before_response = {} response = self.middleware.process_response(request, before_response) self.assertIsNotNone(response.get("Session-Expires-In")) self.assertIsAlmostEqualMinutes(response.get("Session-Expires-In"), EXPIRE_AFTER // 60, delta=1.0)
def test_unprotected(self): for api in ['GET:/v2', 'GET:/v2/', 'GET:/v3.0', 'GET:/v3.0/', 'GET:/v10.22', 'POST:/v2/tokens', 'POST:/v2.1/tokens', 'GET:/v2/tokens/a8Vs7bS', 'GET:/v2.0/tokens/a8Vs7bS']: req = MagicMock() req.headers = {'X-AUTH-TOKEN': None} req.method = api.split(':')[0] req.path = api.split(':')[1] req.env = {} resp = MagicMock() validate_token(req, resp, {}) self.assertIsNone(req.env.get('auth'))
def test_resolve_detail_action_on_api(self): mock_http_request = MagicMock() mock_http_request.method = 'DELETE' mock_api = MagicMock() mock_resource = MagicMock() mock_api.resolve_resource.return_value = mock_resource mock_resource.delete_detail = expected_delete_action = MagicMock() action = action_resolver.resolve_action(mock_http_request, api=mock_api, url='foo/1') assert_that(action, equal_to(expected_delete_action))
def test_resolve_post_on_list_as_create_detail(self): mock_http_request = MagicMock() mock_http_request.method = 'POST' mock_api = MagicMock() mock_resource = MagicMock() mock_api.resolve_resource.return_value = mock_resource mock_resource.create_detail = expected_create_action = MagicMock() action = action_resolver.resolve_action(mock_http_request, api=mock_api, url='foo') assert_that(action, equal_to(expected_create_action))
def test_standard_responder_with_mount(self, request): responder = OpenStackResponder('/mount/point', 'http://127.0.0.1:1234/v2') req, resp = MagicMock(), MagicMock() req.method = 'POST' req.relative_uri = '/mount/point/path/to/resource' responder.on_get(req, resp) request.assert_called_with(req.method, 'http://127.0.0.1:1234/v2/path/to/resource', data=ANY, headers=req.headers, stream=True)
def test_unprotected(self): for api in [ 'GET:/v2', 'GET:/v2/', 'GET:/v3.0', 'GET:/v3.0/', 'GET:/v10.22', 'POST:/v2/tokens', 'POST:/v2.1/tokens', 'GET:/v2/tokens/a8Vs7bS', 'GET:/v2.0/tokens/a8Vs7bS' ]: req = MagicMock() req.headers = {'X-AUTH-TOKEN': None} req.method = api.split(':')[0] req.path = api.split(':')[1] req.env = {} resp = MagicMock() validate_token(req, resp, {}) self.assertIsNone(req.env.get('auth'))
def test_curator_only_member(self): # If user is curator and no other members, can delete the group self.group.curator = self.user.userprofile self.group.save() self.group.add_member(self.user.userprofile, GroupMembership.MEMBER) request = MagicMock() request.user = self.user request.method = 'POST' group_delete(request, self.group.url) # The group was deleted ok_(not Group.objects.filter(url=self.group.url).exists())
def test_is_manager(self): # Test that manager can delete group. manager = UserFactory.create(manager=True) user2 = UserFactory.create() self.group.add_member(user2.userprofile, GroupMembership.MEMBER) request = MagicMock() request.user = manager request.method = 'POST' group_delete(request, self.group.url) # The group was deleted ok_(not Group.objects.filter(url=self.group.url).exists())
def test_not_curator(self): # Only one member (user2) but user requesting the view (user1) is not the curator # (actually, nobody is the curator) user2 = UserFactory.create() self.group.add_member(user2.userprofile, GroupMembership.MEMBER) request = MagicMock() request.user = self.user request.method = 'POST' group_delete(request, self.group.url) # The group was NOT deleted ok_(Group.objects.filter(url=self.group.url).exists())
def test_build_changed_url_encoding(): """ Test create_chroot """ maintainer = MagicMock() maintainer.firstname.return_value = "John" maintainer.lastname.return_value = "Snow" hook = MagicMock() hook.enabled.return_value = True hook.skip_ssl = True hook.method = "get" hook.url = "http://nonsense.invalid/get/{{ build.version|urlencode }}" hook.body = "" srcrepo = MagicMock() srcrepo.hooks = [hook] srcrepo.id.return_value = 111 srcrepo.url.return_value = "git://url" srcrepo.name.return_value = "srcpkg" build = MagicMock() build.maintainer.return_value = maintainer build.sourcerepository = srcrepo build.startstamp = "NOW" build.endstamp = "NOW" build.id = 1337 build.buildtype = "deb" build.ci_branch = "master" build.git_ref = "1337" build.sourcename = "srcpkg" build.version = "0.0.0+git1-1337<>" build.buildstate = "successful" build.url = "/blah" build.raw_log_url = "/blub" with patch("molior.molior.notifier.Configuration") as cfg, patch( "molior.molior.notifier.trigger_hook") as trigger_hook: cfg.return_value.hostname = "localhorst" loop = asyncio.get_event_loop() loop.run_until_complete(build_changed(build)) trigger_hook.assert_called_with( "get", "http://nonsense.invalid/get/{}".format(quote_plus(build.version)), skip_ssl=True, body="", )
def test_process_response_logged_in_with_session_but_invalid_session_security_key( self): request = MagicMock(path="/") request.method = "GET" request.user = MagicMock() request.user.is_authenticated.return_value = True request.session = { "_session_security": u"cantp😺 😸 😻 😽 😼 🙀 😿 😹 😾arsethisasadate" } before_response = {} with self.assertRaises(UnicodeEncodeError): self.middleware.process_response(request, before_response)
def test_helpscout_user(self): request = MagicMock() request.method = 'POST' request.body = json.dumps({'customer': {'email': '*****@*****.**'}}) # User does not exist response = helpscout_user(request) self.assertTemplateUsed(response, 'django_helpscout/404.html') # User found user = User.objects.create(username='******', email='*****@*****.**', password='******') response = helpscout_user(request) self.assertTemplateUsed(response, 'django_helpscout/helpscout.html')