def test_200_image_response(self): data_file = open( os.path.join( os.path.dirname(__file__), 'data/googlelogo_color_272x92dp.png' ), 'rb' ) response = MagicMock() response.status_code = 200 response.headers = { 'content-type': 'image/png' } response.content(data_file.read()) requests_patch = self.get_requests_patch(response) get_filename_fake = MagicMock() get_filename_fake.return_value = '1.png' get_filename_patch = mock.patch( 'image_downloader.utils.get_image_filename_from_response', get_filename_fake ) with requests_patch, get_filename_patch: image, filename = utils.get_image_by_url( 'http://existing-image.com/img/1.png' ) self.assertEquals(filename, '1.png')
def test_handle_response(self): connection = Connection("store.mybigcommerce.com", ("user", "abcdef")) # A normal, 200-ok response data = {"name": "Shirt"} res = MagicMock() res.headers = {"Content-Type": "application/json"} res.status_code = 200 res.content = json.dumps(data) res.json.return_value = data self.assertEqual(connection._handle_response("products/1", res), data) res.status_code = 500 self.assertRaisesHttpException( ServerException, lambda: connection._handle_response("products/1", res), # Test all of the properties of a HttpException 500, {"Content-Type": "application/json"}, json.dumps(data), ) res.status_code = 404 self.assertRaisesHttpException( ClientRequestException, lambda: connection._handle_response("products/1", res), 404 ) res.status_code = 301 self.assertRaisesHttpException( RedirectionException, lambda: connection._handle_response("products/1", res), 301 )
def test_get_success(self): http_session = MagicMock() http_session.get = MagicMock() response = MagicMock() http_session.get.return_value = response response.status_code = 200 response.content = 'dummy blob' blobs = BlobClient( http_session, 'http://example.com/blerbs/', ) result = blobs.get('sha1-7928f34bd3263b86e67d11efff30d67fe7f3d176') http_session.get.assert_called_with( "http://example.com/blerbs/camli/" "sha1-7928f34bd3263b86e67d11efff30d67fe7f3d176") self.assertEqual( type(result), Blob, ) self.assertEqual( result.data, 'dummy blob', )
def test_download_duplicate(self, mock_call, fake_copyfileobj): from tests.inputs import VALID_COMIC_INFO from tests.inputs import IMAGE_PAGE_CONTENT_1550 comic_info = VALID_COMIC_INFO page_info = IMAGE_PAGE_CONTENT_1550 mock_info_call = MagicMock(spec=Response) mock_info_call.json.return_value = get_comic_info() mock_info_call.return_value.status_code = 200 mock_info_call.return_value = page_info mock_image_call = MagicMock(spec=Response) mock_image_call.status_code = 200 mock_image_call.return_value.json.return_value = comic_info mock_image_call.content = page_info mock_image_content_call = MagicMock(spec=Response) mock_image_content_call.raw = MagicMock(spec=HTTPResponse) mock_image_content_call.status_code = 200 mock_call.side_effect = [ mock_info_call, mock_image_call, mock_image_content_call, mock_info_call, mock_image_call, mock_image_content_call ] xkcd_dl.cli.WORKING_DIRECTORY = tempfile.mkdtemp() download_one(get_fake_xkcd_json_dict(), 1550) download_one(get_fake_xkcd_json_dict(), 1550) assert sys.stdout.getvalue().split( '\n')[-2] == "xkcd number '1550' has already been downloaded!" shutil.rmtree(xkcd_dl.cli.WORKING_DIRECTORY, ignore_errors=True)
def test_b2_error(self): response = MagicMock() response.status_code = 503 response.content = six.b( '{"status": 503, "code": "server_busy", "message": "busy"}') with self.assertRaises(ServiceError): _translate_errors(lambda: response)
def test_json_parsing_error(self): # Make sure if the json parsing fails, we get a useful exception # Create a mock response that raises an exception when we try to get the json from it mock_response = MagicMock() mock_response.text = "This was the content" mock_response.content = mock_response.text.encode("utf-8") mock_response.json.side_effect = Exception("This is an exception") # Mock session that returns our mock response on a 'get' call. mock_session = MagicMock() mock_session.get.return_value = mock_response client = OnaApiClient("example.com", "2384729347234") with patch.object(client, "session") as mock_session_method: # 'session' method on our client returns our mock session mock_session_method.return_value = mock_session try: client.get("foo") except OnaApiClientException as e: # Make sure the exception has lots of useful info s = str(e) self.assertIn("could not be parsed", s) self.assertIn("This is an exception", s) self.assertIn("This was the content", s) else: self.fail("Expected OnaApiClientException")
def _request_side_effect(pay_inst, data, url, status=status): dic = pay_inst._request_dict if status == 'succeed': res_code = '00' elif status == 'fail': res_code = '01' elif status == 'wait': res_code = 'c0' res = MagicMock() res.status_code = 200 if url == pay_inst.DYNNUM_URL: res_content = """<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\ <MasMessage xmlns="http://www.99bill.com/mas_cnp_merchant_interface">\ <GetDynNumContent><merchantId>812310060110013</merchantId><customerId>%s</customerId>\ <storablePan>6214857068</storablePan><token>323881987</token><responseCode>%s</responseCode>\ </GetDynNumContent></MasMessage>\ """ % (dic['user_id'], res_code) elif url == pay_inst.PAY_URL: #需确保amount, externalRefNumber, customerId res_content = PAY_RES.substitute(amount=dic['amount'], order_id=dic['order_id'], user_id=dic['user_id'], res_code=res_code) res.content = res_content return res
def test_download_data(self, run_commands_mock, requests_get_mock, make_dir_mock, open_mock): # pylint: disable=unused-argument get_mock = MagicMock() get_mock.content = 'content' requests_get_mock.return_value = get_mock download_info_1 = { 'url': 'gs://remote_path_1/name_1', 'local_path': 'local_path_1/modified_name_1' } download_info_2 = { 'url': 'http://remote_path_2/name_2', 'local_path': 'local_path_2/modified_name_2' } utils.download_data([download_info_1, download_info_2]) make_dir_mock.assert_has_calls( any_order=False, calls=[call('local_path_1'), call('local_path_2')]) requests_get_mock.assert_called_once_with( 'http://remote_path_2/name_2', allow_redirects=True) run_commands_mock.assert_has_calls( any_order=False, calls=[ call([[ 'gsutil', '-m', 'cp', '-r', '-n', 'gs://remote_path_1/name_1', 'local_path_1' ]], shell=False), call(['mv local_path_1/name_1 local_path_1/modified_name_1']), call(['mv local_path_2/name_2 local_path_2/modified_name_2']) ])
def test_slack_delivery(self, mock_slack): slack_mailer_config = { 'queue_url': 'asq://storageaccount.queue.core.windows.net/queuename', 'slack_token': 'mock_token' } slack_compressed_message = MagicMock() slack_compressed_message.content = base64.b64encode( zlib.compress(ASQ_MESSAGE_SLACK.encode('utf8'))) slack_loaded_message = json.loads(ASQ_MESSAGE_SLACK) mock_slack.return_value\ .get_to_addrs_slack_messages_map.return_value = 'mock_slack_message_map' azure_processor = MailerAzureQueueProcessor(slack_mailer_config, logger) self.assertTrue( azure_processor.process_azure_queue_message( slack_compressed_message)) mock_slack.assert_has_calls([ call().slack_handler(slack_loaded_message, 'mock_slack_message_map') ])
def test__request_retries_login(self, mock_login): initial_xreply = {"return_code": 1, "content": "login_required"} pre_login_response = MagicMock(spec=requests.Response()) pre_login_response.status_code = 200 pre_login_response.content = json.dumps(initial_xreply) final_xreply = {"return_code": 0, "content": "success"} post_login_response = MagicMock(spec=requests.Response()) post_login_response.status_code = 200 post_login_response.content = json.dumps(final_xreply) side_effect = [pre_login_response, post_login_response] self.client.session.request = MagicMock(side_effect=side_effect) self.assertEquals((True, "success"), self.client._request("http://example.com"))
def test_request_user_info(self): with patch("wirecloud.fiware.social_auth_backend.requests") as requests_mock: response = MagicMock() response.content = '{"test": true}' requests_mock.get.return_value = response self.assertEqual(self.instance._request_user_info("token"), {"test": True})
def test_download_one(self, mock_call, fake_copyfileobj): from tests.inputs import VALID_COMIC_INFO from tests.inputs import IMAGE_PAGE_CONTENT_1550 comic_info = VALID_COMIC_INFO page_info = IMAGE_PAGE_CONTENT_1550 mock_info_call = MagicMock(spec=Response) mock_info_call.json.return_value = get_comic_info() mock_info_call.return_value.status_code = 200 mock_info_call.return_value = page_info mock_image_call = MagicMock(spec=Response) mock_image_call.status_code = 200 mock_image_call.return_value.json.return_value = comic_info mock_image_call.content = page_info mock_image_content_call = MagicMock(spec=Response) mock_image_content_call.raw = MagicMock(spec=HTTPResponse) mock_image_content_call.status_code = 200 mock_call.side_effect = [ mock_info_call, mock_image_call, mock_image_content_call ] xkcd_dl.cli.WORKING_DIRECTORY = tempfile.mkdtemp() download_one(get_fake_xkcd_json_dict(), 1550) xkcd_download_folder = xkcd_dl.cli.WORKING_DIRECTORY + "/xkcd_archive/1550/" files = os.listdir(xkcd_download_folder) assert "description.txt" in files assert 'EpisodeVII.jpg' in files assert os.path.getsize(xkcd_download_folder + "description.txt") == 238 shutil.rmtree(xkcd_dl.cli.WORKING_DIRECTORY, ignore_errors=True)
def test_get_fortune_pass_many_attempts_at_str_magic_method(self): response = MagicMock() response.status_code = 200 response.content = _TEST_RAW_DATA session = MagicMock() session.get.return_value = response self._subject._session.__enter__.return_value = session # handful of calls [ assert_that(str(self._subject), equal_to(_TEST_DECODED_DATA)) for _ in range(0, 32) ] time.sleep(1) # a handful more calls for _ in range(0, 32): assert_that(str(self._subject), equal_to(_TEST_DECODED_DATA)) # but there are only two calls to the Session assert_that( session.mock_calls, equal_to([ call.get(self._subject._api_url), call.get(self._subject._api_url), ]))
def test_withdraw_bch(self): with patch('requests.post') as mock_post: response = MagicMock() response.status_code = 200 response.content = {'success': True} response.json.return_value = { "success": True, "txid": "66a2987562a405648a6c5622ed6c205fca6169faa8afeb96a994b48010bd186a" } mock_post.return_value = response self.user.withdraw_bch('bchaddress') url = URL_API + '/user/withdraw_bch' mock_post.assert_called_with(url, json={ 'toAddress': 'bchaddress', 'password': '******' }, headers={ 'Content-Type': 'application/json', 'X-Access-Token': 'Token123' })
def test_handle_response(self): connection = Connection('store.mybigcommerce.com', ('user', 'abcdef')) # A normal, 200-ok response data = { 'name': 'Shirt' } res = MagicMock() res.headers = {'Content-Type': 'application/json'} res.status_code = 200 res.content = json.dumps(data) res.json.return_value = data self.assertEqual(connection._handle_response('products/1', res), data) res.status_code = 500 self.assertRaisesHttpException(ServerException, lambda: connection._handle_response('products/1', res), # Test all of the properties of a HttpException 500, {'Content-Type': 'application/json'}, json.dumps(data)) res.status_code = 404 self.assertRaisesHttpException(ClientRequestException, lambda: connection._handle_response('products/1', res), 404) res.status_code = 301 self.assertRaisesHttpException(RedirectionException, lambda: connection._handle_response('products/1', res), 301)
def _mock_response(self, status_code=404, headers={}, content='PAGE_NOT_FOUND'): r = MagicMock(Response()) r.status_code = status_code r.headers = CaseInsensitiveDict(headers if headers is not None else {}) r.content = content r.ok = status_code < 400 return r
def test_missing_keys(self): http_session = MagicMock() response = MagicMock() http_session.get = MagicMock() http_session.get.return_value = response response.status_code = 200 response.content = "{}" response.url = "http://example.com/?camli.mode=config" conn = _connect( 'http://example.com/', http_session=http_session, ) self.assertEqual( conn.blob_root, None, ) self.assertEqual( conn.search_root, None, ) self.assertEqual( conn.sign_root, None, )
def test_too_many_requests(self): response = MagicMock() response.status_code = 429 response.headers = {'retry-after': 1} response.content = b'{"status": 429, "code": "Too Many requests", "message": "retry after some time"}' with self.assertRaises(TooManyRequests): _translate_errors(lambda: response)
def test_http(monkeypatch): resp = MagicMock() resp.status_code = 200 resp.text = '"foo"' resp.content = resp.text resp.json.return_value = 'foo' get = MagicMock() get.return_value = resp monkeypatch.setattr('requests.get', get) http = HttpWrapper('http://example.org') assert 200 == http.code() assert '"foo"' == http.text() assert 'foo' == http.json() assert 5 == http.content_size() get.assert_called_once_with('http://example.org', auth=None, headers={'User-Agent': get_user_agent()}, params=None, timeout=10, verify=True, allow_redirects=True) resp.json.side_effect = Exception('JSON fail') with pytest.raises(HttpError) as ex: http.json() assert 'JSON fail' == ex.value.message
def test_get_fdl_config(self, zipfile, get, boto_session): session, lam, _ = self._init_mocks(['get_function']) boto_session.return_value = session response = MagicMock(['content']) response.content = b"aa" get.return_value = response lam.client.client.get_function.return_value = { 'SupervisorVersion': '1.4.2', 'Code': { 'Location': 'http://loc.es' } } zfile = MagicMock(['__enter__', '__exit__']) zipfile.return_value = zfile filedata = MagicMock(['read']) filedata.read.side_effect = ["- item\n- item2\n", ""] filecont = MagicMock(['__enter__', '__exit__']) filecont.__enter__.return_value = filedata thezip = MagicMock(['open']) thezip.open.return_value = filecont zfile.__enter__.return_value = thezip self.assertEqual(lam.get_fdl_config('arn'), ['item', 'item2']) self.assertEqual(get.call_args_list[0][0][0], "http://loc.es")
def test_datadog_delivery(self, mock_datadog): datadog_mailer_config = { 'queue_url': 'asq://storageaccount.queue.core.windows.net/queuename', 'datadog_api_key': 'mock_api_key', 'datadog_application_key': 'mock_application_key' } datadog_compressed_message = MagicMock() datadog_compressed_message.content = base64.b64encode( zlib.compress(ASQ_MESSAGE_DATADOG.encode('utf8'))) datadog_loaded_message = json.loads(ASQ_MESSAGE_DATADOG) mock_datadog.return_value\ .get_datadog_message_packages.return_value = 'mock_datadog_message_map' azure_processor = MailerAzureQueueProcessor(datadog_mailer_config, logger) self.assertTrue( azure_processor.process_azure_queue_message( datadog_compressed_message)) mock_datadog.assert_has_calls([ call().deliver_datadog_messages('mock_datadog_message_map', datadog_loaded_message) ])
def test_json_parsing_error(self): # Make sure if the json parsing fails, we get a useful exception # Create a mock response that raises an exception when we try to get the json from it mock_response = MagicMock() mock_response.text = "This was the content" mock_response.content = mock_response.text.encode('utf-8') mock_response.json.side_effect = Exception("This is an exception") # Mock session that returns our mock response on a 'get' call. mock_session = MagicMock() mock_session.get.return_value = mock_response client = OnaApiClient('example.com', '2384729347234') with patch.object(client, 'session') as mock_session_method: # 'session' method on our client returns our mock session mock_session_method.return_value = mock_session try: client.get('foo') except OnaApiClientException as e: # Make sure the exception has lots of useful info s = str(e) self.assertIn('could not be parsed', s) self.assertIn("This is an exception", s) self.assertIn("This was the content", s) else: self.fail("Expected OnaApiClientException")
def test_push_strings_reaches_cds_handler( self, mock_push_strings, mock_get_status ): response = MagicMock() response.status_code = 202 response.content = '{"data":{"links":{"job":"/job"}}}' mock_push_strings.return_value = response response = MagicMock() response.status_code = 200 response.content = '{"data":{"status":"completed","details":{}}}' mock_get_status.return_value = response strings = [SourceString('a'), SourceString('b')] mytx = self._get_tx() mytx.push_source_strings(strings, False) mock_push_strings.assert_called_once_with(strings, False)
def mocked_request_setup(): r_return = MagicMock() r_return.status_code = 200 r_return.content = { 'dcos_token': 'foobar' } return r_return
def request(*args, **kwargs): mock_response = MagicMock() mock_response.content = "this shouldn't be raised" def raise_for_status(): raise HTTPError(response=mock_response) mock_response.raise_for_status = raise_for_status return mock_response
def test_delete_all_mails(self): doc = MagicMock(spec=SoledadDocument) doc.content = {'type': 'head'} self.soledad.get_all_docs.return_value = (1, [doc]) delete_all_mails(self.args) self.soledad.delete_doc.assert_called_once_with(doc)
def test_push_strings_reaches_cds_handler(self, mock_push_strings): response = MagicMock() response.status_code = 200 response.content = '{}' mock_push_strings.return_value = response strings = [SourceString('a'), SourceString('b')] mytx = self._get_tx() mytx.push_source_strings(strings, False) mock_push_strings.assert_called_once_with(strings, False)
def test_describe_blob(self): http_session = MagicMock() http_session.get = MagicMock() response = MagicMock() http_session.get.return_value = response response.status_code = 200 response.content = """ { "meta": { "dummy1": { "blobRef": "dummy1" }, "dummy2": { "blobRef": "dummy2" } } } """ searcher = SearchClient( http_session=http_session, base_url="http://example.com/s/", ) result = searcher.describe_blob("dummy1") http_session.get.assert_called_with( 'http://example.com/s/camli/search/describe', params={ 'blobref': 'dummy1', } ) self.assertEqual( type(result), BlobDescription, ) self.assertEqual( result.raw_dict, { "blobRef": "dummy1", } ) self.assertEqual( result.other_raw_dicts, { "dummy1": { "blobRef": "dummy1", }, "dummy2": { "blobRef": "dummy2", }, } )
def test_request_user_info(self): with patch('wirecloud.fiware.social_auth_backend.requests' ) as requests_mock: response = MagicMock() response.content = '{"test": true}' requests_mock.get.return_value = response self.assertEqual(self.instance._request_user_info('token'), {"test": True})
def test_get_package_list(self): mock_response = MagicMock() mock_response.content = self.mock_simple_index expected_result = ['pack-a', 'pack-b', 'pack-c', 'pack-d', 'pack-e'] with patch('pypianalyser.pypi_index_helpers.requests.get', return_value=mock_response): actual_result = get_package_list() self.assertListEqual(expected_result, actual_result)
def test_post_observation(self, mock_conn, caps_mock): caps_mock.get_service_host.return_value = 'some.host.com' caps_mock.return_value.get_access_url.return_value =\ 'http://serviceurl/caom2repo/auth' collection = 'cfht' observation_id = '7000000o' service = 'caom2repo' service_url = 'www.cadc.nrc.ca' obs = SimpleObservation(collection, observation_id) level = logging.DEBUG visitor = CAOM2RepoClient(auth.Subject(netrc='somenetrc'), level, host=service_url) response = MagicMock() response.status = 200 mock_conn.return_value = response iobuffer = BytesIO() ObservationWriter().write(obs, iobuffer) obsxml = iobuffer.getvalue() response.content = obsxml visitor.post_observation(obs) self.assertEqual('POST', mock_conn.call_args[0][0].method) self.assertEqual( '/{}/auth/{}/{}'.format(service, collection, observation_id), mock_conn.call_args[0][0].path_url) self.assertEqual('application/xml', mock_conn.call_args[0][0].headers['Content-Type']) self.assertEqual(obsxml, mock_conn.call_args[0][0].body) # signal problems http_error = requests.HTTPError() response.status_code = 500 http_error.response = response response.raise_for_status.side_effect = [http_error] with self.assertRaises(exceptions.InternalServerException): visitor.update(obs) # temporary transient errors http_error = requests.HTTPError() response.status_code = 503 http_error.response = response response.raise_for_status.side_effect = [http_error, None] visitor.post_observation(obs) # permanent transient errors http_error = requests.HTTPError() response.status_code = 503 http_error.response = response def raise_error(): raise http_error response.raise_for_status.side_effect = raise_error with self.assertRaises(exceptions.HttpException): visitor.post_observation(obs)
def test_get_succeed(self, mock_stdout, mock_requests_get): mock_response = MagicMock() mock_response.content = "test get content" mock_response.status_code = requests.codes.ok mock_requests_get.return_value = mock_response content = get('http://abc', 'headers') self.assertEqual(content, "test get content")
def test__request_non_200(self): response = (False, "Unexpected HTTP status code [503]") mock_response = MagicMock(spec=requests.Response()) mock_response.status_code = 503 mock_response.content = 'Xqueue 500 error' mock_request = MagicMock(return_value=mock_response) self.client.session.request = mock_request self.assertEquals(response, self.client._request('http://example.com', 'get'))
def test_add_image_from_url(self, mock_requests_get, mock_add_image_from_string): response_mock = MagicMock() response_mock.status_code = 200 response_mock.content = 'imagedatafromhttp' mock_requests_get.return_value = response_mock self._client.add_image_from_url('validimageurl') mock_requests_get.assert_called_once_with('validimageurl') mock_add_image_from_string.assert_called_once_with('imagedatafromhttp')
def test__request(self): xreply = {"return_code": 0, "content": "success"} response = MagicMock(spec=requests.Response()) response.status_code = 200 response.content = json.dumps(xreply) self.client.session.request = MagicMock(return_value=response) self.assertEquals((True, "success"), self.client._request("http://example.com"))
def test_get_metadata_for_package(self): mock_response = MagicMock() mock_response.content = self.mock_metadata_blob mock_response.status_code = 200 with patch('pypianalyser.pypi_index_helpers.requests.get', return_value=mock_response): result = get_metadata_for_package('pack1') self.assertIn('info', result) self.assertIn('releases', result)
def test_get_fail(self, mock_stdout, mock_requests_get): mock_response = MagicMock() mock_response.content = "test content" mock_response.status_code = requests.codes.bad mock_requests_get.return_value = mock_response download('http://abc', 'headers', 'saveTo') mock_response.raise_for_status.assert_called_with()
def test_b2_error(self): response = MagicMock() response.status_code = 503 response.content = six.b('{"status": 503, "code": "server_busy", "message": "busy"}') # no assertRaises until 2.7 try: _translate_errors(lambda: response) self.fail('should have raised ServiceError') except ServiceError: pass
def test_put_observation(self, mock_conn, caps_mock): caps_mock.get_service_host.return_value = 'some.host.com' caps_mock.return_value.get_access_url.return_value =\ 'http://serviceurl/caom2repo/pub' collection = 'cfht' observation_id = '7000000o' service = 'caom2repo' service_url = 'www.cadc.nrc.ca' obs = SimpleObservation(collection, observation_id) subject = auth.Subject(certificate='somefile.pem') level = logging.DEBUG visitor = CAOM2RepoClient(subject, level, host=service_url) response = MagicMock() response.status = 200 mock_conn.return_value = response iobuffer = BytesIO() ObservationWriter().write(obs, iobuffer) obsxml = iobuffer.getvalue() response.content = obsxml visitor.put_observation(obs) self.assertEqual('PUT', mock_conn.call_args[0][0].method) self.assertEqual( '/{}/pub/{}/{}'.format(service, collection, observation_id), mock_conn.call_args[0][0].path_url) self.assertEqual('application/xml', mock_conn.call_args[0][0].headers['Content-Type']) self.assertEqual(obsxml, mock_conn.call_args[0][0].body) # signal problems http_error = requests.HTTPError() response.status_code = 500 http_error.response = response response.raise_for_status.side_effect = [http_error] with self.assertRaises(exceptions.InternalServerException): visitor.create(obs) # temporary transient errors http_error = requests.HTTPError() response.status_code = 503 http_error.response = response response.raise_for_status.side_effect = [http_error, None] visitor.put_observation(obs) # permanent transient errors http_error = requests.HTTPError() response.status_code = 503 http_error.response = response def raise_error(): raise http_error response.raise_for_status.side_effect = raise_error with self.assertRaises(exceptions.HttpException): visitor.put_observation(obs)
def test_parser_error_raising(): ''' Test parser when the response contains 404 ''' mocked_response = MagicMock() mocked_response.content = json.dumps({'content': 'nothing here'}) mocked_response.status_code = 404 parser = Parser() parser(mocked_response)
def test_parser_no_content(): ''' Test the parser without any response ''' mocked_response = MagicMock() mocked_response.content = json.dumps({'status_code': 123}) mocked_response.status_code = 123 parser = Parser() eq_(parser(mocked_response), None)
def test__request_retries_login_failure(self, mock_login): # Initial `GET "/xqueue/queuelen/"` response initial_response = {"return_code": 1, "content": "login_required"} pre_login_response = MagicMock(spec=requests.Response()) pre_login_response.status_code = 200 pre_login_response.content = json.dumps(initial_response) self.client.session.request = MagicMock(return_value=pre_login_response) self.assertRaises(BadCredentials, self.client._request, "http://example.com")
def create_response_object( self, status, xml, major_code='<imsx_codeMajor>success</imsx_codeMajor>' ): """ Returns an XML document containing a successful replace_result response. """ response = MagicMock() response.status_code = status response.content = xml.format(major_code=major_code).encode('ascii', 'ignore') return response
def get_mock_data(path): response = MagicMock() mock_data_directory = os.path.join(os.path.dirname(__file__), "data") mock_data_file = os.path.abspath(os.path.join(mock_data_directory, path)) with open(mock_data_file, 'r') as fl: content = fl.read() try: response.json.return_value = json.loads(content) except: response.json.side_effect = Exception("Not a valid json") #NOTE: Ugly way of doing things, improve this in future try: response.content = etree.fromstring(content) except: response.content = content return response
def test_patient_query_with_error(self, request_mock, bulk_create_mock): response = MagicMock() response.status_code = 200 response.content = json.dumps( dict(status="error", data="didn't work") ) request_mock.return_value = response gloss_api.patient_query("AA1111", self.episode) request_mock.assert_called_once_with( "http://fake_url.com/api/patient/AA1111" ) self.assertFalse(bulk_create_mock.called)
def test_recusive_gloss_search(self, requests_mock): return_1 = copy(self.returned_gloss_result) return_1["duplicate_patient"] = [dict(new_id="1000")] return_2 = copy(self.returned_gloss_result) return_2["duplicate_patient"] = [dict(new_id="1001")] return_2["demographics"][0]["first_name"] = "Sue" return_2["demographics"][0]["hospital_number"] = "1000" return_3 = copy(self.returned_gloss_result) return_3["demographics"][0]["first_name"] = "Sarah" return_3["demographics"][0]["hospital_number"] = "1001" side_effects = [] for result in [return_1, return_2, return_3]: response = MagicMock() response.content = json.dumps({ "status": "success", "messages": result }) side_effects.append(response) requests_mock.side_effect = side_effects query = queries.create_query(self.user, self.criteria) result = query.patients_as_json()[0] self.assertEqual(requests_mock.call_count, 3) merged = [{ 'duplicate_patient': [], 'demographics': [{ 'first_name': u'Sarah', 'post_code': None, 'surname': u'Smith', 'gp_practice_code': None, 'title': u'Ms', 'hospital_number': 1001, 'marital_status': None, 'date_of_death': None, 'sex': None, 'external_system': 'Carecast', 'date_of_birth': u'12/12/1983', 'death_indicator': False, 'middle_name': None, 'hospital_number': "1001", 'ethnicity': None}] }] expected = copy(self.returned_gloss_result) expected["demographics"][0]['hospital_number'] = "1231111" expected["duplicate_patient"] = [{u'new_id': "1001"}] expected["merged"] = merged self.assertEqual(result, expected)
def test_list_file_info_http(self, requests_mock, re_mock): retval = MagicMock(spec=requests.models.Response) retval.url = 'http://marine.rutgers.edu/cool/maracoos/codar/ooi/radials/BELM/' retval.content = '<http><body>' \ '<a href="RDLm_BELM_2012_08_14_1200.ruv">RDLm_BELM_2012_08_14_1200.ruv</a> ' \ '14-Aug-2012 08:42 88K \n<img src="/icons/unknown.gif" alt="[ ]"> ' \ '<a href="RDLm_BELM_2012_08_14_1300.ruv">RDLm_BELM_2012_08_14_1300.ruv</a> ' \ '14-Aug-2012 09:41 90K \n</body></html>' requests_mock.return_value = retval re_mock.return_value = ['RDLm_BELM_2012_08_14_1200.ruv', 'RDLm_BELM_2012_08_14_1300.ruv'] lst = [('http://marine.rutgers.edu/cool/maracoos/codar/ooi/radials/BELM/RDLm_BELM_2012_08_14_1200.ruv',), ('http://marine.rutgers.edu/cool/maracoos/codar/ooi/radials/BELM/RDLm_BELM_2012_08_14_1300.ruv',)] self.assertEqual(list_file_info_http(base='http://marine.rutgers.edu/cool/maracoos/codar/ooi/radials/BELM/', pattern='*.ruv'), lst)
def build_response_mock(request, code, msg): """ Mock for build_response method """ if code > 199 and code < 300: status = "correct" else: status = "error" response = MagicMock() response.content = json.dumps({"result": status, "message": msg}) response.status_code = code return response
def test_mock(self): # Stub response from outside mocked_response = MagicMock() mocked_response.status_code = 200 mocked_response.content = "yes" "" requests.get = mocked_response url = "/" response = self.client.get(url) print(response) mocked_response.assert_called_once_with("haha") self.assertEqual(response.status_code, 200) self.fail("not finish")
def test_send_message_to_topic(self, mocked_post): post = MagicMock() post.content = '{}' post.status_code = 200 mocked_post.return_value = post gcm_message = ApiGCMMessage() message = 'test message' topic = '/topics/test-topic' gcm_message.send(message, to=topic) expected_data = { 'data': {'msg': message}, 'to': topic, 'collapse_key': 'message'} self.assertDictEqual( json.loads(mocked_post.call_args[1]['data']), expected_data)
def test_get_sbuffer_http(self, requests_mock, get_type_mock, StringIO_mock): retval = MagicMock(spec=requests.models.Response) retval.url = 'http://marine.rutgers.edu/cool/maracoos/codar/ooi/radials/BELM/' retval.content = '<http><body>'\ '<a href="RDLm_BELM_2012_08_14_1200.ruv">RDLm_BELM_2012_08_14_1200.ruv</a> '\ '14-Aug-2012 08:42 88K \n<img src="/icons/unknown.gif" alt="[ ]"> '\ '<a href="RDLm_BELM_2012_08_14_1300.ruv">RDLm_BELM_2012_08_14_1300.ruv</a> '\ '14-Aug-2012 09:41 90K \n</body></html>' requests_mock.return_value = retval get_type_mock.return_value = 'http' StringIO_mock.return_value = MagicMock(spec=StringIO) self.assertTrue(isinstance(get_sbuffer(url=retval.url), StringIO))
def build_response_mock(request, code, msg): """ Mock for build_response method """ if code > 199 and code < 300: status = 'correct' else: status = 'error' response = MagicMock() response.content = json.dumps({ 'result': status, 'message': msg }) response.status_code = code return response
def test_get_observation(self, mock_get, caps_mock): caps_mock.get_service_host.return_value = 'some.host.com' caps_mock.return_value.get_access_url.return_value =\ 'http://serviceurl/caom2repo/pub' collection = 'cfht' observation_id = '7000000o' service_url = 'www.cadc.nrc.ca/caom2repo' obs = SimpleObservation(collection, observation_id) writer = ObservationWriter() ibuffer = BytesIO() writer.write(obs, ibuffer) response = MagicMock() response.status_code = 200 response.content = ibuffer.getvalue() mock_get.return_value = response ibuffer.seek(0) # reposition the buffer for reading level = logging.DEBUG visitor = CAOM2RepoClient(auth.Subject(), level, host=service_url) self.assertEquals(obs, visitor.get_observation(collection, observation_id)) # signal problems http_error = requests.HTTPError() response.status_code = 500 http_error.response = response response.raise_for_status.side_effect = [http_error] with self.assertRaises(exceptions.InternalServerException): visitor.get_observation(collection, observation_id) # temporary transient errors http_error = requests.HTTPError() response.status_code = 503 http_error.response = response response.raise_for_status.side_effect = [http_error, None] visitor.read(collection, observation_id) # permanent transient errors http_error = requests.HTTPError() response.status_code = 503 http_error.response = response def raise_error(): raise http_error response.raise_for_status.side_effect = raise_error with self.assertRaises(exceptions.HttpException): visitor.get_observation(collection, observation_id)
def test_patient_query_with_successful_response( self, request_mock, bulk_create_mock ): data = { "hospital_number": "AA1111", "status": "success", "messages": [] } response = MagicMock() response.status_code = 200 response.content = json.dumps(data) request_mock.return_value = response gloss_api.patient_query("AA1111", self.episode) request_mock.assert_called_once_with( "http://fake_url.com/api/patient/AA1111" ) bulk_create_mock.assert_called_once_with(data, episode=self.episode)