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