class TestFailoverReceiver(TestCase):
def setUp(self):
configure(CONFIG)
self.received_messages = []
queue_address = uuid4().hex
create_queue(queue_address, durable=False,
auto_delete=True, priorities=5,
extra_properties={'qpid.auto_delete_timeout': 10})
self.sender = Sender(queue_address)
def handle_received_message(message: Message):
self.received_messages.append(message)
return True
self.receiver = Receiver(handle_received_message, queue_address)
def test_failover_receive(self):
expected_messages = (create_message(b'FOOBAR'),
create_message(b'FOOBAR'),
create_message(b'FOOBAR'))
self.sender.queue(expected_messages)
self.sender.send()
self.receiver.limit = 3
self.receiver.receive(timeout=timedelta(seconds=2))
for received, expected in zip(self.received_messages,
expected_messages):
self.assertEqual(received.id, expected.id)
self.assertEqual(received.body, expected.body)
def setUp(self):
configure(CONFIG)
self.received_messages = []
queue_address = uuid4().hex
create_queue(queue_address, durable=False,
auto_delete=True, priorities=5,
extra_properties={'qpid.auto_delete_timeout': 10})
self.sender = Sender(queue_address)
def handle_received_message(message: Message):
self.received_messages.append(message)
return True
self.receiver = Receiver(handle_received_message, queue_address)
class MessagingTestBase(TestCase):
def setUp(self):
configure(CONFIG)
self.received_messages = []
self.expected_messages = []
queue_address = uuid4().hex
create_queue(queue_address,
durable=False,
auto_delete=True,
priorities=10,
extra_properties={'qpid.auto_delete_timeout': 10})
self.sender = Sender(queue_address)
def handle_received_message(message: Message):
self.received_messages.append(message)
return True
self.receiver = Receiver(handle_received_message, queue_address)
def send_messages(self, messages: Iterable[Message]):
self.expected_messages.extend(messages)
self.sender.queue(messages)
self.sender.send()
def receive_messages(self):
with suppress(TimeoutReached):
self.receiver.receive(timeout=timedelta(seconds=2))
def check_messages(self,
check_identity: bool = True,
expected_messages: Optional[Iterable[Message]] = None):
expected_messages = expected_messages or self.expected_messages
self.assertEqual(len(self.received_messages), len(expected_messages))
for received, expected in zip(self.received_messages,
expected_messages):
self.assertEqual(received.body, expected.body)
if check_identity:
# Check identity 100%
self.assertEqual(received.id, expected.id)
self.assertEqual(received.properties, expected.properties)
def send_messages():
sender = Sender(server_url=SERVER_URL)
messages = []
for num in reversed(range(3)):
message = create_message(f'Test message {num+1}')
message.address = QUEUE_NAME
messages.append(message)
sender.queue(messages)
sender.send()
def message_send(args):
properties = None
if args.properties_file:
try:
properties = json.load(args.properties_file)
except json.JSONDecodeError:
print("Invalid JSON properties file\n")
args.parser.print_help()
exit(EX_DATAERR)
message = create_message(args.message.encode(), properties)
sender = Sender(args.address, args.broker_url)
sender.queue(repeat(message, args.repeat))
sender.send()
def test_multi_receive(self):
expected_messages = [
create_message(b'FOOBAR1'),
create_message(b'FOOBAR2'),
create_message(b'FOOBAR3')
]
self.send_messages(expected_messages[0:-1])
second_queue_address = uuid4().hex
create_queue(second_queue_address,
durable=False,
auto_delete=True,
extra_properties={'qpid.auto_delete_timeout': 10})
self.receiver.add_address(second_queue_address)
second_sender = Sender(second_queue_address)
second_sender.queue(expected_messages[-1:])
second_sender.send()
self.receive_messages()
self.assertEqual(len(self.received_messages), len(expected_messages))
from datetime import timedelta
from threading import Thread
from time import sleep
from proton import Message
from qpid_bow.exc import QMF2Exception, QMF2ObjectExists
from qpid_bow.management.queue import create_queue
from qpid_bow.message import create_message, create_reply
from qpid_bow.receiver import Receiver
from qpid_bow.remote_procedure import RemoteProcedure
from qpid_bow.sender import Sender
SERVER_URL = '127.0.0.1'
QUEUE_NAME = 'examples'
TIMEOUT = timedelta(seconds=5)
REPLY_SENDER = Sender(server_url=SERVER_URL)
def main():
try_create_queue(QUEUE_NAME)
remote_service = RemoveService()
remote_service.start()
message = create_message(f'Test RPC message')
rpc = RemoteProcedure(rpc_callback, QUEUE_NAME, SERVER_URL)
rpc.call(message, TIMEOUT)
sleep(3)
remote_service.receiver.stop()
def test_addressless_unroutable(self):
with self.assertRaises(UnroutableMessage):
sender = Sender()
message = create_message(b'FOOBAR')
sender.queue((message, ))
def test_connection_error(self):
sender = Sender(uuid4().hex,
server_url='amqp://*****:*****@example')
sender.queue((create_message(b'FOOBAR'), ))
with self.assertRaises(ConnectionError):
sender.send()
def test_reconnect_strategy_backoff_warning(self):
with pytest.warns(UserWarning):
Sender(uuid4().hex, reconnect_strategy=ReconnectStrategy.backoff)