def create_mock_response(url, response_type, **kwargs):
response = MagicMock()
response.request.url = url
response.request.method = kwargs.get("method", "GET")
response.request.headers = {}
response.request.body = None
if response_type == "redirect":
response.status_code = 301
response.headers = {"location": kwargs["location"]}
elif response_type == "error":
response.status_code = kwargs.get("status_code", 500)
response.reason = kwargs.get("reason", "fake reason")
response.text = '{{"reason":"{}"}}'.format(kwargs.get("reason", "fake reason"))
response.json = lambda: json.loads(response.text)
elif response_type == "stream":
response.status_code = kwargs.get("status_code", 200)
response.headers = {
"content-disposition": 'attachment; filename="fname.ext"',
"content-type": "application/octet-stream",
"content-length": len(response.text),
}
response.iter_content = lambda buffer_size: IterateContents(
kwargs["contents"], kwargs["buffer_size"], kwargs.get("partial_start", 0), kwargs.get("partial_end", None)
)
else:
response.status_code = 200
response.text = kwargs["text"]
response.json = lambda: json.loads(response.text)
response.headers = {"content-type": "application/json", "content-length": len(response.text)}
return response
def _responder(*args, **kwargs):
del kwargs
response = MagicMock()
if args[0].endswith('poll'):
response.json = MagicMock(return_value=self.__poll_responses.pop())
else:
response.json = MagicMock(return_value=ping_get())
return response
def get_impl(path):
result = MagicMock()
result.ok = True
if 'listRecords' in path:
result.json = MagicMock(return_value=self.ACCOUNTING_DATA)
elif 'hasAccount' in path:
result.json = MagicMock(return_value=dict(exists=True))
return result
def test_handle_request_invalid_json_request(self):
json = JSON()
request = MagicMock()
request.json = json_lib.dumps({'id': 0, 'params': []})
self.assertRaises(JSONException, json._handle_request, request)
request.json = json_lib.dumps({'method': 'some.method', 'params': []})
self.assertRaises(JSONException, json._handle_request, request)
request.json = json_lib.dumps({'method': 'some.method', 'id': 0})
self.assertRaises(JSONException, json._handle_request, request)
def test_handle_request_invalid_json_request(self):
json = JSON()
request = MagicMock()
request.json = json_lib.dumps({'id': 0, 'params': []})
self.assertRaises(JSONException, json._handle_request, request)
request.json = json_lib.dumps({'method': 'some.method', 'params': []})
self.assertRaises(JSONException, json._handle_request, request)
request.json = json_lib.dumps({'method': 'some.method', 'id': 0})
self.assertRaises(JSONException, json._handle_request, request)
def test_get_results(self):
result1 = {'item1': 6, 'item2': 2}
result2 = {'item1': 2, 'item2': 4}
component1 = MagicMock()
component1.json = MagicMock(return_value=result1)
self.engine.components['component1'].requests.get.return_value = component1
component2 = MagicMock()
component2.json = MagicMock(return_value=result2)
self.engine.components['component2'].requests.get.return_value = component2
self.assertEqual(self.engine.get_results({'key': 'value'}), {
'component1': result1, 'component2': result2
})
def test_wallet_info(config):
response_data = {
'data': {
'address': 'simple_address',
'eth_balance': 13,
'skale_balance': 123
}
}
response_mock = MagicMock()
response_mock.status_code = requests.codes.ok
response_mock.json = Mock(return_value=response_data)
result = run_command_mock('core.wallet.get_request',
response_mock,
wallet_info)
assert result.exit_code == 0
expected = (
'--------------------------------------------------\n'
'Address: simple_address\n'
'ETH balance: 13 ETH\n'
'SKALE balance: 123 SKALE\n'
'--------------------------------------------------\n'
)
assert result.output == expected
result = run_command_mock('core.wallet.get_request',
response_mock,
wallet_info,
['--format', 'json'])
assert result.exit_code == 0
expected = (
"{'address': 'simple_address', "
"'eth_balance': 13, 'skale_balance': 123}\n"
)
assert result.output == expected
def response_mock(status_code=0, json_data=None, headers=None, raw=None):
result = MagicMock()
result.status_code = status_code
result.json = MagicMock(return_value=json_data)
result.headers = headers
result.raw = raw
return result
def test_payu_widget_form(self):
"""Test showing PayU card widget"""
self.set_up_provider(True, True)
self.payment.token = None
transaction_id = "1234"
data = MagicMock()
data.return_value = {
"id": transaction_id,
"token_type": "test_token_type",
"access_token": "test_access_token",
"links": [{
"rel": "approval_url",
"href": "http://approval_url.com"
}],
}
post = MagicMock()
post.json = data
post.status_code = 200
form = self.provider.get_form(payment=self.payment)
self.assertEqual(form.__class__.__name__, "WidgetPaymentForm")
self.assertTrue(
"payu-widget" in form.fields["script"].widget.render("a", "b"))
self.assertTrue("https://example.com/process_url/token" in
form.fields["script"].widget.render("a", "b"))
self.assertEqual(self.payment.status, PaymentStatus.WAITING)
self.assertEqual(self.payment.captured_amount, Decimal("0"))
def test_k_at_end(self, mock_get):
mock_response = MagicMock()
mock_response.json = {'item': {'name': 'frost dragon bones', 'current': {'price': '123k'}}}
mock_get.return_value = mock_response
self.assertEqual(fetcher.fetch_price(1337), ('frost dragon bones', '123k'))
mock_get.assert_called_once_with(
'http://services.runescape.com/m=itemdb_rs/api/catalogue/detail.json?item=1337')
def test_get_results(self):
result1 = {'item1': 6, 'item2': 2}
result2 = {'item1': 2, 'item2': 4}
component1 = MagicMock()
component1.json = MagicMock(return_value=result1)
self.engine.components[
'component1'].requests.get.return_value = component1
component2 = MagicMock()
component2.json = MagicMock(return_value=result2)
self.engine.components[
'component2'].requests.get.return_value = component2
self.assertEqual(self.engine.get_results({'key': 'value'}), {
'component1': result1,
'component2': result2
})
def test_get_existing_product(self, current_user_resources,
id_correct_resource):
# Set up the test and its dependencies
req = MagicMock()
req.json = MagicMock(return_value=current_user_resources)
r = [current_user_resources[id_correct_resource]
] if id_correct_resource is not None else {}
self.instance._get_existing_products = MagicMock(return_value=r)
self.instance._update_acquire_url = MagicMock()
# Get the expected result
if id_correct_resource is not None:
expected_resource = {
'id': current_user_resources[id_correct_resource]['id'],
'href': current_user_resources[id_correct_resource]['href'],
'name': current_user_resources[id_correct_resource]['name'],
'version':
current_user_resources[id_correct_resource]['version']
}
else:
expected_resource = None
# Call the function and check the result
dataset = DATASET.copy()
self.assertEquals(expected_resource,
self.instance._get_existing_product(dataset))
# Update Acquire URL method is called (when the dataset is registered as resource in the Store)
if expected_resource is not None:
self.instance._update_acquire_url.assert_called_once_with(
dataset, current_user_resources[id_correct_resource])
def test_provider_raises_redirect_needed_on_success_preauth_payment(self):
provider = PaypalCardProvider(
secret=SECRET, client_id=CLIENT_ID, capture=False)
with patch('requests.post') as mocked_post:
transaction_id = '1234'
data = MagicMock()
data.return_value = {
'id': transaction_id,
'token_type': 'test_token_type',
'access_token': 'test_access_token',
'transactions': [
{'related_resources': [
{'authorization': {'links': [
{'rel': 'refund', 'href': 'http://refund.com'},
{'rel': 'capture', 'href': 'http://capture.com'}]}}
]}
]}
post = MagicMock()
post.json = data
post.status_code = 200
mocked_post.return_value = post
with self.assertRaises(RedirectNeeded) as exc:
provider.get_form(
payment=self.payment, data=PROCESS_DATA)
self.assertEqual(exc.args[0], self.payment.get_success_url())
links = provider._get_links(self.payment)
self.assertEqual(self.payment.status, PaymentStatus.PREAUTH)
self.assertEqual(self.payment.captured_amount, Decimal('0'))
self.assertEqual(self.payment.transaction_id, transaction_id)
self.assertTrue('capture' in links)
self.assertTrue('refund' in links)
def test_provider_redirects_on_success_preauth_payment(
self, mocked_redirect, mocked_post):
data = MagicMock()
data.return_value = {
'token_type': 'test_token_type',
'access_token': 'test_access_token',
'payer': {'payer_info': 'test123'},
'transactions': [
{'related_resources': [{
'sale': {'links': ''},
'authorization': {'links': ''}}]}
]}
post = MagicMock()
post.json = data
post.status_code = 200
mocked_post.return_value = post
request = MagicMock()
request.GET = {'token': 'test', 'PayerID': '1234'}
provider = PaypalProvider(
secret=SECRET, client_id=CLIENT_ID, capture=False)
provider.process_data(self.payment, request)
self.assertEqual(self.payment.status, PaymentStatus.PREAUTH)
self.assertEqual(self.payment.captured_amount, Decimal('0'))
def test_recover_from_expired_token(aggregator):
# First api answers with 403 to force the check to re-authenticate
unauthentified_response = MagicMock(status_code=403)
# Api answer when a request is being made to the login endpoint
login_response = MagicMock()
# Third api answer, when the check retries the initial endpoint but is now authenticated
valid_response = MagicMock()
valid_response.json = MagicMock(return_value={"foo": "bar"})
session = MagicMock()
session.send = MagicMock(
side_effect=[unauthentified_response, login_response, valid_response])
session_wrapper = SessionWrapper(aci_url=common.ACI_URL,
log=MagicMock(),
session=session,
apic_cookie="cookie")
api = Api(common.ACI_URLS,
common.USERNAME,
password=common.PASSWORD,
sessions=[session_wrapper])
api._refresh_sessions = False
data = api.make_request("")
# Assert that we retrieved the value from `valid_response.json()`
assert data == {"foo": "bar"}
session_calls = session.send._mock_call_args_list
# Assert that the first call was to the ACI_URL
assert session_calls[0].args[0].url == common.ACI_URL + "/"
# Assert that the second call was to the login endpoint
assert 'aaaLogin.xml' in session_calls[1].args[0].url
# Assert that the last call was to the ACI_URL again
assert session_calls[2].args[0].url == common.ACI_URL + "/"
def test_floating_point_price(self, mock_get):
mock_response = MagicMock()
mock_response.json = {'item': {'name': 'pickle', 'current': {'price': 1423.543}}}
mock_get.return_value = mock_response
self.assertEqual(fetcher.fetch_price(1234), ('pickle', '1423.543'))
mock_get.assert_called_once_with(
'http://services.runescape.com/m=itemdb_rs/api/catalogue/detail.json?item=1234')
def test_comma_in_price(self, mock_get):
mock_response = MagicMock()
mock_response.json = {'item': {'name': 'fire rune', 'current': {'price': '345,821'}}}
mock_get.return_value = mock_response
self.assertEqual(fetcher.fetch_price(554), ('fire rune', '345,821'))
mock_get.assert_called_once_with(
'http://services.runescape.com/m=itemdb_rs/api/catalogue/detail.json?item=554')
def test_get_existing_resource(self, current_user_resources,
id_correct_resource):
# Set up the test and its dependencies
req = MagicMock()
req.json = MagicMock(return_value=current_user_resources)
self.instance._make_request = MagicMock(return_value=req)
self.instance._update_acquire_url = MagicMock()
# Get the expected result
if id_correct_resource is not None:
expected_resource = {
'provider': store_connector.plugins.toolkit.c.user,
'name': current_user_resources[id_correct_resource]['name'],
'version':
current_user_resources[id_correct_resource]['version']
}
else:
expected_resource = None
# Call the function and check the result
dataset = DATASET.copy()
dataset['private'] = True
self.assertEquals(expected_resource,
self.instance._get_existing_resource(dataset))
# Update Acquire URL method is called (when the dataset is registered as resource in the Store)
if expected_resource is not None:
self.instance._update_acquire_url.assert_called_once_with(
dataset, current_user_resources[id_correct_resource])
def test_integer_price(self, mock_get):
mock_response = MagicMock()
mock_response.json = {'item': {'name': 'maple logs', 'current': {'price': 12345}}}
mock_get.return_value = mock_response
self.assertEqual(fetcher.fetch_price(1517), ('maple logs', '12345'))
mock_get.assert_called_once_with(
'http://services.runescape.com/m=itemdb_rs/api/catalogue/detail.json?item=1517')
def test_provider_raises_redirect_needed_on_success_captured_payment(self):
with patch('requests.post') as mocked_post:
transaction_id = '1234'
data = MagicMock()
data.return_value = {
'id': transaction_id,
'token_type': 'test_token_type',
'access_token': 'test_access_token',
'transactions': [
{'related_resources': [
{'sale': {'links': [
{'rel': 'refund', 'href': 'http://refund.com'}]}}
]}
]}
post = MagicMock()
post.json = data
post.status_code = 200
mocked_post.return_value = post
with self.assertRaises(RedirectNeeded) as exc:
self.provider.get_form(
payment=self.payment, data=PROCESS_DATA)
self.assertEqual(exc.args[0], self.payment.get_success_url())
links = self.provider._get_links(self.payment)
self.assertEqual(self.payment.status, 'confirmed')
self.assertEqual(self.payment.captured_amount, self.payment.total)
self.assertEqual(self.payment.transaction_id, transaction_id)
self.assertTrue('refund' in links)
class TestTaxJarFactory(unittest.TestCase):
def setUp(self):
self.response_data = {}
self.request = MagicMock()
def test_data_from_successful_request(self):
self.request.status_code = 200
self.request.json = MagicMock(return_value={'type': 'value'})
with patch.object(TaxJarTypeFactory, 'build') as factory_mock:
TaxJarResponse().data_from_request(self.request)
factory_mock.called_with('type').return_value.called_with('value')
def test_data_from_failed_request(self):
self.request.status_code = 500
self.request.json = MagicMock(return_value={
'status': 500,
'error': 'Server Error',
'detail': 'some detail'
})
try:
TaxJarResponse().data_from_request(self.request)
self.assertTrue(False)
except TaxJarResponseError as err:
self.assertEqual(str(err), "500 Server Error")
self.assertEqual(err.full_response['detail'], 'some detail')
self.assertEqual(err.full_response['response'],
self.request.json())
def test_handle_request_invalid_method(self):
json = JSON()
request = MagicMock()
json_data = {'method': 'no-existing-module.test', 'id': 0, 'params': []}
request.json = json_lib.dumps(json_data)
request_id, result, error = json._handle_request(request)
self.assertEqual(error, {'message': 'Unknown method', 'code': 2})
def test_wallet_info():
response_data = {
'status': 'ok',
'payload': {
'address': 'simple_address',
'eth_balance': 13,
'skale_balance': 123
}
}
response_mock = MagicMock()
response_mock.status_code = requests.codes.ok
response_mock.json = Mock(return_value=response_data)
result = run_command_mock('node_cli.utils.helper.requests.get',
response_mock, wallet_info)
assert result.exit_code == 0
expected = ('--------------------------------------------------\n'
'Address: simple_address\n'
'ETH balance: 13 ETH\n'
'SKALE balance: 123 SKALE\n'
'--------------------------------------------------\n')
assert result.output == expected
result = run_command_mock('node_cli.utils.helper.requests.get',
response_mock, wallet_info, ['--format', 'json'])
assert result.exit_code == 0
expected = ("{\"address\": \"simple_address\", "
"\"eth_balance\": 13, \"skale_balance\": 123}\n")
assert result.output == expected
def _call_api(self, _url, _params=None):
if self._page_idx >= len(self._page_results):
raise requests.exceptions.HTTPError
response = MagicMock()
response.json = MagicMock(return_value=self._page_results[self._page_idx])
self._page_idx += 1
return response
def test_provider_raises_redirect_needed_on_success(self):
with patch('requests.post') as mocked_post:
transaction_id = '1234'
data = MagicMock()
data.return_value = {
'id':
transaction_id,
'token_type':
'test_token_type',
'access_token':
'test_access_token',
'links': [{
'rel': 'approval_url',
'href': 'http://approval_url.com'
}]
}
post = MagicMock()
post.json = data
post.status_code = 200
mocked_post.return_value = post
with self.assertRaises(RedirectNeeded) as exc:
self.provider.get_form(payment=self.payment)
self.assertEqual(self.payment.status, PaymentStatus.WAITING)
self.assertEqual(self.payment.captured_amount, Decimal('0'))
self.assertEqual(self.payment.transaction_id, transaction_id)
def test_provider_raises_redirect_needed_on_success_captured_payment(self):
with patch('requests.post') as mocked_post:
transaction_id = '1234'
data = MagicMock()
data.return_value = {
'id':
transaction_id,
'token_type':
'test_token_type',
'access_token':
'test_access_token',
'transactions': [{
'related_resources': [{
'sale': {
'links': [{
'rel': 'refund',
'href': 'http://refund.com'
}]
}
}]
}]
}
post = MagicMock()
post.json = data
post.status_code = 200
mocked_post.return_value = post
with self.assertRaises(RedirectNeeded) as exc:
self.provider.get_form(payment=self.payment, data=PROCESS_DATA)
self.assertEqual(exc.args[0], self.payment.get_success_url())
links = self.provider._get_links(self.payment)
self.assertEqual(self.payment.status, PaymentStatus.CONFIRMED)
self.assertEqual(self.payment.captured_amount, self.payment.total)
self.assertEqual(self.payment.transaction_id, transaction_id)
self.assertTrue('refund' in links)
def test_provider_redirects_on_success_captured_payment(
self, mocked_redirect, mocked_post):
data = MagicMock()
data.return_value = {
'token_type':
'test_token_type',
'access_token':
'test_access_token',
'payer': {
'payer_info': 'test123'
},
'transactions': [{
'related_resources': [{
'sale': {
'links': ''
},
'authorization': {
'links': ''
}
}]
}]
}
post = MagicMock()
post.json = data
post.status_code = 200
mocked_post.return_value = post
request = MagicMock()
request.GET = {'token': 'test', 'PayerID': '1234'}
self.provider.process_data(self.payment, request)
self.assertEqual(self.payment.status, PaymentStatus.CONFIRMED)
self.assertEqual(self.payment.captured_amount, self.payment.total)
def test_get_existing_product(self, current_user_resources, id_correct_resource):
# Set up the test and its dependencies
req = MagicMock()
req.json = MagicMock(return_value=current_user_resources)
r = [current_user_resources[id_correct_resource]] if id_correct_resource is not None else {}
self.instance._get_existing_products = MagicMock(
return_value=r)
self.instance._update_acquire_url = MagicMock()
# Get the expected result
if id_correct_resource is not None:
expected_resource = {
'id': current_user_resources[id_correct_resource]['id'],
'href': current_user_resources[id_correct_resource]['href'],
'name': current_user_resources[id_correct_resource]['name'],
'version': current_user_resources[id_correct_resource]['version']
}
else:
expected_resource = None
# Call the function and check the result
dataset = DATASET.copy()
self.assertEquals(expected_resource, self.instance._get_existing_product(dataset))
# Update Acquire URL method is called (when the dataset is registered as resource in the Store)
if expected_resource is not None:
self.instance._update_acquire_url.assert_called_once_with(
dataset, current_user_resources[id_correct_resource])
def test_provider_redirects_on_success_preauth_payment(
self, mocked_redirect, mocked_post):
data = MagicMock()
data.return_value = {
'token_type': 'test_token_type',
'access_token': 'test_access_token',
'payer': {'payer_info': 'test123'},
'transactions': [
{'related_resources': [{
'sale': {'links': ''},
'authorization': {'links': ''}}]}
]}
post = MagicMock()
post.json = data
post.status_code = 200
mocked_post.return_value = post
request = MagicMock()
request.GET = {'token': 'test', 'PayerID': '1234'}
provider = PaypalProvider(
secret=SECRET, client_id=CLIENT_ID, capture=False)
provider.process_data(self.payment, request)
self.assertEqual(self.payment.status, 'preauth')
self.assertEqual(self.payment.captured_amount, Decimal('0'))
def test_get_existing_resource(self, current_user_resources, id_correct_resource):
# Set up the test and its dependencies
req = MagicMock()
req.json = MagicMock(return_value=current_user_resources)
self.instance._make_request = MagicMock(return_value=req)
self.instance._update_acquire_url = MagicMock()
# Get the expected result
if id_correct_resource is not None:
expected_resource = {
'provider': store_connector.plugins.toolkit.c.user,
'name': current_user_resources[id_correct_resource]['name'],
'version': current_user_resources[id_correct_resource]['version']
}
else:
expected_resource = None
# Call the function and check the result
dataset = DATASET.copy()
dataset['private'] = True
self.assertEquals(expected_resource, self.instance._get_existing_resource(dataset))
# Update Acquire URL method is called (when the dataset is registered as resource in the Store)
if expected_resource is not None:
self.instance._update_acquire_url.assert_called_once_with(dataset, current_user_resources[id_correct_resource])
def test_handle_request_invalid_method(self):
json = JSON()
request = MagicMock()
json_data = {'method': 'no-existing-module.test', 'id': 0, 'params': []}
request.json = json_lib.dumps(json_data)
request_id, result, error = json._handle_request(request)
self.assertEqual(error, {'message': 'Unknown method', 'code': 2})
def test_accountingTabCachedData(self, get):
resource = self.folder['mfn-b2safe']
get.return_value = MagicMock(ok=False)
browser = self.browseSite()
browser.open(resource.absolute_url())
with self.assertRaises(RuntimeError):
browser.follow('Accounting')
result = MagicMock()
result.ok = True
result.json = MagicMock(return_value=self.ACCOUNTING_DATA)
get.return_value = result
Accounting(self.portal, self.request).update_record_caches()
get.return_value = MagicMock(ok=False)
browser = self.browseSite()
browser.open(resource.absolute_url())
browser.follow('Accounting')
self.assertTrue(get.call_count, 1)
for record in self.ACCOUNTING_DATA:
self.assertTrue(record['core']['value'] in browser.contents)
self.assertTrue(
record['meta']['submission_time'] in browser.contents)
def test_dcos_task_metrics_agent_details(mocked_get_config_val,
mocked_get_master, mocked_http_get):
mocked_get_config_val.return_value = 'http://127.0.0.1'
mock_http_response = MagicMock()
mock_http_response.status_code = 200
mock_http_response.json = lambda: metrics_message
mocked_http_get.return_value = mock_http_response
mock_master = MagicMock()
mock_master.task = lambda _: {'slave_id': 'slave_id'}
mock_master.get_container_id = lambda _: {
'parent': {},
'value': 'container_id'
}
mocked_get_master.return_value = mock_master
_metrics(True, 'task_id', False)
# Metrics should query both endpoints
mocked_http_get.assert_any_call('http://127.0.0.1/system/v1/agent/'
'slave_id/metrics/v0/containers/'
'container_id/app')
mocked_http_get.assert_any_call('http://127.0.0.1/system/v1/agent/'
'slave_id/metrics/v0/containers/'
'container_id')
def test_payu_widget_form(self):
""" Test showing PayU card widget """
self.set_up_provider(True, True)
self.payment.token = None
transaction_id = '1234'
data = MagicMock()
data.return_value = {
'id': transaction_id,
'token_type': 'test_token_type',
'access_token': 'test_access_token',
'links': [{
'rel': 'approval_url',
'href': 'http://approval_url.com'
}]
}
post = MagicMock()
post.json = data
post.status_code = 200
form = self.provider.get_form(payment=self.payment)
self.assertEqual(form.__class__.__name__, "WidgetPaymentForm")
self.assertTrue(
"payu-widget" in form.fields['script'].widget.render('a', 'b'))
self.assertTrue("https://example.com/process_url/token" in
form.fields['script'].widget.render('a', 'b'))
self.assertEqual(self.payment.status, PaymentStatus.WAITING)
self.assertEqual(self.payment.captured_amount, Decimal('0'))
def perform(method, url, **extra):
def rfs(toret):
"""Helper for Raise For Status."""
def call():
if toret.status_code != 200:
raise Exception('Mocked response %s' % toret.status_code)
return call
toreturn = MagicMock()
if url in responses:
if len(responses[url]) == 0:
raise Exception('Unhandled requested to %s (extra %s)' %
(url, extra))
retval = responses[url][0]
responses[url] = responses[url][1:]
toreturn.status_code = 200
if '_code' in retval:
toreturn.status_code = retval['_code']
del retval['_code']
toreturn.json = MagicMock(return_value=retval)
toreturn.raise_for_status = rfs(toreturn)
return toreturn
else:
raise Exception('Unhandled mocked URL: %s (extra: %s)' %
(url, extra))
def test_provider_raises_redirect_needed_on_success_preauth_payment(self):
provider = PaypalCardProvider(
secret=SECRET, client_id=CLIENT_ID, capture=False)
with patch('requests.post') as mocked_post:
transaction_id = '1234'
data = MagicMock()
data.return_value = {
'id': transaction_id,
'token_type': 'test_token_type',
'access_token': 'test_access_token',
'transactions': [
{'related_resources': [
{'authorization': {'links': [
{'rel': 'refund', 'href': 'http://refund.com'},
{'rel': 'capture', 'href': 'http://capture.com'}]}}
]}
]}
post = MagicMock()
post.json = data
post.status_code = 200
mocked_post.return_value = post
with self.assertRaises(RedirectNeeded) as exc:
provider.get_form(
payment=self.payment, data=PROCESS_DATA)
self.assertEqual(exc.args[0], self.payment.get_success_url())
links = provider._get_links(self.payment)
self.assertEqual(self.payment.status, 'preauth')
self.assertEqual(self.payment.captured_amount, Decimal('0'))
self.assertEqual(self.payment.transaction_id, transaction_id)
self.assertTrue('capture' in links)
self.assertTrue('refund' in links)
class TestRequestsHTTPTransportParseResponse(unittest.TestCase):
def setUp(self):
self._transport = RequestsTransport()
self._requests_response = MagicMock(spec=Response())
def test_parse_response_success(self):
transport_response = self._transport._parse_response(self._requests_response)
self.assertIsInstance(transport_response, APIResponse)
self.assertEqual(self._requests_response.json(), transport_response.data)
self.assertEqual(self._requests_response.headers, transport_response.headers)
self.assertEqual(self._requests_response.status_code, transport_response.status_code)
def test_parse_response_json_success(self):
transport_response = self._transport._parse_response(self._requests_response)
self.assertIsInstance(transport_response, APIResponse)
self._requests_response.json.assert_called_once()
self.assertNotEqual(self._requests_response.text, transport_response.data)
self.assertEqual(self._requests_response.json(), transport_response.data)
self.assertEqual(self._requests_response.headers, transport_response.headers)
self.assertEqual(self._requests_response.status_code, transport_response.status_code)
def test_parse_response_text_success(self):
self._requests_response.json.side_effect = ValueError()
transport_response = self._transport._parse_response(self._requests_response)
self.assertIsInstance(transport_response, APIResponse)
with self.assertRaises(ValueError):
self._requests_response.json()
self.assertEqual(self._requests_response.text, transport_response.data)
self.assertEqual(self._requests_response.headers, transport_response.headers)
self.assertEqual(self._requests_response.status_code, transport_response.status_code)
def test_parse_response_400_failure(self):
self._requests_response.raise_for_status.side_effect = HTTPError()
self._requests_response.status_code = 400
transport_response = self._transport._parse_response(self._requests_response)
self.assertIsInstance(transport_response, APIErrorResponse)
self.assertEqual(self._requests_response.json(), transport_response.data)
self.assertEqual(self._requests_response.headers, transport_response.headers)
self.assertEqual(self._requests_response.status_code, transport_response.status_code)
def test_parse_response_500_failure(self):
self._requests_response.raise_for_status.side_effect = HTTPError()
self._requests_response.status_code = 500
with self.assertRaises(HTTPError):
self._transport._parse_response(self._requests_response)
def test_on_json_request_invalid_content_type(self):
"""Test for exception with content type not application/json"""
json = JSON()
request = MagicMock()
request.getHeader.return_value = 'text/plain'
json_data = {'method': 'some.method', 'id': 0, 'params': []}
request.json = json_lib.dumps(json_data)
self.assertRaises(JSONException, json._on_json_request, request)
def test_send_calls_retry_request(self):
resp = MagicMock()
resp.json = Mock()
resp.status_code = Mock()
with patch.object(Adapter, "_retry_request", return_value=resp) as retry_request:
self.accounts_adapter.send()
retry_request.assert_any_call()
def test_provider_handles_captured_payment(self, mocked_post):
data = MagicMock()
data.return_value = {'name': 'AUTHORIZATION_ALREADY_COMPLETED'}
response = MagicMock()
response.json = data
mocked_post.side_effect = HTTPError(response=response)
self.provider.capture(self.payment)
self.assertEqual(self.payment.status, PaymentStatus.CONFIRMED)
def test_get_calls(self):
resp = MagicMock()
resp.json = Mock()
resp.status_code = Mock()
with patch.object(Adapter, 'get', return_value=resp) as get_request:
self.accounts_adapter.get()
get_request.assert_any_call()
def test_on_json_request_invalid_content_type(self):
"""Test for exception with content type not application/json"""
json = JSON()
request = MagicMock()
request.getHeader.return_value = 'text/plain'
json_data = {'method': 'some.method', 'id': 0, 'params': []}
request.json = json_lib.dumps(json_data)
self.assertRaises(JSONException, json._on_json_request, request)
def test_get_calls(self):
resp = MagicMock()
resp.json = Mock()
resp.status_code = Mock()
with patch.object(Adapter, 'get', return_value=resp) as get_request:
self.accounts_adapter.get()
get_request.assert_any_call()
class TestRequestsHTTPTransportParseResponse(unittest.TestCase):
def setUp(self):
self._transport = RequestsTransport()
self._requests_response = MagicMock(spec=Response())
def test_parse_response_success(self):
transport_response = self._transport._parse_response(self._requests_response)
self.assertIsInstance(transport_response, APIResponse)
self.assertEqual(self._requests_response.json(), transport_response.data)
self.assertEqual(self._requests_response.headers, transport_response.headers)
self.assertEqual(self._requests_response.status_code, transport_response.status_code)
def test_parse_response_json_success(self):
transport_response = self._transport._parse_response(self._requests_response)
self.assertIsInstance(transport_response, APIResponse)
self._requests_response.json.assert_called_once()
self.assertNotEqual(self._requests_response.text, transport_response.data)
self.assertEqual(self._requests_response.json(), transport_response.data)
self.assertEqual(self._requests_response.headers, transport_response.headers)
self.assertEqual(self._requests_response.status_code, transport_response.status_code)
def test_parse_response_text_success(self):
self._requests_response.json.side_effect = ValueError()
transport_response = self._transport._parse_response(self._requests_response)
self.assertIsInstance(transport_response, APIResponse)
with self.assertRaises(ValueError):
self._requests_response.json()
self.assertEqual(self._requests_response.text, transport_response.data)
self.assertEqual(self._requests_response.headers, transport_response.headers)
self.assertEqual(self._requests_response.status_code, transport_response.status_code)
def test_parse_response_400_failure(self):
self._requests_response.raise_for_status.side_effect = HTTPError()
self._requests_response.status_code = 400
transport_response = self._transport._parse_response(self._requests_response)
self.assertIsInstance(transport_response, APIErrorResponse)
self.assertEqual(self._requests_response.json(), transport_response.data)
self.assertEqual(self._requests_response.headers, transport_response.headers)
self.assertEqual(self._requests_response.status_code, transport_response.status_code)
def test_parse_response_500_failure(self):
self._requests_response.raise_for_status.side_effect = HTTPError()
self._requests_response.status_code = 500
with self.assertRaises(HTTPError):
self._transport._parse_response(self._requests_response)
def _call_api(self, _url, _params=None):
if self._page_idx >= len(self._page_results):
raise requests.exceptions.HTTPError
response = MagicMock()
response.json = MagicMock(
return_value=self._page_results[self._page_idx])
self._page_idx += 1
return response
def create_mock_response(url, response_type, **kwargs):
response = MagicMock()
response.request.url = url
response.request.method = kwargs.get('method', 'GET')
response.request.headers = {}
response.request.body = None
if response_type == "redirect":
response.status_code = 301
response.headers = {'location': kwargs['location']}
elif response_type == "error":
response.status_code = kwargs.get('status_code', 500)
response.reason = kwargs.get('reason', 'fake reason')
response.text = '{{"reason":"{}"}}'.format(
kwargs.get('reason', 'fake reason'))
response.json = lambda: json.loads(response.text)
elif response_type == "stream":
response.status_code = kwargs.get('status_code', 200)
response.headers = {
'content-disposition': 'attachment; filename="fname.ext"',
'content-type': 'application/octet-stream',
'content-length': len(response.text)
}
def _create_iterator(buffer_size):
response._content_iterator = IterateContents(
kwargs['contents'], kwargs['buffer_size'],
kwargs.get('partial_start', 0),
kwargs.get('partial_end', None))
return response._content_iterator
response.iter_content = _create_iterator
response.raw.tell = lambda: response._content_iterator.total_bytes_iterated(
)
else:
response.status_code = 200
response.text = kwargs['text']
response.json = lambda: json.loads(response.text)
response.headers = {
'content-type': 'application/json',
'content-length': len(response.text)
}
return response
def test_parse_response():
"""
Test parsing of a response
"""
response = MagicMock()
response.status_code = 200
response.json = MagicMock()
Notipy.parse_response(response)
def test_parse_response_fail():
"""
Test parsing of an error response
"""
response = MagicMock()
response.status_code = 500
response.json = MagicMock()
assert_raises(NotificationSendError, Notipy.parse_response, response)
def test_provider_handles_captured_payment(self, mocked_post):
data = MagicMock()
data.return_value = {
'name': 'AUTHORIZATION_ALREADY_COMPLETED'}
response = MagicMock()
response.json = data
mocked_post.side_effect = HTTPError(response=response)
self.provider.capture(self.payment)
self.assertEqual(self.payment.status, 'confirmed')
def expect_a_ubersmith_call(self, requests_mock, returning=None, **kwargs):
response = MagicMock(status_code=200, headers={"content-type": "application/json"})
requests_mock.get = MagicMock(return_value=response)
response.json = MagicMock(return_value=returning)
def assert_called_with():
requests_mock.get.assert_called_with(auth=self.auth, params=kwargs, timeout=self.timeout, url=self.url)
response.json.assert_called_with()
return assert_called_with
def test_recommend(self):
response_mock = MagicMock()
response_mock.json = MagicMock(return_value=OrderedDict((("result1", 1.5), ("result2", 1))))
self.engine.requests.get.return_value = response_mock
results = self.engine.recommend({"value": ["test", "test2"]})
self.assertEqual(results, ["result1", "result2"])
results = self.engine.recommend({"value": "test"}, True)
self.assertEqual(results, OrderedDict((("result1", 1.5), ("result2", 1))))
def create_mock_response(url, response_type, **kwargs):
response = MagicMock()
response.request.url = url
response.request.method = kwargs.get('method', 'GET')
response.request.headers = {}
response.request.body = None
if response_type == "redirect":
response.status_code = 301
response.headers = {'location': kwargs['location']}
elif response_type == "error":
response.status_code = kwargs.get('status_code', 500)
response.reason = kwargs.get('reason', 'fake reason')
response.text = '{{"reason":"{}"}}'.format(kwargs.get('reason', 'fake reason'))
response.json = lambda: json.loads(response.text)
elif response_type == "stream":
response.status_code = kwargs.get('status_code', 200)
response.headers = {
'content-disposition': 'attachment; filename="fname.ext"',
'content-type': 'application/octet-stream',
'content-length': len(response.text)
}
def _create_iterator(buffer_size):
response._content_iterator = IterateContents(kwargs['contents'],
kwargs['buffer_size'],
kwargs.get('partial_start', 0),
kwargs.get('partial_end', None))
return response._content_iterator
response.iter_content = _create_iterator
response.raw.tell = lambda: response._content_iterator.total_bytes_iterated()
else:
response.status_code = 200
response.text = kwargs['text']
response.json = lambda: json.loads(response.text)
response.headers = {
'content-type': 'application/json',
'content-length': len(response.text)
}
return response
def test_WBAPIHTTPError_exception_returns_error_page_with_json_error(self, wbapi_mock):
""" WBAPIHTTPERROR json details are passed thru to client in error page
"""
response_mock = MagicMock()
response_mock.status_code = 500
response_mock.json.return_value = {"details": "An Error Message"}
wbapi_mock.return_value.get_apps.side_effect = WBAPIHTTPError(response=response_mock)
r = self.client.get('/')
self.assertEquals(r.status_code, response_mock.status_code)
self.assertTrue(response_mock.json()["details"] in r.get_data())
def expect_a_ubersmith_call_post(self, requests_mock, returning=None, status_code=200, **kwargs):
response = MagicMock(status_code=status_code, headers={'content-type': 'application/json'})
requests_mock.post = MagicMock(return_value=response)
response.json = MagicMock(return_value=returning)
def assert_called_with():
requests_mock.post.assert_called_with(auth=self.auth, timeout=self.timeout, url=self.url, data=kwargs)
response.json.assert_called_with()
return assert_called_with
def test_provider_refunds_payment(self, mocked_post):
data = MagicMock()
data.return_value = {
'token_type': 'test_token_type',
'access_token': 'test_access_token'}
post = MagicMock()
post.json = data
post.status_code = 200
mocked_post.return_value = post
self.provider.refund(self.payment)
self.assertEqual(self.payment.status, 'refunded')
def test_send_retries_and_assigns_cursor_if_next_cursor_is_returned_once(self):
# We assume the response returns data and next cursor on the first call and data
# only on the second call.
resp = MagicMock()
resp.status_code = 200
resp.json = MagicMock(side_effect=[{"data": "foo", "next_cursor": "foo"}, {"data": "foo"}])
with patch.object(Adapter, "_retry_request", return_value=resp) as retry_request:
self.accounts_adapter.send()
self.assertEquals(2, retry_request.call_count)
self.assertEquals("foo", self.accounts_adapter.params["cursor"])
class TestTaxJarFactory(unittest.TestCase):
def setUp(self):
self.response_data = {}
self.request = MagicMock()
def test_data_from_successful_request(self):
self.request.status_code = 200
self.request.json = MagicMock(return_value={'type': 'value'})
with patch.object(TaxJarTypeFactory, 'build') as factory_mock:
TaxJarResponse().data_from_request(self.request)
factory_mock.called_with('type').return_value.called_with('value')
def test_data_from_failed_400_request(self):
self.request.status_code = 400
self.request.json = MagicMock(return_value={
'status': 400,
'error': 'Bad Request',
'detail': 'some detail'
})
try:
TaxJarResponse().data_from_request(self.request)
self.assertTrue(False)
except TaxJarResponseError as err:
self.assertEqual(str(err), "400 Bad Request")
self.assertEqual(err.full_response['detail'], 'some detail')
self.assertEqual(err.full_response['response'], self.request.json())
def test_data_from_failed_500_request(self):
self.request.status_code = 500
self.request.json = MagicMock(return_value={
'status': 500,
'error': 'Server Error',
'detail': 'some detail'
})
try:
TaxJarResponse().data_from_request(self.request)
self.assertTrue(False)
except TaxJarResponseError as err:
self.assertEqual(str(err), "500 Server Error")
self.assertEqual(err.full_response['detail'], 'some detail')
self.assertEqual(err.full_response['response'], self.request.json())
def test_collection_iterator_with_pagination(self):
page_1 = dummy_fixtures.DUMMY_COLLECTION_FROM_MLA_SEARCH_PAGE_1
page_2 = dummy_fixtures.DUMMY_COLLECTION_FROM_MLA_SEARCH_PAGE_2
with patch.object(BaseResource, '_get') as _mock:
response = MagicMock(spec=Response, ok=True, status_code=200)
response.json = MagicMock(return_value=page_1)
_mock.return_value = response
it = DummyResource.search(credentials=self.credentials)
self.assertEqual(_mock.call_count, 1)
obj1 = next(it)
self.assertEqual(obj1.id, "MLA502003454")
obj2 = next(it)
self.assertEqual(obj2.id, "MLA504842874")
obj3 = next(it)
self.assertEqual(obj3.id, "MLA497525770")
with patch.object(BaseResource, '_get') as _mock:
response = MagicMock(spec=Response, ok=True, status_code=200)
response.json = MagicMock(return_value=page_2)
_mock.return_value = response
obj4 = next(it)
self.assertEqual(obj4.id, "MLA499776777")
# Called to get the fourth result
self.assertEqual(_mock.call_count, 1)
self.assertTrue('params' in _mock.call_args[1])
self.assertTrue('offset' in _mock.call_args[1]['params'])
self.assertEqual(_mock.call_args[1]['params']['offset'], 3)
obj5 = next(it)
self.assertEqual(obj5.id, "MLA503203012")
with self.assertRaises(StopIteration):
next(it)
def test_provider_captures_payment(self, mocked_post):
data = MagicMock()
data.return_value = {
'state': 'completed',
'token_type': 'test_token_type',
'access_token': 'test_access_token'}
post = MagicMock()
post.json = data
post.status_code = 200
mocked_post.return_value = post
self.provider.capture(self.payment)
self.assertEqual(self.payment.status, 'confirmed')
def test_recommend(self):
response_mock = MagicMock()
response_mock.json = MagicMock(return_value=OrderedDict((
('result1', 1.5), ('result2', 1)
)))
self.engine.requests.get.return_value = response_mock
results = self.engine.recommend({'value': 'test'})
self.assertEqual(results, ['result1', 'result2'])
results = self.engine.recommend({'value': 'test'}, True)
self.assertEqual(results, OrderedDict((('result1', 1.5), ('result2', 1))))
