2018-07-29 14:09:44 +00:00
|
|
|
# pragma pylint: disable=missing-docstring, protected-access, invalid-name
|
2019-07-14 22:44:25 +00:00
|
|
|
import json
|
2018-07-19 19:12:27 +00:00
|
|
|
import logging
|
2019-11-23 13:20:41 +00:00
|
|
|
import sys
|
2019-07-25 18:35:20 +00:00
|
|
|
import warnings
|
2019-02-24 12:29:22 +00:00
|
|
|
from copy import deepcopy
|
2019-03-29 19:16:52 +00:00
|
|
|
from pathlib import Path
|
2019-07-25 18:35:20 +00:00
|
|
|
from unittest.mock import MagicMock
|
2018-03-17 21:44:47 +00:00
|
|
|
|
|
|
|
import pytest
|
2019-12-15 08:37:08 +00:00
|
|
|
from jsonschema import ValidationError
|
2018-02-04 06:42:03 +00:00
|
|
|
|
2020-01-26 12:41:04 +00:00
|
|
|
from freqtrade.commands import Arguments
|
|
|
|
from freqtrade.configuration import (Configuration, check_exchange,
|
2019-11-05 11:39:19 +00:00
|
|
|
remove_credentials,
|
2019-09-08 07:54:15 +00:00
|
|
|
validate_config_consistency)
|
2019-08-18 14:10:10 +00:00
|
|
|
from freqtrade.configuration.config_validation import validate_config_schema
|
2019-11-23 13:20:41 +00:00
|
|
|
from freqtrade.configuration.deprecated_settings import (
|
|
|
|
check_conflicting_settings, process_deprecated_setting,
|
|
|
|
process_temporary_deprecated_settings)
|
2020-03-23 06:54:27 +00:00
|
|
|
from freqtrade.configuration.load_config import load_config_file, log_config_error_range
|
2018-07-04 07:31:35 +00:00
|
|
|
from freqtrade.constants import DEFAULT_DB_DRYRUN_URL, DEFAULT_DB_PROD_URL
|
2019-12-30 14:02:17 +00:00
|
|
|
from freqtrade.exceptions import OperationalException
|
2019-11-23 13:09:42 +00:00
|
|
|
from freqtrade.loggers import _set_loggers, setup_logging
|
2018-12-25 13:35:48 +00:00
|
|
|
from freqtrade.state import RunMode
|
2019-09-08 07:54:15 +00:00
|
|
|
from tests.conftest import (log_has, log_has_re,
|
|
|
|
patched_configuration_load_config_file)
|
2018-02-04 06:42:03 +00:00
|
|
|
|
|
|
|
|
2019-04-24 07:30:59 +00:00
|
|
|
@pytest.fixture(scope="function")
|
|
|
|
def all_conf():
|
2019-09-08 08:07:09 +00:00
|
|
|
config_file = Path(__file__).parents[1] / "config_full.json.example"
|
2019-08-10 12:15:09 +00:00
|
|
|
conf = load_config_file(str(config_file))
|
2019-04-24 07:30:59 +00:00
|
|
|
return conf
|
|
|
|
|
|
|
|
|
2018-03-30 20:14:35 +00:00
|
|
|
def test_load_config_missing_attributes(default_conf) -> None:
|
2019-11-26 10:48:01 +00:00
|
|
|
conf = deepcopy(default_conf)
|
|
|
|
conf.pop('exchange')
|
2018-02-04 06:42:03 +00:00
|
|
|
|
2019-08-25 18:38:51 +00:00
|
|
|
with pytest.raises(ValidationError, match=r".*'exchange' is a required property.*"):
|
2019-11-26 10:48:01 +00:00
|
|
|
validate_config_schema(conf)
|
|
|
|
|
|
|
|
conf = deepcopy(default_conf)
|
|
|
|
conf.pop('stake_currency')
|
2020-01-02 09:38:59 +00:00
|
|
|
conf['runmode'] = RunMode.DRY_RUN
|
2019-11-26 10:48:01 +00:00
|
|
|
with pytest.raises(ValidationError, match=r".*'stake_currency' is a required property.*"):
|
|
|
|
validate_config_schema(conf)
|
2018-02-04 06:42:03 +00:00
|
|
|
|
|
|
|
|
2018-06-03 22:48:26 +00:00
|
|
|
def test_load_config_incorrect_stake_amount(default_conf) -> None:
|
2018-07-30 12:40:52 +00:00
|
|
|
default_conf['stake_amount'] = 'fake'
|
2018-06-03 22:48:26 +00:00
|
|
|
|
2019-08-25 18:38:51 +00:00
|
|
|
with pytest.raises(ValidationError, match=r".*'fake' does not match 'unlimited'.*"):
|
2019-07-11 18:23:23 +00:00
|
|
|
validate_config_schema(default_conf)
|
2018-06-03 22:48:26 +00:00
|
|
|
|
|
|
|
|
2018-02-04 06:42:03 +00:00
|
|
|
def test_load_config_file(default_conf, mocker, caplog) -> None:
|
2019-07-21 14:06:44 +00:00
|
|
|
del default_conf['user_data_dir']
|
2019-08-10 12:15:09 +00:00
|
|
|
file_mock = mocker.patch('freqtrade.configuration.load_config.open', mocker.mock_open(
|
2019-07-14 22:44:25 +00:00
|
|
|
read_data=json.dumps(default_conf)
|
|
|
|
))
|
2018-02-04 06:42:03 +00:00
|
|
|
|
2019-08-10 12:15:09 +00:00
|
|
|
validated_conf = load_config_file('somefile')
|
2018-02-04 06:42:03 +00:00
|
|
|
assert file_mock.call_count == 1
|
|
|
|
assert validated_conf.items() >= default_conf.items()
|
|
|
|
|
|
|
|
|
2020-03-22 19:15:33 +00:00
|
|
|
def test_load_config_file_error(default_conf, mocker, caplog) -> None:
|
|
|
|
del default_conf['user_data_dir']
|
|
|
|
filedata = json.dumps(default_conf).replace(
|
|
|
|
'"stake_amount": 0.001,', '"stake_amount": .001,')
|
|
|
|
mocker.patch('freqtrade.configuration.load_config.open', mocker.mock_open(read_data=filedata))
|
|
|
|
mocker.patch.object(Path, "read_text", MagicMock(return_value=filedata))
|
|
|
|
|
2020-05-18 09:40:25 +00:00
|
|
|
with pytest.raises(OperationalException, match=r".*Please verify the following segment.*"):
|
2020-03-22 19:15:33 +00:00
|
|
|
load_config_file('somefile')
|
|
|
|
|
|
|
|
|
2020-03-23 06:54:27 +00:00
|
|
|
def test_load_config_file_error_range(default_conf, mocker, caplog) -> None:
|
|
|
|
del default_conf['user_data_dir']
|
|
|
|
filedata = json.dumps(default_conf).replace(
|
|
|
|
'"stake_amount": 0.001,', '"stake_amount": .001,')
|
|
|
|
mocker.patch.object(Path, "read_text", MagicMock(return_value=filedata))
|
|
|
|
|
|
|
|
x = log_config_error_range('somefile', 'Parse error at offset 64: Invalid value.')
|
|
|
|
assert isinstance(x, str)
|
|
|
|
assert (x == '{"max_open_trades": 1, "stake_currency": "BTC", '
|
|
|
|
'"stake_amount": .001, "fiat_display_currency": "USD", '
|
|
|
|
'"ticker_interval": "5m", "dry_run": true, ')
|
|
|
|
|
|
|
|
|
2019-07-25 18:35:20 +00:00
|
|
|
def test__args_to_config(caplog):
|
|
|
|
|
2019-09-14 11:38:26 +00:00
|
|
|
arg_list = ['trade', '--strategy-path', 'TestTest']
|
2019-09-04 14:38:33 +00:00
|
|
|
args = Arguments(arg_list).get_parsed_arg()
|
2019-07-25 18:35:20 +00:00
|
|
|
configuration = Configuration(args)
|
|
|
|
config = {}
|
|
|
|
with warnings.catch_warnings(record=True) as w:
|
2020-03-24 19:10:15 +00:00
|
|
|
warnings.simplefilter("always")
|
2019-07-25 18:35:20 +00:00
|
|
|
# No warnings ...
|
|
|
|
configuration._args_to_config(config, argname="strategy_path", logstring="DeadBeef")
|
|
|
|
assert len(w) == 0
|
2019-08-11 18:17:39 +00:00
|
|
|
assert log_has("DeadBeef", caplog)
|
2019-07-25 18:35:20 +00:00
|
|
|
assert config['strategy_path'] == "TestTest"
|
|
|
|
|
|
|
|
configuration = Configuration(args)
|
|
|
|
config = {}
|
|
|
|
with warnings.catch_warnings(record=True) as w:
|
2020-03-24 19:10:15 +00:00
|
|
|
warnings.simplefilter("always")
|
2019-07-25 18:35:20 +00:00
|
|
|
# Deprecation warnings!
|
|
|
|
configuration._args_to_config(config, argname="strategy_path", logstring="DeadBeef",
|
|
|
|
deprecated_msg="Going away soon!")
|
|
|
|
assert len(w) == 1
|
|
|
|
assert issubclass(w[-1].category, DeprecationWarning)
|
|
|
|
assert "DEPRECATED: Going away soon!" in str(w[-1].message)
|
2019-08-11 18:17:39 +00:00
|
|
|
assert log_has("DeadBeef", caplog)
|
2019-07-25 18:35:20 +00:00
|
|
|
assert config['strategy_path'] == "TestTest"
|
|
|
|
|
|
|
|
|
2018-05-03 08:48:25 +00:00
|
|
|
def test_load_config_max_open_trades_zero(default_conf, mocker, caplog) -> None:
|
2018-07-30 12:40:52 +00:00
|
|
|
default_conf['max_open_trades'] = 0
|
2019-07-14 22:44:25 +00:00
|
|
|
patched_configuration_load_config_file(mocker, default_conf)
|
2018-05-03 08:48:25 +00:00
|
|
|
|
2019-09-14 11:38:26 +00:00
|
|
|
args = Arguments(['trade']).get_parsed_arg()
|
2019-02-20 14:54:20 +00:00
|
|
|
configuration = Configuration(args)
|
|
|
|
validated_conf = configuration.load_config()
|
|
|
|
|
|
|
|
assert validated_conf['max_open_trades'] == 0
|
|
|
|
assert 'internals' in validated_conf
|
2018-05-03 08:48:25 +00:00
|
|
|
|
|
|
|
|
2019-02-24 12:29:22 +00:00
|
|
|
def test_load_config_combine_dicts(default_conf, mocker, caplog) -> None:
|
|
|
|
conf1 = deepcopy(default_conf)
|
|
|
|
conf2 = deepcopy(default_conf)
|
|
|
|
del conf1['exchange']['key']
|
|
|
|
del conf1['exchange']['secret']
|
|
|
|
del conf2['exchange']['name']
|
|
|
|
conf2['exchange']['pair_whitelist'] += ['NANO/BTC']
|
|
|
|
|
|
|
|
config_files = [conf1, conf2]
|
|
|
|
|
|
|
|
configsmock = MagicMock(side_effect=config_files)
|
2019-07-11 22:41:09 +00:00
|
|
|
mocker.patch(
|
2019-08-10 15:47:58 +00:00
|
|
|
'freqtrade.configuration.configuration.load_config_file',
|
2019-07-11 22:41:09 +00:00
|
|
|
configsmock
|
|
|
|
)
|
2019-02-24 12:29:22 +00:00
|
|
|
|
2019-09-14 11:38:26 +00:00
|
|
|
arg_list = ['trade', '-c', 'test_conf.json', '--config', 'test2_conf.json', ]
|
2019-09-04 14:38:33 +00:00
|
|
|
args = Arguments(arg_list).get_parsed_arg()
|
2019-02-24 12:29:22 +00:00
|
|
|
configuration = Configuration(args)
|
|
|
|
validated_conf = configuration.load_config()
|
|
|
|
|
|
|
|
exchange_conf = default_conf['exchange']
|
|
|
|
assert validated_conf['exchange']['name'] == exchange_conf['name']
|
|
|
|
assert validated_conf['exchange']['key'] == exchange_conf['key']
|
|
|
|
assert validated_conf['exchange']['secret'] == exchange_conf['secret']
|
|
|
|
assert validated_conf['exchange']['pair_whitelist'] != conf1['exchange']['pair_whitelist']
|
|
|
|
assert validated_conf['exchange']['pair_whitelist'] == conf2['exchange']['pair_whitelist']
|
|
|
|
|
|
|
|
assert 'internals' in validated_conf
|
|
|
|
|
|
|
|
|
2019-08-10 18:02:11 +00:00
|
|
|
def test_from_config(default_conf, mocker, caplog) -> None:
|
|
|
|
conf1 = deepcopy(default_conf)
|
|
|
|
conf2 = deepcopy(default_conf)
|
|
|
|
del conf1['exchange']['key']
|
|
|
|
del conf1['exchange']['secret']
|
|
|
|
del conf2['exchange']['name']
|
|
|
|
conf2['exchange']['pair_whitelist'] += ['NANO/BTC']
|
|
|
|
conf2['fiat_display_currency'] = "EUR"
|
|
|
|
config_files = [conf1, conf2]
|
2019-09-20 06:34:18 +00:00
|
|
|
mocker.patch('freqtrade.configuration.configuration.create_datadir', lambda c, x: x)
|
2019-08-10 18:02:11 +00:00
|
|
|
|
|
|
|
configsmock = MagicMock(side_effect=config_files)
|
2019-09-20 17:51:31 +00:00
|
|
|
mocker.patch('freqtrade.configuration.configuration.load_config_file', configsmock)
|
2019-08-10 18:02:11 +00:00
|
|
|
|
|
|
|
validated_conf = Configuration.from_files(['test_conf.json', 'test2_conf.json'])
|
|
|
|
|
|
|
|
exchange_conf = default_conf['exchange']
|
|
|
|
assert validated_conf['exchange']['name'] == exchange_conf['name']
|
|
|
|
assert validated_conf['exchange']['key'] == exchange_conf['key']
|
|
|
|
assert validated_conf['exchange']['secret'] == exchange_conf['secret']
|
|
|
|
assert validated_conf['exchange']['pair_whitelist'] != conf1['exchange']['pair_whitelist']
|
|
|
|
assert validated_conf['exchange']['pair_whitelist'] == conf2['exchange']['pair_whitelist']
|
|
|
|
assert validated_conf['fiat_display_currency'] == "EUR"
|
|
|
|
assert 'internals' in validated_conf
|
2019-09-20 05:02:54 +00:00
|
|
|
assert isinstance(validated_conf['user_data_dir'], Path)
|
|
|
|
|
|
|
|
|
|
|
|
def test_print_config(default_conf, mocker, caplog) -> None:
|
|
|
|
conf1 = deepcopy(default_conf)
|
|
|
|
# Delete non-json elements from default_conf
|
|
|
|
del conf1['user_data_dir']
|
|
|
|
config_files = [conf1]
|
|
|
|
|
|
|
|
configsmock = MagicMock(side_effect=config_files)
|
2019-09-20 06:34:18 +00:00
|
|
|
mocker.patch('freqtrade.configuration.configuration.create_datadir', lambda c, x: x)
|
|
|
|
mocker.patch('freqtrade.configuration.configuration.load_config_file', configsmock)
|
2019-09-20 05:02:54 +00:00
|
|
|
|
|
|
|
validated_conf = Configuration.from_files(['test_conf.json'])
|
|
|
|
|
|
|
|
assert isinstance(validated_conf['user_data_dir'], Path)
|
|
|
|
assert "user_data_dir" in validated_conf
|
|
|
|
assert "original_config" in validated_conf
|
|
|
|
assert isinstance(json.dumps(validated_conf['original_config']), str)
|
2019-02-24 12:29:22 +00:00
|
|
|
|
|
|
|
|
2018-11-14 10:37:53 +00:00
|
|
|
def test_load_config_max_open_trades_minus_one(default_conf, mocker, caplog) -> None:
|
|
|
|
default_conf['max_open_trades'] = -1
|
2019-07-14 22:44:25 +00:00
|
|
|
patched_configuration_load_config_file(mocker, default_conf)
|
2018-11-14 10:37:53 +00:00
|
|
|
|
2019-09-14 11:38:26 +00:00
|
|
|
args = Arguments(['trade']).get_parsed_arg()
|
2018-11-14 10:37:53 +00:00
|
|
|
configuration = Configuration(args)
|
|
|
|
validated_conf = configuration.load_config()
|
|
|
|
|
|
|
|
assert validated_conf['max_open_trades'] > 999999999
|
|
|
|
assert validated_conf['max_open_trades'] == float('inf')
|
2018-12-25 13:35:48 +00:00
|
|
|
assert "runmode" in validated_conf
|
|
|
|
assert validated_conf['runmode'] == RunMode.DRY_RUN
|
2018-11-14 10:37:53 +00:00
|
|
|
|
|
|
|
|
2018-06-08 00:01:38 +00:00
|
|
|
def test_load_config_file_exception(mocker) -> None:
|
2018-03-06 03:44:27 +00:00
|
|
|
mocker.patch(
|
2019-07-11 21:39:42 +00:00
|
|
|
'freqtrade.configuration.configuration.open',
|
2018-03-06 03:44:27 +00:00
|
|
|
MagicMock(side_effect=FileNotFoundError('File not found'))
|
|
|
|
)
|
|
|
|
|
2018-06-08 00:01:38 +00:00
|
|
|
with pytest.raises(OperationalException, match=r'.*Config file "somefile" not found!*'):
|
2019-08-10 12:15:09 +00:00
|
|
|
load_config_file('somefile')
|
2018-03-06 03:44:27 +00:00
|
|
|
|
|
|
|
|
2018-02-04 06:42:03 +00:00
|
|
|
def test_load_config(default_conf, mocker) -> None:
|
2020-02-18 19:26:20 +00:00
|
|
|
del default_conf['strategy_path']
|
2019-07-14 22:44:25 +00:00
|
|
|
patched_configuration_load_config_file(mocker, default_conf)
|
2018-02-04 06:42:03 +00:00
|
|
|
|
2019-09-14 11:38:26 +00:00
|
|
|
args = Arguments(['trade']).get_parsed_arg()
|
2018-02-04 06:42:03 +00:00
|
|
|
configuration = Configuration(args)
|
2018-03-03 21:39:39 +00:00
|
|
|
validated_conf = configuration.load_config()
|
2018-02-04 06:42:03 +00:00
|
|
|
|
2018-03-27 16:29:51 +00:00
|
|
|
assert validated_conf.get('strategy_path') is None
|
2018-12-03 19:31:25 +00:00
|
|
|
assert 'edge' not in validated_conf
|
2018-02-04 06:42:03 +00:00
|
|
|
|
|
|
|
|
|
|
|
def test_load_config_with_params(default_conf, mocker) -> None:
|
2019-07-14 22:44:25 +00:00
|
|
|
patched_configuration_load_config_file(mocker, default_conf)
|
2019-07-11 21:39:42 +00:00
|
|
|
|
2018-05-31 19:04:10 +00:00
|
|
|
arglist = [
|
2019-09-14 11:38:26 +00:00
|
|
|
'trade',
|
2018-03-24 19:44:04 +00:00
|
|
|
'--strategy', 'TestStrategy',
|
2018-03-27 16:29:51 +00:00
|
|
|
'--strategy-path', '/some/path',
|
2018-06-07 03:27:55 +00:00
|
|
|
'--db-url', 'sqlite:///someurl',
|
2018-02-04 06:42:03 +00:00
|
|
|
]
|
2019-09-04 14:38:33 +00:00
|
|
|
args = Arguments(arglist).get_parsed_arg()
|
2018-02-04 06:42:03 +00:00
|
|
|
configuration = Configuration(args)
|
2018-03-03 21:39:39 +00:00
|
|
|
validated_conf = configuration.load_config()
|
2018-02-04 06:42:03 +00:00
|
|
|
|
2018-03-27 16:29:51 +00:00
|
|
|
assert validated_conf.get('strategy') == 'TestStrategy'
|
|
|
|
assert validated_conf.get('strategy_path') == '/some/path'
|
2018-06-07 03:27:55 +00:00
|
|
|
assert validated_conf.get('db_url') == 'sqlite:///someurl'
|
2018-03-27 16:29:51 +00:00
|
|
|
|
2019-01-06 12:47:36 +00:00
|
|
|
# Test conf provided db_url prod
|
|
|
|
conf = default_conf.copy()
|
|
|
|
conf["dry_run"] = False
|
|
|
|
conf["db_url"] = "sqlite:///path/to/db.sqlite"
|
2019-07-14 22:44:25 +00:00
|
|
|
patched_configuration_load_config_file(mocker, conf)
|
2019-01-06 12:47:36 +00:00
|
|
|
|
|
|
|
arglist = [
|
2019-09-14 11:38:26 +00:00
|
|
|
'trade',
|
2019-01-06 12:47:36 +00:00
|
|
|
'--strategy', 'TestStrategy',
|
|
|
|
'--strategy-path', '/some/path'
|
|
|
|
]
|
2019-09-04 14:38:33 +00:00
|
|
|
args = Arguments(arglist).get_parsed_arg()
|
2019-01-06 12:47:36 +00:00
|
|
|
|
|
|
|
configuration = Configuration(args)
|
|
|
|
validated_conf = configuration.load_config()
|
|
|
|
assert validated_conf.get('db_url') == "sqlite:///path/to/db.sqlite"
|
|
|
|
|
|
|
|
# Test conf provided db_url dry_run
|
|
|
|
conf = default_conf.copy()
|
|
|
|
conf["dry_run"] = True
|
|
|
|
conf["db_url"] = "sqlite:///path/to/db.sqlite"
|
2019-07-14 22:44:25 +00:00
|
|
|
patched_configuration_load_config_file(mocker, conf)
|
2019-01-06 12:47:36 +00:00
|
|
|
|
|
|
|
arglist = [
|
2019-09-14 11:38:26 +00:00
|
|
|
'trade',
|
2019-01-06 12:47:36 +00:00
|
|
|
'--strategy', 'TestStrategy',
|
|
|
|
'--strategy-path', '/some/path'
|
|
|
|
]
|
2019-09-04 14:38:33 +00:00
|
|
|
args = Arguments(arglist).get_parsed_arg()
|
2019-01-06 12:47:36 +00:00
|
|
|
|
|
|
|
configuration = Configuration(args)
|
|
|
|
validated_conf = configuration.load_config()
|
|
|
|
assert validated_conf.get('db_url') == "sqlite:///path/to/db.sqlite"
|
|
|
|
|
|
|
|
# Test args provided db_url prod
|
2018-06-16 18:55:35 +00:00
|
|
|
conf = default_conf.copy()
|
|
|
|
conf["dry_run"] = False
|
|
|
|
del conf["db_url"]
|
2019-07-14 22:44:25 +00:00
|
|
|
patched_configuration_load_config_file(mocker, conf)
|
2018-06-16 18:55:35 +00:00
|
|
|
|
|
|
|
arglist = [
|
2019-09-14 11:38:26 +00:00
|
|
|
'trade',
|
2018-07-29 14:09:44 +00:00
|
|
|
'--strategy', 'TestStrategy',
|
|
|
|
'--strategy-path', '/some/path'
|
|
|
|
]
|
2019-09-04 14:38:33 +00:00
|
|
|
args = Arguments(arglist).get_parsed_arg()
|
2018-06-16 18:55:35 +00:00
|
|
|
|
|
|
|
configuration = Configuration(args)
|
|
|
|
validated_conf = configuration.load_config()
|
|
|
|
assert validated_conf.get('db_url') == DEFAULT_DB_PROD_URL
|
2018-12-25 13:35:48 +00:00
|
|
|
assert "runmode" in validated_conf
|
|
|
|
assert validated_conf['runmode'] == RunMode.LIVE
|
2018-06-16 18:55:35 +00:00
|
|
|
|
2019-01-06 12:47:36 +00:00
|
|
|
# Test args provided db_url dry_run
|
2018-06-16 18:55:35 +00:00
|
|
|
conf = default_conf.copy()
|
|
|
|
conf["dry_run"] = True
|
|
|
|
conf["db_url"] = DEFAULT_DB_PROD_URL
|
2019-07-14 22:44:25 +00:00
|
|
|
patched_configuration_load_config_file(mocker, conf)
|
2018-06-16 18:55:35 +00:00
|
|
|
|
|
|
|
arglist = [
|
2019-09-14 11:38:26 +00:00
|
|
|
'trade',
|
2018-06-16 18:55:35 +00:00
|
|
|
'--strategy', 'TestStrategy',
|
|
|
|
'--strategy-path', '/some/path'
|
|
|
|
]
|
2019-09-04 14:38:33 +00:00
|
|
|
args = Arguments(arglist).get_parsed_arg()
|
2018-06-16 18:55:35 +00:00
|
|
|
|
|
|
|
configuration = Configuration(args)
|
|
|
|
validated_conf = configuration.load_config()
|
|
|
|
assert validated_conf.get('db_url') == DEFAULT_DB_DRYRUN_URL
|
|
|
|
|
2018-03-27 16:29:51 +00:00
|
|
|
|
2019-10-15 04:51:03 +00:00
|
|
|
@pytest.mark.parametrize("config_value,expected,arglist", [
|
|
|
|
(True, True, ['trade', '--dry-run']), # Leave config untouched
|
|
|
|
(False, True, ['trade', '--dry-run']), # Override config untouched
|
|
|
|
(False, False, ['trade']), # Leave config untouched
|
|
|
|
(True, True, ['trade']), # Leave config untouched
|
|
|
|
])
|
|
|
|
def test_load_dry_run(default_conf, mocker, config_value, expected, arglist) -> None:
|
|
|
|
|
|
|
|
default_conf['dry_run'] = config_value
|
|
|
|
patched_configuration_load_config_file(mocker, default_conf)
|
|
|
|
|
|
|
|
configuration = Configuration(Arguments(arglist).get_parsed_arg())
|
|
|
|
validated_conf = configuration.load_config()
|
|
|
|
|
2020-01-20 19:24:40 +00:00
|
|
|
assert validated_conf['dry_run'] is expected
|
2020-02-27 18:35:58 +00:00
|
|
|
assert validated_conf['runmode'] == (RunMode.DRY_RUN if expected else RunMode.LIVE)
|
2019-10-15 04:51:03 +00:00
|
|
|
|
|
|
|
|
2018-03-27 16:29:51 +00:00
|
|
|
def test_load_custom_strategy(default_conf, mocker) -> None:
|
2018-07-30 12:40:52 +00:00
|
|
|
default_conf.update({
|
2018-03-27 16:29:51 +00:00
|
|
|
'strategy': 'CustomStrategy',
|
|
|
|
'strategy_path': '/tmp/strategies',
|
|
|
|
})
|
2019-07-14 22:44:25 +00:00
|
|
|
patched_configuration_load_config_file(mocker, default_conf)
|
2018-03-27 16:29:51 +00:00
|
|
|
|
2019-09-14 11:38:26 +00:00
|
|
|
args = Arguments(['trade']).get_parsed_arg()
|
2018-03-27 16:29:51 +00:00
|
|
|
configuration = Configuration(args)
|
|
|
|
validated_conf = configuration.load_config()
|
|
|
|
|
|
|
|
assert validated_conf.get('strategy') == 'CustomStrategy'
|
|
|
|
assert validated_conf.get('strategy_path') == '/tmp/strategies'
|
2018-02-04 06:42:03 +00:00
|
|
|
|
|
|
|
|
|
|
|
def test_show_info(default_conf, mocker, caplog) -> None:
|
2019-07-14 22:44:25 +00:00
|
|
|
patched_configuration_load_config_file(mocker, default_conf)
|
2019-07-11 21:39:42 +00:00
|
|
|
|
2018-05-31 19:04:10 +00:00
|
|
|
arglist = [
|
2019-09-14 11:38:26 +00:00
|
|
|
'trade',
|
2018-03-24 19:44:04 +00:00
|
|
|
'--strategy', 'TestStrategy',
|
2018-06-07 03:27:55 +00:00
|
|
|
'--db-url', 'sqlite:///tmp/testdb',
|
2018-02-04 06:42:03 +00:00
|
|
|
]
|
2019-09-04 14:38:33 +00:00
|
|
|
args = Arguments(arglist).get_parsed_arg()
|
2018-02-04 06:42:03 +00:00
|
|
|
|
|
|
|
configuration = Configuration(args)
|
2018-03-03 21:39:39 +00:00
|
|
|
configuration.get_config()
|
|
|
|
|
2019-08-11 18:17:39 +00:00
|
|
|
assert log_has('Using DB: "sqlite:///tmp/testdb"', caplog)
|
|
|
|
assert log_has('Dry run is enabled', caplog)
|
2018-02-09 07:35:38 +00:00
|
|
|
|
|
|
|
|
|
|
|
def test_setup_configuration_without_arguments(mocker, default_conf, caplog) -> None:
|
2019-07-14 22:44:25 +00:00
|
|
|
patched_configuration_load_config_file(mocker, default_conf)
|
2019-07-11 21:39:42 +00:00
|
|
|
|
2018-05-31 19:04:10 +00:00
|
|
|
arglist = [
|
2019-09-14 11:38:26 +00:00
|
|
|
'backtesting',
|
2018-02-09 07:35:38 +00:00
|
|
|
'--config', 'config.json',
|
2018-03-24 19:44:04 +00:00
|
|
|
'--strategy', 'DefaultStrategy',
|
2018-02-09 07:35:38 +00:00
|
|
|
]
|
|
|
|
|
2019-09-04 14:38:33 +00:00
|
|
|
args = Arguments(arglist).get_parsed_arg()
|
2018-02-09 07:35:38 +00:00
|
|
|
|
|
|
|
configuration = Configuration(args)
|
|
|
|
config = configuration.get_config()
|
|
|
|
assert 'max_open_trades' in config
|
|
|
|
assert 'stake_currency' in config
|
|
|
|
assert 'stake_amount' in config
|
|
|
|
assert 'exchange' in config
|
|
|
|
assert 'pair_whitelist' in config['exchange']
|
|
|
|
assert 'datadir' in config
|
2019-07-21 13:56:32 +00:00
|
|
|
assert 'user_data_dir' in config
|
2019-08-11 18:17:39 +00:00
|
|
|
assert log_has('Using data directory: {} ...'.format(config['datadir']), caplog)
|
2018-02-09 07:35:38 +00:00
|
|
|
assert 'ticker_interval' in config
|
2019-08-11 18:17:39 +00:00
|
|
|
assert not log_has('Parameter -i/--ticker-interval detected ...', caplog)
|
2018-02-09 07:35:38 +00:00
|
|
|
|
2018-07-17 18:26:59 +00:00
|
|
|
assert 'position_stacking' not in config
|
2019-08-11 18:17:39 +00:00
|
|
|
assert not log_has('Parameter --enable-position-stacking detected ...', caplog)
|
2018-02-09 07:35:38 +00:00
|
|
|
|
|
|
|
assert 'timerange' not in config
|
|
|
|
assert 'export' not in config
|
|
|
|
|
|
|
|
|
|
|
|
def test_setup_configuration_with_arguments(mocker, default_conf, caplog) -> None:
|
2019-07-14 22:44:25 +00:00
|
|
|
patched_configuration_load_config_file(mocker, default_conf)
|
2019-07-11 22:41:09 +00:00
|
|
|
mocker.patch(
|
2019-07-12 00:26:27 +00:00
|
|
|
'freqtrade.configuration.configuration.create_datadir',
|
|
|
|
lambda c, x: x
|
2019-07-11 22:41:09 +00:00
|
|
|
)
|
2019-07-21 12:32:29 +00:00
|
|
|
mocker.patch(
|
|
|
|
'freqtrade.configuration.configuration.create_userdata_dir',
|
2019-07-31 17:39:54 +00:00
|
|
|
lambda x, *args, **kwargs: Path(x)
|
2019-07-21 12:32:29 +00:00
|
|
|
)
|
2018-05-31 19:04:10 +00:00
|
|
|
arglist = [
|
2019-09-14 11:38:26 +00:00
|
|
|
'backtesting',
|
2018-02-09 07:35:38 +00:00
|
|
|
'--config', 'config.json',
|
2018-03-24 19:44:04 +00:00
|
|
|
'--strategy', 'DefaultStrategy',
|
2018-02-09 07:35:38 +00:00
|
|
|
'--datadir', '/foo/bar',
|
2019-07-21 12:32:29 +00:00
|
|
|
'--userdir', "/tmp/freqtrade",
|
2018-02-03 16:15:40 +00:00
|
|
|
'--ticker-interval', '1m',
|
2018-07-17 18:26:59 +00:00
|
|
|
'--enable-position-stacking',
|
2018-07-17 19:05:03 +00:00
|
|
|
'--disable-max-market-positions',
|
2018-02-09 07:35:38 +00:00
|
|
|
'--timerange', ':100',
|
|
|
|
'--export', '/bar/foo'
|
|
|
|
]
|
|
|
|
|
2019-09-04 14:38:33 +00:00
|
|
|
args = Arguments(arglist).get_parsed_arg()
|
2018-02-09 07:35:38 +00:00
|
|
|
|
|
|
|
configuration = Configuration(args)
|
|
|
|
config = configuration.get_config()
|
|
|
|
assert 'max_open_trades' in config
|
|
|
|
assert 'stake_currency' in config
|
|
|
|
assert 'stake_amount' in config
|
|
|
|
assert 'exchange' in config
|
|
|
|
assert 'pair_whitelist' in config['exchange']
|
|
|
|
assert 'datadir' in config
|
2019-08-18 13:00:12 +00:00
|
|
|
assert log_has('Using data directory: {} ...'.format("/foo/bar"), caplog)
|
2019-10-18 09:31:43 +00:00
|
|
|
assert log_has('Using user-data directory: {} ...'.format(Path("/tmp/freqtrade")), caplog)
|
2019-07-21 13:56:32 +00:00
|
|
|
assert 'user_data_dir' in config
|
|
|
|
|
2018-02-09 07:35:38 +00:00
|
|
|
assert 'ticker_interval' in config
|
2019-04-24 19:24:00 +00:00
|
|
|
assert log_has('Parameter -i/--ticker-interval detected ... Using ticker_interval: 1m ...',
|
2019-08-11 18:17:39 +00:00
|
|
|
caplog)
|
2018-02-09 07:35:38 +00:00
|
|
|
|
2019-10-05 13:34:31 +00:00
|
|
|
assert 'position_stacking' in config
|
2019-08-11 18:17:39 +00:00
|
|
|
assert log_has('Parameter --enable-position-stacking detected ...', caplog)
|
2018-07-17 19:05:03 +00:00
|
|
|
|
|
|
|
assert 'use_max_market_positions' in config
|
2019-08-11 18:17:39 +00:00
|
|
|
assert log_has('Parameter --disable-max-market-positions detected ...', caplog)
|
|
|
|
assert log_has('max_open_trades set to unlimited ...', caplog)
|
2018-02-09 07:35:38 +00:00
|
|
|
|
|
|
|
assert 'timerange' in config
|
2019-08-11 18:17:39 +00:00
|
|
|
assert log_has('Parameter --timerange detected: {} ...'.format(config['timerange']), caplog)
|
2018-02-09 07:35:38 +00:00
|
|
|
|
|
|
|
assert 'export' in config
|
2019-08-11 18:17:39 +00:00
|
|
|
assert log_has('Parameter --export detected: {} ...'.format(config['export']), caplog)
|
2018-03-04 08:51:22 +00:00
|
|
|
|
|
|
|
|
2018-07-28 04:40:39 +00:00
|
|
|
def test_setup_configuration_with_stratlist(mocker, default_conf, caplog) -> None:
|
|
|
|
"""
|
|
|
|
Test setup_configuration() function
|
|
|
|
"""
|
2019-07-14 22:44:25 +00:00
|
|
|
patched_configuration_load_config_file(mocker, default_conf)
|
2018-07-28 04:40:39 +00:00
|
|
|
|
|
|
|
arglist = [
|
|
|
|
'backtesting',
|
2019-09-14 11:38:26 +00:00
|
|
|
'--config', 'config.json',
|
2018-07-28 04:40:39 +00:00
|
|
|
'--ticker-interval', '1m',
|
|
|
|
'--export', '/bar/foo',
|
|
|
|
'--strategy-list',
|
|
|
|
'DefaultStrategy',
|
|
|
|
'TestStrategy'
|
|
|
|
]
|
|
|
|
|
2019-09-04 14:38:33 +00:00
|
|
|
args = Arguments(arglist).get_parsed_arg()
|
2018-07-28 04:40:39 +00:00
|
|
|
|
2018-12-25 13:35:48 +00:00
|
|
|
configuration = Configuration(args, RunMode.BACKTEST)
|
2018-07-28 04:40:39 +00:00
|
|
|
config = configuration.get_config()
|
2018-12-25 13:35:48 +00:00
|
|
|
assert config['runmode'] == RunMode.BACKTEST
|
2018-07-28 04:40:39 +00:00
|
|
|
assert 'max_open_trades' in config
|
|
|
|
assert 'stake_currency' in config
|
|
|
|
assert 'stake_amount' in config
|
|
|
|
assert 'exchange' in config
|
|
|
|
assert 'pair_whitelist' in config['exchange']
|
|
|
|
assert 'datadir' in config
|
2019-08-11 18:17:39 +00:00
|
|
|
assert log_has('Using data directory: {} ...'.format(config['datadir']), caplog)
|
2018-07-28 04:40:39 +00:00
|
|
|
assert 'ticker_interval' in config
|
2019-04-24 19:24:00 +00:00
|
|
|
assert log_has('Parameter -i/--ticker-interval detected ... Using ticker_interval: 1m ...',
|
2019-08-11 18:17:39 +00:00
|
|
|
caplog)
|
2018-07-28 04:40:39 +00:00
|
|
|
|
|
|
|
assert 'strategy_list' in config
|
2019-09-18 19:57:37 +00:00
|
|
|
assert log_has('Using strategy list of 2 strategies', caplog)
|
2018-07-28 04:40:39 +00:00
|
|
|
|
|
|
|
assert 'position_stacking' not in config
|
|
|
|
|
|
|
|
assert 'use_max_market_positions' not in config
|
|
|
|
|
|
|
|
assert 'timerange' not in config
|
|
|
|
|
|
|
|
assert 'export' in config
|
2019-08-11 18:17:39 +00:00
|
|
|
assert log_has('Parameter --export detected: {} ...'.format(config['export']), caplog)
|
2018-07-28 04:40:39 +00:00
|
|
|
|
|
|
|
|
2018-03-05 07:12:34 +00:00
|
|
|
def test_hyperopt_with_arguments(mocker, default_conf, caplog) -> None:
|
2019-07-14 22:44:25 +00:00
|
|
|
patched_configuration_load_config_file(mocker, default_conf)
|
2019-07-11 21:39:42 +00:00
|
|
|
|
2018-05-31 19:04:10 +00:00
|
|
|
arglist = [
|
2018-03-04 08:51:22 +00:00
|
|
|
'hyperopt',
|
2018-03-05 07:12:34 +00:00
|
|
|
'--epochs', '10',
|
2018-03-04 08:51:22 +00:00
|
|
|
'--spaces', 'all',
|
|
|
|
]
|
2019-09-04 14:38:33 +00:00
|
|
|
args = Arguments(arglist).get_parsed_arg()
|
2018-03-04 08:51:22 +00:00
|
|
|
|
2018-12-25 13:35:48 +00:00
|
|
|
configuration = Configuration(args, RunMode.HYPEROPT)
|
2018-03-04 08:51:22 +00:00
|
|
|
config = configuration.get_config()
|
2018-03-05 07:12:34 +00:00
|
|
|
|
|
|
|
assert 'epochs' in config
|
|
|
|
assert int(config['epochs']) == 10
|
2019-04-24 19:12:23 +00:00
|
|
|
assert log_has('Parameter --epochs detected ... Will run Hyperopt with for 10 epochs ...',
|
2019-08-11 18:17:39 +00:00
|
|
|
caplog)
|
2018-03-05 07:12:34 +00:00
|
|
|
|
2018-03-04 08:51:22 +00:00
|
|
|
assert 'spaces' in config
|
2018-03-04 08:58:20 +00:00
|
|
|
assert config['spaces'] == ['all']
|
2019-08-25 18:38:51 +00:00
|
|
|
assert log_has("Parameter -s/--spaces detected: ['all']", caplog)
|
2018-12-25 13:35:48 +00:00
|
|
|
assert "runmode" in config
|
|
|
|
assert config['runmode'] == RunMode.HYPEROPT
|
2018-03-30 20:14:35 +00:00
|
|
|
|
|
|
|
|
2018-10-04 18:35:28 +00:00
|
|
|
def test_check_exchange(default_conf, caplog) -> None:
|
2019-06-14 15:40:25 +00:00
|
|
|
# Test an officially supported by Freqtrade team exchange
|
2019-08-31 13:19:59 +00:00
|
|
|
default_conf['runmode'] = RunMode.DRY_RUN
|
2018-07-30 12:40:52 +00:00
|
|
|
default_conf.get('exchange').update({'name': 'BITTREX'})
|
2019-07-11 18:23:23 +00:00
|
|
|
assert check_exchange(default_conf)
|
2019-06-15 11:14:07 +00:00
|
|
|
assert log_has_re(r"Exchange .* is officially supported by the Freqtrade development team\.",
|
2019-08-11 18:17:39 +00:00
|
|
|
caplog)
|
2019-06-15 11:14:07 +00:00
|
|
|
caplog.clear()
|
2018-03-30 20:14:35 +00:00
|
|
|
|
2019-06-14 15:40:25 +00:00
|
|
|
# Test an officially supported by Freqtrade team exchange
|
2018-07-30 12:40:52 +00:00
|
|
|
default_conf.get('exchange').update({'name': 'binance'})
|
2019-07-11 18:23:23 +00:00
|
|
|
assert check_exchange(default_conf)
|
2019-06-15 11:14:07 +00:00
|
|
|
assert log_has_re(r"Exchange .* is officially supported by the Freqtrade development team\.",
|
2019-08-11 18:17:39 +00:00
|
|
|
caplog)
|
2019-06-15 11:14:07 +00:00
|
|
|
caplog.clear()
|
2018-03-30 20:14:35 +00:00
|
|
|
|
2019-06-14 15:40:25 +00:00
|
|
|
# Test an available exchange, supported by ccxt
|
2019-09-05 18:16:09 +00:00
|
|
|
default_conf.get('exchange').update({'name': 'huobipro'})
|
2019-07-11 18:23:23 +00:00
|
|
|
assert check_exchange(default_conf)
|
2019-09-30 21:33:54 +00:00
|
|
|
assert log_has_re(r"Exchange .* is known to the the ccxt library, available for the bot, "
|
|
|
|
r"but not officially supported "
|
2019-08-11 18:17:39 +00:00
|
|
|
r"by the Freqtrade development team\. .*", caplog)
|
2019-06-15 11:14:07 +00:00
|
|
|
caplog.clear()
|
2019-06-14 15:40:25 +00:00
|
|
|
|
|
|
|
# Test a 'bad' exchange, which known to have serious problems
|
|
|
|
default_conf.get('exchange').update({'name': 'bitmex'})
|
2019-08-13 06:26:10 +00:00
|
|
|
with pytest.raises(OperationalException,
|
|
|
|
match=r"Exchange .* is known to not work with the bot yet.*"):
|
|
|
|
check_exchange(default_conf)
|
2019-06-15 11:14:07 +00:00
|
|
|
caplog.clear()
|
2019-06-14 15:40:25 +00:00
|
|
|
|
|
|
|
# Test a 'bad' exchange with check_for_bad=False
|
|
|
|
default_conf.get('exchange').update({'name': 'bitmex'})
|
2019-07-11 18:23:23 +00:00
|
|
|
assert check_exchange(default_conf, False)
|
2019-09-30 21:33:54 +00:00
|
|
|
assert log_has_re(r"Exchange .* is known to the the ccxt library, available for the bot, "
|
|
|
|
r"but not officially supported "
|
2019-08-11 18:17:39 +00:00
|
|
|
r"by the Freqtrade development team\. .*", caplog)
|
2019-06-15 11:14:07 +00:00
|
|
|
caplog.clear()
|
2019-06-14 15:40:25 +00:00
|
|
|
|
|
|
|
# Test an invalid exchange
|
2018-07-30 12:40:52 +00:00
|
|
|
default_conf.get('exchange').update({'name': 'unknown_exchange'})
|
2018-03-30 20:14:35 +00:00
|
|
|
with pytest.raises(
|
|
|
|
OperationalException,
|
2019-09-30 21:33:54 +00:00
|
|
|
match=r'Exchange "unknown_exchange" is not known to the ccxt library '
|
2019-06-12 20:03:16 +00:00
|
|
|
r'and therefore not available for the bot.*'
|
2018-03-30 20:14:35 +00:00
|
|
|
):
|
2019-07-11 18:23:23 +00:00
|
|
|
check_exchange(default_conf)
|
2018-07-19 19:12:27 +00:00
|
|
|
|
2019-08-31 13:19:59 +00:00
|
|
|
# Test no exchange...
|
|
|
|
default_conf.get('exchange').update({'name': ''})
|
|
|
|
default_conf['runmode'] = RunMode.PLOT
|
|
|
|
assert check_exchange(default_conf)
|
|
|
|
|
2019-09-21 09:24:51 +00:00
|
|
|
# Test no exchange...
|
|
|
|
default_conf.get('exchange').update({'name': ''})
|
2019-11-03 09:18:46 +00:00
|
|
|
default_conf['runmode'] = RunMode.UTIL_EXCHANGE
|
2019-09-21 09:24:51 +00:00
|
|
|
with pytest.raises(OperationalException,
|
|
|
|
match=r'This command requires a configured exchange.*'):
|
|
|
|
check_exchange(default_conf)
|
|
|
|
|
2018-07-19 19:12:27 +00:00
|
|
|
|
2019-11-05 11:39:19 +00:00
|
|
|
def test_remove_credentials(default_conf, caplog) -> None:
|
|
|
|
conf = deepcopy(default_conf)
|
|
|
|
conf['dry_run'] = False
|
|
|
|
remove_credentials(conf)
|
|
|
|
|
|
|
|
assert conf['dry_run'] is True
|
|
|
|
assert conf['exchange']['key'] == ''
|
|
|
|
assert conf['exchange']['secret'] == ''
|
|
|
|
assert conf['exchange']['password'] == ''
|
|
|
|
assert conf['exchange']['uid'] == ''
|
|
|
|
|
|
|
|
|
2018-07-19 19:12:27 +00:00
|
|
|
def test_cli_verbose_with_params(default_conf, mocker, caplog) -> None:
|
2019-07-14 22:44:25 +00:00
|
|
|
patched_configuration_load_config_file(mocker, default_conf)
|
2019-07-11 21:39:42 +00:00
|
|
|
|
2018-07-19 19:12:27 +00:00
|
|
|
# Prevent setting loggers
|
2019-07-06 21:31:48 +00:00
|
|
|
mocker.patch('freqtrade.loggers._set_loggers', MagicMock)
|
2019-09-14 11:38:26 +00:00
|
|
|
arglist = ['trade', '-vvv']
|
2019-09-04 14:38:33 +00:00
|
|
|
args = Arguments(arglist).get_parsed_arg()
|
2018-07-19 19:12:27 +00:00
|
|
|
|
|
|
|
configuration = Configuration(args)
|
|
|
|
validated_conf = configuration.load_config()
|
|
|
|
|
|
|
|
assert validated_conf.get('verbosity') == 3
|
2019-08-11 18:17:39 +00:00
|
|
|
assert log_has('Verbosity set to 3', caplog)
|
2018-07-19 19:12:27 +00:00
|
|
|
|
|
|
|
|
|
|
|
def test_set_loggers() -> None:
|
|
|
|
# Reset Logging to Debug, otherwise this fails randomly as it's set globally
|
|
|
|
logging.getLogger('requests').setLevel(logging.DEBUG)
|
|
|
|
logging.getLogger("urllib3").setLevel(logging.DEBUG)
|
|
|
|
logging.getLogger('ccxt.base.exchange').setLevel(logging.DEBUG)
|
|
|
|
logging.getLogger('telegram').setLevel(logging.DEBUG)
|
|
|
|
|
|
|
|
previous_value1 = logging.getLogger('requests').level
|
|
|
|
previous_value2 = logging.getLogger('ccxt.base.exchange').level
|
|
|
|
previous_value3 = logging.getLogger('telegram').level
|
2020-05-31 07:57:31 +00:00
|
|
|
previous_value3 = logging.getLogger('werkzeug').level
|
2018-07-19 19:12:27 +00:00
|
|
|
|
2019-07-06 21:31:48 +00:00
|
|
|
_set_loggers()
|
2018-07-19 19:12:27 +00:00
|
|
|
|
|
|
|
value1 = logging.getLogger('requests').level
|
|
|
|
assert previous_value1 is not value1
|
|
|
|
assert value1 is logging.INFO
|
|
|
|
|
|
|
|
value2 = logging.getLogger('ccxt.base.exchange').level
|
|
|
|
assert previous_value2 is not value2
|
|
|
|
assert value2 is logging.INFO
|
|
|
|
|
|
|
|
value3 = logging.getLogger('telegram').level
|
|
|
|
assert previous_value3 is not value3
|
|
|
|
assert value3 is logging.INFO
|
|
|
|
|
2019-07-06 21:31:48 +00:00
|
|
|
_set_loggers(verbosity=2)
|
2018-07-19 19:12:27 +00:00
|
|
|
|
|
|
|
assert logging.getLogger('requests').level is logging.DEBUG
|
|
|
|
assert logging.getLogger('ccxt.base.exchange').level is logging.INFO
|
|
|
|
assert logging.getLogger('telegram').level is logging.INFO
|
2020-05-31 07:57:31 +00:00
|
|
|
assert logging.getLogger('werkzeug').level is logging.INFO
|
2018-07-19 19:12:27 +00:00
|
|
|
|
2020-05-31 07:57:31 +00:00
|
|
|
_set_loggers(verbosity=3, api_verbosity='error')
|
2018-07-19 19:12:27 +00:00
|
|
|
|
|
|
|
assert logging.getLogger('requests').level is logging.DEBUG
|
|
|
|
assert logging.getLogger('ccxt.base.exchange').level is logging.DEBUG
|
|
|
|
assert logging.getLogger('telegram').level is logging.INFO
|
2020-05-31 07:57:31 +00:00
|
|
|
assert logging.getLogger('werkzeug').level is logging.ERROR
|
2018-07-30 11:57:51 +00:00
|
|
|
|
|
|
|
|
2019-11-23 13:25:32 +00:00
|
|
|
@pytest.mark.skipif(sys.platform == "win32", reason="does not run on windows")
|
2019-11-23 13:09:42 +00:00
|
|
|
def test_set_loggers_syslog(mocker):
|
|
|
|
logger = logging.getLogger()
|
|
|
|
orig_handlers = logger.handlers
|
|
|
|
logger.handlers = []
|
|
|
|
|
|
|
|
config = {'verbosity': 2,
|
|
|
|
'logfile': 'syslog:/dev/log',
|
|
|
|
}
|
|
|
|
|
|
|
|
setup_logging(config)
|
|
|
|
assert len(logger.handlers) == 2
|
|
|
|
assert [x for x in logger.handlers if type(x) == logging.handlers.SysLogHandler]
|
|
|
|
assert [x for x in logger.handlers if type(x) == logging.StreamHandler]
|
|
|
|
# reset handlers to not break pytest
|
|
|
|
logger.handlers = orig_handlers
|
|
|
|
|
|
|
|
|
2019-11-23 13:25:32 +00:00
|
|
|
@pytest.mark.skip(reason="systemd is not installed on every system, so we're not testing this.")
|
2019-11-23 13:09:42 +00:00
|
|
|
def test_set_loggers_journald(mocker):
|
|
|
|
logger = logging.getLogger()
|
|
|
|
orig_handlers = logger.handlers
|
|
|
|
logger.handlers = []
|
|
|
|
|
|
|
|
config = {'verbosity': 2,
|
|
|
|
'logfile': 'journald',
|
|
|
|
}
|
|
|
|
|
|
|
|
setup_logging(config)
|
|
|
|
assert len(logger.handlers) == 2
|
|
|
|
assert [x for x in logger.handlers if type(x).__name__ == "JournaldLogHandler"]
|
|
|
|
assert [x for x in logger.handlers if type(x) == logging.StreamHandler]
|
|
|
|
# reset handlers to not break pytest
|
|
|
|
logger.handlers = orig_handlers
|
|
|
|
|
|
|
|
|
|
|
|
def test_set_loggers_journald_importerror(mocker, import_fails):
|
|
|
|
logger = logging.getLogger()
|
|
|
|
orig_handlers = logger.handlers
|
|
|
|
logger.handlers = []
|
|
|
|
|
|
|
|
config = {'verbosity': 2,
|
|
|
|
'logfile': 'journald',
|
|
|
|
}
|
|
|
|
with pytest.raises(OperationalException,
|
|
|
|
match=r'You need the systemd python package.*'):
|
|
|
|
setup_logging(config)
|
|
|
|
logger.handlers = orig_handlers
|
|
|
|
|
|
|
|
|
2019-03-29 19:16:52 +00:00
|
|
|
def test_set_logfile(default_conf, mocker):
|
2019-07-14 22:44:25 +00:00
|
|
|
patched_configuration_load_config_file(mocker, default_conf)
|
2019-03-29 19:16:52 +00:00
|
|
|
|
|
|
|
arglist = [
|
2019-09-14 11:38:26 +00:00
|
|
|
'trade', '--logfile', 'test_file.log',
|
2019-03-29 19:16:52 +00:00
|
|
|
]
|
2019-09-04 14:38:33 +00:00
|
|
|
args = Arguments(arglist).get_parsed_arg()
|
2019-03-29 19:16:52 +00:00
|
|
|
configuration = Configuration(args)
|
|
|
|
validated_conf = configuration.load_config()
|
|
|
|
|
|
|
|
assert validated_conf['logfile'] == "test_file.log"
|
|
|
|
f = Path("test_file.log")
|
|
|
|
assert f.is_file()
|
|
|
|
f.unlink()
|
|
|
|
|
|
|
|
|
2018-10-10 18:13:56 +00:00
|
|
|
def test_load_config_warn_forcebuy(default_conf, mocker, caplog) -> None:
|
|
|
|
default_conf['forcebuy_enable'] = True
|
2019-07-14 22:44:25 +00:00
|
|
|
patched_configuration_load_config_file(mocker, default_conf)
|
2018-10-10 18:13:56 +00:00
|
|
|
|
2019-09-14 11:38:26 +00:00
|
|
|
args = Arguments(['trade']).get_parsed_arg()
|
2018-10-10 18:13:56 +00:00
|
|
|
configuration = Configuration(args)
|
|
|
|
validated_conf = configuration.load_config()
|
|
|
|
|
|
|
|
assert validated_conf.get('forcebuy_enable')
|
2019-08-11 18:17:39 +00:00
|
|
|
assert log_has('`forcebuy` RPC message enabled.', caplog)
|
2018-10-10 18:13:56 +00:00
|
|
|
|
|
|
|
|
2018-07-30 11:57:51 +00:00
|
|
|
def test_validate_default_conf(default_conf) -> None:
|
2019-12-15 08:37:08 +00:00
|
|
|
# Validate via our validator - we allow setting defaults!
|
|
|
|
validate_config_schema(default_conf)
|
2019-01-01 13:07:40 +00:00
|
|
|
|
|
|
|
|
2020-01-03 06:07:59 +00:00
|
|
|
def test_validate_max_open_trades(default_conf):
|
|
|
|
default_conf['max_open_trades'] = float('inf')
|
|
|
|
default_conf['stake_amount'] = 'unlimited'
|
|
|
|
with pytest.raises(OperationalException, match='`max_open_trades` and `stake_amount` '
|
|
|
|
'cannot both be unlimited.'):
|
|
|
|
validate_config_consistency(default_conf)
|
|
|
|
|
|
|
|
|
2019-03-14 08:26:31 +00:00
|
|
|
def test_validate_tsl(default_conf):
|
2019-08-22 17:49:30 +00:00
|
|
|
default_conf['stoploss'] = 0.0
|
2019-08-22 17:49:50 +00:00
|
|
|
with pytest.raises(OperationalException, match='The config stoploss needs to be different '
|
|
|
|
'from 0 to avoid problems with sell orders.'):
|
2019-08-22 17:49:30 +00:00
|
|
|
validate_config_consistency(default_conf)
|
|
|
|
default_conf['stoploss'] = -0.10
|
|
|
|
|
2019-03-14 08:01:03 +00:00
|
|
|
default_conf['trailing_stop'] = True
|
|
|
|
default_conf['trailing_stop_positive'] = 0
|
|
|
|
default_conf['trailing_stop_positive_offset'] = 0
|
|
|
|
|
|
|
|
default_conf['trailing_only_offset_is_reached'] = True
|
|
|
|
with pytest.raises(OperationalException,
|
2019-03-16 09:38:25 +00:00
|
|
|
match=r'The config trailing_only_offset_is_reached needs '
|
2019-03-14 08:01:03 +00:00
|
|
|
'trailing_stop_positive_offset to be more than 0 in your config.'):
|
2019-08-18 14:10:10 +00:00
|
|
|
validate_config_consistency(default_conf)
|
2019-03-14 08:01:03 +00:00
|
|
|
|
|
|
|
default_conf['trailing_stop_positive_offset'] = 0.01
|
|
|
|
default_conf['trailing_stop_positive'] = 0.015
|
|
|
|
with pytest.raises(OperationalException,
|
2019-03-16 09:38:25 +00:00
|
|
|
match=r'The config trailing_stop_positive_offset needs '
|
2019-08-24 07:08:08 +00:00
|
|
|
'to be greater than trailing_stop_positive in your config.'):
|
2019-08-18 14:10:10 +00:00
|
|
|
validate_config_consistency(default_conf)
|
2019-03-16 09:38:25 +00:00
|
|
|
|
|
|
|
default_conf['trailing_stop_positive'] = 0.01
|
|
|
|
default_conf['trailing_stop_positive_offset'] = 0.015
|
2019-08-18 14:10:10 +00:00
|
|
|
validate_config_consistency(default_conf)
|
2019-04-11 15:07:51 +00:00
|
|
|
|
2019-08-22 17:49:30 +00:00
|
|
|
# 0 trailing stop positive - results in "Order would trigger immediately"
|
|
|
|
default_conf['trailing_stop_positive'] = 0
|
|
|
|
default_conf['trailing_stop_positive_offset'] = 0.02
|
|
|
|
default_conf['trailing_only_offset_is_reached'] = False
|
|
|
|
with pytest.raises(OperationalException,
|
2019-08-22 17:49:50 +00:00
|
|
|
match='The config trailing_stop_positive needs to be different from 0 '
|
2019-08-22 17:49:30 +00:00
|
|
|
'to avoid problems with sell orders'):
|
|
|
|
validate_config_consistency(default_conf)
|
|
|
|
|
2019-04-11 15:07:51 +00:00
|
|
|
|
2019-08-18 14:19:24 +00:00
|
|
|
def test_validate_edge(edge_conf):
|
|
|
|
edge_conf.update({"pairlist": {
|
|
|
|
"method": "VolumePairList",
|
|
|
|
}})
|
|
|
|
|
|
|
|
with pytest.raises(OperationalException,
|
|
|
|
match="Edge and VolumePairList are incompatible, "
|
|
|
|
"Edge will override whatever pairs VolumePairlist selects."):
|
|
|
|
validate_config_consistency(edge_conf)
|
|
|
|
|
|
|
|
edge_conf.update({"pairlist": {
|
|
|
|
"method": "StaticPairList",
|
|
|
|
}})
|
|
|
|
validate_config_consistency(edge_conf)
|
2019-04-11 15:07:51 +00:00
|
|
|
|
|
|
|
|
2019-10-25 05:07:01 +00:00
|
|
|
def test_validate_whitelist(default_conf):
|
|
|
|
default_conf['runmode'] = RunMode.DRY_RUN
|
|
|
|
# Test regular case - has whitelist and uses StaticPairlist
|
|
|
|
validate_config_consistency(default_conf)
|
|
|
|
conf = deepcopy(default_conf)
|
|
|
|
del conf['exchange']['pair_whitelist']
|
|
|
|
# Test error case
|
|
|
|
with pytest.raises(OperationalException,
|
|
|
|
match="StaticPairList requires pair_whitelist to be set."):
|
|
|
|
|
|
|
|
validate_config_consistency(conf)
|
|
|
|
|
|
|
|
conf = deepcopy(default_conf)
|
|
|
|
|
2019-11-09 13:15:47 +00:00
|
|
|
conf.update({"pairlists": [{
|
2019-10-25 05:07:01 +00:00
|
|
|
"method": "VolumePairList",
|
2019-11-09 13:15:47 +00:00
|
|
|
}]})
|
2019-10-25 05:07:01 +00:00
|
|
|
# Dynamic whitelist should not care about pair_whitelist
|
|
|
|
validate_config_consistency(conf)
|
|
|
|
del conf['exchange']['pair_whitelist']
|
|
|
|
|
|
|
|
validate_config_consistency(conf)
|
|
|
|
|
2020-02-25 06:03:11 +00:00
|
|
|
|
2019-08-11 21:33:34 +00:00
|
|
|
def test_load_config_test_comments() -> None:
|
|
|
|
"""
|
|
|
|
Load config with comments
|
|
|
|
"""
|
|
|
|
config_file = Path(__file__).parents[0] / "config_test_comments.json"
|
|
|
|
conf = load_config_file(str(config_file))
|
|
|
|
|
|
|
|
assert conf
|
|
|
|
|
|
|
|
|
2019-04-11 15:07:51 +00:00
|
|
|
def test_load_config_default_exchange(all_conf) -> None:
|
2019-04-11 19:22:33 +00:00
|
|
|
"""
|
|
|
|
config['exchange'] subtree has required options in it
|
|
|
|
so it cannot be omitted in the config
|
|
|
|
"""
|
2019-04-11 15:07:51 +00:00
|
|
|
del all_conf['exchange']
|
|
|
|
|
|
|
|
assert 'exchange' not in all_conf
|
|
|
|
|
|
|
|
with pytest.raises(ValidationError,
|
2019-08-25 18:38:51 +00:00
|
|
|
match=r"'exchange' is a required property"):
|
2019-07-11 18:23:23 +00:00
|
|
|
validate_config_schema(all_conf)
|
2019-04-11 15:07:51 +00:00
|
|
|
|
|
|
|
|
|
|
|
def test_load_config_default_exchange_name(all_conf) -> None:
|
2019-04-11 19:22:33 +00:00
|
|
|
"""
|
|
|
|
config['exchange']['name'] option is required
|
|
|
|
so it cannot be omitted in the config
|
|
|
|
"""
|
2019-04-11 15:07:51 +00:00
|
|
|
del all_conf['exchange']['name']
|
|
|
|
|
|
|
|
assert 'name' not in all_conf['exchange']
|
|
|
|
|
|
|
|
with pytest.raises(ValidationError,
|
2019-08-25 18:38:51 +00:00
|
|
|
match=r"'name' is a required property"):
|
2019-07-11 18:23:23 +00:00
|
|
|
validate_config_schema(all_conf)
|
2019-04-11 15:07:51 +00:00
|
|
|
|
|
|
|
|
2019-04-24 07:48:25 +00:00
|
|
|
@pytest.mark.parametrize("keys", [("exchange", "sandbox", False),
|
|
|
|
("exchange", "key", ""),
|
|
|
|
("exchange", "secret", ""),
|
|
|
|
("exchange", "password", ""),
|
|
|
|
])
|
|
|
|
def test_load_config_default_subkeys(all_conf, keys) -> None:
|
2019-04-11 19:22:33 +00:00
|
|
|
"""
|
2019-04-24 07:48:25 +00:00
|
|
|
Test for parameters with default values in sub-paths
|
|
|
|
so they can be omitted in the config and the default value
|
2019-04-24 07:55:53 +00:00
|
|
|
should is added to the config.
|
2019-04-11 19:22:33 +00:00
|
|
|
"""
|
2019-04-24 07:48:25 +00:00
|
|
|
# Get first level key
|
|
|
|
key = keys[0]
|
|
|
|
# get second level key
|
|
|
|
subkey = keys[1]
|
2019-04-11 15:07:51 +00:00
|
|
|
|
2019-04-24 07:48:25 +00:00
|
|
|
del all_conf[key][subkey]
|
2019-04-11 15:07:51 +00:00
|
|
|
|
2019-04-24 07:48:25 +00:00
|
|
|
assert subkey not in all_conf[key]
|
2019-04-11 15:07:51 +00:00
|
|
|
|
2019-07-11 18:23:23 +00:00
|
|
|
validate_config_schema(all_conf)
|
2019-04-24 07:48:25 +00:00
|
|
|
assert subkey in all_conf[key]
|
|
|
|
assert all_conf[key][subkey] == keys[2]
|
2019-08-16 13:52:59 +00:00
|
|
|
|
|
|
|
|
|
|
|
def test_pairlist_resolving():
|
|
|
|
arglist = [
|
|
|
|
'download-data',
|
|
|
|
'--pairs', 'ETH/BTC', 'XRP/BTC',
|
|
|
|
'--exchange', 'binance'
|
|
|
|
]
|
|
|
|
|
2019-09-04 14:38:33 +00:00
|
|
|
args = Arguments(arglist).get_parsed_arg()
|
2019-08-16 13:52:59 +00:00
|
|
|
|
2019-10-25 05:12:50 +00:00
|
|
|
configuration = Configuration(args, RunMode.OTHER)
|
2019-08-16 13:52:59 +00:00
|
|
|
config = configuration.get_config()
|
|
|
|
|
|
|
|
assert config['pairs'] == ['ETH/BTC', 'XRP/BTC']
|
|
|
|
assert config['exchange']['name'] == 'binance'
|
|
|
|
|
|
|
|
|
|
|
|
def test_pairlist_resolving_with_config(mocker, default_conf):
|
|
|
|
patched_configuration_load_config_file(mocker, default_conf)
|
|
|
|
arglist = [
|
|
|
|
'download-data',
|
2019-09-14 11:19:40 +00:00
|
|
|
'--config', 'config.json',
|
2019-08-16 13:52:59 +00:00
|
|
|
]
|
|
|
|
|
2019-09-04 14:38:33 +00:00
|
|
|
args = Arguments(arglist).get_parsed_arg()
|
2019-08-16 13:52:59 +00:00
|
|
|
|
|
|
|
configuration = Configuration(args)
|
|
|
|
config = configuration.get_config()
|
|
|
|
|
|
|
|
assert config['pairs'] == default_conf['exchange']['pair_whitelist']
|
|
|
|
assert config['exchange']['name'] == default_conf['exchange']['name']
|
|
|
|
|
|
|
|
# Override pairs
|
|
|
|
arglist = [
|
|
|
|
'download-data',
|
2019-09-14 11:19:40 +00:00
|
|
|
'--config', 'config.json',
|
2019-08-16 13:52:59 +00:00
|
|
|
'--pairs', 'ETH/BTC', 'XRP/BTC',
|
|
|
|
]
|
|
|
|
|
2019-09-04 14:38:33 +00:00
|
|
|
args = Arguments(arglist).get_parsed_arg()
|
2019-08-16 13:52:59 +00:00
|
|
|
|
|
|
|
configuration = Configuration(args)
|
|
|
|
config = configuration.get_config()
|
|
|
|
|
|
|
|
assert config['pairs'] == ['ETH/BTC', 'XRP/BTC']
|
|
|
|
assert config['exchange']['name'] == default_conf['exchange']['name']
|
|
|
|
|
|
|
|
|
|
|
|
def test_pairlist_resolving_with_config_pl(mocker, default_conf):
|
|
|
|
patched_configuration_load_config_file(mocker, default_conf)
|
|
|
|
load_mock = mocker.patch("freqtrade.configuration.configuration.json_load",
|
|
|
|
MagicMock(return_value=['XRP/BTC', 'ETH/BTC']))
|
|
|
|
mocker.patch.object(Path, "exists", MagicMock(return_value=True))
|
2019-08-21 04:59:07 +00:00
|
|
|
mocker.patch.object(Path, "open", MagicMock(return_value=MagicMock()))
|
2019-08-16 13:52:59 +00:00
|
|
|
|
|
|
|
arglist = [
|
|
|
|
'download-data',
|
2019-09-14 11:19:40 +00:00
|
|
|
'--config', 'config.json',
|
2019-08-16 13:52:59 +00:00
|
|
|
'--pairs-file', 'pairs.json',
|
|
|
|
]
|
|
|
|
|
2019-09-04 14:38:33 +00:00
|
|
|
args = Arguments(arglist).get_parsed_arg()
|
2019-08-16 13:52:59 +00:00
|
|
|
|
|
|
|
configuration = Configuration(args)
|
|
|
|
config = configuration.get_config()
|
|
|
|
|
|
|
|
assert load_mock.call_count == 1
|
|
|
|
assert config['pairs'] == ['ETH/BTC', 'XRP/BTC']
|
|
|
|
assert config['exchange']['name'] == default_conf['exchange']['name']
|
|
|
|
|
|
|
|
|
|
|
|
def test_pairlist_resolving_with_config_pl_not_exists(mocker, default_conf):
|
|
|
|
patched_configuration_load_config_file(mocker, default_conf)
|
|
|
|
mocker.patch("freqtrade.configuration.configuration.json_load",
|
|
|
|
MagicMock(return_value=['XRP/BTC', 'ETH/BTC']))
|
|
|
|
mocker.patch.object(Path, "exists", MagicMock(return_value=False))
|
|
|
|
|
|
|
|
arglist = [
|
|
|
|
'download-data',
|
2019-09-14 11:19:40 +00:00
|
|
|
'--config', 'config.json',
|
2019-08-16 13:52:59 +00:00
|
|
|
'--pairs-file', 'pairs.json',
|
|
|
|
]
|
|
|
|
|
2019-09-04 14:38:33 +00:00
|
|
|
args = Arguments(arglist).get_parsed_arg()
|
2019-08-16 13:52:59 +00:00
|
|
|
|
|
|
|
with pytest.raises(OperationalException, match=r"No pairs file found with path.*"):
|
|
|
|
configuration = Configuration(args)
|
|
|
|
configuration.get_config()
|
2019-08-17 05:05:42 +00:00
|
|
|
|
|
|
|
|
|
|
|
def test_pairlist_resolving_fallback(mocker):
|
|
|
|
mocker.patch.object(Path, "exists", MagicMock(return_value=True))
|
2019-08-21 04:59:07 +00:00
|
|
|
mocker.patch.object(Path, "open", MagicMock(return_value=MagicMock()))
|
2019-08-17 05:05:42 +00:00
|
|
|
mocker.patch("freqtrade.configuration.configuration.json_load",
|
|
|
|
MagicMock(return_value=['XRP/BTC', 'ETH/BTC']))
|
|
|
|
arglist = [
|
|
|
|
'download-data',
|
|
|
|
'--exchange', 'binance'
|
|
|
|
]
|
|
|
|
|
2019-09-04 14:38:33 +00:00
|
|
|
args = Arguments(arglist).get_parsed_arg()
|
2019-09-03 04:48:51 +00:00
|
|
|
# Fix flaky tests if config.json exists
|
2019-09-12 18:25:27 +00:00
|
|
|
args["config"] = None
|
2019-08-17 05:05:42 +00:00
|
|
|
|
2019-10-25 05:07:01 +00:00
|
|
|
configuration = Configuration(args, RunMode.OTHER)
|
2019-08-17 05:05:42 +00:00
|
|
|
config = configuration.get_config()
|
|
|
|
|
|
|
|
assert config['pairs'] == ['ETH/BTC', 'XRP/BTC']
|
|
|
|
assert config['exchange']['name'] == 'binance'
|
2019-12-23 14:09:17 +00:00
|
|
|
assert config['datadir'] == Path.cwd() / "user_data/data/binance"
|
2019-10-08 23:44:04 +00:00
|
|
|
|
|
|
|
|
|
|
|
@pytest.mark.parametrize("setting", [
|
|
|
|
("ask_strategy", "use_sell_signal", True,
|
|
|
|
"experimental", "use_sell_signal", False),
|
|
|
|
("ask_strategy", "sell_profit_only", False,
|
|
|
|
"experimental", "sell_profit_only", True),
|
|
|
|
("ask_strategy", "ignore_roi_if_buy_signal", False,
|
|
|
|
"experimental", "ignore_roi_if_buy_signal", True),
|
|
|
|
])
|
2019-10-09 15:22:54 +00:00
|
|
|
def test_process_temporary_deprecated_settings(mocker, default_conf, setting, caplog):
|
2019-10-08 23:44:04 +00:00
|
|
|
patched_configuration_load_config_file(mocker, default_conf)
|
|
|
|
|
2019-10-09 15:22:54 +00:00
|
|
|
# Create sections for new and deprecated settings
|
|
|
|
# (they may not exist in the config)
|
|
|
|
default_conf[setting[0]] = {}
|
2019-10-08 23:44:04 +00:00
|
|
|
default_conf[setting[3]] = {}
|
2019-10-09 15:22:54 +00:00
|
|
|
# Assign new setting
|
2019-10-08 23:44:04 +00:00
|
|
|
default_conf[setting[0]][setting[1]] = setting[2]
|
2019-10-09 15:22:54 +00:00
|
|
|
# Assign deprecated setting
|
2019-10-08 23:44:04 +00:00
|
|
|
default_conf[setting[3]][setting[4]] = setting[5]
|
|
|
|
|
2019-10-09 15:22:54 +00:00
|
|
|
# New and deprecated settings are conflicting ones
|
2019-10-08 23:44:04 +00:00
|
|
|
with pytest.raises(OperationalException, match=r'DEPRECATED'):
|
|
|
|
process_temporary_deprecated_settings(default_conf)
|
|
|
|
|
2019-10-09 15:22:54 +00:00
|
|
|
caplog.clear()
|
|
|
|
|
|
|
|
# Delete new setting
|
2019-10-08 23:44:04 +00:00
|
|
|
del default_conf[setting[0]][setting[1]]
|
2019-10-09 15:22:54 +00:00
|
|
|
|
2019-10-08 23:44:04 +00:00
|
|
|
process_temporary_deprecated_settings(default_conf)
|
|
|
|
assert log_has_re('DEPRECATED', caplog)
|
2019-10-09 15:22:54 +00:00
|
|
|
# The value of the new setting shall have been set to the
|
|
|
|
# value of the deprecated one
|
2019-10-08 23:44:04 +00:00
|
|
|
assert default_conf[setting[0]][setting[1]] == setting[5]
|
2019-10-09 15:22:54 +00:00
|
|
|
|
|
|
|
|
2020-01-03 09:58:31 +00:00
|
|
|
def test_process_deprecated_setting_edge(mocker, edge_conf, caplog):
|
|
|
|
patched_configuration_load_config_file(mocker, edge_conf)
|
|
|
|
edge_conf.update({'edge': {
|
2020-01-03 10:34:17 +00:00
|
|
|
'enabled': True,
|
2020-01-03 09:58:31 +00:00
|
|
|
'capital_available_percentage': 0.5,
|
|
|
|
}})
|
|
|
|
|
|
|
|
process_temporary_deprecated_settings(edge_conf)
|
|
|
|
assert log_has_re(r"DEPRECATED.*Using 'edge.capital_available_percentage'*", caplog)
|
|
|
|
|
|
|
|
|
2019-10-09 15:22:54 +00:00
|
|
|
def test_check_conflicting_settings(mocker, default_conf, caplog):
|
|
|
|
patched_configuration_load_config_file(mocker, default_conf)
|
|
|
|
|
|
|
|
# Create sections for new and deprecated settings
|
|
|
|
# (they may not exist in the config)
|
|
|
|
default_conf['sectionA'] = {}
|
|
|
|
default_conf['sectionB'] = {}
|
|
|
|
# Assign new setting
|
|
|
|
default_conf['sectionA']['new_setting'] = 'valA'
|
|
|
|
# Assign deprecated setting
|
|
|
|
default_conf['sectionB']['deprecated_setting'] = 'valB'
|
|
|
|
|
|
|
|
# New and deprecated settings are conflicting ones
|
|
|
|
with pytest.raises(OperationalException, match=r'DEPRECATED'):
|
|
|
|
check_conflicting_settings(default_conf,
|
|
|
|
'sectionA', 'new_setting',
|
|
|
|
'sectionB', 'deprecated_setting')
|
|
|
|
|
|
|
|
caplog.clear()
|
|
|
|
|
|
|
|
# Delete new setting (deprecated exists)
|
|
|
|
del default_conf['sectionA']['new_setting']
|
|
|
|
check_conflicting_settings(default_conf,
|
|
|
|
'sectionA', 'new_setting',
|
|
|
|
'sectionB', 'deprecated_setting')
|
|
|
|
assert not log_has_re('DEPRECATED', caplog)
|
|
|
|
assert 'new_setting' not in default_conf['sectionA']
|
|
|
|
|
|
|
|
caplog.clear()
|
|
|
|
|
|
|
|
# Assign new setting
|
|
|
|
default_conf['sectionA']['new_setting'] = 'valA'
|
|
|
|
# Delete deprecated setting
|
|
|
|
del default_conf['sectionB']['deprecated_setting']
|
|
|
|
check_conflicting_settings(default_conf,
|
|
|
|
'sectionA', 'new_setting',
|
|
|
|
'sectionB', 'deprecated_setting')
|
|
|
|
assert not log_has_re('DEPRECATED', caplog)
|
|
|
|
assert default_conf['sectionA']['new_setting'] == 'valA'
|
|
|
|
|
|
|
|
|
|
|
|
def test_process_deprecated_setting(mocker, default_conf, caplog):
|
|
|
|
patched_configuration_load_config_file(mocker, default_conf)
|
|
|
|
|
|
|
|
# Create sections for new and deprecated settings
|
|
|
|
# (they may not exist in the config)
|
|
|
|
default_conf['sectionA'] = {}
|
|
|
|
default_conf['sectionB'] = {}
|
|
|
|
# Assign new setting
|
|
|
|
default_conf['sectionA']['new_setting'] = 'valA'
|
|
|
|
# Assign deprecated setting
|
|
|
|
default_conf['sectionB']['deprecated_setting'] = 'valB'
|
|
|
|
|
|
|
|
# Both new and deprecated settings exists
|
|
|
|
process_deprecated_setting(default_conf,
|
|
|
|
'sectionA', 'new_setting',
|
|
|
|
'sectionB', 'deprecated_setting')
|
|
|
|
assert log_has_re('DEPRECATED', caplog)
|
|
|
|
# The value of the new setting shall have been set to the
|
|
|
|
# value of the deprecated one
|
|
|
|
assert default_conf['sectionA']['new_setting'] == 'valB'
|
|
|
|
|
|
|
|
caplog.clear()
|
|
|
|
|
|
|
|
# Delete new setting (deprecated exists)
|
|
|
|
del default_conf['sectionA']['new_setting']
|
|
|
|
process_deprecated_setting(default_conf,
|
|
|
|
'sectionA', 'new_setting',
|
|
|
|
'sectionB', 'deprecated_setting')
|
|
|
|
assert log_has_re('DEPRECATED', caplog)
|
|
|
|
# The value of the new setting shall have been set to the
|
|
|
|
# value of the deprecated one
|
|
|
|
assert default_conf['sectionA']['new_setting'] == 'valB'
|
|
|
|
|
|
|
|
caplog.clear()
|
|
|
|
|
|
|
|
# Assign new setting
|
|
|
|
default_conf['sectionA']['new_setting'] = 'valA'
|
|
|
|
# Delete deprecated setting
|
|
|
|
del default_conf['sectionB']['deprecated_setting']
|
|
|
|
process_deprecated_setting(default_conf,
|
|
|
|
'sectionA', 'new_setting',
|
|
|
|
'sectionB', 'deprecated_setting')
|
|
|
|
assert not log_has_re('DEPRECATED', caplog)
|
|
|
|
assert default_conf['sectionA']['new_setting'] == 'valA'
|