class TestInstrumentsAPI(unittest.TestCase):
def setUp(self):
with mock.patch.object(Client, 'get_credentials', return_value=True):
self.client = Client(
("http://mydomain.com", "http://mystreamingdomain.com"),
"my_account",
"my_token"
)
def test_get_instruments_pass(self):
with mock.patch.object(
Client, '_Client__call',
return_value={"message": "good one"}
):
assert self.client.get_instruments()
def test_get_prices(self):
with mock.patch.object(
Client, '_Client__call',
return_value={"message": "good one"}
):
assert self.client.get_prices(instruments="EUR_GBP", stream=False)
def test_get_instrument_history(self):
with mock.patch.object(
Client, '_Client__call',
return_value=[{}]
):
assert self.client.get_instrument_history('EUR_GBP')
def setUp(self):
with mock.patch.object(Client, 'get_credentials', return_value=True):
self.client = Client(
("http://mydomain.com", "http://mystreamingdomain.com"),
"my_account",
"my_token"
)
def test_custom_json_options(self, m):
with mock.patch.object(Client, 'get_credentials', return_value=True):
c = Client(("http://mydomain.com", "http://mystreamingdomain.com"),
"my_account", "my_token")
c.json_options['parse_float'] = Decimal
m.get(requests_mock.ANY, text=json.dumps({'float': 1.01}))
r = c._Client__call('http://www.example.com/')
assert isinstance(r['float'], Decimal)
class TestTradeAPI(unittest.TestCase):
def setUp(self):
with mock.patch.object(Client, 'get_credentials', return_value=True):
self.client = Client(
("http://mydomain.com", "http://mystreamingdomain.com"),
"my_account",
"my_token"
)
def test_get_trades(self):
with mock.patch.object(Client, '_Client__call', return_value=True):
assert self.client.get_trades()
def test_get_trade(self):
with mock.patch.object(Client, '_Client__call', return_value=True):
assert self.client.get_trade(1)
assert self.client.get_trade(trade_id=1)
def test_update_trade(self):
with mock.patch.object(Client, '_Client__call', return_value=True):
assert self.client.update_trade(1)
assert self.client.update_trade(1, 0)
assert self.client.update_trade(1, 1)
assert self.client.update_trade(1, None, 0)
assert self.client.update_trade(1, None, 1)
assert self.client.update_trade(1, None, None, 0)
assert self.client.update_trade(1, None, None, 1)
def test_close_trade(self):
with mock.patch.object(Client, '_Client__call', return_value=True):
assert self.client.close_trade(1)
assert self.client.close_trade(trade_id=1)
def setUp(self):
with mock.patch.object(Client, 'get_credentials', return_value=True):
self.client = Client(
("http://mydomain.com", "http://mystreamingdomain.com"),
"my_account",
"my_token"
)
class TestPositionAPI(unittest.TestCase):
def setUp(self):
with mock.patch.object(Client, 'get_credentials', return_value=True):
self.client = Client(
("http://mydomain.com", "http://mystreamingdomain.com"),
"my_account", "my_token")
def test_get_positions(self):
with mock.patch.object(Client, '_Client__call', return_value=True):
assert self.client.get_positions()
def test_get_position(self):
with mock.patch.object(Client, '_Client__call', return_value=True):
assert self.client.get_position('AUD_USD')
assert self.client.get_position(instrument='AUD_USD')
def test_close_position(self):
with mock.patch.object(Client, '_Client__call', return_value=True):
assert self.client.close_position('AUD_USD')
assert self.client.close_position(instrument='AUD_USD')
def test_call_stream_fail(self, m):
"""Ensure that failure HTTP streaming response codes fail."""
with mock.patch.object(Client, 'get_credentials', return_value=True):
c = Client(("http://mydomain.com", "http://mystreamingdomain.com"),
"my_account", "my_token")
c.session = requests.Session()
status_codes = [400, 401, 403, 404, 500]
caught = 0
for status_code in status_codes:
m.get(requests_mock.ANY,
text=json.dumps({'message': 'test'}),
status_code=400)
try:
c._Client__call_stream(uri="http://example.com",
params={"test": "test"},
method="get")
except BadRequest:
caught += 1
self.assertEqual(len(status_codes), caught)
class TestAccountAPI(unittest.TestCase):
def setUp(self):
with mock.patch.object(Client, 'get_credentials', return_value=True):
self.client = Client(
("http://mydomain.com", "http://mystreamingdomain.com"),
"my_account",
"my_token"
)
def test_create_account(self):
with mock.patch.object(Client, '_Client__call', return_value=True):
assert self.client.create_account()
def test_create_account_with_currency(self):
with mock.patch.object(Client, '_Client__call', return_value=True):
assert self.client.create_account('AUD')
assert self.client.create_account(currency='AUD')
def test_get_accounts(self):
with mock.patch.object(Client, '_Client__call', return_value=True):
assert self.client.get_accounts()
def test_get_accounts_with_username(self):
with mock.patch.object(Client, '_Client__call', return_value=True):
assert self.client.get_accounts('bob')
assert self.client.get_accounts(username='******')
class TestPositionAPI(unittest.TestCase):
def setUp(self):
with mock.patch.object(Client, 'get_credentials', return_value=True):
self.client = Client(
("http://mydomain.com", "http://mystreamingdomain.com"),
"my_account",
"my_token"
)
def test_get_positions(self):
with mock.patch.object(Client, '_Client__call', return_value=True):
assert self.client.get_positions()
def test_get_position(self):
with mock.patch.object(Client, '_Client__call', return_value=True):
assert self.client.get_position('AUD_USD')
assert self.client.get_position(instrument='AUD_USD')
def test_close_position(self):
with mock.patch.object(Client, '_Client__call', return_value=True):
assert self.client.close_position('AUD_USD')
assert self.client.close_position(instrument='AUD_USD')
class TestInstrumentsAPI(unittest.TestCase):
def setUp(self):
with mock.patch.object(Client, 'get_credentials', return_value=True):
self.client = Client(
("http://mydomain.com", "http://mystreamingdomain.com"),
"my_account", "my_token")
def test_get_instruments_pass(self):
with mock.patch.object(Client,
'_Client__call',
return_value={"message": "good one"}):
assert self.client.get_instruments()
def test_get_prices(self):
with mock.patch.object(Client,
'_Client__call',
return_value={"message": "good one"}):
assert self.client.get_prices(instruments="EUR_GBP", stream=False)
def test_get_instrument_history(self):
with mock.patch.object(Client, '_Client__call', return_value=[{}]):
assert self.client.get_instrument_history('EUR_GBP')
class TestOrdersAPI(unittest.TestCase):
def setUp(self):
with mock.patch.object(Client, 'get_credentials', return_value=True):
self.client = Client(
("http://mydomain.com", "http://mystreamingdomain.com"),
"my_account",
"my_token"
)
def test_credentials_pass(self):
with mock.patch.object(
Client, '_Client__call',
return_value={"message": "good one"}
):
assert self.client.get_credentials()
def test_credentials_fail(self):
with mock.patch.object(Client, '_Client__call', return_value=()):
assert not self.client.get_credentials()
e = RequestException("I fail")
with mock.patch.object(Client, '_Client__call', side_effect=e):
assert not self.client.get_credentials()
def test_get_orders(self):
with mock.patch.object(Client, '_Client__call', return_value=True):
assert self.client.get_orders()
def test_get_order(self):
with mock.patch.object(Client, '_Client__call', return_value=True):
assert self.client.get_order(1)
def test_create_order(self):
order = Order(instrument="GBP_EUR", units=1, side="buy", type="market")
with mock.patch.object(Client, '_Client__call', return_value=True):
assert self.client.create_order(order)
def test_update_order(self):
order = Order(instrument="GBP_EUR", units=1, side="buy", type="market")
with mock.patch.object(Client, '_Client__call', return_value=True):
assert self.client.update_order(1, order)
def test_close_order(self):
with mock.patch.object(Client, '_Client__call', return_value=True):
assert self.client.close_order(1)
class IntegrationTestCase(unittest.TestCase):
# Keep this as it will be share between all tests cases, prevent to over
# use as this literaly creates new users (I expext the use to be wipeout)
client = Client(SANDBOX)
user = client.create_account(currency="GBP")
client.account_id = user['accountId']
def build_order(self, immediate=False):
""" Build an order to be used with create_order.
Building an order is commonly required in the integration
tests, so this makes it easy.
Parameters
----------
immediate: bool
Whether to place an order that will be met immediately
or not; this is achieved by examining current prices and
bidding well below for non-immediate or by placing a
market order for immediate.
Returns an Order
"""
if immediate:
return Order(
instrument="GBP_USD",
units=1,
side="buy",
type="market"
)
expiry = datetime.utcnow() + timedelta(minutes=1)
prices = self.client.get_prices("GBP_USD", False)
price = prices['prices'][0]
at = round(price['bid'] * 0.9, 5)
# order must not be met straight away, otherwise we can't get it back
return Order(
instrument="GBP_USD",
units=1,
side="buy",
type="limit",
price=at,
expiry=expiry.isoformat()
)
class TestOrdersAPI(unittest.TestCase):
def setUp(self):
with mock.patch.object(Client, 'get_credentials', return_value=True):
self.client = Client(
("http://mydomain.com", "http://mystreamingdomain.com"),
"my_account", "my_token")
def test_credentials_pass(self):
with mock.patch.object(Client,
'_Client__call',
return_value={"message": "good one"}):
assert self.client.get_credentials()
def test_credentials_fail(self):
with mock.patch.object(Client, '_Client__call', return_value=()):
assert not self.client.get_credentials()
e = RequestException("I fail")
with mock.patch.object(Client, '_Client__call', side_effect=e):
assert not self.client.get_credentials()
def test_get_orders(self):
with mock.patch.object(Client, '_Client__call', return_value=True):
assert self.client.get_orders()
def test_get_order(self):
with mock.patch.object(Client, '_Client__call', return_value=True):
assert self.client.get_order(1)
def test_create_order(self):
order = Order(instrument="GBP_EUR", units=1, side="buy", type="market")
with mock.patch.object(Client, '_Client__call', return_value=True):
assert self.client.create_order(order)
def test_update_order(self):
order = Order(instrument="GBP_EUR", units=1, side="buy", type="market")
with mock.patch.object(Client, '_Client__call', return_value=True):
assert self.client.update_order(1, order)
def test_close_order(self):
with mock.patch.object(Client, '_Client__call', return_value=True):
assert self.client.close_order(1)
def test_call_stream_pass(self, m):
"""Ensure that successful HTTP streaming response codes pass."""
with mock.patch.object(Client, 'get_credentials', return_value=True):
c = Client(("http://mydomain.com", "http://mystreamingdomain.com"),
"my_account", "my_token")
c.session = requests.Session()
for status_code in [200, 201, 202, 301, 302]:
m.get(requests_mock.ANY, status_code=status_code)
c._Client__call_stream(uri="http://example.com",
params={"test": "test"},
method="get")
m.post(requests_mock.ANY, status_code=status_code)
c._Client__call_stream(uri="http://example.com",
params={"test": "test"},
method="post")
class TestAccountAPI(unittest.TestCase):
def setUp(self):
with mock.patch.object(Client, 'get_credentials', return_value=True):
self.client = Client(
("http://mydomain.com", "http://mystreamingdomain.com"),
"my_account", "my_token")
def test_create_account(self):
with mock.patch.object(Client, '_Client__call', return_value=True):
assert self.client.create_account()
def test_create_account_with_currency(self):
with mock.patch.object(Client, '_Client__call', return_value=True):
assert self.client.create_account('AUD')
assert self.client.create_account(currency='AUD')
def test_get_accounts(self):
with mock.patch.object(Client, '_Client__call', return_value=True):
assert self.client.get_accounts()
def test_get_accounts_with_username(self):
with mock.patch.object(Client, '_Client__call', return_value=True):
assert self.client.get_accounts('bob')
assert self.client.get_accounts(username='******')
class TestTransactionAPI(unittest.TestCase):
def setUp(self):
with mock.patch.object(Client, 'get_credentials', return_value=True):
self.client = Client(
("http://mydomain.com", "http://mystreamingdomain.com"),
"my_account",
"my_token"
)
def test_get_transactions(self):
with mock.patch.object(Client, '_Client__call', return_value=True):
assert self.client.get_transactions()
def test_get_transaction(self):
with mock.patch.object(Client, '_Client__call', return_value=True):
assert self.client.get_transaction(1)
@requests_mock.Mocker()
def test_request_transaction_history(self, m):
location = 'http://example.com/transactions.json.gz'
m.get(
requests_mock.ANY,
headers={'Location': location}, status_code=202
)
self.assertEqual(location, self.client.request_transaction_history())
@requests_mock.Mocker()
def test_get_transaction_history(self, m):
# Mock zip file content
content = BytesIO()
with ZipFile(content, 'w') as zip:
zip.writestr('transactions.json', json.dumps({'ok': True}))
content.seek(0)
# Mock requests, one HEAD to check if it's there, one GET once it is
location = 'http://example.com/transactions.json.gz'
m.head(location, status_code=200)
m.get(location, body=content, status_code=200)
method = 'request_transaction_history'
with mock.patch.object(Client, method, return_value=location):
transactions = self.client.get_transaction_history()
assert transactions['ok']
assert m.call_count == 2
@requests_mock.Mocker()
def test_get_transaction_history_slow(self, m):
"""Ensures that get_transaction_history retries requests."""
# Mock zip file content
content = BytesIO()
with ZipFile(content, 'w') as zip:
zip.writestr('transactions.json', json.dumps({'ok': True}))
content.seek(0)
# Mock requests, one HEAD to check if it's there, one GET once it is
location = 'http://example.com/transactions.json.gz'
m.head(location, [{'status_code': 404}, {'status_code': 200}])
m.get(location, body=content, status_code=200)
method = 'request_transaction_history'
with mock.patch.object(Client, method, return_value=location):
transactions = self.client.get_transaction_history()
assert transactions['ok']
assert m.call_count == 3
@requests_mock.Mocker()
def test_get_transaction_history_gives_up(self, m):
"""Ensures that get_transaction_history eventually gives up."""
# Mock requests, one HEAD to check if it's there, one GET once it is
location = 'http://example.com/transactions.json.gz'
m.head(location, [{'status_code': 404}, {'status_code': 404}])
method = 'request_transaction_history'
with mock.patch.object(Client, method, return_value=location):
transactions = self.client.get_transaction_history(.3)
assert not transactions
# Possible timing issue, may be one or the other
assert m.call_count == 2 or m.call_count == 3
@requests_mock.Mocker()
def test_get_transaction_history_handles_bad_files(self, m):
"""Ensures that get_transaction_history gracefully handles bad files.
"""
# Mock requests, one HEAD to check if it's there, one GET once it is
location = 'http://example.com/transactions.json.gz'
m.head(location, status_code=200)
m.get(location, text='invalid', status_code=200)
method = 'request_transaction_history'
with mock.patch.object(Client, method, return_value=location):
transactions = self.client.get_transaction_history()
assert not transactions
def test_connect_fail(self):
with mock.patch.object(Client, 'get_credentials', return_value=False):
with self.assertRaises(BadCredentials):
Client(("http://mydomain.com", "http://mystreamingdomain.com"),
"my_account", "my_token")
def test_connect_pass(self):
with mock.patch.object(Client, 'get_credentials', return_value=True):
Client(("http://mydomain.com", "http://mystreamingdomain.com"),
"my_account", "my_token")
class TestTransactionAPI(unittest.TestCase):
def setUp(self):
with mock.patch.object(Client, 'get_credentials', return_value=True):
self.client = Client(
("http://mydomain.com", "http://mystreamingdomain.com"),
"my_account", "my_token")
def test_get_transactions(self):
with mock.patch.object(Client, '_Client__call', return_value=True):
assert self.client.get_transactions()
def test_get_transaction(self):
with mock.patch.object(Client, '_Client__call', return_value=True):
assert self.client.get_transaction(1)
@requests_mock.Mocker()
def test_request_transaction_history(self, m):
location = 'http://example.com/transactions.json.gz'
m.get(requests_mock.ANY,
headers={'Location': location},
status_code=202)
self.assertEqual(location, self.client.request_transaction_history())
@requests_mock.Mocker()
def test_get_transaction_history(self, m):
# Mock zip file content
content = BytesIO()
with ZipFile(content, 'w') as zip:
zip.writestr('transactions.json', json.dumps({'ok': True}))
content.seek(0)
# Mock requests, one HEAD to check if it's there, one GET once it is
location = 'http://example.com/transactions.json.gz'
m.head(location, status_code=200)
m.get(location, body=content, status_code=200)
method = 'request_transaction_history'
with mock.patch.object(Client, method, return_value=location):
transactions = self.client.get_transaction_history()
assert transactions['ok']
assert m.call_count == 2
@requests_mock.Mocker()
def test_get_transaction_history_slow(self, m):
"""Ensures that get_transaction_history retries requests."""
# Mock zip file content
content = BytesIO()
with ZipFile(content, 'w') as zip:
zip.writestr('transactions.json', json.dumps({'ok': True}))
content.seek(0)
# Mock requests, one HEAD to check if it's there, one GET once it is
location = 'http://example.com/transactions.json.gz'
m.head(location, [{'status_code': 404}, {'status_code': 200}])
m.get(location, body=content, status_code=200)
method = 'request_transaction_history'
with mock.patch.object(Client, method, return_value=location):
transactions = self.client.get_transaction_history()
assert transactions['ok']
assert m.call_count == 3
@requests_mock.Mocker()
def test_get_transaction_history_gives_up(self, m):
"""Ensures that get_transaction_history eventually gives up."""
# Mock requests, one HEAD to check if it's there, one GET once it is
location = 'http://example.com/transactions.json.gz'
m.head(location, [{'status_code': 404}, {'status_code': 404}])
method = 'request_transaction_history'
with mock.patch.object(Client, method, return_value=location):
transactions = self.client.get_transaction_history(.3)
assert not transactions
# Possible timing issue, may be one or the other
assert m.call_count == 2 or m.call_count == 3
@requests_mock.Mocker()
def test_get_transaction_history_handles_bad_files(self, m):
"""Ensures that get_transaction_history gracefully handles bad files.
"""
# Mock requests, one HEAD to check if it's there, one GET once it is
location = 'http://example.com/transactions.json.gz'
m.head(location, status_code=200)
m.get(location, text='invalid', status_code=200)
method = 'request_transaction_history'
with mock.patch.object(Client, method, return_value=location):
transactions = self.client.get_transaction_history()
assert not transactions
def test_connect_fail(self):
with self.assertRaises(BadRequest):
Client(SANDBOX, 999999999)
