def test_method_must_have_side_effects(self): """Method must have side effects.""" from ..csrf import CSRFError mock_request = Mock() mock_request.method = 'b' validator = self.makeOne('token', target_methods=['a']) retval = validator.validate(mock_request) self.assertTrue(retval is None) self.assertRaises( AssertionError, mock_request.headers.get.assert_called_with, 'X-Requested-With' ) mock_request = Mock() mock_request.method = 'a' self.assertRaises( CSRFError, validator.validate, mock_request )
def test_serverCreate(self): mock = Mock() mock.method = Mock(return_value=True) actual = mock.method() expected = True self.assertEqual(actual, expected)
def test_mock_assert_called_with_can_fail(): test_object = Mock() test_object.method({'bob': 'barker'}) with pytest.raises(AssertionError): test_object.method.assert_called_with(instance_of(list))
def test_any_mock_calls_comparison_order(self): mock = Mock() d = datetime.now() class Foo(object): def __eq__(self, other): return False def __ne__(self, other): return True for d in datetime.now(), Foo(): mock.reset_mock() mock(d, foo=d, bar=d) mock.method(d, zinga=d, alpha=d) mock().method(a1=d, z99=d) expected = [ call(ANY, foo=ANY, bar=ANY), call.method(ANY, zinga=ANY, alpha=ANY), call(), call().method(a1=ANY, z99=ANY) ] self.assertEqual(expected, mock.mock_calls) self.assertEqual(mock.mock_calls, expected)
def test_clientRead(self): mock = Mock() mock.method = Mock(return_value=True) actual = mock.method() expected = True self.assertEqual(actual, expected)
def test_spec__object(): mock = Mock(spec=Spec()) attrs = dir(mock) assert 'class_attr' in attrs assert '_private_attr' in attrs # constructor IS consulted assert 'method' in attrs mock.method('arg1', 'arg2') # signature is not respected assert 'prop_ro' in attrs mock.prop_ro = 'bla' # read-only is not respected
def prepare_request_mock( self, data=None, referer='http://localhost/user_with_workspaces/public-workspace', user=None, extra_headers={}, GET='', use_deprecated_code=False): request = Mock() request.get_host.return_value = 'localhost' GET_PARAMETERS = parse_qsl(GET) request.GET = MagicMock() request.GET.__len__.side_effect = lambda: len(GET_PARAMETERS) request.GET.__getitem__.side_effect = lambda key: GET_PARAMETERS[key] request.GET.urlencode.side_effect = lambda: GET request.COOKIES = { settings.SESSION_COOKIE_NAME: 'test', } request.META = { 'HTTP_ACCEPT': 'application/json', 'SERVER_PROTOCOL': 'http', 'REMOTE_ADDR': '127.0.0.1', 'HTTP_HOST': 'localhost', 'HTTP_REFERER': referer, } if data is not None: request.method = 'POST' data = data.encode('utf-8') request.META['content_type'] = 'application/json' request.META['content_length'] = len(data) request.read.return_value = data else: request.method = 'GET' if use_deprecated_code: request.META['HTTP_X_FI_WARE_OAUTH_TOKEN'] = 'true' extra_headers = { self.deprecation_mapping[key]: value for key, value in six.iteritems(extra_headers) } else: request.META['HTTP_FIWARE_OAUTH_TOKEN'] = 'true' request.META.update(extra_headers) if user is None: request.user = self.admin_mock else: request.user = user return request
def test_deny_create_on_put_permission(self): permission = DenyCreateOnPutPermission() view = Mock() request = Mock() request.method = 'GET' self.assertTrue(permission.has_permission(request, view)) request.method = 'PUT' self.assertTrue(permission.has_permission(request, view)) request.method = 'PUT' view.get_object = Mock(side_effect=Http404) self.assertFalse(permission.has_permission(request, view))
def test_mock_method_calls(self): mock = Mock() mock() mock.method().attribute.method() mock.attribute.method() # mock_calls: inclusive, recursive; split by '()', good for callable mocks. self.assertEqual(mock.mock_calls, [ call(), call.method(), call.method().attribute.method(), call.attribute.method()]) # method_calls: exclusive, recursive; terminated by '()', good for non-callable mocks. self.assertEqual(mock.method_calls, [call.method(), call.attribute.method()])
def test_process_request_empty_header(self): request = Mock(path="/") request.method = "OPTIONS" request.META = {"HTTP_ACCESS_CONTROL_REQUEST_METHOD": ""} with settings_override(CORS_URLS_REGEX="^.*$"): response = self.middleware.process_request(request) self.assertIsInstance(response, HttpResponse)
def requestMock(path, method="GET", host="localhost", port=8080, isSecure=False): postpath = path.split('/') request = Mock() request.getRequestHostname.return_value = host request.getHost.return_value.port = port request.postpath = postpath request.prepath = [] request.method = method request.isSecure.return_value = isSecure request.notifyFinish.return_value = Deferred() request.finished = False request.__klein_branch_segments__ = [] def render(resource): return _render(resource, request) def finish(): request.notifyFinish.return_value.callback(None) request.finished = True def processingFailed(failure): request.failed = failure request.notifyFinish.return_value.errback(failure) request.finish.side_effect = finish request.render.side_effect = render request.processingFailed.side_effect = processingFailed return request
def test_decorate_valid_view(self): class ArticleForm(forms.ModelForm): class Meta: model = Article class ArticleView(views.CreateView): model = Article form_class = with_request(ArticleForm) view_class = with_request(ArticleView) self.assertTrue(hasattr(view_class, 'get_form_kwargs')) self.assertTrue(getattr(view_class, '_with_request_decorated', False)) # does the get_form_kwargs return request correctly? view = view_class() # ``request`` and ``object`` are stored on the instance in ``dispatch`` # method in real usage but simply store fake request now for simulating mock_request = Mock() mock_request.method = 'GET' view.request = mock_request view.object = Article() kwargs = view.get_form_kwargs() self.assertTrue('request' in kwargs) self.assertEqual(kwargs['request'], mock_request) # does the form created by the view correctly handle request? form_class = view.get_form_class() form = view.get_form(form_class) self.assertTrue(hasattr(form_class, '__init__')) self.assertTrue(hasattr(form_class, 'save')) self.assertTrue(getattr(form_class, '_with_request_decorated', False)) # does the request correctly stored? self.assertEqual(form.request, mock_request)
def test_get_bounding_box_of_country(self): request = Mock() request.method = 'GET' request.GET.get.return_value = MockGeoserver().response() geonames_service = Mock() geoserver = Mock() geoserver.get_admin_units_for_country.return_value = '["Districts", "County"]' geonames_service.query_for_country.return_value = ''' {"geonames" :[{"countryName":"India", "bBoxWest":68.1866760253906, "currencyCode":"INR", "fipsCode":"IN", "countryCode":"IN", "isoNumeric":"356", "capital":"New Delhi", "areaInSqKm":"3287590.0", "languages":"en-IN,hi,bn,te,mr,ta,ur,gu,ml,kn,or,pa,as,ks,sd,sa,ur-IN", "bBoxEast":97.4033126831055, "isoAlpha3":"IND", "continent":"AS", "bBoxNorth":35.5042304992676, "geonameId":1269750, "bBoxSouth":6.74713850021362, "population":"1147995000"}]}''' response = views.country_details(request, geonames_service, geoserver) self.assertEquals('{"north": 180, "west": -90, "admin_units": "", "country": "Request failed", "east": 90, "adm1": [], "south": -180}', response.content)
def test_owner_or_mod_required_passes_url_parameters(self): @owner_or_moderator_required def mock_view(request, user, context): return None request = Mock(spec=('path', 'POST', 'user', 'method')) request.method = "POST" request.user = AnonymousUser() request.POST = {'abra': 'cadabra', 'foo': 'bar'} request.path = '/some/path/' user = self.create_user('user') response = mock_view(request, user, {}) self.assertEqual(isinstance(response, HttpResponseRedirect), True) url = response['location'] parsed_url = urllib.parse.urlparse(url) self.assertEqual(parsed_url.path, reverse('user_signin')) next_jwt = dict(urllib.parse.parse_qsl(parsed_url.query))['next'] next_url = decode_jwt(next_jwt).get('next_url') parsed_url = urllib.parse.urlparse(next_url) self.assertEqual(parsed_url.path, request.path) query = dict(urllib.parse.parse_qsl(parsed_url.query)) self.assertEqual(set(query.keys()), set(['foo', 'abra'])) self.assertEqual(set(query.values()), set(['bar', 'cadabra'])) self.assertEqual(query['abra'], 'cadabra')
def test_fakesock_socket_sendall_with_body_data_with_chunked_entry(POTENTIAL_HTTP_PORTS, old_socket, match_uriinfo): ("fakesock.socket#sendall should call real_sendall when not ") # Background: # Using a subclass of socket that mocks out real_sendall class MySocket(fakesock.socket): def real_sendall(self, data): raise AssertionError('should have never been called') matcher = Mock(name='matcher') info = Mock(name='info') httpretty.match_uriinfo.return_value = (matcher, info) # Using a mocked entry entry = Mock() entry.method = 'GET' entry.info.path = '/foo' entry.request.headers = { 'transfer-encoding': 'chunked', } entry.request.body = b'' # Given an instance of that socket socket = MySocket() socket._entry = entry # And that is is considered http socket.connect(('foo.com', 80)) # When I try to send data socket.sendall(b"BLABLABLABLA") # Then the entry should have that body httpretty.last_request.body.should.equal(b'BLABLABLABLA')
def test_process_request_replace_https_referer(self): post_middleware = CorsPostCsrfMiddleware() request = Mock(path='/') request.method = 'GET' request.is_secure = lambda: False request.META = { 'HTTP_REFERER': 'http://foo.google.com/', 'HTTP_HOST': 'foobar.com', 'HTTP_ORIGIN': 'http://foo.google.com', } # test that we won't replace if the request is not secure with settings_override(CORS_URLS_REGEX='^.*$', CORS_ORIGIN_REGEX_WHITELIST='.*google.*', CORS_REPLACE_HTTPS_REFERER=True): response = self.middleware.process_request(request) self.assertIsNone(response) self.assertTrue('ORIGINAL_HTTP_REFERER' not in request.META) self.assertEquals(request.META['HTTP_REFERER'], 'http://foo.google.com/') request.is_secure = lambda: True request.META = { 'HTTP_REFERER': 'https://foo.google.com/', 'HTTP_HOST': 'foobar.com', 'HTTP_ORIGIN': 'https://foo.google.com', } # test that we won't replace with the setting off with settings_override(CORS_URLS_REGEX='^.*$', CORS_ORIGIN_REGEX_WHITELIST='.*google.*'): response = self.middleware.process_request(request) self.assertIsNone(response) self.assertTrue('ORIGINAL_HTTP_REFERER' not in request.META) self.assertEquals(request.META['HTTP_REFERER'], 'https://foo.google.com/') with settings_override(CORS_URLS_REGEX='^.*$', CORS_ORIGIN_REGEX_WHITELIST='.*google.*', CORS_REPLACE_HTTPS_REFERER=True): response = self.middleware.process_request(request) self.assertIsNone(response) self.assertEquals(request.META['ORIGINAL_HTTP_REFERER'], 'https://foo.google.com/') self.assertEquals(request.META['HTTP_REFERER'], 'https://foobar.com/') # make sure the replace code is idempotent with settings_override(CORS_URLS_REGEX='^.*$', CORS_ORIGIN_REGEX_WHITELIST='.*google.*', CORS_REPLACE_HTTPS_REFERER=True): response = self.middleware.process_view(request, None, None, None) self.assertIsNone(response) self.assertEquals(request.META['ORIGINAL_HTTP_REFERER'], 'https://foo.google.com/') self.assertEquals(request.META['HTTP_REFERER'], 'https://foobar.com/') with settings_override(CORS_URLS_REGEX='^.*$', CORS_REPLACE_HTTPS_REFERER=True): post_middleware.process_request(request) self.assertTrue('ORIGINAL_HTTP_REFERER' not in request.META) self.assertEquals(request.META['HTTP_REFERER'], 'https://foo.google.com/') with settings_override(CORS_URLS_REGEX='^.*$', CORS_REPLACE_HTTPS_REFERER=True): response = post_middleware.process_request(request) self.assertIsNone(response)
def test_process_view_replace_https_referer(self): post_middleware = CorsPostCsrfMiddleware() request = Mock(path='/') request.method = 'GET' request.is_secure = lambda: True request.META = { 'HTTP_REFERER': 'https://foo.google.com/', 'HTTP_HOST': 'foobar.com', 'HTTP_ORIGIN': 'https://foo.google.com', } with settings_override(CORS_URLS_REGEX='^.*$', CORS_ORIGIN_REGEX_WHITELIST='.*google.*', CORS_REPLACE_HTTPS_REFERER=True): response = self.middleware.process_view(request, None, None, None) self.assertIsNone(response) self.assertEquals(request.META['ORIGINAL_HTTP_REFERER'], 'https://foo.google.com/') self.assertEquals(request.META['HTTP_REFERER'], 'https://foobar.com/') with settings_override(CORS_URLS_REGEX='^.*$', CORS_REPLACE_HTTPS_REFERER=True): post_middleware.process_view(request, None, None, None) self.assertTrue('ORIGINAL_HTTP_REFERER' not in request.META) self.assertEquals(request.META['HTTP_REFERER'], 'https://foo.google.com/') with settings_override(CORS_URLS_REGEX='^.*$', CORS_REPLACE_HTTPS_REFERER=True): response = post_middleware.process_view(request, None, None, None) self.assertIsNone(response)
def test_process_request_empty_header(self): request = Mock(path='/') request.method = 'OPTIONS' request.META = {'HTTP_ACCESS_CONTROL_REQUEST_METHOD': ''} with settings_override(CORS_URLS_REGEX='^.*$'): response = self.middleware.process_request(request) self.assertIsInstance(response, HttpResponse)
def test_login_and_store_credentials_in_session(self): # only testing custom logic, which happens on POST # everything else is handled by django.contrib.auth mockrequest = Mock() mockrequest.method = 'POST' def not_logged_in(rqst): rqst.user.is_authenticated.return_value = False def set_logged_in(rqst): rqst.user.is_authenticated.return_value = True rqst.POST.get.return_value = "TEST_PASSWORD" # failed login with patch('eulfedora.views.authviews.login', new=Mock(side_effect=not_logged_in)): mockrequest.session = dict() response = login_and_store_credentials_in_session(mockrequest) self.assert_(FEDORA_PASSWORD_SESSION_KEY not in mockrequest.session, 'user password for fedora should not be stored in session on failed login') # successful login with patch('eulfedora.views.authviews.login', new=Mock(side_effect=set_logged_in)): response = login_and_store_credentials_in_session(mockrequest) self.assert_(FEDORA_PASSWORD_SESSION_KEY in mockrequest.session, 'user password for fedora should be stored in session on successful login') # test password stored in the mock request pwd = mockrequest.POST.get() # encrypted password stored in session sessionpwd = mockrequest.session[FEDORA_PASSWORD_SESSION_KEY] self.assertNotEqual(pwd, sessionpwd, 'password should not be stored in the session without encryption') self.assertEqual(pwd, cryptutil.decrypt(sessionpwd), 'user password stored in session is encrypted')
def has_object_perm(self, auth, user, obj, method='GET'): perm = ProjectPermission() request = Mock() request.auth = auth request.user = user request.method = method return perm.has_object_permission(request, None, obj)
def has_perm(self, method, obj, auth=None, user=None): perm = TeamPermission() request = Mock() request.auth = auth request.user = user request.method = method return perm.has_object_permission(request, None, obj)
def get_signed_grade_mock_request_with_correct_signature(self): """ Generate a proper LTI request object """ mock_request = Mock() mock_request.headers = { 'X-Requested-With': 'XMLHttpRequest', 'Content-Type': 'application/x-www-form-urlencoded', 'Authorization': ( u'OAuth realm="https://testurl/", oauth_body_hash="wwzA3s8gScKD1VpJ7jMt9b%2BMj9Q%3D",' 'oauth_nonce="18821463", oauth_timestamp="1409321145", ' 'oauth_consumer_key="__consumer_key__", oauth_signature_method="HMAC-SHA1", ' 'oauth_version="1.0", oauth_signature="fHsE1hhIz76/msUoMR3Lyb7Aou4%3D"' ) } mock_request.url = u'https://testurl' mock_request.http_method = u'POST' mock_request.method = mock_request.http_method mock_request.body = ( '<?xml version=\'1.0\' encoding=\'utf-8\'?>\n' '<imsx_POXEnvelopeRequest xmlns="http://www.imsglobal.org/services/ltiv1p1/xsd/imsoms_v1p0">' '<imsx_POXHeader><imsx_POXRequestHeaderInfo><imsx_version>V1.0</imsx_version>' '<imsx_messageIdentifier>edX_fix</imsx_messageIdentifier></imsx_POXRequestHeaderInfo>' '</imsx_POXHeader><imsx_POXBody><replaceResultRequest><resultRecord><sourcedGUID>' '<sourcedId>MITxLTI/MITxLTI/201x:localhost%3A8000-i4x-MITxLTI-MITxLTI-lti-3751833a214a4f66a0d18f63234207f2:363979ef768ca171b50f9d1bfb322131</sourcedId>' # pylint: disable=line-too-long '</sourcedGUID><result><resultScore><language>en</language><textString>0.32</textString></resultScore>' '</result></resultRecord></replaceResultRequest></imsx_POXBody></imsx_POXEnvelopeRequest>' ) return mock_request
def test_api_resource(): """ Test APIResource class """ resource = pdrest.APIResource() resource.register("method", "method", do_nothing) request = Mock() request.method = "method" request.path = "method" result = resource._get_callback(request) assert result[0] == do_nothing resource.getChild("method", request) resource.unregister(regex="method") # After unregister, the callback should be gone. result = resource._get_callback(request) assert result[0] is None resource.getChild("method", request) resource.children = Mock(name="what") result = resource.getChild("method", request) resource.getChild("method", request)
def test_raw_datastream_version(self): rqst = Mock() rqst.method = 'GET' # return empty headers for ETag condition check rqst.META = {} self.obj.text.content = 'second version content' self.obj.text.save() # retrieve the view for each version and compare for version in self.obj.text.history().versions: # get the datastream version to compare with the response dsversion = self.obj.getDatastreamObject(self.obj.text.id, as_of_date=version.created) response = raw_datastream_old(rqst, self.obj.pid, self.obj.text.id, as_of_date=version.created) expected, got = 200, response.status_code self.assertEqual(expected, got, 'Expected %s but returned %s for raw_datastream as of %s' \ % (expected, got, version.created)) expected, got = 'text/plain', response['Content-Type'] self.assertEqual(expected, got, 'Expected %s but returned %s for mimetype on raw_datastream as of %s' \ % (expected, got, version.created)) # should use version-specific checksum and size self.assertEqual(dsversion.checksum, response['Content-MD5'], 'datastream checksum should be set as Content-MD5 header in the response') self.assertEqual(dsversion.size, int(response['Content-Length'])) # should retrieve appropriate version of the content self.assertEqual(dsversion.content, response.content)
def get_signed_grade_mock_request_with_correct_signature(self): """ Generate a proper LTI request object """ mock_request = Mock() mock_request.headers = { u'X-Requested-With': u'XMLHttpRequest', u'Content-Type': u'application/x-www-form-urlencoded', u'Authorization': (u'OAuth realm="https://testurl/", oauth_body_hash="wwzA3s8gScKD1VpJ7jMt9b%2BMj9Q%3D",' u'oauth_nonce="18821463", oauth_timestamp="1409321145", ' u'oauth_consumer_key="__consumer_key__", oauth_signature_method="HMAC-SHA1", ' u'oauth_version="1.0", oauth_signature="fHsE1hhIz76/msUoMR3Lyb7Aou4%3D"' ) } mock_request.url = u'https://testurl' mock_request.http_method = u'POST' mock_request.method = mock_request.http_method mock_request.body = ( u'<?xml version=\'1.0\' encoding=\'utf-8\'?>\n' u'<imsx_POXEnvelopeRequest xmlns="http://www.imsglobal.org/services/ltiv1p1/xsd/imsoms_v1p0">' u'<imsx_POXHeader><imsx_POXRequestHeaderInfo><imsx_version>V1.0</imsx_version>' u'<imsx_messageIdentifier>edX_fix</imsx_messageIdentifier></imsx_POXRequestHeaderInfo>' u'</imsx_POXHeader><imsx_POXBody><replaceResultRequest><resultRecord><sourcedGUID>' u'<sourcedId>MITxLTI/MITxLTI/201x:localhost%3A8000-i4x-MITxLTI-MITxLTI-lti-3751833a214a4f66a0d18f63234207f2' u':363979ef768ca171b50f9d1bfb322131</sourcedId>' u'</sourcedGUID><result><resultScore><language>en</language><textString>0.32</textString></resultScore>' u'</result></resultRecord></replaceResultRequest></imsx_POXBody></imsx_POXEnvelopeRequest>' ).encode('utf-8') return mock_request
def test_process_view_replace_https_referer(self): post_middleware = CorsPostCsrfMiddleware() request = Mock(path='/') request.method = 'GET' request.is_secure = lambda: True request.META = { 'HTTP_REFERER': 'https://foo.google.com/', 'HTTP_HOST': 'foobar.com', 'HTTP_ORIGIN': 'https://foo.google.com', } with override_settings(CORS_URLS_REGEX='^.*$', CORS_ORIGIN_REGEX_WHITELIST='.*google.*', CORS_REPLACE_HTTPS_REFERER=True): response = self.middleware.process_view(request, None, None, None) self.assertIsNone(response) self.assertEquals(request.META['ORIGINAL_HTTP_REFERER'], 'https://foo.google.com/') self.assertEquals(request.META['HTTP_REFERER'], 'https://foobar.com/') with override_settings(CORS_URLS_REGEX='^.*$', CORS_REPLACE_HTTPS_REFERER=True): post_middleware.process_view(request, None, None, None) self.assertTrue('ORIGINAL_HTTP_REFERER' not in request.META) self.assertEquals(request.META['HTTP_REFERER'], 'https://foo.google.com/') with override_settings(CORS_URLS_REGEX='^.*$', CORS_REPLACE_HTTPS_REFERER=True): response = post_middleware.process_view(request, None, None, None) self.assertIsNone(response)
def has_object_perm(self, auth, user, obj, method="GET"): perm = OrganizationPermission() request = Mock() request.auth = auth request.user = user request.method = method return perm.has_object_permission(request, None, obj)
def test_raw_audit_trail(self): rqst = Mock() rqst.method = 'GET' # created with no ingest message = no audit trail self.assertRaises(Http404, raw_audit_trail, rqst, self.obj.pid) # modify object so it will have an audit trail self.obj.dc.content.title = 'audit this!' changelog = 'I just changed the title' self.obj.save(changelog) response = raw_audit_trail(rqst, self.obj.pid) expected, got = 200, response.status_code self.assertEqual(expected, got, 'Expected %s but returned %s for raw_audit_trail' \ % (expected, got)) expected, got = 'text/xml', response['Content-Type'] self.assertEqual(expected, got, 'Expected %s but returned %s for mimetype on raw_audit_trail' \ % (expected, got)) self.assert_(b'<audit:auditTrail' in response.content) self.assert_( force_bytes('<audit:justification>%s</audit:justification>' % changelog) in response.content) self.assert_('Last-Modified' in response)
def prepare_request_mock(self, data, referer='http://localhost/user_with_workspaces/Public Workspace', user=None, extra_headers={}, GET=''): request = Mock() request.method = 'POST' request.get_host.return_value = 'localhost' GET_PARAMETERS = parse_qsl(GET) request.GET = MagicMock() request.GET.__len__.side_effect = lambda: len(GET_PARAMETERS) request.GET.__getitem__.side_effect = lambda key: GET_PARAMETERS[key] request.GET.urlencode.side_effect = lambda: GET request.COOKIES = { settings.SESSION_COOKIE_NAME: 'test', } request.META = { 'HTTP_ACCEPT': 'application/json', 'SERVER_PROTOCOL': 'http', 'REMOTE_ADDR': '127.0.0.1', 'content_type': 'application/json', 'content_length': len(data), 'HTTP_HOST': 'localhost', 'HTTP_REFERER': referer, 'HTTP_X_FI_WARE_OAUTH_TOKEN': 'true', } request.META.update(extra_headers) request.read.return_value = data if user is None: request.user = self.admin_mock else: request.user = user return request
def request(method='GET', form={}): request = Mock() request.method = method request.form = form request.headers = Mock() request.headers.get = Mock() request.headers.get.return_value = "application/hal+json" return request
def test_Mock1(self): mock = Mock() mock.method.return_value = "foo" self.assertTrue(mock.method(1, 2, 3, 4), "foo") self.assertTrue(mock.method.called) with self.assertRaises(AssertionError): mock.method.assert_called_with(8, 6)
def test_login_redirect_invalid_method(self): request = Mock() request.META = {} request.method = 'POST' request.session.get.return_value = None response = login(request) self.assertEqual(response.status_code, 405)
def has_object_perm(self, method, obj, auth=None, user=None, is_superuser=None): perm = OrganizationPermission() request = Mock() request.auth = auth request.user = user request.method = method request.is_superuser = lambda: is_superuser if is_superuser is not None else user.is_superuser return perm.has_object_permission(request, None, obj)
def test_validate_post_notsupported(self): '''This test case ensures creation of new persons through api always fails.''' request = Mock() request.method = "POST" with self.assertRaises(FantasticoRoaMethodNotSupportedError): self._validator.validate({}, request)
def setUp(self): request = Mock() request.method = 'POST' request.POST = {'livetranslation-popup-0-msgid': 'the-msgid', 'livetranslation-popup-0-en': 'the-msgstr'} with patch('livetranslation.views.save_translations') as save: self.response = get_translations(request) self.save_translations = save
def test_show_failure_message_when_delete_admin_unit_fails(self): request = Mock() request.session = {} admin_unit_manager = Mock() request.method = 'POST' request.POST.side_effect = Exception response = views.delete_administrative_unit(request, admin_unit_manager) self.assertEquals(request.session['message'], "Unable to delete Admin unit")
def request_wrap(data: dict): """ Wrapper for sending data to a json handler """ request = Mock() request.method = "POST" request.body = json.dumps(data).encode("utf-8") return request
def setUp(self): request = Mock() request.method = 'GET' request.GET = {'msgid': 'the-msgid'} get_all_translations = Mock(return_value={"dummy": "json"}) with patch('livetranslation.views.get_all_translations', get_all_translations): self.response = get_translations(request)
def test_sendEvent(self, _meter): event = Mock(spec=["method", "retry"]) event.retry = None event.method = "sendEvent" markEventsSent(event) _meter.mark.assert_called_once_with()
def test_no_long_url(self): url = '1234567890' * 19 # 190-character URL mock_request = Mock() mock_request.META = {'CONTENT_TYPE': 'text/plain'} mock_request.GET = {} mock_request.path = url mock_request.method = 'get' request_model = RequestModelFactory(mock_request).construct_request_model() self.assertEqual(request_model.path, url)
def test_sendEvents(self, _meter): event = Mock(spec=["method", "retry", "args"]) event.retry = None event.method = "sendEvents" event.args = [0, 1] markEventsSent(event) _meter.mark.assert_called_once_with(len(event.args))
def mock_request(method='subtract', args=None, kwargs=None): mock_request = Mock(RPCRequest) mock_request.method = method mock_request.args = args or [4, 6] mock_request.kwargs = kwargs or {} mock_request.respond = Mock(RPCRequest.respond) mock_request.error_respond = Mock(RPCRequest.error_respond) return mock_request
def test_trap_duplicate_skipped_on_standalone(self, trap_duplicate_mock): self.create_switch('webapps-unique-by-domain') request = Mock() request.method = 'POST' request.POST = {'manifest': ''} request.return_value = collections.namedtuple('FakeResponse', 'status_code content') standalone_hosted_upload(request) assert not trap_duplicate_mock.called
def test_mock_method_calls(self): mock = Mock() mock() mock.method().attribute.method() mock.attribute.method() # mock_calls: inclusive, recursive; split by '()', good for callable mocks. self.assertEqual(mock.mock_calls, [ call(), call.method(), call.method().attribute.method(), call.attribute.method() ]) # method_calls: exclusive, recursive; terminated by '()', good for non-callable mocks. self.assertEqual( mock.method_calls, [call.method(), call.attribute.method()])
def test_setup_queue(self): result = Mock() result.method = Mock() result.method.queue = Mock() self.channel.queue_declare.return_value = result self._new_transport() self.channel.queue_declare.assert_called_once_with(exclusive=True) self.channel.basic_consume.assert_called_once_with(ANY, no_ack=True, queue=result.method.queue)
def test_max_request(self): SilkyConfig().SILKY_MAX_REQUEST_BODY_SIZE = 10 # 10kb mock_request = Mock() mock_request.META = {'CONTENT_TYPE': 'text/plain'} mock_request.GET = {} mock_request.method = 'get' mock_request.body = 'a'.encode('ascii') * 1024 * 100 # 100kb mock_request.path = reverse('silk:requests') request_model = RequestModelFactory(mock_request).construct_request_model() self.assertFalse(request_model.raw_body)
def test_no_long_url(self): url = '1234567890' * 19 # 190-character URL mock_request = Mock() mock_request.META = {'CONTENT_TYPE': 'text/plain'} mock_request.GET = {} mock_request.path = url mock_request.method = 'get' request_model = RequestModelFactory( mock_request).construct_request_model() self.assertEqual(request_model.path, url)
def build_mocks(self, resource_type='widget'): get_object_or_404_mock = Mock() resource_mock = Mock() resource_mock.resource_type.return_value = resource_type get_object_or_404_mock.return_value = resource_mock request_mock = Mock() request_mock.method = 'GET' return request_mock, get_object_or_404_mock, Mock()