def test_format(self):
req = MagicMock()
resp = MagicMock()
resp.body = {"example": "JSON"}
resp.content_type = None
hook_format(req, resp)
resp.body = '{"example": "JSON"}'
resp.content_type = 'application/json'
def test_format(self):
req = MagicMock()
resp = MagicMock()
resp.body = {"example": "JSON"}
resp.content_type = None
hook_format(req, resp)
resp.body = '{"example": "JSON"}'
resp.content_type = 'application/json'
def test_parseRequestBody(self):
req = MagicMock()
req.body = '{"key":"value"}'
data = self.rest_app._parseRequestBody(req)
self.assertEqual(data, {'key': 'value'})
self.assertEqual(data.keys(), ['key'])
self.assertEqual(type(data.keys()[0]), str)
# test some bad data
req.body = '{aaaaaaa}'
self.assertRaises(HTTPBadRequest, self.rest_app._parseRequestBody, req)
def test_parseRequestBody(self):
req = MagicMock()
req.body = '{"key":"value"}'
data = self.rest_app._parseRequestBody(req)
self.assertEqual(data, {'key': 'value'})
self.assertEqual(data.keys(), ['key'])
self.assertEqual(type(data.keys()[0]), str)
# test some bad data
req.body = '{aaaaaaa}'
self.assertRaises(HTTPBadRequest, self.rest_app._parseRequestBody, req)
def remove_public_id(self, last_public_id, original_id, HTTPCallbackGroup,
get_associated_privates,
get_associated_publics,
_delete_number):
# Setup
HTTPCallbackGroup.return_value = MagicMock()
on_success_handler = MagicMock()
on_failure_handler = MagicMock()
self.handler.forward_error = MagicMock()
if original_id:
sip_uri = SIP_URI
else:
sip_uri = SIP_URI2
# Test
numbers.remove_public_id(self.db_sess,
sip_uri,
on_success_handler,
on_failure_handler,
False)
# Asserts
get_associated_privates.assert_called_once_with(sip_uri, ANY)
HTTPCallbackGroup.assert_called_once_with(ANY, ANY)
# Extract inner function and can call it with response
on_get_privates_success = HTTPCallbackGroup.call_args[0][0]
response = MagicMock()
response.body = '{"public_id": "%s", "private_ids": ["%s"]}' % (sip_uri, PRIVATE_ID)
on_get_privates_success([response])
# Response should have been parsed now and a new call invoked
get_associated_publics.assert_called_once_with(PRIVATE_ID, ANY)
on_get_publics_success = HTTPCallbackGroup.call_args[0][0]
response = MagicMock()
if last_public_id:
response.body = '{"associated_public_ids": ["%s"]}' % (sip_uri)
else:
response.body = '{"associated_public_ids": ["*****@*****.**", "%s"]}' % (sip_uri)
on_get_publics_success([response])
if original_id and not last_public_id:
# When deleting the originally created public identity we want the request to fail
# if other public identities are associated with the private id
on_failure_handler.assert_called_once_with(response)
else:
_delete_number.assert_called_once_with(self.db_sess,
sip_uri,
PRIVATE_ID,
last_public_id,
on_success_handler,
on_failure_handler,
False)
def remove_public_id(self, last_public_id, original_id, HTTPCallbackGroup,
get_associated_privates,
get_associated_publics,
_delete_number):
# Setup
HTTPCallbackGroup.return_value = MagicMock()
on_success_handler = MagicMock()
on_failure_handler = MagicMock()
self.handler.forward_error = MagicMock()
if original_id:
sip_uri = SIP_URI
else:
sip_uri = SIP_URI2
# Test
numbers.remove_public_id(self.db_sess,
sip_uri,
on_success_handler,
on_failure_handler,
False)
# Asserts
get_associated_privates.assert_called_once_with(sip_uri, ANY)
HTTPCallbackGroup.assert_called_once_with(ANY, ANY)
# Extract inner function and can call it with response
on_get_privates_success = HTTPCallbackGroup.call_args[0][0]
response = MagicMock()
response.body = '{"public_id": "%s", "private_ids": ["%s"]}' % (sip_uri, PRIVATE_ID)
on_get_privates_success([response])
# Response should have been parsed now and a new call invoked
get_associated_publics.assert_called_once_with(PRIVATE_ID, ANY)
on_get_publics_success = HTTPCallbackGroup.call_args[0][0]
response = MagicMock()
if last_public_id:
response.body = '{"associated_public_ids": ["%s"]}' % (sip_uri)
else:
response.body = '{"associated_public_ids": ["*****@*****.**", "%s"]}' % (sip_uri)
on_get_publics_success([response])
if original_id and not last_public_id:
# When deleting the originally created public identity we want the request to fail
# if other public identities are associated with the private id
on_failure_handler.assert_called_once_with(response)
else:
_delete_number.assert_called_once_with(self.db_sess,
sip_uri,
PRIVATE_ID,
last_public_id,
on_success_handler,
on_failure_handler,
False)
def testHandleBatchSingle(self, mockEngine, addMetricMock):
# Create mocks
metric_storer.gCustomMetrics = {}
metricMock = MagicMock()
def addMetricSideEffect(*_args, **_kwargs):
metric_storer.gCustomMetrics["test.metric"] = [
metricMock, datetime.datetime.utcnow()
]
addMetricMock.side_effect = addMetricSideEffect
modelSwapperMock = MagicMock()
metricStreamerMock = MagicMock()
body = '{"protocol": "plain", "data": ["test.metric 4.0 1386792175"]}'
message = MagicMock()
message.body = body
# Call the function under test
metric_storer._handleBatch(mockEngine, [message], [],
metricStreamerMock, modelSwapperMock)
# Check the results
addMetricMock.assert_called_once_with(mockEngine, "test.metric")
metricStreamerMock.streamMetricData.assert_called_once()
data, _uid, modelSwapper = metricStreamerMock.streamMetricData.call_args[
0]
self.assertIs(modelSwapper, modelSwapperMock)
self.assertEqual(len(data), 1)
self.assertEqual(len(data[0]), 2)
self.assertEqual(repr(data[0][0]),
"datetime.datetime(2013, 12, 11, 20, 2, 55)")
self.assertAlmostEqual(data[0][1], 4.0)
def test__validate_body_no_body():
request = MagicMock()
request.body = None
with pytest.raises(exceptions.HTTPError) as exc:
_validate_body(request)
assert exc.value.status_code == 400
assert exc.value.errors == 'No Data in Body'
def test__validate_body_empty_body():
request = MagicMock()
request.body = ''
with pytest.raises(exceptions.HTTPError) as exc:
_validate_body(request)
assert exc.value.status_code == 400
assert exc.value.errors == 'Body is empty string'
def test_sauthc1signer_query(self):
# The plus sign in a url query must be replaced with %20
r = MagicMock()
r.headers = {}
r.url = 'https://api.stormpath.com/v1/directories?orderBy=name+asc'
r.method = 'GET'
r.body = None
mock_dt = MagicMock()
mock_dt.utcnow.return_value = datetime.datetime(2013, 7, 1, 0, 0, 0, 0)
mock_uuid4 = MagicMock(
return_value='a43a9d25-ab06-421e-8605-33fd1e760825')
s = Sauthc1Signer(id='MyId', secret='Shush!')
with patch('stormpath.auth.datetime', mock_dt):
with patch('stormpath.auth.uuid4', mock_uuid4):
r2 = s(r)
self.assertEqual(r, r2)
self.assertEqual(
r.headers['Authorization'],
'SAuthc1 sauthc1Id=MyId/20130701/a43a9d25-ab06-421e-8605-33fd1e760825/sauthc1_request, '
+ # noqa
'sauthc1SignedHeaders=host;x-stormpath-date, ' +
'sauthc1Signature=fc04c5187cc017bbdf9c0bb743a52a9487ccb91c0996267988ceae3f10314176'
) # noqa
def a_request():
request = MagicMock()
request.method = "post"
request.url = "http://{}.com".format(a_string())
request.headers = {a_string(): a_string()}
request.body = a_string()
return request
def test_HTMLHandler(self):
req = MagicMock()
req.body = ''
x = HTMLHandler(self.app, req, template='404.html')
x._transforms = []
x.get_current_user = lambda: False
x.template = '404.html'
try:
with patch.object(x, 'get_secure_cookie') as mget:
mget.return_value = self.login_code
x.get()
assert False
except HTTPError:
pass
x = HTMLHandler(self.app, req, template=None)
x._transforms = []
x.get_current_user = lambda: True
with patch.object(x, 'get_secure_cookie') as mget:
mget.return_value = self.login_code
x.get()
x = HTMLHandler(self.app, req, template='404.html')
x._transforms = []
x.get_current_user = lambda: b'test'
with patch.object(x, 'get_secure_cookie') as mget:
mget.return_value = self.login_code
x.get()
def test_competitions2(self):
req = MagicMock()
req.body = ''
x = {
0: MagicMock(),
1: MagicMock(),
2: MagicMock(),
3: MagicMock(),
4: MagicMock(),
5: MagicMock()
}
x[0].id = 0
x[1].id = 1
x[2].id = 1
x[3].id = 2
x[4].id = 2
x[5].id = 2
x[0].clientId = 0
x[1].clientId = 0
x[2].clientId = 1
x[3].clientId = 2
x[4].clientId = 2
x[5].clientId = 2
x[0].spec.type = CompetitionType.PREDICT
x[1].spec.type = CompetitionType.PREDICT
x[2].spec.type = CompetitionType.PREDICT
x[3].spec.type = CompetitionType.CLASSIFY
x[4].spec.type = CompetitionType.CLASSIFY
x[5].spec.type = CompetitionType.CLASSIFY
x[0].expiration = datetime(2019, 1, 1)
x[1].expiration = datetime(2019, 1, 1)
x[2].expiration = datetime(2019, 1, 1)
x[3].expiration = datetime(2019, 1, 1)
x[4].expiration = datetime(2017, 1, 1)
x[5].expiration = datetime(2019, 1, 1)
context = {
'clients': {
1234: ''
},
'competitions': x,
'leaderboards': {},
'submissions': {},
'stash': [],
'sessionmaker': MagicMock()
}
x = CompetitionHandler(self.app, req, **context)
x._transforms = []
x.get_current_user = lambda: True
x.get_argument = lambda *args: True
x._validate = lambda *args: {
'id': (1, 2),
'client_id': (1, 2),
'type': [CompetitionType.CLASSIFY]
}
x.get()
def test_ping_fail(self, settings, AsyncHTTPClient):
self.standard_setup(settings, AsyncHTTPClient)
homestead.ping()
self.mock_httpclient.fetch.assert_called_once_with("http://homestead/ping", ANY)
mock_response = MagicMock()
mock_response.body = "Failure"
self.mock_httpclient.fetch.call_args[0][1](mock_response)
def test_send_mail_failure_unable_to_send(self):
instance = MagicMock()
instance.resource_status = 'to-send'
instance.subject = 'subject'
instance.body = 'body'
instance.created_by = 'sender'
send_email_pre_save(sender='', instance=instance)
def TestCommandParsing(self):
request = MagicMock()
request.path = "/test"
request.query = "item1=value1"
request.remote_ip = "1.2.3.4"
request.method = "PUT"
request.headers = {
'User': '******',
'Creation-Time': 'test_time',
'User-Agent': 'test_user_agent'
}
request.body="item2=value2&item2=value3&item2=value4"
self.command = Command(request)
self.assertEqual(self.command.command_name, 'test')
self.assertEqual(self.command.command_type, 'PUT')
self.assertEqual(self.command.has_param('item1'), True)
self.assertEqual(self.command.has_param('item2'), True)
self.assertEqual(self.command.has_param('item3'), False)
self.assertEqual(self.command.get_param('item1'), 'value1')
self.assertEqual('value2' in self.command.get_param('item2'), True)
self.assertEqual('value3' in self.command.get_param('item2'), True)
self.assertEqual('value4' in self.command.get_param('item2'), True)
data = self.command.format_trace
self.assertEqual(data['Username'], 'test_user')
self.assertEqual(data['Created'], 'test_time')
self.assertEqual(data['Source_Address'], '1.2.3.4')
self.assertEqual(data['Source_ID'], 'test_user_agent')
def _setup():
global reconnect_handler, session_manager, session_list, path, kernel_id, kernel_manager,\
individual_kernel_manager, response_id, good_msg, client, spark_events, request
# Mock kernel manager
client = MagicMock()
client.execute = MagicMock(return_value=response_id)
client.get_shell_msg = MagicMock(return_value=good_msg)
individual_kernel_manager = MagicMock()
individual_kernel_manager.client = MagicMock(return_value=client)
kernel_manager = MagicMock()
kernel_manager.get_kernel = MagicMock(return_value=individual_kernel_manager)
# Mock session manager
session_list = [create_session_dict(path, kernel_id)]
session_manager = MagicMock()
session_manager.list_sessions = MagicMock(return_value=session_list)
# Mock spark events
spark_events = MagicMock()
# Mock request
request = MagicMock()
request.body = json.dumps({"path": path, "username": username, "password": password, "endpoint": endpoint})
# Create mocked reconnect_handler
ReconnectHandler.__bases__ = (SimpleObject,)
reconnect_handler = ReconnectHandler()
reconnect_handler.spark_events = spark_events
reconnect_handler.session_manager = session_manager
reconnect_handler.kernel_manager = kernel_manager
reconnect_handler.set_status = MagicMock()
reconnect_handler.finish = MagicMock()
reconnect_handler.current_user = '******'
reconnect_handler.request = request
def test_ping_http(self, settings, AsyncHTTPClient):
self.standard_setup(settings, AsyncHTTPClient)
mock_response = MagicMock()
mock_response.body = "OK"
self.mock_httpclient.fetch.return_value = mock_response
homestead.ping()
self.mock_httpclient.fetch.assert_called_once_with("http://homestead/ping", ANY)
def test_process_notification_refund_not_finalized(self):
"""Test processing PayU partial refund notification"""
self.set_up_provider(True, True)
mocked_request = MagicMock()
mocked_request.body = json.dumps({
"order": {
"status": "COMPLETED"
},
"refund": {
"amount": "11000",
"currencyCode": "USD",
"status": "FOO",
"reasonDescription": "BlenderKit refund",
},
}).encode("utf8")
mocked_request.META = {
"CONTENT_TYPE":
"application/json",
"HTTP_OPENPAYU_SIGNATURE":
"signature=0af4d2830ed40ec2cea5249a172bf6d9;algorithm=MD5",
}
mocked_request.status_code = 200
with self.assertRaisesRegex(Exception, "Refund was not finelized"):
self.provider.process_data(payment=self.payment,
request=mocked_request)
def test_process_notification_refund(self):
"""Test processing PayU refund notification"""
self.set_up_provider(True, True)
mocked_request = MagicMock()
mocked_request.body = json.dumps({
"order": {
"status": "COMPLETED"
},
"refund": {
"amount": "22000",
"currencyCode": "USD",
"status": "FINALIZED",
"reasonDescription": "BlenderKit refund",
},
}).encode("utf8")
mocked_request.META = {
"CONTENT_TYPE":
"application/json",
"HTTP_OPENPAYU_SIGNATURE":
"signature=dd8cdddaa98438e7a76f5e830395d7e8;algorithm=MD5",
}
mocked_request.status_code = 200
ret_val = self.provider.process_data(payment=self.payment,
request=mocked_request)
self.assertEqual(ret_val.__class__.__name__, "HttpResponse")
self.assertEqual(ret_val.status_code, 200)
self.assertEqual(ret_val.content, b"ok")
self.assertEqual(self.payment.status, PaymentStatus.REFUNDED)
self.assertEqual(self.payment.captured_amount, Decimal("0"))
def test_ServerMessagesMixin(self):
req = MagicMock()
req.body = ''
x = ServerMessagesMixin()
x._transforms = []
x.te = MagicMock()
x.te._ex = MagicMock()
x.te._ex.messages = MagicMock()
x.te._ex.messages.return_value = [MagicMock()]
x.te._ex.messages.return_value[0].to_dict = MagicMock()
x.te._ex.messages.return_value[0].to_dict.return_value = {'test': 1, 'instrument': {'underlying': 'test'}}
x.get_data()
x.get_data('test')
x.get_data(None, 0, 'BTCUSD')
x.te._ex.messages.return_value = {'TRADE': [MagicMock()]}
x.te._ex.messages.return_value['TRADE'][0].to_dict = MagicMock()
x.te._ex.messages.return_value['TRADE'][0].to_dict.return_value = {'test': 1}
x.get_data('TRADE')
x.get_data('TRADE', 0, 'test')
x.get_data('TRADE', 0, 'BTCUSD')
x.get_data('TRADE', 0, 'BTCUSD')
def test_process_notification_partial_refund(self):
"""Test processing PayU partial refund notification"""
self.payment.change_status(PaymentStatus.CONFIRMED)
self.payment.total = 220
self.payment.save()
self.payment.refresh_from_db()
self.set_up_provider(True, True)
mocked_request = MagicMock()
mocked_request.body = json.dumps({
"order": {
"status": "COMPLETED"
},
"refund": {
"amount": "11000",
"currencyCode": "USD",
"status": "FINALIZED",
"reasonDescription": "BlenderKit refund",
},
}).encode("utf8")
mocked_request.META = {
"CONTENT_TYPE":
"application/json",
"HTTP_OPENPAYU_SIGNATURE":
"signature=6f1076d9d2fa7dc58a87f20f2c69ebf8;algorithm=MD5",
}
mocked_request.status_code = 200
ret_val = self.provider.process_data(payment=self.payment,
request=mocked_request)
self.assertEqual(ret_val.__class__.__name__, "HttpResponse")
self.assertEqual(ret_val.status_code, 200)
self.assertEqual(ret_val.content, b"ok")
self.payment.refresh_from_db()
self.assertEqual(self.payment.total, Decimal("110"))
self.assertEqual(self.payment.status, PaymentStatus.CONFIRMED)
def test__validate_body_no_body():
request = MagicMock()
request.body = None
with pytest.raises(exceptions.HTTPError) as exc:
_validate_body(request)
assert exc.value.status_code == 400
assert exc.value.errors == 'No Data in Body'
def test_process_notification_total_amount(self):
""" Test processing PayU notification if it captures correct amount """
self.set_up_provider(True, True)
mocked_request = MagicMock()
mocked_request.body = json.dumps(
{
"order": {
"status": "COMPLETED",
"totalAmount": 200,
"currencyCode": "USD"
}
}, ).encode("utf8")
mocked_request.META = {
'CONTENT_TYPE':
'application/json',
"HTTP_OPENPAYU_SIGNATURE":
"signature=01a0e768ab1f762da4b955585aa4e59e;algorithm=MD5",
}
mocked_request.status_code = 200
ret_val = self.provider.process_data(payment=self.payment,
request=mocked_request)
self.assertEqual(ret_val.__class__.__name__, "HttpResponse")
self.assertEqual(ret_val.status_code, 200)
self.assertEqual(ret_val.content, b"ok")
self.assertEqual(self.payment.status, PaymentStatus.CONFIRMED)
self.assertEqual(self.payment.captured_amount, Decimal('2'))
def test_ServerMessagesMixin(self):
req = MagicMock()
req.body = ''
x = TradesHandler(self.app,
req,
trading_engine=MagicMock(),
psp_kwargs={})
x._transforms = []
x.te = MagicMock()
x.te._ex = MagicMock()
x.te._ex.messages = MagicMock()
x.te._ex.messages.return_value = [MagicMock()]
x.te._ex.messages.return_value[0].to_dict = MagicMock()
x.te._ex.messages.return_value[0].to_dict.return_value = {
'test': 1,
'instrument': {
'underlying': 'test'
}
}
x.get_data()
x.get_data('test')
x.get_data(None, 'BTCUSD')
x.te._ex.messages.return_value = {'TRADE': [MagicMock()]}
x.te._ex.messages.return_value['TRADE'][0].to_dict = MagicMock()
x.te._ex.messages.return_value['TRADE'][0].to_dict.return_value = {
'test': 1
}
x.get_data()
x.get_data(pair='test')
x.get_data(pair='BTCUSD')
def testHandleBatchSingle(self, mockEngine, addMetricMock):
# Create mocks
metric_storer.gCustomMetrics = {}
metricMock = MagicMock()
def addMetricSideEffect(*_args, **_kwargs):
metric_storer.gCustomMetrics["test.metric"] = [metricMock, datetime.datetime.utcnow()]
addMetricMock.side_effect = addMetricSideEffect
modelSwapperMock = MagicMock()
metricStreamerMock = MagicMock()
body = '{"protocol": "plain", "data": ["test.metric 4.0 1386792175"]}'
message = MagicMock()
message.body = body
# Call the function under test
metric_storer._handleBatch(mockEngine, [message], [], metricStreamerMock, modelSwapperMock)
# Check the results
addMetricMock.assert_called_once_with(mockEngine, "test.metric")
metricStreamerMock.streamMetricData.assert_called_once()
data, _uid, modelSwapper = metricStreamerMock.streamMetricData.call_args[0]
self.assertIs(modelSwapper, modelSwapperMock)
self.assertEqual(len(data), 1)
self.assertEqual(len(data[0]), 2)
self.assertEqual(repr(data[0][0]), "datetime.datetime(2013, 12, 11, 20, 2, 55)")
self.assertAlmostEqual(data[0][1], 4.0)
def test_get_one_number(self, get_numbers,
HTTPCallbackGroup,
get_associated_privates):
self.handler.get_and_check_user_id = MagicMock(return_value=USER_ID)
get_numbers.return_value = [{"number": SIP_URI, "number_id": NUMBER_ID, "gab_listed": GAB_LISTED}]
HTTPCallbackGroup.return_value = MagicMock()
self.handler.get("foobar")
# Assert that we kick off asynchronous GET at homestead
self.handler.get_and_check_user_id.assert_called_once_with("foobar")
HTTPCallbackGroup.assert_called_once_with(ANY, # functools.partial object
self.handler._on_get_failure)
get_associated_privates.assert_called_once_with(SIP_URI,
ANY # function
# argument
)
# Simulate success of all requests.
response = MagicMock()
response.body = '{"private_ids": ["*****@*****.**"]}'
self.handler._on_get_success(SIP_URI, [response])
self.handler.finish.assert_called_once_with(
{
"numbers": [
{"number_id": NUMBER_ID_HEX,
"number": "5555550123",
"sip_username": "******",
"domain": REALM,
"gab_listed": GAB_LISTED,
"formatted_number": "(555) 555-0123",
"sip_uri": SIP_URI,
"private_id": "*****@*****.**", }
]
})
def test_LoginHandler(self):
req = MagicMock()
req.body = ''
context = {
'clients': {
1234: ''
},
'competitions': {},
'leaderboards': {},
'submissions': {},
'stash': [],
'sessionmaker': MagicMock()
}
x = LoginHandler(self.app, req, **context)
x._transforms = []
x._validate = lambda *args: True
x.current_user = True
x.get()
x = LoginHandler(self.app, req, **context)
x._transforms = []
x._validate = lambda *args: True
x.current_user = False
x.get()
def test__validate_body_empty_body():
request = MagicMock()
request.body = ''
with pytest.raises(exceptions.HTTPError) as exc:
_validate_body(request)
assert exc.value.status_code == 400
assert exc.value.errors == 'Body is empty string'
def get_two_numbers(self, shared_private_id, get_numbers,
HTTPCallbackGroup,
get_associated_privates):
self.handler.get_and_check_user_id = MagicMock(return_value=USER_ID)
get_numbers.return_value = [{"number": "sip:[email protected]", "number_id": NUMBER_ID, "gab_listed": 0},
{"number": "sip:[email protected]", "number_id": NUMBER_ID2, "gab_listed": 1}]
HTTPCallbackGroup.return_value = MagicMock()
self.handler.get("foobar")
# Simulate success of all requests.
response1 = MagicMock()
response1.body = '{"public_id": "sip:[email protected]", "private_ids": ["*****@*****.**"]}'
response2 = MagicMock()
if shared_private_id:
response2.body = '{"public_id": "sip:[email protected]", "private_ids": ["*****@*****.**"]}'
else:
response2.body = '{"public_id": "sip:[email protected]", "private_ids": ["*****@*****.**"]}'
self.handler._on_get_success("sip:[email protected]", [response1])
self.handler._on_get_success("sip:[email protected]", [response2])
self.handler.finish.assert_called_once_with(
{
"numbers": [
{
"number_id": NUMBER_ID_HEX,
"number": "4155551234",
"sip_username": "******",
"domain": "sip.com",
"gab_listed": 0,
"formatted_number": "(415) 555-1234",
"sip_uri": "sip:[email protected]",
"private_id": "*****@*****.**",
},
{
"number_id": NUMBER_ID2_HEX,
"number": "4155555678",
"sip_username": "******",
"domain": "sip.com",
"gab_listed": 1,
"formatted_number": "(415) 555-5678",
"sip_uri": "sip:[email protected]",
"private_id": (shared_private_id and "*****@*****.**" or "*****@*****.**"),
}
]
})
def create_email_message():
sent_email = MagicMock(spec=Message)
sent_email.subject = "Example Subject"
sent_email.body = "<html><body>Testing</body></html>"
sent_email.attachments = []
sent_email.to_recipients = ["*****@*****.**"]
sent_email.send_and_save = MagicMock()
return sent_email
def get_two_numbers(self, shared_private_id, get_numbers,
HTTPCallbackGroup,
get_associated_privates):
self.handler.get_and_check_user_id = MagicMock(return_value=USER_ID)
get_numbers.return_value = [{"number": "sip:[email protected]", "number_id": NUMBER_ID, "gab_listed": 0},
{"number": "sip:[email protected]", "number_id": NUMBER_ID2, "gab_listed": 1}]
HTTPCallbackGroup.return_value = MagicMock()
self.handler.get("foobar")
# Simulate success of all requests.
response1 = MagicMock()
response1.body = '{"public_id": "sip:[email protected]", "private_ids": ["*****@*****.**"]}'
response2 = MagicMock()
if shared_private_id:
response2.body = '{"public_id": "sip:[email protected]", "private_ids": ["*****@*****.**"]}'
else:
response2.body = '{"public_id": "sip:[email protected]", "private_ids": ["*****@*****.**"]}'
self.handler._on_get_success("sip:[email protected]", [response1])
self.handler._on_get_success("sip:[email protected]", [response2])
self.handler.finish.assert_called_once_with(
{
"numbers": [
{
"number_id": NUMBER_ID_HEX,
"number": "4155551234",
"sip_username": "******",
"domain": "sip.com",
"gab_listed": 0,
"formatted_number": "(415) 555-1234",
"sip_uri": "sip:[email protected]",
"private_id": "*****@*****.**",
},
{
"number_id": NUMBER_ID2_HEX,
"number": "4155555678",
"sip_username": "******",
"domain": "sip.com",
"gab_listed": 1,
"formatted_number": "(415) 555-5678",
"sip_uri": "sip:[email protected]",
"private_id": (shared_private_id and "*****@*****.**" or "*****@*****.**"),
}
]
})
def test_ping_fail(self, settings, AsyncHTTPClient):
self.standard_setup(settings, AsyncHTTPClient)
homestead.ping()
self.mock_httpclient.fetch.assert_called_once_with(
"http://homestead/ping", ANY)
mock_response = MagicMock()
mock_response.body = "Failure"
self.mock_httpclient.fetch.call_args[0][1](mock_response)
def testHandleDataInvalidBody(self, mockEngine, loggingMock):
"""Make sure _handleData doesn't throw an exception for invalid data."""
# Call the function under test
body = '{"protocol": "plain", "data": ["test.metric 4.0 12:30PM"]}'
message = MagicMock()
message.body = body
metric_storer._handleBatch(mockEngine, [message], [], MagicMock(), MagicMock())
# Check the results
self.assertTrue(loggingMock.warn.called)
def testHandleDataInvalidProtocol(self, mockEngine, loggingMock):
"""Ensure _handleData doesn't throw an exception for unknown protocol."""
# Call the function under test
body = '{"protocol": "unknown_protocol",' ' "data": ["test.metric 4.0 1386792175"]}'
message = MagicMock()
message.body = body
metric_storer._handleBatch(mockEngine, [message], [], MagicMock(), MagicMock())
# Check the results
self.assertTrue(loggingMock.warn.called)
def test_invalid_xml():
spider = create_spider()
response = MagicMock()
response.url = "https://s3.cern.ch/incoming-bucket/invalid_record.xml"
response.body = "This is not actually XML"
result = list(spider.parse(response))
assert result[0].exception.startswith('XMLSyntaxError')
assert result[0].traceback is not None
assert result[0].source_data == "This is not actually XML"
def test_bsso_msg_generation(self, mock_bsso_alert):
from pybossa.view.account import generate_bsso_account_notification
mock_alert = MagicMock()
mock_alert.body = None
mock_alert.html = None
mock_bsso_alert = mock_alert
user = {'fullname': "test test", "email": "*****@*****.**"}
assert generate_bsso_account_notification(user, "*****@*****.**",
"test") != None
def phonable_task(func, url):
number = '+12103004000' if url.endswith('abc') else '+13103004000'
reply = MagicMock()
reply.code = 200
reply.body = json.dumps({"number": number})
task = MagicMock(spec=YieldPoint)
task.get_result.return_value = reply
return task
def test_assets_url_is_generated_with_final_filename_when_debug_is_false(self):
context = MagicMock()
context['caller'] = MagicMock()
context['caller'].body = MagicMock()
configure(MOCK_CONF_PROD_MODE)
tag(context, 'final-js-bundle')
context['caller'].body.assert_called_with(ASSETS_URL='my-url/final-js-bundle.js')
def create_meeting():
meeting = MagicMock(spec=CalendarItem)
meeting.subject = "Test"
meeting.body = "Just a test"
meeting.attachments = []
meeting.start = EWSDateTime(2020, 11, 10, 14, 0, tzinfo=TEST_TZ)
meeting.end = EWSDateTime(2020, 11, 10, 15, 0, tzinfo=TEST_TZ)
meeting.required_attendees = ['*****@*****.**']
return meeting
def test_process_data(self):
"""
CoinbaseProvider.process_data() returns a correct HTTP response
"""
request = MagicMock()
request.body = json.dumps(COINBASE_REQUEST)
response = self.provider.process_data(self.payment, request)
self.assertEqual(type(response), HttpResponse)
self.assertEqual(self.payment.status, "confirmed")
def test_submit(self, render, loads, user, thread, question):
"""
This function tests **submit()**.
"""
loads.return_value = "return"
request = MagicMock()
request.body = "body of the request"
views.submit(request)
self.assertTrue(render.called)
def test_process_notification_error_malformed_post(self):
""" Test processing PayU notification with malformed POST """
self.set_up_provider(True, True)
mocked_request = MagicMock()
mocked_request.body = b'{}'
mocked_request.META = {'CONTENT_TYPE': 'application/json'}
with self.assertRaises(PayuApiError) as context:
self.provider.process_data(payment=self.payment, request=mocked_request)
self.assertEqual(context.exception.args[0], "Malformed POST")
def test_process_data(self):
"""
CoinbaseProvider.process_data() returns a correct HTTP response
"""
request = MagicMock()
request.body = json.dumps(COINBASE_REQUEST)
response = self.provider.process_data(self.payment, request)
self.assertEqual(type(response), HttpResponse)
self.assertEqual(self.payment.status, 'confirmed')
def testHandleDataInvalidBody(self, mockEngine, loggingMock):
"""Make sure _handleData doesn't throw an exception for invalid data."""
# Call the function under test
body = '{"protocol": "plain", "data": ["test.metric 4.0 12:30PM"]}'
message = MagicMock()
message.body = body
metric_storer._handleBatch(mockEngine, [message], [], MagicMock(),
MagicMock())
# Check the results
self.assertTrue(loggingMock.warn.called)
def generate_dummy_email(kind, to_addr, body, uid):
email = MagicMock()
email.kind = kind
email.body = body
email.uid = uid
email.to_MIMEText = lambda: FakeMIMEText(body)
email.fr_addr = "*****@*****.**"
email.to_addr = to_addr
return email
def test_verify_body_size_okay():
errors = []
request = MagicMock()
request.headers = {'Content-Length': options.max_post_body_size}
request.body = " " * (options.max_post_body_size)
# MUT
verify_body_size(request, errors)
assert len(errors) == 0
def test_incorrect_custom_token_process_data(self):
"""
CoinbaseProvider.process_data() checks request custom token
"""
data = dict(COINBASE_REQUEST)
data.update({'order': {'custom': 'fake'}})
request = MagicMock()
request.body = json.dumps(data)
response = self.provider.process_data(self.payment, request)
self.assertEqual(type(response), HttpResponseForbidden)
def test_assets_url_is_generated_for_each_file_when_debug_is_true(self):
context = MagicMock()
context['caller'] = MagicMock()
context['caller'].body = MagicMock()
configure(MOCK_CONF_DEBUG_MODE)
tag(context, 'final-js-bundle')
context['caller'].body.assert_any_call(ASSETS_URL='my-url/file1.js')
context['caller'].body.assert_any_call(ASSETS_URL='my-url/file2.js')
def generate_dummy_email(kind, to_addr, body, uid):
email = MagicMock()
email.kind = kind
email.body = body
email.uid = uid
email.to_MIMEText = lambda: FakeMIMEText(body)
email.fr_addr = "*****@*****.**"
email.to_addr = to_addr
return email
def test_incorrect_custom_token_process_data(self):
"""
CoinbaseProvider.process_data() checks request custom token
"""
data = dict(COINBASE_REQUEST)
data.update({"order": {"custom": "fake"}})
request = MagicMock()
request.body = json.dumps(data)
response = self.provider.process_data(self.payment, request)
self.assertEqual(type(response), HttpResponseForbidden)
def test_verify_body_size_okay():
errors = []
request = MagicMock()
request.headers = {'Content-Length': options.max_post_body_size}
request.body = " " * (options.max_post_body_size)
# MUT
verify_body_size(request, errors)
assert len(errors) == 0
def test_helpscout_user(self):
request = MagicMock()
request.method = 'POST'
request.body = json.dumps({'customer': {'email': '*****@*****.**'}})
# User does not exist
response = helpscout_user(request)
self.assertTemplateUsed(response, 'django_helpscout/404.html')
# User found
user = User.objects.create(username='******', email='*****@*****.**', password='******')
response = helpscout_user(request)
self.assertTemplateUsed(response, 'django_helpscout/helpscout.html')
def test_create_member(self):
collection_handler = webservice.CollectionHandler(r'/', '')
collection_handler.model = webservice.SimpleDataModel("test")
request = MagicMock()
request.body = '{"key": "value"}'
request.path = "/"
response = collection_handler.create_member(request, id_='123')
self.assertEqual('application/json', response.content_type)
self.assertEqual(str(httplib.CREATED) + " Created", response.status)
self.assertEqual("%s/%s" % (request.path, '123'), response.location)
actual_response = json.loads(response.body)
actual_id = actual_response.get("id")
actual_value = actual_response.get("key")
self.assertEqual('123', actual_id)
self.assertEqual('value', actual_value)
def test_list_members(self):
collection_handler = webservice.CollectionHandler(r'/', '')
collection_handler.model = webservice.SimpleDataModel("test")
request = MagicMock()
request.body = '{"key": "value"}'
request.params = MagicMock()
request.path = "/"
response = collection_handler.list_members(request)
items = collection_handler.model.get_items(
request.params,
context=collection_handler._get_context(request))
expected_body = "%s\n" % json.dumps(items, indent=2)
self.assertEqual('application/json', response.content_type)
self.assertEqual(expected_body, response.body)
self.assertEqual('application/json', response.content_type)
self.assertEqual(str(httplib.OK) + " OK", response.status)
def test_regular(self):
suggestions = MagicMock()
sender = MagicMock()
target = Target(suggestions, sender)
target.bson_json_decode_and_load = MagicMock(return_value="decoded_response")
target.suggest_responder.suggestion_items = MagicMock()
response = MagicMock()
response.body = "response_body"
response.headers = {"next_offset": "next_offset_value"}
target.get_suggestion_items_callback(response, "handler", {'offset': "offset_value"})
target.bson_json_decode_and_load.assert_called_once_with('response_body')
suggestions.write_suggestion_items.assert_called_once_with('handler', 'decoded_response', "offset_value",
"next_offset_value")
target.suggest_responder.suggestion_items.assert_called_once_with('handler', {'offset': 'offset_value'},
'decoded_response')
def test_post_mainline(self, get_number,
allocate_number,
gen_sip_pass,
HTTPCallbackGroup,
get_associated_privates,
put_password):
# Setup
self.handler.get_and_check_user_id = MagicMock(return_value=USER_ID)
self.handler.check_number_ownership = Mock()
gen_sip_pass.return_value = "sip_pass"
HTTPCallbackGroup.return_value = MagicMock()
self.handler.finish = MagicMock()
# Test
self.handler.post("foobar", SIP_URI)
# Assert
HTTPCallbackGroup.assert_called_once_with(self.handler.on_get_privates_success,
self.handler.on_get_privates_failure)
get_associated_privates.assert_called_once_with(SIP_URI,
self.handler._request_group.callback())
# Reset http callback group
HTTPCallbackGroup.reset_mock()
HTTPCallbackGroup.return_value = MagicMock()
# Invoke callback for returned private IDs and assert password is created
response = MagicMock()
response.body = '{"public_id": "%s", "private_ids": ["*****@*****.**"]}' % SIP_URI
self.handler.on_get_privates_success([response])
HTTPCallbackGroup.assert_called_once_with(self.handler.on_put_password_success,
self.handler.on_put_password_failure)
put_password.assert_called_once_with("*****@*****.**",
REALM,
"sip_pass",
self.handler._request_group.callback())
# Invoke call for password PUT
response = MagicMock()
response.code = 200
self.handler.on_put_password_success(response)
self.handler.finish.assert_called_once_with({"sip_password": "******"})
def test_regular_has_entities(self):
sender = MagicMock()
context = MagicMock()
suggest = Mock()
target = Target(sender, context, suggest)
target.json_decode = MagicMock(
return_value={
"entities": [
{
"source": "non_detection"
}
],
"_rev": "_context_rev_value"
}
)
handler = MagicMock()
handler.user_id = "user_id_value"
handler.application_id = "application_id_value"
handler.session_id = "session_id_value"
handler.locale = "locale_value"
response = MagicMock()
response.body = "response_value"
target.get_context_callback(response, handler, "message_value")
self.assertEqual(1, suggest.post_suggest.call_count)
self.assertEqual("user_id_value", suggest.post_suggest.call_args_list[0][0][0])
self.assertEqual("application_id_value", suggest.post_suggest.call_args_list[0][0][1])
self.assertEqual("session_id_value", suggest.post_suggest.call_args_list[0][0][2])
self.assertEqual("locale_value", suggest.post_suggest.call_args_list[0][0][3])
self.assertDictEqual({'_rev': '_context_rev_value', 'entities': [{'source': 'non_detection'}]},
suggest.post_suggest.call_args_list[0][0][4])
target.json_decode.assert_called_once_with('response_value')
self.assertDictEqual({'_rev': '_context_rev_value', 'entities': [{'source': 'non_detection'}]}, handler.context)
self.assertEqual("_context_rev_value", handler.context_rev)
def test_sauthc1signer(self):
r = MagicMock()
r.headers = {}
r.url = 'https://api.stormpath.com/v1/'
r.method = 'GET'
r.body = None
mock_dt = MagicMock()
mock_dt.utcnow.return_value = datetime.datetime(2013, 7, 1,
0, 0, 0, 0)
mock_uuid4 = MagicMock(
return_value='a43a9d25-ab06-421e-8605-33fd1e760825')
s = Sauthc1Signer(id='MyId', secret='Shush!')
with patch('stormpath.auth.datetime', mock_dt):
with patch('stormpath.auth.uuid4', mock_uuid4):
r2 = s(r)
self.assertEqual(r, r2)
self.assertEqual(r.headers['Authorization'],
'SAuthc1 sauthc1Id=MyId/20130701/a43a9d25-ab06-421e-8605-33fd1e760825/sauthc1_request, ' + # noqa
'sauthc1SignedHeaders=host;x-stormpath-date, ' +
'sauthc1Signature=990a95aabbcbeb53e48fb721f73b75bd3ae025a2e86ad359d08558e1bbb9411c') # noqa
def test_sauthc1signer_query(self):
# The plus sign in a url query must be replaced with %20
r = MagicMock()
r.headers = {}
r.url = 'https://api.stormpath.com/v1/directories?orderBy=name+asc'
r.method = 'GET'
r.body = None
mock_dt = MagicMock()
mock_dt.utcnow.return_value = datetime.datetime(2013, 7, 1,
0, 0, 0, 0)
mock_uuid4 = MagicMock(
return_value='a43a9d25-ab06-421e-8605-33fd1e760825')
s = Sauthc1Signer(id='MyId', secret='Shush!')
with patch('stormpath.auth.datetime', mock_dt):
with patch('stormpath.auth.uuid4', mock_uuid4):
r2 = s(r)
self.assertEqual(r, r2)
self.assertEqual(r.headers['Authorization'],
'SAuthc1 sauthc1Id=MyId/20130701/a43a9d25-ab06-421e-8605-33fd1e760825/sauthc1_request, ' + # noqa
'sauthc1SignedHeaders=host;x-stormpath-date, ' +
'sauthc1Signature=fc04c5187cc017bbdf9c0bb743a52a9487ccb91c0996267988ceae3f10314176') # noqa