adelorenzo/stable
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Fixed some breaking tests

Browse Source
This commit is contained in:
Sam Germain 2021-10-11 08:26:15 -06:00
parent 81cf4653a9
commit 2e7adb99da
1 changed files with 32 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

70
tests/test_freqtradebot.py
View File

@ -203,13 +203,11 @@ def test_edge_overrides_stake_amount(mocker, edge_conf) -> None:
'LTC/BTC', freqtrade.edge) == (999.9 * 0.5 * 0.01) / 0.21 'LTC/BTC', freqtrade.edge) == (999.9 * 0.5 * 0.01) / 0.21
@pytest.mark.parametrize('buy_price_mult,ignore_strat_sl,is_short', [ @pytest.mark.parametrize('buy_price_mult,ignore_strat_sl', [
(0.79, False, False), # Override stoploss (0.79, False), # Override stoploss
(0.85, True, False), # Override strategy stoploss (0.85, True), # Override strategy stoploss
(0.85, False, True), # Override stoploss
(0.79, True, True) # Override strategy stoploss
]) ])
def test_edge_overrides_stoploss(limit_order, fee, caplog, mocker, is_short, def test_edge_overrides_stoploss(limit_order, fee, caplog, mocker,
buy_price_mult, ignore_strat_sl, edge_conf) -> None: buy_price_mult, ignore_strat_sl, edge_conf) -> None:
patch_RPCManager(mocker) patch_RPCManager(mocker)
patch_exchange(mocker) patch_exchange(mocker)
@ -220,7 +218,7 @@ def test_edge_overrides_stoploss(limit_order, fee, caplog, mocker, is_short,
# Thus, if price falls 21%, stoploss should be triggered # Thus, if price falls 21%, stoploss should be triggered
# #
# mocking the ticker: price is falling ... # mocking the ticker: price is falling ...
enter_price = limit_order[enter_side(is_short)]['price'] enter_price = limit_order['buy']['price']
mocker.patch.multiple( mocker.patch.multiple(
'freqtrade.exchange.Exchange', 'freqtrade.exchange.Exchange',
fetch_ticker=MagicMock(return_value={ fetch_ticker=MagicMock(return_value={
@ -235,13 +233,12 @@ def test_edge_overrides_stoploss(limit_order, fee, caplog, mocker, is_short,
# Create a trade with "limit_buy_order_usdt" price # Create a trade with "limit_buy_order_usdt" price
freqtrade = FreqtradeBot(edge_conf) freqtrade = FreqtradeBot(edge_conf)
freqtrade.active_pair_whitelist = ['NEO/BTC'] freqtrade.active_pair_whitelist = ['NEO/BTC']
patch_get_signal(freqtrade, enter_short=is_short, enter_long=not is_short) patch_get_signal(freqtrade)
freqtrade.strategy.min_roi_reached = MagicMock(return_value=False) freqtrade.strategy.min_roi_reached = MagicMock(return_value=False)
freqtrade.enter_positions() freqtrade.enter_positions()
trade = Trade.query.first() trade = Trade.query.first()
trade.is_short = is_short
caplog.clear() caplog.clear()
trade.update(limit_order[enter_side(is_short)]) trade.update(limit_order['buy'])
############################################# #############################################
# stoploss shoud be hit # stoploss shoud be hit
@ -1564,12 +1561,11 @@ def test_handle_stoploss_on_exchange_custom_stop(
assert freqtrade.handle_trade(trade) is True assert freqtrade.handle_trade(trade) is True
@pytest.mark.parametrize("is_short", [False, True]) def test_tsl_on_exchange_compatible_with_edge(mocker, edge_conf, fee, caplog,
def test_tsl_on_exchange_compatible_with_edge(mocker, edge_conf, fee, caplog, is_short,
limit_order) -> None: limit_order) -> None:
enter_order = limit_order[enter_side(is_short)] enter_order = limit_order['buy']
exit_order = limit_order[exit_side(is_short)] exit_order = limit_order['sell']
# When trailing stoploss is set # When trailing stoploss is set
stoploss = MagicMock(return_value={'id': 13434334}) stoploss = MagicMock(return_value={'id': 13434334})
@ -1613,17 +1609,15 @@ def test_tsl_on_exchange_compatible_with_edge(mocker, edge_conf, fee, caplog, is
# setting stoploss_on_exchange_interval to 0 seconds # setting stoploss_on_exchange_interval to 0 seconds
freqtrade.strategy.order_types['stoploss_on_exchange_interval'] = 0 freqtrade.strategy.order_types['stoploss_on_exchange_interval'] = 0
patch_get_signal(freqtrade, enter_short=is_short, enter_long=not is_short) patch_get_signal(freqtrade)
freqtrade.active_pair_whitelist = freqtrade.edge.adjust(freqtrade.active_pair_whitelist) freqtrade.active_pair_whitelist = freqtrade.edge.adjust(freqtrade.active_pair_whitelist)
freqtrade.enter_positions() freqtrade.enter_positions()
trade = Trade.query.first() trade = Trade.query.first()
trade.is_short = is_short
trade.is_open = True trade.is_open = True
trade.open_order_id = None trade.open_order_id = None
trade.stoploss_order_id = 100 trade.stoploss_order_id = 100
trade.is_short = is_short
stoploss_order_hanging = MagicMock(return_value={ stoploss_order_hanging = MagicMock(return_value={
'id': 100, 'id': 100,
@ -1681,7 +1675,7 @@ def test_tsl_on_exchange_compatible_with_edge(mocker, edge_conf, fee, caplog, is
pair='NEO/BTC', pair='NEO/BTC',
order_types=freqtrade.strategy.order_types, order_types=freqtrade.strategy.order_types,
stop_price=4.4 * 0.99, stop_price=4.4 * 0.99,
side=exit_side(is_short), side='sell',
leverage=1.0 leverage=1.0
) )
@ -1931,12 +1925,12 @@ def test_update_trade_state_sell(
assert order.status == 'closed' assert order.status == 'closed'
@pytest.mark.parametrize('is_short', [ @pytest.mark.parametrize('is_short,close_profit,profit', [
False, (False, 0.09451372, 5.685),
True (True, 0.08675799087, 5.7),
]) ])
def test_handle_trade( def test_handle_trade(
default_conf_usdt, limit_order_open, limit_order, fee, mocker, is_short default_conf_usdt, limit_order_open, limit_order, fee, mocker, is_short, close_profit, profit
) -> None: ) -> None:
open_order = limit_order_open[exit_side(is_short)] open_order = limit_order_open[exit_side(is_short)]
enter_order = limit_order[enter_side(is_short)] enter_order = limit_order[enter_side(is_short)]
@ -1978,8 +1972,8 @@ def test_handle_trade(
trade.update(exit_order) trade.update(exit_order)
assert trade.close_rate == 2.0 if is_short else 2.2 assert trade.close_rate == 2.0 if is_short else 2.2
assert trade.close_profit == 0.09451372 assert trade.close_profit == close_profit
assert trade.calc_profit() == 5.685 assert trade.calc_profit() == profit
assert trade.close_date is not None assert trade.close_date is not None
@ -2838,7 +2832,7 @@ def test_execute_trade_exit_up(default_conf_usdt, ticker_usdt, fee, ticker_usdt_
) )
# Prevented sell ... # Prevented sell ...
# TODO-lev: side="buy" # TODO-lev: side="buy"
freqtrade.execute_trade_exit(trade=trade, limit=ticker_usdt_sell_up()['bid'], freqtrade.execute_trade_exit(trade=trade, limit=ticker_usdt_sell_up()['ask' if is_short else 'bid'],
sell_reason=SellCheckTuple(sell_type=SellType.ROI)) sell_reason=SellCheckTuple(sell_type=SellType.ROI))
assert rpc_mock.call_count == 0 assert rpc_mock.call_count == 0
assert freqtrade.strategy.confirm_trade_exit.call_count == 1 assert freqtrade.strategy.confirm_trade_exit.call_count == 1
@ -2846,7 +2840,7 @@ def test_execute_trade_exit_up(default_conf_usdt, ticker_usdt, fee, ticker_usdt_
# Repatch with true # Repatch with true
freqtrade.strategy.confirm_trade_exit = MagicMock(return_value=True) freqtrade.strategy.confirm_trade_exit = MagicMock(return_value=True)
# TODO-lev: side="buy" # TODO-lev: side="buy"
freqtrade.execute_trade_exit(trade=trade, limit=ticker_usdt_sell_up()['bid'], freqtrade.execute_trade_exit(trade=trade, limit=ticker_usdt_sell_up()['ask' if is_short else 'bid'],
sell_reason=SellCheckTuple(sell_type=SellType.ROI)) sell_reason=SellCheckTuple(sell_type=SellType.ROI))
assert freqtrade.strategy.confirm_trade_exit.call_count == 1 assert freqtrade.strategy.confirm_trade_exit.call_count == 1
@ -3328,12 +3322,12 @@ def test_execute_trade_exit_insufficient_funds_error(default_conf_usdt, ticker_u
@ pytest.mark.parametrize("is_short", [False, True]) @ pytest.mark.parametrize("is_short", [False, True])
@ pytest.mark.parametrize('profit_only,bid,ask,handle_first,handle_second,sell_type', [ @ pytest.mark.parametrize('profit_only,bid,ask,handle_first,handle_second,sell_type', [
# Enable profit # Enable profit
(True, 1.9, 2.2, False, True, SellType.SELL_SIGNAL.value), (True, 2.19, 2.2, False, True, SellType.SELL_SIGNAL.value),
# Disable profit # Disable profit
(False, 2.9, 3.2, True, False, SellType.SELL_SIGNAL.value), (False, 3.19, 3.2, True, False, SellType.SELL_SIGNAL.value),
# Enable loss # Enable loss
# * Shouldn't this be SellType.STOP_LOSS.value # * Shouldn't this be SellType.STOP_LOSS.value
(True, 0.19, 0.22, False, False, None), (True, 0.21, 0.22, False, False, None),
# Disable loss # Disable loss
(False, 0.10, 0.22, True, False, SellType.SELL_SIGNAL.value), (False, 0.10, 0.22, True, False, SellType.SELL_SIGNAL.value),
]) ])
@ -3373,7 +3367,7 @@ def test_sell_profit_only(
trade.is_short = is_short trade.is_short = is_short
trade.update(limit_order[enter_side(is_short)]) trade.update(limit_order[enter_side(is_short)])
freqtrade.wallets.update() freqtrade.wallets.update()
patch_get_signal(freqtrade, enter_long=False, exit_long=True) patch_get_signal(freqtrade, enter_long=False, exit_short=is_short, exit_long=not is_short)
assert freqtrade.handle_trade(trade) is handle_first assert freqtrade.handle_trade(trade) is handle_first
if handle_second: if handle_second:
@ -3381,9 +3375,8 @@ def test_sell_profit_only(
assert freqtrade.handle_trade(trade) is True assert freqtrade.handle_trade(trade) is True
@ pytest.mark.parametrize("is_short", [False, True])
def test_sell_not_enough_balance(default_conf_usdt, limit_order, limit_order_open, def test_sell_not_enough_balance(default_conf_usdt, limit_order, limit_order_open,
is_short, fee, mocker, caplog) -> None: fee, mocker, caplog) -> None:
patch_RPCManager(mocker) patch_RPCManager(mocker)
patch_exchange(mocker) patch_exchange(mocker)
mocker.patch.multiple( mocker.patch.multiple(
@ -3394,22 +3387,21 @@ def test_sell_not_enough_balance(default_conf_usdt, limit_order, limit_order_ope
'last': 0.00002172 'last': 0.00002172
}), }),
create_order=MagicMock(side_effect=[ create_order=MagicMock(side_effect=[
limit_order_open[enter_side(is_short)], limit_order_open['buy'],
{'id': 1234553382}, {'id': 1234553382},
]), ]),
get_fee=fee, get_fee=fee,
) )
freqtrade = FreqtradeBot(default_conf_usdt) freqtrade = FreqtradeBot(default_conf_usdt)
patch_get_signal(freqtrade, enter_short=is_short, enter_long=not is_short) patch_get_signal(freqtrade)
freqtrade.strategy.min_roi_reached = MagicMock(return_value=False) freqtrade.strategy.min_roi_reached = MagicMock(return_value=False)
freqtrade.enter_positions() freqtrade.enter_positions()
trade = Trade.query.first() trade = Trade.query.first()
trade.is_short = is_short
amnt = trade.amount amnt = trade.amount
trade.update(limit_order[enter_side(is_short)]) trade.update(limit_order['buy'])
patch_get_signal(freqtrade, enter_long=False, exit_long=True) patch_get_signal(freqtrade, enter_long=False, exit_long=True)
mocker.patch('freqtrade.wallets.Wallets.get_free', MagicMock(return_value=trade.amount * 0.985)) mocker.patch('freqtrade.wallets.Wallets.get_free', MagicMock(return_value=trade.amount * 0.985))
@ -3692,7 +3684,8 @@ def test_trailing_stop_loss_positive(
assert log_has( assert log_has(
f"ETH/USDT - HIT STOP: current price at {enter_price + (-0.02 if is_short else 0.02):.6f}, " f"ETH/USDT - HIT STOP: current price at {enter_price + (-0.02 if is_short else 0.02):.6f}, "
f"stoploss is {trade.stop_loss:.6f}, " f"stoploss is {trade.stop_loss:.6f}, "
f"initial stoploss was at {2.2 if is_short else 1.8}00000, trade opened at 2.000000", caplog) f"initial stoploss was at {2.2 if is_short else 1.8}00000, trade opened at 2.000000",
caplog)
assert trade.sell_reason == SellType.TRAILING_STOP_LOSS.value assert trade.sell_reason == SellType.TRAILING_STOP_LOSS.value
@ -3729,7 +3722,8 @@ def test_disable_ignore_roi_if_buy_signal(default_conf_usdt, limit_order, limit_
trade.is_short = is_short trade.is_short = is_short
trade.update(limit_order[enter_side(is_short)]) trade.update(limit_order[enter_side(is_short)])
# Sell due to min_roi_reached # Sell due to min_roi_reached
patch_get_signal(freqtrade, enter_long=not is_short, enter_short=is_short, exit_short=is_short) patch_get_signal(freqtrade, enter_long=not is_short, exit_long=not is_short,
enter_short=is_short, exit_short=is_short)
assert freqtrade.handle_trade(trade) is True assert freqtrade.handle_trade(trade) is True
# Test if buy-signal is absent # Test if buy-signal is absent