def test_indicator_frame_set(self, indicator_mock):
indicator_mock.ref = "test_indicator_ref"
fs = FrameSetFactory()
fs.add_indicator(indicator_mock)
assert indicator_mock.set_frame_set.call_args_list == [call(fs)]
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_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_set_as_indicator(self, indicator_mock):
indicator_mock.ref = "test_indicator_ref"
fs = FrameSetFactory()
fs.add_indicator(indicator_mock)
assert fs.indicators == {"test_indicator_ref": indicator_mock}
def test_epic_market_open(self, market_open):
fs = FrameSetFactory()
epic = EpicFactory()
epic.market_open = market_open
fs.epic = epic
assert fs.epic_market_open == market_open
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_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_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_apply_frames_limit(self, mocker):
fs = FrameSetFactory(max_frames_in_memory=3)
frame_mock = mocker.Mock()
frame_mock.previous_frame = "test"
for frame_idx in range(10):
fs.frames.append(frame_mock)
fs.clean_old_frames()
assert len(fs.frames) == 3
def test_keep_only_last_frames(self, mocker):
fs = FrameSetFactory(max_frames_in_memory=3)
for frame_idx in range(10):
frame_mock = mocker.Mock()
frame_mock.previous_frame = "test"
frame_mock.idx = frame_idx
fs.frames.append(frame_mock)
fs.clean_old_frames()
assert [frame.idx for frame in fs.frames] == [7, 8, 9]
def test_nominal(self, mocker, frame_end, tick_datetime,
expected_response):
frame_mock = mocker.Mock(spec=Frame)
frame_mock.period_end = arrow.get(frame_end)
mocker.patch(
f"{CLASS_DEFINITION_PATH}.current",
new_callable=lambda: frame_mock,
)
fs = FrameSetFactory()
tick = TickFactory(datetime=arrow.get(tick_datetime))
assert fs.is_frame_over_timed(tick) == expected_response
def test_add_tick_to_last_call(self, mocker, mock_is_frame_over_tick):
mock_is_frame_over_tick.return_value = False
fs = FrameSetFactory(unit=Unit.TICK)
add_tick_to_last_mock = mocker.patch.object(fs,
"add_tick_to_last",
wraps=fs.add_tick_to_last)
tick = TickFactory()
fs.on_new_tick(tick)
assert add_tick_to_last_mock.call_args_list == [call(tick)]
def test_indicators_not_empty(self, mocker):
epic_mock = mocker.Mock()
epic_mock.market_open = True
parent_framset = FrameSetFactory()
indicator_mock = mocker.Mock()
indicator_mock.ref = "my_indicator_ref"
indicator_mock.build_value_from_frame.return_value = "indicator_value"
parent_framset.epic = epic_mock
parent_framset.add_indicator(indicator_mock)
fr = FrameFactory(parent_frameset=parent_framset)
assert fr.indicators == {"my_indicator_ref": "indicator_value"}
def test_create_new_frame_call__no_gap(self, mocker):
create_new_frame_mock = mocker.patch(
f"{CLASS_DEFINITION_PATH}.create_new_frame", )
fs = FrameSetFactory(unit=Unit.SECOND, unit_quantity=10)
tick = TickFactory(datetime=arrow.get("2020-01-01 12:34:56"))
fs.on_new_tick(tick)
assert create_new_frame_mock.call_args_list == [
call(tick, arrow.get("2020-01-01 12:34:50"),
arrow.get("2020-01-01 12:35:00"))
]
def test_nominal(self, mocker):
frame_mock = mocker.Mock(spec=Frame)
mocker.patch(
f"{CLASS_DEFINITION_PATH}.current",
new_callable=lambda: frame_mock,
)
fs = FrameSetFactory()
tick = TickFactory()
fs.add_tick_to_last(tick)
assert frame_mock.on_new_tick.call_args_list == [call(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_create_new_frame_call(self, mocker, mock_is_frame_over_tick):
mock_is_frame_over_tick.return_value = True
fs = FrameSetFactory(unit=Unit.TICK)
create_new_frame_mock = mocker.patch.object(fs,
"create_new_frame",
wraps=fs.create_new_frame)
tick = TickFactory()
fs.on_new_tick(tick)
assert create_new_frame_mock.call_args_list == [
call(tick=tick, period_start=tick.datetime, period_end=None)
]
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_set_new_as_current_next(self, mocker):
mock_current = mocker.Mock()
mocker.patch(
f"{CLASS_DEFINITION_PATH}.current",
new_callable=lambda: mock_current,
)
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 mock_current.next_frame == "my_new_frame"
def test_frame_init__minimal(self, mock_frame_init):
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_frame_init.call_args_list == [
call(
parent_frameset=fs,
first_tick=tick,
period_start=period_start,
period_end=None,
previous_frame=None,
)
]
def test_nominal(self):
indicator = BaseIndicatorFactory()
frame_set = FrameSetFactory()
indicator.set_frame_set(frame_set)
assert indicator.frame_set == frame_set
def test_timeframe_mixin_call(self, mocker):
mixin_init_mock = mocker.patch.object(TimeframeMixin,
"__init__",
wraps=TimeframeMixin.__init__)
fs = FrameSetFactory(unit=Unit.SECOND, unit_quantity=30)
assert mixin_init_mock.call_args_list == [call(fs, Unit.SECOND, 30)]
def test_ref_mixin_call(self, mocker):
mixin_init_mock = mocker.patch.object(RefMixin,
"__init__",
wraps=RefMixin.__init__)
fs = FrameSetFactory(ref="test_ref")
assert call(fs, "test_ref") in mixin_init_mock.call_args_list
def test_set_frame_set(self, mocker):
parent_method = mocker.patch(
"estrade.graph.base_indicator.BaseIndicator.set_frame_set",
return_value=None,
)
rsi = RSIFactory(periods=7)
frame_set = FrameSetFactory(unit_quantity=5, max_frames_in_memory=35)
rsi.set_frame_set(frame_set)
assert parent_method.call_args_list == [call(frame_set)]
def test_indicators_on_new_tick_called__indicator_none(
self, mocker, market_open):
epic_mock = mocker.Mock()
epic_mock.market_open = market_open
parent_framset = FrameSetFactory()
indicator_mock = mocker.Mock()
indicator_mock.ref = "my_indicator_ref"
parent_framset.epic = epic_mock
parent_framset.add_indicator(indicator_mock)
fr = FrameFactory(parent_frameset=parent_framset)
fr.indicators = {"my_indicator_ref": None}
tick = TickFactory()
fr.on_new_tick(tick)
assert indicator_mock.build_value_from_frame.call_args_list == [
call(fr, market_open), # call on Frame Init
call(fr, market_open),
]
def test_create_new_frame_call__gap(self, mocker):
fs = FrameSetFactory(unit=Unit.SECOND, unit_quantity=10)
create_new_frame_mock = mocker.patch.object(fs,
"create_new_frame",
wraps=fs.create_new_frame)
current_last_tick = TickFactory()
current_frame = FrameFactory(
first_tick=current_last_tick,
period_start=arrow.get("2020-01-01 12:34:10"),
period_end=arrow.get("2020-01-01 12:34:20"),
)
fs.frames = [current_frame]
new_tick = TickFactory(datetime=arrow.get("2020-01-01 12:34:56"))
fs.on_new_tick(new_tick)
assert create_new_frame_mock.call_args_list == [
call(
current_last_tick,
arrow.get("2020-01-01 12:34:20"),
arrow.get("2020-01-01 12:34:30"),
),
call(
current_last_tick,
arrow.get("2020-01-01 12:34:30"),
arrow.get("2020-01-01 12:34:40"),
),
call(
current_last_tick,
arrow.get("2020-01-01 12:34:40"),
arrow.get("2020-01-01 12:34:50"),
),
call(
new_tick,
arrow.get("2020-01-01 12:34:50"),
arrow.get("2020-01-01 12:35:00"),
),
]
def test_previous_frame(self, mocker, mock_frame_init):
mock_current = mocker.Mock()
mock_current.next_frame = None
mocker.patch(
f"{CLASS_DEFINITION_PATH}.current",
new_callable=lambda: mock_current,
)
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_frame_init.call_args_list == [
call(
parent_frameset=fs,
first_tick=tick,
period_start=period_start,
period_end=None,
previous_frame=mock_current,
)
]
def test_indicators__default(self):
fs = FrameSetFactory()
assert fs.indicators == {}
def test_frames__default(self):
fs = FrameSetFactory()
assert fs.frames == []
def test_max_frames_in_memory__manual(self):
fs = FrameSetFactory(max_frames_in_memory=23)
assert fs.max_frames_in_memory == 23
