示例#1
0
    def test_stop_consume_raises_warning_with_auto_delete(self):
        transport = AMQPTransport(Mock())
        transport.stop_consume_impl = Mock()
        self.ch.on_channel_open(transport)
        #transport.channel_number = sentinel.channel_number

        self.ch._consumer_tag = sentinel.consumer_tag
        self.ch._recv_name = NameTrio(sentinel.ex, sentinel.queue, sentinel.binding)
        self.ch._fsm.current_state = self.ch.S_ACTIVE
        self.ch._consuming = True

        #self.ch._ensure_transport = MagicMock()
        self.ch._queue_auto_delete = True

        self.ch.stop_consume()

        self.assertTrue(self.ch._transport.stop_consume_impl.called)
        self.assertIn(self.ch._consumer_tag, self.ch._transport.stop_consume_impl.call_args[0])
示例#2
0
    def test_stop_consume_raises_warning_with_auto_delete(self, mocklog):
        transport = AMQPTransport(Mock())
        transport.stop_consume_impl = Mock()
        self.ch.on_channel_open(transport)
        #transport.channel_number = sentinel.channel_number

        self.ch._consumer_tag = sentinel.consumer_tag
        self.ch._recv_name = NameTrio(sentinel.ex, sentinel.queue,
                                      sentinel.binding)
        self.ch._fsm.current_state = self.ch.S_ACTIVE
        self.ch._consuming = True

        #self.ch._ensure_transport = MagicMock()
        self.ch._queue_auto_delete = True

        self.ch.stop_consume()

        self.assertTrue(mocklog.debug.called)
        self.assertIn(sentinel.queue, mocklog.debug.call_args[0])
