ruff format: update strategy tests

tests/strategy/test_strategy_loading.py

@@ -14,7 +14,7 @@ from tests.conftest import CURRENT_TEST_STRATEGY, log_has, log_has_re
 
 
 def test_search_strategy():
-    default_location = Path(__file__).parent / 'strats'
+    default_location = Path(__file__).parent / "strats"
 
     s, _ = StrategyResolver._search_object(
         directory=default_location,
@@ -25,7 +25,7 @@ def test_search_strategy():
 
     s, _ = StrategyResolver._search_object(
         directory=default_location,
-        object_name='NotFoundStrategy',
+        object_name="NotFoundStrategy",
         add_source=True,
     )
     assert s is None
@@ -46,9 +46,9 @@ def test_search_all_strategies_with_failed():
     assert len(strategies) == 14
     # with enum_failed=True search_all_objects() shall find 2 good strategies
     # and 1 which fails to load
-    assert len([x for x in strategies if x['class'] is not None]) == 13
+    assert len([x for x in strategies if x["class"] is not None]) == 13
 
-    assert len([x for x in strategies if x['class'] is None]) == 1
+    assert len([x for x in strategies if x["class"] is None]) == 1
 
     directory = Path(__file__).parent / "strats_nonexistingdir"
     strategies = StrategyResolver._search_all_objects(directory, enum_failed=True)
@@ -56,123 +56,126 @@ def test_search_all_strategies_with_failed():
 
 
 def test_load_strategy(default_conf, dataframe_1m):
-    default_conf.update({'strategy': 'SampleStrategy',
-                         'strategy_path': str(Path(__file__).parents[2] / 'freqtrade/templates')
-                         })
+    default_conf.update(
+        {
+            "strategy": "SampleStrategy",
+            "strategy_path": str(Path(__file__).parents[2] / "freqtrade/templates"),
+        }
+    )
     strategy = StrategyResolver.load_strategy(default_conf)
     assert isinstance(strategy.__source__, str)
-    assert 'class SampleStrategy' in strategy.__source__
+    assert "class SampleStrategy" in strategy.__source__
     assert isinstance(strategy.__file__, str)
-    assert 'rsi' in strategy.advise_indicators(dataframe_1m, {'pair': 'ETH/BTC'})
+    assert "rsi" in strategy.advise_indicators(dataframe_1m, {"pair": "ETH/BTC"})
 
 
 def test_load_strategy_base64(dataframe_1m, caplog, default_conf):
-    filepath = Path(__file__).parents[2] / 'freqtrade/templates/sample_strategy.py'
+    filepath = Path(__file__).parents[2] / "freqtrade/templates/sample_strategy.py"
     encoded_string = urlsafe_b64encode(filepath.read_bytes()).decode("utf-8")
-    default_conf.update({'strategy': f'SampleStrategy:{encoded_string}'})
+    default_conf.update({"strategy": f"SampleStrategy:{encoded_string}"})
 
     strategy = StrategyResolver.load_strategy(default_conf)
-    assert 'rsi' in strategy.advise_indicators(dataframe_1m, {'pair': 'ETH/BTC'})
+    assert "rsi" in strategy.advise_indicators(dataframe_1m, {"pair": "ETH/BTC"})
     # Make sure strategy was loaded from base64 (using temp directory)!!
-    assert log_has_re(r"Using resolved strategy SampleStrategy from '"
-                      r".*(/|\\).*(/|\\)SampleStrategy\.py'\.\.\.", caplog)
+    assert log_has_re(
+        r"Using resolved strategy SampleStrategy from '"
+        r".*(/|\\).*(/|\\)SampleStrategy\.py'\.\.\.",
+        caplog,
+    )
 
 
 def test_load_strategy_invalid_directory(caplog, default_conf, tmp_path):
-    default_conf['user_data_dir'] = tmp_path
+    default_conf["user_data_dir"] = tmp_path
 
-    extra_dir = Path.cwd() / 'some/path'
+    extra_dir = Path.cwd() / "some/path"
     with pytest.raises(OperationalException, match=r"Impossible to load Strategy.*"):
-        StrategyResolver._load_strategy('StrategyTestV333', config=default_conf,
-                                        extra_dir=extra_dir)
+        StrategyResolver._load_strategy(
+            "StrategyTestV333", config=default_conf, extra_dir=extra_dir
+        )
 
-    assert log_has_re(r'Path .*' + r'some.*path.*' + r'.* does not exist', caplog)
+    assert log_has_re(r"Path .*" + r"some.*path.*" + r".* does not exist", caplog)
 
 
 def test_load_not_found_strategy(default_conf, tmp_path):
-    default_conf['user_data_dir'] = tmp_path
-    default_conf['strategy'] = 'NotFoundStrategy'
-    with pytest.raises(OperationalException,
-                       match=r"Impossible to load Strategy 'NotFoundStrategy'. "
-                             r"This class does not exist or contains Python code errors."):
+    default_conf["user_data_dir"] = tmp_path
+    default_conf["strategy"] = "NotFoundStrategy"
+    with pytest.raises(
+        OperationalException,
+        match=r"Impossible to load Strategy 'NotFoundStrategy'. "
+        r"This class does not exist or contains Python code errors.",
+    ):
         StrategyResolver.load_strategy(default_conf)
 
 
 def test_load_strategy_noname(default_conf):
-    default_conf['strategy'] = ''
-    with pytest.raises(OperationalException,
-                       match="No strategy set. Please use `--strategy` to specify "
-                             "the strategy class to use."):
+    default_conf["strategy"] = ""
+    with pytest.raises(
+        OperationalException,
+        match="No strategy set. Please use `--strategy` to specify " "the strategy class to use.",
+    ):
         StrategyResolver.load_strategy(default_conf)
 
 
-@ pytest.mark.filterwarnings("ignore:deprecated")
-@ pytest.mark.parametrize('strategy_name', ['StrategyTestV2'])
+@pytest.mark.filterwarnings("ignore:deprecated")
+@pytest.mark.parametrize("strategy_name", ["StrategyTestV2"])
 def test_strategy_pre_v3(dataframe_1m, default_conf, strategy_name):
-    default_conf.update({'strategy': strategy_name})
+    default_conf.update({"strategy": strategy_name})
 
     strategy = StrategyResolver.load_strategy(default_conf)
-    metadata = {'pair': 'ETH/BTC'}
+    metadata = {"pair": "ETH/BTC"}
     assert strategy.minimal_roi[0] == 0.04
-    assert default_conf["minimal_roi"]['0'] == 0.04
+    assert default_conf["minimal_roi"]["0"] == 0.04
 
     assert strategy.stoploss == -0.10
-    assert default_conf['stoploss'] == -0.10
+    assert default_conf["stoploss"] == -0.10
 
-    assert strategy.timeframe == '5m'
-    assert default_conf['timeframe'] == '5m'
+    assert strategy.timeframe == "5m"
+    assert default_conf["timeframe"] == "5m"
 
     df_indicators = strategy.advise_indicators(dataframe_1m, metadata=metadata)
-    assert 'adx' in df_indicators
+    assert "adx" in df_indicators
 
     dataframe = strategy.advise_entry(df_indicators, metadata=metadata)
-    assert 'buy' not in dataframe.columns
-    assert 'enter_long' in dataframe.columns
+    assert "buy" not in dataframe.columns
+    assert "enter_long" in dataframe.columns
 
     dataframe = strategy.advise_exit(df_indicators, metadata=metadata)
-    assert 'sell' not in dataframe.columns
-    assert 'exit_long' in dataframe.columns
+    assert "sell" not in dataframe.columns
+    assert "exit_long" in dataframe.columns
 
 
 def test_strategy_can_short(caplog, default_conf):
     caplog.set_level(logging.INFO)
-    default_conf.update({
-        'strategy': CURRENT_TEST_STRATEGY,
-    })
+    default_conf.update(
+        {
+            "strategy": CURRENT_TEST_STRATEGY,
+        }
+    )
     strat = StrategyResolver.load_strategy(default_conf)
     assert isinstance(strat, IStrategy)
-    default_conf['strategy'] = 'StrategyTestV3Futures'
+    default_conf["strategy"] = "StrategyTestV3Futures"
     with pytest.raises(ImportError, match=""):
         StrategyResolver.load_strategy(default_conf)
 
-    default_conf['trading_mode'] = 'futures'
+    default_conf["trading_mode"] = "futures"
     strat = StrategyResolver.load_strategy(default_conf)
     assert isinstance(strat, IStrategy)
 
 
 def test_strategy_override_minimal_roi(caplog, default_conf):
     caplog.set_level(logging.INFO)
-    default_conf.update({
-        'strategy': CURRENT_TEST_STRATEGY,
-        'minimal_roi': {
-            "20": 0.1,
-            "0": 0.5
-        }
-    })
+    default_conf.update({"strategy": CURRENT_TEST_STRATEGY, "minimal_roi": {"20": 0.1, "0": 0.5}})
     strategy = StrategyResolver.load_strategy(default_conf)
 
     assert strategy.minimal_roi[0] == 0.5
     assert log_has(
-        "Override strategy 'minimal_roi' with value in config file: {'20': 0.1, '0': 0.5}.",
-        caplog)
+        "Override strategy 'minimal_roi' with value in config file: {'20': 0.1, '0': 0.5}.", caplog
+    )
 
 
 def test_strategy_override_stoploss(caplog, default_conf):
     caplog.set_level(logging.INFO)
