def test_autoCreateSensor(self): sensorNotFound = Mock() sensorNotFound.status_code = 404 sensorNotFound.text = '{"errorcode": "404-001", "message": ""}' created = Mock() created.status_code = 201 ok = Mock() ok.status_code = 200 request = Mock() request.side_effect = [authRequest(), sensorNotFound, created, ok] sensorcloud.webrequest.Requests.Request = request device = sensorcloud.Device("FAKE", "fake") sensor = device.sensor("sensor") self.assertTrue("channel" in sensor) calls = [ mock.call('GET', 'https://dsx.sensorcloud.microstrain.com/SensorCloud/devices/FAKE/sensors/sensor/channels/channel/attributes/', mock.ANY), mock.call('PUT', 'https://dsx.sensorcloud.microstrain.com/SensorCloud/devices/FAKE/sensors/sensor/', mock.ANY), mock.call('GET', 'https://dsx.sensorcloud.microstrain.com/SensorCloud/devices/FAKE/sensors/sensor/channels/channel/attributes/', mock.ANY) ] request.assert_has_calls(calls)
def get_mock(): ysc = youtube_status_code yu = youtube_url yc = youtube_cookies yt = youtube_text yh = youtube_headers yosc = youtube_oembed_status_code you = youtube_oembed_url yoh = youtube_oembed_headers yot = youtube_oembed_text mock_obj_1 = Mock() mock_obj_1.status_code = ysc mock_obj_1.url = yu mock_obj_1.headers = yh mock_obj_1.cookies = yc mock_obj_1.text = yt mock_obj_1.json = lambda: json.loads(mock_obj_1.text) mock_obj_2 = Mock() mock_obj_2.status_code = 200 mock_obj_2.url = you mock_obj_2.headers = yoh mock_obj_2.text = yot mock_obj_2.json = lambda: json.loads(mock_obj_2.text) return [mock_obj_1, mock_obj_1, mock_obj_2]
def setUp(self, mock_requests): mock_tournament_response = Mock(spec=requests.Response) mock_matches_response = Mock(spec=requests.Response) mock_participants_response = Mock(spec=requests.Response) with open(TOURNAMENT_JSON_FILE) as f: self.tournament_json_dict = json.load(f) with open(MATCHES_JSON_FILE) as f: self.matches_json_dict = json.load(f) with open(PARTICIPANTS_JSON_FILE) as f: self.participants_json_dict = json.load(f) mock_tournament_response.status_code = 200 mock_matches_response.status_code = 200 mock_participants_response.status_code = 200 mock_tournament_response.json.return_value = self.tournament_json_dict mock_matches_response.json.return_value = self.matches_json_dict mock_participants_response.json.return_value = self.participants_json_dict expected_tournament_url = scraper.challonge.TOURNAMENT_URL % TOURNAMENT_ID; expected_matches_url = scraper.challonge.MATCHES_URL % TOURNAMENT_ID; expected_participants_url = scraper.challonge.PARTICIPANTS_URL % TOURNAMENT_ID; mock_requests_return_values = { (expected_tournament_url, TEMPLATE_API_KEY): mock_tournament_response, (expected_matches_url, TEMPLATE_API_KEY): mock_matches_response, (expected_participants_url, TEMPLATE_API_KEY): mock_participants_response } mock_requests.get.side_effect = lambda url, **kwargs: mock_requests_return_values[(url, kwargs['params']['api_key'])] self.scraper = ChallongeScraper(TOURNAMENT_ID, TEMPLATE_CONFIG_FILE_PATH)
def test_import_geospatial_data_task_error(self, post_mock, execute_tasks_mock, delete_mock, get_mock): """Import data source test with task failing.""" get_mock.__name__ = 'get' delete_mock.__name__ = 'delete' post_mock.__name__ = 'post' res = {'uuid': 'test_blob_uuid'} mock_1 = Mock() mock_1.status_code = 200 mock_1.json.return_value = res post_mock.return_value = mock_1 mock_2 = Mock() mock_2.status_code = 200 mock_2.json.side_effect = snowfloat.errors.RequestError(status=500, code=None, message=None, more=None) delete_mock.return_value = mock_2 mock_3 = Mock() mock_3.status_code = 200 mock_3.json.side_effect = [ {'uuid': 'test_blob_uuid', 'state': 'started'}, {'uuid': 'test_blob_uuid', 'state': 'success'}] get_mock.return_value = mock_3 execute_tasks_mock.return_value = [{'error': 'test_error'},] tfile = tempfile.NamedTemporaryFile(delete=False) tfile.close() self.assertRaises(snowfloat.errors.RequestError, self.client.import_geospatial_data, tfile.name, srid=4326, state_check_interval=0.1) self.import_geospatial_data_helper(post_mock, get_mock, execute_tasks_mock) os.remove(tfile.name)
def test_auth_header_preserved_from_s3_redirects(self): request = AWSRequest() request.url = 'https://bucket.s3.amazonaws.com/' request.method = 'GET' request.headers['Authorization'] = 'original auth header' prepared_request = request.prepare() fake_response = Mock() fake_response.headers = { 'location': 'https://bucket.s3-us-west-2.amazonaws.com'} fake_response.url = request.url fake_response.status_code = 307 fake_response.is_permanent_redirect = False # This line is needed to disable the cookie handling # code in requests. fake_response.raw._original_response = None success_response = Mock() success_response.raw._original_response = None success_response.is_redirect = False success_response.status_code = 200 session = PreserveAuthSession() session.send = Mock(return_value=success_response) list(session.resolve_redirects( fake_response, prepared_request, stream=False)) redirected_request = session.send.call_args[0][0] # The Authorization header for the newly sent request should # still have our original Authorization header. self.assertEqual( redirected_request.headers['Authorization'], 'original auth header')
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 test_registration(self): """ Test handle registration and subsequent checks. """ client = self.portal.handle_client response = Mock() response.status_code = 201 response.headers = {"location": self.handle_url} client.session.post = Mock(return_value=response) view = self.portal.page.restrictedTraverse('hasHandle') self.assertEqual(view.create(), self.handle_url) self.assertTrue(view.hasHandle()) self.assertEqual(view.handle(), self.handle) response.status_code = 204 response.text = '' client.session.get = Mock(return_value=response) client.session.put = Mock(return_value=response) client.session.delete = Mock(return_value=response) self.assertEqual(view.read(), self.handle_url) self.assertEqual(view.update(), self.handle_url) self.assertTrue(view.hasDeletePermission()) self.assertEqual(view.delete(), None)
def test_get_techloan_data(self): """ Tests that getting the data from the techloan instance returns the expected data and raises errors appropriately """ test_json = self.load_json_file('cte_techloan_type_data.json') status_codes = [200, 400] # Mock a get call with different status codes returned for status in status_codes: mock = Mock() mock.status_code = status mock.json = Mock(return_value=test_json) with patch.object(requests, 'get', return_value=mock): techloan_data = cte_techloan.get_techloan_data() if (status == 200): self.assertEqual(techloan_data, test_json) else: self.assertIs(techloan_data, None) # Mock a call with invalid techloan_data test_json = 1 mock = Mock() mock.status_code = 200 mock.json = Mock(return_value=test_json) with patch.object(requests, 'get', return_value=mock): techloan_data = cte_techloan.get_techloan_data() self.assertIs(techloan_data, None)
def test_import_geospatial_data_blob_state_failure(self, post_mock, execute_tasks_mock, delete_mock, get_mock): """Import data source test with upload blob failing.""" get_mock.__name__ = 'get' delete_mock.__name__ = 'delete' post_mock.__name__ = 'post' res = {'uuid': 'test_blob_uuid'} mock_1 = Mock() mock_1.status_code = 200 mock_1.json.return_value = res post_mock.return_value = mock_1 mock_2 = Mock() mock_2.status_code = 200 mock_2.json.return_value = {} delete_mock.return_value = mock_2 mock_3 = Mock() mock_3.status_code = 200 mock_3.json.side_effect = [ {'uuid': 'test_blob_uuid', 'state': 'started'}, {'uuid': 'test_blob_uuid', 'state': 'failure'}] get_mock.return_value = mock_3 tfile = tempfile.NamedTemporaryFile(delete=False) tfile.close() self.assertRaises(snowfloat.errors.RequestError, self.client.import_geospatial_data, tfile.name, state_check_interval=0.1) self.import_geospatial_data_helper(post_mock, get_mock, execute_tasks_mock, validate_execute_tasks=False) os.remove(tfile.name)
def test_resource_in_discovery_container_after_get_patch_delete(self): with mock.patch('requests.get') as requests_get_mock: resource = {"@odata.id": "odata.id", "something": "irrelevant"} get_response = Mock() get_response.status_code = ReturnCodes.OK get_response.headers = {} get_response.text = json.dumps(resource) requests_get_mock.return_value = get_response discovery_container = DiscoveryContainer() self.api_caller.get_resource("/resource", discovery_container) self.assertEqual(discovery_container["http://{API_ENDPOINT}/resource".format( API_ENDPOINT=API_ENDPOINT)].body, resource) patched_resource = {"@odata.id": "odata.id", "something": "relevant"} get_response.text = json.dumps(patched_resource) with mock.patch('requests.patch') as requests_patch_mock: patch_response = Mock() patch_response.status_code = ReturnCodes.OK patch_response.headers = {} patch_response.text = "{}" requests_patch_mock.return_value = patch_response _, _, _, _ = self.api_caller.patch_resource("/resource", discovery_container) self.assertEqual(discovery_container["http://{API_ENDPOINT}/resource".format( API_ENDPOINT=API_ENDPOINT)].body, patched_resource) with mock.patch('requests.delete') as requests_delete_mock: delete_response = Mock() delete_response.status_code = ReturnCodes.NO_CONTENT delete_response.headers = {} delete_response.text = "" requests_delete_mock.return_value = delete_response _, _, _, _ = self.api_caller.delete_resource("/resource", discovery_container) self.assertNotIn("/resource", discovery_container)
def test_delete(self): resp = Mock() resp.status_code = 200 body = None self.instances.api.client.delete = Mock(return_value=(resp, body)) self.instances.delete('instance1') resp.status_code = 500 self.assertRaises(Exception, self.instances.delete, 'instance1')
def get(self, url): self.count += 1 resp = Mock(spec = requests.models.Response) if self.count == 3: resp.status_code = 200 resp.content = self.successful_response else: resp.status_code = 500 return resp
def test__action(self): resp = Mock() self.management.api.client.post = Mock(return_value=(resp, 'body')) resp.status_code = 200 self.management._action(1, 'body') self.assertEqual(1, self.management.api.client.post.call_count) resp.status_code = 400 self.assertRaises(Exception, self.management._action, 1, 'body') self.assertEqual(2, self.management.api.client.post.call_count)
def side_effect(*args, **kwargs): response = Mock() data = json.loads(kwargs.get("data", "{}")) if "source_language_code" in data and "name" in data and "slug" in data: response.status_code = 201 else: response.status_code = 400 return response
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 test_index(self): resp = Mock() resp.status_code = 400 body = {"Accounts": {}} self.accounts.api.client.get = Mock(return_value=(resp, body)) self.assertRaises(Exception, self.accounts.index) resp.status_code = 200 self.assertTrue(isinstance(self.accounts.index(), base.Resource)) self.accounts.api.client.get = Mock(return_value=(resp, None)) self.assertRaises(Exception, self.accounts.index)
def side_effect(*args, **kwargs): response = Mock() data = json.loads(kwargs.get('data', "{}")) if 'source_language_code' in data and 'name' in data and 'slug' in \ data: response.status_code = 201 else: response.status_code = 400 return response
def test_fetch_page_errors(self): """Should handle bad JSON and 500s""" client = Mock() response = Mock() client.get.return_value = response response.status_code = 500 self.assertEqual({'results': []}, fr.fetch_page(2003, 2, 1, client)) response.status_code = 200 response.json.side_effect = ValueError self.assertEqual({'results': []}, fr.fetch_page(2003, 2, 1, client))
def side_effect(*args, **kwargs): response = Mock() response.status_code = 201 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' break return 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_given_status_ok_then_no_error_raised(self): response = Mock() response.status_code = 200 self.confd_session.check_response(response) response.status_code = 201 self.confd_session.check_response(response) response.status_code = 204 self.confd_session.check_response(response) call_count = response.raise_for_status.call_count assert_that(call_count, equal_to(0))
def test_reauthentication(self): unauthorized = Mock() unauthorized.status_code = 401 ok = Mock() ok.status_code = 200 request = Mock() request.side_effect = [authRequest(), unauthorized, authRequest(), ok] sensorcloud.webrequest.Requests.Request = request device = sensorcloud.Device("FAKE", "fake") response = device.url("/fake/").get() self.assertEqual(response.status_code, 200)
def test_fetch_access_token(self, mock_client_log_request, mock_oauth1): # mock the OAuth1 and session post response mock_oauth1.return_value = "oauth" r = Mock() r.content = "oauth_token=key" self.mock_requests_session.return_value.post.return_value = r self.client._token = {"key": "key", "secret": "secret", "verifier": "verifier"} # UnAuthorized Case r.status_code = 401 with self.assertRaises(ox3apiclient.OAuthException): self.client.fetch_access_token() # Authorized Case r.status_code = 200 self.assertEqual(self.client.fetch_access_token(), "key")
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_decode_gzip(self, r_g): def compressed_gzip_body(): stream = cStringIO.StringIO() compressor = gzip.GzipFile(fileobj=stream, mode='w') compressor.write(u"é".encode('utf-8') * 100) compressor.close() stream.seek(0) return stream normal_response_object = Mock() # Build an HTTPResponse object like the one requests uses, with # a gzip compressed body. `decode_content` needs to be False to # properly emulate requests behaviour : it's the caller's # responsability to decode, since it's supposed to be a raw stream. body = compressed_gzip_body() normal_response_object.raw = HTTPResponse( status=200, preload_content=False, headers={ 'content-encoding': 'gzip', 'content-type': 'application/blah; charset=utf-8' }, body=body, decode_content=False) normal_response_object.encoding = 'UTF-8' normal_response_object.status_code = 200 r_g.return_value = normal_response_object eq_(appbase.try_get_resource(self.err, None, "http://foo.bar/", ""), u"é" * 100) self.assert_silent()
def test_put_validation_error(self): path = 'foo' url = 'https://api.jirafe.com/v1/id/foo' data_string = '{"bar":"baz"}' auth_header = "some header" session = Mock() session.site_id = 'id' session.get_header = Mock(return_value=auth_header) options = { "data": data_string, "headers": auth_header } errors = { 'foo': 'foo error', 'bar': 'bar error', } json_response = {'success': False, 'error_type': 'validation', 'errors': errors} put_response = {'errors': errors} mock_response = Mock() mock_response.json = Mock(return_value=put_response) mock_response.status_code = 400 self.requests.put = Mock(return_value=mock_response) actual_response = self.client._put(session, path, data_string) self.requests.put.assert_called_with(url, **options) self.assertEqual(json_response, actual_response)
def post(url, data, verify=True): response = Mock() if not post.called: response.status_code = 404 post.called = True response.text = 'I AINT NO JSON, FOOL!' return response
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_sf_form_proxy(self, post_patch): new_mock = Mock() new_mock.status_code = 200 post_patch.return_value = new_mock with self.activate('en-US'): url = reverse('about.partnerships.contact-bizdev') resp = self.client.post(url, { 'first_name': 'The', 'last_name': 'Dude', 'title': 'Abider of things', 'company': 'Urban Achievers', 'email': '*****@*****.**', }, HTTP_X_REQUESTED_WITH='XMLHttpRequest') self.assertEqual(resp.status_code, 200) self.assertEqual(resp.content, 'ok') post_patch.assert_called_once_with(ANY, { 'first_name': u'The', 'last_name': u'Dude', 'description': u'', 'retURL': 'http://www.mozilla.org/en-US/about/' 'partnerships?success=1', 'title': u'Abider of things', 'URL': u'', 'company': u'Urban Achievers', 'oid': '00DU0000000IrgO', 'phone': u'', 'mobile': u'', '00NU0000002pDJr': [], 'email': u'*****@*****.**', })
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_get_file(self, mock_open, mock_requests_get, mock_session_post, mock_isfile): mock_file = MagicMock(spec=file) mock_open.return_value = mock_file c = DataClient(certfile=test_cert) self.assertTrue(c.is_authorized) #logger = c.get_logger(debug=True) # a couple of mocked responses to requests mock_response = Mock() mock_response.text = test_get_transfer_resp_xml mock_response.status_code = 200 mock_response.history = [1] mock_response_get = Mock() mock_response_get.text = test_get_transfer_resp_xml mock_response_get.status_code = 200 mock_response_get.history = [1] mock_response_get.iter_content = Mock(return_value=[1]) mock_response_get_fail = Mock() mock_response_get_fail.text = test_get_transfer_resp_xml mock_response_get_fail.status_code = 503 mock_response_get_fail.history = [1] mock_response_get_fail.raise_for_status = Mock( side_effect=Exception('Failed.')) # We mock the client session POST response to return desired # XML with a list of endpoints. We then check that the post # was called with the correct values. # The "mock_requests_get" is called to actually get the data, # and we ensure it is called with the correct endpoint. It also # requires an "iter_content" method that returns an iterable # to simulate streaming. mock_session_post.return_value = mock_response mock_requests_get.return_value = mock_response_get c.transfer_file(test_localfile, uri=test_uri) mock_session_post.assert_called_once_with(c.base_url, data=test_get_transfer_xml, json=None, verify=False, headers=test_headers) mock_requests_get.assert_called_once_with(test_endpoint1, stream=True) mock_open.reset_mock() mock_requests_get.reset_mock() mock_session_post.reset_mock() mock_isfile.reset_mock() # First GET (endpoint1) returns a failed response. The second # GET (endpoint2) will work mock_requests_get.side_effect = [ mock_response_get_fail, mock_response_get ] c.transfer_file(test_localfile, uri=test_uri) mock_session_post.assert_called_once_with(c.base_url, data=test_get_transfer_xml, json=None, verify=False, headers=test_headers) mock_requests_get.assert_has_calls([ call(test_endpoint1, stream=True), call(test_endpoint2, stream=True) ]) mock_open.reset_mock() mock_requests_get.reset_mock() mock_session_post.reset_mock() mock_isfile.reset_mock() # Both endpoints, and therefore the transfer, fail mock_requests_get.side_effect = [ mock_response_get_fail, mock_response_get_fail ] with self.assertRaises(TransferException): c.transfer_file(test_localfile, uri=test_uri) mock_session_post.assert_called_once_with(c.base_url, data=test_get_transfer_xml, json=None, verify=False, headers=test_headers) mock_requests_get.assert_has_calls([ call(test_endpoint1, stream=True), call(test_endpoint2, stream=True) ]) mock_open.reset_mock() mock_requests_get.reset_mock() mock_session_post.reset_mock() mock_isfile.reset_mock()
def test_put_file(self, mock_open, mock_requests_put, mock_session_post, mock_isfile): mock_file = MagicMock(spec=file) mock_open.return_value = mock_file c = DataClient(certfile=test_cert) self.assertTrue(c.is_authorized) #logger = c.get_logger(debug=True) # a couple of mocked responses to requests mock_response = Mock() mock_response.text = test_put_transfer_resp_xml mock_response.status_code = 200 mock_response.history = [1] mock_response_fail = Mock() mock_response_fail.text = test_put_transfer_resp_xml mock_response_fail.status_code = 503 mock_response_fail.history = [1] mock_response_fail.raise_for_status = Mock( side_effect=Exception('Failed.')) # make sure that transfer_file raises en error on bad inputs with self.assertRaises(ValueError): c.transfer_file(test_localfile) # We mock the client session POST response to return desired # XML with a list of endpoints. We then check that the post # was called with the correct values. # The "mock_requests_put" is called to actually put the data, # and we ensure it is called with the correct endpoint. # # We do the whole thing three times: first time specifying a uri, # second time specifying archive (filename for URI derived from # local filename), and finally specifying both archive and filename. for i in range(3): mock_session_post.return_value = mock_response mock_requests_put.return_value = mock_response if i is 0: c.transfer_file(test_localfile, uri=test_uri, is_put=True) elif i is 1: c.transfer_file(test_localfile, archive=test_archive, is_put=True) else: c.transfer_file(test_localfile, archive=test_archive, filename=test_localfile, is_put=True) mock_session_post.assert_called_once_with( c.base_url, data=test_put_transfer_xml, json=None, verify=False, headers=test_headers) mock_requests_put.assert_called_once_with(test_endpoint1, data=mock_file) mock_open.reset_mock() mock_requests_put.reset_mock() mock_session_post.reset_mock() mock_isfile.reset_mock() # Test specifying the stream mock_session_post.return_value = mock_response mock_requests_put.return_value = mock_response c.transfer_file(test_localfile, archive=test_archive, filename=test_localfile, is_put=True, stream=test_stream) expected_headers = copy.deepcopy(test_headers) expected_headers['X-CADC-Stream'] = test_stream mock_session_post.assert_called_once_with(c.base_url, data=test_put_transfer_xml, json=None, verify=False, headers=expected_headers) mock_requests_put.assert_called_once_with(test_endpoint1, data=mock_file) mock_open.reset_mock() mock_requests_put.reset_mock() mock_session_post.reset_mock() mock_isfile.reset_mock() # First PUT (endpoint1) returns a failed response. The second # PUT (endpoint2) will work mock_requests_put.side_effect = [mock_response_fail, mock_response] c.transfer_file(test_localfile, uri=test_uri, is_put=True) mock_session_post.assert_called_once_with(c.base_url, data=test_put_transfer_xml, json=None, verify=False, headers=test_headers) mock_requests_put.assert_has_calls([ call(test_endpoint1, data=mock_file), call(test_endpoint2, data=mock_file) ]) mock_open.reset_mock() mock_requests_put.reset_mock() mock_session_post.reset_mock() mock_isfile.reset_mock() # Both endpoints, and therefore the transfer, fail mock_requests_put.side_effect = [ mock_response_fail, mock_response_fail ] with self.assertRaises(TransferException): c.transfer_file(test_localfile, uri=test_uri, is_put=True) mock_session_post.assert_called_once_with(c.base_url, data=test_put_transfer_xml, json=None, verify=False, headers=test_headers) mock_requests_put.assert_has_calls([ call(test_endpoint1, data=mock_file), call(test_endpoint2, data=mock_file) ]) mock_open.reset_mock() mock_requests_put.reset_mock() mock_session_post.reset_mock() mock_isfile.reset_mock() # An anonymous put should raise an UnauthorizedException c.is_authorized = False with self.assertRaises(UnauthorizedException): c.transfer_file(test_localfile, uri=test_uri, is_put=True)
def fake_http_404_response(*args, **kwargs): resp = Mock() resp.content = get_content('http_response.html') resp.status_code = 404 return resp
def _retry_after_response(status_code): mock_network_response = Mock(DefaultNetworkResponse, headers={}) mock_network_response.status_code = status_code mock_network_response.headers.update({'Retry-After': '1'}) return mock_network_response
def mock_response(self, mock, body, code): result = Mock() result.content = body result.status_code = code mock.fetch = Mock(return_value=result)
def sixpack_unavailable(*args, **kwargs): m = Mock() m.status_code = 500 m.content = '{"status": "failed"}' return m
def api_not_found_job_response(): mock_response = Mock() mock_response.status_code = 200 text = {"SearchResult": {"SearchResultCount": 0, "SearchResultItems": []}} mock_response.text = json.dumps(text) return mock_response
def make_request(self, *args, **kwargs): response = Mock() response.status_code = 204 response.content = "{}".encode('utf8') return response
def get_side_effect(url): urls.append(url) mocked_response = Mock() mocked_response.status_code = 404 return mocked_response
def create_mock_response(self, body, status_code=200): response = Mock() response.content = body response.status_code = status_code return response
def make_response(self, text, status_code=200): fake_response = Mock() fake_response.text = text fake_response.status_code = status_code return fake_response
def server_error_response(request): mock_network_response = Mock(DefaultNetworkResponse) mock_network_response.status_code = int(request.param) return mock_network_response
def retry_after_response(request): mock_network_response = Mock(DefaultNetworkResponse) mock_network_response.status_code = int(request.param) mock_network_response.headers = {'Retry-After': '1'} return mock_network_response
def new_participate(*args, **kwargs): m = Mock() m.status_code = 200 m.json.return_value = {"status": "ok"} return m
def new_convert(*args, **kwargs): m = Mock() m.status_code = 200 m.json.return_value = {"status": "ok"} return m
def test_upload_file(app, default_user, _get_user_mock): """Test upload_file view.""" with app.test_client() as client: with patch("reana_server.rest.workflows.requests"): file_content = b"Upload this data." res = client.post( url_for("workflows.upload_file", workflow_id_or_name="1"), query_string={"file_name": "test_upload.txt"}, input_stream=BytesIO(file_content), ) assert res.status_code == 403 # wrong content type res = client.post( url_for("workflows.upload_file", workflow_id_or_name="1"), query_string={ "access_token": default_user.access_token, "file_name": "test_upload.txt", }, headers={"Content-Type": "multipart/form-data"}, input_stream=BytesIO(file_content), ) assert res.status_code == 400 # missing file name res = client.post( url_for("workflows.upload_file", workflow_id_or_name="1"), query_string={ "access_token": default_user.access_token, "file_name": None, }, headers={"Content-Type": "application/octet-stream"}, input_stream=BytesIO(file_content), ) assert res.status_code == 400 requests_mock = Mock() requests_response_mock = Mock() requests_response_mock.status_code = 200 requests_response_mock.json = Mock(return_value={"message": "File uploaded."}) requests_mock.post = Mock(return_value=requests_response_mock) with patch( "reana_server.rest.workflows.requests", requests_mock ) as requests_client: res = client.post( url_for("workflows.upload_file", workflow_id_or_name="1"), query_string={ "access_token": default_user.access_token, "file_name": "test_upload.txt", }, headers={"Content-Type": "application/octet-stream"}, input_stream=BytesIO(file_content), ) requests_client.post.assert_called_once() assert ( file_content == requests_client.post.call_args_list[0][1]["data"].read() ) # empty file res = client.post( url_for("workflows.upload_file", workflow_id_or_name="1"), query_string={ "access_token": default_user.access_token, "file_name": "empty.txt", }, headers={"Content-Type": "application/octet-stream"}, input_stream=BytesIO(b""), ) assert requests_client.post.call_count == 2 data = requests_client.post.call_args_list[1][1]["data"] assert not len(data) assert not data.read()
def fake_gcal_response(*args, **kwargs): resp = Mock() resp.content = get_content('gcal_response.ics') resp.status_code = 200 return resp
def mock_response(status_code='get', content={}): CODES = dict(get=200, patch=200, post=201, delete=204) response = Mock(name='response') response.status_code = CODES[str(status_code).lower()] or status_code response.content = content return response
def mock_response(self, status_code, urls=None): response = Mock() response.status_code = status_code self.parser.parse = Mock(return_value=urls) return response
def failed_non_json_response(): mock_network_response = Mock(DefaultNetworkResponse, headers={}) mock_network_response.status_code = 404 _set_content_and_json_from_content(mock_network_response, content=b'') mock_network_response.ok = False return mock_network_response
def fake_jenkins_response(*args, **kwargs): resp = Mock() resp.json = lambda: json.loads(get_content('jenkins_response.json')) resp.status_code = 200 return resp
def test_2XX(_1): incoming_response = Mock(spec=IncomingResponse) incoming_response.status_code = 200 operation = Mock(spec=Operation) swagger_result = response_callback(incoming_response, operation) assert swagger_result == 99
def fake_slow_graphite_response(*args, **kwargs): resp = Mock() time.sleep(0.1) resp.json = lambda: json.loads(get_content('graphite_null_response.json')) resp.status_code = 200 return resp
def jenkins_blocked_response(*args, **kwargs): resp = Mock() resp.json = json.loads(get_content('jenkins_blocked_response.json')) resp.status_code = 200 return resp
def test_handleResponse(self): response = Mock() response.status_code = 200 content = self.controller.handleResponse(response, None) self.assertEqual(content, "") content = self.controller.handleResponse(response, {"a": 1}) self.assertEqual(content, {"a": 1}) response.status_code = 301 with self.assertRaises(APIException) as cm: content = self.controller.handleResponse( response, { "Errors": { "Error": { "message": "Some error", "ReasonCode": "some code" } } }) self.assertEqual(cm.exception.getHttpStatus(), 301) self.assertEqual(cm.exception.getMessage(), "Moved Permanently") self.assertEqual(cm.exception.getReasonCode(), "some code") self.assertEqual(cm.exception.getSource(), None) with self.assertRaises(APIException) as cm: content = self.controller.handleResponse( response, { "Errors": { "Error": { "Source": "System", "ReasonCode": "SYSTEM_ERROR1", "Description": "Unknown Error1", "Recoverable": "false" } } }) self.assertEqual(cm.exception.getHttpStatus(), 301) self.assertEqual(cm.exception.getMessage(), "Unknown Error1") self.assertEqual(cm.exception.getReasonCode(), "SYSTEM_ERROR1") self.assertEqual(cm.exception.getSource(), "System") with self.assertRaises(APIException) as cm: content = self.controller.handleResponse( response, { "errors": { "error": { "source": "System", "reasoncode": "SYSTEM_ERROR1", "description": "Unknown Error1", "recoverable": "false" } } }) self.assertEqual(cm.exception.getHttpStatus(), 301) self.assertEqual(cm.exception.getMessage(), "Unknown Error1") self.assertEqual(cm.exception.getReasonCode(), "SYSTEM_ERROR1") self.assertEqual(cm.exception.getSource(), "System") with self.assertRaises(APIException) as cm: content = self.controller.handleResponse( response, { "errors": { "error": [{ "source": "System", "reasoncode": "SYSTEM_ERROR1", "description": "Unknown Error1", "recoverable": "false" }] } }) self.assertEqual(cm.exception.getHttpStatus(), 301) self.assertEqual(cm.exception.getMessage(), "Unknown Error1") self.assertEqual(cm.exception.getReasonCode(), "SYSTEM_ERROR1") self.assertEqual(cm.exception.getSource(), "System") response.status_code = 400 with self.assertRaises(APIException) as cm: content = self.controller.handleResponse( response, {"Errors": { "Error": { "message": "Some error" } }}) self.assertEqual(cm.exception.getHttpStatus(), 400) self.assertEqual(cm.exception.getMessage(), "Bad Request") self.assertEqual(cm.exception.getReasonCode(), None) self.assertEqual(cm.exception.getSource(), None) response.status_code = 401 with self.assertRaises(APIException) as cm: content = self.controller.handleResponse( response, {"Errors": { "Error": { "message": "Some error" } }}) self.assertEqual(cm.exception.getHttpStatus(), 401) self.assertEqual(cm.exception.getMessage(), "Unauthorized") self.assertEqual(cm.exception.getReasonCode(), None) self.assertEqual(cm.exception.getSource(), None) response.status_code = 403 with self.assertRaises(APIException) as cm: content = self.controller.handleResponse( response, {"Errors": { "Error": { "message": "Some error" } }}) self.assertEqual(cm.exception.getHttpStatus(), 403) self.assertEqual(cm.exception.getMessage(), "Forbidden") self.assertEqual(cm.exception.getReasonCode(), None) response.status_code = 404 with self.assertRaises(APIException) as cm: content = self.controller.handleResponse( response, {"Errors": { "Error": { "message": "Some error" } }}) self.assertEqual(cm.exception.getHttpStatus(), 404) self.assertEqual(cm.exception.getMessage(), "Not Found") self.assertEqual(cm.exception.getReasonCode(), None) self.assertEqual(cm.exception.getSource(), None) response.status_code = 405 with self.assertRaises(APIException) as cm: content = self.controller.handleResponse( response, {"Errors": { "Error": { "message": "Some error" } }}) self.assertEqual(cm.exception.getHttpStatus(), 405) self.assertEqual(cm.exception.getMessage(), "Method Not Allowed") self.assertEqual(cm.exception.getReasonCode(), None) self.assertEqual(cm.exception.getSource(), None) response.status_code = 500 with self.assertRaises(APIException) as cm: content = self.controller.handleResponse( response, {"Errors": { "Error": { "message": "Some error" } }}) self.assertEqual(cm.exception.getHttpStatus(), 500) self.assertEqual(cm.exception.getMessage(), "Internal Server Error") self.assertEqual(cm.exception.getReasonCode(), None) self.assertEqual(cm.exception.getSource(), None) self.assertEqual( cm.exception.getRawErrorData().get("Errors.Error.message"), "Some error") response.status_code = 500 with self.assertRaises(APIException) as cm: content = self.controller.handleResponse( response, { "errors": [{ "source": "OpenAPIClientId", "reasonCode": "AUTHORIZATION_FAILED", "key": "050007", "description": "Unauthorized Access", "recoverable": False, "requestId": None, "details": { "details": [{ "name": "ErrorDetailCode", "value": "050007" }] } }] }) self.assertEqual(cm.exception.getHttpStatus(), 500) self.assertEqual(cm.exception.getMessage(), "Unauthorized Access") self.assertEqual(cm.exception.getReasonCode(), "AUTHORIZATION_FAILED") self.assertEqual(cm.exception.getSource(), "OpenAPIClientId") self.assertEqual( cm.exception.getRawErrorData().get("errors[0].source"), "OpenAPIClientId")
def non_json_response(): mock_network_response = Mock(DefaultNetworkResponse, headers={}) _set_content_and_json_from_content(mock_network_response, content=b'') mock_network_response.ok = True mock_network_response.status_code = 200 return mock_network_response
def test_subscribe_success(self): response = Mock() response.status_code = 200 with patch('requests.post', return_value=response): MailchimpService.subscribe('*****@*****.**')
def fake_graphite_response(*args, **kwargs): resp = Mock() resp.json = json.loads(get_content('graphite_response.json')) resp.status_code = 200 return resp
def unauthorized_response(): res = Mock(DefaultNetworkResponse) res.content = b'' res.status_code = 401 res.ok = False return res
def get_mock_response(self, content=None): response = Mock() response.content = self.response_body if content is None else content response.status_code = 200 return response