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()