-    default_conf.update({
-        'strategy': CURRENT_TEST_STRATEGY,
-        'stoploss': -0.5
-    })
+    default_conf.update({"strategy": CURRENT_TEST_STRATEGY, "stoploss": -0.5})
     strategy = StrategyResolver.load_strategy(default_conf)
 
     assert strategy.stoploss == -0.5
@@ -181,10 +184,7 @@ def test_strategy_override_stoploss(caplog, default_conf):
 
 def test_strategy_override_max_open_trades(caplog, default_conf):
     caplog.set_level(logging.INFO)
-    default_conf.update({
-        'strategy': CURRENT_TEST_STRATEGY,
-        'max_open_trades': 7
-    })
+    default_conf.update({"strategy": CURRENT_TEST_STRATEGY, "max_open_trades": 7})
     strategy = StrategyResolver.load_strategy(default_conf)
 
     assert strategy.max_open_trades == 7
@@ -193,10 +193,7 @@ def test_strategy_override_max_open_trades(caplog, default_conf):
 
 def test_strategy_override_trailing_stop(caplog, default_conf):
     caplog.set_level(logging.INFO)
-    default_conf.update({
-        'strategy': CURRENT_TEST_STRATEGY,
-        'trailing_stop': True
-    })
+    default_conf.update({"strategy": CURRENT_TEST_STRATEGY, "trailing_stop": True})
     strategy = StrategyResolver.load_strategy(default_conf)
 
     assert strategy.trailing_stop
