Don't calll _wake if previous state was busy/pause after queueing a tx.

Add tests for _wake.

atxm/machine.py

@@ -427,15 +427,15 @@ def queue_transaction(
         Optionally provide a dictionary of additional string data
         to log during the transaction's lifecycle for identification.
         """
-        previously_busy = self._busy
+        previously_busy_or_paused = self._busy or self._pause
 
         if signer.address not in self.signers:
             self.signers[signer.address] = signer
 
         tx = self._tx_tracker._queue(
             _from=signer.address, params=params, *args, **kwargs
         )
-        if not previously_busy:
+        if not previously_busy_or_paused:
             self._wake()
 
         return tx

tests/conftest.py

@@ -79,7 +79,7 @@ def interval(machine):
     return 1
 
 
-@pytest.fixture(autouse=True)
+@pytest.fixture
 def mock_wake_sleep(machine, mocker):
     wake = mocker.patch.object(machine, "_wake")
     sleep = mocker.patch.object(machine, "_sleep")

tests/test_api.py

@@ -4,7 +4,15 @@
 
 
 @pytest_twisted.inlineCallbacks
-def test_machine(account, w3, legacy_transaction, eip1559_transaction, machine, clock):
+def test_machine(
+    account,
+    w3,
+    legacy_transaction,
+    eip1559_transaction,
+    machine,
+    clock,
+    mock_wake_sleep,
+):
     assert not machine.busy
     async_txs = machine.queue_transactions(
         params=[legacy_transaction, eip1559_transaction],

tests/test_machine.py

@@ -44,7 +44,7 @@ def test_queue(
     eip1559_transaction,
     mock_wake_sleep,
 ):
-    wake, sleep = mock_wake_sleep
+    wake, _ = mock_wake_sleep
 
     # The machine is idle
     assert machine.current_state == machine._IDLE
@@ -76,6 +76,116 @@ def test_queue(
     assert len(state_observer.transitions) == 0  # nothing actually executed
 
 
+def test_wake_after_queuing_when_idle_and_not_already_running(
+    machine,
+    eip1559_transaction,
+    account,
+):
+    assert machine.current_state == machine._IDLE
+    assert not machine.busy
+
+    assert not machine.running
+
+    # Queue a transaction
+    _ = machine.queue_transaction(
+        params=eip1559_transaction,
+        signer=account,
+        info={"message": "something wonderful is happening..."},
+    )
+
+    assert machine.running
+    assert machine.current_state == machine._BUSY
+
+    machine.stop()
+
+
+def test_wake_after_queuing_when_idle_and_already_running(
+    machine,
+    eip1559_transaction,
+    account,
+    mocker,
+):
+    machine.start(now=True)
+
+    stop_spy = mocker.spy(machine._task, "stop")
+
+    assert machine.current_state == machine._IDLE
+    assert not machine.busy
+
+    assert machine.running
+
+    # Queue a transaction
+    _ = machine.queue_transaction(
+        params=eip1559_transaction,
+        signer=account,
+        info={"message": "something wonderful is happening..."},
+    )
+
+    assert stop_spy.call_count == 1  # task stopped and restarted
+
+    assert machine.running
+    assert machine.current_state == machine._BUSY
+
+    machine.stop()
+
+
+def test_wake_no_call_after_queuing_when_already_busy(
+    machine,
+    eip1559_transaction,
+    account,
+    mock_wake_sleep,
+):
+    wake, _ = mock_wake_sleep
+
+    assert machine.current_state == machine._IDLE
+
+    # Queue a transaction
+    _ = machine.queue_transaction(
+        params=eip1559_transaction,
+        signer=account,
+        info={"message": "something wonderful is happening..."},
+    )
+
+    assert wake.call_count == 1
+
+    machine._cycle()
+    assert machine.current_state == machine._BUSY
+
+    # Queue another transaction while busy
+    _ = machine.queue_transaction(
+        params=eip1559_transaction,
+        signer=account,
+        info={"message": "something wonderful is happening..."},
+    )
+
+    assert wake.call_count == 1  # remains unchanged
+
+
+def test_wake_no_call_after_queuing_when_already_paused(
+    machine,
+    eip1559_transaction,
+    account,
+    mock_wake_sleep,
+):
+    wake, _ = mock_wake_sleep
+
+    assert machine.current_state == machine._IDLE
+
+    machine.pause()
+    machine._cycle()
+    assert machine.paused
+    assert machine.current_state == machine._PAUSED
+
+    # Queue a transaction
+    _ = machine.queue_transaction(
+        params=eip1559_transaction,
+        signer=account,
+        info={"message": "something wonderful is happening..."},
+    )
+
+    assert wake.call_count == 0
+
+
 @pytest_twisted.inlineCallbacks
 def test_broadcast(
     clock,
@@ -204,8 +314,6 @@ def test_finalize(
 def test_follow(
     chain, machine, state_observer, clock, eip1559_transaction, account, mock_wake_sleep
 ):
-    wake, sleep = mock_wake_sleep
-
     machine.start()
     assert machine.current_state == machine._IDLE
 
@@ -245,7 +353,9 @@ def test_follow(
     machine.stop()
 
 
-def test_simple_state_transitions(chain, machine, eip1559_transaction, account):
+def test_simple_state_transitions(
+    chain, machine, eip1559_transaction, account, mock_wake_sleep
+):
     assert machine.current_state == machine._IDLE
 
     for i in range(3):