示例#3
0
class TestAMQPTransportCommonMethods(PyonTestCase):
    def setUp(self):
        self.tp = AMQPTransport(MagicMock())
        self.tp._sync_call = Mock()

    def test_declare_exchange_impl(self):
        self.tp.declare_exchange_impl(sentinel.exchange)

        self.tp._sync_call.assert_called_once_with(
            self.tp._client.exchange_declare,
            'callback',
            exchange=sentinel.exchange,
            type='topic',
            durable=False,
            auto_delete=True,
            arguments={})

    @patch('pyon.net.transport.os', new_callable=MagicMock)
    def test_declare_exchange_impl_queue_blame(self, osmock):
        osmock.environ.get.return_value = True
        osmock.environ.__getitem__.return_value = sentinel.testid

        self.tp.declare_exchange_impl(sentinel.exchange)

        self.tp._sync_call.assert_called_once_with(
            self.tp._client.exchange_declare,
            'callback',
            exchange=sentinel.exchange,
            type='topic',
            durable=False,
            auto_delete=True,
            arguments={'created-by': sentinel.testid})

    def test_delete_exchange_impl(self):
        self.tp.delete_exchange_impl(sentinel.exchange)
        self.tp._sync_call.assert_called_once_with(
            self.tp._client.exchange_delete,
            'callback',
            exchange=sentinel.exchange)

    def test_declare_queue_impl(self):
        retqueue = self.tp.declare_queue_impl(sentinel.queue)

        self.tp._sync_call.assert_called_once_with(
            self.tp._client.queue_declare,
            'callback',
            queue=sentinel.queue,
            auto_delete=True,
            durable=False,
            arguments={})

        self.assertEquals(retqueue,
                          self.tp._sync_call.return_value.method.queue)

    @patch('pyon.net.transport.os', new_callable=MagicMock)
    def test_declare_queue_impl_queue_blame(self, osmock):
        osmock.environ.get.return_value = True
        osmock.environ.__getitem__.return_value = sentinel.testid

        retqueue = self.tp.declare_queue_impl(sentinel.queue)

        self.tp._sync_call.assert_called_once_with(
            self.tp._client.queue_declare,
            'callback',
            queue=sentinel.queue,
            durable=False,
            auto_delete=True,
            arguments={'created-by': sentinel.testid})

        self.assertEquals(retqueue,
                          self.tp._sync_call.return_value.method.queue)

    def test_delete_queue(self):
        self.tp.delete_queue_impl(sentinel.queue)

        self.tp._sync_call.assert_called_once_with(
            self.tp._client.queue_delete, 'callback', queue=sentinel.queue)

    def test_bind_impl(self):
        self.tp.bind_impl(sentinel.exchange, sentinel.queue, sentinel.binding)

        self.tp._sync_call.assert_called_once_with(
            self.tp._client.queue_bind,
            'callback',
            queue=sentinel.queue,
            exchange=sentinel.exchange,
            routing_key=sentinel.binding)

    def test_unbind_impl(self):
        self.tp.unbind_impl(sentinel.exchange, sentinel.queue,
                            sentinel.binding)

        self.tp._sync_call.assert_called_once_with(
            self.tp._client.queue_unbind,
            'callback',
            queue=sentinel.queue,
            exchange=sentinel.exchange,
            routing_key=sentinel.binding)

    def test_ack_impl(self):
        self.tp.ack_impl(sentinel.dtag)

        self.tp._client.basic_ack.assert_called_once_with(sentinel.dtag)

    def test_reject_impl(self):
        self.tp.reject_impl(sentinel.dtag)

        self.tp._client.basic_reject.assert_called_once_with(sentinel.dtag,
                                                             requeue=False)

    def test_start_consume_impl(self):
        rettag = self.tp.start_consume_impl(sentinel.callback, sentinel.queue)

        self.tp._client.basic_consume.assert_called_once_with(
            sentinel.callback,
            queue=sentinel.queue,
            no_ack=False,
            exclusive=False)

        self.assertEquals(rettag, self.tp._client.basic_consume.return_value)

    def test_stop_consume_impl(self):
        self.tp.stop_consume_impl(sentinel.ctag)

        self.tp._sync_call.assert_called_once_with(
            self.tp._client.basic_cancel, 'callback', sentinel.ctag)

    @patch('pyon.net.transport.sleep', Mock()
           )  # patch to make sleep() be a mock call and therefore superfast
    def test_stop_consume_remains_in_consumers(self):
        self.tp._client._consumers = [sentinel.ctag]
        self.assertRaises(TransportError, self.tp.stop_consume_impl,
                          sentinel.ctag)

    @patch('pyon.net.transport.sleep')
    def test_stop_consume_eventually_removed(self, sleepmock):
        self.tp._client._consumers.__contains__.side_effect = [
            True, False, False
        ]  # is checked once more at exit of method

        self.tp.stop_consume_impl(sentinel.ctag)
        sleepmock.assert_called_once_with(1)

    def test_setup_listener(self):
        cb = Mock()
        self.tp.setup_listener(sentinel.binding, cb)

        cb.assert_called_once_with(self.tp, sentinel.binding)

    def test_get_stats_impl(self):
        mo = Mock()
        self.tp._sync_call.return_value = mo
        ret = self.tp.get_stats_impl(sentinel.queue)

        self.tp._sync_call.assert_called_once_with(
            self.tp._client.queue_declare,
            'callback',
            queue=sentinel.queue,
            passive=True)

        self.assertEquals(ret,
                          (mo.method.message_count, mo.method.consumer_count))

    def test_purge_impl(self):
        self.tp.purge_impl(sentinel.queue)

        self.tp._sync_call.assert_called_once_with(self.tp._client.queue_purge,
                                                   'callback',
                                                   queue=sentinel.queue)

    def test_qos_impl(self):
        self.tp.qos_impl()

        self.tp._sync_call.assert_called_once_with(self.tp._client.basic_qos,
                                                   'callback',
                                                   prefetch_size=0,
                                                   prefetch_count=0,
                                                   global_=False)

    @patch('pyon.net.transport.BasicProperties')
    def test_publish_impl(self, bpmock):
        self.tp.publish_impl(sentinel.exchange, sentinel.routing_key,
                             sentinel.body, sentinel.properties)

        self.tp._client.basic_publish.assert_called_once_with(
            exchange=sentinel.exchange,
            routing_key=sentinel.routing_key,
            body=sentinel.body,
            properties=bpmock(headers=sentinel.properties, delivery_mode=None),
            immediate=False,
            mandatory=False)

    @patch('pyon.net.transport.BasicProperties')
    def test_publish_impl_durable(self, bpmock):
        self.tp.publish_impl(sentinel.exchange,
                             sentinel.routing_key,
                             sentinel.body,
                             sentinel.properties,
                             durable_msg=True)

        self.tp._client.basic_publish.assert_called_once_with(
            exchange=sentinel.exchange,
            routing_key=sentinel.routing_key,
            body=sentinel.body,
            properties=bpmock(headers=sentinel.properties, delivery_mode=2),
            immediate=False,
            mandatory=False)
