def test_build_protocol_different_delegates(self):
"""Test building AMQClient getting different delegates."""
address = IPv4Address("TCP", "127.0.0.1", 5672)
factory = AMQFactory()
client1 = factory.buildProtocol(address)
client2 = factory.buildProtocol(address)
self.assertIsNot(client2.delegate, client1.delegate)
def setUp(self):
super(NotificationSourceTest, self).setUp()
self.useFixture(CaptureTwistedLogs())
self.logger = Logger()
self.clock = Clock()
self.factory = AMQFactory(clock=self.clock, spec=AMQP0_8_SPEC_PATH)
self.connector = FakeConnector(self.factory, logger=self.logger)
self.source = NotificationSource(self.connector, clock=self.clock)
def test_build_protocol(self):
"""Test building AMQClient instances with default parameters."""
address = IPv4Address("TCP", "127.0.0.1", 5672)
factory = AMQFactory()
client = factory.buildProtocol(address)
self.assertIsInstance(client, AMQClient)
self.assertEqual("/", client.vhost)
self.assertEqual(DEFAULT_SPEC, client.spec.file)
self.assertEqual(0, client.heartbeatInterval)
def setUp(self):
super(NotificationSourceTest, self).setUp()
self.useFixture(CaptureTwistedLogs())
self.logger = Logger()
self.clock = Clock()
self.factory = AMQFactory(clock=self.clock, spec=AMQP0_8_SPEC_PATH)
self.connector = FakeConnector(self.factory, logger=self.logger)
self.source = NotificationSource(self.connector, clock=self.clock)
def test_build_protocol_custom_parameters(self):
"""Test building AMQClient instances with custom parameters."""
address = IPv4Address("TCP", "127.0.0.1", 5672)
spec = "../specs/rabbitmq/amqp0-8.stripped.rabbitmq.xml"
clock = Clock()
factory = AMQFactory(spec=spec, clock=clock)
factory.set_vhost("foo")
factory.set_heartbeat(1)
client = factory.buildProtocol(address)
self.assertEqual("foo", client.vhost)
self.assertEqual(spec, client.spec.file)
self.assertEqual(1, client.heartbeatInterval)
self.assertEqual(1, len(clock.getDelayedCalls()))
def test_connect(self):
"""
The endpoint returns a connected and authenticated client.
"""
factory = AMQFactory(spec=self.spec)
endpoint = AMQEndpoint(reactor,
self.host,
self.port,
username=self.user,
password=self.password,
vhost=self.vhost)
client = yield endpoint.connect(factory)
channel = yield client.channel(1)
yield channel.channel_open()
yield client.close()
def setUp(self):
super(NotificationSourceIntegrationTest, self).setUp()
self.endpoint = AMQEndpoint(reactor,
self.rabbit.config.hostname,
self.rabbit.config.port,
username="******",
password="******",
heartbeat=1)
self.policy = backoffPolicy(initialDelay=0)
self.factory = AMQFactory(spec=AMQP0_8_SPEC_PATH)
self.service = ClientService(self.endpoint,
self.factory,
retryPolicy=self.policy)
self.connector = NotificationConnector(self.service)
self.source = NotificationSource(self.connector)
self.client = yield self.endpoint.connect(self.factory)
self.channel = yield self.client.channel(1)
yield self.channel.channel_open()
yield self.channel.queue_declare(queue="uuid")
self.service.startService()
class NotificationSourceTest(TestCase):
def setUp(self):
super(NotificationSourceTest, self).setUp()
self.useFixture(CaptureTwistedLogs())
self.logger = Logger()
self.clock = Clock()
self.factory = AMQFactory(clock=self.clock, spec=AMQP0_8_SPEC_PATH)
self.connector = FakeConnector(self.factory, logger=self.logger)
self.source = NotificationSource(self.connector, clock=self.clock)
def test_get(self):
"""
A new Notification is fired as soon as available on the queue
matching the given UUID.
"""
deferred = self.source.get("uuid", 1)
channel = self.connector.transport.channel(1)
channel.basic_consume_ok(consumer_tag="uuid1.1")
channel.deliver("foo", consumer_tag='uuid.1', delivery_tag=1)
channel.basic_cancel_ok(consumer_tag="uuid1.1")
self.assertThat(deferred, fires_with_payload("foo"))
def test_get_with_queue_timeout(self):
"""
If the configured timeout expires while waiting for a message, from
the subscribed queued, d Timeout exception is raised.
"""
deferred = self.source.get("uuid", 1)
channel = self.connector.transport.channel(1)
channel.basic_consume_ok(consumer_tag="uuid1.1")
self.clock.advance(self.source.timeout)
channel.basic_cancel_ok(consumer_tag="uuid1.1")
self.assertThat(deferred, fires_with_timeout())
def test_get_with_retry_loop_timeout(self):
"""
The retry loop gets interrupted if hits the configured timeout, and
a Timeout exception is raised.
"""
deferred = self.source.get("uuid", 1)
# Let some time elapse and fail the first try simulating a broker
# shutdown.
channel = self.connector.transport.channel(1)
self.clock.advance(self.source.timeout / 2)
channel.connection_close(reply_code=320)
# Let some more time elapse and fail the second try too (this time
# with a queue timeout).
channel = self.connector.transport.channel(1)
channel.basic_consume_ok(consumer_tag="uuid1.1")
self.clock.advance(self.source.timeout / 2)
channel.basic_cancel_ok(consumer_tag="uuid1.1")
self.assertEqual(2, self.connector.connections)
self.assertThat(deferred, fires_with_timeout())
def test_get_with_retry_after_connection_lost(self):
"""
The retry loop gets interrupted it hits the configured timeout, and
a Timeout exceptionis raised.
"""
deferred = self.source.get("uuid", 1)
# Let some time elapse and fail the first try.
channel = self.connector.transport.channel(1)
self.clock.advance(self.source.timeout / 2)
channel.connection_close(reply_code=320)
# Let some more time elapse and fail the second try too (this time
# with a queue timeout).
channel = self.connector.transport.channel(1)
channel = self.connector.transport.channel(1)
channel.basic_consume_ok(consumer_tag="uuid1.1")
self.clock.advance(self.source.timeout / 2)
channel.basic_cancel_ok(consumer_tag="uuid1.1")
self.assertEqual(2, self.connector.connections)
self.assertThat(deferred, fires_with_timeout())
def test_get_with_heartbeat_check_failure(self):
"""
If the connection gets dropped because of a heartbeat check failure,
we keep trying again.
"""
self.factory.setHeartbeat(1)
deferred = self.source.get("uuid", 1)
self.clock.advance(1)
self.clock.advance(1)
self.clock.advance(1)
channel = self.connector.transport.channel(1)
channel.basic_consume_ok(consumer_tag="uuid1.1")
channel.deliver("foo", consumer_tag='uuid.1', delivery_tag=1)
channel.basic_cancel_ok(consumer_tag="uuid1.1")
self.assertEqual(2, self.connector.connections)
self.assertThat(deferred, fires_with_payload("foo"))
def test_get_with_transport_error(self):
"""
If the connection gets dropped because of a transport failure (e.g.
the TCP socket got closed), we keep retrying.
"""
deferred = self.source.get("uuid", 1)
self.connector.transport.loseConnection()
channel = self.connector.transport.channel(1)
channel.basic_consume_ok(consumer_tag="uuid1.1")
channel.deliver("foo", consumer_tag='uuid.1', delivery_tag=1)
channel.basic_cancel_ok(consumer_tag="uuid1.1")
self.assertEqual(2, self.connector.connections)
self.assertThat(deferred, fires_with_payload("foo"))
def test_get_with_connection_closed_unexpected(self):
"""
If we got a connection-closed message from the broker with an
unexpected error code, we raise an error.
"""
deferred = self.source.get("uuid", 1)
channel = self.connector.transport.channel(1)
channel.connection_close(reply_code=501)
self.assertThat(deferred, fires_with_connection_closed())
def test_get_with_timeout_and_pending_message(self):
"""
If the configured timeout expires, but a message arrives while we
are cancelling the consumer, the notification will be still fired.
"""
deferred = self.source.get("uuid", 1)
channel = self.connector.transport.channel(1)
channel.basic_consume_ok(consumer_tag="uuid1.1")
self.clock.advance(self.source.timeout)
channel.deliver("foo", consumer_tag='uuid.1', delivery_tag=1)
channel.basic_cancel_ok(consumer_tag="uuid1.1")
self.assertThat(deferred, fires_with_payload("foo"))
def test_get_with_queue_closed(self):
"""
If the queue we're consuming from gets closed for whatever reason
(for example the client got disconnected), we try again.
"""
deferred = self.source.get("uuid", 1)
channel = self.connector.transport.channel(1)
channel.basic_consume_ok(consumer_tag="uuid1.1")
# Simulate the broker being stopped
channel.connection_close(reply_code=320, reply_text="shutdown")
channel = self.connector.transport.channel(1)
channel.basic_consume_ok(consumer_tag="uuid1.1")
channel.deliver("foo", consumer_tag='uuid.1', delivery_tag=1)
channel.basic_cancel_ok(consumer_tag="uuid1.1")
self.assertThat(deferred, fires_with_payload("foo"))
def test_get_with_queue_not_found(self):
"""
If we try to consume from a queue that doesn't exist, NotFound is
raised.
"""
deferred = self.source.get("uuid", 1)
channel = self.connector.transport.channel(1)
channel.channel_close(reply_code=404, reply_text="not found")
channel = self.connector.transport.channel(0)
channel.connection_close_ok()
self.assertThat(deferred, fires_with_not_found())
def test_get_with_queue_not_found_unclean_close(self):
"""
If when hitting 404 we fail to shutdown the AMQP connection cleanly
within 5 seconds, the client just forces a close.
"""
client = yield self.connector()
deferred = self.source.get("uuid", 1)
channel = self.connector.transport.channel(1)
channel.channel_close(reply_code=404, reply_text="not found")
self.clock.advance(5)
self.assertThat(deferred, fires_with_not_found())
self.assertTrue(self.successResultOf(client.disconnected.wait()))
def test_get_with_concurrent_consume_calls(self):
"""
Calls to basic_consume get serialized, and in case of a 404 failure
the ones not affected get retried.
"""
deferred1 = self.source.get("uuid1", 1)
deferred2 = self.source.get("uuid2", 1)
# Make the first call fail with 404
channel = self.connector.transport.channel(1)
channel.channel_close(reply_code=404, reply_text="not found")
channel = self.connector.transport.channel(0)
channel.connection_close_ok()
self.assertThat(deferred1, fires_with_not_found())
# The second call will be retried
self.assertEqual(2, self.connector.connections)
channel = self.connector.transport.channel(1)
channel.basic_consume_ok(consumer_tag="uuid2.1")
channel.deliver("foo", consumer_tag='uuid2.1', delivery_tag=1)
channel.basic_cancel_ok(consumer_tag="uuid2.1")
self.assertThat(deferred2, fires_with_payload("foo"))
def test_notification_ack(self):
"""
Calling Notification.ack() acknowledges a notification.
"""
deferred = self.source.get("uuid", 1)
channel = self.connector.transport.channel(1)
channel.basic_consume_ok(consumer_tag="uuid.1")
channel.deliver("foo", consumer_tag='uuid.1', delivery_tag=1)
channel.basic_cancel_ok(consumer_tag="uuid.1")
notification = extract_result(deferred)
self.connector.transport.outgoing.clear()
notification.ack()
[frame] = self.connector.transport.outgoing[1]
self.assertEqual("ack", frame.payload.method.name)
self.assertEqual((1, False), frame.payload.args)
def test_notification_ack_is_serialized(self):
"""
Calls to Notification.ack() are serialized, so they don't get spurious
errors from unrelated channel commands.
"""
deferred = self.source.get("uuid1", 1)
channel = self.connector.transport.channel(1)
channel.basic_consume_ok(consumer_tag="uuid1.1")
channel.deliver("foo", consumer_tag='uuid1.1', delivery_tag=1)
channel.basic_cancel_ok(consumer_tag="uuid1.1")
notification = extract_result(deferred)
# Simulate a concurrent get() call locking the channel during its
# basic-consume.
self.source.get("uuid2", 1)
# Calling Notification.ack() now will not result in any outgoing frame,
# since the call will wait for the basic-consume above to complete.
self.connector.transport.outgoing.clear()
notification.ack()
self.assertEqual({}, self.connector.transport.outgoing)
# As soon as the channel lock is released, the frame is sent.
channel.basic_consume_ok(consumer_tag="uuid2.1")
[frame] = self.connector.transport.outgoing[1]
self.assertEqual("ack", frame.payload.method.name)
self.assertEqual((1, False), frame.payload.args)
def test_notification_reject(self):
"""
Calling Notification.reject() rejects a notification.
"""
deferred = self.source.get("uuid", 1)
channel = self.connector.transport.channel(1)
channel.basic_consume_ok(consumer_tag="uuid.1")
channel.deliver("foo", consumer_tag='uuid.1', delivery_tag=1)
channel.basic_cancel_ok(consumer_tag="uuid.1")
notification = extract_result(deferred)
self.connector.transport.outgoing.clear()
notification.reject()
[frame] = self.connector.transport.outgoing[1]
self.assertEqual("reject", frame.payload.method.name)
self.assertEqual((1, True), frame.payload.args)
def test_notification_bounced(self):
"""
If an error happens while ack'ing a Notification, a Bounced exception
is raised.
"""
deferred = self.source.get("uuid1", 1)
channel = self.connector.transport.channel(1)
channel.basic_consume_ok(consumer_tag="uuid1.1")
channel.deliver("foo", consumer_tag='uuid1.1', delivery_tag=1)
channel.basic_cancel_ok(consumer_tag="uuid1.1")
notification = extract_result(deferred)
# Simulate the broker shutting down.
channel.connection_close(reply_code=320, reply_text="shutdown")
self.assertRaises(Bounced, extract_result, notification.ack())
class NotificationSourceTest(TestCase):
def setUp(self):
super(NotificationSourceTest, self).setUp()
self.useFixture(CaptureTwistedLogs())
self.logger = Logger()
self.clock = Clock()
self.factory = AMQFactory(clock=self.clock, spec=AMQP0_8_SPEC_PATH)
self.connector = FakeConnector(self.factory, logger=self.logger)
self.source = NotificationSource(self.connector, clock=self.clock)
def test_get(self):
"""
A new Notification is fired as soon as available on the queue
matching the given UUID.
"""
deferred = self.source.get("uuid", 1)
channel = self.connector.transport.channel(1)
channel.basic_consume_ok(consumer_tag="uuid1.1")
channel.deliver("foo", consumer_tag='uuid.1', delivery_tag=1)
channel.basic_cancel_ok(consumer_tag="uuid1.1")
self.assertThat(deferred, fires_with_payload("foo"))
def test_get_with_queue_timeout(self):
"""
If the configured timeout expires while waiting for a message, from
the subscribed queued, d Timeout exception is raised.
"""
deferred = self.source.get("uuid", 1)
channel = self.connector.transport.channel(1)
channel.basic_consume_ok(consumer_tag="uuid1.1")
self.clock.advance(self.source.timeout)
channel.basic_cancel_ok(consumer_tag="uuid1.1")
self.assertThat(deferred, fires_with_timeout())
def test_get_with_retry_loop_timeout(self):
"""
The retry loop gets interrupted if hits the configured timeout, and
a Timeout exception is raised.
"""
deferred = self.source.get("uuid", 1)
# Let some time elapse and fail the first try simulating a broker
# shutdown.
channel = self.connector.transport.channel(1)
self.clock.advance(self.source.timeout / 2)
channel.connection_close(reply_code=320)
# Let some more time elapse and fail the second try too (this time
# with a queue timeout).
channel = self.connector.transport.channel(1)
channel.basic_consume_ok(consumer_tag="uuid1.1")
self.clock.advance(self.source.timeout / 2)
channel.basic_cancel_ok(consumer_tag="uuid1.1")
self.assertEqual(2, self.connector.connections)
self.assertThat(deferred, fires_with_timeout())
def test_get_with_retry_after_connection_lost(self):
"""
The retry loop gets interrupted it hits the configured timeout, and
a Timeout exceptionis raised.
"""
deferred = self.source.get("uuid", 1)
# Let some time elapse and fail the first try.
channel = self.connector.transport.channel(1)
self.clock.advance(self.source.timeout / 2)
channel.connection_close(reply_code=320)
# Let some more time elapse and fail the second try too (this time
# with a queue timeout).
channel = self.connector.transport.channel(1)
channel = self.connector.transport.channel(1)
channel.basic_consume_ok(consumer_tag="uuid1.1")
self.clock.advance(self.source.timeout / 2)
channel.basic_cancel_ok(consumer_tag="uuid1.1")
self.assertEqual(2, self.connector.connections)
self.assertThat(deferred, fires_with_timeout())
def test_get_with_heartbeat_check_failure(self):
"""
If the connection gets dropped because of a heartbeat check failure,
we keep trying again.
"""
self.factory.setHeartbeat(1)
deferred = self.source.get("uuid", 1)
self.clock.advance(1)
self.clock.advance(1)
self.clock.advance(1)
channel = self.connector.transport.channel(1)
channel.basic_consume_ok(consumer_tag="uuid1.1")
channel.deliver("foo", consumer_tag='uuid.1', delivery_tag=1)
channel.basic_cancel_ok(consumer_tag="uuid1.1")
self.assertEqual(2, self.connector.connections)
self.assertThat(deferred, fires_with_payload("foo"))
def test_get_with_transport_error(self):
"""
If the connection gets dropped because of a transport failure (e.g.
the TCP socket got closed), we keep retrying.
"""
deferred = self.source.get("uuid", 1)
self.connector.transport.loseConnection()
channel = self.connector.transport.channel(1)
channel.basic_consume_ok(consumer_tag="uuid1.1")
channel.deliver("foo", consumer_tag='uuid.1', delivery_tag=1)
channel.basic_cancel_ok(consumer_tag="uuid1.1")
self.assertEqual(2, self.connector.connections)
self.assertThat(deferred, fires_with_payload("foo"))
def test_get_with_connection_closed_unexpected(self):
"""
If we got a connection-closed message from the broker with an
unexpected error code, we raise an error.
"""
deferred = self.source.get("uuid", 1)
channel = self.connector.transport.channel(1)
channel.connection_close(reply_code=501)
self.assertThat(deferred, fires_with_connection_closed())
def test_get_with_timeout_and_pending_message(self):
"""
If the configured timeout expires, but a message arrives while we
are cancelling the consumer, the notification will be still fired.
"""
deferred = self.source.get("uuid", 1)
channel = self.connector.transport.channel(1)
channel.basic_consume_ok(consumer_tag="uuid1.1")
self.clock.advance(self.source.timeout)
channel.deliver("foo", consumer_tag='uuid.1', delivery_tag=1)
channel.basic_cancel_ok(consumer_tag="uuid1.1")
self.assertThat(deferred, fires_with_payload("foo"))
def test_get_with_queue_closed(self):
"""
If the queue we're consuming from gets closed for whatever reason
(for example the client got disconnected), we try again.
"""
deferred = self.source.get("uuid", 1)
channel = self.connector.transport.channel(1)
channel.basic_consume_ok(consumer_tag="uuid1.1")
# Simulate the broker being stopped
channel.connection_close(reply_code=320, reply_text="shutdown")
channel = self.connector.transport.channel(1)
channel.basic_consume_ok(consumer_tag="uuid1.1")
channel.deliver("foo", consumer_tag='uuid.1', delivery_tag=1)
channel.basic_cancel_ok(consumer_tag="uuid1.1")
self.assertThat(deferred, fires_with_payload("foo"))
def test_get_with_queue_not_found(self):
"""
If we try to consume from a queue that doesn't exist, NotFound is
raised.
"""
deferred = self.source.get("uuid", 1)
channel = self.connector.transport.channel(1)
channel.channel_close(reply_code=404, reply_text="not found")
channel = self.connector.transport.channel(0)
channel.connection_close_ok()
self.assertThat(deferred, fires_with_not_found())
def test_get_with_queue_not_found_unclean_close(self):
"""
If when hitting 404 we fail to shutdown the AMQP connection cleanly
within 5 seconds, the client just forces a close.
"""
client = yield self.connector()
deferred = self.source.get("uuid", 1)
channel = self.connector.transport.channel(1)
channel.channel_close(reply_code=404, reply_text="not found")
self.clock.advance(5)
self.assertThat(deferred, fires_with_not_found())
self.assertTrue(self.successResultOf(client.disconnected.wait()))
def test_get_with_concurrent_consume_calls(self):
"""
Calls to basic_consume get serialized, and in case of a 404 failure
the ones not affected get retried.
"""
deferred1 = self.source.get("uuid1", 1)
deferred2 = self.source.get("uuid2", 1)
# Make the first call fail with 404
channel = self.connector.transport.channel(1)
channel.channel_close(reply_code=404, reply_text="not found")
channel = self.connector.transport.channel(0)
channel.connection_close_ok()
self.assertThat(deferred1, fires_with_not_found())
# The second call will be retried
self.assertEqual(2, self.connector.connections)
channel = self.connector.transport.channel(1)
channel.basic_consume_ok(consumer_tag="uuid2.1")
channel.deliver("foo", consumer_tag='uuid2.1', delivery_tag=1)
channel.basic_cancel_ok(consumer_tag="uuid2.1")
self.assertThat(deferred2, fires_with_payload("foo"))
def test_notification_ack(self):
"""
Calling Notification.ack() acknowledges a notification.
"""
deferred = self.source.get("uuid", 1)
channel = self.connector.transport.channel(1)
channel.basic_consume_ok(consumer_tag="uuid.1")
channel.deliver("foo", consumer_tag='uuid.1', delivery_tag=1)
channel.basic_cancel_ok(consumer_tag="uuid.1")
notification = extract_result(deferred)
self.connector.transport.outgoing.clear()
notification.ack()
[frame] = self.connector.transport.outgoing[1]
self.assertEqual("ack", frame.payload.method.name)
self.assertEqual((1, False), frame.payload.args)
def test_notification_ack_is_serialized(self):
"""
Calls to Notification.ack() are serialized, so they don't get spurious
errors from unrelated channel commands.
"""
deferred = self.source.get("uuid1", 1)
channel = self.connector.transport.channel(1)
channel.basic_consume_ok(consumer_tag="uuid1.1")
channel.deliver("foo", consumer_tag='uuid1.1', delivery_tag=1)
channel.basic_cancel_ok(consumer_tag="uuid1.1")
notification = extract_result(deferred)
# Simulate a concurrent get() call locking the channel during its
# basic-consume.
self.source.get("uuid2", 1)
# Calling Notification.ack() now will not result in any outgoing frame,
# since the call will wait for the basic-consume above to complete.
self.connector.transport.outgoing.clear()
notification.ack()
self.assertEqual({}, self.connector.transport.outgoing)
# As soon as the channel lock is released, the frame is sent.
channel.basic_consume_ok(consumer_tag="uuid2.1")
[frame] = self.connector.transport.outgoing[1]
self.assertEqual("ack", frame.payload.method.name)
self.assertEqual((1, False), frame.payload.args)
def test_notification_reject(self):
"""
Calling Notification.reject() rejects a notification.
"""
deferred = self.source.get("uuid", 1)
channel = self.connector.transport.channel(1)
channel.basic_consume_ok(consumer_tag="uuid.1")
channel.deliver("foo", consumer_tag='uuid.1', delivery_tag=1)
channel.basic_cancel_ok(consumer_tag="uuid.1")
notification = extract_result(deferred)
self.connector.transport.outgoing.clear()
notification.reject()
[frame] = self.connector.transport.outgoing[1]
self.assertEqual("reject", frame.payload.method.name)
self.assertEqual((1, True), frame.payload.args)
def test_notification_bounced(self):
"""
If an error happens while ack'ing a Notification, a Bounced exception
is raised.
"""
deferred = self.source.get("uuid1", 1)
channel = self.connector.transport.channel(1)
channel.basic_consume_ok(consumer_tag="uuid1.1")
channel.deliver("foo", consumer_tag='uuid1.1', delivery_tag=1)
channel.basic_cancel_ok(consumer_tag="uuid1.1")
notification = extract_result(deferred)
# Simulate the broker shutting down.
channel.connection_close(reply_code=320, reply_text="shutdown")
self.assertRaises(Bounced, extract_result, notification.ack())
def setUp(self):
super(NotificationConnectorTest, self).setUp()
self.clock = Clock()
self.factory = AMQFactory(spec=AMQP0_8_SPEC_PATH, clock=self.clock)
self.service = FakeClientService(self.factory)
self.connector = NotificationConnector(self.service, clock=self.clock)
def setUp(self):
super(AMQEndpointTest, self).setUp()
self.reactor = MemoryReactorClock()
self.factory = AMQFactory(clock=Clock())