To better align with multiple client protocols, this PR

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

freqtrade/tests/clients/test_client.py

@@ -0,0 +1,589 @@
+# pragma pylint: disable=invalid-sequence-index, invalid-name, too-many-arguments
+
+"""
+Unit test file for rpc/rpc.py
+"""
+
+from datetime import datetime
+from unittest.mock import MagicMock
+
+from freqtrade.freqtradebot import FreqtradeBot
+from freqtrade.persistence import Trade
+from freqtrade.clients.common_client import CLIENT
+from freqtrade.state import State
+from freqtrade.tests.test_freqtradebot import patch_get_signal, patch_coinmarketcap
+
+
+# Functions for recurrent object patching
+def prec_satoshi(a, b) -> float:
+    """
+    :return: True if A and B differs less than one satoshi.
+    """
+    return abs(a - b) < 0.00000001
+
+
+# Unit tests
+def test_server_trade_status(default_conf, ticker, fee, mocker) -> None:
+    """
+    Test server_trade_status() method
+    """
+    patch_get_signal(mocker, (True, False))
+    patch_coinmarketcap(mocker)
+    mocker.patch('freqtrade.clients.client_manager.Telegram', MagicMock())
+    mocker.patch.multiple(
+        'freqtrade.freqtradebot.exchange',
+        validate_pairs=MagicMock(),
+        get_ticker=ticker,
+        get_fee=fee
+    )
+
+    freqtradebot = FreqtradeBot(default_conf)
+    client = CLIENT(freqtradebot)
+
+    freqtradebot.state = State.STOPPED
+    (error, result) = client.server_trade_status()
+    assert error
+    assert 'trader is not running' in result
+
+    freqtradebot.state = State.RUNNING
+    (error, result) = client.server_trade_status()
+    assert error
+    assert 'no active trade' in result
+
+    freqtradebot.create_trade()
+    (error, result) = client.server_trade_status()
+    assert not error
+    trade = result[0]
+
+    result_message = [
+        '*Trade ID:* `1`\n'
+        '*Current Pair:* '
+        '[ETH/BTC](https://bittrex.com/Market/Index?MarketName=BTC-ETH)\n'
+        '*Open Since:* `just now`\n'
+        '*Amount:* `90.99181074`\n'
+        '*Open Rate:* `0.00001099`\n'
+        '*Close Rate:* `None`\n'
+        '*Current Rate:* `0.00001098`\n'
+        '*Close Profit:* `None`\n'
+        '*Current Profit:* `-0.59%`\n'
+        '*Open Order:* `(limit buy rem=0.00000000)`'
+    ]
+    assert result == result_message
+    assert trade.find('[ETH/BTC]') >= 0
+
+
+def test_server_status_table(default_conf, ticker, fee, mocker) -> None:
+    """
+    Test server_status_table() method
+    """
+    patch_get_signal(mocker, (True, False))
+    patch_coinmarketcap(mocker)
+    mocker.patch('freqtrade.clients.client_manager.Telegram', MagicMock())
+    mocker.patch.multiple(
+        'freqtrade.freqtradebot.exchange',
+        validate_pairs=MagicMock(),
+        get_ticker=ticker,
+        get_fee=fee
+    )
+
+    freqtradebot = FreqtradeBot(default_conf)
+    client = CLIENT(freqtradebot)
+
+    freqtradebot.state = State.STOPPED
+    (error, result) = client.server_status_table()
+    assert error
+    assert '*Status:* `trader is not running`' in result
+
+    freqtradebot.state = State.RUNNING
+    (error, result) = client.server_status_table()
+    assert error
+    assert '*Status:* `no active order`' in result
+
+    freqtradebot.create_trade()
+    (error, result) = client.server_status_table()
+    assert 'just now' in result['Since'].all()
+    assert 'ETH/BTC' in result['Pair'].all()
+    assert '-0.59%' in result['Profit'].all()
+
+
+def test_server_daily_profit(default_conf, update, ticker, fee,
+                          limit_buy_order, limit_sell_order, mocker) -> None:
+    """
+    Test server_daily_profit() method
+    """
+    patch_get_signal(mocker, (True, False))
+    patch_coinmarketcap(mocker, value={'price_usd': 15000.0})
+    mocker.patch('freqtrade.clients.client_manager.Telegram', MagicMock())
+    mocker.patch.multiple(
+        'freqtrade.freqtradebot.exchange',
+        validate_pairs=MagicMock(),
+        get_ticker=ticker,
+        get_fee=fee
+    )
+
+    freqtradebot = FreqtradeBot(default_conf)
+    stake_currency = default_conf['stake_currency']
+    fiat_display_currency = default_conf['fiat_display_currency']
+
+    rpc = CLIENT(freqtradebot)
+
+    # Create some test data
+    freqtradebot.create_trade()
+    trade = Trade.query.first()
+    assert trade
+
+    # Simulate buy & sell
+    trade.update(limit_buy_order)
+    trade.update(limit_sell_order)
+    trade.close_date = datetime.utcnow()
+    trade.is_open = False
+
+    # Try valid data
+    update.message.text = '/daily 2'
+    (error, days) = rpc.server_daily_profit(7, stake_currency, fiat_display_currency)
+    assert not error
+    assert len(days) == 7
+    for day in days:
+        # [datetime.date(2018, 1, 11), '0.00000000 BTC', '0.000 USD']
+        assert (day[1] == '0.00000000 BTC' or
+                day[1] == '0.00006217 BTC')
+
+        assert (day[2] == '0.000 USD' or
+                day[2] == '0.933 USD')
+    # ensure first day is current date
+    assert str(days[0][0]) == str(datetime.utcnow().date())
+
+    # Try invalid data
+    (error, days) = rpc.server_daily_profit(0, stake_currency, fiat_display_currency)
+    assert error
+    assert days.find('must be an integer greater than 0') >= 0
+
+
+def test_server_trade_statistics(default_conf, ticker, ticker_sell_up, fee,
+                              limit_buy_order, limit_sell_order, mocker) -> None:
+    """
+    Test server_trade_statistics() method
+    """
+    patch_get_signal(mocker, (True, False))
+    mocker.patch.multiple(
+        'freqtrade.fiat_convert.Market',
+        ticker=MagicMock(return_value={'price_usd': 15000.0}),
+    )
+    mocker.patch('freqtrade.fiat_convert.CryptoToFiatConverter._find_price', return_value=15000.0)
+    mocker.patch('freqtrade.clients.client_manager.Telegram', MagicMock())
+    mocker.patch.multiple(
+        'freqtrade.freqtradebot.exchange',
+        validate_pairs=MagicMock(),
+        get_ticker=ticker,
+        get_fee=fee
+    )
+
+    freqtradebot = FreqtradeBot(default_conf)
+    stake_currency = default_conf['stake_currency']
+    fiat_display_currency = default_conf['fiat_display_currency']
+
+    rpc = CLIENT(freqtradebot)
+
+    (error, stats) = rpc.server_trade_statistics(stake_currency, fiat_display_currency)
+    assert error
+    assert stats.find('no closed trade') >= 0
+
+    # Create some test data
+    freqtradebot.create_trade()
+    trade = Trade.query.first()
+    # Simulate fulfilled LIMIT_BUY order for trade
+    trade.update(limit_buy_order)
+
+    # Update the ticker with a market going up
+    mocker.patch.multiple(
+        'freqtrade.freqtradebot.exchange',
+        validate_pairs=MagicMock(),
+        get_ticker=ticker_sell_up
+    )
+    trade.update(limit_sell_order)
+    trade.close_date = datetime.utcnow()
+    trade.is_open = False
+
+    freqtradebot.create_trade()
+    trade = Trade.query.first()
+    # Simulate fulfilled LIMIT_BUY order for trade
+    trade.update(limit_buy_order)
+
+    # Update the ticker with a market going up
+    mocker.patch.multiple(
+        'freqtrade.freqtradebot.exchange',
+        validate_pairs=MagicMock(),
+        get_ticker=ticker_sell_up
+    )
+    trade.update(limit_sell_order)
+    trade.close_date = datetime.utcnow()
+    trade.is_open = False
+
+    (error, stats) = rpc.server_trade_statistics(stake_currency, fiat_display_currency)
+    assert not error
+    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_fiat'], 0.93255)
+    assert prec_satoshi(stats['profit_all_coin'], 5.632e-05)
+    assert prec_satoshi(stats['profit_all_percent'], 2.81)
+    assert prec_satoshi(stats['profit_all_fiat'], 0.8448)
+    assert stats['trade_count'] == 2
+    assert stats['first_trade_date'] == 'just now'
+    assert stats['latest_trade_date'] == 'just now'
+    assert stats['avg_duration'] == '0:00:00'
+    assert stats['best_pair'] == 'ETH/BTC'
+    assert prec_satoshi(stats['best_rate'], 6.2)
+
+
+# Test that server_trade_statistics can handle trades that lacks
+# trade.open_rate (it is set to None)
+def test_server_trade_statistics_closed(mocker, default_conf, ticker, fee,
+                                     ticker_sell_up, limit_buy_order, limit_sell_order):
+    """
+    Test server_trade_statistics() method
+    """
+    patch_get_signal(mocker, (True, False))
+    mocker.patch.multiple(
+        'freqtrade.fiat_convert.Market',
+        ticker=MagicMock(return_value={'price_usd': 15000.0}),
+    )
+    mocker.patch('freqtrade.fiat_convert.CryptoToFiatConverter._find_price', return_value=15000.0)
+    mocker.patch('freqtrade.clients.client_manager.Telegram', MagicMock())
+    mocker.patch.multiple(
+        'freqtrade.freqtradebot.exchange',
+        validate_pairs=MagicMock(),
+        get_ticker=ticker,
+        get_fee=fee
+    )
+
+    freqtradebot = FreqtradeBot(default_conf)
+    stake_currency = default_conf['stake_currency']
+    fiat_display_currency = default_conf['fiat_display_currency']
+
+    rpc = CLIENT(freqtradebot)
+
+    # Create some test data
+    freqtradebot.create_trade()
+    trade = Trade.query.first()
+    # Simulate fulfilled LIMIT_BUY order for trade
+    trade.update(limit_buy_order)
+    # Update the ticker with a market going up
+    mocker.patch.multiple(
+        'freqtrade.freqtradebot.exchange',
+        validate_pairs=MagicMock(),
+        get_ticker=ticker_sell_up,
+        get_fee=fee
+    )
+    trade.update(limit_sell_order)
+    trade.close_date = datetime.utcnow()
+    trade.is_open = False
+
+    for trade in Trade.query.order_by(Trade.id).all():
+        trade.open_rate = None
+
+    (error, stats) = rpc.server_trade_statistics(stake_currency, fiat_display_currency)
+    assert not error
+    assert prec_satoshi(stats['profit_closed_coin'], 0)
+    assert prec_satoshi(stats['profit_closed_percent'], 0)
+    assert prec_satoshi(stats['profit_closed_fiat'], 0)
+    assert prec_satoshi(stats['profit_all_coin'], 0)
+    assert prec_satoshi(stats['profit_all_percent'], 0)
+    assert prec_satoshi(stats['profit_all_fiat'], 0)
+    assert stats['trade_count'] == 1
+    assert stats['first_trade_date'] == 'just now'
+    assert stats['latest_trade_date'] == 'just now'
+    assert stats['avg_duration'] == '0:00:00'
+    assert stats['best_pair'] == 'ETH/BTC'
+    assert prec_satoshi(stats['best_rate'], 6.2)
+
+
+def test_server_balance_handle(default_conf, mocker):
+    """
+    Test server_balance() method
+    """
+    mock_balance = {
+        'BTC': {
+            'free': 10.0,
+            'total': 12.0,
+            'used': 2.0,
+        },
+        'ETH': {
+            'free': 0.0,
+            'total': 0.0,
+            'used': 0.0,
+        }
+    }
+
+    patch_get_signal(mocker, (True, False))
+    mocker.patch.multiple(
+        'freqtrade.fiat_convert.Market',
+        ticker=MagicMock(return_value={'price_usd': 15000.0}),
+    )
+    mocker.patch('freqtrade.fiat_convert.CryptoToFiatConverter._find_price', return_value=15000.0)
+    mocker.patch('freqtrade.clients.client_manager.Telegram', MagicMock())
+    mocker.patch.multiple(
+        'freqtrade.freqtradebot.exchange',
+        validate_pairs=MagicMock(),
+        get_balances=MagicMock(return_value=mock_balance)
+    )
+
+    freqtradebot = FreqtradeBot(default_conf)
+    rpc = CLIENT(freqtradebot)
+
+    (error, res) = rpc.server_balance(default_conf['fiat_display_currency'])
+    assert not error
+    (trade, x, y, z) = res
+    assert prec_satoshi(x, 12)
+    assert prec_satoshi(z, 180000)
+    assert 'USD' in y
+    assert len(trade) == 1
+    assert 'BTC' in trade[0]['currency']
+    assert prec_satoshi(trade[0]['available'], 10)
+    assert prec_satoshi(trade[0]['balance'], 12)
+    assert prec_satoshi(trade[0]['pending'], 2)
+    assert prec_satoshi(trade[0]['est_btc'], 12)
+
+
+def test_server_start(mocker, default_conf) -> None:
+    """
+    Test server_start() method
+    """
+    patch_get_signal(mocker, (True, False))
+    patch_coinmarketcap(mocker)
+    mocker.patch('freqtrade.clients.client_manager.Telegram', MagicMock())
+    mocker.patch.multiple(
+        'freqtrade.freqtradebot.exchange',
+        validate_pairs=MagicMock(),
+        get_ticker=MagicMock()
+    )
+
+    freqtradebot = FreqtradeBot(default_conf)
+    rpc = CLIENT(freqtradebot)
+    freqtradebot.state = State.STOPPED
+
+    (error, result) = rpc.server_start()
+    assert not error
+    assert '`Starting trader ...`' in result
+    assert freqtradebot.state == State.RUNNING
+
+    (error, result) = rpc.server_start()
+    assert error
+    assert '*Status:* `already running`' in result
+    assert freqtradebot.state == State.RUNNING
+
+
+def test_server_stop(mocker, default_conf) -> None:
+    """
+    Test server_stop() method
+    """
+    patch_get_signal(mocker, (True, False))
+    patch_coinmarketcap(mocker)
+    mocker.patch('freqtrade.clients.client_manager.Telegram', MagicMock())
+    mocker.patch.multiple(
+        'freqtrade.freqtradebot.exchange',
+        validate_pairs=MagicMock(),
+        get_ticker=MagicMock()
+    )
+
+    freqtradebot = FreqtradeBot(default_conf)
+    rpc = CLIENT(freqtradebot)
+    freqtradebot.state = State.RUNNING
+
+    (error, result) = rpc.server_stop()
+    assert not error
+    assert '`Stopping trader ...`' in result
+    assert freqtradebot.state == State.STOPPED
+
+    (error, result) = rpc.server_stop()
+    assert error
+    assert '*Status:* `already stopped`' in result
+    assert freqtradebot.state == State.STOPPED
+
+
+def test_server_forcesell(default_conf, ticker, fee, mocker) -> None:
+    """
+    Test server_forcesell() method
+    """
+    patch_get_signal(mocker, (True, False))
+    patch_coinmarketcap(mocker)
+    mocker.patch('freqtrade.clients.client_manager.Telegram', MagicMock())
+
+    cancel_order_mock = MagicMock()
+    mocker.patch.multiple(
+        'freqtrade.freqtradebot.exchange',
+        validate_pairs=MagicMock(),
+        get_ticker=ticker,
+        cancel_order=cancel_order_mock,
+        get_order=MagicMock(
+            return_value={
+                'status': 'closed',
+                'type': 'limit',
+                'side': 'buy'
+            }
+        ),
+        get_fee=fee,
+    )
+
+    freqtradebot = FreqtradeBot(default_conf)
+    rpc = CLIENT(freqtradebot)
+
+    freqtradebot.state = State.STOPPED
+    (error, res) = rpc.server_forcesell(None)
+    assert error
+    assert res == '`trader is not running`'
+
+    freqtradebot.state = State.RUNNING
+    (error, res) = rpc.server_forcesell(None)
+    assert error
+    assert res == 'Invalid argument.'
+
+    (error, res) = rpc.server_forcesell('all')
+    assert not error
+    assert res == ''
+
+    freqtradebot.create_trade()
+    (error, res) = rpc.server_forcesell('all')
+    assert not error
+    assert res == ''
+
+    (error, res) = rpc.server_forcesell('1')
+    assert not error
+    assert res == ''
+
+    freqtradebot.state = State.STOPPED
+    (error, res) = rpc.server_forcesell(None)
+    assert error
+    assert res == '`trader is not running`'
+
+    (error, res) = rpc.server_forcesell('all')
+    assert error
+    assert res == '`trader is not running`'
+
+    freqtradebot.state = State.RUNNING
+    assert cancel_order_mock.call_count == 0
+    # make an limit-buy open trade
+    trade = Trade.query.filter(Trade.id == '1').first()
+    filled_amount = trade.amount / 2
+    mocker.patch(
+        'freqtrade.freqtradebot.exchange.get_order',
+        return_value={
+            'status': 'open',
+            'type': 'limit',
+            'side': 'buy',
+            'filled': filled_amount
+        }
+    )
+    # check that the trade is called, which is done by ensuring exchange.cancel_order is called
+    # and trade amount is updated
+    (error, res) = rpc.server_forcesell('1')
+    assert not error
+    assert res == ''
+    assert cancel_order_mock.call_count == 1
+    assert trade.amount == filled_amount
+
+    freqtradebot.create_trade()
+    trade = Trade.query.filter(Trade.id == '2').first()
+    amount = trade.amount
+    # make an limit-buy open trade, if there is no 'filled', don't sell it
+    mocker.patch(
+        'freqtrade.freqtradebot.exchange.get_order',
+        return_value={
+            'status': 'open',
+            'type': 'limit',
+            'side': 'buy',
+            'filled': None
+        }
+    )
+    # check that the trade is called, which is done by ensuring exchange.cancel_order is called
+    (error, res) = rpc.server_forcesell('2')
+    assert not error
+    assert res == ''
+    assert cancel_order_mock.call_count == 2
+    assert trade.amount == amount
+
+    freqtradebot.create_trade()
+    # make an limit-sell open trade
+    mocker.patch(
+        'freqtrade.freqtradebot.exchange.get_order',
+        return_value={
+            'status': 'open',
+            'type': 'limit',
+            'side': 'sell'
+        }
+    )
+    (error, res) = rpc.server_forcesell('3')
+    assert not error
+    assert res == ''
+    # status quo, no exchange calls
+    assert cancel_order_mock.call_count == 2
+
+
+def test_performance_handle(default_conf, ticker, limit_buy_order, fee,
+                            limit_sell_order, mocker) -> None:
+    """
+    Test server_performance() method
+    """
+    patch_get_signal(mocker, (True, False))
+    patch_coinmarketcap(mocker)
+    mocker.patch('freqtrade.clients.client_manager.Telegram', MagicMock())
+    mocker.patch.multiple(
+        'freqtrade.freqtradebot.exchange',
+        validate_pairs=MagicMock(),
+        get_balances=MagicMock(return_value=ticker),
+        get_ticker=ticker,
+        get_fee=fee
+    )
+
+    freqtradebot = FreqtradeBot(default_conf)
+    rpc = CLIENT(freqtradebot)
+
+    # Create some test data
+    freqtradebot.create_trade()
+    trade = Trade.query.first()
+    assert trade
+
+    # Simulate fulfilled LIMIT_BUY order for trade
+    trade.update(limit_buy_order)
+
+    # Simulate fulfilled LIMIT_SELL order for trade
+    trade.update(limit_sell_order)
+
+    trade.close_date = datetime.utcnow()
+    trade.is_open = False
+    (error, res) = rpc.server_performance()
+    assert not error
+    assert len(res) == 1
+    assert res[0]['pair'] == 'ETH/BTC'
+    assert res[0]['count'] == 1
+    assert prec_satoshi(res[0]['profit'], 6.2)
+
+
+def test_server_count(mocker, default_conf, ticker, fee) -> None:
+    """
+    Test server_count() method
+    """
+    patch_get_signal(mocker, (True, False))
+    patch_coinmarketcap(mocker)
+    mocker.patch('freqtrade.clients.client_manager.Telegram', MagicMock())
+    mocker.patch.multiple(
+        'freqtrade.freqtradebot.exchange',
+        validate_pairs=MagicMock(),
+        get_balances=MagicMock(return_value=ticker),
+        get_ticker=ticker,
+        get_fee=fee,
+    )
+
+    freqtradebot = FreqtradeBot(default_conf)
+    rpc = CLIENT(freqtradebot)
+
+    (error, trades) = rpc.server_count()
+    nb_trades = len(trades)
+    assert not error
+    assert nb_trades == 0
+
+    # Create some test data
+    freqtradebot.create_trade()
+    (error, trades) = rpc.server_count()
+    nb_trades = len(trades)
+    assert not error
+    assert nb_trades == 1

freqtrade/tests/clients/test_client_manager.py

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