def test__fetch_token(self):
self.context.get_property = MagicMock(side_effect=('p1', 'p2', 'p3',
'p4', None, None))
self.context.requests_get = MagicMock(
return_value=CryptowelderContext._parse("""
{"access_token":"00000000-0000-0000-0000-000000000000"}
"""))
self.assertEqual('00000000-0000-0000-0000-000000000000',
self.target._fetch_token())
self.assertEqual(1, self.context.requests_get.call_count)
# Cached
self.assertEqual('00000000-0000-0000-0000-000000000000',
self.target._fetch_token())
self.assertEqual('00000000-0000-0000-0000-000000000000',
self.target._fetch_token())
self.assertEqual(1, self.context.requests_get.call_count)
# Force Refresh
self.assertEqual('00000000-0000-0000-0000-000000000000',
self.target._fetch_token(force=True))
self.assertEqual(2, self.context.requests_get.call_count)
# No key
self.assertIsNone(self.target._fetch_token(force=True))
self.assertEqual(2, self.context.requests_get.call_count)
def test__process_margin(self):
now = datetime.fromtimestamp(1234567890.123456, utc)
self.context.get_now = MagicMock(return_value=now)
self.context.save_balances = MagicMock()
self.target._query_private = MagicMock(return_value=CryptowelderContext._parse("""
{
"success": true,
"margin": {
"foo": "123456.78901234",
"jpy": "131767.22675655"
},
"margin_available": {
"jpy": "116995.98446494"
},
"margin_level": "8.36743"
}
"""))
self.target._process_margin()
balances = self.context.save_balances.call_args[0][0]
self.assertEqual(1, len(balances))
self.assertEqual('coincheck', balances[0].bc_site)
self.assertEqual('MARGIN', balances[0].bc_acct.name)
self.assertEqual('JPY', balances[0].bc_unit.name)
self.assertEqual('2009-02-13 23:31:30.123456 UTC', balances[0].bc_time.strftime(self.FORMAT))
self.assertEqual(Decimal('131767.22675655'), balances[0].bc_amnt)
# Query Reject
self.target._query_private.reset_mock()
self.target._query_private.return_value = {'success': False}
self.context.save_balances.reset_mock()
self.target._process_margin()
self.target._query_private.assert_called_once()
self.context.save_balances.assert_not_called()
# Query Empty
self.target._query_private.reset_mock()
self.target._query_private.return_value = {}
self.context.save_balances.reset_mock()
self.target._process_margin()
self.target._query_private.assert_called_once()
self.context.save_balances.assert_called_once()
# Query None
self.target._query_private.reset_mock()
self.target._query_private.return_value = None
self.context.save_balances.reset_mock()
self.target._process_margin()
self.target._query_private.assert_called_once()
self.context.save_balances.assert_not_called()
# Query Failure
self.target._query_private.reset_mock()
self.target._query_private.side_effect = Exception('test')
self.context.save_balances.reset_mock()
self.target._process_margin()
self.target._query_private.assert_called_once()
self.context.save_balances.assert_not_called()
def main_historical():
context = CryptowelderContext(config='~/.cryptowelder', debug=True)
context.launch_prometheus()
target = MetricWelder(context)
timestamp = context.get_now().replace(day=1, hour=0, minute=0, second=0, microsecond=0)
while True:
if timestamp >= datetime.now().astimezone(utc):
break
target.process_metric(default_time=timestamp, default_count=1)
timestamp = timestamp + timedelta(minutes=60)
def main_historical():
context = CryptowelderContext(config='~/.cryptowelder', debug=True)
context.launch_prometheus()
target = BitflyerWelder(context)
maturity = datetime(year=2017, month=4, day=28)
while maturity < datetime.now():
y = maturity.strftime('%Y')
m = [k for k, v in BitflyerWelder._MONTHS.items() if v == maturity.month][0]
d = maturity.strftime('%d')
product = 'BTCJPY%s%s%s' % (d, m, y)
target._process_product(product)
target._process_evaluation(product)
target._process_ticker(product)
target._process_transaction(product)
maturity = maturity + timedelta(days=7)
def test__process_ticker(self):
now = datetime.fromtimestamp(1234567890.123456, utc)
self.context.get_now = MagicMock(return_value=now)
self.context.save_tickers = MagicMock()
self.context.requests_get = MagicMock(
return_value=CryptowelderContext._parse("""
{
"last": 723000,
"high": 768540,
"low": 718000,
"vwap": 748497.021,
"volume": 11395.2944,
"bid": 723000,
"ask": 723485
}
"""))
self.target._process_ticker('btc_jpy')
tickers = self.context.save_tickers.call_args[0][0]
self.assertEqual(1, len(tickers))
self.assertEqual('zaif', tickers[0].tk_site)
self.assertEqual('2009-02-13 23:31:30.123456 UTC',
tickers[0].tk_time.strftime(self.FORMAT))
self.assertEqual('btc_jpy', tickers[0].tk_code)
self.assertEqual(Decimal('723485'), tickers[0].tk_ask)
self.assertEqual(Decimal('723000'), tickers[0].tk_bid)
self.assertEqual(Decimal('723000'), tickers[0].tk_ltp)
# Query Empty
self.context.requests_get.reset_mock()
self.context.requests_get.return_value = {}
self.context.save_tickers.reset_mock()
self.target._process_ticker('btc_jpy')
self.context.requests_get.assert_called_once()
self.context.save_tickers.assert_called_once()
# Query None
self.context.requests_get.reset_mock()
self.context.requests_get.return_value = None
self.context.save_tickers.reset_mock()
self.target._process_ticker('btc_jpy')
self.context.requests_get.assert_called_once()
self.context.save_tickers.assert_not_called()
# Query Failure
self.context.requests_get.reset_mock()
self.context.requests_get.side_effect = Exception('test')
self.context.save_tickers.reset_mock()
self.target._process_ticker('btc_jpy')
self.context.requests_get.assert_called_once()
self.context.save_tickers.assert_not_called()
def test__process_ticker(self):
self.context.save_tickers = MagicMock()
self.context.requests_get = MagicMock(
return_value=CryptowelderContext._parse("""
{
"mid": "8901.25",
"bid": "8901.2",
"ask": "8901.3",
"last_price": "8901.4",
"low": "7890.123456789",
"high": "9012.3",
"volume": "123456.78901234",
"timestamp": "1234567890.1234567"
}
"""))
self.target._process_ticker("FOO_BAR")
tickers = self.context.save_tickers.call_args[0][0]
self.assertEqual(1, len(tickers))
self.assertEqual('bitfinex', tickers[0].tk_site)
self.assertEqual('FOO_BAR', tickers[0].tk_code)
self.assertEqual('2009-02-13 23:31:30.123457 UTC',
tickers[0].tk_time.strftime(self.FORMAT))
self.assertEqual('8901.3', tickers[0].tk_ask)
self.assertEqual('8901.2', tickers[0].tk_bid)
self.assertEqual('8901.4', tickers[0].tk_ltp)
# Query Empty
self.context.requests_get.reset_mock()
self.context.requests_get.return_value = {}
self.context.save_tickers.reset_mock()
self.target._process_ticker("FOO_BAR")
self.context.requests_get.assert_called_once()
self.context.save_tickers.assert_called_once()
# Query None
self.context.requests_get.reset_mock()
self.context.requests_get.return_value = None
self.context.save_tickers.reset_mock()
self.target._process_ticker("FOO_BAR")
self.context.requests_get.assert_called_once()
self.context.save_tickers.assert_not_called()
# Query Failure
self.context.requests_get.reset_mock()
self.context.requests_get.side_effect = Exception('test')
self.context.save_tickers.reset_mock()
self.target._process_ticker("FOO_BAR")
self.context.requests_get.assert_called_once()
self.context.save_tickers.assert_not_called()
def test__process_margin(self):
now = datetime.fromtimestamp(1234567890.123456, utc)
self.context.get_now = MagicMock(return_value=now)
self.context.save_balances = MagicMock()
self.target._query_private = MagicMock(return_value=CryptowelderContext._parse("""
[
{
"currency": "FOO",
"walletBalance": 12345678
},
{
"currency": "XBt",
"walletBalance": 23456789
}
]
"""))
self.target._process_margin()
balances = self.context.save_balances.call_args[0][0]
self.assertEqual(1, len(balances))
self.assertEqual('bitmex', balances[0].bc_site)
self.assertEqual('MARGIN', balances[0].bc_acct.name)
self.assertEqual('BTC', balances[0].bc_unit.name)
self.assertEqual('2009-02-13 23:31:30.123456 UTC', balances[0].bc_time.strftime(self.FORMAT))
self.assertEqual(Decimal('0.23456789'), balances[0].bc_amnt)
# Query Empty
self.target._query_private.reset_mock()
self.target._query_private.return_value = {}
self.context.save_balances.reset_mock()
self.target._process_margin()
self.target._query_private.assert_called_once()
self.context.save_balances.assert_called_once()
# Query None
self.target._query_private.reset_mock()
self.target._query_private.return_value = None
self.context.save_balances.reset_mock()
self.target._process_margin()
self.target._query_private.assert_called_once()
self.context.save_balances.assert_called_once()
# Query Failure
self.target._query_private.reset_mock()
self.target._query_private.side_effect = Exception('test')
self.context.save_balances.reset_mock()
self.target._process_margin()
self.target._query_private.assert_called_once()
self.context.save_balances.assert_not_called()
def test__process_balance(self):
now = datetime.fromtimestamp(1234567890)
self.context.get_now = MagicMock(return_value=now)
self.context.save_balances = MagicMock()
self.target._query_private = MagicMock(
return_value=CryptowelderContext._parse("""
[
{
"currency_code": "JPY",
"amount": 1024078,
"available": 508000
},
{
"currency_code": "FOO",
"amount": 20.48,
"available": 16.38
},
{
"currency_code": "BTC",
"amount": 10.24,
"available": 4.12
}
]
"""))
self.target._process_balance('/FOO/BAR', AccountType.CASH)
self.target._query_private.assert_called_once_with('/FOO/BAR')
balances = self.context.save_balances.call_args[0][0]
self.assertEqual(2, len(balances))
self.assertEqual('bitflyer', balances[0].bc_site)
self.assertEqual(AccountType.CASH, balances[0].bc_acct)
self.assertEqual(1234567890, balances[0].bc_time.timestamp())
self.assertEqual(UnitType.JPY, balances[0].bc_unit)
self.assertEqual(Decimal('1024078'), balances[0].bc_amnt)
self.assertEqual('bitflyer', balances[1].bc_site)
self.assertEqual(AccountType.CASH, balances[1].bc_acct)
self.assertEqual(1234567890, balances[1].bc_time.timestamp())
self.assertEqual(UnitType.BTC, balances[1].bc_unit)
self.assertEqual(Decimal('10.24'), balances[1].bc_amnt)
# Query Failure
self.target._query_private.reset_mock()
self.target._query_private.side_effect = Exception('test')
self.context.save_balances.reset_mock()
self.target._process_balance('/FOO/BAR', AccountType.CASH)
self.target._query_private.assert_called_once()
self.context.save_balances.assert_not_called()
def test__process_ticker(self):
now = datetime.fromtimestamp(1234567890.123456, utc)
self.context.get_now = MagicMock(return_value=now)
self.context.save_tickers = MagicMock()
self.context.requests_get = MagicMock(return_value=CryptowelderContext._parse("""
{
"last": 27390,
"bid": 26900,
"ask": 27390,
"high": 27659,
"low": 26400,
"volume": "50.29627103",
"timestamp": 1423377841
}
"""))
self.target._process_ticker()
tickers = self.context.save_tickers.call_args[0][0]
self.assertEqual(1, len(tickers))
self.assertEqual('coincheck', tickers[0].tk_site)
self.assertEqual('2009-02-13 23:31:30.123456 UTC', tickers[0].tk_time.strftime(self.FORMAT))
self.assertEqual('btc_jpy', tickers[0].tk_code)
self.assertEqual(Decimal('27390'), tickers[0].tk_ask)
self.assertEqual(Decimal('26900'), tickers[0].tk_bid)
self.assertEqual(Decimal('27390'), tickers[0].tk_ltp)
# Query Blank
self.context.save_tickers.reset_mock()
self.context.requests_get.reset_mock()
self.context.requests_get.return_value = {}
self.target._process_ticker()
self.context.save_tickers.assert_called_once()
# Query Empty
self.context.save_tickers.reset_mock()
self.context.requests_get.reset_mock()
self.context.requests_get.return_value = None
self.target._process_ticker()
self.context.save_tickers.assert_not_called()
# Query Failure
self.context.save_tickers.reset_mock()
self.context.requests_get.reset_mock()
self.context.requests_get.side_effect = Exception('test')
self.target._process_ticker()
self.context.save_tickers.assert_not_called()
def test__process_ticker(self):
now = datetime.fromtimestamp(1234567890.123456, utc)
self.context.get_now = MagicMock(return_value=now)
self.context.save_tickers = MagicMock()
self.context.requests_get = MagicMock(return_value=CryptowelderContext._parse("""
{"high":39700,"low":36300,"buy":1.879,"sell":0,"last":38800,"vol":283.954}
"""))
self.target._process_ticker('btc')
tickers = self.context.save_tickers.call_args[0][0]
self.assertEqual(1, len(tickers))
self.assertEqual('btcbox', tickers[0].tk_site)
self.assertEqual('2009-02-13 23:31:30.123456 UTC', tickers[0].tk_time.strftime(self.FORMAT))
self.assertEqual('btc', tickers[0].tk_code)
self.assertEqual(Decimal('0'), tickers[0].tk_ask)
self.assertEqual(Decimal('1.879'), tickers[0].tk_bid)
self.assertEqual(Decimal('38800'), tickers[0].tk_ltp)
# Query Empty
self.context.requests_get.reset_mock()
self.context.requests_get.return_value = {}
self.context.save_tickers.reset_mock()
self.target._process_ticker('btc')
self.context.requests_get.assert_called_once()
self.context.save_tickers.assert_called_once()
# Query None
self.context.requests_get.reset_mock()
self.context.requests_get.return_value = None
self.context.save_tickers.reset_mock()
self.target._process_ticker('btc')
self.context.requests_get.assert_called_once()
self.context.save_tickers.assert_not_called()
# Query Failure
self.context.requests_get.reset_mock()
self.context.requests_get.side_effect = Exception('test')
self.context.save_tickers.reset_mock()
self.target._process_ticker('btc')
self.context.requests_get.assert_called_once()
self.context.save_tickers.assert_not_called()
def test__process_markets(self):
self.target._process_ticker = MagicMock()
self.target._process_position = MagicMock()
self.target._process_transaction = MagicMock()
self.context.requests_get = MagicMock(
return_value=CryptowelderContext._parse("""
[
{ "product_code": "BTC_JPY" },
{ "product_code": "FX_BTC_JPY" },
{ "product_code": "ETH_BTC" },
{
"product_code": "BTCJPY28APR2017",
"alias": "BTCJPY_MAT1WK"
},
{
"product_code": "BTCJPY05MAY2017",
"alias": "BTCJPY_MAT2WK"
}
]
"""))
self.target._process_markets()
for product in [
"BTC_JPY", "FX_BTC_JPY", "ETH_BTC", "BTCJPY28APR2017",
"BTCJPY05MAY2017"
]:
self.target._process_ticker.assert_any_call(product)
self.target._process_position.assert_any_call(product)
self.target._process_transaction.assert_any_call(product)
# Query Failure
self.context.requests_get = MagicMock(side_effect=Exception('test'))
self.target._process_ticker.reset_mock()
self.target._process_position.reset_mock()
self.target._process_transaction.reset_mock()
self.target._process_markets()
self.target._process_ticker.assert_not_called()
self.target._process_position.assert_not_called()
self.target._process_transaction.assert_not_called()
def test__process_ticker(self):
self.target._fetch_special_quotation = MagicMock(return_value=None)
self.context.save_tickers = MagicMock()
self.context.requests_get = MagicMock(
return_value=CryptowelderContext._parse("""
{
"product_code": "BTC_JPY",
"timestamp": "2015-07-08T02:50:59.97",
"tick_id": 3579,
"best_bid": 30000,
"best_ask": 36640,
"best_bid_size": 0.1,
"best_ask_size": 5,
"total_bid_depth": 15.13,
"total_ask_depth": 20,
"ltp": 31690,
"volume": 16819.26,
"volume_by_product": 6819.26
}
"""))
self.target._process_ticker("FOO_BAR")
tickers = self.context.save_tickers.call_args[0][0]
self.assertEqual(1, len(tickers))
self.assertEqual('bitflyer', tickers[0].tk_site)
self.assertEqual('FOO_BAR', tickers[0].tk_code)
self.assertEqual('2015-07-08 02:50:59.000000 UTC',
tickers[0].tk_time.strftime(self.FORMAT))
self.assertEqual(Decimal('36640'), tickers[0].tk_ask)
self.assertEqual(Decimal('30000'), tickers[0].tk_bid)
self.assertEqual(Decimal('31690'), tickers[0].tk_ltp)
# Empty Query
self.context.save_tickers.reset_mock()
self.context.requests_get = MagicMock(return_value=None)
self.target._process_ticker("FOO_BAR")
tickers = self.context.save_tickers.assert_not_called()
def setUp(self):
self.target = CryptowelderContext(read_only=False)
class TestCryptowelderContext(TestCase):
@classmethod
def setUpClass(cls):
cls.SERVER = HTTPServer(('localhost', 65535), TestHander)
Thread(target=lambda: cls.SERVER.serve_forever()).start()
sleep(1) # Wait for the server to start.
@classmethod
def tearDownClass(cls):
cls.SERVER.shutdown()
def setUp(self):
self.target = CryptowelderContext(read_only=False)
def test_property(self):
self.assertIsNone(self.target.get_property('foo', 'bar', None))
self.assertEquals(self.target.get_property('foo', 'bar', '12'), '12')
self.target.set_property('foo', 'bar', '34')
self.assertEquals(self.target.get_property('foo', 'bar', None), '34')
self.assertEquals(self.target.get_property('foo', 'bar', '12'), '34')
self.target.set_property('foo', 'bar', '56')
self.assertEquals(self.target.get_property('foo', 'bar', None), '56')
self.assertEquals(self.target.get_property('foo', 'bar', '12'), '56')
def test_get_logger(self):
logger = self.target.get_logger(self)
self.assertEqual(logger.level, DEBUG)
self.assertEqual(len(logger.handlers), 2)
self.assertIsInstance(logger.handlers[0], StreamHandler)
self.assertIsInstance(logger.handlers[1], BufferingHandler)
def test_is_closed(self):
self.assertFalse(self.target.is_closed())
def test_get_now(self):
self.assertIsNotNone(self.target.get_now())
def test_get_nonce(self):
values = set()
def execute():
for i in range(0, 100):
nonce = self.target.get_nonce('test')
millis = int(nonce.timestamp() * 1000)
values.add(millis)
threads = [Thread(target=execute) for i in range(0, 8)]
for t in threads:
t.start()
for t in threads:
t.join()
self.assertEqual(100 * len(threads), len(values))
def test_parse_iso_timestamp(self):
# Unix Time
result = self.target.parse_iso_timestamp('1234567890')
self.assertIsNotNone(result)
self.assertEqual(2009, result.year)
self.assertEqual(2, result.month)
self.assertEqual(13, result.day)
self.assertEqual(23, result.hour)
self.assertEqual(31, result.minute)
self.assertEqual(30, result.second)
self.assertEqual(0, result.microsecond)
self.assertEqual('UTC', result.tzname())
# Unix Time - Various Types
self.assertEqual(result, self.target.parse_iso_timestamp(1234567890))
self.assertEqual(result, self.target.parse_iso_timestamp(1234567890.0))
self.assertEqual(
result, self.target.parse_iso_timestamp(Decimal('1234567890.0')))
# Unix Time with Decimal
result = self.target.parse_iso_timestamp('1234567890.123456')
self.assertIsNotNone(result)
self.assertEqual(2009, result.year)
self.assertEqual(2, result.month)
self.assertEqual(13, result.day)
self.assertEqual(23, result.hour)
self.assertEqual(31, result.minute)
self.assertEqual(30, result.second)
self.assertEqual(123456, result.microsecond)
self.assertEqual('UTC', result.tzname())
# Unix Time - Various Types
self.assertEqual(result,
self.target.parse_iso_timestamp(1234567890.123456))
self.assertEqual(
result,
self.target.parse_iso_timestamp(Decimal('1234567890.123456')))
# ISO
result = self.target.parse_iso_timestamp('2017-04-14T12:34:56.789')
self.assertIsNotNone(result)
self.assertEqual(2017, result.year)
self.assertEqual(4, result.month)
self.assertEqual(14, result.day)
self.assertEqual(12, result.hour)
self.assertEqual(34, result.minute)
self.assertEqual(56, result.second)
self.assertEqual(0, result.microsecond)
self.assertEqual('UTC', result.tzname())
# ISO - Various Formats
self.assertEqual(
result, self.target.parse_iso_timestamp('2017-04-14T12:34:56'))
self.assertEqual(
result, self.target.parse_iso_timestamp('2017-04-14T12:34:56Z'))
self.assertEqual(
result,
self.target.parse_iso_timestamp('2017-04-14T12:34:56.789123'))
self.assertEqual(
result,
self.target.parse_iso_timestamp('2017-04-14T12:34:56.789123Z'))
# ISO - Invalid Formats
self.assertIsNone(self.target.parse_iso_timestamp('2017-04-14T12:34'))
self.assertIsNone(self.target.parse_iso_timestamp('2017-04-14T12:34Z'))
self.assertIsNone(self.target.parse_iso_timestamp(''))
self.assertIsNone(self.target.parse_iso_timestamp(None))
def test_launch_prometheus(self):
method = MagicMock()
# Default
self.target.launch_prometheus(method=method)
method.assert_called_with(20000, addr='localhost')
# Custom host:port
self.target.set_property(self.target._SECTION, 'prometheus_host',
'127.0.0.1')
self.target.set_property(self.target._SECTION, 'prometheus_port',
'65535')
self.target.launch_prometheus(method=method)
method.assert_called_with(65535, addr='127.0.0.1')
def test__parse(self):
result = self.target._parse(
'{"str":"foo", "int":123, "flt":1.2, "flg":true}')
self.assertEqual(len(result), 4)
self.assertEqual(result['str'], "foo")
self.assertEqual(result['int'], 123)
self.assertEqual(result['flt'], Decimal('1.2'))
self.assertEqual(result['flg'], True)
self.assertIsNone(self.target._parse(None))
self.assertIsNone(self.target._parse(''))
def test__request(self):
TestHander.init()
result = self.target._request(lambda: get("http://localhost:65535"))
self.assertIsNone(result)
TestHander.init(
content='{"str":"foo", "int":123, "flt":1.2, "flg":true}')
result = self.target._request(lambda: get("http://localhost:65535"))
self.assertEqual(len(result), 4)
self.assertEqual(result['str'], "foo")
self.assertEqual(result['int'], 123)
self.assertEqual(result['flt'], Decimal('1.2'))
self.assertEqual(result['flg'], True)
def test__request_ClientError(self):
self.target.set_property(self.target._SECTION, 'request_retry', '3')
self.target.set_property(self.target._SECTION, 'request_sleep',
'0.001')
TestHander.init(status=404)
try:
self.target._request(lambda: get("http://localhost:65535"),
label='test client')
self.fail('Error Expected : 4xx')
except BaseException as e:
self.assertEqual('404', str(e.args[0]))
self.assertEqual('TEST-FAIL', str(e.args[1]))
self.assertEqual('test client', str(e.args[2]))
def test__request_ServerError(self):
self.target.set_property(self.target._SECTION, 'request_retry', '3')
self.target.set_property(self.target._SECTION, 'request_sleep',
'0.001')
TestHander.init(status=502)
try:
self.target._request(lambda: get("http://localhost:65535"),
label='test server')
self.fail('Error Expected : 5xx')
except BaseException as e:
self.assertEqual('502', str(e.args[0]))
self.assertEqual('TEST-FAIL', str(e.args[1]))
self.assertEqual('test server', str(e.args[2]))
def test__request_ConnectionError(self):
self.target.set_property(self.target._SECTION, 'request_retry', '3')
self.target.set_property(self.target._SECTION, 'request_sleep',
'0.001')
TestHander.init()
try:
self.target._request(lambda: get("http://localhost:1"),
label='test refuse')
self.fail('Error Expected : Refused')
except BaseException as e:
self.assertEqual('test refuse', str(e.args[0]))
def test_requests_get(self):
response = "{'foo': 'bar'}"
self.target._request = MagicMock(return_value=response)
self.assertEqual(self.target.requests_get('http://localhost:65535'),
response)
self.target._request.assert_called_once()
def test_requests_post(self):
response = "{'foo': 'bar'}"
self.target._request = MagicMock(return_value=response)
self.assertEqual(self.target.requests_post('http://localhost:65535'),
response)
self.target._request.assert_called_once()
def test__truncate_datetime(self):
# Arbitrary Time
dt = datetime(year=2017,
month=4,
day=14,
hour=12,
minute=34,
second=56,
microsecond=789123,
tzinfo=utc)
result = self.target._truncate_datetime(dt)
self.assertEqual(2017, result.year)
self.assertEqual(4, result.month)
self.assertEqual(14, result.day)
self.assertEqual(12, result.hour)
self.assertEqual(35, result.minute) # Round UP
self.assertEqual(0, result.second)
self.assertEqual(0, result.microsecond)
self.assertEqual('UTC', result.tzname())
# On boundary
dt = datetime(year=2017,
month=4,
day=14,
hour=12,
minute=34,
second=0,
microsecond=0,
tzinfo=utc)
result = self.target._truncate_datetime(dt)
self.assertEqual(2017, result.year)
self.assertEqual(4, result.month)
self.assertEqual(14, result.day)
self.assertEqual(12, result.hour)
self.assertEqual(34, result.minute) # Round NONE
self.assertEqual(0, result.second)
self.assertEqual(0, result.microsecond)
self.assertEqual('UTC', result.tzname())
# On boundary + 1 micro
result = self.target._truncate_datetime(dt + timedelta(microseconds=1))
self.assertEqual(2017, result.year)
self.assertEqual(4, result.month)
self.assertEqual(14, result.day)
self.assertEqual(12, result.hour)
self.assertEqual(35, result.minute) # Round UP
self.assertEqual(0, result.second)
self.assertEqual(0, result.microsecond)
self.assertEqual('UTC', result.tzname())
# On boundary - 1 micro
result = self.target._truncate_datetime(dt - timedelta(microseconds=1))
self.assertEqual(2017, result.year)
self.assertEqual(4, result.month)
self.assertEqual(14, result.day)
self.assertEqual(12, result.hour)
self.assertEqual(34, result.minute) # Round UP
self.assertEqual(0, result.second)
self.assertEqual(0, result.microsecond)
self.assertEqual('UTC', result.tzname())
def test_save_products(self):
self.target._create_all()
dt = datetime.now()
p1 = Product()
p1.pr_site = 'ps1'
p1.pr_code = 'pc1'
p1.pr_fund = 'pf1'
p1.pr_inst = 'pi1'
p1.pr_disp = 'pd1'
p1.pr_expr = dt
p2 = Product()
p2.pr_site = 'ps2'
p2.pr_code = 'pc2'
p3 = copy(p1)
p4 = copy(p2)
p5 = copy(p1)
p5.pr_code = None
# All new records
results = self.target.save_products([p1, p2])
self.assertEqual(len(results), 2)
self.assertTrue(p1 in results)
self.assertTrue(p2 in results)
# Existing records
results = self.target.save_products([p3, None, p4])
self.assertEqual(len(results), 0)
# PK Failure
with self.assertRaises(BaseException):
self.target.save_products([p5])
# Read-only
self.target._is_read_only = lambda: True
results = self.target.save_products([p1])
self.assertEqual(len(results), 0)
def test_save_evaluations(self):
self.target._create_all()
v1 = Evaluation()
v1.ev_site = 's1'
v1.ev_unit = 'u1'
v1.ev_ticker_site = 'ts1'
v1.ev_ticker_code = 'tc1'
v1.ev_convert_site = 'cs1'
v1.ev_convert_code = 'cc1'
v2 = Evaluation()
v2.ev_site = 's2'
v2.ev_unit = 'c2'
v3 = copy(v1)
v4 = copy(v2)
v5 = copy(v1)
v5.ev_unit = None
# All new records
results = self.target.save_evaluations([v1, v2])
self.assertEqual(len(results), 2)
self.assertTrue(v1 in results)
self.assertTrue(v2 in results)
# Existing records
results = self.target.save_evaluations([v3, None, v4])
self.assertEqual(len(results), 0)
# PK Failure
with self.assertRaises(BaseException):
self.target.save_evaluations([v5])
# Read-only
self.target._is_read_only = lambda: True
results = self.target.save_evaluations([v1])
self.assertEqual(len(results), 0)
def test_save_tickers(self):
self.target._create_all()
dt = datetime.now()
t1 = Ticker()
t1.tk_site = 'ts'
t1.tk_code = 'tp'
t1.tk_time = dt + timedelta(minutes=1)
t1.tk_ltp = Decimal('1.2')
t2 = Ticker()
t2.tk_site = 'ts'
t2.tk_code = 'tp'
t2.tk_time = dt + timedelta(minutes=2)
t2.tk_ltp = Decimal('2.3')
t3 = copy(t1)
t3.tk_ltp = Decimal('3.4')
t4 = copy(t2)
t4.tk_ltp = Decimal('4.5')
t5 = copy(t1)
t5.tk_code = None
# All new records
results = self.target.save_tickers([t1, t2])
self.assertEqual(len(results), 2)
self.assertTrue(t1 in results)
self.assertTrue(t2 in results)
# Existing records
results = self.target.save_tickers([t3, None, t4])
self.assertEqual(len(results), 2)
self.assertTrue(t3 in results)
self.assertTrue(t4 in results)
# PK Failure
with self.assertRaises(BaseException):
self.target.save_tickers([t5])
# Read-only
self.target._is_read_only = lambda: True
results = self.target.save_tickers([t1])
self.assertEqual(len(results), 0)
def test_save_balances(self):
self.target._create_all()
dt = datetime.now()
b1 = Balance()
b1.bc_site = 'ts'
b1.bc_acct = AccountType.CASH
b1.bc_unit = UnitType.QTY
b1.bc_time = dt + timedelta(minutes=1)
b1.bc_amnt = Decimal('1.2')
b2 = Balance()
b2.bc_site = 'ts'
b2.bc_acct = AccountType.CASH
b2.bc_unit = UnitType.QTY
b2.bc_time = dt + timedelta(minutes=2)
b2.bc_amnt = Decimal('1.2')
b3 = copy(b1)
b3.bc_amnt = Decimal('3.4')
b4 = copy(b2)
b4.bc_amnt = Decimal('4.5')
b5 = copy(b1)
b5.bc_unit = None
# All new records
results = self.target.save_balances([b1, b2])
self.assertEqual(len(results), 2)
self.assertTrue(b1 in results)
self.assertTrue(b2 in results)
# Existing records
results = self.target.save_balances([b3, None, b4])
self.assertEqual(len(results), 2)
self.assertTrue(b3 in results)
self.assertTrue(b4 in results)
# PK Failure
with self.assertRaises(BaseException):
self.target.save_balances([b5])
# Read-only
self.target._is_read_only = lambda: True
results = self.target.save_balances([b1])
self.assertEqual(len(results), 0)
def test_save_positions(self):
self.target._create_all()
dt = datetime.now()
p1 = Position()
p1.ps_site = 'ps'
p1.ps_code = 'pc'
p1.ps_time = dt + timedelta(minutes=1)
p1.ps_inst = Decimal('1.2')
p1.ps_fund = None
p2 = Position()
p2.ps_site = 'ps'
p2.ps_code = 'pc'
p2.ps_time = dt + timedelta(minutes=2)
p2.ps_inst = None
p2.ps_fund = Decimal('3.4')
p3 = copy(p1)
p3.ps_inst = Decimal('3.4')
p3.ps_fund = Decimal('4.5')
p4 = copy(p2)
p4.ps_inst = Decimal('5.6')
p4.ps_fund = Decimal('6.7')
p5 = copy(p1)
p5.ps_code = None
# All new records
results = self.target.save_positions([p1, p2])
self.assertEqual(len(results), 2)
self.assertTrue(p1 in results)
self.assertTrue(p2 in results)
# Existing records
results = self.target.save_positions([p3, None, p4])
self.assertEqual(len(results), 2)
self.assertTrue(p3 in results)
self.assertTrue(p4 in results)
# PK Failure
with self.assertRaises(BaseException):
self.target.save_positions([p5])
# Read-only
self.target._is_read_only = lambda: True
results = self.target.save_positions([p1])
self.assertEqual(len(results), 0)
def test_save_transactions(self):
self.target._create_all()
t1 = Transaction()
t1.tx_site = 'ts'
t1.tx_code = 'tp'
t1.tx_type = TransactionType.TRADE
t1.tx_acct = AccountType.CASH
t1.tx_oid = 'to'
t1.tx_eid = 'te'
t1.tx_time = datetime.now()
t1.tx_fund = -1.2
t1.tx_inst = +2.3
t2 = Transaction()
t2.tx_site = 'ts'
t2.tx_code = 'tp'
t2.tx_type = TransactionType.TRADE
t2.tx_acct = AccountType.CASH
t2.tx_oid = 'NEW'
t2.tx_eid = 'te'
t2.tx_time = datetime.now()
t2.tx_fund = -2.3
t2.tx_inst = +3.4
t3 = Transaction()
t3.tx_site = 'ts'
t3.tx_code = 'NEW'
t3.tx_type = TransactionType.TRADE
t3.tx_acct = AccountType.CASH
t3.tx_oid = 'to'
t3.tx_eid = 'te'
t3.tx_time = datetime.now()
t3.tx_fund = -3.4
t3.tx_inst = +4.5
t4 = Transaction()
t4.tx_site = 'NEW'
t4.tx_code = 'tp'
t4.tx_type = TransactionType.TRADE
t4.tx_acct = AccountType.CASH
t4.tx_oid = 'to'
t4.tx_eid = 'te'
t4.tx_time = datetime.now()
t4.tx_fund = -4.5
t4.tx_inst = +5.6
t2c = copy(t2)
t3c = copy(t3)
t4c = copy(t4)
t4c.tx_oid = None
# All new records
results = self.target.save_transactions([t1, t2, t3])
self.assertEqual(len(results), 3)
self.assertTrue(t1 in results)
self.assertTrue(t2 in results)
self.assertTrue(t3 in results)
# One new record
results = self.target.save_transactions([t2c, t3c, None, t4])
self.assertEqual(len(results), 1)
self.assertTrue(t4 in results)
# No record
results = self.target.save_transactions(None)
self.assertEqual(len(results), 0)
# PK Failure
with self.assertRaises(BaseException):
self.target.save_transactions([t4c])
# Read-only
self.target._is_read_only = lambda: True
results = self.target.save_transactions([t1])
self.assertEqual(len(results), 0)
def test_save_metrics(self):
self.target._create_all()
dt = datetime.now()
m1 = Metric()
m1.mc_type = 't1'
m1.mc_time = dt + timedelta(minutes=1)
m1.mc_name = 'n1'
m1.mc_amnt = Decimal('1.2')
m2 = Metric()
m2.mc_type = 't2'
m2.mc_time = dt + timedelta(minutes=2)
m2.mc_name = 'n2'
m2.mc_amnt = Decimal('2.3')
m3 = copy(m1)
m3.mc_amnt = Decimal('3.4')
m4 = copy(m2)
m4.mc_amnt = Decimal('4.5')
m5 = copy(m1)
m5.mc_name = None
# All new records
results = self.target.save_metrics([m1, m2])
self.assertEqual(len(results), 2)
self.assertTrue(m1 in results)
self.assertTrue(m2 in results)
# Existing records
results = self.target.save_metrics([m3, None, m4])
self.assertEqual(len(results), 2)
self.assertTrue(m3 in results)
self.assertTrue(m4 in results)
# PK Failure
with self.assertRaises(BaseException):
self.target.save_metrics([m5])
# Read-only
self.target._is_read_only = lambda: True
results = self.target.save_metrics([m1])
self.assertEqual(len(results), 0)
def test_delete_metrics(self):
self.target._create_all()
base = datetime.now(tz=utc).replace(minute=0, second=0, microsecond=0)
def load_records():
m1 = Metric()
m1.mc_type = 'test'
m1.mc_time = base.replace(minute=1)
m1.mc_name = 'foo'
m2 = Metric()
m2.mc_type = 'test'
m2.mc_time = base.replace(minute=2)
m2.mc_name = 'bar'
m3 = Metric()
m3.mc_type = 'test'
m3.mc_time = base.replace(minute=3)
m3.mc_name = 'hoge'
self.target.save_metrics((m1, m2, m3))
load_records()
count = self.target.delete_metrics(base)
self.assertEqual(count, 0)
count = self.target.delete_metrics(base.replace(minute=1))
self.assertEqual(count, 0)
count = self.target.delete_metrics(base.replace(minute=3))
self.assertEqual(count, 2)
count = self.target.delete_metrics(base.replace(minute=4))
self.assertEqual(count, 1)
load_records()
count = self.target.delete_metrics(base.replace(minute=4),
exclude_minutes=[1, 2, 3])
self.assertEqual(count, 0)
count = self.target.delete_metrics(base.replace(minute=4),
exclude_minutes=[1])
self.assertEqual(count, 2)
try:
self.target.delete_metrics(None)
self.fail()
except BaseException as e:
self.assertIsNotNone(e)
def test_fetch_tickers(self):
self.target._create_all()
# TODO : Test data
self.target.fetch_tickers(datetime.now())
def test_fetch_balances(self):
self.target._create_all()
# TODO : Test data
self.target.fetch_balances(datetime.now())
def test_fetch_positions(self):
self.target._create_all()
# TODO : Test data
self.target.fetch_positions(datetime.now())
def test_fetch_transactions(self):
self.target._create_all()
now = datetime.now()
# TODO : Test data
self.target.fetch_transactions(now - timedelta(days=1), now)
def test_Product(self):
value = Product()
self.assertEqual(
"{'table': 't_product', 'site': 'None', 'code': 'None', 'inst': 'None', 'fund': 'None', "
"'disp': 'None', 'expr': 'None'}", str(value))
value.pr_site = 'foo'
value.pr_code = 'bar'
value.pr_inst = 'hoge'
value.pr_fund = 'piyo'
value.pr_disp = 'test'
value.pr_expr = datetime.fromtimestamp(1234567890.123456, tz=utc)
self.assertEqual(
"{'table': 't_product', 'site': 'foo', 'code': 'bar', 'inst': 'hoge', 'fund': 'piyo', "
"'disp': 'test', 'expr': '2009-02-13 23:31:30.123456 UTC'}",
str(value))
def test_Evaluation(self):
value = Evaluation()
self.assertEqual(
"{'table': 't_evaluation', 'site': 'None', 'unit': 'None', "
"'t_site': 'None', 't_code': 'None', 'c_site': 'None', 'c_code': 'None'}",
str(value))
value.ev_site = 'foo'
value.ev_unit = 'bar'
value.ev_ticker_site = 'hoge'
value.ev_ticker_code = 'piyo'
value.ev_convert_site = 'huga'
value.ev_convert_code = 'poyo'
self.assertEqual(
"{'table': 't_evaluation', 'site': 'foo', 'unit': 'bar', "
"'t_site': 'hoge', 't_code': 'piyo', 'c_site': 'huga', 'c_code': 'poyo'}",
str(value))
def test_Account(self):
value = Account()
self.assertEqual(
"{'table': 't_account', 'site': 'None', 'acct': 'None', 'unit': 'None', 'disp': 'None'}",
str(value))
value.ac_site = 'foo'
value.ac_acct = 'bar'
value.ac_unit = 'hoge'
value.ac_disp = 'piyo'
self.assertEqual(
"{'table': 't_account', 'site': 'foo', 'acct': 'bar', 'unit': 'hoge', 'disp': 'piyo'}",
str(value))
def test_Ticker(self):
value = Ticker()
self.assertEqual(
"{'table': 't_ticker', 'site': 'None', 'code': 'None', 'time': 'None', "
"'ask': 'None', 'bid': 'None', 'ltp': 'None'}", str(value))
value.tk_site = 'foo'
value.tk_code = 'bar'
value.tk_time = datetime.fromtimestamp(1234567890.123456, tz=utc)
value.tk_ask = Decimal('1.2')
value.tk_bid = Decimal('2.3')
value.tk_ltp = Decimal('3.4')
self.assertEqual(
"{'table': 't_ticker', 'site': 'foo', 'code': 'bar', "
"'time': '2009-02-13 23:31:30.123456 UTC', "
"'ask': '1.2', 'bid': '2.3', 'ltp': '3.4'}", str(value))
def test_Balance(self):
value = Balance()
self.assertEqual(
"{'table': 't_balance', 'site': 'None', 'account': 'None', "
"'unit': 'None', 'time': 'None', 'amount': 'None'}", str(value))
value.bc_site = 'foo'
value.bc_acct = AccountType.CASH
value.bc_unit = UnitType.JPY
value.bc_time = datetime.fromtimestamp(1234567890.123456, tz=utc)
value.bc_amnt = Decimal('1.2')
self.assertEqual(
"{'table': 't_balance', 'site': 'foo', 'account': 'CASH', 'unit': 'JPY', "
"'time': '2009-02-13 23:31:30.123456 UTC', 'amount': '1.2'}",
str(value))
def test_Position(self):
value = Position()
self.assertEqual(
"{'table': 't_position', 'site': 'None', 'code': 'None', "
"'time': 'None', 'instrument': 'None', 'funding': 'None'}",
str(value))
value.ps_site = 'foo'
value.ps_code = 'bar'
value.ps_time = datetime.fromtimestamp(1234567890.123456, tz=utc)
value.ps_inst = Decimal('1.2')
value.ps_fund = Decimal('2.3')
self.assertEqual(
"{'table': 't_position', 'site': 'foo', 'code': 'bar', "
"'time': '2009-02-13 23:31:30.123456 UTC', "
"'instrument': '1.2', 'funding': '2.3'}", str(value))
def test_Transaction(self):
value = Transaction()
self.assertEqual(
"{'table': 't_transaction', 'site': 'None', 'code': 'None', "
"'type': 'None', 'acct': 'None', 'oid': 'None', 'eid': 'None', "
"'time': 'None', 'instrument': 'None', 'funding': 'None'}",
str(value))
value.tx_site = 'foo'
value.tx_code = 'bar'
value.tx_type = TransactionType.TRADE
value.tx_acct = AccountType.CASH
value.tx_oid = "o_id"
value.tx_eid = "e_id"
value.tx_time = datetime.fromtimestamp(1234567890.123456, tz=utc)
value.tx_inst = Decimal('1.2')
value.tx_fund = Decimal('2.3')
self.assertEqual(
"{'table': 't_transaction', 'site': 'foo', 'code': 'bar', 'type': 'TRADE', "
"'acct': 'CASH', 'oid': 'o_id', 'eid': 'e_id', "
"'time': '2009-02-13 23:31:30.123456 UTC', "
"'instrument': '1.2', 'funding': '2.3'}", str(value))
def test_Metric(self):
value = Metric()
self.assertEqual(
"{'table': 't_metric', 'type': 'None', "
"'time': 'None', 'name': 'None', 'amnt': 'None'}", str(value))
value.mc_type = 'foo'
value.mc_time = datetime.fromtimestamp(1234567890.123456, tz=utc)
value.mc_name = 'bar'
value.mc_amnt = Decimal('1.2')
self.assertEqual(
"{'table': 't_metric', 'type': 'foo', "
"'time': '2009-02-13 23:31:30.123456 UTC', 'name': 'bar', 'amnt': '1.2'}",
str(value))
def test__process_trade(self):
side_effects = [
CryptowelderContext._parse("""
{
"success": 1,
"return": {
"182": {
"currency_pair": "btc_jpy",
"action": "bid",
"amount": 0.03,
"price": 56000,
"fee": 0,
"your_action": "ask",
"bonus": 1.6,
"timestamp": 1402018713,
"comment" : "demo"
}
}
}
"""),
CryptowelderContext._parse("""
{
"success": 1,
"return": {
"180": {
"currency_pair": "btc_jpy",
"action": "ask",
"amount": 0.04,
"price": 56001,
"fee": 3.2,
"your_action": "bid",
"bonus": 0,
"timestamp": 1402018710,
"comment" : "test"
}
}
}
"""),
CryptowelderContext._parse("""
{
"success": 1
}
""")
]
# Query 3 times
self.target._query_private = MagicMock(side_effect=side_effects)
self.context.save_transactions = MagicMock(return_value=[None])
self.target._process_trades('foo_bar')
self.target._query_private.assert_called()
self.context.save_transactions.assert_called()
calls = self.context.save_transactions.call_args_list
self.assertEqual(2, len(calls))
values = list(calls[0][0][0])
self.assertEqual(1, len(values))
self.assertEqual('zaif', values[0].tx_site)
self.assertEqual('foo_bar', values[0].tx_code)
self.assertEqual(TransactionType.TRADE, values[0].tx_type)
self.assertEqual(AccountType.CASH, values[0].tx_acct)
self.assertEqual('182', values[0].tx_oid)
self.assertEqual('182', values[0].tx_eid)
self.assertEqual('2014-06-06 01:38:33.000000 UTC',
values[0].tx_time.strftime(self.FORMAT))
self.assertEqual(Decimal('-0.03'), values[0].tx_inst)
self.assertEqual(Decimal('1681.60'), values[0].tx_fund)
values = list(calls[1][0][0])
self.assertEqual(1, len(values))
self.assertEqual('zaif', values[0].tx_site)
self.assertEqual('foo_bar', values[0].tx_code)
self.assertEqual(TransactionType.TRADE, values[0].tx_type)
self.assertEqual(AccountType.CASH, values[0].tx_acct)
self.assertEqual('180', values[0].tx_oid)
self.assertEqual('180', values[0].tx_eid)
self.assertEqual('2014-06-06 01:38:30.000000 UTC',
values[0].tx_time.strftime(self.FORMAT))
self.assertEqual(Decimal('0.04'), values[0].tx_inst)
self.assertEqual(Decimal('-2243.24'), values[0].tx_fund)
# Nothing saved
self.target._query_private = MagicMock(side_effect=side_effects)
self.context.save_transactions = MagicMock(return_value=None)
self.target._process_trades('foo_bar')
self.target._query_private.assert_called_once()
self.context.save_transactions.assert_called_once()
# Empty Trades
self.target._query_private = MagicMock(
return_value=CryptowelderContext._parse("""
{
"success": 1,
"return": {
}
}
"""))
self.context.save_transactions = MagicMock(return_value=[None])
self.target._process_trades('foo_bar')
self.target._query_private.assert_called_once()
self.context.save_transactions.assert_not_called()
# Failure Response
self.target._query_private = MagicMock(
return_value=CryptowelderContext._parse("""
{
"success": 0,
"return": {
}
}
"""))
self.context.save_transactions = MagicMock(return_value=[None])
self.target._process_trades('foo_bar')
self.target._query_private.assert_called_once()
self.context.save_transactions.assert_not_called()
# Exception Response
self.target._query_private = MagicMock(side_effect=Exception('test'))
self.context.save_transactions = MagicMock(return_value=[None])
self.target._process_trades('foo_bar')
self.target._query_private.assert_called_once()
self.context.save_transactions.assert_not_called()
def test__process_ticker(self):
now = datetime.fromtimestamp(1234567890.123456, utc)
self.context.get_now = MagicMock(return_value=now)
self.context.get_property = MagicMock(
return_value='BTCUSDT,ETHBTC,BCCBTC,FOOBAR')
self.context.save_tickers = MagicMock()
self.context.requests_get = MagicMock(side_effect=[
CryptowelderContext._parse("""
[
{
"symbol": "ETHBTC",
"price": "0.05618000"
},
{
"symbol": "BCCBTC",
"price": "0.09989100"
},
{
"symbol": "BTCUSDT",
"price": "6778.00000000"
}
]
"""),
CryptowelderContext._parse("""
[
{
"symbol": "ETHBTC",
"bidPrice": "0.05608800",
"bidQty": "2.09100000",
"askPrice": "0.05613000",
"askQty": "0.71900000"
},
{
"symbol": "BCCBTC",
"bidPrice": "0.09977100",
"bidQty": "0.77700000",
"askPrice": "0.09990500",
"askQty": "3.96600000"
},
{
"symbol": "BTCUSDT",
"bidPrice": "6762.01000000",
"bidQty": "0.29040300",
"askPrice": "6768.97000000",
"askQty": "0.01863300"
}
]
""")
])
self.target._process_ticker()
tickers = self.context.save_tickers.call_args[0][0]
self.assertEqual(4, len(tickers))
for t in tickers:
self.assertEqual('binance', t.tk_site)
self.assertEqual('2009-02-13 23:31:30.123456 UTC',
t.tk_time.strftime(self.FORMAT))
self.assertEqual('BTCUSDT', tickers[0].tk_code)
self.assertEqual('6768.97000000', tickers[0].tk_ask)
self.assertEqual('6762.01000000', tickers[0].tk_bid)
self.assertEqual('6778.00000000', tickers[0].tk_ltp)
self.assertEqual('ETHBTC', tickers[1].tk_code)
self.assertEqual('0.05613000', tickers[1].tk_ask)
self.assertEqual('0.05608800', tickers[1].tk_bid)
self.assertEqual('0.05618000', tickers[1].tk_ltp)
self.assertEqual('BCCBTC', tickers[2].tk_code)
self.assertEqual('0.09990500', tickers[2].tk_ask)
self.assertEqual('0.09977100', tickers[2].tk_bid)
self.assertEqual('0.09989100', tickers[2].tk_ltp)
self.assertEqual('FOOBAR', tickers[3].tk_code)
self.assertEqual(None, tickers[3].tk_ask)
self.assertEqual(None, tickers[3].tk_bid)
self.assertEqual(None, tickers[3].tk_ltp)
# Query Empty
self.context.requests_get.reset_mock()
self.context.requests_get.side_effect = ([], [])
self.context.save_tickers.reset_mock()
self.target._process_ticker()
self.context.requests_get.assert_called()
self.context.save_tickers.assert_called_once()
# Query None
self.context.requests_get.reset_mock()
self.context.requests_get.side_effect = (None, None)
self.context.save_tickers.reset_mock()
self.target._process_ticker()
self.context.requests_get.assert_called()
self.context.save_tickers.assert_not_called()
# Query Failure
self.context.requests_get.reset_mock()
self.context.requests_get.side_effect = Exception('test')
self.context.save_tickers.reset_mock()
self.target._process_ticker()
self.context.requests_get.assert_called_once()
self.context.save_tickers.assert_not_called()
def test__process_balance(self):
now = datetime.fromtimestamp(1234567890.123456, utc)
self.context.get_now = MagicMock(return_value=now)
self.context.save_balances = MagicMock()
self.target._query_private = MagicMock(
return_value=CryptowelderContext._parse("""
{
"success": 1,
"return": {
"funds": {
"jpy": 15320,
"btc": 1.389,
"xem": 100.2,
"mona": 2600,
"pepecash": 0.1
},
"deposit": {
"jpy": 20440,
"btc": 1.479,
"xem": 100.2,
"mona": 3200,
"pepecash": 0.1
},
"rights": {
"info": 1,
"trade": 1,
"withdraw": 0,
"personal_info": 0
},
"open_orders": 3,
"server_time": 1401950833
}
}
"""))
self.target._process_balance()
balances = self.context.save_balances.call_args[0][0]
self.assertEqual(2, len(balances))
self.assertEqual('zaif', balances[0].bc_site)
self.assertEqual('CASH', balances[0].bc_acct.name)
self.assertEqual('JPY', balances[0].bc_unit.name)
self.assertEqual('2014-06-05 06:47:13.000000 UTC',
balances[0].bc_time.strftime(self.FORMAT))
self.assertEqual(Decimal('15320'), balances[0].bc_amnt)
self.assertEqual('zaif', balances[1].bc_site)
self.assertEqual('CASH', balances[1].bc_acct.name)
self.assertEqual('BTC', balances[1].bc_unit.name)
self.assertEqual('2014-06-05 06:47:13.000000 UTC',
balances[1].bc_time.strftime(self.FORMAT))
self.assertEqual(Decimal('1.389'), balances[1].bc_amnt)
# Query Reject
self.target._query_private.reset_mock()
self.target._query_private.return_value = '{"success": 0}'
self.context.save_balances.reset_mock()
self.target._process_balance()
self.target._query_private.assert_called_once()
self.context.save_balances.assert_not_called()
# Query None
self.target._query_private.reset_mock()
self.target._query_private.return_value = None
self.context.save_balances.reset_mock()
self.target._process_balance()
self.target._query_private.assert_called_once()
self.context.save_balances.assert_not_called()
# Query Failure
self.target._query_private.reset_mock()
self.target._query_private.side_effect = Exception('test')
self.context.save_balances.reset_mock()
self.target._process_balance()
self.target._query_private.assert_called_once()
self.context.save_balances.assert_not_called()
def test__process_ticker(self):
self.context.save_tickers = MagicMock()
self.context.requests_get = MagicMock(
return_value=CryptowelderContext._parse("""
{
"prices": [
{
"instrument":"USD_JPY",
"time":"2013-06-21T17:49:02.475381Z",
"bid":97.618,
"ask":97.633
},
{
"instrument":"EUR_CAD",
"time":"2013-06-21T17:51:38.063560Z",
"bid":1.37489,
"ask":1.37517,
"status": "halted"
}
]
}
"""))
self.context.get_property = MagicMock(side_effect=['foo', 'bar'])
self.target._process_ticker()
tickers = self.context.save_tickers.call_args[0][0]
self.assertEqual(2, len(tickers))
self.assertEqual('oanda', tickers[0].tk_site)
self.assertEqual('2013-06-21 17:49:02.000000 UTC',
tickers[0].tk_time.strftime(self.FORMAT))
self.assertEqual('USD_JPY', tickers[0].tk_code)
self.assertEqual(Decimal('97.633'), tickers[0].tk_ask)
self.assertEqual(Decimal('97.618'), tickers[0].tk_bid)
self.assertEqual(None, tickers[0].tk_ltp)
self.assertEqual('oanda', tickers[1].tk_site)
self.assertEqual('2013-06-21 17:51:38.000000 UTC',
tickers[1].tk_time.strftime(self.FORMAT))
self.assertEqual('EUR_CAD', tickers[1].tk_code)
self.assertEqual(Decimal('1.37517'), tickers[1].tk_ask)
self.assertEqual(Decimal('1.37489'), tickers[1].tk_bid)
self.assertEqual(None, tickers[0].tk_ltp)
# Query Empty
self.context.get_property = MagicMock(side_effect=['foo', 'bar'])
self.context.requests_get.reset_mock()
self.context.requests_get.return_value = {}
self.context.save_tickers.reset_mock()
self.target._process_ticker()
self.context.requests_get.assert_called_once()
self.context.save_tickers.assert_called_once()
# Query None
self.context.get_property = MagicMock(side_effect=['foo', 'bar'])
self.context.requests_get.reset_mock()
self.context.requests_get.return_value = None
self.context.save_tickers.reset_mock()
self.target._process_ticker()
self.context.requests_get.assert_called_once()
self.context.save_tickers.assert_called_once()
# Query Failure
self.context.get_property = MagicMock(side_effect=['foo', 'bar'])
self.context.requests_get.reset_mock()
self.context.requests_get.side_effect = Exception('test')
self.context.save_tickers.reset_mock()
self.target._process_ticker()
self.context.requests_get.assert_called_once()
self.context.save_tickers.assert_not_called()
# No Token
self.context.get_property = MagicMock(return_value=None)
self.context.requests_get.reset_mock()
self.context.requests_get.side_effect = Exception('test')
self.context.save_tickers.reset_mock()
self.target._process_ticker()
self.context.requests_get.assert_not_called()
self.context.save_tickers.assert_not_called()
def test__process_transaction(self):
self.context.save_transactions = MagicMock(side_effect=[[None], []])
self.target._query_private = MagicMock(side_effect=[
CryptowelderContext._parse("""
[
{
"id": 37233,
"child_order_id": "JOR20150707-060559-021935",
"side": "BUY",
"price": 33470,
"size": 0.05,
"commission": 0.0001,
"exec_date": "2015-07-07T09:57:40.397",
"child_order_acceptance_id": "JRF20150707-060559-396699"
},
{
"id": 37232,
"child_order_id": "JOR20150707-060426-021925",
"side": "SELL",
"price": 33480,
"size": 0.05,
"commission": 0.0002,
"exec_date": "2015-07-07T09:57:41.398",
"child_order_acceptance_id": "JRF20150707-060559-396699"
}
]
"""), []
])
self.target._process_transaction('FOO_BAR')
self.target._query_private.assert_has_calls([
call('/v1/me/getexecutions?count=100&product_code=FOO_BAR'),
call(
'/v1/me/getexecutions?count=100&product_code=FOO_BAR&before=37232'
),
])
calls = self.context.save_transactions.call_args_list
self.assertEqual(2, len(calls))
# First Loop
transactions = calls[0][0][0]
self.assertEqual(2, len(transactions))
self.assertEqual('bitflyer', transactions[0].tx_site)
self.assertEqual('FOO_BAR', transactions[0].tx_code)
self.assertEqual(TransactionType.TRADE, transactions[0].tx_type)
self.assertEqual('JOR20150707-060559-021935', transactions[0].tx_oid)
self.assertEqual('37233', transactions[0].tx_eid)
self.assertEqual('2015-07-07 09:57:40.000000 UTC',
transactions[0].tx_time.strftime(self.FORMAT))
self.assertEqual(Decimal('0.0499'), transactions[0].tx_inst)
self.assertEqual(Decimal('-1673.5'), transactions[0].tx_fund)
self.assertEqual('bitflyer', transactions[1].tx_site)
self.assertEqual('FOO_BAR', transactions[1].tx_code)
self.assertEqual(TransactionType.TRADE, transactions[1].tx_type)
self.assertEqual('JOR20150707-060426-021925', transactions[1].tx_oid)
self.assertEqual('37232', transactions[1].tx_eid)
self.assertEqual('2015-07-07 09:57:41.000000 UTC',
transactions[1].tx_time.strftime(self.FORMAT))
self.assertEqual(Decimal('-0.0502'), transactions[1].tx_inst)
self.assertEqual(Decimal('1674.0'), transactions[1].tx_fund)
# Second Loop
transactions = calls[1][0][0]
self.assertEqual(0, len(transactions))
# Query None
self.target._query_private = MagicMock(return_value=None)
self.context.save_transactions.reset_mock()
self.target._process_transaction("FOO_BAR")
self.target._query_private.assert_called_once()
self.context.save_transactions.assert_not_called()
# Query Failure
self.target._query_private = MagicMock(side_effect=Exception('test'))
self.context.save_transactions.reset_mock()
self.target._process_transaction("FOO_BAR")
self.target._query_private.assert_called_once()
self.context.save_transactions.assert_not_called()
def test__process_cash(self):
now = datetime.fromtimestamp(1234567890.123456, utc)
self.context.get_now = MagicMock(return_value=now)
self.context.save_balances = MagicMock()
self.target._query_private = MagicMock(
return_value=CryptowelderContext._parse("""
[
{
"currency": "BTC",
"balance": "0.04925688"
},
{
"currency": "FOO",
"balance": "7.17696"
},
{
"currency": "JPY",
"balance": "356.01377"
}
]
"""))
self.target._process_cash()
balances = self.context.save_balances.call_args[0][0]
self.assertEqual(2, len(balances))
self.assertEqual('quoinex', balances[0].bc_site)
self.assertEqual('CASH', balances[0].bc_acct.name)
self.assertEqual('BTC', balances[0].bc_unit.name)
self.assertEqual('2009-02-13 23:31:30.123456 UTC',
balances[0].bc_time.strftime(self.FORMAT))
self.assertEqual('0.04925688', balances[0].bc_amnt)
self.assertEqual('quoinex', balances[1].bc_site)
self.assertEqual('CASH', balances[1].bc_acct.name)
self.assertEqual('JPY', balances[1].bc_unit.name)
self.assertEqual('2009-02-13 23:31:30.123456 UTC',
balances[1].bc_time.strftime(self.FORMAT))
self.assertEqual('356.01377', balances[1].bc_amnt)
# Query Reject
self.target._query_private.reset_mock()
self.target._query_private.return_value = '{"success": 0}'
self.context.save_balances.reset_mock()
self.target._process_cash()
self.target._query_private.assert_called_once()
self.context.save_balances.assert_not_called()
# Query None
self.target._query_private.reset_mock()
self.target._query_private.return_value = None
self.context.save_balances.reset_mock()
self.target._process_cash()
self.target._query_private.assert_called_once()
self.context.save_balances.assert_called_once()
# Query Failure
self.target._query_private.reset_mock()
self.target._query_private.side_effect = Exception('test')
self.context.save_balances.reset_mock()
self.target._process_cash()
self.target._query_private.assert_called_once()
self.context.save_balances.assert_not_called()
def test__process_ticker(self):
now = datetime.fromtimestamp(1234567890.123456, utc)
self.context.save_tickers = MagicMock()
self.context.requests_get = MagicMock(return_value=CryptowelderContext._parse("""
[
{
"symbol": ".BXBT",
"state": "Unlisted",
"referenceSymbol": ".BXBT",
"multiplier": null,
"lastPrice": 6789.1,
"bidPrice": null,
"askPrice": null,
"timestamp": "2018-04-14T12:34:56.789Z"
},
{
"symbol": ".BXBT30M",
"state": "Unlisted",
"referenceSymbol": ".BXBT",
"multiplier": -100000000,
"lastPrice": 89.1,
"bidPrice": 89.0,
"askPrice": 89.2,
"timestamp": "2018-04-14T02:34:56.789Z"
},
{
"symbol": "XBTM18",
"state": "Open",
"referenceSymbol": ".BXBT30M",
"multiplier": -100000000,
"lastPrice": 7890.1,
"bidPrice": 7890.0,
"askPrice": 7890.2,
"timestamp": "2018-04-14T01:23:45.678Z"
}
]
"""))
self.target._process_ticker()
tickers = self.context.save_tickers.call_args[0][0]
self.assertEqual(2, len(tickers))
self.assertEqual('bitmex', tickers[0].tk_site)
self.assertEqual('2018-04-14 12:34:56.000000 UTC', tickers[0].tk_time.strftime(self.FORMAT))
self.assertEqual('.BXBT', tickers[0].tk_code)
self.assertEqual(None, tickers[0].tk_ask)
self.assertEqual(None, tickers[0].tk_bid)
self.assertEqual(Decimal('6789.1'), tickers[0].tk_ltp)
self.assertEqual('bitmex', tickers[1].tk_site)
self.assertEqual('2018-04-14 01:23:45.000000 UTC', tickers[1].tk_time.strftime(self.FORMAT))
self.assertEqual('XBTM18', tickers[1].tk_code)
self.assertEqual(Decimal('7890.2'), tickers[1].tk_ask)
self.assertEqual(Decimal('7890.0'), tickers[1].tk_bid)
self.assertEqual(Decimal('7890.1'), tickers[1].tk_ltp)
# Query Blank
self.context.save_tickers.reset_mock()
self.context.requests_get.reset_mock()
self.context.requests_get.return_value = {}
self.target._process_ticker()
self.context.save_tickers.assert_called_once()
# Query Empty
self.context.save_tickers.reset_mock()
self.context.requests_get.reset_mock()
self.context.requests_get.return_value = None
self.target._process_ticker()
self.context.save_tickers.assert_not_called()
# Query Failure
self.context.save_tickers.reset_mock()
self.context.requests_get.reset_mock()
self.context.requests_get.side_effect = Exception('test')
self.target._process_ticker()
self.context.save_tickers.assert_not_called()
def test__process_position(self):
now = datetime.fromtimestamp(1234567890)
self.context.save_positions = MagicMock()
self.context.get_now = MagicMock(return_value=now)
self.target._query_private = MagicMock(
return_value=CryptowelderContext._parse("""
[
{
"product_code": "FOO_BAR",
"side": "BUY",
"price": 36000,
"size": 10,
"commission": 5,
"swap_point_accumulate": -35,
"require_collateral": 120000,
"open_date": "2015-11-03T10:04:45.011",
"leverage": 3,
"pnl": 965
},
{
"product_code": "HOGE_PIYO",
"side": "SELL",
"price": 12000,
"size": 3,
"commission": 2,
"swap_point_accumulate": -20,
"require_collateral": 100000,
"open_date": "2015-11-03T10:04:45.010",
"leverage": 10,
"pnl": -123
}
]
"""))
self.target._process_position('FX_BTC_JPY')
self.target._query_private.assert_called_once_with(
'/v1/me/getpositions?product_code=FX_BTC_JPY')
positions = self.context.save_positions.call_args[0][0]
self.assertEqual(1, len(positions))
self.assertEqual('bitflyer', positions[0].ps_site)
self.assertEqual('FX_BTC_JPY', positions[0].ps_code)
self.assertEqual(1234567890, positions[0].ps_time.timestamp())
self.assertEqual(Decimal('7'), positions[0].ps_inst)
self.assertEqual(Decimal('890'), positions[0].ps_fund)
# Not Margin Product
self.target._query_private.reset_mock()
self.target._process_position('BTC_JPY')
self.target._query_private.assert_not_called()
# Query None
self.target._query_private.reset_mock()
self.target._query_private.side_effect = [None]
self.context.save_positions.reset_mock()
self.target._process_position("FX_BTC_JPY")
self.target._query_private.assert_called_once()
self.context.save_positions.assert_not_called()
# Query Failure
self.target._query_private.reset_mock()
self.target._query_private.side_effect = Exception('test')
self.context.save_positions.reset_mock()
self.target._process_position("FX_BTC_JPY")
self.target._query_private.assert_called_once()
self.context.save_positions.assert_not_called()
def test__process_ticker(self):
now = datetime.fromtimestamp(1234567890.123456, utc)
self.context.get_now = MagicMock(return_value=now)
self.context.save_tickers = MagicMock()
self.context.requests_get = MagicMock(
return_value=CryptowelderContext._parse("""
{
"USDT_BTC": {
"id": 121,
"last": "6837.76161630",
"lowestAsk": "6847.96452531",
"highestBid": "6837.95942149",
"percentChange": "0.00322068",
"baseVolume": "16800887.95429000",
"quoteVolume": "2394.01850315",
"isFrozen": "0",
"high24hr": "7230.95559729",
"low24hr": "6790.00000400"
},
"BTC_BCH": {
"id": 189,
"last": "0.09980623",
"lowestAsk": "0.09986232",
"highestBid": "0.09980509",
"percentChange": "-0.02342240",
"baseVolume": "144.70806421",
"quoteVolume": "1458.21509325",
"isFrozen": "0",
"high24hr": "0.10245491",
"low24hr": "0.09791995"
},
"BTC_ETH": {
"id": 148,
"last": "0.05646514",
"lowestAsk": "0.05646514",
"highestBid": "0.05646490",
"percentChange": "-0.01688621",
"baseVolume": "926.77280825",
"quoteVolume": "16280.27386100",
"isFrozen": "0",
"high24hr": "0.05772499",
"low24hr": "0.05627504"
}
}
"""))
self.target._process_ticker()
tickers = self.context.save_tickers.call_args[0][0]
self.assertEqual(3, len(tickers))
for t in tickers:
self.assertEqual('poloniex', t.tk_site)
self.assertEqual('2009-02-13 23:31:30.123456 UTC',
t.tk_time.strftime(self.FORMAT))
self.assertEqual('USDT_BTC', tickers[0].tk_code)
self.assertEqual('6847.96452531', tickers[0].tk_ask)
self.assertEqual('6837.95942149', tickers[0].tk_bid)
self.assertEqual('6837.76161630', tickers[0].tk_ltp)
self.assertEqual('BTC_BCH', tickers[1].tk_code)
self.assertEqual('0.09986232', tickers[1].tk_ask)
self.assertEqual('0.09980509', tickers[1].tk_bid)
self.assertEqual('0.09980623', tickers[1].tk_ltp)
self.assertEqual('BTC_ETH', tickers[2].tk_code)
self.assertEqual('0.05646514', tickers[2].tk_ask)
self.assertEqual('0.05646490', tickers[2].tk_bid)
self.assertEqual('0.05646514', tickers[2].tk_ltp)
# Query Empty
self.context.requests_get.reset_mock()
self.context.requests_get.return_value = {}
self.context.save_tickers.reset_mock()
self.target._process_ticker()
self.context.requests_get.assert_called_once()
self.context.save_tickers.assert_called_once()
# Query None
self.context.requests_get.reset_mock()
self.context.requests_get.return_value = None
self.context.save_tickers.reset_mock()
self.target._process_ticker()
self.context.requests_get.assert_called_once()
self.context.save_tickers.assert_not_called()
# Query Failure
self.context.requests_get.reset_mock()
self.context.requests_get.side_effect = Exception('test')
self.context.save_tickers.reset_mock()
self.target._process_ticker()
self.context.requests_get.assert_called_once()
self.context.save_tickers.assert_not_called()
def test__process_transaction(self):
side_effects = [CryptowelderContext._parse("""
{
"success": true,
"transactions": [
{
"id": 38,
"order_id": 49,
"created_at": "2015-11-18T07:02:21.000Z",
"funds": {
"btc": "0.1",
"jpy": "-4096.135"
},
"pair": "btc_jpy",
"rate": "40900.0",
"fee_currency": "JPY",
"fee": "6.135",
"liquidity": "T",
"side": "buy"
},
{
"id": 37,
"order_id": 48,
"created_at": "2015-11-18T07:02:21.000Z",
"funds": {
"btc": "-0.1",
"jpy": "4094.09"
},
"pair": "btc_jpy",
"rate": "40900.0",
"fee_currency": "JPY",
"fee": "-4.09",
"liquidity": "M",
"side": "sell"
}
]
}
"""), CryptowelderContext._parse("""
{
"success": true,
"pagination": {
"limit": 1,
"order": "desc",
"starting_after": null,
"ending_before": null
},
"data": [
{
"id": 36,
"order_id": 49,
"created_at": "2015-11-18T07:02:21.000Z",
"funds": {
"btc": "0.1",
"jpy": "-4096.135"
},
"pair": "btc_jpy",
"rate": "40900.0",
"fee_currency": "JPY",
"fee": "6.135",
"liquidity": "T",
"side": "buy"
},
{
"id": 35,
"order_id": 48,
"created_at": "2015-11-18T07:02:21.000Z",
"funds": {
"btc": "-0.1",
"jpy": "4094.09"
},
"pair": "btc_jpy",
"rate": "40900.0",
"fee_currency": "JPY",
"fee": "-4.09",
"liquidity": "M",
"side": "sell"
}
]
}
"""), None]
# Query 3 times
self.target._query_private = MagicMock(side_effect=side_effects)
self.context.save_transactions = MagicMock(side_effect=([None], []))
self.target._process_transaction()
self.target._query_private.assert_called()
self.context.save_transactions.assert_called()
calls = self.context.save_transactions.call_args_list
self.assertEqual(2, len(calls))
values = list(calls[0][0][0])
self.assertEqual(2, len(values))
value = values[0]
self.assertEqual('coincheck', value.tx_site)
self.assertEqual('btc_jpy', value.tx_code)
self.assertEqual(TransactionType.TRADE, value.tx_type)
self.assertEqual(AccountType.CASH, value.tx_acct)
self.assertEqual('49', value.tx_oid)
self.assertEqual('38', value.tx_eid)
self.assertEqual('2015-11-18 07:02:21.000000 UTC', value.tx_time.strftime(self.FORMAT))
self.assertEqual('0.1', value.tx_inst)
self.assertEqual('-4096.135', value.tx_fund)
value = values[1]
self.assertEqual('coincheck', value.tx_site)
self.assertEqual('btc_jpy', value.tx_code)
self.assertEqual(TransactionType.TRADE, value.tx_type)
self.assertEqual(AccountType.CASH, value.tx_acct)
self.assertEqual('48', value.tx_oid)
self.assertEqual('37', value.tx_eid)
self.assertEqual('2015-11-18 07:02:21.000000 UTC', value.tx_time.strftime(self.FORMAT))
self.assertEqual('-0.1', value.tx_inst)
self.assertEqual('4094.09', value.tx_fund)
values = list(calls[1][0][0])
self.assertEqual(2, len(values))
value = values[0]
self.assertEqual('coincheck', value.tx_site)
self.assertEqual('btc_jpy', value.tx_code)
self.assertEqual(TransactionType.TRADE, value.tx_type)
self.assertEqual(AccountType.CASH, value.tx_acct)
self.assertEqual('49', value.tx_oid)
self.assertEqual('36', value.tx_eid)
self.assertEqual('2015-11-18 07:02:21.000000 UTC', value.tx_time.strftime(self.FORMAT))
self.assertEqual('0.1', value.tx_inst)
self.assertEqual('-4096.135', value.tx_fund)
value = values[1]
self.assertEqual('coincheck', value.tx_site)
self.assertEqual('btc_jpy', value.tx_code)
self.assertEqual(TransactionType.TRADE, value.tx_type)
self.assertEqual(AccountType.CASH, value.tx_acct)
self.assertEqual('48', value.tx_oid)
self.assertEqual('35', value.tx_eid)
self.assertEqual('2015-11-18 07:02:21.000000 UTC', value.tx_time.strftime(self.FORMAT))
self.assertEqual('-0.1', value.tx_inst)
self.assertEqual('4094.09', value.tx_fund)
# Empty Trades
self.target._query_private = MagicMock(return_value={"success": True})
self.context.save_transactions = MagicMock(side_effect=[[None], None])
self.target._process_transaction()
self.target._query_private.assert_called()
self.context.save_transactions.assert_called()
self.assertEqual(2, len(self.context.save_transactions.call_args_list))
self.assertEqual(0, len(self.context.save_transactions.call_args_list[0][0][0]))
self.assertEqual(0, len(self.context.save_transactions.call_args_list[1][0][0]))
# Failure Response
self.target._query_private = MagicMock(return_value=CryptowelderContext._parse("""
{
"success": 0,
"return": {
}
}
"""))
self.context.save_transactions = MagicMock(return_value=[None])
self.target._process_transaction()
self.target._query_private.assert_called_once()
self.context.save_transactions.assert_not_called()
# No Response
self.target._query_private = MagicMock(return_value=None)
self.context.save_transactions = MagicMock(return_value=[None])
self.target._process_transaction()
self.target._query_private.assert_called_once()
self.context.save_transactions.assert_not_called()
# Exception Response
self.target._query_private = MagicMock(side_effect=Exception('test'))
self.context.save_transactions = MagicMock(return_value=[None])
self.target._process_transaction()
self.target._query_private.assert_called_once()
self.context.save_transactions.assert_not_called()
def test__process_cash(self):
now = datetime.fromtimestamp(1234567890.123456, utc)
self.context.get_now = MagicMock(return_value=now)
self.context.save_balances = MagicMock()
self.context.requests_post = MagicMock(
return_value=CryptowelderContext._parse("""
{
"resultCode": "0",
"errors": null,
"rcBalanceList": [
{
"currencyCd": "JPY",
"decPlace": "0",
"cashBalance": "1.0000000000",
"availableCash": "2.0000000000",
"undeliveredAmount": "0",
"reservedWithdrawal": "0",
"ttbRate": null,
"rateDecPlace": null,
"jpyChange": "0.0000000000",
"currencyCd2": "JPY",
"decPlace2": "0"
},
{
"currencyCd": "USD",
"decPlace": "2",
"cashBalance": "3.0000000000",
"availableCash": "4.0000000000",
"undeliveredAmount": "0",
"reservedWithdrawal": null,
"ttbRate": "108.40",
"rateDecPlace": "2",
"jpyChange": "0",
"currencyCd2": "JPY",
"decPlace2": "0"
}
],
"totalLegalTenderJpy": "0.0000000000"
}
"""))
# No token
self.target._process_cash(None)
self.assertEqual(0, self.context.requests_post.call_count)
self.assertEqual(0, self.context.save_balances.call_count)
# With Token
self.target._process_cash('tkn')
self.assertEqual(1, self.context.requests_post.call_count)
self.assertEqual(1, self.context.save_balances.call_count)
balances = self.context.save_balances.call_args[0][0]
self.assertEqual(2, len(balances))
b = balances[0]
self.assertEqual('bitpoint', b.bc_site)
self.assertEqual('CASH', b.bc_acct.name)
self.assertEqual('JPY', b.bc_unit.name)
self.assertEqual('2009-02-13 23:31:30.123456 UTC',
b.bc_time.strftime(self.FORMAT))
self.assertEqual('1.0000000000', b.bc_amnt)
b = balances[1]
self.assertEqual('bitpoint', b.bc_site)
self.assertEqual('CASH', b.bc_acct.name)
self.assertEqual('USD', b.bc_unit.name)
self.assertEqual('2009-02-13 23:31:30.123456 UTC',
b.bc_time.strftime(self.FORMAT))
self.assertEqual('3.0000000000', b.bc_amnt)
# Error response
self.context.requests_post = MagicMock(
return_value=CryptowelderContext._parse("""
{
"error": "invalid_token",
"error_description": "Invalid access token: hoge"
}
"""))
self.target._fetch_token = MagicMock(return_value='hoge')
self.target._process_cash('tkn')
self.assertEqual(2, self.context.requests_post.call_count)
self.assertEqual(1, self.context.save_balances.call_count)
# No response
self.context.requests_post = MagicMock(return_value=None)
self.target._fetch_token = MagicMock(return_value='hoge')
self.target._process_cash('tkn')
self.assertEqual(1, self.context.requests_post.call_count)
self.assertEqual(1, self.context.save_balances.call_count)
def test__process_balance(self):
now = datetime.fromtimestamp(1234567890.123456, utc)
self.context.get_now = MagicMock(return_value=now)
self.context.get_property = MagicMock(return_value='hoge')
self.context.save_balances = MagicMock()
self.context.requests_get = MagicMock(side_effect=[
CryptowelderContext._parse("""
{
"accounts": [
{
"accountId" : 8954947,
"accountName" : "Primary",
"accountCurrency" : "USD",
"marginRate" : 0.05
},
{
"accountId" : 8954950,
"accountName" : "SweetHome",
"accountCurrency" : "CAD",
"marginRate" : 0.02
}
]
}
"""),
CryptowelderContext._parse("""
{
"accountId" : 8954947,
"accountName" : "Primary",
"balance" : 100000,
"unrealizedPl" : 2,
"realizedPl" : 4,
"marginUsed" : 8,
"marginAvail" : 100001,
"openTrades" : 16,
"openOrders" : 32,
"marginRate" : 0.05,
"accountCurrency" : "USD"
}
"""), None
])
self.target._process_balance()
balances = self.context.save_balances.call_args[0][0]
self.assertEqual(1, len(balances))
b = balances[0]
self.assertEqual('oanda', b.bc_site)
self.assertEqual('MARGIN', b.bc_acct.name)
self.assertEqual('USD', b.bc_unit.name)
self.assertEqual('2009-02-13 23:31:30.123456 UTC',
b.bc_time.strftime(self.FORMAT))
self.assertEqual(Decimal('100000'), b.bc_amnt)
# Query Empty
self.context.requests_get.reset_mock()
self.context.requests_get.side_effect = [{}, {}]
self.context.save_balances.reset_mock()
self.target._process_balance()
self.context.requests_get.assert_called_once()
self.context.save_balances.assert_called_once()
# Query None
self.context.requests_get.reset_mock()
self.context.requests_get.return_value = None
self.context.save_balances.reset_mock()
self.target._process_balance()
self.context.requests_get.assert_called_once()
self.context.save_balances.assert_called_once()
# Query Failure
self.context.requests_get.reset_mock()
self.context.requests_get.side_effect = Exception('test')
self.context.save_balances.reset_mock()
self.target._process_balance()
self.context.requests_get.assert_called_once()
self.context.save_balances.assert_not_called()
# No Token
self.context.get_property = MagicMock(return_value=None)
self.context.requests_get.reset_mock()
self.context.requests_get.side_effect = Exception('test')
self.context.save_balances.reset_mock()
self.target._process_balance()
self.context.requests_get.assert_not_called()
self.context.save_balances.assert_not_called()
def test__process_ticker(self):
now = datetime.fromtimestamp(1234567890.123456, utc)
self.context.save_tickers = MagicMock()
self.target._process_ticker(
now, 'BTCUSD',
CryptowelderContext._parse("""
[
{
"id": "5",
"product_type": "CurrencyPair",
"code": "CASH",
"name": " CASH Trading",
"market_ask": 800000.02,
"market_bid": 800000.01,
"indicator": -1,
"currency": "JPY",
"currency_pair_code": "BTCJPY",
"symbol": "¥",
"btc_minimum_withdraw": null,
"fiat_minimum_withdraw": null,
"pusher_channel": "product_cash_btcjpy_5",
"taker_fee": 0,
"maker_fee": 0,
"low_market_bid": "700000.1",
"high_market_ask": "900000.2",
"volume_24h": "7890.123456789123456789",
"last_price_24h": "800000.3",
"last_traded_price": "800000.4",
"last_traded_quantity": "0.123",
"quoted_currency": "JPY",
"base_currency": "BTC",
"disabled": false
},
{
"id": "1",
"product_type": "CurrencyPair",
"code": "CASH",
"name": " CASH Trading",
"market_ask": 7000.02,
"market_bid": 7000.01,
"indicator": 1,
"currency": "USD",
"currency_pair_code": "BTCUSD",
"symbol": "$",
"btc_minimum_withdraw": null,
"fiat_minimum_withdraw": null,
"pusher_channel": "product_cash_btcusd_1",
"taker_fee": 0,
"maker_fee": 0,
"low_market_bid": "6000.01",
"high_market_ask": "8000.02",
"volume_24h": "123.456789",
"last_price_24h": "7000.03",
"last_traded_price": "7000.04",
"last_traded_quantity": "0.00123",
"quoted_currency": "USD",
"base_currency": "BTC",
"disabled": false
}
]
"""))
tickers = self.context.save_tickers.call_args[0][0]
self.assertEqual(1, len(tickers))
self.assertEqual('quoinex', tickers[0].tk_site)
self.assertEqual('2009-02-13 23:31:30.123456 UTC',
tickers[0].tk_time.strftime(self.FORMAT))
self.assertEqual('BTCUSD', tickers[0].tk_code)
self.assertEqual(Decimal('7000.02'), tickers[0].tk_ask)
self.assertEqual(Decimal('7000.01'), tickers[0].tk_bid)
self.assertEqual(Decimal('7000.04'), tickers[0].tk_ltp)
# Query Blank
self.context.save_tickers.reset_mock()
self.target._process_ticker(now, 'BTCUSD',
[{
'currency_pair_code': 'BTCUSD'
}])
self.context.save_tickers.assert_called_once()
# Query Empty
self.context.save_tickers.reset_mock()
self.target._process_ticker(now, 'BTCUSD', {})
self.context.save_tickers.assert_not_called()
# Query None
self.context.save_tickers.reset_mock()
self.target._process_ticker(now, 'BTCUSD', None)
self.context.save_tickers.assert_not_called()
# Save Failure
self.context.save_tickers.reset_mock()
self.context.save_tickers.side_effect = Exception('test')
self.target._process_ticker(now, 'BTCUSD',
[{
'currency_pair_code': 'BTCUSD'
}])
self.context.save_tickers.assert_called_once()
def test__process_cash(self):
now = datetime.fromtimestamp(1234567890.123456, utc)
self.context.get_now = MagicMock(return_value=now)
self.context.save_balances = MagicMock()
self.target._query_private = MagicMock(return_value=CryptowelderContext._parse("""
{
"success": true,
"jpy": "0.8401",
"btc": "7.75052654",
"jpy_reserved": "3000.0",
"btc_reserved": "3.5002",
"jpy_lend_in_use": "0",
"btc_lend_in_use": "0.3",
"jpy_lent": "0",
"btc_lent": "1.2",
"jpy_debt": "0",
"btc_debt": "0"
}
"""))
self.target._process_cash()
balances = self.context.save_balances.call_args[0][0]
self.assertEqual(2, len(balances))
self.assertEqual('coincheck', balances[0].bc_site)
self.assertEqual('CASH', balances[0].bc_acct.name)
self.assertEqual('JPY', balances[0].bc_unit.name)
self.assertEqual('2009-02-13 23:31:30.123456 UTC', balances[0].bc_time.strftime(self.FORMAT))
self.assertEqual(Decimal('3000.8401'), balances[0].bc_amnt)
self.assertEqual('coincheck', balances[1].bc_site)
self.assertEqual('CASH', balances[1].bc_acct.name)
self.assertEqual('BTC', balances[1].bc_unit.name)
self.assertEqual('2009-02-13 23:31:30.123456 UTC', balances[1].bc_time.strftime(self.FORMAT))
self.assertEqual(Decimal('11.25072654'), balances[1].bc_amnt)
# Query Reject
self.target._query_private.reset_mock()
self.target._query_private.return_value = {'success': False}
self.context.save_balances.reset_mock()
self.target._process_cash()
self.target._query_private.assert_called_once()
self.context.save_balances.assert_not_called()
# Query Empty
self.target._query_private.reset_mock()
self.target._query_private.return_value = {}
self.context.save_balances.reset_mock()
self.target._process_cash()
self.target._query_private.assert_called_once()
self.context.save_balances.assert_called_once()
# Query None
self.target._query_private.reset_mock()
self.target._query_private.return_value = None
self.context.save_balances.reset_mock()
self.target._process_cash()
self.target._query_private.assert_called_once()
self.context.save_balances.assert_not_called()
# Query Failure
self.target._query_private.reset_mock()
self.target._query_private.side_effect = Exception('test')
self.context.save_balances.reset_mock()
self.target._process_cash()
self.target._query_private.assert_called_once()
self.context.save_balances.assert_not_called()
def main():
context = CryptowelderContext(config='~/.cryptowelder', debug=True)
context.launch_prometheus()
target = OandaWelder(context)
target.run()
def test__process_balance(self):
now = datetime.fromtimestamp(1234567890.123456, utc)
self.context.get_now = MagicMock(return_value=now)
self.context.save_balances = MagicMock()
self.target._query_private = MagicMock(return_value=CryptowelderContext._parse("""
{
"uid":8,
"nameauth":0,
"moflag":0,
"btc_balance":4234234,
"btc_lock":1,
"ltc_balance":32429.6,
"ltc_lock":2.4,
"eth_balance":2,
"eth_lock":0,
"jpy_balance":2344581.519,
"jpy_lock":868862.481,
"hoge_balance":8,
"hoge_lock":9
}
"""))
self.target._process_balance()
balances = self.context.save_balances.call_args[0][0]
self.assertEqual(4, len(balances))
map = {b.bc_unit.name: b for b in balances}
key = sorted(map.keys())
b = map[key[0]]
self.assertEqual('btcbox', b.bc_site)
self.assertEqual('CASH', b.bc_acct.name)
self.assertEqual('BTC', b.bc_unit.name)
self.assertEqual('2009-02-13 23:31:30.123456 UTC', b.bc_time.strftime(self.FORMAT))
self.assertEqual(Decimal('4234235'), b.bc_amnt)
b = map[key[1]]
self.assertEqual('btcbox', b.bc_site)
self.assertEqual('CASH', b.bc_acct.name)
self.assertEqual('ETH', b.bc_unit.name)
self.assertEqual('2009-02-13 23:31:30.123456 UTC', b.bc_time.strftime(self.FORMAT))
self.assertEqual(Decimal('2'), b.bc_amnt)
b = map[key[2]]
self.assertEqual('btcbox', b.bc_site)
self.assertEqual('CASH', b.bc_acct.name)
self.assertEqual('JPY', b.bc_unit.name)
self.assertEqual('2009-02-13 23:31:30.123456 UTC', b.bc_time.strftime(self.FORMAT))
self.assertEqual(Decimal('3213444.000'), b.bc_amnt)
b = map[key[3]]
self.assertEqual('btcbox', b.bc_site)
self.assertEqual('CASH', b.bc_acct.name)
self.assertEqual('LTC', b.bc_unit.name)
self.assertEqual('2009-02-13 23:31:30.123456 UTC', b.bc_time.strftime(self.FORMAT))
self.assertEqual(Decimal('32432.0'), b.bc_amnt)
# Query Empty
self.target._query_private.reset_mock()
self.target._query_private.return_value = {}
self.context.save_balances.reset_mock()
self.target._process_balance()
self.target._query_private.assert_called_once()
self.context.save_balances.assert_called_once()
# Query Reject
self.target._query_private.reset_mock()
self.target._query_private.return_value = CryptowelderContext._parse("""
{
"result":false
}
""")
self.context.save_balances.reset_mock()
self.target._process_balance()
self.target._query_private.assert_called_once()
self.context.save_balances.assert_not_called()
# Query None
self.target._query_private.reset_mock()
self.target._query_private.return_value = None
self.context.save_balances.reset_mock()
self.target._process_balance()
self.target._query_private.assert_called_once()
self.context.save_balances.assert_not_called()
# Query Failure
self.target._query_private.reset_mock()
self.target._query_private.side_effect = Exception('test')
self.context.save_balances.reset_mock()
self.target._process_balance()
self.target._query_private.assert_called_once()
self.context.save_balances.assert_not_called()