@@ -206,84 +203,81 @@ def test_strategy_override_trailing_stop(caplog, default_conf):
 
 def test_strategy_override_trailing_stop_positive(caplog, default_conf):
     caplog.set_level(logging.INFO)
-    default_conf.update({
-        'strategy': CURRENT_TEST_STRATEGY,
-        'trailing_stop_positive': -0.1,
-        'trailing_stop_positive_offset': -0.2
-
-    })
+    default_conf.update(
+        {
+            "strategy": CURRENT_TEST_STRATEGY,
+            "trailing_stop_positive": -0.1,
+            "trailing_stop_positive_offset": -0.2,
+        }
+    )
     strategy = StrategyResolver.load_strategy(default_conf)
 
     assert strategy.trailing_stop_positive == -0.1
-    assert log_has("Override strategy 'trailing_stop_positive' with value in config file: -0.1.",
-                   caplog)
+    assert log_has(
+        "Override strategy 'trailing_stop_positive' with value in config file: -0.1.", caplog
+    )
 
     assert strategy.trailing_stop_positive_offset == -0.2
-    assert log_has("Override strategy 'trailing_stop_positive' with value in config file: -0.1.",
-                   caplog)
+    assert log_has(
+        "Override strategy 'trailing_stop_positive' with value in config file: -0.1.", caplog
+    )
 
 
 def test_strategy_override_timeframe(caplog, default_conf):
     caplog.set_level(logging.INFO)
 
-    default_conf.update({
-        'strategy': CURRENT_TEST_STRATEGY,
-        'timeframe': 60,
-        'stake_currency': 'ETH'
-    })
+    default_conf.update(
+        {"strategy": CURRENT_TEST_STRATEGY, "timeframe": 60, "stake_currency": "ETH"}
+    )
     strategy = StrategyResolver.load_strategy(default_conf)
 
     assert strategy.timeframe == 60
