def test_keep_alive_error_handler(self):
mock_response = create_mock_json('tests/resources/keep_alive_success.json')
assert self.keep_alive._error_handler(mock_response.json()) is None
mock_response = create_mock_json('tests/resources/keep_alive_fail.json')
with self.assertRaises(KeepAliveError):
self.keep_alive._error_handler(mock_response.json())
def test_login_error_handler(self):
mock_response = create_mock_json('tests/resources/login_success.json')
assert self.login._error_handler(mock_response.json()) is None
mock_response = create_mock_json('tests/resources/login_fail.json')
with self.assertRaises(LoginError):
self.login._error_handler(mock_response.json())
def test_base_endpoint_error_handler(self):
mock_response = create_mock_json('tests/resources/base_endpoint_success.json')
assert self.base_endpoint._error_handler(mock_response.json()) is None
mock_response = create_mock_json('tests/resources/base_endpoint_fail.json')
with self.assertRaises(APIError):
self.base_endpoint._error_handler(mock_response.json())
def test_create_origination_urls_instance(self, request):
resp = create_mock_json('tests/resources/trunking/origination_urls_instance.json')
resp.status_code = 201
request.return_value = resp
origination_urls = OriginationUrls(BASE_URI, AUTH)
result = origination_urls.create('Name', 'sip:169.10.1.35')
assert_equal(result.sid, "OUaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
assert_equal(result.account_sid, "ACaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
assert_equal(result.trunk_sid, "TK11111111111111111111111111111111")
assert_equal(result.friendly_name, "Name")
assert_equal(result.sip_url, "sip:169.10.1.35")
assert_equal(result.weight, 10)
assert_equal(result.priority, 20)
assert_true(result.enabled)
assert_equal(result.url, "{0}/OriginationUrls/OUaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa".format(BASE_URI))
data_dict = dict()
data_dict['FriendlyName'] = 'Name'
data_dict['SipUrl'] = 'sip:169.10.1.35'
data_dict['Priority'] = 10
data_dict['Weight'] = 10
data_dict['Enabled'] = 'true'
request.assert_called_with(
"POST",
"{0}/OriginationUrls".format(BASE_URI),
auth=AUTH,
use_json_extension=False,
data=data_dict,
)
def test_get_origination_urls_lists(self, request):
resp = create_mock_json('tests/resources/trunking/origination_urls_list.json')
resp.status_code = 200
request.return_value = resp
origination_urls = OriginationUrls(BASE_URI, AUTH)
result = origination_urls.list()
assert_equal(len(result), 1)
assert_equal(result[0].sid, 'OUaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa')
assert_equal(result[0].account_sid, 'ACaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa')
assert_equal(result[0].trunk_sid, "TK11111111111111111111111111111111")
assert_equal(result[0].friendly_name, "Name")
assert_equal(result[0].sip_url, "sip:169.10.1.35")
assert_equal(result[0].weight, 10)
assert_equal(result[0].priority, 20)
assert_true(result[0].enabled)
assert_equal(result[0].url, "{0}/OriginationUrls/OUaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa".format(BASE_URI))
request.assert_called_with(
"GET",
"{0}/OriginationUrls".format(BASE_URI),
auth=AUTH,
params={},
use_json_extension=False,
)
def test_members(self, mock):
resp = create_mock_json("tests/resources/members_list.json")
mock.return_value = resp
self.client.members("QU123").list()
uri = "https://api.twilio.com/2010-04-01/Accounts/ACCOUNT_SID/Queues/QU123/Members"
mock.assert_called_with("GET", uri, params={}, auth=AUTH,
use_json_extension=True)
def test_number_country(self, request):
resp = create_mock_json('tests/resources/pricing/phone_number_country_instance.json')
resp.status_code = 200
request.return_value = resp
countries = PhoneNumberCountries(BASE_URI + "/PhoneNumbers", AUTH)
country = countries.get('EE')
assert_equal(country.country, "Estonia")
assert_equal(
country.phone_number_prices,
[
{
'type': 'mobile',
'base_price': 3.00,
'current_price': 3.00,
},
{
'type': 'national',
'base_price': 1.00,
'current_price': 1.00,
}
],
)
request.assert_called_with(
"GET",
"{0}/PhoneNumbers/Countries/EE".format(BASE_URI),
auth=AUTH,
use_json_extension=False,
)
def test_call(self, mock_response):
mock = create_mock_json('tests/resources/keep_alive_success.json')
mock_response.return_value = mock
response = self.keep_alive()
assert response == mock.json()
assert self.keep_alive.client.session_token == mock.json().get('token')
def test_call(self, mock_response):
mock = create_mock_json('tests/resources/logout_success.json')
mock_response.return_value = mock
response = self.logout()
assert response == mock.json()
assert self.logout.client.session_token is None
def test_events(mock):
client = TwilioMonitorClient("ACCOUNT_SID", "AUTH_TOKEN")
resp = create_mock_json("tests/resources/monitor/events_instance.json")
mock.return_value = resp
client.events.get("AEaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
uri = "https://monitor.twilio.com/v1/Events/AEaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
mock.assert_called_with("GET", uri, auth=("ACCOUNT_SID", "AUTH_TOKEN"), use_json_extension=False)
def test_create_call_feedback_one_request(self, request):
resp = create_mock_json('tests/resources/call_feedback.json')
resp.status_code = 201
request.return_value = resp
base_uri = 'https://api.twilio.com/2010-04-01/Accounts/AC123'
account_sid = 'AC123'
auth = (account_sid, "token")
calls = Calls(base_uri, auth)
uri = "%s/Calls/CA123/Feedback" % base_uri
feedback = calls.feedback(
'CA123',
quality_score=5,
issue=['imperfect-audio', 'post-dial-delay']
)
exp_data = {
'QualityScore': 5,
'Issue': ['imperfect-audio', 'post-dial-delay'],
}
assert_equal(['imperfect-audio', 'post-dial-delay'], feedback.issues)
request.assert_called_with(
"POST", uri,
data=exp_data, auth=auth,
use_json_extension=True,
)
def test_members(self, mock_request):
resp = create_mock_json("tests/resources/members_list.json")
mock_request.return_value = resp
self.client.members("QU123").list()
mock_request.assert_called_with("GET", ANY, params=ANY, auth=AUTH,
timeout=sentinel.timeout,
use_json_extension=True)
def test_create_call_feedback(self, request):
resp = create_mock_json('tests/resources/call_feedback.json')
resp.status_code = 201
request.return_value = resp
mock = Mock()
mock.uri = '/base'
mock.auth = AUTH
call = Call(mock, 'CA123')
call.load_subresources()
feedback = call.feedback.create(
quality_score=5,
issues=['imperfect-audio', 'post-dial-delay'],
)
exp_data = {
'QualityScore': 5,
'Issues': ['imperfect-audio', 'post-dial-delay'],
}
assert_equal(5, feedback.quality_score, 5)
assert_equal(['imperfect-audio', 'post-dial-delay'], feedback.issues)
request.assert_called_with(
"POST", "/base/CA123/Feedback",
data=exp_data, auth=AUTH,
timeout=ANY, use_json_extension=True,
)
def test_market_book(self):
mock_response = create_mock_json('tests/resources/list_market_book.json')
market_books = mock_response.json().get('result')
for market_book in market_books:
resource = resources.MarketBook(date_time_sent=self.DATE_TIME_SENT,
**market_book)
assert resource._datetime_sent == self.DATE_TIME_SENT
assert resource.market_id == market_book['marketId']
assert resource.bet_delay == market_book['betDelay']
assert resource.bsp_reconciled == market_book['bspReconciled']
assert resource.complete == market_book['complete']
assert resource.cross_matching == market_book['crossMatching']
assert resource.inplay == market_book['inplay']
assert resource.is_market_data_delayed == market_book['isMarketDataDelayed']
assert resource.last_match_time == datetime.datetime.strptime(
market_book['lastMatchTime'], "%Y-%m-%dT%H:%M:%S.%fZ")
assert resource.number_of_active_runners == market_book['numberOfActiveRunners']
assert resource.number_of_runners == market_book['numberOfRunners']
assert resource.number_of_winners == market_book['numberOfWinners']
assert resource.runners_voidable == market_book['runnersVoidable']
assert resource.status == market_book['status']
assert resource.total_available == market_book['totalAvailable']
assert resource.total_matched == market_book['totalMatched']
assert resource.version == market_book['version']
assert len(resource.runners) == len(market_book['runners'])
for runner in market_book['runners']:
pass
def test_place_orders(self):
mock_response = create_mock_json('tests/resources/place_orders.json')
place_orders = mock_response.json().get('result')
resource = resources.PlaceOrders(date_time_sent=self.DATE_TIME_SENT,
**place_orders)
assert resource._datetime_sent == self.DATE_TIME_SENT
assert resource.market_id == place_orders['marketId']
assert resource.status == place_orders['status']
assert resource.customer_ref == place_orders.get('customerRef')
assert resource.error_code == place_orders.get('errorCode')
assert len(resource.place_instruction_reports) == len(place_orders.get('instructionReports'))
for order in place_orders.get('instructionReports'):
assert resource.place_instruction_reports[0].size_matched == order['sizeMatched']
assert resource.place_instruction_reports[0].status == order['status']
assert resource.place_instruction_reports[0].bet_id == order['betId']
assert resource.place_instruction_reports[0].average_price_matched == order['averagePriceMatched']
assert resource.place_instruction_reports[0].placed_date == datetime.datetime.strptime(
order['placedDate'], "%Y-%m-%dT%H:%M:%S.%fZ")
assert resource.place_instruction_reports[0].error_code == order.get('errorCode')
assert resource.place_instruction_reports[0].instruction.selection_id == order['instruction']['selectionId']
assert resource.place_instruction_reports[0].instruction.side == order['instruction']['side']
assert resource.place_instruction_reports[0].instruction.order_type == order['instruction']['orderType']
assert resource.place_instruction_reports[0].instruction.handicap == order['instruction']['handicap']
assert resource.place_instruction_reports[0].instruction.order.persistence_type == order['instruction']['limitOrder']['persistenceType']
assert resource.place_instruction_reports[0].instruction.order.price == order['instruction']['limitOrder']['price']
assert resource.place_instruction_reports[0].instruction.order.size == order['instruction']['limitOrder']['size']
def test_triggers_create(request):
resp = create_mock_json("tests/resources/usage_triggers_instance.json")
resp.status_code = 201
request.return_value = resp
usage.triggers.create(
friendly_name="foo",
usage_category="sms",
trigger_by="count",
recurring="price",
trigger_value="10.00",
callback_url="http://www.example.com",
callback_method="POST"
)
uri = "%s/Usage/Triggers" % BASE_URI
request.assert_called_with("POST", uri, data={
"FriendlyName": "foo",
"UsageCategory": "sms",
"TriggerBy": "count",
"Recurring": "price",
"TriggerValue": "10.00",
"CallbackUrl": "http://www.example.com",
"CallbackMethod": "POST"
}, auth=AUTH, use_json_extension=True)
def test_call(self, mock_response):
mock = create_mock_json('tests/resources/login_success.json')
mock_response.return_value = mock
response = self.login()
assert response == mock.json()
assert self.login.client.session_token == mock.json().get('sessionToken')
def test_get_key(mock):
resp = create_mock_json("tests/resources/keys_instance.json")
mock.return_value = resp
url = BASE_URL + "/Keys/{0}".format(KEY_SID)
list_resource.get(KEY_SID)
mock.assert_called_with("GET", url, auth=AUTH, use_json_extension=True)
def test_list_keys(mock):
resp = create_mock_json("tests/resources/keys_list.json")
mock.return_value = resp
url = BASE_URL + "/Keys"
list_resource.list()
mock.assert_called_with("GET", url, params={}, auth=AUTH, use_json_extension=True)
def test_queue_delete(mock):
resp = create_mock_json("tests/resources/queues_instance.json")
mock.return_value = resp
uri = "%s/Queues/%s" % (BASE_URI, QUEUE_SID)
instance_resource.delete()
mock.assert_called_with("DELETE", uri, auth=AUTH, use_json_extension=True)
def test_queues_get(mock):
resp = create_mock_json("tests/resources/queues_instance.json")
mock.return_value = resp
uri = "%s/Queues/%s" % (BASE_URI, QUEUE_SID)
list_resource.get(QUEUE_SID)
mock.assert_called_with("GET", uri, auth=AUTH,
use_json_extension=True)
def test_phone_numbers(mock):
client = TwilioLookupsClient("ACCOUNT_SID", "AUTH_TOKEN")
resp = create_mock_json("tests/resources/lookups/phone_number_instance.json")
mock.return_value = resp
client.phone_numbers.get("+15108675309")
uri = "https://lookups.twilio.com/v1/PhoneNumbers/+15108675309"
mock.assert_called_with("GET", uri, params={}, auth=("ACCOUNT_SID", "AUTH_TOKEN"),
use_json_extension=False)
def test_get(self, mock):
resp = create_mock_json("tests/resources/ip_messaging/message_instance.json")
mock.return_value = resp
uri = "%s/Messages/%s" % (BASE_URI, MESSAGE_SID)
list_resource.get(MESSAGE_SID)
mock.assert_called_with("GET", uri, auth=AUTH, use_json_extension=False)
def test_replace_orders(self, mock_response):
mock = create_mock_json('tests/resources/replace_orders.json')
mock_response.return_value = mock
response = self.betting.replace_orders()
assert mock.json.call_count == 1
mock_response.assert_called_with('SportsAPING/v1.0/replaceOrders', None, None)
assert isinstance(response, resources.ReplaceOrders)
def test_workflows(self, request):
resp = create_mock_json("tests/resources/task_router/workflows_list.json")
request.return_value = resp
workflows = self.task_router_client.workflows("WS123")
workflows = workflows.list()
assert_true(workflows[0].sid is not None)
uri = "https://taskrouter.twilio.com/v1/Workspaces/WS123/Workflows"
request.assert_called_with("GET", uri, headers=ANY, params={}, auth=AUTH)
def test_data(self):
mock_response = create_mock_json('tests/resources/base_resource.json')
base_resource = BaseResource(date_time_sent=datetime.datetime(2003, 8, 4, 12, 30, 45),
**mock_response.json())
assert base_resource._datetime_sent == datetime.datetime(2003, 8, 4, 12, 30, 45)
assert base_resource.id == 12345
assert base_resource.elapsed_time > 0
assert base_resource._data == mock_response.json()
def test_list_market_book(self, mock_response):
mock = create_mock_json('tests/resources/list_market_book.json')
mock_response.return_value = mock
response = self.betting.list_market_book()
assert mock.json.call_count == 1
mock_response.assert_called_with('SportsAPING/v1.0/listMarketBook', None, None)
assert isinstance(response[0], resources.MarketBook)
assert len(response) == 1
def test_get(self, request):
resp = create_mock_json("tests/resources/task_router/reservations_instance.json")
resp.status_code = 200
request.return_value = resp
uri = "{0}/Reservations/{1}".format(BASE_URI, RESERVATION_SID)
list_resource = Reservations(BASE_URI, AUTH)
list_resource.get(RESERVATION_SID)
request.assert_called_with("GET", uri, auth=AUTH, use_json_extension=False)
def test_list_for_worker(self, request):
resp = create_mock_json("tests/resources/task_router/reservations_list.json")
resp.status_code = 200
request.return_value = resp
uri = "{0}/Reservations".format(BASE_WORKER_URI)
list_resource = Reservations(BASE_WORKER_URI, AUTH)
list_resource.list()
request.assert_called_with("GET", uri, params={}, auth=AUTH, use_json_extension=False)
def test_list_events(self, mock_response):
mock = create_mock_json('tests/resources/list_events.json')
mock_response.return_value = mock
response = self.betting.list_events()
assert mock.json.call_count == 1
mock_response.assert_called_with('SportsAPING/v1.0/listEvents', None, None)
assert isinstance(response[0], resources.EventResult)
assert len(response) == 7
def test_event_type_result(self):
mock_response = create_mock_json(
"tests/resources/list_event_types.json")
event_types = mock_response.json().get("result")
for event_type in event_types:
resource = resources.EventTypeResult(
elapsed_time=self.ELAPSED_TIME, **event_type)
assert resource.elapsed_time == self.ELAPSED_TIME
assert resource.market_count == event_type["marketCount"]
assert resource.event_type.id == event_type["eventType"]["id"]
assert resource.event_type.name == event_type["eventType"]["name"]
def test_request(self, mock_post, mock_login_headers, mock_cert):
mock_response = create_mock_json('tests/resources/login_success.json')
mock_post.return_value = mock_response
url = 'https://identitysso.betfair.com/api/certlogin'
response = self.login.request()
mock_post.assert_called_once_with(
url,
data='username=username&password=password',
headers=mock_login_headers,
cert=mock_cert)
assert response == mock_response
def test_list(self, request):
resp = create_mock_json(
'tests/resources/task_router/activities_list.json')
resp.status_code = 200
request.return_value = resp
uri = "{0}/Activities".format(BASE_URI)
list_resource = Activities(BASE_URI, AUTH)
list_resource.list()
request.assert_called_with("GET",
uri,
params={},
auth=AUTH,
use_json_extension=False)
def test_request(self, mock_post, mock_login_headers, mock_cert):
mock_response = create_mock_json("tests/resources/login_success.json")
mock_post.return_value = mock_response
url = "https://identitysso-cert.betfair.com/api/certlogin"
response = self.login.request()
mock_post.assert_called_once_with(
url,
data={"username": "******", "password": "******"},
headers=mock_login_headers,
cert=mock_cert,
)
assert response[1] == mock_response.json()
def test_update_cache_md(self, mock_strip_datetime,
mock_market_definition):
publish_time = mock.Mock()
market_change = create_mock_json(
'tests/resources/streaming_mcm_UPDATE_md.json')
book_data = market_change.json().get('mc')
for book in book_data:
self.market_book_cache.update_cache(book, publish_time)
mock_strip_datetime.assert_called_with(publish_time)
mock_market_definition.assert_called_with(
**book.get('marketDefinition'))
assert self.market_book_cache.market_definition == mock_market_definition(
**book.get('marketDefinition'))
def test_create_trunk_instance(self, request):
resp = create_mock_json(
'tests/resources/trunking/trunks_instance.json')
resp.status_code = 201
request.return_value = resp
trunks = Trunks(BASE_URI, AUTH)
kwargs = {
'FriendlyName': 'Test',
'DomainName': 'test-trunk.pstn.twilio.com'
}
result = trunks.create(**kwargs)
assert_equal(result.sid, 'TK11111111111111111111111111111111')
assert_equal(result.account_sid, 'ACaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa')
assert_equal(result.domain_name, "test-trunk.pstn.twilio.com")
assert_equal(result.friendly_name, "Test")
assert_equal(result.recording, {
"trim": "do-not-trim",
"mode": "record-from-ringing"
})
assert_equal(result.auth_type, "CREDENTIAL_LIST")
assert_equal(result.auth_type_set, ["CREDENTIAL_LIST"])
TRUNK_INSTANCE_BASE_URI = "{0}/{1}/{2}".format(BASE_URI, "Trunks",
TRUNK_SID)
assert_equal(result.url, TRUNK_INSTANCE_BASE_URI)
assert_equal(result.links['origination_urls'],
"{0}/OriginationUrls".format(TRUNK_INSTANCE_BASE_URI))
assert_equal(result.links['credential_lists'],
"{0}/CredentialLists".format(TRUNK_INSTANCE_BASE_URI))
assert_equal(
result.links['ip_access_control_lists'],
"{0}/IpAccessControlLists".format(TRUNK_INSTANCE_BASE_URI))
assert_equal(result.links['phone_numbers'],
"{0}/PhoneNumbers".format(TRUNK_INSTANCE_BASE_URI))
data_dict = dict()
data_dict['FriendlyName'] = 'Test'
data_dict['DomainName'] = 'test-trunk.pstn.twilio.com'
request.assert_called_with(
"POST",
"{0}/Trunks".format(BASE_URI),
auth=AUTH,
use_json_extension=False,
data=data_dict,
)
def test_update_orders(self):
mock_response = create_mock_json('tests/resources/update_orders.json')
update_orders = mock_response.json().get('result')
resource = resources.UpdateOrders(date_time_sent=self.DATE_TIME_SENT,
**update_orders)
assert resource._datetime_sent == self.DATE_TIME_SENT
assert resource.market_id == update_orders['marketId']
assert resource.status == update_orders['status']
assert resource.customer_ref == update_orders.get('customerRef')
assert resource.error_code == update_orders.get('errorCode')
assert len(resource.update_instruction_reports) == len(update_orders.get('instructionReports'))
for order in update_orders.get('instructionReports'):
pass
def test_on_change_message(self):
stream = mock.Mock()
self.stream_listener.stream = stream
mock_response = create_mock_json('tests/resources/streaming_mcm_SUB_IMAGE.json')
self.stream_listener._on_change_message(mock_response.json(), 1)
stream.on_subscribe.assert_called_with(mock_response.json())
mock_response = create_mock_json('tests/resources/streaming_mcm_RESUB_DELTA.json')
self.stream_listener._on_change_message(mock_response.json(), 1)
stream.on_resubscribe.assert_called_with(mock_response.json())
mock_response = create_mock_json('tests/resources/streaming_mcm_HEARTBEAT.json')
self.stream_listener._on_change_message(mock_response.json(), 1)
stream.on_heartbeat.assert_called_with(mock_response.json())
mock_response = create_mock_json('tests/resources/streaming_mcm_update.json')
self.stream_listener._on_change_message(mock_response.json(), 1)
stream.on_update.assert_called_with(mock_response.json())
mock_response = create_mock_json('tests/resources/streaming_ocm_SUB_IMAGE.json')
self.stream_listener._on_change_message(mock_response.json(), 1)
stream.on_subscribe.assert_called_with(mock_response.json())
def test_get(self, request):
resp = create_mock_json(
'tests/resources/conversations/participant_instance.json')
resp.status_code = 200
request.return_value = resp
uri = "{0}/Conversations/{1}".format(BASE_URI, CONVERSATION_SID)
expected = "{0}/Participants/{1}".format(uri, PARTICIPANT_SID)
list_resource = Participants(uri, AUTH)
list_resource.get(PARTICIPANT_SID)
request.assert_called_with("GET",
expected,
use_json_extension=False,
auth=AUTH)
def test_get(self, request):
resp = create_mock_json(
'tests/resources/task_router/task_queues_instance.json')
resp.status_code = 200
request.return_value = resp
uri = "{0}/TaskQueues/{1}".format(BASE_URI, TASK_QUEUE_SID)
list_resource = TaskQueues(BASE_URI, AUTH, TIMEOUT)
list_resource.get(TASK_QUEUE_SID)
request.assert_called_with("GET",
uri,
auth=AUTH,
timeout=TIMEOUT,
use_json_extension=False)
def test_create_user(mock):
resp = create_mock_json("tests/resources/ip_messaging/user_instance.json")
resp.status_code = 201
mock.return_value = resp
uri = "%s/Users" % (BASE_URI)
list_resource.create('test_id')
exp_params = {'Id': "test_id"}
mock.assert_called_with("POST",
uri,
data=exp_params,
auth=AUTH,
use_json_extension=False)
def test_get_carrier_info(request):
resp = create_mock_json(
"tests/resources/lookups/phone_number_instance.json", )
request.return_value = resp
phone_numbers = PhoneNumbers('/v1', AUTH, TIMEOUT)
pn = phone_numbers.get('+15108675309', include_carrier_info=True)
assert_equal(pn.phone_number, '+15108675309')
request.assert_called_with('GET',
'/v1/PhoneNumbers/+15108675309',
auth=AUTH,
timeout=TIMEOUT,
params={'Type': 'carrier'},
use_json_extension=False)
def test_get_with_country_code(request):
resp = create_mock_json(
"tests/resources/lookups/phone_number_instance.json", )
request.return_value = resp
phone_numbers = PhoneNumbers('/v1', AUTH, TIMEOUT)
pn = phone_numbers.get('510-867-5309', country_code='US')
assert_equal(pn.phone_number, '+15108675309')
request.assert_called_with('GET',
'/v1/PhoneNumbers/510-867-5309',
auth=AUTH,
timeout=TIMEOUT,
params={'CountryCode': 'US'},
use_json_extension=False)
def test_get_phone_number(request):
resp = create_mock_json(
"tests/resources/lookups/phone_number_instance.json", )
request.return_value = resp
phone_numbers = PhoneNumbers('/v1', AUTH, TIMEOUT)
pn = phone_numbers.get(NUMBER)
assert_equal(pn.phone_number, NUMBER)
request.assert_called_with('GET',
'/v1/PhoneNumbers/{0}'.format(NUMBER_ENCODED),
auth=AUTH,
timeout=TIMEOUT,
params={},
use_json_extension=False)
def test_on_update(self, mock_update_clk, mock_calc_latency, mock_process,
mock_clear_stale_cache):
mock_response = create_mock_json(
"tests/resources/streaming_mcm_update.json")
self.stream.on_update(mock_response.json())
mock_update_clk.assert_called_with(mock_response.json())
mock_calc_latency.assert_called_with(mock_response.json().get("pt"))
mock_process.assert_called_with(mock_response.json().get("mc"),
mock_response.json().get("pt"))
mock_calc_latency.return_value = 10
self.stream.on_update(mock_response.json())
mock_clear_stale_cache.assert_not_called()
def test_time_range_result(self):
mock_response = create_mock_json('tests/resources/list_time_ranges.json')
time_ranges = mock_response.json().get('result')
for time_range in time_ranges:
resource = resources.TimeRangeResult(date_time_sent=self.DATE_TIME_SENT,
**time_range)
assert resource._datetime_sent == self.DATE_TIME_SENT
assert resource.market_count == time_range['marketCount']
assert resource.time_range._from == datetime.datetime.strptime(time_range['timeRange']['from'],
"%Y-%m-%dT%H:%M:%S.%fZ")
assert resource.time_range.to == datetime.datetime.strptime(time_range['timeRange']['to'],
"%Y-%m-%dT%H:%M:%S.%fZ")
def test_fetch_workers_statistics(request):
resp = create_mock_json(
'tests/resources/task_router/workers_statistics_instance.json')
resp.status_code = 200
request.return_value = resp
workers = Workers(BASE_URI, AUTH, TIMEOUT)
workers.statistics.get()
request.assert_called_with('GET',
'{0}/Workers/Statistics'.format(BASE_URI),
params={},
auth=AUTH,
timeout=TIMEOUT,
use_json_extension=False)
def test_create(self, request):
resp = create_mock_json('tests/resources/task_router/workflows_instance.json')
resp.status_code = 201
request.return_value = resp
workflows = Workflows(BASE_URI, AUTH)
workflows.create("Test Workflow", "configuration", "http://www.example.com")
exp_params = {
'FriendlyName': "Test Workflow",
'Configuration': "configuration",
'AssignmentCallbackUrl': 'http://www.example.com'
}
request.assert_called_with("POST", "{0}/Workflows".format(BASE_URI), data=exp_params, auth=AUTH,
use_json_extension=False)
def test_create_message(self, mock):
resp = create_mock_json(
"tests/resources/ip_messaging/message_instance.json")
resp.status_code = 201
mock.return_value = resp
uri = "%s/Messages" % (BASE_URI)
list_resource.create('TestBody')
exp_params = {'Body': "TestBody"}
mock.assert_called_with("POST",
uri,
data=exp_params,
auth=AUTH,
use_json_extension=False)
def test_hangup(mock):
resp = create_mock_json("tests/resources/calls_instance.json")
resp.status_code = 204
mock.return_value = resp
uri = "%s/Calls/%s" % (BASE_URI, CALL_SID)
r = list_resource.hangup(CALL_SID)
exp_data = {"Status": "completed"}
mock.assert_called_with("POST",
uri,
data=exp_data,
auth=AUTH,
use_json_extension=True)
assert_true(r)
def test_paging_iter(mock):
resp = create_mock_json("tests/resources/recordings_list.json")
mock.return_value = resp
uri = "%s/Recordings" % (BASE_URI)
next(recordings.iter(before=date(2010, 12, 5)))
exp_params = {'DateCreated<': '2010-12-05'}
mock.assert_called_with("GET", uri, params=exp_params, auth=AUTH,
use_json_extension=True)
next(recordings.iter(after=date(2012, 12, 7)))
exp_params = {'DateCreated>': '2012-12-07'}
mock.assert_called_with("GET", uri, params=exp_params, auth=AUTH,
use_json_extension=True)
def test_time_range_result(self):
mock_response = create_mock_json(
"tests/resources/list_time_ranges.json")
time_ranges = mock_response.json().get("result")
for time_range in time_ranges:
resource = resources.TimeRangeResult(
elapsed_time=self.ELAPSED_TIME, **time_range)
assert resource.elapsed_time == self.ELAPSED_TIME
assert resource.market_count == time_range["marketCount"]
assert resource.time_range._from == datetime.datetime.strptime(
time_range["timeRange"]["from"], BETFAIR_DATE_FORMAT)
assert resource.time_range.to == datetime.datetime.strptime(
time_range["timeRange"]["to"], BETFAIR_DATE_FORMAT)
def test_update(self, mock):
resp = create_mock_json(
"tests/resources/ip_messaging/message_instance.json")
mock.return_value = resp
update_params = {'UniqueName': 'unique'}
uri = "%s/Messages/%s" % (BASE_URI, MESSAGE_SID)
list_resource.update(MESSAGE_SID, unique_name='unique')
mock.assert_called_with("POST",
uri,
data=update_params,
auth=AUTH,
use_json_extension=False)
def test_on_data(self, mock_error_handler, mock_on_change_message, mock_on_status, mock_on_connection):
self.stream_listener.stream_unique_id = 2
mock_response = create_mock_json('tests/resources/streaming_connection.json')
self.stream_listener.on_data(mock_response.content)
mock_error_handler.assert_called_with(mock_response.json(), mock_response.json().get('id'))
mock_on_connection.assert_called_with(mock_response.json(), mock_response.json().get('id'))
mock_response = create_mock_json('tests/resources/streaming_status.json')
self.stream_listener.on_data(mock_response.content)
mock_error_handler.assert_called_with(mock_response.json(), mock_response.json().get('id'))
mock_on_status.assert_called_with(mock_response.json(), mock_response.json().get('id'))
mock_response = create_mock_json('tests/resources/streaming_mcm_update.json')
self.stream_listener.on_data(mock_response.content)
mock_error_handler.assert_called_with(mock_response.json(), mock_response.json().get('id'))
mock_on_change_message.assert_called_with(mock_response.json(), mock_response.json().get('id'))
on_data = self.stream_listener.on_data('some content')
assert on_data is None
mock_error_handler.return_value = True
on_data = self.stream_listener.on_data(mock_response.content)
assert on_data is False
def test_create_service(mock):
resp = create_mock_json(
"tests/resources/ip_messaging/service_instance.json")
resp.status_code = 201
mock.return_value = resp
uri = "%s/Services" % (BASE_URI)
list_resource.create('TestService')
exp_params = {'FriendlyName': "TestService"}
mock.assert_called_with("POST",
uri,
data=exp_params,
auth=AUTH,
use_json_extension=False)
def test_create_credential(mock):
resp = create_mock_json(
"tests/resources/ip_messaging/credential_instance.json")
resp.status_code = 201
mock.return_value = resp
uri = "%s/Credentials" % (BASE_URI)
list_resource.create('apn')
exp_params = {'Type': "apn"}
mock.assert_called_with("POST",
uri,
data=exp_params,
auth=AUTH,
use_json_extension=False)
def test_list_in_progress(self, request):
resp = create_mock_json(
'tests/resources/conversations/participant_list.json')
resp.status_code = 200
request.return_value = resp
uri = "{0}/Conversations/{1}".format(BASE_URI, CONVERSATION_SID)
expected = "{0}/Participants".format(uri)
list_resource = Participants(uri, AUTH)
list_resource.list()
request.assert_called_with("GET",
expected,
params={},
auth=AUTH,
use_json_extension=False)
def test_create_channel(self, mock):
resp = create_mock_json(
"tests/resources/ip_messaging/channel_instance.json")
resp.status_code = 201
mock.return_value = resp
uri = "%s/Channels" % (BASE_URI)
list_resource.create(friendly_name='TestChannel', unique_name='Unique')
exp_params = {'FriendlyName': "TestChannel", 'UniqueName': 'Unique'}
mock.assert_called_with("POST",
uri,
data=exp_params,
auth=AUTH,
use_json_extension=False)
def test_request(self, mock_post, mock_request_headers, mock_cert, mock_create_req):
mock_response = create_mock_json('tests/resources/login_success.json')
mock_post.return_value = mock_response
mock_client_cert = mock.Mock()
mock_client_cert.return_value = []
mock_cert.return_value = mock_client_cert
url = 'https://api.betfair.com/exchange/betting/json-rpc/v1'
response = self.base_endpoint.request(None, None, None)
mock_post.assert_called_once_with(url, data=mock_create_req(),
headers=mock_request_headers, timeout=(3.05, 16))
assert response[0] == mock_response.json()
assert isinstance(response[1], float)
def test_update_orders(self):
mock_response = create_mock_json("tests/resources/update_orders.json")
update_orders = mock_response.json().get("result")
resource = resources.UpdateOrders(elapsed_time=self.ELAPSED_TIME,
**update_orders)
assert resource.elapsed_time == self.ELAPSED_TIME
assert resource.market_id == update_orders["marketId"]
assert resource.status == update_orders["status"]
assert resource.customer_ref == update_orders.get("customerRef")
assert resource.error_code == update_orders.get("errorCode")
assert len(resource.update_instruction_reports) == len(
update_orders.get("instructionReports"))
for order in update_orders.get("instructionReports"):
pass