def test__init__end_date_smaller_than_start_date(self):
with self.assertRaises(ValueError) as e:
Timeframe(pd_start_date=pd_ts('2017-02-01'),
pd_end_date=pd_ts('2017-01-01'),
pd_timedelta=pandas.Timedelta(minutes=1))
self.assertEqual(str(e.exception),
'Timeframe: end date is smaller then start date')
async def test__create_exchange__default_exchange_backend_parameters(
self, async_init_mock, base_init_mock, exchange_backend):
base_init_mock.return_value = None
async_init_mock.return_value = None
timeframe = Timeframe(pd_start_date=pd_ts('2017-01-01 1:00'),
pd_end_date=pd_ts('2017-01-01 1:03'),
pd_interval=pandas.Timedelta(minutes=1))
backtest = BacktestContext(timeframe=timeframe)
# Create two instances, to see if they get the same backend
backtest.create_exchange('binance', {'some': 'test'}, async_ccxt=True)
async_init_mock.assert_called_once_with(
config={'some': 'test'},
exchange_backend=exchange_backend.return_value)
exchange = backtest.create_exchange('binance', {'some': 'test'})
self.assertEqual(exchange.__class__.__bases__,
(BacktestExchangeBase, ccxt.binance))
exchange_backend.assert_called_once_with(timeframe=timeframe)
self.assertEqual(base_init_mock.mock_calls, [
call(config={'some': 'test'},
exchange_backend=exchange_backend.return_value)
])
self.assertEqual(async_init_mock.mock_calls, [
call(config={'some': 'test'},
exchange_backend=exchange_backend.return_value)
])
def test__execute_algorithm(self, kraken_currencies, kraken_markets,
okex_markets):
okex_markets.side_effect = fetch_markets_return([ETH_BTC_MARKET])
kraken_markets.side_effect = fetch_markets_return([BTC_USD_MARKET])
kraken_currencies.return_value = []
result = execute_algorithm(exchange_names=['kraken', 'okex'],
symbols=[],
live=False,
auth_aliases={},
AlgorithmClass=TestAlgo,
args=self,
start_balances={
'okex': {
'ETH': 3
},
'kraken': {
'USD': 100
}
},
pd_start_date=pd_ts('2019-10-01 10:10'),
pd_end_date=pd_ts('2019-10-01 10:16'),
pd_interval=pandas.Timedelta(minutes=2),
data_dir=data_dir)
self.assertEqual(result.args, self)
assert_test_algo_result(self, result)
def test__init__timedelta_negative(self):
with self.assertRaises(ValueError) as e:
Timeframe(pd_start_date=pd_ts('2017-01-01 1:00'),
pd_end_date=pd_ts('2017-01-01 1:03'),
pd_timedelta=pandas.Timedelta(minutes=-1))
self.assertEqual(str(e.exception),
'Timeframe: timedelta needs to be positive')
def test__date(self):
t = Timeframe(pd_start_date=pd_ts('2017-01-01 1:00'),
pd_end_date=pd_ts('2017-01-01 1:35'),
pd_interval=pandas.Timedelta(minutes=1))
backtest = BacktestContext(timeframe=t)
self.assertEqual(backtest.date(), pd_ts('2017-01-01 1:00'))
t.add_timedelta()
self.assertEqual(backtest.date(), pd_ts('2017-01-01 1:01'))
def test__date(self):
t = Timeframe(pd_start_date=pd_ts('2017-01-01 1:00'),
pd_end_date=pd_ts('2017-01-01 1:35'),
pd_interval=pandas.Timedelta(minutes=1))
context = LiveContext(timeframe=t, conf_dir='')
self.assertEqual(context.date(), pd_ts('2017-01-01 1:00'))
t.add_timedelta()
self.assertEqual(context.date(), pd_ts('2017-01-01 1:01'))
def test__different_timedelta(self):
t = Timeframe(pd_start_date=pd_ts('2017-01-01 1:00'),
pd_end_date=pd_ts('2017-01-01 1:35'),
pd_timedelta=pandas.Timedelta(minutes=15))
t.add_timedelta()
self.assertEqual(t.date(), pd_ts('2017-01-01 1:15'))
t.add_timedelta()
self.assertEqual(t.date(), pd_ts('2017-01-01 1:30'))
t.add_timedelta()
self.assertEqual(t.date(), None)
def test__different_timedelta(self):
t = Timeframe(pd_start_date=pd_ts('2017-01-01 1:00'),
pd_end_date=pd_ts('2017-01-01 1:35'),
pd_interval=pandas.Timedelta(minutes=15))
t.add_timedelta()
self.assertEqual(t.date(), pd_ts('2017-01-01 1:15'))
t.add_timedelta()
self.assertEqual(t.date(), pd_ts('2017-01-01 1:30'))
self.assertEqual(t.finished(), False)
t.add_timedelta()
self.assertEqual(t.finished(), True)
self.assertEqual(t.date(), pd_ts('2017-01-01 1:35'))
def test__execute_algorithm(self):
result = execute_algorithm(exchange_names=['kraken', 'okex3'],
symbols=[],
AlgorithmClass=TestAlgo,
args=self,
live=False,
auth_aliases={},
start_balances={'okex3': {'ETH': 3},
'kraken': {'USD': 100}},
pd_start_date=pd_ts('2019-10-01 10:10'),
pd_end_date=pd_ts('2019-10-01 10:16'),
pd_timedelta=pandas.Timedelta(minutes=2),
data_dir=data_dir)
self.assertEqual(result.args, self)
assert_test_algo_result(self, result)
def template__main_loop__exit_exception_during_sleep(
self, exception_class, log_str, sleep_mock):
algorithm = Mock(spec=AlgorithmBase)
sleep_mock.side_effect = [exception_class('aa')]
# We need to use future dates, because we are in live mode
timeframe = Timeframe(pd_start_date=pd_ts('2217-01-01 1:00'),
pd_end_date=pd_ts('2217-01-01 1:03'),
pd_interval=pandas.Timedelta(minutes=1))
with self.assertLogs('btrccts') as cm:
result = main_loop(timeframe=timeframe,
algorithm=algorithm,
live=True)
self.assertEqual(
algorithm.mock_calls,
[call.next_iteration(),
call.exit(reason=ExitReason.STOPPED)])
self.assertEqual(cm.output,
['INFO:btrccts:Starting main_loop', log_str])
self.assertEqual(algorithm, result)
def run_test(self, Algo):
with self.assertLogs('btrccts'):
result = execute_algorithm(exchange_names=['kraken', 'okex'],
symbols=[],
live=False,
auth_aliases={},
AlgorithmClass=Algo,
args=self,
start_balances={
'okex': {
'ETH': 3
},
'kraken': {
'USD': 100
}
},
pd_start_date=pd_ts('2019-10-01 10:10'),
pd_end_date=pd_ts('2019-10-01 10:16'),
pd_interval=pandas.Timedelta(minutes=2),
data_dir=data_dir)
return result
def template__parse_params_and_execute_algorithm__check_call(
self, execute_algorithm, argv_params, check_params):
sys_argv = self.create_sys_argv(argv_params)
execute_algorithm.side_effect = execute_algorithm_return_args
with patch.object(sys, 'argv', sys_argv):
args = parse_params_and_execute_algorithm(TestAlgo)
params = {
'AlgorithmClass': TestAlgo,
'args': args,
'data_dir': data_dir,
'conf_dir': config_dir,
'exchange_names': ['kraken'],
'pd_end_date': pd_ts('2009-01-01 00:00:00+0000'),
'pd_start_date': pd_ts('2001-01-01 00:00:00+0000'),
'pd_interval': pandas.Timedelta('0 days 00:01:00'),
'start_balances': {},
'live': False,
'auth_aliases': {},
'symbols': ['BTC/USD'],
}
params.update(check_params)
execute_algorithm.assert_called_once_with(**params)
def test__add_timedelta__date(self):
t = Timeframe(pd_start_date=pd_ts('2017-01-01 1:00'),
pd_end_date=pd_ts('2017-01-01 1:03'),
pd_interval=pandas.Timedelta(minutes=1))
self.assertEqual(t.date(), pd_ts('2017-01-01 1:00'))
# should return the same value
self.assertEqual(t.date(), pd_ts('2017-01-01 1:00'))
t.add_timedelta()
self.assertEqual(t.date(), pd_ts('2017-01-01 1:01'))
t.add_timedelta()
t.add_timedelta()
self.assertEqual(t.date(), pd_ts('2017-01-01 1:03'))
self.assertEqual(t.finished(), False)
t.add_timedelta()
self.assertEqual(t.finished(), True)
self.assertEqual(t.date(), pd_ts('2017-01-01 1:03'))
def setUp(self):
self.timeframe = Timeframe(pd_start_date=pd_ts('2017-01-01 1:00'),
pd_end_date=pd_ts('2017-01-01 1:03'),
pd_interval=pandas.Timedelta(minutes=1))
def test__add_timedelta_until__add_multiple_times(self):
t = Timeframe(pd_start_date=pd_ts('2017-01-01 1:00'),
pd_end_date=pd_ts('2017-01-01 2:35'),
pd_timedelta=pandas.Timedelta(minutes=15))
t.add_timedelta_until(pd_ts('2017-01-01 2:31'))
self.assertEqual(t.date(), pd_ts('2017-01-01 2:30'))
def test__end_date(self):
t = Timeframe(pd_start_date=pd_ts('2017-01-01 1:00'),
pd_end_date=pd_ts('2017-01-01 1:35'),
pd_timedelta=pandas.Timedelta(minutes=15))
self.assertEqual(t.end_date(), pd_ts('2017-01-01 1:35'))
def test__add_timedelta_until__single(self):
t = Timeframe(pd_start_date=pd_ts('2017-01-01 1:00'),
pd_end_date=pd_ts('2017-01-01 2:35'),
pd_interval=pandas.Timedelta(minutes=15))
t.add_timedelta_until(pd_ts('2017-01-01 1:29'))
self.assertEqual(t.date(), pd_ts('2017-01-01 1:15'))