-    assert strategy.stake_currency == 'ETH'
-    assert log_has("Override strategy 'timeframe' with value in config file: 60.",
-                   caplog)
+    assert strategy.stake_currency == "ETH"
+    assert log_has("Override strategy 'timeframe' with value in config file: 60.", caplog)
 
 
 def test_strategy_override_process_only_new_candles(caplog, default_conf):
     caplog.set_level(logging.INFO)
 
-    default_conf.update({
-        'strategy': CURRENT_TEST_STRATEGY,
-        'process_only_new_candles': False
-    })
+    default_conf.update({"strategy": CURRENT_TEST_STRATEGY, "process_only_new_candles": False})
     strategy = StrategyResolver.load_strategy(default_conf)
 
     assert not strategy.process_only_new_candles
-    assert log_has("Override strategy 'process_only_new_candles' with value in config file: False.",
-                   caplog)
+    assert log_has(
+        "Override strategy 'process_only_new_candles' with value in config file: False.", caplog
+    )
 
 
 def test_strategy_override_order_types(caplog, default_conf):
     caplog.set_level(logging.INFO)
 
     order_types = {
-        'entry': 'market',
-        'exit': 'limit',
-        'stoploss': 'limit',
-        'stoploss_on_exchange': True,
+        "entry": "market",
+        "exit": "limit",
+        "stoploss": "limit",
+        "stoploss_on_exchange": True,
     }
-    default_conf.update({
-        'strategy': CURRENT_TEST_STRATEGY,
-        'order_types': order_types
-    })
+    default_conf.update({"strategy": CURRENT_TEST_STRATEGY, "order_types": order_types})
     strategy = StrategyResolver.load_strategy(default_conf)
 
     assert strategy.order_types
-    for method in ['entry', 'exit', 'stoploss', 'stoploss_on_exchange']:
+    for method in ["entry", "exit", "stoploss", "stoploss_on_exchange"]:
         assert strategy.order_types[method] == order_types[method]
 
-    assert log_has("Override strategy 'order_types' with value in config file:"
-                   " {'entry': 'market', 'exit': 'limit', 'stoploss': 'limit',"
-                   " 'stoploss_on_exchange': True}.", caplog)
+    assert log_has(
+        "Override strategy 'order_types' with value in config file:"
+        " {'entry': 'market', 'exit': 'limit', 'stoploss': 'limit',"
+        " 'stoploss_on_exchange': True}.",
+        caplog,
+    )
 
-    default_conf.update({
-        'strategy': CURRENT_TEST_STRATEGY,
-        'order_types': {'exit': 'market'}
-    })
+    default_conf.update({"strategy": CURRENT_TEST_STRATEGY, "order_types": {"exit": "market"}})
     # Raise error for invalid configuration
-    with pytest.raises(ImportError,
-                       match=r"Impossible to load Strategy '" + CURRENT_TEST_STRATEGY + "'. "
-                             r"Order-types mapping is incomplete."):
+    with pytest.raises(
+        ImportError,
+        match=r"Impossible to load Strategy '" + CURRENT_TEST_STRATEGY + "'. "
+        r"Order-types mapping is incomplete.",
+    ):
         StrategyResolver.load_strategy(default_conf)
 
 
@@ -291,50 +285,57 @@ def test_strategy_override_order_tif(caplog, default_conf):
     caplog.set_level(logging.INFO)
 
     order_time_in_force = {
-        'entry': 'FOK',
-        'exit': 'GTC',
+        "entry": "FOK",
+        "exit": "GTC",
     }
 
-    default_conf.update({
-        'strategy': CURRENT_TEST_STRATEGY,
-        'order_time_in_force': order_time_in_force
-    })
+    default_conf.update(
+        {"strategy": CURRENT_TEST_STRATEGY, "order_time_in_force": order_time_in_force}
+    )
     strategy = StrategyResolver.load_strategy(default_conf)
 
     assert strategy.order_time_in_force
-    for method in ['entry', 'exit']:
+    for method in ["entry", "exit"]:
         assert strategy.order_time_in_force[method] == order_time_in_force[method]
 
