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

To better align with multiple client protocols, this PR

Browse Source 
Refactors the existing RPC directory, classes, defs as below.
This is to better reflect the nature of the files/classes/defs to support other clients - such as rest

The code is functional, ive tested every RPC button in Telegram.
1 unit test is failing ( they all were till find_replace) in test_rpc_telegram.

Can I ask for anothers opinion on why this 1 test fails, im at loss to debug
- mocker is stretching my working knowledge of python -

Ive renamed common methods from RPC_method_name to server_method_name
e.g rpc_stop becomes server_stop, the super class is CLIENTS not RPC as it is agnostic to RPC

freqtrade/rcp/ - rpc.py
......................- rpc_manager.py
......................- telegram.py

to:

freqtrade/clients/client_manager.py (was rpc_manager
......................-common/client.py (was rpc.py - but is agnostic to what client calls)
......................-rpc/telegram.py
......................-rpc/*discord.py (example future RPC client
......................-rest/*cmd line.py (example future rest cmdline rest client
......................-rest/*web.py (example future rest web client
This commit is contained in:
creslinux 2018-06-09 09:03:22 +00:00
parent 8db3dfa8c6
commit 631df64c68
14 changed files with 200 additions and 200 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

0
freqtrade/rpc/__init__.py → freqtrade/clients/__init__.py
View File

10
freqtrade/rpc/rpc_manager.py → freqtrade/clients/client_manager.py
View File

@ -1,18 +1,18 @@
""" """
This module contains class to manage RPC communications (Telegram, Slack, ...) This module contains class to manage CLIENT communications (Telegram, Slack, ...)
""" """
from typing import Any, List from typing import Any, List
import logging import logging
from freqtrade.rpc.telegram import Telegram from freqtrade.clients.rpc.telegram import Telegram
logger = logging.getLogger(__name__) logger = logging.getLogger(__name__)
class RPCManager(object): class ClientManager(object):
""" """
Class to manage RPC objects (Telegram, Slack, ...) Class to manage CLIENT objects (Telegram, Slack, ...)
""" """
def __init__(self, freqtrade) -> None: def __init__(self, freqtrade) -> None:
""" """
@ -28,7 +28,7 @@ class RPCManager(object):
def _init(self) -> None: def _init(self) -> None:
""" """
Init RPC modules Init CLIENT modules
:return: :return:
""" """
if self.freqtrade.config['telegram'].get('enabled', False): if self.freqtrade.config['telegram'].get('enabled', False):

28
freqtrade/rpc/rpc.py → freqtrade/clients/common_client.py
View File

@ -1,5 +1,5 @@
""" """
This module contains class to define a RPC communications This module contains class to define a CLIENT communications
""" """
import logging import logging
from datetime import datetime, timedelta, date from datetime import datetime, timedelta, date
@ -20,9 +20,9 @@ from freqtrade.state import State
logger = logging.getLogger(__name__) logger = logging.getLogger(__name__)
class RPC(object): class CLIENT(object):
""" """
RPC class can be used to have extra feature, like bot data, and access to DB data CLIENT class can be used to have extra feature, like bot data, and access to DB data
""" """
def __init__(self, freqtrade) -> None: def __init__(self, freqtrade) -> None:
""" """
@ -32,9 +32,9 @@ class RPC(object):
""" """
self.freqtrade = freqtrade self.freqtrade = freqtrade
def rpc_trade_status(self) -> Tuple[bool, Any]: def server_trade_status(self) -> Tuple[bool, Any]:
""" """
Below follows the RPC backend it is prefixed with rpc_ to raise awareness that it is Below follows the CLIENT backend it is prefixed with rpc_ to raise awareness that it is
a remotely exposed function a remotely exposed function
:return: :return:
""" """
@ -84,7 +84,7 @@ class RPC(object):
result.append(message) result.append(message)
return False, result return False, result
def rpc_status_table(self) -> Tuple[bool, Any]: def server_status_table(self) -> Tuple[bool, Any]:
trades = Trade.query.filter(Trade.is_open.is_(True)).all() trades = Trade.query.filter(Trade.is_open.is_(True)).all()
if self.freqtrade.state != State.RUNNING: if self.freqtrade.state != State.RUNNING:
return True, '*Status:* `trader is not running`' return True, '*Status:* `trader is not running`'
@ -111,7 +111,7 @@ class RPC(object):
# result, or raise error # result, or raise error
return False, df_statuses return False, df_statuses
def rpc_daily_profit( def server_daily_profit(
self, timescale: int, self, timescale: int,
stake_currency: str, fiat_display_currency: str) -> Tuple[bool, Any]: stake_currency: str, fiat_display_currency: str) -> Tuple[bool, Any]:
today = datetime.utcnow().date() today = datetime.utcnow().date()
@ -159,7 +159,7 @@ class RPC(object):
] ]
return False, stats return False, stats
def rpc_trade_statistics( def server_trade_statistics(
self, stake_currency: str, fiat_display_currency: str) -> Tuple[bool, Any]: self, stake_currency: str, fiat_display_currency: str) -> Tuple[bool, Any]:
""" """
:return: cumulative profit statistics. :return: cumulative profit statistics.
@ -242,7 +242,7 @@ class RPC(object):
} }
) )
def rpc_balance(self, fiat_display_currency: str) -> Tuple[bool, Any]: def server_balance(self, fiat_display_currency: str) -> Tuple[bool, Any]:
""" """
:return: current account balance per crypto :return: current account balance per crypto
""" """
@ -279,7 +279,7 @@ class RPC(object):
value = fiat.convert_amount(total, 'BTC', symbol) value = fiat.convert_amount(total, 'BTC', symbol)
return False, (output, total, symbol, value) return False, (output, total, symbol, value)
def rpc_start(self) -> Tuple[bool, str]: def server_start(self) -> Tuple[bool, str]:
""" """
Handler for start. Handler for start.
""" """
@ -289,7 +289,7 @@ class RPC(object):
self.freqtrade.state = State.RUNNING self.freqtrade.state = State.RUNNING
return False, '`Starting trader ...`' return False, '`Starting trader ...`'
def rpc_stop(self) -> Tuple[bool, str]: def server_stop(self) -> Tuple[bool, str]:
""" """
Handler for stop. Handler for stop.
""" """
@ -300,7 +300,7 @@ class RPC(object):
return True, '*Status:* `already stopped`' return True, '*Status:* `already stopped`'
# FIX: no test for this!!!! # FIX: no test for this!!!!
def rpc_forcesell(self, trade_id) -> Tuple[bool, Any]: def server_forcesell(self, trade_id) -> Tuple[bool, Any]:
""" """
Handler for forcesell <id>. Handler for forcesell <id>.
Sells the given trade at current price Sells the given trade at current price
@ -357,7 +357,7 @@ class RPC(object):
Trade.session.flush() Trade.session.flush()
return False, '' return False, ''
def rpc_performance(self) -> Tuple[bool, Any]: def server_performance(self) -> Tuple[bool, Any]:
""" """
Handler for performance. Handler for performance.
Shows a performance statistic from finished trades Shows a performance statistic from finished trades
@ -378,7 +378,7 @@ class RPC(object):
return False, trades return False, trades
def rpc_count(self) -> Tuple[bool, Any]: def server_count(self) -> Tuple[bool, Any]:
""" """
Returns the number of trades running Returns the number of trades running
:return: None :return: None

0
freqtrade/clients/rpc/__init__.py Normal file
View File

26
freqtrade/rpc/telegram.py → freqtrade/clients/rpc/telegram.py
View File

@ -12,7 +12,7 @@ from telegram.error import NetworkError, TelegramError
from telegram.ext import CommandHandler, Updater from telegram.ext import CommandHandler, Updater
from freqtrade.__init__ import __version__ from freqtrade.__init__ import __version__
from freqtrade.rpc.rpc import RPC from freqtrade.clients.common_client import CLIENT
logger = logging.getLogger(__name__) logger = logging.getLogger(__name__)
@ -53,13 +53,13 @@ def authorized_only(command_handler: Callable[[Any, Bot, Update], None]) -> Call
return wrapper return wrapper
class Telegram(RPC): class Telegram(CLIENT):
""" """
Telegram, this class send messages to Telegram Telegram, this class send messages to Telegram
""" """
def __init__(self, freqtrade) -> None: def __init__(self, freqtrade) -> None:
""" """
Init the Telegram call, and init the super class RPC Init the Telegram call, and init the super class CLIENT
:param freqtrade: Instance of a freqtrade bot :param freqtrade: Instance of a freqtrade bot
:return: None :return: None
""" """
@ -143,7 +143,7 @@ class Telegram(RPC):
return return
# Fetch open trade # Fetch open trade
(error, trades) = self.rpc_trade_status() (error, trades) = self.server_trade_status()
if error: if error:
self.send_msg(trades, bot=bot) self.send_msg(trades, bot=bot)
else: else:
@ -160,7 +160,7 @@ class Telegram(RPC):
:return: None :return: None
""" """
# Fetch open trade # Fetch open trade
(err, df_statuses) = self.rpc_status_table() (err, df_statuses) = self.server_status_table()
if err: if err:
self.send_msg(df_statuses, bot=bot) self.send_msg(df_statuses, bot=bot)
else: else:
@ -182,7 +182,7 @@ class Telegram(RPC):
timescale = int(update.message.text.replace('/daily', '').strip()) timescale = int(update.message.text.replace('/daily', '').strip())
except (TypeError, ValueError): except (TypeError, ValueError):
timescale = 7 timescale = 7
(error, stats) = self.rpc_daily_profit( (error, stats) = self.server_daily_profit(
timescale, timescale,
self._config['stake_currency'], self._config['stake_currency'],
self._config['fiat_display_currency'] self._config['fiat_display_currency']
@ -213,7 +213,7 @@ class Telegram(RPC):
:param update: message update :param update: message update
:return: None :return: None
""" """
(error, stats) = self.rpc_trade_statistics( (error, stats) = self.server_trade_statistics(
self._config['stake_currency'], self._config['stake_currency'],
self._config['fiat_display_currency'] self._config['fiat_display_currency']
) )
@ -256,7 +256,7 @@ class Telegram(RPC):
""" """
Handler for /balance Handler for /balance
""" """
(error, result) = self.rpc_balance(self._config['fiat_display_currency']) (error, result) = self.server_balance(self._config['fiat_display_currency'])
if error: if error:
self.send_msg('`All balances are zero.`') self.send_msg('`All balances are zero.`')
return return
@ -284,7 +284,7 @@ class Telegram(RPC):
:param update: message update :param update: message update
:return: None :return: None
""" """
(error, msg) = self.rpc_start() (error, msg) = self.server_start()
if error: if error:
self.send_msg(msg, bot=bot) self.send_msg(msg, bot=bot)
@ -297,7 +297,7 @@ class Telegram(RPC):
:param update: message update :param update: message update
:return: None :return: None
""" """
(error, msg) = self.rpc_stop() (error, msg) = self.server_stop()
self.send_msg(msg, bot=bot) self.send_msg(msg, bot=bot)
@authorized_only @authorized_only
@ -311,7 +311,7 @@ class Telegram(RPC):
""" """
trade_id = update.message.text.replace('/forcesell', '').strip() trade_id = update.message.text.replace('/forcesell', '').strip()
(error, message) = self.rpc_forcesell(trade_id) (error, message) = self.server_forcesell(trade_id)
if error: if error:
self.send_msg(message, bot=bot) self.send_msg(message, bot=bot)
return return
@ -325,7 +325,7 @@ class Telegram(RPC):
:param update: message update :param update: message update
:return: None :return: None
""" """
(error, trades) = self.rpc_performance() (error, trades) = self.server_performance()
if error: if error:
self.send_msg(trades, bot=bot) self.send_msg(trades, bot=bot)
return return
@ -348,7 +348,7 @@ class Telegram(RPC):
:param update: message update :param update: message update
:return: None :return: None
""" """
(error, trades) = self.rpc_count() (error, trades) = self.server_count()
if error: if error:
self.send_msg(trades, bot=bot) self.send_msg(trades, bot=bot)
return return

4
freqtrade/freqtradebot.py
View File

@ -21,7 +21,7 @@ from freqtrade import constants
from freqtrade.analyze import Analyze from freqtrade.analyze import Analyze
from freqtrade.fiat_convert import CryptoToFiatConverter from freqtrade.fiat_convert import CryptoToFiatConverter
from freqtrade.persistence import Trade from freqtrade.persistence import Trade
from freqtrade.rpc.rpc_manager import RPCManager from freqtrade.clients.client_manager import ClientManager
from freqtrade.state import State from freqtrade.state import State
logger = logging.getLogger(__name__) logger = logging.getLogger(__name__)
@ -52,7 +52,7 @@ class FreqtradeBot(object):
self.config = config self.config = config
self.analyze = Analyze(self.config) self.analyze = Analyze(self.config)
self.fiat_converter = CryptoToFiatConverter() self.fiat_converter = CryptoToFiatConverter()
self.rpc: RPCManager = RPCManager(self) self.rpc: ClientManager = ClientManager(self)
self.persistence = None self.persistence = None
self.exchange = None self.exchange = None

0
freqtrade/tests/clients/__init__.py Normal file
View File

0
freqtrade/tests/clients/rpc/__init__.py Normal file
View File

88
freqtrade/tests/rpc/test_rpc_telegram.py → freqtrade/tests/clients/rpc/test_rpc_telegram.py
View File

@ -17,8 +17,8 @@ from telegram.error import NetworkError
from freqtrade import __version__ from freqtrade import __version__
from freqtrade.freqtradebot import FreqtradeBot from freqtrade.freqtradebot import FreqtradeBot
from freqtrade.persistence import Trade from freqtrade.persistence import Trade
from freqtrade.rpc.telegram import Telegram from freqtrade.clients.rpc.telegram import Telegram
from freqtrade.rpc.telegram import authorized_only from freqtrade.clients.rpc.telegram import authorized_only
from freqtrade.state import State from freqtrade.state import State
from freqtrade.tests.conftest import get_patched_freqtradebot, log_has from freqtrade.tests.conftest import get_patched_freqtradebot, log_has
from freqtrade.tests.test_freqtradebot import patch_get_signal, patch_coinmarketcap from freqtrade.tests.test_freqtradebot import patch_get_signal, patch_coinmarketcap
@ -51,8 +51,8 @@ def test__init__(default_conf, mocker) -> None:
""" """
Test __init__() method Test __init__() method
""" """
mocker.patch('freqtrade.rpc.telegram.Updater', MagicMock()) mocker.patch('freqtrade.clients.rpc.telegram.Updater', MagicMock())
mocker.patch('freqtrade.rpc.telegram.Telegram._init', MagicMock()) mocker.patch('freqtrade.clients.rpc.telegram.Telegram._init', MagicMock())
telegram = Telegram(get_patched_freqtradebot(mocker, default_conf)) telegram = Telegram(get_patched_freqtradebot(mocker, default_conf))
assert telegram._updater is None assert telegram._updater is None
@ -64,7 +64,7 @@ def test_init(default_conf, mocker, caplog) -> None:
Test _init() method Test _init() method
""" """
start_polling = MagicMock() start_polling = MagicMock()
mocker.patch('freqtrade.rpc.telegram.Updater', MagicMock(return_value=start_polling)) mocker.patch('freqtrade.clients.rpc.telegram.Updater', MagicMock(return_value=start_polling))
Telegram(get_patched_freqtradebot(mocker, default_conf)) Telegram(get_patched_freqtradebot(mocker, default_conf))
assert start_polling.call_count == 0 assert start_polling.call_count == 0
@ -101,7 +101,7 @@ def test_cleanup(default_conf, mocker) -> None:
""" """
updater_mock = MagicMock() updater_mock = MagicMock()
updater_mock.stop = MagicMock() updater_mock.stop = MagicMock()
mocker.patch('freqtrade.rpc.telegram.Updater', updater_mock) mocker.patch('freqtrade.clients.rpc.telegram.Updater', updater_mock)
# not enabled # not enabled
conf = deepcopy(default_conf) conf = deepcopy(default_conf)
@ -124,7 +124,7 @@ def test_is_enabled(default_conf, mocker) -> None:
""" """
Test is_enabled() method Test is_enabled() method
""" """
mocker.patch('freqtrade.rpc.telegram.Updater', MagicMock()) mocker.patch('freqtrade.clients.rpc.telegram.Updater', MagicMock())
telegram = Telegram(get_patched_freqtradebot(mocker, default_conf)) telegram = Telegram(get_patched_freqtradebot(mocker, default_conf))
assert telegram.is_enabled() assert telegram.is_enabled()
@ -254,13 +254,13 @@ def test_status(default_conf, update, mocker, fee, ticker) -> None:
msg_mock = MagicMock() msg_mock = MagicMock()
status_table = MagicMock() status_table = MagicMock()
mocker.patch.multiple( mocker.patch.multiple(
'freqtrade.rpc.telegram.Telegram', 'freqtrade.clients.rpc.telegram.Telegram',
_init=MagicMock(), _init=MagicMock(),
rpc_trade_status=MagicMock(return_value=(False, [1, 2, 3])), rpc_trade_status=MagicMock(return_value=(False, [1, 2, 3])),
_status_table=status_table, _status_table=status_table,
send_msg=msg_mock send_msg=msg_mock
) )
mocker.patch('freqtrade.freqtradebot.RPCManager', MagicMock()) mocker.patch('freqtrade.freqtradebot.ClientManager', MagicMock())
freqtradebot = FreqtradeBot(conf) freqtradebot = FreqtradeBot(conf)
telegram = Telegram(freqtradebot) telegram = Telegram(freqtradebot)
@ -293,12 +293,12 @@ def test_status_handle(default_conf, update, ticker, fee, mocker) -> None:
msg_mock = MagicMock() msg_mock = MagicMock()
status_table = MagicMock() status_table = MagicMock()
mocker.patch.multiple( mocker.patch.multiple(
'freqtrade.rpc.telegram.Telegram', 'freqtrade.clients.rpc.telegram.Telegram',
_init=MagicMock(), _init=MagicMock(),
_status_table=status_table, _status_table=status_table,
send_msg=msg_mock send_msg=msg_mock
) )
mocker.patch('freqtrade.freqtradebot.RPCManager', MagicMock()) mocker.patch('freqtrade.freqtradebot.ClientManager', MagicMock())
freqtradebot = FreqtradeBot(default_conf) freqtradebot = FreqtradeBot(default_conf)
telegram = Telegram(freqtradebot) telegram = Telegram(freqtradebot)
@ -339,11 +339,11 @@ def test_status_table_handle(default_conf, update, ticker, fee, mocker) -> None:
) )
msg_mock = MagicMock() msg_mock = MagicMock()
mocker.patch.multiple( mocker.patch.multiple(
'freqtrade.rpc.telegram.Telegram', 'freqtrade.clients.rpc.telegram.Telegram',
_init=MagicMock(), _init=MagicMock(),
send_msg=msg_mock send_msg=msg_mock
) )
mocker.patch('freqtrade.freqtradebot.RPCManager', MagicMock()) mocker.patch('freqtrade.freqtradebot.ClientManager', MagicMock())
conf = deepcopy(default_conf) conf = deepcopy(default_conf)
conf['stake_amount'] = 15.0 conf['stake_amount'] = 15.0
@ -395,11 +395,11 @@ def test_daily_handle(default_conf, update, ticker, limit_buy_order, fee,
) )
msg_mock = MagicMock() msg_mock = MagicMock()
mocker.patch.multiple( mocker.patch.multiple(
'freqtrade.rpc.telegram.Telegram', 'freqtrade.clients.rpc.telegram.Telegram',
_init=MagicMock(), _init=MagicMock(),
send_msg=msg_mock send_msg=msg_mock
) )
mocker.patch('freqtrade.freqtradebot.RPCManager', MagicMock()) mocker.patch('freqtrade.freqtradebot.ClientManager', MagicMock())
freqtradebot = FreqtradeBot(default_conf) freqtradebot = FreqtradeBot(default_conf)
telegram = Telegram(freqtradebot) telegram = Telegram(freqtradebot)
@ -463,11 +463,11 @@ def test_daily_wrong_input(default_conf, update, ticker, mocker) -> None:
) )
msg_mock = MagicMock() msg_mock = MagicMock()
mocker.patch.multiple( mocker.patch.multiple(
'freqtrade.rpc.telegram.Telegram', 'freqtrade.clients.rpc.telegram.Telegram',
_init=MagicMock(), _init=MagicMock(),
send_msg=msg_mock send_msg=msg_mock
) )
mocker.patch('freqtrade.freqtradebot.RPCManager', MagicMock()) mocker.patch('freqtrade.freqtradebot.ClientManager', MagicMock())
freqtradebot = FreqtradeBot(default_conf) freqtradebot = FreqtradeBot(default_conf)
telegram = Telegram(freqtradebot) telegram = Telegram(freqtradebot)
@ -504,11 +504,11 @@ def test_profit_handle(default_conf, update, ticker, ticker_sell_up, fee,
) )
msg_mock = MagicMock() msg_mock = MagicMock()
mocker.patch.multiple( mocker.patch.multiple(
'freqtrade.rpc.telegram.Telegram', 'freqtrade.clients.rpc.telegram.Telegram',
_init=MagicMock(), _init=MagicMock(),
send_msg=msg_mock send_msg=msg_mock
) )
mocker.patch('freqtrade.freqtradebot.RPCManager', MagicMock()) mocker.patch('freqtrade.freqtradebot.ClientManager', MagicMock())
freqtradebot = FreqtradeBot(default_conf) freqtradebot = FreqtradeBot(default_conf)
telegram = Telegram(freqtradebot) telegram = Telegram(freqtradebot)
@ -602,7 +602,7 @@ def test_telegram_balance_handle(default_conf, update, mocker) -> None:
msg_mock = MagicMock() msg_mock = MagicMock()
mocker.patch.multiple( mocker.patch.multiple(
'freqtrade.rpc.telegram.Telegram', 'freqtrade.clients.rpc.telegram.Telegram',
_init=MagicMock(), _init=MagicMock(),
send_msg=msg_mock send_msg=msg_mock
) )
@ -632,7 +632,7 @@ def test_zero_balance_handle(default_conf, update, mocker) -> None:
msg_mock = MagicMock() msg_mock = MagicMock()
mocker.patch.multiple( mocker.patch.multiple(
'freqtrade.rpc.telegram.Telegram', 'freqtrade.clients.rpc.telegram.Telegram',
_init=MagicMock(), _init=MagicMock(),
send_msg=msg_mock send_msg=msg_mock
) )
@ -654,11 +654,11 @@ def test_start_handle(default_conf, update, mocker) -> None:
mocker.patch('freqtrade.freqtradebot.exchange.init', MagicMock()) mocker.patch('freqtrade.freqtradebot.exchange.init', MagicMock())
msg_mock = MagicMock() msg_mock = MagicMock()
mocker.patch.multiple( mocker.patch.multiple(
'freqtrade.rpc.telegram.Telegram', 'freqtrade.clients.rpc.telegram.Telegram',
_init=MagicMock(), _init=MagicMock(),
send_msg=msg_mock send_msg=msg_mock
) )
mocker.patch('freqtrade.freqtradebot.RPCManager', MagicMock()) mocker.patch('freqtrade.freqtradebot.ClientManager', MagicMock())
freqtradebot = FreqtradeBot(default_conf) freqtradebot = FreqtradeBot(default_conf)
telegram = Telegram(freqtradebot) telegram = Telegram(freqtradebot)
@ -678,11 +678,11 @@ def test_start_handle_already_running(default_conf, update, mocker) -> None:
mocker.patch('freqtrade.freqtradebot.exchange.init', MagicMock()) mocker.patch('freqtrade.freqtradebot.exchange.init', MagicMock())
msg_mock = MagicMock() msg_mock = MagicMock()
mocker.patch.multiple( mocker.patch.multiple(
'freqtrade.rpc.telegram.Telegram', 'freqtrade.clients.rpc.telegram.Telegram',
_init=MagicMock(), _init=MagicMock(),
send_msg=msg_mock send_msg=msg_mock
) )
mocker.patch('freqtrade.freqtradebot.RPCManager', MagicMock()) mocker.patch('freqtrade.freqtradebot.ClientManager', MagicMock())
freqtradebot = FreqtradeBot(default_conf) freqtradebot = FreqtradeBot(default_conf)
telegram = Telegram(freqtradebot) telegram = Telegram(freqtradebot)
@ -703,11 +703,11 @@ def test_stop_handle(default_conf, update, mocker) -> None:
mocker.patch('freqtrade.freqtradebot.exchange.init', MagicMock()) mocker.patch('freqtrade.freqtradebot.exchange.init', MagicMock())
msg_mock = MagicMock() msg_mock = MagicMock()
mocker.patch.multiple( mocker.patch.multiple(
'freqtrade.rpc.telegram.Telegram', 'freqtrade.clients.rpc.telegram.Telegram',
_init=MagicMock(), _init=MagicMock(),
send_msg=msg_mock send_msg=msg_mock
) )
mocker.patch('freqtrade.freqtradebot.RPCManager', MagicMock()) mocker.patch('freqtrade.freqtradebot.ClientManager', MagicMock())
freqtradebot = FreqtradeBot(default_conf) freqtradebot = FreqtradeBot(default_conf)
telegram = Telegram(freqtradebot) telegram = Telegram(freqtradebot)
@ -728,11 +728,11 @@ def test_stop_handle_already_stopped(default_conf, update, mocker) -> None:
mocker.patch('freqtrade.freqtradebot.exchange.init', MagicMock()) mocker.patch('freqtrade.freqtradebot.exchange.init', MagicMock())
msg_mock = MagicMock() msg_mock = MagicMock()
mocker.patch.multiple( mocker.patch.multiple(
'freqtrade.rpc.telegram.Telegram', 'freqtrade.clients.rpc.telegram.Telegram',
_init=MagicMock(), _init=MagicMock(),
send_msg=msg_mock send_msg=msg_mock
) )
mocker.patch('freqtrade.freqtradebot.RPCManager', MagicMock()) mocker.patch('freqtrade.freqtradebot.ClientManager', MagicMock())
freqtradebot = FreqtradeBot(default_conf) freqtradebot = FreqtradeBot(default_conf)
telegram = Telegram(freqtradebot) telegram = Telegram(freqtradebot)
@ -752,8 +752,8 @@ def test_forcesell_handle(default_conf, update, ticker, fee, ticker_sell_up, moc
patch_get_signal(mocker, (True, False)) patch_get_signal(mocker, (True, False))
patch_coinmarketcap(mocker, value={'price_usd': 15000.0}) patch_coinmarketcap(mocker, value={'price_usd': 15000.0})
mocker.patch('freqtrade.fiat_convert.CryptoToFiatConverter._find_price', return_value=15000.0) mocker.patch('freqtrade.fiat_convert.CryptoToFiatConverter._find_price', return_value=15000.0)
rpc_mock = mocker.patch('freqtrade.rpc.telegram.Telegram.send_msg', MagicMock()) rpc_mock = mocker.patch('freqtrade.clients.rpc.telegram.Telegram.send_msg', MagicMock())
mocker.patch('freqtrade.rpc.telegram.Telegram._init', MagicMock()) mocker.patch('freqtrade.clients.rpc.telegram.Telegram._init', MagicMock())
mocker.patch.multiple( mocker.patch.multiple(
'freqtrade.freqtradebot.exchange', 'freqtrade.freqtradebot.exchange',
validate_pairs=MagicMock(), validate_pairs=MagicMock(),
@ -792,8 +792,8 @@ def test_forcesell_down_handle(default_conf, update, ticker, fee, ticker_sell_do
patch_get_signal(mocker, (True, False)) patch_get_signal(mocker, (True, False))
patch_coinmarketcap(mocker, value={'price_usd': 15000.0}) patch_coinmarketcap(mocker, value={'price_usd': 15000.0})
mocker.patch('freqtrade.fiat_convert.CryptoToFiatConverter._find_price', return_value=15000.0) mocker.patch('freqtrade.fiat_convert.CryptoToFiatConverter._find_price', return_value=15000.0)
rpc_mock = mocker.patch('freqtrade.rpc.telegram.Telegram.send_msg', MagicMock()) rpc_mock = mocker.patch('freqtrade.clients.rpc.telegram.Telegram.send_msg', MagicMock())
mocker.patch('freqtrade.rpc.telegram.Telegram._init', MagicMock()) mocker.patch('freqtrade.clients.rpc.telegram.Telegram._init', MagicMock())
mocker.patch.multiple( mocker.patch.multiple(
'freqtrade.freqtradebot.exchange', 'freqtrade.freqtradebot.exchange',
validate_pairs=MagicMock(), validate_pairs=MagicMock(),
@ -836,8 +836,8 @@ def test_forcesell_all_handle(default_conf, update, ticker, fee, mocker) -> None
patch_get_signal(mocker, (True, False)) patch_get_signal(mocker, (True, False))
patch_coinmarketcap(mocker, value={'price_usd': 15000.0}) patch_coinmarketcap(mocker, value={'price_usd': 15000.0})
mocker.patch('freqtrade.fiat_convert.CryptoToFiatConverter._find_price', return_value=15000.0) mocker.patch('freqtrade.fiat_convert.CryptoToFiatConverter._find_price', return_value=15000.0)
rpc_mock = mocker.patch('freqtrade.rpc.telegram.Telegram.send_msg', MagicMock()) rpc_mock = mocker.patch('freqtrade.clients.rpc.telegram.Telegram.send_msg', MagicMock())
mocker.patch('freqtrade.rpc.telegram.Telegram._init', MagicMock()) mocker.patch('freqtrade.clients.rpc.telegram.Telegram._init', MagicMock())
mocker.patch('freqtrade.exchange.get_pair_detail_url', MagicMock()) mocker.patch('freqtrade.exchange.get_pair_detail_url', MagicMock())
mocker.patch.multiple( mocker.patch.multiple(
'freqtrade.freqtradebot.exchange', 'freqtrade.freqtradebot.exchange',
@ -873,7 +873,7 @@ def test_forcesell_handle_invalid(default_conf, update, mocker) -> None:
mocker.patch('freqtrade.fiat_convert.CryptoToFiatConverter._find_price', return_value=15000.0) mocker.patch('freqtrade.fiat_convert.CryptoToFiatConverter._find_price', return_value=15000.0)
msg_mock = MagicMock() msg_mock = MagicMock()
mocker.patch.multiple( mocker.patch.multiple(
'freqtrade.rpc.telegram.Telegram', 'freqtrade.clients.rpc.telegram.Telegram',
_init=MagicMock(), _init=MagicMock(),
send_msg=msg_mock send_msg=msg_mock
) )
@ -915,7 +915,7 @@ def test_performance_handle(default_conf, update, ticker, fee,
patch_coinmarketcap(mocker) patch_coinmarketcap(mocker)
msg_mock = MagicMock() msg_mock = MagicMock()
mocker.patch.multiple( mocker.patch.multiple(
'freqtrade.rpc.telegram.Telegram', 'freqtrade.clients.rpc.telegram.Telegram',
_init=MagicMock(), _init=MagicMock(),
send_msg=msg_mock send_msg=msg_mock
) )
@ -925,7 +925,7 @@ def test_performance_handle(default_conf, update, ticker, fee,
get_ticker=ticker, get_ticker=ticker,
get_fee=fee get_fee=fee
) )
mocker.patch('freqtrade.freqtradebot.RPCManager', MagicMock()) mocker.patch('freqtrade.freqtradebot.ClientManager', MagicMock())
freqtradebot = FreqtradeBot(default_conf) freqtradebot = FreqtradeBot(default_conf)
telegram = Telegram(freqtradebot) telegram = Telegram(freqtradebot)
@ -956,7 +956,7 @@ def test_performance_handle_invalid(default_conf, update, mocker) -> None:
patch_coinmarketcap(mocker) patch_coinmarketcap(mocker)
msg_mock = MagicMock() msg_mock = MagicMock()
mocker.patch.multiple( mocker.patch.multiple(
'freqtrade.rpc.telegram.Telegram', 'freqtrade.clients.rpc.telegram.Telegram',
_init=MagicMock(), _init=MagicMock(),
send_msg=msg_mock send_msg=msg_mock
) )
@ -979,7 +979,7 @@ def test_count_handle(default_conf, update, ticker, fee, mocker) -> None:
patch_coinmarketcap(mocker) patch_coinmarketcap(mocker)
msg_mock = MagicMock() msg_mock = MagicMock()
mocker.patch.multiple( mocker.patch.multiple(
'freqtrade.rpc.telegram.Telegram', 'freqtrade.clients.rpc.telegram.Telegram',
_init=MagicMock(), _init=MagicMock(),
send_msg=msg_mock send_msg=msg_mock
) )
@ -1022,7 +1022,7 @@ def test_help_handle(default_conf, update, mocker) -> None:
mocker.patch('freqtrade.freqtradebot.exchange.init', MagicMock()) mocker.patch('freqtrade.freqtradebot.exchange.init', MagicMock())
msg_mock = MagicMock() msg_mock = MagicMock()
mocker.patch.multiple( mocker.patch.multiple(
'freqtrade.rpc.telegram.Telegram', 'freqtrade.clients.rpc.telegram.Telegram',
_init=MagicMock(), _init=MagicMock(),
send_msg=msg_mock send_msg=msg_mock
) )
@ -1042,7 +1042,7 @@ def test_version_handle(default_conf, update, mocker) -> None:
mocker.patch('freqtrade.freqtradebot.exchange.init', MagicMock()) mocker.patch('freqtrade.freqtradebot.exchange.init', MagicMock())
msg_mock = MagicMock() msg_mock = MagicMock()
mocker.patch.multiple( mocker.patch.multiple(
'freqtrade.rpc.telegram.Telegram', 'freqtrade.clients.rpc.telegram.Telegram',
_init=MagicMock(), _init=MagicMock(),
send_msg=msg_mock send_msg=msg_mock
) )
@ -1060,7 +1060,7 @@ def test_send_msg(default_conf, mocker) -> None:
""" """
patch_coinmarketcap(mocker) patch_coinmarketcap(mocker)
mocker.patch('freqtrade.freqtradebot.exchange.init', MagicMock()) mocker.patch('freqtrade.freqtradebot.exchange.init', MagicMock())
mocker.patch('freqtrade.rpc.telegram.Telegram._init', MagicMock()) mocker.patch('freqtrade.clients.rpc.telegram.Telegram._init', MagicMock())
conf = deepcopy(default_conf) conf = deepcopy(default_conf)
bot = MagicMock() bot = MagicMock()
freqtradebot = FreqtradeBot(conf) freqtradebot = FreqtradeBot(conf)
@ -1082,7 +1082,7 @@ def test_send_msg_network_error(default_conf, mocker, caplog) -> None:
""" """
patch_coinmarketcap(mocker) patch_coinmarketcap(mocker)
mocker.patch('freqtrade.freqtradebot.exchange.init', MagicMock()) mocker.patch('freqtrade.freqtradebot.exchange.init', MagicMock())
mocker.patch('freqtrade.rpc.telegram.Telegram._init', MagicMock()) mocker.patch('freqtrade.clients.rpc.telegram.Telegram._init', MagicMock())
conf = deepcopy(default_conf) conf = deepcopy(default_conf)
bot = MagicMock() bot = MagicMock()
bot.send_message = MagicMock(side_effect=NetworkError('Oh snap')) bot.send_message = MagicMock(side_effect=NetworkError('Oh snap'))

148
freqtrade/tests/rpc/test_rpc.py → freqtrade/tests/clients/test_client.py
View File

@ -9,7 +9,7 @@ from unittest.mock import MagicMock
from freqtrade.freqtradebot import FreqtradeBot from freqtrade.freqtradebot import FreqtradeBot
from freqtrade.persistence import Trade from freqtrade.persistence import Trade
from freqtrade.rpc.rpc import RPC from freqtrade.clients.common_client import CLIENT
from freqtrade.state import State from freqtrade.state import State
from freqtrade.tests.test_freqtradebot import patch_get_signal, patch_coinmarketcap from freqtrade.tests.test_freqtradebot import patch_get_signal, patch_coinmarketcap
@ -23,13 +23,13 @@ def prec_satoshi(a, b) -> float:
# Unit tests # Unit tests
def test_rpc_trade_status(default_conf, ticker, fee, mocker) -> None: def test_server_trade_status(default_conf, ticker, fee, mocker) -> None:
""" """
Test rpc_trade_status() method Test server_trade_status() method
""" """
patch_get_signal(mocker, (True, False)) patch_get_signal(mocker, (True, False))
patch_coinmarketcap(mocker) patch_coinmarketcap(mocker)
mocker.patch('freqtrade.rpc.rpc_manager.Telegram', MagicMock()) mocker.patch('freqtrade.clients.client_manager.Telegram', MagicMock())
mocker.patch.multiple( mocker.patch.multiple(
'freqtrade.freqtradebot.exchange', 'freqtrade.freqtradebot.exchange',
validate_pairs=MagicMock(), validate_pairs=MagicMock(),
@ -38,20 +38,20 @@ def test_rpc_trade_status(default_conf, ticker, fee, mocker) -> None:
) )
freqtradebot = FreqtradeBot(default_conf) freqtradebot = FreqtradeBot(default_conf)
rpc = RPC(freqtradebot) client = CLIENT(freqtradebot)
freqtradebot.state = State.STOPPED freqtradebot.state = State.STOPPED
(error, result) = rpc.rpc_trade_status() (error, result) = client.server_trade_status()
assert error assert error
assert 'trader is not running' in result assert 'trader is not running' in result
freqtradebot.state = State.RUNNING freqtradebot.state = State.RUNNING
(error, result) = rpc.rpc_trade_status() (error, result) = client.server_trade_status()
assert error assert error
assert 'no active trade' in result assert 'no active trade' in result
freqtradebot.create_trade() freqtradebot.create_trade()
(error, result) = rpc.rpc_trade_status() (error, result) = client.server_trade_status()
assert not error assert not error
trade = result[0] trade = result[0]
@ -72,13 +72,13 @@ def test_rpc_trade_status(default_conf, ticker, fee, mocker) -> None:
assert trade.find('[ETH/BTC]') >= 0 assert trade.find('[ETH/BTC]') >= 0
def test_rpc_status_table(default_conf, ticker, fee, mocker) -> None: def test_server_status_table(default_conf, ticker, fee, mocker) -> None:
""" """
Test rpc_status_table() method Test server_status_table() method
""" """
patch_get_signal(mocker, (True, False)) patch_get_signal(mocker, (True, False))
patch_coinmarketcap(mocker) patch_coinmarketcap(mocker)
mocker.patch('freqtrade.rpc.rpc_manager.Telegram', MagicMock()) mocker.patch('freqtrade.clients.client_manager.Telegram', MagicMock())
mocker.patch.multiple( mocker.patch.multiple(
'freqtrade.freqtradebot.exchange', 'freqtrade.freqtradebot.exchange',
validate_pairs=MagicMock(), validate_pairs=MagicMock(),
@ -87,33 +87,33 @@ def test_rpc_status_table(default_conf, ticker, fee, mocker) -> None:
) )
freqtradebot = FreqtradeBot(default_conf) freqtradebot = FreqtradeBot(default_conf)
rpc = RPC(freqtradebot) client = CLIENT(freqtradebot)
freqtradebot.state = State.STOPPED freqtradebot.state = State.STOPPED
(error, result) = rpc.rpc_status_table() (error, result) = client.server_status_table()
assert error assert error
assert '*Status:* `trader is not running`' in result assert '*Status:* `trader is not running`' in result
freqtradebot.state = State.RUNNING freqtradebot.state = State.RUNNING
(error, result) = rpc.rpc_status_table() (error, result) = client.server_status_table()
assert error assert error
assert '*Status:* `no active order`' in result assert '*Status:* `no active order`' in result
freqtradebot.create_trade() freqtradebot.create_trade()
(error, result) = rpc.rpc_status_table() (error, result) = client.server_status_table()
assert 'just now' in result['Since'].all() assert 'just now' in result['Since'].all()
assert 'ETH/BTC' in result['Pair'].all() assert 'ETH/BTC' in result['Pair'].all()
assert '-0.59%' in result['Profit'].all() assert '-0.59%' in result['Profit'].all()
def test_rpc_daily_profit(default_conf, update, ticker, fee, def test_server_daily_profit(default_conf, update, ticker, fee,
limit_buy_order, limit_sell_order, mocker) -> None: limit_buy_order, limit_sell_order, mocker) -> None:
""" """
Test rpc_daily_profit() method Test server_daily_profit() method
""" """
patch_get_signal(mocker, (True, False)) patch_get_signal(mocker, (True, False))
patch_coinmarketcap(mocker, value={'price_usd': 15000.0}) patch_coinmarketcap(mocker, value={'price_usd': 15000.0})
mocker.patch('freqtrade.rpc.rpc_manager.Telegram', MagicMock()) mocker.patch('freqtrade.clients.client_manager.Telegram', MagicMock())
mocker.patch.multiple( mocker.patch.multiple(
'freqtrade.freqtradebot.exchange', 'freqtrade.freqtradebot.exchange',
validate_pairs=MagicMock(), validate_pairs=MagicMock(),
@ -125,7 +125,7 @@ def test_rpc_daily_profit(default_conf, update, ticker, fee,
stake_currency = default_conf['stake_currency'] stake_currency = default_conf['stake_currency']
fiat_display_currency = default_conf['fiat_display_currency'] fiat_display_currency = default_conf['fiat_display_currency']
rpc = RPC(freqtradebot) rpc = CLIENT(freqtradebot)
# Create some test data # Create some test data
freqtradebot.create_trade() freqtradebot.create_trade()
@ -140,7 +140,7 @@ def test_rpc_daily_profit(default_conf, update, ticker, fee,
# Try valid data # Try valid data
update.message.text = '/daily 2' update.message.text = '/daily 2'
(error, days) = rpc.rpc_daily_profit(7, stake_currency, fiat_display_currency) (error, days) = rpc.server_daily_profit(7, stake_currency, fiat_display_currency)
assert not error assert not error
assert len(days) == 7 assert len(days) == 7
for day in days: for day in days:
@ -154,15 +154,15 @@ def test_rpc_daily_profit(default_conf, update, ticker, fee,
assert str(days[0][0]) == str(datetime.utcnow().date()) assert str(days[0][0]) == str(datetime.utcnow().date())
# Try invalid data # Try invalid data
(error, days) = rpc.rpc_daily_profit(0, stake_currency, fiat_display_currency) (error, days) = rpc.server_daily_profit(0, stake_currency, fiat_display_currency)
assert error assert error
assert days.find('must be an integer greater than 0') >= 0 assert days.find('must be an integer greater than 0') >= 0
def test_rpc_trade_statistics(default_conf, ticker, ticker_sell_up, fee, def test_server_trade_statistics(default_conf, ticker, ticker_sell_up, fee,
limit_buy_order, limit_sell_order, mocker) -> None: limit_buy_order, limit_sell_order, mocker) -> None:
""" """
Test rpc_trade_statistics() method Test server_trade_statistics() method
""" """
patch_get_signal(mocker, (True, False)) patch_get_signal(mocker, (True, False))
mocker.patch.multiple( mocker.patch.multiple(
@ -170,7 +170,7 @@ def test_rpc_trade_statistics(default_conf, ticker, ticker_sell_up, fee,
ticker=MagicMock(return_value={'price_usd': 15000.0}), ticker=MagicMock(return_value={'price_usd': 15000.0}),
) )
mocker.patch('freqtrade.fiat_convert.CryptoToFiatConverter._find_price', return_value=15000.0) mocker.patch('freqtrade.fiat_convert.CryptoToFiatConverter._find_price', return_value=15000.0)
mocker.patch('freqtrade.rpc.rpc_manager.Telegram', MagicMock()) mocker.patch('freqtrade.clients.client_manager.Telegram', MagicMock())
mocker.patch.multiple( mocker.patch.multiple(
'freqtrade.freqtradebot.exchange', 'freqtrade.freqtradebot.exchange',
validate_pairs=MagicMock(), validate_pairs=MagicMock(),
@ -182,9 +182,9 @@ def test_rpc_trade_statistics(default_conf, ticker, ticker_sell_up, fee,
stake_currency = default_conf['stake_currency'] stake_currency = default_conf['stake_currency']
fiat_display_currency = default_conf['fiat_display_currency'] fiat_display_currency = default_conf['fiat_display_currency']
rpc = RPC(freqtradebot) rpc = CLIENT(freqtradebot)
(error, stats) = rpc.rpc_trade_statistics(stake_currency, fiat_display_currency) (error, stats) = rpc.server_trade_statistics(stake_currency, fiat_display_currency)
assert error assert error
assert stats.find('no closed trade') >= 0 assert stats.find('no closed trade') >= 0
@ -219,7 +219,7 @@ def test_rpc_trade_statistics(default_conf, ticker, ticker_sell_up, fee,
trade.close_date = datetime.utcnow() trade.close_date = datetime.utcnow()
trade.is_open = False trade.is_open = False
(error, stats) = rpc.rpc_trade_statistics(stake_currency, fiat_display_currency) (error, stats) = rpc.server_trade_statistics(stake_currency, fiat_display_currency)
assert not error assert not error
assert prec_satoshi(stats['profit_closed_coin'], 6.217e-05) assert prec_satoshi(stats['profit_closed_coin'], 6.217e-05)
assert prec_satoshi(stats['profit_closed_percent'], 6.2) assert prec_satoshi(stats['profit_closed_percent'], 6.2)
@ -235,12 +235,12 @@ def test_rpc_trade_statistics(default_conf, ticker, ticker_sell_up, fee,
assert prec_satoshi(stats['best_rate'], 6.2) assert prec_satoshi(stats['best_rate'], 6.2)
# Test that rpc_trade_statistics can handle trades that lacks # Test that server_trade_statistics can handle trades that lacks
# trade.open_rate (it is set to None) # trade.open_rate (it is set to None)
def test_rpc_trade_statistics_closed(mocker, default_conf, ticker, fee, def test_server_trade_statistics_closed(mocker, default_conf, ticker, fee,
ticker_sell_up, limit_buy_order, limit_sell_order): ticker_sell_up, limit_buy_order, limit_sell_order):
""" """
Test rpc_trade_statistics() method Test server_trade_statistics() method
""" """
patch_get_signal(mocker, (True, False)) patch_get_signal(mocker, (True, False))
mocker.patch.multiple( mocker.patch.multiple(
@ -248,7 +248,7 @@ def test_rpc_trade_statistics_closed(mocker, default_conf, ticker, fee,
ticker=MagicMock(return_value={'price_usd': 15000.0}), ticker=MagicMock(return_value={'price_usd': 15000.0}),
) )
mocker.patch('freqtrade.fiat_convert.CryptoToFiatConverter._find_price', return_value=15000.0) mocker.patch('freqtrade.fiat_convert.CryptoToFiatConverter._find_price', return_value=15000.0)
mocker.patch('freqtrade.rpc.rpc_manager.Telegram', MagicMock()) mocker.patch('freqtrade.clients.client_manager.Telegram', MagicMock())
mocker.patch.multiple( mocker.patch.multiple(
'freqtrade.freqtradebot.exchange', 'freqtrade.freqtradebot.exchange',
validate_pairs=MagicMock(), validate_pairs=MagicMock(),
@ -260,7 +260,7 @@ def test_rpc_trade_statistics_closed(mocker, default_conf, ticker, fee,
stake_currency = default_conf['stake_currency'] stake_currency = default_conf['stake_currency']
fiat_display_currency = default_conf['fiat_display_currency'] fiat_display_currency = default_conf['fiat_display_currency']
rpc = RPC(freqtradebot) rpc = CLIENT(freqtradebot)
# Create some test data # Create some test data
freqtradebot.create_trade() freqtradebot.create_trade()
@ -281,7 +281,7 @@ def test_rpc_trade_statistics_closed(mocker, default_conf, ticker, fee,
for trade in Trade.query.order_by(Trade.id).all(): for trade in Trade.query.order_by(Trade.id).all():
trade.open_rate = None trade.open_rate = None
(error, stats) = rpc.rpc_trade_statistics(stake_currency, fiat_display_currency) (error, stats) = rpc.server_trade_statistics(stake_currency, fiat_display_currency)
assert not error assert not error
assert prec_satoshi(stats['profit_closed_coin'], 0) assert prec_satoshi(stats['profit_closed_coin'], 0)
assert prec_satoshi(stats['profit_closed_percent'], 0) assert prec_satoshi(stats['profit_closed_percent'], 0)
@ -297,9 +297,9 @@ def test_rpc_trade_statistics_closed(mocker, default_conf, ticker, fee,
assert prec_satoshi(stats['best_rate'], 6.2) assert prec_satoshi(stats['best_rate'], 6.2)
def test_rpc_balance_handle(default_conf, mocker): def test_server_balance_handle(default_conf, mocker):
""" """
Test rpc_balance() method Test server_balance() method
""" """
mock_balance = { mock_balance = {
'BTC': { 'BTC': {
@ -320,7 +320,7 @@ def test_rpc_balance_handle(default_conf, mocker):
ticker=MagicMock(return_value={'price_usd': 15000.0}), ticker=MagicMock(return_value={'price_usd': 15000.0}),
) )
mocker.patch('freqtrade.fiat_convert.CryptoToFiatConverter._find_price', return_value=15000.0) mocker.patch('freqtrade.fiat_convert.CryptoToFiatConverter._find_price', return_value=15000.0)
mocker.patch('freqtrade.rpc.rpc_manager.Telegram', MagicMock()) mocker.patch('freqtrade.clients.client_manager.Telegram', MagicMock())
mocker.patch.multiple( mocker.patch.multiple(
'freqtrade.freqtradebot.exchange', 'freqtrade.freqtradebot.exchange',
validate_pairs=MagicMock(), validate_pairs=MagicMock(),
@ -328,9 +328,9 @@ def test_rpc_balance_handle(default_conf, mocker):
) )
freqtradebot = FreqtradeBot(default_conf) freqtradebot = FreqtradeBot(default_conf)
rpc = RPC(freqtradebot) rpc = CLIENT(freqtradebot)
(error, res) = rpc.rpc_balance(default_conf['fiat_display_currency']) (error, res) = rpc.server_balance(default_conf['fiat_display_currency'])
assert not error assert not error
(trade, x, y, z) = res (trade, x, y, z) = res
assert prec_satoshi(x, 12) assert prec_satoshi(x, 12)
@ -344,13 +344,13 @@ def test_rpc_balance_handle(default_conf, mocker):
assert prec_satoshi(trade[0]['est_btc'], 12) assert prec_satoshi(trade[0]['est_btc'], 12)
def test_rpc_start(mocker, default_conf) -> None: def test_server_start(mocker, default_conf) -> None:
""" """
Test rpc_start() method Test server_start() method
""" """
patch_get_signal(mocker, (True, False)) patch_get_signal(mocker, (True, False))
patch_coinmarketcap(mocker) patch_coinmarketcap(mocker)
mocker.patch('freqtrade.rpc.rpc_manager.Telegram', MagicMock()) mocker.patch('freqtrade.clients.client_manager.Telegram', MagicMock())
mocker.patch.multiple( mocker.patch.multiple(
'freqtrade.freqtradebot.exchange', 'freqtrade.freqtradebot.exchange',
validate_pairs=MagicMock(), validate_pairs=MagicMock(),
@ -358,27 +358,27 @@ def test_rpc_start(mocker, default_conf) -> None:
) )
freqtradebot = FreqtradeBot(default_conf) freqtradebot = FreqtradeBot(default_conf)
rpc = RPC(freqtradebot) rpc = CLIENT(freqtradebot)
freqtradebot.state = State.STOPPED freqtradebot.state = State.STOPPED
(error, result) = rpc.rpc_start() (error, result) = rpc.server_start()
assert not error assert not error
assert '`Starting trader ...`' in result assert '`Starting trader ...`' in result
assert freqtradebot.state == State.RUNNING assert freqtradebot.state == State.RUNNING
(error, result) = rpc.rpc_start() (error, result) = rpc.server_start()
assert error assert error
assert '*Status:* `already running`' in result assert '*Status:* `already running`' in result
assert freqtradebot.state == State.RUNNING assert freqtradebot.state == State.RUNNING
def test_rpc_stop(mocker, default_conf) -> None: def test_server_stop(mocker, default_conf) -> None:
""" """
Test rpc_stop() method Test server_stop() method
""" """
patch_get_signal(mocker, (True, False)) patch_get_signal(mocker, (True, False))
patch_coinmarketcap(mocker) patch_coinmarketcap(mocker)
mocker.patch('freqtrade.rpc.rpc_manager.Telegram', MagicMock()) mocker.patch('freqtrade.clients.client_manager.Telegram', MagicMock())
mocker.patch.multiple( mocker.patch.multiple(
'freqtrade.freqtradebot.exchange', 'freqtrade.freqtradebot.exchange',
validate_pairs=MagicMock(), validate_pairs=MagicMock(),
@ -386,27 +386,27 @@ def test_rpc_stop(mocker, default_conf) -> None:
) )
freqtradebot = FreqtradeBot(default_conf) freqtradebot = FreqtradeBot(default_conf)
rpc = RPC(freqtradebot) rpc = CLIENT(freqtradebot)
freqtradebot.state = State.RUNNING freqtradebot.state = State.RUNNING
(error, result) = rpc.rpc_stop() (error, result) = rpc.server_stop()
assert not error assert not error
assert '`Stopping trader ...`' in result assert '`Stopping trader ...`' in result
assert freqtradebot.state == State.STOPPED assert freqtradebot.state == State.STOPPED
(error, result) = rpc.rpc_stop() (error, result) = rpc.server_stop()
assert error assert error
assert '*Status:* `already stopped`' in result assert '*Status:* `already stopped`' in result
assert freqtradebot.state == State.STOPPED assert freqtradebot.state == State.STOPPED
def test_rpc_forcesell(default_conf, ticker, fee, mocker) -> None: def test_server_forcesell(default_conf, ticker, fee, mocker) -> None:
""" """
Test rpc_forcesell() method Test server_forcesell() method
""" """
patch_get_signal(mocker, (True, False)) patch_get_signal(mocker, (True, False))
patch_coinmarketcap(mocker) patch_coinmarketcap(mocker)
mocker.patch('freqtrade.rpc.rpc_manager.Telegram', MagicMock()) mocker.patch('freqtrade.clients.client_manager.Telegram', MagicMock())
cancel_order_mock = MagicMock() cancel_order_mock = MagicMock()
mocker.patch.multiple( mocker.patch.multiple(
@ -425,37 +425,37 @@ def test_rpc_forcesell(default_conf, ticker, fee, mocker) -> None:
) )
freqtradebot = FreqtradeBot(default_conf) freqtradebot = FreqtradeBot(default_conf)
rpc = RPC(freqtradebot) rpc = CLIENT(freqtradebot)
freqtradebot.state = State.STOPPED freqtradebot.state = State.STOPPED
(error, res) = rpc.rpc_forcesell(None) (error, res) = rpc.server_forcesell(None)
assert error assert error
assert res == '`trader is not running`' assert res == '`trader is not running`'
freqtradebot.state = State.RUNNING freqtradebot.state = State.RUNNING
(error, res) = rpc.rpc_forcesell(None) (error, res) = rpc.server_forcesell(None)
assert error assert error
assert res == 'Invalid argument.' assert res == 'Invalid argument.'
(error, res) = rpc.rpc_forcesell('all') (error, res) = rpc.server_forcesell('all')
assert not error assert not error
assert res == '' assert res == ''
freqtradebot.create_trade() freqtradebot.create_trade()
(error, res) = rpc.rpc_forcesell('all') (error, res) = rpc.server_forcesell('all')
assert not error assert not error
assert res == '' assert res == ''
(error, res) = rpc.rpc_forcesell('1') (error, res) = rpc.server_forcesell('1')
assert not error assert not error
assert res == '' assert res == ''
freqtradebot.state = State.STOPPED freqtradebot.state = State.STOPPED
(error, res) = rpc.rpc_forcesell(None) (error, res) = rpc.server_forcesell(None)
assert error assert error
assert res == '`trader is not running`' assert res == '`trader is not running`'
(error, res) = rpc.rpc_forcesell('all') (error, res) = rpc.server_forcesell('all')
assert error assert error
assert res == '`trader is not running`' assert res == '`trader is not running`'
@ -475,7 +475,7 @@ def test_rpc_forcesell(default_conf, ticker, fee, mocker) -> None:
) )
# check that the trade is called, which is done by ensuring exchange.cancel_order is called # check that the trade is called, which is done by ensuring exchange.cancel_order is called
# and trade amount is updated # and trade amount is updated
(error, res) = rpc.rpc_forcesell('1') (error, res) = rpc.server_forcesell('1')
assert not error assert not error
assert res == '' assert res == ''
assert cancel_order_mock.call_count == 1 assert cancel_order_mock.call_count == 1
@ -495,7 +495,7 @@ def test_rpc_forcesell(default_conf, ticker, fee, mocker) -> None:
} }
) )
# check that the trade is called, which is done by ensuring exchange.cancel_order is called # check that the trade is called, which is done by ensuring exchange.cancel_order is called
(error, res) = rpc.rpc_forcesell('2') (error, res) = rpc.server_forcesell('2')
assert not error assert not error
assert res == '' assert res == ''
assert cancel_order_mock.call_count == 2 assert cancel_order_mock.call_count == 2
@ -511,7 +511,7 @@ def test_rpc_forcesell(default_conf, ticker, fee, mocker) -> None:
'side': 'sell' 'side': 'sell'
} }
) )
(error, res) = rpc.rpc_forcesell('3') (error, res) = rpc.server_forcesell('3')
assert not error assert not error
assert res == '' assert res == ''
# status quo, no exchange calls # status quo, no exchange calls
@ -521,11 +521,11 @@ def test_rpc_forcesell(default_conf, ticker, fee, mocker) -> None:
def test_performance_handle(default_conf, ticker, limit_buy_order, fee, def test_performance_handle(default_conf, ticker, limit_buy_order, fee,
limit_sell_order, mocker) -> None: limit_sell_order, mocker) -> None:
""" """
Test rpc_performance() method Test server_performance() method
""" """
patch_get_signal(mocker, (True, False)) patch_get_signal(mocker, (True, False))
patch_coinmarketcap(mocker) patch_coinmarketcap(mocker)
mocker.patch('freqtrade.rpc.rpc_manager.Telegram', MagicMock()) mocker.patch('freqtrade.clients.client_manager.Telegram', MagicMock())
mocker.patch.multiple( mocker.patch.multiple(
'freqtrade.freqtradebot.exchange', 'freqtrade.freqtradebot.exchange',
validate_pairs=MagicMock(), validate_pairs=MagicMock(),
@ -535,7 +535,7 @@ def test_performance_handle(default_conf, ticker, limit_buy_order, fee,
) )
freqtradebot = FreqtradeBot(default_conf) freqtradebot = FreqtradeBot(default_conf)
rpc = RPC(freqtradebot) rpc = CLIENT(freqtradebot)
# Create some test data # Create some test data
freqtradebot.create_trade() freqtradebot.create_trade()
@ -550,7 +550,7 @@ def test_performance_handle(default_conf, ticker, limit_buy_order, fee,
trade.close_date = datetime.utcnow() trade.close_date = datetime.utcnow()
trade.is_open = False trade.is_open = False
(error, res) = rpc.rpc_performance() (error, res) = rpc.server_performance()
assert not error assert not error
assert len(res) == 1 assert len(res) == 1
assert res[0]['pair'] == 'ETH/BTC' assert res[0]['pair'] == 'ETH/BTC'
@ -558,13 +558,13 @@ def test_performance_handle(default_conf, ticker, limit_buy_order, fee,
assert prec_satoshi(res[0]['profit'], 6.2) assert prec_satoshi(res[0]['profit'], 6.2)
def test_rpc_count(mocker, default_conf, ticker, fee) -> None: def test_server_count(mocker, default_conf, ticker, fee) -> None:
""" """
Test rpc_count() method Test server_count() method
""" """
patch_get_signal(mocker, (True, False)) patch_get_signal(mocker, (True, False))
patch_coinmarketcap(mocker) patch_coinmarketcap(mocker)
mocker.patch('freqtrade.rpc.rpc_manager.Telegram', MagicMock()) mocker.patch('freqtrade.clients.client_manager.Telegram', MagicMock())
mocker.patch.multiple( mocker.patch.multiple(
'freqtrade.freqtradebot.exchange', 'freqtrade.freqtradebot.exchange',
validate_pairs=MagicMock(), validate_pairs=MagicMock(),
@ -574,16 +574,16 @@ def test_rpc_count(mocker, default_conf, ticker, fee) -> None:
) )
freqtradebot = FreqtradeBot(default_conf) freqtradebot = FreqtradeBot(default_conf)
rpc = RPC(freqtradebot) rpc = CLIENT(freqtradebot)
(error, trades) = rpc.rpc_count() (error, trades) = rpc.server_count()
nb_trades = len(trades) nb_trades = len(trades)
assert not error assert not error
assert nb_trades == 0 assert nb_trades == 0
# Create some test data # Create some test data
freqtradebot.create_trade() freqtradebot.create_trade()
(error, trades) = rpc.rpc_count() (error, trades) = rpc.server_count()
nb_trades = len(trades) nb_trades = len(trades)
assert not error assert not error
assert nb_trades == 1 assert nb_trades == 1

72
freqtrade/tests/rpc/test_rpc_manager.py → freqtrade/tests/clients/test_client_manager.py
View File

@ -1,37 +1,37 @@
""" """
Unit test file for rpc/rpc_manager.py Unit test file for rpc/client_manager.py
""" """
import logging import logging
from copy import deepcopy from copy import deepcopy
from unittest.mock import MagicMock from unittest.mock import MagicMock
from freqtrade.rpc.rpc_manager import RPCManager from freqtrade.clients.client_manager import ClientManager
from freqtrade.rpc.telegram import Telegram from freqtrade.clients.rpc.telegram import Telegram
from freqtrade.tests.conftest import log_has, get_patched_freqtradebot from freqtrade.tests.conftest import log_has, get_patched_freqtradebot
def test_rpc_manager_object() -> None: def test_client_manager_object() -> None:
""" """
Test the Arguments object has the mandatory methods Test the Arguments object has the mandatory methods
:return: None :return: None
""" """
assert hasattr(RPCManager, '_init') assert hasattr(ClientManager, '_init')
assert hasattr(RPCManager, 'send_msg') assert hasattr(ClientManager, 'send_msg')
assert hasattr(RPCManager, 'cleanup') assert hasattr(ClientManager, 'cleanup')
def test__init__(mocker, default_conf) -> None: def test__init__(mocker, default_conf) -> None:
""" """
Test __init__() method Test __init__() method
""" """
init_mock = mocker.patch('freqtrade.rpc.rpc_manager.RPCManager._init', MagicMock()) init_mock = mocker.patch('freqtrade.clients.client_manager.ClientManager._init', MagicMock())
freqtradebot = get_patched_freqtradebot(mocker, default_conf) freqtradebot = get_patched_freqtradebot(mocker, default_conf)
rpc_manager = RPCManager(freqtradebot) client_manager = ClientManager(freqtradebot)
assert rpc_manager.freqtrade == freqtradebot assert client_manager.freqtrade == freqtradebot
assert rpc_manager.registered_modules == [] assert client_manager.registered_modules == []
assert rpc_manager.telegram is None assert client_manager.telegram is None
assert init_mock.call_count == 1 assert init_mock.call_count == 1
@ -45,11 +45,11 @@ def test_init_telegram_disabled(mocker, default_conf, caplog) -> None:
conf['telegram']['enabled'] = False conf['telegram']['enabled'] = False
freqtradebot = get_patched_freqtradebot(mocker, conf) freqtradebot = get_patched_freqtradebot(mocker, conf)
rpc_manager = RPCManager(freqtradebot) client_manager = ClientManager(freqtradebot)
assert not log_has('Enabling rpc.telegram ...', caplog.record_tuples) assert not log_has('Enabling rpc.telegram ...', caplog.record_tuples)
assert rpc_manager.registered_modules == [] assert client_manager.registered_modules == []
assert rpc_manager.telegram is None assert client_manager.telegram is None
def test_init_telegram_enabled(mocker, default_conf, caplog) -> None: def test_init_telegram_enabled(mocker, default_conf, caplog) -> None:
@ -57,16 +57,16 @@ def test_init_telegram_enabled(mocker, default_conf, caplog) -> None:
Test _init() method with Telegram enabled Test _init() method with Telegram enabled
""" """
caplog.set_level(logging.DEBUG) caplog.set_level(logging.DEBUG)
mocker.patch('freqtrade.rpc.telegram.Telegram._init', MagicMock()) mocker.patch('freqtrade.clients.rpc.telegram.Telegram._init', MagicMock())
freqtradebot = get_patched_freqtradebot(mocker, default_conf) freqtradebot = get_patched_freqtradebot(mocker, default_conf)
rpc_manager = RPCManager(freqtradebot) client_manager = ClientManager(freqtradebot)
assert log_has('Enabling rpc.telegram ...', caplog.record_tuples) assert log_has('Enabling rpc.telegram ...', caplog.record_tuples)
len_modules = len(rpc_manager.registered_modules) len_modules = len(client_manager.registered_modules)
assert len_modules == 1 assert len_modules == 1
assert 'telegram' in rpc_manager.registered_modules assert 'telegram' in client_manager.registered_modules
assert isinstance(rpc_manager.telegram, Telegram) assert isinstance(client_manager.telegram, Telegram)
def test_cleanup_telegram_disabled(mocker, default_conf, caplog) -> None: def test_cleanup_telegram_disabled(mocker, default_conf, caplog) -> None:
@ -74,14 +74,14 @@ def test_cleanup_telegram_disabled(mocker, default_conf, caplog) -> None:
Test cleanup() method with Telegram disabled Test cleanup() method with Telegram disabled
""" """
caplog.set_level(logging.DEBUG) caplog.set_level(logging.DEBUG)
telegram_mock = mocker.patch('freqtrade.rpc.telegram.Telegram.cleanup', MagicMock()) telegram_mock = mocker.patch('freqtrade.clients.rpc.telegram.Telegram.cleanup', MagicMock())
conf = deepcopy(default_conf) conf = deepcopy(default_conf)
conf['telegram']['enabled'] = False conf['telegram']['enabled'] = False
freqtradebot = get_patched_freqtradebot(mocker, conf) freqtradebot = get_patched_freqtradebot(mocker, conf)
rpc_manager = RPCManager(freqtradebot) client_manager = ClientManager(freqtradebot)
rpc_manager.cleanup() client_manager.cleanup()
assert not log_has('Cleaning up rpc.telegram ...', caplog.record_tuples) assert not log_has('Cleaning up rpc.telegram ...', caplog.record_tuples)
assert telegram_mock.call_count == 0 assert telegram_mock.call_count == 0
@ -92,18 +92,18 @@ def test_cleanup_telegram_enabled(mocker, default_conf, caplog) -> None:
Test cleanup() method with Telegram enabled Test cleanup() method with Telegram enabled
""" """
caplog.set_level(logging.DEBUG) caplog.set_level(logging.DEBUG)
mocker.patch('freqtrade.rpc.telegram.Telegram._init', MagicMock()) mocker.patch('freqtrade.clients.rpc.telegram.Telegram._init', MagicMock())
telegram_mock = mocker.patch('freqtrade.rpc.telegram.Telegram.cleanup', MagicMock()) telegram_mock = mocker.patch('freqtrade.clients.rpc.telegram.Telegram.cleanup', MagicMock())
freqtradebot = get_patched_freqtradebot(mocker, default_conf) freqtradebot = get_patched_freqtradebot(mocker, default_conf)
rpc_manager = RPCManager(freqtradebot) client_manager = ClientManager(freqtradebot)
# Check we have Telegram as a registered modules # Check we have Telegram as a registered modules
assert 'telegram' in rpc_manager.registered_modules assert 'telegram' in client_manager.registered_modules
rpc_manager.cleanup() client_manager.cleanup()
assert log_has('Cleaning up rpc.telegram ...', caplog.record_tuples) assert log_has('Cleaning up rpc.telegram ...', caplog.record_tuples)
assert 'telegram' not in rpc_manager.registered_modules assert 'telegram' not in client_manager.registered_modules
assert telegram_mock.call_count == 1 assert telegram_mock.call_count == 1
@ -111,14 +111,14 @@ def test_send_msg_telegram_disabled(mocker, default_conf, caplog) -> None:
""" """
Test send_msg() method with Telegram disabled Test send_msg() method with Telegram disabled
""" """
telegram_mock = mocker.patch('freqtrade.rpc.telegram.Telegram.send_msg', MagicMock()) telegram_mock = mocker.patch('freqtrade.clients.rpc.telegram.Telegram.send_msg', MagicMock())
conf = deepcopy(default_conf) conf = deepcopy(default_conf)
conf['telegram']['enabled'] = False conf['telegram']['enabled'] = False
freqtradebot = get_patched_freqtradebot(mocker, conf) freqtradebot = get_patched_freqtradebot(mocker, conf)
rpc_manager = RPCManager(freqtradebot) client_manager = ClientManager(freqtradebot)
rpc_manager.send_msg('test') client_manager.send_msg('test')
assert log_has('test', caplog.record_tuples) assert log_has('test', caplog.record_tuples)
assert telegram_mock.call_count == 0 assert telegram_mock.call_count == 0
@ -128,12 +128,12 @@ def test_send_msg_telegram_enabled(mocker, default_conf, caplog) -> None:
""" """
Test send_msg() method with Telegram disabled Test send_msg() method with Telegram disabled
""" """
telegram_mock = mocker.patch('freqtrade.rpc.telegram.Telegram.send_msg', MagicMock()) telegram_mock = mocker.patch('freqtrade.clients.rpc.telegram.Telegram.send_msg', MagicMock())
mocker.patch('freqtrade.rpc.telegram.Telegram._init', MagicMock()) mocker.patch('freqtrade.clients.rpc.telegram.Telegram._init', MagicMock())
freqtradebot = get_patched_freqtradebot(mocker, default_conf) freqtradebot = get_patched_freqtradebot(mocker, default_conf)
rpc_manager = RPCManager(freqtradebot) client_manager = ClientManager(freqtradebot)
rpc_manager.send_msg('test') client_manager.send_msg('test')
assert log_has('test', caplog.record_tuples) assert log_has('test', caplog.record_tuples)
assert telegram_mock.call_count == 1 assert telegram_mock.call_count == 1

6
freqtrade/tests/conftest.py
View File

@ -37,11 +37,11 @@ def get_patched_freqtradebot(mocker, config) -> FreqtradeBot:
# mocker.patch('freqtrade.fiat_convert.Market', {'price_usd': 12345.0}) # mocker.patch('freqtrade.fiat_convert.Market', {'price_usd': 12345.0})
patch_coinmarketcap(mocker, {'price_usd': 12345.0}) patch_coinmarketcap(mocker, {'price_usd': 12345.0})
mocker.patch('freqtrade.freqtradebot.Analyze', MagicMock()) mocker.patch('freqtrade.freqtradebot.Analyze', MagicMock())
mocker.patch('freqtrade.freqtradebot.RPCManager', MagicMock()) mocker.patch('freqtrade.freqtradebot.ClientManager', MagicMock())
mocker.patch('freqtrade.freqtradebot.persistence.init', MagicMock()) mocker.patch('freqtrade.freqtradebot.persistence.init', MagicMock())
mocker.patch('freqtrade.freqtradebot.exchange.init', MagicMock()) mocker.patch('freqtrade.freqtradebot.exchange.init', MagicMock())
mocker.patch('freqtrade.freqtradebot.RPCManager._init', MagicMock()) mocker.patch('freqtrade.freqtradebot.ClientManager._init', MagicMock())
mocker.patch('freqtrade.freqtradebot.RPCManager.send_msg', MagicMock()) mocker.patch('freqtrade.freqtradebot.ClientManager.send_msg', MagicMock())
mocker.patch('freqtrade.freqtradebot.Analyze.get_signal', MagicMock()) mocker.patch('freqtrade.freqtradebot.Analyze.get_signal', MagicMock())
return FreqtradeBot(config) return FreqtradeBot(config)

12
freqtrade/tests/test_freqtradebot.py
View File

@ -30,7 +30,7 @@ def get_patched_freqtradebot(mocker, config) -> FreqtradeBot:
:return: None :return: None
""" """
mocker.patch('freqtrade.freqtradebot.Analyze', MagicMock()) mocker.patch('freqtrade.freqtradebot.Analyze', MagicMock())
mocker.patch('freqtrade.freqtradebot.RPCManager', MagicMock()) mocker.patch('freqtrade.freqtradebot.ClientManager', MagicMock())
mocker.patch('freqtrade.freqtradebot.persistence.init', MagicMock()) mocker.patch('freqtrade.freqtradebot.persistence.init', MagicMock())
mocker.patch('freqtrade.freqtradebot.exchange.init', MagicMock()) mocker.patch('freqtrade.freqtradebot.exchange.init', MagicMock())
patch_coinmarketcap(mocker) patch_coinmarketcap(mocker)
@ -53,12 +53,12 @@ def patch_get_signal(mocker, value=(True, False)) -> None:
def patch_RPCManager(mocker) -> MagicMock: def patch_RPCManager(mocker) -> MagicMock:
""" """
This function mock RPC manager to avoid repeating this code in almost every tests This function mock CLIENT manager to avoid repeating this code in almost every tests
:param mocker: mocker to patch RPCManager class :param mocker: mocker to patch ClientManager class
:return: RPCManager.send_msg MagicMock to track if this method is called :return: ClientManager.send_msg MagicMock to track if this method is called
""" """
mocker.patch('freqtrade.freqtradebot.RPCManager._init', MagicMock()) mocker.patch('freqtrade.freqtradebot.ClientManager._init', MagicMock())
rpc_mock = mocker.patch('freqtrade.freqtradebot.RPCManager.send_msg', MagicMock()) rpc_mock = mocker.patch('freqtrade.freqtradebot.ClientManager.send_msg', MagicMock())
return rpc_mock return rpc_mock

6
freqtrade/tests/test_main.py
View File

@ -77,7 +77,7 @@ def test_main_fatal_exception(mocker, default_conf, caplog) -> None:
lambda *args, **kwargs: default_conf lambda *args, **kwargs: default_conf
) )
mocker.patch('freqtrade.freqtradebot.CryptoToFiatConverter', MagicMock()) mocker.patch('freqtrade.freqtradebot.CryptoToFiatConverter', MagicMock())
mocker.patch('freqtrade.freqtradebot.RPCManager', MagicMock()) mocker.patch('freqtrade.freqtradebot.ClientManager', MagicMock())
args = ['-c', 'config.json.example'] args = ['-c', 'config.json.example']
@ -104,7 +104,7 @@ def test_main_keyboard_interrupt(mocker, default_conf, caplog) -> None:
lambda *args, **kwargs: default_conf lambda *args, **kwargs: default_conf
) )
mocker.patch('freqtrade.freqtradebot.CryptoToFiatConverter', MagicMock()) mocker.patch('freqtrade.freqtradebot.CryptoToFiatConverter', MagicMock())
mocker.patch('freqtrade.freqtradebot.RPCManager', MagicMock()) mocker.patch('freqtrade.freqtradebot.ClientManager', MagicMock())
args = ['-c', 'config.json.example'] args = ['-c', 'config.json.example']
@ -131,7 +131,7 @@ def test_main_operational_exception(mocker, default_conf, caplog) -> None:
lambda *args, **kwargs: default_conf lambda *args, **kwargs: default_conf
) )
mocker.patch('freqtrade.freqtradebot.CryptoToFiatConverter', MagicMock()) mocker.patch('freqtrade.freqtradebot.CryptoToFiatConverter', MagicMock())
mocker.patch('freqtrade.freqtradebot.RPCManager', MagicMock()) mocker.patch('freqtrade.freqtradebot.ClientManager', MagicMock())
args = ['-c', 'config.json.example'] args = ['-c', 'config.json.example']