test(functional): verify "sent" status while recipient offline (#7506)

* test(functional): verify "sent" status while recipient offline

Add envelope.sent / outgoingStatus="sent" coverage to
TestDeliveryConfirmation, with the recipient offline for the whole
exchange so MVDS can never ACK. The message can then only ever reach
"sent" (envelope published to a peer), never "delivered", isolating the
envelope-sent path from MVDS delivery.

Register the envelope.sent SignalType and use the store REST API (#7473)
to confirm the envelope actually reached the store node.

Replaces test_delivery_confirmation_after_recipient_offline, whose
DELIVERED assertion duplicated test_delivery_confirmation_online (it only
reached DELIVERED by bringing the recipient back online).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* test(functional): confirm store persistence with a single REST read

envelope.sent already guarantees the envelope reached a peer, so the
message is persisted at the store node by then — a single get_messages
read suffices instead of polling.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: igor-sirotin

tests-functional/clients/signals.py

@@ -17,6 +17,7 @@
 class SignalType(Enum):
     MESSAGES_NEW = "messages.new"
     MESSAGE_DELIVERED = "message.delivered"
+    ENVELOPE_SENT = "envelope.sent"
     NODE_READY = "node.ready"
     NODE_STARTED = "node.started"
     NODE_LOGIN = "node.login"

tests-functional/tests/test_transport_delivery_confirmation.py

@@ -1,9 +1,10 @@
 import logging
-from time import sleep
+import time
 from uuid import uuid4
 
 import pytest
 
+from clients.logos_delivery import LogosDeliveryClient
 from clients.signals import SignalType
 from steps import messenger
 
@@ -13,13 +14,24 @@
 @pytest.mark.rpc
 @pytest.mark.wakuext
 class TestDeliveryConfirmation:
-    """Regression coverage for delivery confirmation (issue #7472).
-
-    A 1:1 message must progress to outgoing status ``delivered`` and the
-    sender must receive a ``message.delivered`` signal, both when the
-    recipient is online and when it comes online after a period offline.
+    """Regression coverage for outgoing message status (issue #7472).
+
+    Two distinct outgoing states are exercised:
+
+    * ``delivered`` — driven by an MVDS delivery ACK from the recipient. Verified
+      with the recipient online (``test_delivery_confirmation_online``).
+    * ``sent`` — driven by ``envelope.sent`` (the envelope reaching at least one
+      peer, i.e. the store node), independent of MVDS. Verified with the
+      recipient offline (``test_sent_status_while_recipient_offline``), so MVDS
+      cannot ACK and the only way the status can advance is the envelope-sent
+      path. This is the path that ``EnvelopesMonitor`` currently drives and that
+      the logos-delivery Messaging API will own once integrated.
     """
 
+    @pytest.fixture()
+    def logos_delivery(self):
+        return LogosDeliveryClient()
+
     @pytest.fixture()
     def sender(self, backend_new_profile):
         return backend_new_profile("sender")
@@ -28,10 +40,10 @@ def sender(self, backend_new_profile):
     def receiver(self, backend_new_profile):
         return backend_new_profile("receiver")
 
-    def _assert_outgoing_status(self, node, message_id, expected_status="delivered"):
-        # The status field is written just before the message.delivered signal
-        # fires (same loop in markDeliveredMessages), so once we've seen the
-        # signal a single read is enough — no polling needed.
+    def _assert_outgoing_status(self, node, message_id, expected_status):
+        # The status field is written just before the corresponding signal fires
+        # (same loop in markDeliveredMessages / processSentMessage), so once we've
+        # seen the signal a single read is enough — no polling needed.
         message = node.wakuext_service.message_by_message_id(message_id)
         actual_status = message.get("outgoingStatus", "")
         assert actual_status == expected_status, f"Message {message_id} outgoing status was '{actual_status}', expected '{expected_status}'"
@@ -51,25 +63,38 @@ def test_delivery_confirmation_online(self, sender, receiver):
 
         self._assert_outgoing_status(sender, message_id, "delivered")
 
-    def test_delivery_confirmation_after_recipient_offline(self, sender, receiver):
+    def test_sent_status_while_recipient_offline(self, sender, receiver, logos_delivery):
         messenger.make_contacts(sender, receiver)
 
-        message_text = f"delivery_offline_{uuid4()}"
+        message_text = f"sent_offline_{uuid4()}"
 
-        # The recipient is offline when the message is sent; confirmation must
-        # still arrive once it reconnects and the message is delivered.
+        # Mark the start of the offline window for the store query (Unix ns, with
+        # a small buffer for host/container clock skew).
+        offline_start_ns = time.time_ns() - 5_000_000_000
+
+        # The recipient stays offline for the whole exchange, so MVDS datasync can
+        # never ACK the message. The message can therefore only ever reach "sent"
+        # (envelope published to a peer), never "delivered" — which isolates the
+        # envelope.sent path from MVDS delivery. All assertions stay inside the
+        # pause block so the recipient can't come back and ACK mid-test.
         with messenger.node_pause(receiver):
             response = sender.wakuext_service.send_one_to_one_message(receiver.public_key, message_text)
             message_id = response.get("messages", [])[0].get("id", "")
             assert message_id, "Sender did not get a message id back"
-            sleep(30)
-
-        receiver.wait_for_online(timeout=60)
 
-        with receiver.expect_signal(SignalType.MESSAGES_NEW, pattern=message_id, timeout=120, start="beginning"):
-            pass
-
-        with sender.expect_signal(SignalType.MESSAGE_DELIVERED, pattern=message_id, timeout=120, start="beginning"):
-            pass
-
-        self._assert_outgoing_status(sender, message_id, "delivered")
+            # `message_id` is only known after the send, so wait post-hoc and scan
+            # from the beginning to avoid matching envelope.sent signals from
+            # make_contacts.
+            with sender.expect_signal(SignalType.ENVELOPE_SENT, pattern=message_id, timeout=120, start="beginning"):
+                pass
+
+            # Exact match: "sent" (not "delivered") proves the status came from the
+            # envelope-sent path and not from an MVDS ACK.
+            self._assert_outgoing_status(sender, message_id, "sent")
+
+            # envelope.sent means the envelope already reached a peer, so it is
+            # already persisted at the store node: a single REST read confirms it
+            # was published to the network (not just marked locally), with MVDS
+            # provably out of the picture (recipient offline). No polling needed.
+            stored = logos_delivery.get_messages(start_time=offline_start_ns)
+            assert stored, "Store node holds no messages for the offline window; envelope was not published"