def test_send_priorities(self): messages_to_send = [] for i in range(0, 30): messages_to_send.append( create_message(b'LOW', priority=Priority.low)) messages_to_send.append( create_message(b'NORMAL', priority=Priority.normal)) messages_to_send.append( create_message(b'HIGH', priority=Priority.high)) # Send messages with priority in random order shuffle(messages_to_send) self.send_messages(messages_to_send) # Should be received in order self.expected_messages = sorted(messages_to_send, reverse=True, key=lambda message: message.priority) # Give Qpid a bit of time for ordering if needed sleep(3) self.receive_messages() # Don't check identity, because only the priority order is preserved self.check_messages(check_identity=False)
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 test_receive_limit(self): self.send_messages( (create_message(b'FOOBAR1'), create_message(b'FOOBAR2'), create_message(b'FOOBAR3'))) # Should first receive only 2 self.receiver.limit = 2 self.receive_messages() self.check_messages(expected_messages=self.expected_messages[:-1]) # Receive the rest self.receiver.limit = None self.receive_messages() self.check_messages()
def test_addressless_routable(self): message = create_message(b'FOOBAR') message.address = self.sender.address self.sender.address = None self.send_messages((message, )) self.receive_messages() self.check_messages()
def setUp(self): self.properties = {'foo': 'bar'} self.origin_message = create_message(b'foobar', self.properties, Priority.high) self.origin_message.reply_to = 'foobar_address' self.origin_message.correlation_id = uuid4() self.reply_message = create_reply(self.origin_message, b'foobar-reply')
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 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))
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 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_receive(self): self.send_messages( (create_message(b'FOOBAR1'), create_message(b'FOOBAR2'), create_message(b'FOOBAR3'))) self.receive_messages() self.check_messages()
def test_connection_error(self): rpc = RemoteProcedure(lambda m: True, uuid4().hex, server_url='amqp://*****:*****@example') with self.assertRaises(ConnectionError): rpc.call(create_message(b'FOOBAR'))
def test_unroutable(self): with self.assertRaises(UnroutableMessage): create_reply(create_message(b'foobar'), b'foobar')
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 setUp(self): self.properties = {'foo': 'bar'} self.message = create_message(b'foobar', self.properties)
def test_content_type_none_native_dict(self): message = create_message({'foo': 'bar'}) self.assertEqual(message.content_type, symbol('None'))
def test_content_type_none_native_list(self): message = create_message([1, 2, 3]) self.assertEqual(message.content_type, symbol('None'))
def test_addressless_unroutable(self): with self.assertRaises(UnroutableMessage): sender = Sender() message = create_message(b'FOOBAR') sender.queue((message, ))
def test_send_properties(self): message = create_message(b'FOOBAR', {'foo': 'bar', 'baz': 123}) self.send_messages((message, )) self.receive_messages() self.check_messages()