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
