def test_update_high_tick(self):
fr = FrameFactory()
fr.high_tick = TickFactory(bid=99, ask=101)
new_high = TickFactory(bid=100, ask=102)
fr.on_new_tick(new_high)
assert fr.high_tick == new_high
def test_update_low_tick(self):
fr = FrameFactory()
fr.low_tick = TickFactory(bid=99, ask=101)
new_low = TickFactory(bid=98, ask=100)
fr.on_new_tick(new_low)
assert fr.low_tick == new_low
def test_anterior_tick(self):
epic = EpicFactory()
last_tick = TickFactory(datetime=arrow.get("2020-01-01 12:34:56"))
epic.last_tick = last_tick
new_tick = TickFactory(datetime=arrow.get("2020-01-01 12:34:55"))
with pytest.raises(EpicException):
epic.on_new_tick(new_tick)
def test_convert_to_dict():
tick = TickFactory()
tick_dict = tick.asdict()
assert tick_dict == {
"datetime": tick.datetime,
"bid": tick.bid,
"ask": tick.ask,
"spread": tick.spread,
"value": tick.value,
}
def test_update_low_tick(self, mocker):
biv = BaseIndicatorValueFactory()
parent_indicator_mock = mocker.Mock()
parent_indicator_mock.market_open_only = False
biv.indicator = parent_indicator_mock
current_low_tick = TickFactory(bid=99, ask=101)
biv.low_tick = current_low_tick
tick = TickFactory(bid=98, ask=101)
biv.on_new_tick(tick, True)
assert biv.low_tick == tick
def test_on_day_change(self, mocker):
frame_mock = mocker.Mock(spec=Frame)
frame_mock.nb_ticks = 1
mocker.patch(
f"{CLASS_DEFINITION_PATH}.current",
new_callable=lambda: frame_mock,
)
fs = FrameSetFactory(unit_quantity=3)
fs.epic.last_tick = TickFactory(
datetime=arrow.get("2020-01-01 23:59:59"))
new_tick = TickFactory(datetime=arrow.get("2020-01-02 00:00:00"))
assert fs.is_frame_over_tick(new_tick) is True
def test_nominal(self, mocker, current_nb_ticks, tick_datetime,
expected_response):
frame_mock = mocker.Mock(spec=Frame)
frame_mock.nb_ticks = current_nb_ticks
mocker.patch(
f"{CLASS_DEFINITION_PATH}.current",
new_callable=lambda: frame_mock,
)
fs = FrameSetFactory(unit_quantity=3)
fs.epic.last_tick = TickFactory(
datetime=arrow.get("2020-01-01 12:34:56"))
new_tick = TickFactory(datetime=arrow.get(tick_datetime))
assert fs.is_frame_over_tick(new_tick) == expected_response
def test_update_last_tick(self):
tick = TickFactory()
fr = FrameFactory()
fr.on_new_tick(tick)
assert fr.last_tick == tick
def test_no_current(self, mocker):
mocker.patch(f"{CLASS_DEFINITION_PATH}.current",
new_callable=lambda: None)
fs = FrameSetFactory()
tick = TickFactory()
assert fs.is_frame_over_tick(tick) is True
def test_is_frame_over_tick_call(self, mock_is_frame_over_tick):
fs = FrameSetFactory(unit=Unit.TICK)
tick = TickFactory()
fs.on_new_tick(tick)
assert mock_is_frame_over_tick.call_args_list == [call(tick)]
def test_nominal(self, mock_update, direction, expected_current):
trade: Trade = TradeFactory(direction=direction)
tick = TickFactory(bid=99, ask=100)
trade.update_from_tick(tick)
mock_update.assert_called_once_with(expected_current)
def test_kwargs(self, mock_init_trade):
default_trade_args, _ = TradeFactory.get_default_args()
Trade.open_from_tick(tick=TickFactory(),
ref="test",
**default_trade_args)
assert mock_init_trade.call_count == 1
assert mock_init_trade.call_args_list[0][1]["ref"] == "test"
def test_close_value(self, mock_trade_close):
tick = TickFactory()
trade = TradeFactory()
trade.current_close_value = 87.9
trade.close_from_tick(tick)
assert mock_trade_close.call_count == 1
assert mock_trade_close.call_args_list[0][1]["close_value"] == 87.9
def test_clean_old_frames(self, mock_clean_old_frames):
tick = TickFactory()
period_start = arrow.get("2020-01-01 12:35:00")
fs = FrameSetFactory()
fs.create_new_frame(tick=tick, period_start=period_start)
assert mock_clean_old_frames.call_args_list == [call()]
def test_kwargs(self, mock_trade_close):
tick = TickFactory()
trade = TradeFactory()
trade.close_from_tick(tick, test_arg="test_value")
assert mock_trade_close.call_count == 1
assert mock_trade_close.call_args_list[0][1][
"test_arg"] == "test_value"
def test_datetime(self, mock_trade_close):
dt = arrow.get("2020-01-01 12:34:56")
tick = TickFactory(datetime=dt)
trade = TradeFactory()
trade.close_from_tick(tick)
assert mock_trade_close.call_count == 1
assert mock_trade_close.call_args_list[0][1]["datetime"] == dt
def test_update_last_tick(
self, mocker, market_open_only, market_open, expected_last_tick_update
):
biv = BaseIndicatorValueFactory()
parent_indicator_mock = mocker.Mock()
parent_indicator_mock.market_open_only = market_open_only
biv.indicator = parent_indicator_mock
current_last_tick = TickFactory()
biv.last_tick = current_last_tick
tick = TickFactory()
biv.on_new_tick(tick, market_open)
if expected_last_tick_update:
assert biv.last_tick == tick
else:
assert biv.last_tick == current_last_tick
def test_epic(self, mock_init_trade):
tick = TickFactory()
default_trade_args, _ = TradeFactory.get_default_args()
Trade.open_from_tick(tick=tick, **default_trade_args)
assert mock_init_trade.call_count == 1
assert (mock_init_trade.call_args_list[0][1]["epic"] ==
default_trade_args["epic"])
def test_response(self, mocker):
mocker.patch(f"{CLASS_TRADE_DEFINITION_PATH}.close",
return_value="test_close")
tick = TickFactory()
trade = TradeFactory()
response = trade.close_from_tick(tick)
assert response == "test_close"
def test_parent__call(self, mocker):
parent_on_new_tick = mocker.patch(
"estrade.graph.base_indicator.BaseIndicatorValue.on_new_tick")
bc = BaseCandleFactory()
new_tick = TickFactory()
bc.on_new_tick(new_tick)
assert parent_on_new_tick.call_args_list == [call(new_tick)]
def test_parent__call(self, mocker):
parent_on_new_tick = mocker.patch(
"estrade.graph.base_indicator.BaseIndicatorValue.on_new_tick"
)
rsiv = RSIValueFactory()
new_tick = TickFactory()
rsiv.on_new_tick(new_tick, True)
assert parent_on_new_tick.call_args_list == [call(new_tick, True)]
def test_add_to_last_tick(self, mocker, mock_is_frame_over_timed):
mock_is_frame_over_timed.return_value = False
add_tick_to_last_mock = mocker.patch(
f"{CLASS_DEFINITION_PATH}.add_tick_to_last", )
fs = FrameSetFactory(unit=Unit.SECOND)
tick = TickFactory()
fs.on_new_tick(tick)
assert add_tick_to_last_mock.call_args_list == [call(tick)]
def test_open_datetime(self, mock_init_trade):
tick_datetime = arrow.get("2020-01-01 12:34:56")
tick = TickFactory(datetime=tick_datetime)
default_trade_args, _ = TradeFactory.get_default_args()
Trade.open_from_tick(tick=tick, **default_trade_args)
assert mock_init_trade.call_count == 1
assert (mock_init_trade.call_args_list[0][1]["open_datetime"] ==
tick_datetime)
def test_call_close_from_tick(self, mock_close_from_tick):
epic = EpicFactory()
trade = TradeFactory(epic=epic)
last_tick = TickFactory()
epic.last_tick = last_tick
trade.close_from_epic()
assert mock_close_from_tick.call_args_list == [call(last_tick)]
def test_add_to_frames(self, mocker):
mocker.patch(f"{CLASS_FRAME_DEFINITION_PATH}",
return_value="my_new_frame")
tick = TickFactory()
period_start = arrow.get("2020-01-01 12:35:00")
fs = FrameSetFactory()
fs.create_new_frame(tick=tick, period_start=period_start)
assert fs.frames == ["my_new_frame"]
def test_parent__call(self, mocker):
parent_on_new_tick = mocker.patch(
"estrade.graph.base_indicator.BaseIndicatorValue.on_new_tick"
)
smav = SimpleMovingAverageValueFactory()
new_tick = TickFactory()
smav.on_new_tick(new_tick, True)
assert parent_on_new_tick.call_args_list == [call(new_tick, True)]
def test_update_extended_closes(self):
smav = SimpleMovingAverageValueFactory()
smav.last_closes = [1, 2, 3]
new_tick = TickFactory(bid=3, ask=5)
smav.frame.last_tick = new_tick
smav.on_new_tick(new_tick, True)
assert smav.extended_closes == [1, 2, 3, 4]
def test_convert_tick_datetime(self):
epic = EpicFactory(timezone="Asia/Tokyo")
tz_NY = pytz.timezone("America/New_York")
datetime_NY = datetime.now(tz_NY)
tick = TickFactory(datetime=datetime_NY)
epic.on_new_tick(tick)
# datetime is converted to epic timezone
assert epic.last_tick.datetime.tzinfo == tz.gettz(epic.timezone)
def test_update_trades(self, mocker):
epic = EpicFactory()
trade = TradeFactory(direction=TradeDirection.BUY, quantity=4, epic=epic)
epic.trade_provider.open_trade(trade)
trade_update_mock = mocker.patch.object(trade, "update_from_tick")
new_tick = TickFactory()
epic.on_new_tick(new_tick)
assert trade_update_mock.call_args_list == [call(new_tick)]
def test_update_frame_sets(self, mocker):
epic = EpicFactory()
frame_set_mock = mocker.Mock()
epic.frame_sets["test"] = frame_set_mock
new_tick = TickFactory()
epic.on_new_tick(new_tick)
assert frame_set_mock.on_new_tick.call_args_list == [call(new_tick)]
