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_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_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_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_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_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 _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_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_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)
