class BaseEndPointTest(unittest.TestCase):
def setUp(self):
client = APIClient('username', 'password', 'app_key', 'UK')
self.base_endpoint = BaseEndpoint(client)
def test_base_endpoint_create_req(self):
payload = {'jsonrpc': '2.0',
'method': 'test',
'params': 'empty',
'id': 1}
assert self.base_endpoint.create_req('test', 'empty') == json.dumps(payload)
@mock.patch('betfairlightweight.endpoints.baseendpoint.BaseEndpoint.create_req')
@mock.patch('betfairlightweight.baseclient.BaseClient.cert')
@mock.patch('betfairlightweight.baseclient.BaseClient.request_headers')
@mock.patch('betfairlightweight.baseclient.requests.post')
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 == mock_response
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_base_endpoint_process_response(self):
mock_resource = mock.Mock()
response_list = [{}, {}]
response = self.base_endpoint.process_response(response_list, mock_resource, None)
assert type(response) == list
assert response[0] == mock_resource()
response_result_list = {'result': [{}, {}]}
response = self.base_endpoint.process_response(response_result_list, mock_resource, None)
assert type(response) == list
assert response[0] == mock_resource()
response_result = {'result': {}}
response = self.base_endpoint.process_response(response_result, mock_resource, None)
assert response == mock_resource()
def test_base_endpoint_url(self):
assert self.base_endpoint.url == '%s%s' % (self.base_endpoint.client.api_uri, 'betting/json-rpc/v1')
def test_base_endpoint_process_response(self):
mock_resource = mock.Mock()
response_list = [{}, {}]
response = self.base_endpoint.process_response(response_list, mock_resource, None, False)
assert type(response) == list
assert response[0] == mock_resource()
response_result_list = {'result': [{}, {}]}
response = self.base_endpoint.process_response(response_result_list, mock_resource, None, False)
assert type(response) == list
assert response[0] == mock_resource()
response_result = {'result': {}}
response = self.base_endpoint.process_response(response_result, mock_resource, None, False)
assert response == mock_resource()
# lightweight tests
response_list = [{}, {}]
response = self.base_endpoint.process_response(response_list, mock_resource, None, True)
assert response == response_list
client = APIClient('username', 'password', 'app_key', lightweight=True)
base_endpoint = BaseEndpoint(client)
response_list = [{}, {}]
response = base_endpoint.process_response(response_list, mock_resource, None, False)
assert type(response) == list
assert response[0] == mock_resource()
class BaseEndPointTest(unittest.TestCase):
def setUp(self):
client = APIClient('username', 'password', 'app_key', 'UK')
self.base_endpoint = BaseEndpoint(client)
def test_base_endpoint_create_req(self):
payload = {
'jsonrpc': '2.0',
'method': 'test',
'params': 'empty',
'id': 1
}
assert self.base_endpoint.create_req('test',
'empty') == json.dumps(payload)
@mock.patch(
'betfairlightweight.endpoints.baseendpoint.BaseEndpoint.create_req')
@mock.patch('betfairlightweight.baseclient.BaseClient.cert')
@mock.patch('betfairlightweight.baseclient.BaseClient.request_headers')
@mock.patch('betfairlightweight.baseclient.requests.post')
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 == mock_response
@mock.patch(
'betfairlightweight.endpoints.baseendpoint.BaseEndpoint.create_req')
@mock.patch('betfairlightweight.baseclient.BaseClient.cert')
@mock.patch('betfairlightweight.baseclient.BaseClient.request_headers')
@mock.patch('betfairlightweight.baseclient.requests.post')
def test_request_error(self, mock_post, mock_request_headers, mock_cert,
mock_create_req):
mock_post.side_effect = ConnectionError()
with self.assertRaises(APIError):
self.base_endpoint.request(None, None, None)
mock_post.side_effect = ValueError()
with self.assertRaises(APIError):
self.base_endpoint.request(None, None, None)
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_base_endpoint_process_response(self):
mock_resource = mock.Mock()
response_list = [{}, {}]
response = self.base_endpoint.process_response(response_list,
mock_resource, None)
assert type(response) == list
assert response[0] == mock_resource()
response_result_list = {'result': [{}, {}]}
response = self.base_endpoint.process_response(response_result_list,
mock_resource, None)
assert type(response) == list
assert response[0] == mock_resource()
response_result = {'result': {}}
response = self.base_endpoint.process_response(response_result,
mock_resource, None)
assert response == mock_resource()
def test_base_endpoint_url(self):
assert self.base_endpoint.url == '%s%s' % (
self.base_endpoint.client.api_uri, 'betting/json-rpc/v1')
class BaseEndPointTest(unittest.TestCase):
def setUp(self):
client = APIClient('username', 'password', 'app_key', 'UK')
self.base_endpoint = BaseEndpoint(client)
def test_base_endpoint_create_req(self):
payload = {'jsonrpc': '2.0',
'method': 'test',
'params': 'empty',
'id': 1}
assert self.base_endpoint.create_req('test', 'empty') == json.dumps(payload)
@mock.patch('betfairlightweight.endpoints.baseendpoint.BaseEndpoint.create_req')
@mock.patch('betfairlightweight.baseclient.BaseClient.cert')
@mock.patch('betfairlightweight.baseclient.BaseClient.request_headers')
@mock.patch('betfairlightweight.baseclient.requests.post')
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)
@mock.patch('betfairlightweight.endpoints.baseendpoint.BaseEndpoint.create_req')
@mock.patch('betfairlightweight.baseclient.BaseClient.cert')
@mock.patch('betfairlightweight.baseclient.BaseClient.request_headers')
@mock.patch('betfairlightweight.baseclient.requests.post')
def test_request_error(self, mock_post, mock_request_headers, mock_cert, mock_create_req):
mock_post.side_effect = ConnectionError()
with self.assertRaises(APIError):
self.base_endpoint.request(None, None, None)
mock_post.side_effect = ValueError()
with self.assertRaises(APIError):
self.base_endpoint.request(None, None, None)
@mock.patch('betfairlightweight.endpoints.baseendpoint.BaseEndpoint.create_req')
@mock.patch('betfairlightweight.baseclient.BaseClient.cert')
@mock.patch('betfairlightweight.baseclient.BaseClient.request_headers')
@mock.patch('betfairlightweight.baseclient.requests.post')
def test_request_json_error(self, mock_post, mock_request_headers, mock_cert, mock_create_req):
mock_response = mock.Mock()
mock_response.status_code = 200
mock_response.json.side_effect = ValueError()
mock_post.return_value = mock_response
with self.assertRaises(InvalidResponse):
self.base_endpoint.request(None, None, None)
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_base_endpoint_process_response(self):
mock_resource = mock.Mock()
response_list = [{}, {}]
response = self.base_endpoint.process_response(response_list, mock_resource, None, False)
assert type(response) == list
assert response[0] == mock_resource()
response_result_list = {'result': [{}, {}]}
response = self.base_endpoint.process_response(response_result_list, mock_resource, None, False)
assert type(response) == list
assert response[0] == mock_resource()
response_result = {'result': {}}
response = self.base_endpoint.process_response(response_result, mock_resource, None, False)
assert response == mock_resource()
# lightweight tests
response_list = [{}, {}]
response = self.base_endpoint.process_response(response_list, mock_resource, None, True)
assert response == response_list
client = APIClient('username', 'password', 'app_key', lightweight=True)
base_endpoint = BaseEndpoint(client)
response_list = [{}, {}]
response = base_endpoint.process_response(response_list, mock_resource, None, False)
assert type(response) == list
assert response[0] == mock_resource()
def test_base_endpoint_process_response_no_error(self):
class MockResource(object):
def __init__(self, elapsed_time, hello):
self.elapsed_time = elapsed_time
self.hello = hello
mock_resource = MockResource
response_list = [{'hello': 'world'}]
response = self.base_endpoint.process_response(response_list, mock_resource, 0, False)
assert type(response) == list
assert response[0].__dict__ == mock_resource(elapsed_time=0, **response_list[0]).__dict__
def test_base_endpoint_process_response_error(self):
class MockResource(object):
def __init__(self, elapsed_time, hello):
self.elapsed_time = elapsed_time
self.hello = hello
mock_resource = MockResource
response_list = [{}] # missing 'hello'
with self.assertRaises(InvalidResponse):
self.base_endpoint.process_response(response_list, mock_resource, 0, False)
def test_base_endpoint_url(self):
assert self.base_endpoint.url == '%s%s' % (self.base_endpoint.client.api_uri, 'betting/json-rpc/v1')
class BaseEndPointTest(unittest.TestCase):
def setUp(self):
client = APIClient("username", "password", "app_key", "UK")
self.base_endpoint = BaseEndpoint(client)
def test_base_endpoint_create_req(self):
payload = {
"jsonrpc": "2.0",
"method": "test",
"params": "empty",
"id": 1
}
assert self.base_endpoint.create_req("test",
"empty") == json.dumps(payload)
@mock.patch(
"betfairlightweight.endpoints.baseendpoint.BaseEndpoint.create_req")
@mock.patch("betfairlightweight.baseclient.BaseClient.cert")
@mock.patch("betfairlightweight.baseclient.BaseClient.request_headers")
@mock.patch("betfairlightweight.baseclient.requests.post")
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[1] == mock_response.json()
assert isinstance(response[2], float)
@mock.patch(
"betfairlightweight.endpoints.baseendpoint.BaseEndpoint.create_req")
@mock.patch("betfairlightweight.baseclient.BaseClient.cert")
@mock.patch("betfairlightweight.baseclient.BaseClient.request_headers")
@mock.patch("betfairlightweight.baseclient.requests.post")
def test_request_error(self, mock_post, mock_request_headers, mock_cert,
mock_create_req):
mock_post.side_effect = ConnectionError()
with self.assertRaises(APIError):
self.base_endpoint.request(None, None, None)
mock_post.side_effect = ValueError()
with self.assertRaises(APIError):
self.base_endpoint.request(None, None, None)
@mock.patch("betfairlightweight.endpoints.baseendpoint.json.loads",
side_effect=ValueError)
@mock.patch(
"betfairlightweight.endpoints.baseendpoint.BaseEndpoint.create_req")
@mock.patch("betfairlightweight.baseclient.BaseClient.cert")
@mock.patch("betfairlightweight.baseclient.BaseClient.request_headers")
@mock.patch("betfairlightweight.baseclient.requests.post")
def test_request_json_error(
self,
mock_post,
mock_request_headers,
mock_cert,
mock_create_req,
mock_json_loads,
):
mock_response = mock.Mock()
mock_response.status_code = 200
mock_post.return_value = mock_response
with self.assertRaises(InvalidResponse):
self.base_endpoint.request(None, None, None)
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_base_endpoint_process_response(self):
mock_resource = mock.Mock()
response_list = [{}, {}]
response = self.base_endpoint.process_response(response_list,
mock_resource, None,
False)
assert type(response) == list
assert response[0] == mock_resource()
response_result_list = {"result": [{}, {}]}
response = self.base_endpoint.process_response(response_result_list,
mock_resource, None,
False)
assert type(response) == list
assert response[0] == mock_resource()
response_result = {"result": {}}
response = self.base_endpoint.process_response(response_result,
mock_resource, None,
False)
assert response == mock_resource()
# lightweight tests
response_list = [{}, {}]
response = self.base_endpoint.process_response(response_list,
mock_resource, None,
True)
assert response == response_list
client = APIClient("username", "password", "app_key", lightweight=True)
base_endpoint = BaseEndpoint(client)
response_list = [{}, {}]
response = base_endpoint.process_response(response_list, mock_resource,
None, False)
assert type(response) == list
assert response[0] == mock_resource()
def test_base_endpoint_process_response_no_error(self):
class MockResource:
def __init__(self, elapsed_time, hello, **kwargs):
self.elapsed_time = elapsed_time
self.hello = hello
mock_resource = MockResource
response_list = [{"hello": "world"}]
response = self.base_endpoint.process_response(response_list,
mock_resource, 0, False)
assert type(response) == list
assert (response[0].__dict__ == mock_resource(
elapsed_time=0, **response_list[0]).__dict__)
def test_base_endpoint_process_response_error(self):
class MockResource:
def __init__(self, elapsed_time, hello):
self.elapsed_time = elapsed_time
self.hello = hello
mock_resource = MockResource
response_list = [{}] # missing 'hello'
with self.assertRaises(InvalidResponse):
self.base_endpoint.process_response(response_list, mock_resource,
0, False)
def test_base_endpoint_url(self):
assert self.base_endpoint.url == "%s%s" % (
self.base_endpoint.client.api_uri,
"betting/json-rpc/v1",
)