Correct summary bug in python wrapper

[ric-plt/lib/rmr.git] / src / bindings / rmr-python / tests / test_rmr.py

diff --git a/src/bindings/rmr-python/tests/test_rmr.py b/src/bindings/rmr-python/tests/test_rmr.py
index dfc1364..172cc67 100644 (file)
--- a/src/bindings/rmr-python/tests/test_rmr.py
+++ b/src/bindings/rmr-python/tests/test_rmr.py
@@ -17,7 +17,7 @@
 # ==================================================================================
 import time
 import pytest
-from rmr import rmr
+from rmr import rmr, helpers
 
 
 SIZE = 256
@@ -39,6 +39,10 @@ def setup_module():
     while rmr.rmr_ready(MRC_RCV) == 0:
         time.sleep(1)
 
+    global MRC_BUF_RCV
+    MRC_BUF_RCV = rmr.rmr_init(b"4564", rmr.RMR_MAX_RCV_BYTES, 0x02)
+    while rmr.rmr_ready(MRC_RCV) == 0:
+        time.sleep(1)
 
 def teardown_module():
     """
@@ -174,15 +178,18 @@ def test_send_rcv():
     sbuf_send.contents.mtype = 0
     sbuf_send = rmr.rmr_send_msg(MRC_SEND, sbuf_send)
     send_summary = rmr.message_summary(sbuf_send)
+    assert send_summary["message state"] == 0           # if send fails don't attempt receive
+    assert send_summary["message status"] == "RMR_OK"
+    time.sleep(.5)
 
     # receive it in other context
     sbuf_rcv = rmr.rmr_alloc_msg(MRC_RCV, SIZE)
     sbuf_rcv = rmr.rmr_torcv_msg(MRC_RCV, sbuf_rcv, 2000)
     rcv_summary = rmr.message_summary(sbuf_rcv)
-    assert rcv_summary["payload"] == pay
+    assert rcv_summary["message state"] == 0
+    assert rcv_summary["message status"] == "RMR_OK"
     assert rcv_summary["message type"] == 0
-    assert send_summary["message state"] == rcv_summary["message state"] == 0
-    assert send_summary["message status"] == rcv_summary["message status"] == "RMR_OK"
+    assert rcv_summary["payload"] == pay
 
     # send an ACK back
     ack_pay = b"message received"
@@ -194,6 +201,69 @@ def test_send_rcv():
     sbuf_send = rmr.rmr_torcv_msg(MRC_SEND, sbuf_send, 2000)
     send_ack_summary = rmr.message_summary(sbuf_send)
 
-    assert send_ack_summary["payload"] == ack_pay
     assert send_ack_summary["message state"] == rcv_ack_summary["message state"] == 0
     assert send_ack_summary["message status"] == rcv_ack_summary["message status"] == "RMR_OK"
+    assert send_ack_summary["payload"] == ack_pay
+
+
+def send_burst(mrc, fmt, mtype=1, num=13, counter=0):
+    """
+        Internal function to support test_rcv_all.
+        Send a burst of messages optionally giving the type, payload
+        and number to send.
+    """
+    sbuf_send = rmr.rmr_alloc_msg(MRC_SEND, SIZE)               # seed message buffer
+
+    for i in range(num):
+        payload = bytes(fmt % counter, "UTF-8")
+        counter += 1
+
+        rmr.set_payload_and_length(payload, sbuf_send)
+        sbuf_send.contents.mtype = mtype
+
+        max_retries = 5
+        while max_retries > 0:
+            sbuf_send = rmr.rmr_send_msg(mrc, sbuf_send)
+            ms = rmr.message_summary(sbuf_send)
+            if ms["message state"] != 10:                       # 10 is retry
+                break
+            max_retries -= 1
+            time.sleep(.75)
+
+        assert ms["message state"] == 0
+        assert max_retries > 0
+
+
+def test_rcv_all():
+    """
+    test the ability to receive a batch of queued messages. 
+    """
+    pay_fmt = "send to ring msg: %d"                # dynamic message format with counter
+
+    send_burst(MRC_SEND, pay_fmt)                   # send a bunch of 13 messages that should queue
+    time.sleep(1)                                        # ensure underlying transport gets cycles to send/receive
+
+    bundle = helpers.rmr_rcvall_msgs(MRC_BUF_RCV)        # use the buffered receiver to read all with a single call
+    assert len(bundle) == 13
+
+    for i in range(len(bundle)):
+        ms = bundle[i]                              # validate each summary returned, and ordering preserved
+        assert ms["message state"] == 0
+        expected_pay = bytes(pay_fmt % i, "UTF-8")
+        assert ms["payload"] == expected_pay
+
+    send_burst(MRC_SEND, pay_fmt, mtype=1, num=10)           # send a second round with msg types 1 and 2 to test filter
+    send_burst(MRC_SEND, pay_fmt, mtype=2, num=8)
+    send_burst(MRC_SEND, pay_fmt, mtype=1, num=5)
+    send_burst(MRC_SEND, pay_fmt, mtype=2, num=4, counter=8)    # total of 12 messages with type 2 should be queued
+    time.sleep(1)                                                    # ensure underlying transport gets cycles to send/receive
+
+    bundle = helpers.rmr_rcvall_msgs(MRC_BUF_RCV, [2])   # receive only message type 2 messages
+    assert len(bundle) == 12                        # we should only get the second batch of 12 messages
+
+    for i in range(len(bundle)):
+        ms = bundle[i]                              # validate each summary
+        assert ms["message state"] == 0             # all should be OK
+        assert ms["message type"] == 2              # only mtype 2 should have been received
+        expected_pay = bytes(pay_fmt % i, "UTF-8")           # ordering should still jive with the counter
+        assert ms["payload"] == expected_pay