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