-    assert log_has("Override strategy 'order_time_in_force' with value in config file:"
-                   " {'entry': 'FOK', 'exit': 'GTC'}.", caplog)
+    assert log_has(
+        "Override strategy 'order_time_in_force' with value in config file:"
+        " {'entry': 'FOK', 'exit': 'GTC'}.",
+        caplog,
+    )
 
-    default_conf.update({
-        'strategy': CURRENT_TEST_STRATEGY,
-        'order_time_in_force': {'entry': 'FOK'}
-    })
+    default_conf.update(
+        {"strategy": CURRENT_TEST_STRATEGY, "order_time_in_force": {"entry": "FOK"}}
+    )
     # Raise error for invalid configuration
-    with pytest.raises(ImportError,
-                       match=f"Impossible to load Strategy '{CURRENT_TEST_STRATEGY}'. "
-                             "Order-time-in-force mapping is incomplete."):
+    with pytest.raises(
+        ImportError,
+        match=f"Impossible to load Strategy '{CURRENT_TEST_STRATEGY}'. "
+        "Order-time-in-force mapping is incomplete.",
+    ):
         StrategyResolver.load_strategy(default_conf)
 
 
 def test_strategy_override_use_exit_signal(caplog, default_conf):
     caplog.set_level(logging.INFO)
-    default_conf.update({
-        'strategy': CURRENT_TEST_STRATEGY,
-    })
+    default_conf.update(
+        {
+            "strategy": CURRENT_TEST_STRATEGY,
+        }
+    )
     strategy = StrategyResolver.load_strategy(default_conf)
     assert strategy.use_exit_signal
     assert isinstance(strategy.use_exit_signal, bool)
     # must be inserted to configuration
-    assert 'use_exit_signal' in default_conf
-    assert default_conf['use_exit_signal']
+    assert "use_exit_signal" in default_conf
+    assert default_conf["use_exit_signal"]
 
-    default_conf.update({
-        'strategy': CURRENT_TEST_STRATEGY,
-        'use_exit_signal': False,
-    })
+    default_conf.update(
+        {
+            "strategy": CURRENT_TEST_STRATEGY,
+            "use_exit_signal": False,
+        }
+    )
     strategy = StrategyResolver.load_strategy(default_conf)
 
     assert not strategy.use_exit_signal
@@ -344,20 +345,24 @@ def test_strategy_override_use_exit_signal(caplog, default_conf):
 
 def test_strategy_override_use_exit_profit_only(caplog, default_conf):
     caplog.set_level(logging.INFO)
-    default_conf.update({
-        'strategy': CURRENT_TEST_STRATEGY,
-    })
+    default_conf.update(
+        {
+            "strategy": CURRENT_TEST_STRATEGY,
+        }
+    )
     strategy = StrategyResolver.load_strategy(default_conf)
     assert not strategy.exit_profit_only
     assert isinstance(strategy.exit_profit_only, bool)
     # must be inserted to configuration
-    assert 'exit_profit_only' in default_conf
-    assert not default_conf['exit_profit_only']
+    assert "exit_profit_only" in default_conf
+    assert not default_conf["exit_profit_only"]
 
-    default_conf.update({
-        'strategy': CURRENT_TEST_STRATEGY,
-        'exit_profit_only': True,
-    })
+    default_conf.update(
+        {
+            "strategy": CURRENT_TEST_STRATEGY,
+            "exit_profit_only": True,
+        }
+    )
     strategy = StrategyResolver.load_strategy(default_conf)
 
     assert strategy.exit_profit_only
@@ -367,138 +372,135 @@ def test_strategy_override_use_exit_profit_only(caplog, default_conf):
 
 def test_strategy_max_open_trades_infinity_from_strategy(caplog, default_conf):
     caplog.set_level(logging.INFO)
-    default_conf.update({
-        'strategy': CURRENT_TEST_STRATEGY,
-    })
-    del default_conf['max_open_trades']
+    default_conf.update(
+        {
+            "strategy": CURRENT_TEST_STRATEGY,
+        }
+    )
+    del default_conf["max_open_trades"]
 
     strategy = StrategyResolver.load_strategy(default_conf)
 
     # this test assumes -1 set to 'max_open_trades' in CURRENT_TEST_STRATEGY
