def test_logout_error_handler(self):
mock_response = create_mock_json('tests/resources/logout_success.json')
assert self.logout._error_handler(mock_response.json()) is None
mock_response = create_mock_json('tests/resources/logout_fail.json')
with self.assertRaises(LogoutError):
self.logout._error_handler(mock_response.json())
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_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_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_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_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_call(self, mock_response):
mock_json = create_mock_json('tests/resources/login_success.json')
mock_response.return_value = (mock_json.json(), 1.3)
response = self.login()
assert isinstance(response, LoginResource)
assert self.login.client.session_token == mock_json.json().get('sessionToken')
def test_error_handler(self):
mock_response = create_mock_json(
'tests/resources/streaming_connection.json')
self.stream_listener._error_handler(mock_response.json(), 1)
error_data = {
'errorMessage': 'AppKey is not valid',
'connectionClosed': True,
'connectionId': '005-015616813698-533678',
'op': 'status',
'id': 2,
'errorCode': 'INVALID_APP_KEY',
'statusCode': 'FAILURE'
}
return_value = self.stream_listener._error_handler(error_data, 1)
assert return_value is True
error_data = {
'errorMessage':
'Customer tried to subscribe to more markets than allowed to',
'connectionClosed': False,
'connectionId': '005-015616813698-533678',
'op': 'status',
'id': 2,
'errorCode': 'SUBSCRIPTION_LIMIT_EXCEEDED',
'statusCode': 'FAILURE'
}
return_value = self.stream_listener._error_handler(error_data, 1)
assert return_value is None
def test_process(self, mock_on_process, mock_cache):
sub_image = create_mock_json(
"tests/resources/streaming_mcm_SUB_IMAGE.json")
data = sub_image.json()["mc"]
self.assertTrue(self.stream._process(data, 123))
self.assertEqual(len(self.stream), len(data))
mock_on_process.assert_called_with([mock_cache()])
def setUp(self):
self.mock_response = create_mock_json(
"tests/resources/streaming_market_definition.json"
)
market_definition = self.mock_response.json()
runner = market_definition["runners"][0]
self.market_definition_runner = MarketDefinitionRunner(**runner)
def test_process_empty_image(self, mock_on_process, mock_cache):
self.stream._caches = {"1.161613698": mock.Mock()}
sub_image = create_mock_json("tests/resources/streaming_ocm_EMPTY_IMAGE.json")
data = sub_image.json()["oc"]
self.assertTrue(self.stream._process(data, 123))
self.assertEqual(len(self.stream), len(data))
self.assertTrue(self.stream._process(data, 123))
def test_call(self, mock_response):
mock = create_mock_json('tests/resources/logout_success.json')
mock_response.return_value = (mock.json(), 1.3)
response = self.logout()
assert isinstance(response, LogoutResource)
assert self.logout.client.session_token is None
def test_call(self, mock_response):
mock = create_mock_json('tests/resources/keep_alive_success.json')
mock_response.return_value = (mock.json(), 1.3)
response = self.keep_alive()
assert isinstance(response, KeepAliveResource)
assert self.keep_alive.client.session_token == mock.json().get('token')
def test_error_handler(self):
mock_response = create_mock_json(
"tests/resources/streaming_connection.json")
self.stream_listener._error_handler(mock_response.json(), 1)
error_data = {
"errorMessage": "AppKey is not valid",
"connectionClosed": True,
"connectionId": "005-015616813698-533678",
"op": "status",
"id": 2,
"errorCode": "INVALID_APP_KEY",
"statusCode": "FAILURE",
}
return_value = self.stream_listener._error_handler(error_data, 1)
assert return_value is True
error_data = {
"errorMessage":
"Customer tried to subscribe to more markets than allowed to",
"connectionClosed": False,
"connectionId": "005-015616813698-533678",
"op": "status",
"id": 2,
"errorCode": "SUBSCRIPTION_LIMIT_EXCEEDED",
"statusCode": "FAILURE",
}
return_value = self.stream_listener._error_handler(error_data, 1)
assert return_value is None
def test_cancel_orders(self):
mock_response = create_mock_json('tests/resources/cancel_orders.json')
cancel_orders = mock_response.json().get('result')
resource = resources.CancelOrders(elapsed_time=self.ELAPSED_TIME,
**cancel_orders)
assert resource.elapsed_time == self.ELAPSED_TIME
assert resource.market_id == cancel_orders['marketId']
assert resource.status == cancel_orders['status']
assert resource.customer_ref == cancel_orders.get('customerRef')
assert resource.error_code == cancel_orders.get('errorCode')
assert len(resource.cancel_instruction_reports) == len(
cancel_orders.get('instructionReports'))
for order in cancel_orders.get('instructionReports'):
assert resource.cancel_instruction_reports[
0].size_cancelled == order['sizeCancelled']
assert resource.cancel_instruction_reports[0].status == order[
'status']
assert resource.cancel_instruction_reports[
0].cancelled_date == datetime.datetime.strptime(
order['cancelledDate'], "%Y-%m-%dT%H:%M:%S.%fZ")
assert resource.cancel_instruction_reports[
0].instruction.bet_id == order['instruction']['betId']
assert resource.cancel_instruction_reports[
0].instruction.size_reduction == order['instruction'].get(
'sizeReduction')
def test_cancel_orders(self):
mock_response = create_mock_json("tests/resources/cancel_orders.json")
cancel_orders = mock_response.json().get("result")
resource = resources.CancelOrders(elapsed_time=self.ELAPSED_TIME,
**cancel_orders)
assert resource.elapsed_time == self.ELAPSED_TIME
assert resource.market_id == cancel_orders["marketId"]
assert resource.status == cancel_orders["status"]
assert resource.customer_ref == cancel_orders.get("customerRef")
assert resource.error_code == cancel_orders.get("errorCode")
assert len(resource.cancel_instruction_reports) == len(
cancel_orders.get("instructionReports"))
for order in cancel_orders.get("instructionReports"):
assert (resource.cancel_instruction_reports[0].size_cancelled ==
order["sizeCancelled"])
assert resource.cancel_instruction_reports[0].status == order[
"status"]
assert resource.cancel_instruction_reports[
0].cancelled_date == datetime.datetime.strptime(
order["cancelledDate"], BETFAIR_DATE_FORMAT)
assert (resource.cancel_instruction_reports[0].instruction.bet_id
== order["instruction"]["betId"])
assert resource.cancel_instruction_reports[
0].instruction.size_reduction == order["instruction"].get(
"sizeReduction")
def test_process(self, mock_on_process, mock_cache):
sub_image = create_mock_json(
"tests/resources/streaming_ocm_FULL_IMAGE.json")
data = sub_image.json()["oc"]
self.stream._process(data, 123)
self.assertEqual(len(self.stream), len(data))
def test_market_catalogue_no_ero_data(self):
mock_response = create_mock_json(
'tests/resources/list_market_catalogue_no_ero.json')
market_catalogues = mock_response.json().get('result')
for market_catalogue in market_catalogues:
resources.MarketCatalogue(elapsed_time=self.ELAPSED_TIME,
**market_catalogue)
def test_request(self, mock_get, mock_request_headers, mock_cert):
mock_response = create_mock_json('tests/resources/login_success.json')
mock_get.return_value = mock_response
url = 'https://api.betfair.com/exchange/betting/rest/v1/en/navigation/menu.json'
self.navigation.request()
mock_get.assert_called_once_with(url, headers=mock_request_headers, timeout=(3.05, 16))
def test_process_no_market_definition(self, mock_on_process, mock_cache):
sub_image_error = create_mock_json(
"tests/resources/streaming_mcm_SUB_IMAGE_no_market_def.json")
data = sub_image_error.json()["mc"]
self.assertTrue(self.stream._process(data, 123))
self.assertEqual(len(data), 137)
self.assertEqual(len(self.stream),
135) # two markets missing marketDef
def test_update_cache_closed(self):
mock_response = create_mock_json(
"tests/resources/streaming_ocm_SUB_IMAGE.json")
for order_book in mock_response.json().get("oc"):
self.order_book_cache.update_cache(order_book, 1234)
self.assertEqual(self.order_book_cache.streaming_update,
order_book)
self.assertTrue(self.order_book_cache.closed)
def test_call(self, mock_response):
mock_json = create_mock_json(
"tests/resources/login_interactive_success.json")
mock_response.return_value = (mock.Mock(), mock_json.json(), 1.3)
response = self.login()
assert isinstance(response, LoginResource)
assert self.login.client.session_token == mock_json.json().get("token")
def test_update_cache_new(self, mock_order_book_runner):
self.runner.selection_id = 108956
mock_response = create_mock_json('tests/resources/streaming_ocm_UPDATE.json')
for order_book in mock_response.json().get('oc'):
self.order_book_cache.update_cache(order_book, 1234)
for order_changes in order_book.get('orc'):
mock_order_book_runner.assert_called_with(**order_changes)
def test_request(self, mock_post, mock_logout_headers):
mock_response = create_mock_json('tests/resources/logout_success.json')
mock_post.return_value = mock_response
url = 'https://identitysso.betfair.com/api/logout'
response = self.logout.request()
mock_post.assert_called_once_with(url, headers=mock_logout_headers)
assert response[0] == mock_response.json()
def test_process_no_img(self, mock_on_process, mock_cache):
sub_image = create_mock_json("tests/resources/streaming_mcm_SUB_IMAGE.json")
data = sub_image.json()["mc"]
data[0]["img"] = False
mock_market_cache = mock_cache()
self.stream._caches = {data[0]["id"]: mock_market_cache}
self.assertFalse(self.stream._process(data, 123))
self.assertEqual(len(self.stream), len(data))
mock_market_cache.update_cache.assert_called_with(data[0], 123)
def test_update_cache_new(self, mock_order_book_runner):
self.order_book_cache.runners = {(108956, 0): self.runner}
mock_response = create_mock_json("tests/resources/streaming_ocm_UPDATE.json")
for order_book in mock_response.json().get("oc"):
self.order_book_cache.update_cache(order_book, 1234)
self.assertEqual(self.order_book_cache.streaming_update, order_book)
for order_changes in order_book.get("orc"):
mock_order_book_runner.assert_called_with(**order_changes)
def test_update_cache_tv(self, mock_strip_datetime):
publish_time = mock.Mock()
market_change = create_mock_json('tests/resources/streaming_mcm_UPDATE_tv.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)
assert self.market_book_cache.total_matched == book.get('tv')
def test_update_cache(self):
mock_response = create_mock_json('tests/resources/streaming_ocm_UPDATE.json')
for order_book in mock_response.json().get('oc'):
self.order_book_cache.update_cache(order_book, 1234)
for order_changes in order_book.get('orc'):
# self.runner.matched_lays.update.assert_called_with(order_changes.get('ml', []))
# self.runner.matched_backs.update.assert_called_with(order_book.get('mb', []))
self.runner.update_unmatched.assert_called_with(order_changes.get('uo', []))
def test_request(self, mock_post, mock_keep_alive_headers):
mock_response = create_mock_json("tests/resources/logout_success.json")
mock_post.return_value = mock_response
url = "https://identitysso.betfair.com/api/keepAlive"
response = self.keep_alive.request()
mock_post.assert_called_once_with(url, headers=mock_keep_alive_headers)
assert response[1] == mock_response.json()
def test_list_available_events(self, mock_response):
mock = create_mock_json("tests/resources/availableevents.json")
mock_response.return_value = (mock.Mock(), mock.json(), 1.3)
response = self.scores.list_available_events()
assert mock.json.call_count == 1
mock_response.assert_called_with(
"ScoresAPING/v1.0/listAvailableEvents", {}, None)
assert all(
isinstance(event, resources.AvailableEvent) for event in response)
