X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2Fbindings%2Frmr-python%2Ftests%2Ftest_rmr.py;h=33b61f75148ecccbc5e326bbc015f0483c3d570a;hb=refs%2Fchanges%2F42%2F2642%2F1;hp=cd0754529512c5a9d653c2df04e40b6f6b686d51;hpb=f1d8288e7a8d73e5d7441269a5d258eb90ed389e;p=ric-plt%2Flib%2Frmr.git diff --git a/src/bindings/rmr-python/tests/test_rmr.py b/src/bindings/rmr-python/tests/test_rmr.py index cd07545..33b61f7 100644 --- a/src/bindings/rmr-python/tests/test_rmr.py +++ b/src/bindings/rmr-python/tests/test_rmr.py @@ -1,7 +1,7 @@ # vim: ts=4 sw=4 expandtab: # =================================================================================2 -# Copyright (c) 2019 Nokia -# Copyright (c) 2018-2019 AT&T Intellectual Property. +# Copyright (c) 2019-2020 Nokia +# Copyright (c) 2018-2020 AT&T Intellectual Property. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. @@ -41,7 +41,7 @@ def setup_module(): 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: + while rmr.rmr_ready(MRC_BUF_RCV) == 0: time.sleep(1) @@ -60,6 +60,7 @@ def _assert_new_sbuf(sbuf): summary = rmr.message_summary(sbuf) assert summary["payload"] == b"" assert summary["payload length"] == 0 + assert summary["subscription id"] == -1 assert summary["transaction id"] == b"" assert summary["message state"] == 0 assert summary["message status"] == "RMR_OK" @@ -109,17 +110,23 @@ def test_meid(): assert rmr.rmr_get_meid(sbuf) == rmr.message_summary(sbuf)["meid"] == b"\x01\x02" assert len(rmr.rmr_get_meid(sbuf)) == 2 - rmr.rmr_set_meid(sbuf, b"\x00" * 32) + rmr.rmr_set_meid(sbuf, b"\x00" * 31) assert rmr.rmr_get_meid(sbuf) == rmr.message_summary(sbuf)["meid"] == b"" # NULL bytes get truncated - rmr.rmr_set_meid(sbuf, b"6" * 32) - assert rmr.rmr_get_meid(sbuf) == rmr.message_summary(sbuf)["meid"] == b"6" * 32 # string in string out + rmr.rmr_set_meid(sbuf, b"6" * 31) + assert rmr.rmr_get_meid(sbuf) == rmr.message_summary(sbuf)["meid"] == b"6" * 31 # string in string out rmr.rmr_set_meid(sbuf, b"\x01\x02") assert ( - rmr.rmr_get_meid(sbuf) == rmr.message_summary(sbuf)["meid"] == b"\x01\x02" + b"6" * 30 - ) # bytes in string out, 6s left over - assert len(rmr.rmr_get_meid(sbuf)) == 32 + rmr.rmr_get_meid(sbuf) == rmr.message_summary(sbuf)["meid"] == b"\x01\x02" + ) # Ctypes will chop at first nil, so expect only 2 bytes back + + assert len(rmr.rmr_get_meid(sbuf)) == 2 + + # test that an exception is raised for buffers which are too long + with pytest.raises(exceptions.MeidSizeOutOfRange): + rmr.rmr_set_meid(sbuf, b"8" * 32) + def test_rmr_set_get(): @@ -152,6 +159,28 @@ def test_rmr_set_get(): assert (len(summary["meid"])) == 4 +def test_alloc_fancy(): + """test allocation with setting payload, trans, mtype, subid""" + pay = b"yoo\x01\x00\x80" + sbuf = rmr.rmr_alloc_msg(MRC_SEND, SIZE, payload=pay, gen_transaction_id=True, mtype=14, meid=b"asdf", sub_id=654321) + summary = rmr.message_summary(sbuf) + assert summary["payload"] == pay + assert summary["payload length"] == 6 + assert summary["transaction id"] != b"" # hard to test what it will be, but make sure not empty + assert len(summary["transaction id"]) == 32 + assert summary["message state"] == 0 + assert summary["message type"] == sbuf.contents.mtype == 14 + assert rmr.rmr_get_meid(sbuf) == summary["meid"] == b"asdf" + assert sbuf.contents.sub_id == summary["subscription id"] == 654321 + + +def test_alloc_overlapping_flags(): + """test allocation with setting the transaction id""" + sbuf = rmr.rmr_alloc_msg(MRC_SEND, SIZE, gen_transaction_id=True, fixed_transaction_id=b"6" * 32) + summary = rmr.message_summary(sbuf) + assert summary["transaction id"] == b"66666666666666666666666666666666" + + def test_rcv_timeout(): """ test torcv; this is a scary test because if it fails... it doesn't fail, it will run forever! @@ -194,8 +223,7 @@ def test_send_rcv(): # send an ACK back ack_pay = b"message received" - rmr.set_payload_and_length(ack_pay, sbuf_rcv) - sbuf_rcv = rmr.rmr_rts_msg(MRC_RCV, sbuf_rcv) + sbuf_rcv = rmr.rmr_rts_msg(MRC_RCV, sbuf_rcv, payload=ack_pay, mtype=6666) rcv_ack_summary = rmr.message_summary(sbuf_rcv) # have the sender receive it @@ -205,6 +233,55 @@ def test_send_rcv(): 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 + assert send_ack_summary["message type"] == 6666 + + +def test_send_rcv_subid_good(): + """ + test send and receive where subid is used for routing + """ + pay = b"\x01\x00\x80" + test_mtype = 46656 + test_subid = 777 + + # send a message + sbuf_send = rmr.rmr_alloc_msg(MRC_SEND, 3, pay, mtype=test_mtype, sub_id=test_subid) + pre_send_summary = rmr.message_summary(sbuf_send) + sbuf_send = rmr.rmr_send_msg(MRC_SEND, sbuf_send) + send_summary = rmr.message_summary(sbuf_send) + + # receive it in other context + time.sleep(0.5) + sbuf_rcv = rmr.rmr_alloc_msg(MRC_RCV, 3) + sbuf_rcv = rmr.rmr_torcv_msg(MRC_RCV, sbuf_rcv, 2000) + rcv_summary = rmr.message_summary(sbuf_rcv) + + # asserts + assert send_summary["message state"] == rcv_summary["message state"] == 0 + assert send_summary["message status"] == rcv_summary["message status"] == "RMR_OK" + assert pre_send_summary["payload"] == rcv_summary["payload"] == pay + assert pre_send_summary["message type"] == rcv_summary["message type"] == test_mtype + assert pre_send_summary["subscription id"] == rcv_summary["subscription id"] == test_subid + + +def test_send_rcv_subid_bad_subid(): + """ + test send and receive where subid is used for routing but nobody recieves this subid + """ + sbuf_send = rmr.rmr_alloc_msg(MRC_SEND, 3, b"\x01\x00\x80", mtype=46656, sub_id=778) + sbuf_send = rmr.rmr_send_msg(MRC_SEND, sbuf_send) + assert rmr.message_summary(sbuf_send)["message state"] == 2 + assert rmr.message_summary(sbuf_send)["message status"] == "RMR_ERR_NOENDPT" + + +def test_send_rcv_subid_bad_mtype(): + """ + test send and receive where subid is used for routing but nobody recieves this mtype + """ + sbuf_send = rmr.rmr_alloc_msg(MRC_SEND, 3, b"\x01\x00\x80", mtype=46657, sub_id=777) + sbuf_send = rmr.rmr_send_msg(MRC_SEND, sbuf_send) + assert rmr.message_summary(sbuf_send)["message state"] == 2 + assert rmr.message_summary(sbuf_send)["message status"] == "RMR_ERR_NOENDPT" def send_burst(mrc, fmt, mtype=1, num=13, counter=0): @@ -247,7 +324,7 @@ def test_rcv_all(): 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)): + for i, ms in enumerate(bundle): ms = bundle[i] # validate each summary returned, and ordering preserved assert ms["message state"] == 0 expected_pay = bytes(pay_fmt % i, "UTF-8") @@ -259,15 +336,17 @@ def test_rcv_all(): 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 + bundle = helpers.rmr_rcvall_msgs_raw(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 + for i, (ms, sbuf) in enumerate(bundle): # test the raw version + test_summary = rmr.message_summary(sbuf) + assert test_summary == ms 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 + rmr.rmr_free_msg(sbuf) def test_bad_buffer(): @@ -276,32 +355,19 @@ def test_bad_buffer(): rmr.rmr_alloc_msg(None, 4096) -def test_alloc_fancy(): - """test allocation with setting payload, trans, mtype""" - pay = b"yoo\x01\x00\x80" - sbuf = rmr.rmr_alloc_msg(MRC_SEND, SIZE, payload=pay, gen_transaction_id=True, mtype=14, meid=b"asdf") - summary = rmr.message_summary(sbuf) - assert summary["payload"] == pay - assert summary["payload length"] == 6 - assert summary["transaction id"] != b"" # hard to test what it will be, but make sure not empty - assert summary["message state"] == 0 - assert summary["message type"] == 14 - assert summary["meid"] == b"asdf" - - def test_resize_payload(): """test the ability to insert a larger payload into an existing message""" mtype = 99 subid = 100 mbuf = rmr.rmr_alloc_msg(MRC_SEND, 25) # allocate buffer with small payload - mbuf.contents.mtype = mtype # type and sub-id should not change + mbuf.contents.mtype = mtype # type and sub-id should not change mbuf.contents.sub_id = subid long_payload = b"This is a long payload that should force the message buffer to be reallocated" rmr.set_payload_and_length(long_payload, mbuf) summary = rmr.message_summary(mbuf) - assert summary["payload max size"] >= len(long_payload) # RMR may allocate a larger payload space - assert summary["payload length"] == len(long_payload) # however, the length must be exactly the same - assert summary["message type"] == mtype # both mtype and sub-id should be preserved in new + assert summary["payload max size"] >= len(long_payload) # RMR may allocate a larger payload space + assert summary["payload length"] == len(long_payload) # however, the length must be exactly the same + assert summary["message type"] == mtype # both mtype and sub-id should be preserved in new assert summary["subscription id"] == subid