-    assert strategy.max_open_trades == float('inf')
-    assert default_conf['max_open_trades'] == float('inf')
+    assert strategy.max_open_trades == float("inf")
+    assert default_conf["max_open_trades"] == float("inf")
 
 
 def test_strategy_max_open_trades_infinity_from_config(caplog, default_conf, mocker):
     caplog.set_level(logging.INFO)
-    default_conf.update({
-        'strategy': CURRENT_TEST_STRATEGY,
-        'max_open_trades': -1,
-        'exchange': 'binance'
-    })
+    default_conf.update(
+        {"strategy": CURRENT_TEST_STRATEGY, "max_open_trades": -1, "exchange": "binance"}
+    )
 
     configuration = Configuration(args=default_conf)
     parsed_config = configuration.get_config()
 
-    assert parsed_config['max_open_trades'] == float('inf')
+    assert parsed_config["max_open_trades"] == float("inf")
 
     strategy = StrategyResolver.load_strategy(parsed_config)
 
-    assert strategy.max_open_trades == float('inf')
+    assert strategy.max_open_trades == float("inf")
 
 
-@ pytest.mark.filterwarnings("ignore:deprecated")
+@pytest.mark.filterwarnings("ignore:deprecated")
 def test_missing_implements(default_conf, caplog):
-
     default_location = Path(__file__).parent / "strats"
-    default_conf.update({'strategy': 'StrategyTestV2',
-                         'strategy_path': default_location})
+    default_conf.update({"strategy": "StrategyTestV2", "strategy_path": default_location})
     StrategyResolver.load_strategy(default_conf)
 
     log_has_re(r"DEPRECATED: .*use_sell_signal.*use_exit_signal.", caplog)
 
-    default_conf['trading_mode'] = 'futures'
-    with pytest.raises(OperationalException,
-                       match=r"DEPRECATED: .*use_sell_signal.*use_exit_signal."):
+    default_conf["trading_mode"] = "futures"
+    with pytest.raises(
+        OperationalException, match=r"DEPRECATED: .*use_sell_signal.*use_exit_signal."
+    ):
         StrategyResolver.load_strategy(default_conf)
 
-    default_conf['trading_mode'] = 'spot'
+    default_conf["trading_mode"] = "spot"
 
     default_location = Path(__file__).parent / "strats/broken_strats"
-    default_conf.update({'strategy': 'TestStrategyNoImplements',
-                         'strategy_path': default_location})
-    with pytest.raises(OperationalException,
-                       match=r"`populate_entry_trend` or `populate_buy_trend`.*"):
+    default_conf.update({"strategy": "TestStrategyNoImplements", "strategy_path": default_location})
+    with pytest.raises(
+        OperationalException, match=r"`populate_entry_trend` or `populate_buy_trend`.*"
+    ):
         StrategyResolver.load_strategy(default_conf)
 
-    default_conf['strategy'] = 'TestStrategyNoImplementSell'
+    default_conf["strategy"] = "TestStrategyNoImplementSell"
 
-    with pytest.raises(OperationalException,
-                       match=r"`populate_exit_trend` or `populate_sell_trend`.*"):
+    with pytest.raises(
+        OperationalException, match=r"`populate_exit_trend` or `populate_sell_trend`.*"
+    ):
         StrategyResolver.load_strategy(default_conf)
 
     # Futures mode is more strict ...
-    default_conf['trading_mode'] = 'futures'
+    default_conf["trading_mode"] = "futures"
 
-    with pytest.raises(OperationalException,
-                       match=r"`populate_exit_trend` must be implemented.*"):
+    with pytest.raises(OperationalException, match=r"`populate_exit_trend` must be implemented.*"):
         StrategyResolver.load_strategy(default_conf)
 
-    default_conf['strategy'] = 'TestStrategyNoImplements'
-    with pytest.raises(OperationalException,
-                       match=r"`populate_entry_trend` must be implemented.*"):
+    default_conf["strategy"] = "TestStrategyNoImplements"
+    with pytest.raises(OperationalException, match=r"`populate_entry_trend` must be implemented.*"):
         StrategyResolver.load_strategy(default_conf)
 
