def test_get_product_get_image(self, requests_mock): response_mock = Mock() response_mock.status_code = 200 response_mock.content = json.dumps({'id': 991, 'name': 'test prod'}) requests_mock.get.return_value = response_mock cli = APIClient('test_api_key', 'test user agent') p = ProductResource(cli, '46') res = p.get(991) self.assertEqual(991, res.id) requests_mock.get.assert_called_with( url='https://api.tiendanube.com/v1/46/products/991', headers={'Authentication': 'bearer test_api_key', 'User-Agent': 'test user agent'}, params=None ) response_mock.content = json.dumps({'id': 1, 'name': 'test prod image'}) res = res.images.get(1) self.assertEqual(bunchify({'id': 1, 'name': 'test prod image'}), res) requests_mock.get.assert_called_with( url='https://api.tiendanube.com/v1/46/products/991/images/1', headers={'Authentication': 'bearer test_api_key', 'User-Agent': 'test user agent'}, params=None )
def test_validate_package(self): maint = self.get_maintainer() pack = Package(filename='foo', name='bar_2go', package_format='1', version='0.0.0', description='pdesc', licenses=['BSD'], maintainers=[maint]) pack.validate() # check invalid names pack.name = '2bar' self.assertRaises(InvalidPackage, Package.validate, pack) pack.name = 'bar bza' self.assertRaises(InvalidPackage, Package.validate, pack) pack.name = 'BAR' self.assertRaises(InvalidPackage, Package.validate, pack) # dashes should be acceptable in packages other than catkin or # ament*. # no build_type, so catkin is assumed per REP-140. pack.name = 'bar-bza' self.assertRaises(InvalidPackage, Package.validate, pack) # check explicit catkin and ament_* build_types build_type = Mock(tagname='build_type', attributes={}, content='catkin') pack.exports = [build_type] self.assertRaises(InvalidPackage, Package.validate, pack) build_type.content = 'ament_cmake' self.assertRaises(InvalidPackage, Package.validate, pack) build_type.content = 'ament_python' self.assertRaises(InvalidPackage, Package.validate, pack) # check non ament/catkin build type is valid build_type.content = 'cmake' pack.validate() # check authors emails pack.name = 'bar' auth1 = Mock() auth2 = Mock() auth2.validate.side_effect = InvalidPackage('foo') pack.authors = [auth1, auth2] self.assertRaises(InvalidPackage, Package.validate, pack) pack.authors = [] pack.validate() # check maintainer required with email pack.maintainers = [] self.assertRaises(InvalidPackage, Package.validate, pack) pack.maintainers = [maint] maint.email = None self.assertRaises(InvalidPackage, Package.validate, pack) maint.email = '*****@*****.**' for dep_type in [ pack.build_depends, pack.buildtool_depends, pack.build_export_depends, pack.buildtool_export_depends, pack.exec_depends, pack.test_depends, pack.doc_depends]: pack.validate() depend = Dependency(pack.name) dep_type.append(depend) self.assertRaises(InvalidPackage, Package.validate, pack) dep_type.remove(depend)
def __init__(self): ticket_mock = Mock() ticket_mock.content = json.dumps(_get_ticket('Test')) ticket_mock.status_code = 200 child_mock = Mock() child_mock.content = json.dumps([_get_ticket('Child'), _get_ticket('Child2')]) child_mock.status_code = 200 self.mocks = [ticket_mock, child_mock]
def mock_response(fixture=None, status=200): response = Mock() if fixture is None: response.content = '' elif isinstance(fixture, dict): response.content = str(fixture) else: response.content = load_fixture(fixture) response.status_code = status return response
def inner(status_code=200, response_ok=True, response=None, content=None): mock_box_response = Mock(BoxResponse) mock_network_response = Mock(DefaultNetworkResponse) mock_box_response.network_response = mock_network_response mock_box_response.status_code = status_code mock_box_response.ok = response_ok if response is not None: mock_box_response.json.return_value = response mock_box_response.content = json.dumps(response).encode() else: mock_box_response.content = content return mock_box_response, mock_network_response
def side_effect(*args, **kwargs): response = Mock() data = json.loads(kwargs.get('data', "{}")) for param in required_post_params: if param not in data: response.status_code = 400 response.content = '%r is required' return response response.status_code = 200 response.content = json.dumps({'s':1}) return response
def test_internal_message_list(self): msg = { "status": "queued", "messages": [] } response = Mock() response.status_code = 200 response.content = json.dumps(msg) self.mock_requests.request.return_value = response lbh = LogBookHandler('uuid') # The logbook starts off with no messages eq_(0, len(lbh.messages)) msg['messages'].append( { "asctime": "2012-02-08T11:15:04", "message": "message1", }) response.content = json.dumps(msg) self.mock_requests.request.return_value = response new_msg = lbh.fetch() # The logbook has one message now eq_(1, len(lbh.messages)) eq_(new_msg, lbh.messages) messages = [ { "asctime": "2012-02-08T11:15:05", "message": "message2", }, { "asctime": "2012-02-08T11:15:06", "message": "message3", }] msg['messages'].extend(messages) response.content = json.dumps(msg) self.mock_requests.request.return_value = response new_msg = lbh.fetch() # The logbook has one message now eq_(3, len(lbh.messages)) eq_(new_msg, messages)
def build_response_mock(status_code, json_body=None, headers=None, add_content_length=True, **kwargs): real_response = requests.Response() real_response.status_code = status_code text = None if json_body is not None: text = json.dumps(json_body) if add_content_length and headers is not {}: real_response.headers['content-length'] = len(text) if headers is not None: for k, v in headers.items(): real_response.headers[k] = v for k, v in kwargs.items(): setattr(real_response, k, v) response = Mock(wraps=real_response, autospec=True) if text: response.text = text # for some reason, wraps cannot handle attributes which are dicts # and accessed by key response.headers = real_response.headers response.content = text return response
def setUp(self): response = Mock() response.content = json.dumps({'status': 'ok'}) response.headers = {'Content-Type': 'application/json'} response.ok = True response.status_code = requests.codes.ok self.response = response
def test_arbitrary_member(self, mock_request): mock_response = Mock() mock_response.ok = True mock_response.content = json.dumps({"short_codes": []}) mock_request.return_value = mock_response self.assertEqual([], self.client.sms.short_codes.list()) mock_request.assert_called_once_with("GET", ANY, params=ANY, auth=AUTH, timeout=sentinel.timeout)
def setUp(self): # mock request object request = Request() request.method = "GET" request.url = "http://example.com/" request.params = {} request.data = {} request.params_and_data = {} self.request = request # mock response object response = Mock() response.content = "access_token=321" response.headers = {"content-type": "text/html; charset=UTF-8"} response.ok = True response.status_code = 200 self.response = response # mock raise_for_status with an error def raise_for_status(): raise Exception("Response not OK!") self.raise_for_status = raise_for_status # mock hook object hook = Mock() hook.consumer_key = "123" hook.consumer_secret = "456" hook.access_token = "321" hook.access_token_secret = "654" self.hook = hook
def test_success(self): # Setting up valid ticket valid_ticket = "valid_ticket" LoginEmailSentCertified(ticket=valid_ticket).put() # setting user data return rpc = Mock() result = Mock() result.status_code = 200 result.content = '{"id":"123456","email":"*****@*****.**"}' rpc.get_result = Mock(return_value=result) pswdless.urlfetch.create_rpc = Mock(return_value=rpc) fetch = Mock() pswdless.urlfetch.make_fetch_call = fetch post_params = {"app_id": "1", "token": "2", "ticket": valid_ticket} url_detail = "https://pswdless.appspot.com/rest/detail" params = {"url_detail": url_detail} params.update(post_params) response = Mock() response.set_cookie = Mock() cmd = LogUserIn(cookie_name="user", response=response, **params) cmd.execute() self.assertDictEqual({"id": "123456", "email": "*****@*****.**"}, cmd.result) fetch.assert_called_once_with( rpc, url_detail, urllib.urlencode(post_params), method=urlfetch.POST, validate_certificate=True ) self.assertIsNone(LoginEmailSentCertified.find_by_ticket(valid_ticket).get()) response.set_cookie.assert_called_once_with("user", cmd._signed, httponly=True)
def test_head_object_with_json(self): http_response = Mock() http_response.encoding = 'utf-8' http_response.headers = CaseInsensitiveDict( {'Date': 'Thu, 22 Aug 2013 02:11:57 GMT', 'Content-Length': '0', 'x-amz-request-id': '2B74ECB010FF029E', 'ETag': '"40d06eb6194712ac1c915783004ef730"', 'Server': 'AmazonS3', 'content-type': 'application/json', 'Content-Type': 'application/json', 'accept-ranges': 'bytes', 'Last-Modified': 'Tue, 20 Aug 2013 18:33:25 GMT', 'x-amz-server-side-encryption': 'AES256'}) http_response.content = '' put_object = self.s3.get_operation('HeadObject') expected = {"AcceptRanges": "bytes", "ContentType": "application/json", "LastModified": "Tue, 20 Aug 2013 18:33:25 GMT", "ContentLength": "0", "ETag": '"40d06eb6194712ac1c915783004ef730"', "ServerSideEncryption": "AES256" } response_data = get_response(self.session, put_object, http_response)[1] self.assertEqual(response_data, expected)
def test_fail_max_retry(self): # this tests the read function when HTTP requests keep returning 503s # read call fails when it reaches the maximum number of retries, in # this case set to 2 # mock the 503 responses mock_resp = Mock(name="503 resp") mock_resp.status_code = 503 mock_resp.content = "Testing" headers = {'Content-Length': 10, 'X-CADC-Content-Length': 5, 'Retry-After': 4} def getheader(name, default): return headers[name] mock_resp.headers = MagicMock() mock_resp.headers.get.side_effect = getheader conn = Connection() conn.session.send = Mock(return_value=mock_resp) vofile = vos.VOFile(["Some URL"], conn, "GET") req = requests.Request("GET", "http://some/url") vofile.request = req.prepare() # set number of retries to 1 and check the OSError was thrown vofile.maxRetries = 1 with self.assertRaises(OSError) as cm: vofile.read() mock_resp.headers.get.assert_called_with('Retry-After', 5)
def it_can_construct_a_special_uri_for_delete_operations(self): class Doc(Document): id = fields.NumberField() class Meta: backend_type = 'http' def uri(self): return 'get' def delete_uri(self): return 'delete' manager = BackendManager('http') doc = Doc({'id': 1}) expected = {'id': 1} response = Mock(name='mock_http_response') response.status_code = 200 # set the return value of the GET request and the DELETE request self.mock_request.delete.return_value = response response.content = json.dumps(expected) self.mock_request.get.return_value = response # now make the fetch operation manager.delete(doc) # we should have made one GET and one PUT request eq_([('delete', {'url': 'delete'})], self.mock_request.method_calls)
def it_can_update_the_document_on_the_remote_backend(self): class Doc(Document): id = fields.NumberField() name = fields.StringField() class Meta: backend_type = 'http' def uri(self): return 'http://location' doc = Doc({'id': 1}) expected = { 'id': 1, 'name': 'other', } response = Mock(name='mock_http_response') response.content = json.dumps(expected) response.status_code = 200 # set the return value of the GET request self.mock_request.get.return_value = response self.mock_request.put.return_value = response doc.update({'name': 'other'}) # we should have made one GET and one PUT request eq_([('get', {'url': 'http://location'}), ('put', {'url': 'http://location', 'data': json.dumps(expected)})], self.mock_request.method_calls) eq_('other', doc.name)
def it_can_delete_resources_from_a_remote_endpoint(self): mock_resp = Mock(name="mock_response") expected = {'id': 1} mock_resp.content = json.dumps(expected) mock_resp.status_code = 204 self.mock_request.delete.return_value = mock_resp manager = BackendManager('http') class Doc(Document): id = fields.NumberField() class Meta: backend_type = 'http' def uri(self): return 'http://location' doc = Doc({'id': 1}) manager.delete(doc) # make sure we are working with correct expectations eq_(HttpBackendManager, type(manager)) eq_([ ('delete', {'url': doc.uri()}) ], self.mock_request.method_calls)
def it_can_fetch_resources_from_a_remote_endpoint(self): mock_resp = Mock(name="mock_response") expected = {'id': 1} mock_resp.content = json.dumps(expected) mock_resp.status_code = 200 self.mock_request.get.return_value = mock_resp manager = BackendManager('http') class Doc(Document): id = fields.NumberField() class Meta: backend_type = 'http' def uri(self): return 'http://location' doc = Doc({'id': 1}) # the http manager returns the response as python dict content = manager.fetch(doc) # make sure we are working with correct expectations eq_(HttpBackendManager, type(manager)) eq_(mock_resp, manager.response) ok_(isinstance(content, dict)) eq_([('get', {'url': doc.uri()})], self.mock_request.method_calls)
def test_success(self): rpc = Mock() result = Mock() result.status_code = 200 result.content = '{"ticket":"123456"}' rpc.get_result = Mock(return_value=result) pswdless.urlfetch.create_rpc = Mock(return_value=rpc) fetch = Mock() pswdless.urlfetch.make_fetch_call = fetch post_params = { "app_id": 1, "token": "2", "hook": "http://yourhooke.com", "email": "*****@*****.**", "lang": "pt_BR", } url = "https://pswdless.appspot.com/rest/login" send_login_params = {"url_login": url} send_login_params.update(post_params) send_login = facade.send_login_email(**send_login_params) send_login.execute() self.assertDictEqual({"ticket": "123456"}, send_login.result) les_model = LoginEmailSentCertified.find_by_ticket("123456").get() self.assertEqual("123456", les_model.ticket) fetch.assert_called_once_with( rpc, url, urllib.urlencode(post_params), method=urlfetch.POST, validate_certificate=True )
def test_get_response_size_from_content(self): parser = HTMLParser('', False) mock_response = Mock() mock_response.headers = {} mock_response.content = '1234567890' parser.response = mock_response assert parser.get_response_size() == 10
def test_unexpected_response(self): response = Mock() response.status_code = 422 response.content = '{"message": "Unprocessable Entity"}' exception = UnexpectedResponse(response) self.assertEqual("%s" % exception, "Unexpected response from server (Error code: 422, Message: Unprocessable Entity)")
def test_unexpected_response_without_error_message(self): response = Mock() response.status_code = 422 response.content = 'no processable response' exception = UnexpectedResponse(response) self.assertEqual("%s" % exception, "Unexpected response from server (422 error code)")
def setUp(self): response = Mock() response.content = self.response_body response.status_code = 200 with patch('requests.post') as post: post.return_value = response self.perform_action()
def non_json_response(): mock_network_response = Mock(DefaultNetworkResponse) mock_network_response.content = b'' mock_network_response.ok = True mock_network_response.status_code = 200 mock_network_response.json.side_effect = ValueError('No JSON object could be decoded') return mock_network_response
def generic_successful_response(): mock_network_response = Mock(DefaultNetworkResponse) mock_network_response.content = b'{"message": "success"}' mock_network_response.status_code = 200 mock_network_response.ok = True mock_network_response.raw = Mock() return mock_network_response
def request(*args, **kwargs): response = Mock() response.status_code = status if fixture: fixture_path = os.path.join(FIXTURES, fixture) response.content = open(fixture_path).read() return response
def test_parse_fedora_access(self): TEMPLATE_TEXT = """ {% load fedora %} {% fedora_access %} {{ test_obj.value }} {% permission_denied %} permission fallback {% fedora_failed %} connection fallback {% end_fedora_access %} """ t = Template(TEMPLATE_TEXT) test_obj = MockFedoraObject() ctx = Context({'test_obj': test_obj}) val = t.render(ctx) self.assertEqual(val.strip(), 'sample text') response = Mock() response.status_code = 401 response.headers = {'content-type': 'text/plain'} response.content = '' test_obj._value = PermissionDenied(response) # force test_obj.value to fail val = t.render(ctx) self.assertEqual(val.strip(), 'permission fallback') response.status_code = 500 test_obj._value = RequestFailed(response) # force test_obj.value to fail val = t.render(ctx) self.assertEqual(val.strip(), 'connection fallback')
def create_mock_json(path, status_code=200): with open(path) as f: resp = Mock() resp.content = f.read() resp.json.return_value = json.loads(resp.content) resp.status_code = status_code return resp
def test_list_objects_with_invalid_content_length(self): http_response = Mock() http_response.encoding = 'utf-8' http_response.headers = CaseInsensitiveDict( {'Date': 'Thu, 22 Aug 2013 02:11:57 GMT', # We say we have 265 bytes but we're returning 0, # this should raise an exception because this is not # a HEAD request. 'Content-Length': '265', 'x-amz-request-id': '2B74ECB010FF029E', 'ETag': '"40d06eb6194712ac1c915783004ef730"', 'Server': 'AmazonS3', 'content-type': 'binary/octet-stream', 'Content-Type': 'binary/octet-stream', 'accept-ranges': 'bytes', 'Last-Modified': 'Tue, 20 Aug 2013 18:33:25 GMT', 'x-amz-server-side-encryption': 'AES256' }) http_response.content = '' http_response.request.method = 'GET' list_objects = self.s3.get_operation('ListObjects') expected = {"AcceptRanges": "bytes", "ContentType": "binary/octet-stream", "LastModified": "Tue, 20 Aug 2013 18:33:25 GMT", "ContentLength": "265", "ETag": '"40d06eb6194712ac1c915783004ef730"', "ServerSideEncryption": "AES256" } with self.assertRaises(IncompleteReadError): response_data = get_response(self.session, list_objects, http_response)[1]
def setUp(self): # mock request object request = Request() request.method = 'GET' request.url = 'http://example.com/' request.params = {} request.data = {} request.params_and_data = {} self.request = request # mock response object response = Mock() response.content = 'access_token=321' response.headers = {'content-type': 'text/html; charset=UTF-8'} response.ok = True response.status_code = 200 self.response = response # mock raise_for_status with an error def raise_for_status(): raise Exception('Response not OK!') self.raise_for_status = raise_for_status # mock hook object hook = Mock() hook.consumer_key = '123' hook.consumer_secret = '456' hook.access_token = '321' hook.access_token_secret = '654' self.hook = hook
def get_event(event_id, allow_none=True): m = Mock() m.content = events[event_id] d = defer.Deferred() self.reactor.callLater(0.0, d.callback, m) return d
def create_mock_response(self, fixture_name, status=200, headers={}): content = self.load_fixture(fixture_name) mock_response = Mock() mock_response.content = content mock_response.status_code = status return mock_response
def unauthorized_response(): res = Mock(Response) res.content = b'' res.status_code = 401 res.ok = False return res
def _create_mock_web_page(page_type=-1, content="content"): mock_web_page = Mock(spec=WebPage) mock_web_page.type = page_type mock_web_page.content = content return mock_web_page
def fake_recurring_response(*args, **kwargs): resp = Mock() resp.content = get_content('recurring_response.ics') resp.status_code = 200 return resp
def _error_response(self): error_response = Mock(['content']) error_response.content = '{"errors": []}'.encode('utf8') return error_response
def make_request(self, *args, **kwargs): response = Mock() response.status_code = 204 response.content = "{}".encode('utf8') return response
def fake_http_200_response(*args, **kwargs): resp = Mock() resp.content = get_content('http_response.html') resp.status_code = 200 return resp
def create_mock_json(path): with open(path) as f: resp = Mock() resp.content = f.read() return resp
def mock_response(self, mock, body, code): result = Mock() result.content = body result.status_code = code mock.request = Mock(return_value=result)