Adjust tests

tests/test_freqtradebot.py

@@ -782,7 +782,7 @@ def test_process_exchange_failures(default_conf, ticker, mocker) -> None:
     worker = Worker(args=None, config=default_conf)
     patch_get_signal(worker.freqtrade)
 
-    worker._process()
+    worker._process_running()
     assert sleep_mock.has_calls()
 
 
@@ -799,7 +799,7 @@ def test_process_operational_exception(default_conf, ticker, mocker) -> None:
 
     assert worker.freqtrade.state == State.RUNNING
 
-    worker._process()
+    worker._process_running()
     assert worker.freqtrade.state == State.STOPPED
     assert 'OperationalException' in msg_mock.call_args_list[-1][0][0]['status']
 
@@ -3665,30 +3665,6 @@ def test_startup_trade_reinit(default_conf, edge_conf, mocker):
     assert reinit_mock.call_count == 0
 
 
-def test_process_i_am_alive(default_conf, mocker, caplog):
-    patch_RPCManager(mocker)
-    patch_exchange(mocker)
-    mocker.patch('freqtrade.exchange.Exchange.exchange_has', MagicMock(return_value=True))
-
-    ftbot = get_patched_freqtradebot(mocker, default_conf)
-    message = r"Bot heartbeat\. PID=.*"
-    ftbot.process()
-    assert log_has_re(message, caplog)
-    assert ftbot._heartbeat_msg != 0
-
-    caplog.clear()
-    # Message is not shown before interval is up
-    ftbot.process()
-    assert not log_has_re(message, caplog)
-
-    caplog.clear()
-    # Set clock - 70 seconds
-    ftbot._heartbeat_msg -= 70
-
-    ftbot.process()
-    assert log_has_re(message, caplog)
-
-
 @pytest.mark.usefixtures("init_persistence")
 def test_sync_wallet_dry_run(mocker, default_conf, ticker, fee, limit_buy_order, caplog):
     default_conf['dry_run'] = True

tests/test_worker.py

@@ -5,7 +5,7 @@
 from freqtrade.data.dataprovider import DataProvider
 from freqtrade.state import State
 from freqtrade.worker import Worker
-from tests.conftest import get_patched_worker, log_has
+from tests.conftest import get_patched_worker, log_has, log_has_re
 
 
 def test_worker_state(mocker, default_conf, markets) -> None:
@@ -38,15 +38,13 @@ def test_worker_running(mocker, default_conf, caplog) -> None:
 def test_worker_stopped(mocker, default_conf, caplog) -> None:
     mock_throttle = MagicMock()
     mocker.patch('freqtrade.worker.Worker._throttle', mock_throttle)
-    mock_sleep = mocker.patch('time.sleep', return_value=None)
 
     worker = get_patched_worker(mocker, default_conf)
     worker.freqtrade.state = State.STOPPED
     state = worker._worker(old_state=State.RUNNING)
     assert state is State.STOPPED
     assert log_has('Changing state to: STOPPED', caplog)
-    assert mock_throttle.call_count == 0
-    assert mock_sleep.call_count == 1
+    assert mock_throttle.call_count == 1
 
 
 def test_throttle(mocker, default_conf, caplog) -> None:
@@ -57,14 +55,14 @@ def throttled_func():
     worker = get_patched_worker(mocker, default_conf)
 
     start = time.time()
-    result = worker._throttle(throttled_func, min_secs=0.1)
+    result = worker._throttle(throttled_func, throttle_secs=0.1)
     end = time.time()
 
     assert result == 42
     assert end - start > 0.1
-    assert log_has('Throttling throttled_func for 0.10 seconds', caplog)
+    assert log_has_re(r"Throttling with 'throttled_func\(\)': sleep for 0\.10 s.*", caplog)
 
-    result = worker._throttle(throttled_func, min_secs=-1)
+    result = worker._throttle(throttled_func, throttle_secs=-1)
     assert result == 42
 
 
@@ -74,8 +72,54 @@ def throttled_func(nb_assets=-1):
 
     worker = get_patched_worker(mocker, default_conf)
 
-    result = worker._throttle(throttled_func, min_secs=0.1, nb_assets=666)
+    result = worker._throttle(throttled_func, throttle_secs=0.1, nb_assets=666)
     assert result == 666
 
-    result = worker._throttle(throttled_func, min_secs=0.1)
+    result = worker._throttle(throttled_func, throttle_secs=0.1)
     assert result == -1
+
+
+def test_worker_heartbeat_running(default_conf, mocker, caplog):
+    message = r"Bot heartbeat\. PID=.*state='RUNNING'"
+
+    mock_throttle = MagicMock()
+    mocker.patch('freqtrade.worker.Worker._throttle', mock_throttle)
+    worker = get_patched_worker(mocker, default_conf)
+
+    worker.freqtrade.state = State.RUNNING
+    worker._worker(old_state=State.STOPPED)
+    assert log_has_re(message, caplog)
+
+    caplog.clear()
+    # Message is not shown before interval is up
+    worker._worker(old_state=State.RUNNING)
+    assert not log_has_re(message, caplog)
+
+    caplog.clear()
+    # Set clock - 70 seconds
+    worker._heartbeat_msg -= 70
+    worker._worker(old_state=State.RUNNING)
+    assert log_has_re(message, caplog)
+
+
+def test_worker_heartbeat_stopped(default_conf, mocker, caplog):
+    message = r"Bot heartbeat\. PID=.*state='STOPPED'"
+
+    mock_throttle = MagicMock()
+    mocker.patch('freqtrade.worker.Worker._throttle', mock_throttle)
+    worker = get_patched_worker(mocker, default_conf)
+
+    worker.freqtrade.state = State.STOPPED
+    worker._worker(old_state=State.RUNNING)
+    assert log_has_re(message, caplog)
+
+    caplog.clear()
+    # Message is not shown before interval is up
+    worker._worker(old_state=State.STOPPED)
+    assert not log_has_re(message, caplog)
+
+    caplog.clear()
+    # Set clock - 70 seconds
+    worker._heartbeat_msg -= 70
+    worker._worker(old_state=State.STOPPED)
+    assert log_has_re(message, caplog)