-    default_conf['strategy'] = 'TestStrategyImplementCustomSell'
-    with pytest.raises(OperationalException,
-                       match=r"Please migrate your implementation of `custom_sell`.*"):
+    default_conf["strategy"] = "TestStrategyImplementCustomSell"
+    with pytest.raises(
+        OperationalException, match=r"Please migrate your implementation of `custom_sell`.*"
+    ):
         StrategyResolver.load_strategy(default_conf)
 
-    default_conf['strategy'] = 'TestStrategyImplementBuyTimeout'
-    with pytest.raises(OperationalException,
-                       match=r"Please migrate your implementation of `check_buy_timeout`.*"):
+    default_conf["strategy"] = "TestStrategyImplementBuyTimeout"
+    with pytest.raises(
+        OperationalException, match=r"Please migrate your implementation of `check_buy_timeout`.*"
+    ):
         StrategyResolver.load_strategy(default_conf)
 
-    default_conf['strategy'] = 'TestStrategyImplementSellTimeout'
-    with pytest.raises(OperationalException,
-                       match=r"Please migrate your implementation of `check_sell_timeout`.*"):
+    default_conf["strategy"] = "TestStrategyImplementSellTimeout"
+    with pytest.raises(
+        OperationalException, match=r"Please migrate your implementation of `check_sell_timeout`.*"
+    ):
         StrategyResolver.load_strategy(default_conf)
 
 
 def test_call_deprecated_function(default_conf):
     default_location = Path(__file__).parent / "strats/broken_strats/"
-    del default_conf['timeframe']
-    default_conf.update({'strategy': 'TestStrategyLegacyV1',
-                         'strategy_path': default_location})
-    with pytest.raises(OperationalException,
-                       match=r"Strategy Interface v1 is no longer supported.*"):
+    del default_conf["timeframe"]
+    default_conf.update({"strategy": "TestStrategyLegacyV1", "strategy_path": default_location})
+    with pytest.raises(
+        OperationalException, match=r"Strategy Interface v1 is no longer supported.*"
+    ):
         StrategyResolver.load_strategy(default_conf)
 
 
 def test_strategy_interface_versioning(dataframe_1m, default_conf):
-    default_conf.update({'strategy': 'StrategyTestV2'})
+    default_conf.update({"strategy": "StrategyTestV2"})
     strategy = StrategyResolver.load_strategy(default_conf)
-    metadata = {'pair': 'ETH/BTC'}
+    metadata = {"pair": "ETH/BTC"}
 
     assert strategy.INTERFACE_VERSION == 2
 
     indicator_df = strategy.advise_indicators(dataframe_1m, metadata=metadata)
     assert isinstance(indicator_df, DataFrame)
-    assert 'adx' in indicator_df.columns
+    assert "adx" in indicator_df.columns
 
     enterdf = strategy.advise_entry(dataframe_1m, metadata=metadata)
     assert isinstance(enterdf, DataFrame)
 
-    assert 'buy' not in enterdf.columns
-    assert 'enter_long' in enterdf.columns
+    assert "buy" not in enterdf.columns
+    assert "enter_long" in enterdf.columns
 
     exitdf = strategy.advise_exit(dataframe_1m, metadata=metadata)
     assert isinstance(exitdf, DataFrame)
-    assert 'sell' not in exitdf
-    assert 'exit_long' in exitdf
+    assert "sell" not in exitdf
+    assert "exit_long" in exitdf
 
 
 def test_strategy_ft_load_params_from_file(mocker, default_conf):
-    default_conf.update({'strategy': 'StrategyTestV2'})
-    del default_conf['max_open_trades']
-    mocker.patch('freqtrade.strategy.hyper.HyperStrategyMixin.load_params_from_file',
-                 return_value={
-                     'params': {
-                         'max_open_trades':  {
-                            'max_open_trades': -1
-                         }
-                         }
-                     })
+    default_conf.update({"strategy": "StrategyTestV2"})
+    del default_conf["max_open_trades"]
+    mocker.patch(
+        "freqtrade.strategy.hyper.HyperStrategyMixin.load_params_from_file",
+        return_value={"params": {"max_open_trades": {"max_open_trades": -1}}},
+    )
     strategy = StrategyResolver.load_strategy(default_conf)
-    assert strategy.max_open_trades == float('inf')
-    assert strategy.config['max_open_trades'] == float('inf')
+    assert strategy.max_open_trades == float("inf")
+    assert strategy.config["max_open_trades"] == float("inf")