示例#4
0
class TestAMQPTransportCommonMethods(PyonTestCase):

    def setUp(self):
        self.tp = AMQPTransport(MagicMock())
        self.tp._sync_call = Mock()

    def test_declare_exchange_impl(self):
        self.tp.declare_exchange_impl(sentinel.exchange)

        self.tp._sync_call.assert_called_once_with(self.tp._client.exchange_declare,
                                                   'callback',
                                                   exchange=sentinel.exchange,
                                                   type='topic',
                                                   durable=False,
                                                   auto_delete=True,
                                                   arguments={})

    @patch('pyon.net.transport.os', new_callable=MagicMock)
    def test_declare_exchange_impl_queue_blame(self, osmock):
        osmock.environ.get.return_value = True
        osmock.environ.__getitem__.return_value = sentinel.testid

        self.tp.declare_exchange_impl(sentinel.exchange)

        self.tp._sync_call.assert_called_once_with(self.tp._client.exchange_declare,
                                                   'callback',
                                                   exchange=sentinel.exchange,
                                                   type='topic',
                                                   durable=False,
                                                   auto_delete=True,
                                                   arguments={'created-by':sentinel.testid})

    def test_delete_exchange_impl(self):
        self.tp.delete_exchange_impl(sentinel.exchange)
        self.tp._sync_call.assert_called_once_with(self.tp._client.exchange_delete,
                                                   'callback',
                                                   exchange=sentinel.exchange)

    def test_declare_queue_impl(self):
        retqueue = self.tp.declare_queue_impl(sentinel.queue)

        self.tp._sync_call.assert_called_once_with(self.tp._client.queue_declare,
                                                   'callback',
                                                   queue=sentinel.queue,
                                                   auto_delete=True,
                                                   durable=False,
                                                   arguments={})

        self.assertEquals(retqueue, self.tp._sync_call.return_value.method.queue)

    @patch('pyon.net.transport.os', new_callable=MagicMock)
    def test_declare_queue_impl_queue_blame(self, osmock):
        osmock.environ.get.return_value = True
        osmock.environ.__getitem__.return_value = sentinel.testid

        retqueue = self.tp.declare_queue_impl(sentinel.queue)

        self.tp._sync_call.assert_called_once_with(self.tp._client.queue_declare,
                                                   'callback',
                                                   queue=sentinel.queue,
                                                   durable=False,
                                                   auto_delete=True,
                                                   arguments={'created-by':sentinel.testid})

        self.assertEquals(retqueue, self.tp._sync_call.return_value.method.queue)

    def test_delete_queue(self):
        self.tp.delete_queue_impl(sentinel.queue)

        self.tp._sync_call.assert_called_once_with(self.tp._client.queue_delete,
                                                   'callback',
                                                   queue=sentinel.queue)

    def test_bind_impl(self):
        self.tp.bind_impl(sentinel.exchange, sentinel.queue, sentinel.binding)

        self.tp._sync_call.assert_called_once_with(self.tp._client.queue_bind,
                                                   'callback',
                                                   queue=sentinel.queue,
                                                   exchange=sentinel.exchange,
                                                   routing_key=sentinel.binding)

    def test_unbind_impl(self):
        self.tp.unbind_impl(sentinel.exchange, sentinel.queue, sentinel.binding)

        self.tp._sync_call.assert_called_once_with(self.tp._client.queue_unbind,
                                                   'callback',
                                                   queue=sentinel.queue,
                                                   exchange=sentinel.exchange,
                                                   routing_key=sentinel.binding)

    def test_ack_impl(self):
        self.tp.ack_impl(sentinel.dtag)

        self.tp._client.basic_ack.assert_called_once_with(sentinel.dtag)

    def test_reject_impl(self):
        self.tp.reject_impl(sentinel.dtag)

        self.tp._client.basic_reject.assert_called_once_with(sentinel.dtag, requeue=False)

    def test_start_consume_impl(self):
        rettag = self.tp.start_consume_impl(sentinel.callback, sentinel.queue)

        self.tp._client.basic_consume.assert_called_once_with(sentinel.callback,
                                                              queue=sentinel.queue,
                                                              no_ack=False,
                                                              exclusive=False)

        self.assertEquals(rettag, self.tp._client.basic_consume.return_value)

    def test_stop_consume_impl(self):
        self.tp.stop_consume_impl(sentinel.ctag)

        self.tp._sync_call.assert_called_once_with(self.tp._client.basic_cancel,
                                                   'callback',
                                                   sentinel.ctag)

    @patch('pyon.net.transport.sleep', Mock())      # patch to make sleep() be a mock call and therefore superfast
    def test_stop_consume_remains_in_consumers(self):
        self.tp._client._consumers = [sentinel.ctag]
        self.assertRaises(TransportError, self.tp.stop_consume_impl, sentinel.ctag)

    @patch('pyon.net.transport.sleep')
    def test_stop_consume_eventually_removed(self, sleepmock):
        self.tp._client._consumers.__contains__.side_effect = [True, False, False] # is checked once more at exit of method

        self.tp.stop_consume_impl(sentinel.ctag)
        sleepmock.assert_called_once_with(1)

    def test_setup_listener(self):
        cb = Mock()
        self.tp.setup_listener(sentinel.binding, cb)

        cb.assert_called_once_with(self.tp, sentinel.binding)

    def test_get_stats_impl(self):
        mo = Mock()
        self.tp._sync_call.return_value = mo
        ret = self.tp.get_stats_impl(sentinel.queue)

        self.tp._sync_call.assert_called_once_with(self.tp._client.queue_declare,
                                                   'callback',
                                                   queue=sentinel.queue,
                                                   passive=True)

        self.assertEquals(ret, (mo.method.message_count, mo.method.consumer_count))

    def test_purge_impl(self):
        self.tp.purge_impl(sentinel.queue)

        self.tp._sync_call.assert_called_once_with(self.tp._client.queue_purge,
                                                   'callback',
                                                   queue=sentinel.queue)

    def test_qos_impl(self):
        self.tp.qos_impl()

        self.tp._sync_call.assert_called_once_with(self.tp._client.basic_qos,
                                                   'callback',
                                                   prefetch_size=0,
                                                   prefetch_count=0,
                                                   global_=False)

    @patch('pyon.net.transport.BasicProperties')
    def test_publish_impl(self, bpmock):
        self.tp.publish_impl(sentinel.exchange, sentinel.routing_key, sentinel.body, sentinel.properties)

        self.tp._client.basic_publish.assert_called_once_with(exchange=sentinel.exchange,
                                                              routing_key=sentinel.routing_key,
                                                              body=sentinel.body,
                                                              properties=bpmock(headers=sentinel.properties,
                                                                                delivery_mode=None),
                                                              immediate=False,
                                                              mandatory=False)

    @patch('pyon.net.transport.BasicProperties')
    def test_publish_impl_durable(self, bpmock):
        self.tp.publish_impl(sentinel.exchange, sentinel.routing_key, sentinel.body, sentinel.properties, durable_msg=True)

        self.tp._client.basic_publish.assert_called_once_with(exchange=sentinel.exchange,
                                                              routing_key=sentinel.routing_key,
                                                              body=sentinel.body,
                                                              properties=bpmock(headers=sentinel.properties,
                                                                                delivery_mode=2),
                                                              immediate=False,
                                                              mandatory=False)