Python Channel.set_state方法代码示例

# 需要导入模块: from amqpstorm import Channel [as 别名]
# 或者: from amqpstorm.Channel import set_state [as 别名]
 def test_build_empty_inbound_messages(self):
     channel = Channel(0, FakeConnection(), 360)
     channel.set_state(Channel.OPEN)
     result = None
     for message in channel.build_inbound_messages(break_on_empty=True):
         result = message
     self.assertIsNone(result)

# 需要导入模块: from amqpstorm import Channel [as 别名]
# 或者: from amqpstorm.Channel import set_state [as 别名]
    def test_channel_start_consuming_idle_wait(self):
        self.msg = None
        consumer_tag = 'travis-ci'

        channel = Channel(0, FakeConnection(), 360)
        channel.set_state(channel.OPEN)

        message = self.message.encode('utf-8')
        message_len = len(message)

        def add_inbound():
            deliver = specification.Basic.Deliver(consumer_tag='travis-ci')
            header = ContentHeader(body_size=message_len)
            body = ContentBody(value=message)

            channel._inbound = [deliver, header, body]

        def callback(msg):
            self.msg = msg
            channel.set_state(channel.CLOSED)

        channel.add_consumer_tag(consumer_tag)
        channel._consumer_callbacks[consumer_tag] = callback

        threading.Timer(function=add_inbound, interval=1).start()
        channel.start_consuming()

        self.assertIsNotNone(self.msg, 'No message consumed')
        self.assertIsInstance(self.msg.body, str)
        self.assertEqual(self.msg.body.encode('utf-8'), message)

# 需要导入模块: from amqpstorm import Channel [as 别名]
# 或者: from amqpstorm.Channel import set_state [as 别名]
    def test_exchange_unbind_invalid_parameter(self):
        channel = Channel(0, FakeConnection(), 360)
        channel.set_state(Channel.OPEN)
        exchange = Exchange(channel)

        self.assertRaisesRegexp(
            exception.AMQPInvalidArgument,
            'destination should be a string',
            exchange.unbind, None
        )

        self.assertRaisesRegexp(
            exception.AMQPInvalidArgument,
            'source should be a string',
            exchange.unbind, '', None
        )

        self.assertRaisesRegexp(
            exception.AMQPInvalidArgument,
            'routing_key should be a string',
            exchange.unbind, '', '', None
        )

        self.assertRaisesRegexp(
            exception.AMQPInvalidArgument,
            'arguments should be a dict or None',
            exchange.unbind, '', '', '', []
        )

# 需要导入模块: from amqpstorm import Channel [as 别名]
# 或者: from amqpstorm.Channel import set_state [as 别名]
    def test_basic_get_invalid_parameter(self):
        channel = Channel(0, FakeConnection(), 360)
        channel.set_state(Channel.OPEN)
        basic = Basic(channel)

        self.assertRaisesRegexp(
            exception.AMQPInvalidArgument,
            'queue should be a string',
            basic.get, None
        )

        self.assertRaisesRegexp(
            exception.AMQPInvalidArgument,
            'no_ack should be a boolean',
            basic.get, '', 'travis-ci'
        )

        channel.consumer_tags.append('travis-ci')

        self.assertRaisesRegexp(
            exception.AMQPChannelError,
            "Cannot call 'get' when channel "
            "is set to consume",
            basic.get, '', True, 'travis-ci'
        )

# 需要导入模块: from amqpstorm import Channel [as 别名]
# 或者: from amqpstorm.Channel import set_state [as 别名]
    def test_channel_process_data_events_as_tuple(self):
        self.msg = None

        channel = Channel(0, FakeConnection(), 360)
        channel.set_state(channel.OPEN)

        message = self.message.encode('utf-8')
        message_len = len(message)

        deliver = specification.Basic.Deliver(consumer_tag='travis-ci')
        header = ContentHeader(body_size=message_len)
        body = ContentBody(value=message)

        channel._inbound = [deliver, header, body]

        def callback(body, channel, method, properties):
            self.msg = (body, channel, method, properties)

        channel._consumer_callbacks['travis-ci'] = callback
        channel.process_data_events(to_tuple=True)

        self.assertIsNotNone(self.msg, 'No message consumed')

        body, channel, method, properties = self.msg

        self.assertIsInstance(body, bytes)
        self.assertIsInstance(channel, Channel)
        self.assertIsInstance(method, dict)
        self.assertIsInstance(properties, dict)
        self.assertEqual(body, message)

# 需要导入模块: from amqpstorm import Channel [as 别名]
# 或者: from amqpstorm.Channel import set_state [as 别名]
    def test_channel_raise_with_close_reply_code_500(self):
        connection = FakeConnection()
        channel = Channel(0, connection, 360)

        # Set up Fake Channel.
        channel._inbound = [1, 2, 3]
        channel.set_state(channel.OPEN)
        channel._consumer_tags = [1, 2, 3]

        close_frame = specification.Channel.Close(
            reply_code=500,
            reply_text='travis-ci'
        )
        channel._close_channel(close_frame)

        self.assertEqual(channel._inbound, [])
        self.assertEqual(channel._consumer_tags, [])
        self.assertEqual(channel._state, channel.CLOSED)

        self.assertIsInstance(
            connection.get_last_frame(),
            specification.Channel.CloseOk
        )

        self.assertRaisesRegexp(
            AMQPChannelError,
            'Channel 0 was closed by remote server: travis-ci',
            channel.check_for_errors
        )

# 需要导入模块: from amqpstorm import Channel [as 别名]
# 或者: from amqpstorm.Channel import set_state [as 别名]
    def test_channel_start_consuming_no_consumer_tags(self):
        channel = Channel(0, FakeConnection(), 360)
        channel.set_state(channel.OPEN)

        channel._consumer_callbacks = ['fake']

        self.assertIsNone(channel.start_consuming())

# 需要导入模块: from amqpstorm import Channel [as 别名]
# 或者: from amqpstorm.Channel import set_state [as 别名]
    def test_channel_build_empty_inbound_messages(self):
        channel = Channel(0, FakeConnection(), 360)
        channel.set_state(Channel.OPEN)
        generator = channel.build_inbound_messages(break_on_empty=True)

        if hasattr(generator, 'next'):
            self.assertRaises(StopIteration, generator.next)
        else:
            self.assertRaises(StopIteration, generator.__next__)

# 需要导入模块: from amqpstorm import Channel [as 别名]
# 或者: from amqpstorm.Channel import set_state [as 别名]
    def test_channel_build_inbound_raises(self, _):
        channel = Channel(0, FakeConnection(), 360)
        channel.set_state(Channel.OPEN)

        generator = channel.build_inbound_messages(break_on_empty=False)
        if hasattr(generator, 'next'):
            self.assertRaises(AMQPChannelError, generator.next)
        else:
            self.assertRaises(AMQPChannelError, generator.__next__)

# 需要导入模块: from amqpstorm import Channel [as 别名]
# 或者: from amqpstorm.Channel import set_state [as 别名]
    def test_channel_closed_after_connection_closed(self):
        channel = Channel(0, FakeConnection(FakeConnection.CLOSED), 360)
        channel.set_state(channel.OPEN)

        self.assertTrue(channel.is_open)
        self.assertRaisesRegexp(exception.AMQPConnectionError,
                                'connection was closed',
                                channel.check_for_errors)
        self.assertTrue(channel.is_closed)

# 需要导入模块: from amqpstorm import Channel [as 别名]
# 或者: from amqpstorm.Channel import set_state [as 别名]
    def test_channel_raises_when_closed(self):
        channel = Channel(0, FakeConnection(FakeConnection.OPEN), 360)
        channel.set_state(channel.CLOSED)

        self.assertFalse(channel.is_open)
        self.assertRaisesRegexp(exception.AMQPChannelError,
                                'channel was closed',
                                channel.check_for_errors)
        self.assertTrue(channel.is_closed)

# 需要导入模块: from amqpstorm import Channel [as 别名]
# 或者: from amqpstorm.Channel import set_state [as 别名]
    def test_basic_recover_invalid_parameter(self):
        channel = Channel(0, FakeConnection(), 360)
        channel.set_state(Channel.OPEN)
        basic = Basic(channel)

        self.assertRaisesRegexp(
            exception.AMQPInvalidArgument,
            'requeue should be a boolean',
            basic.recover, None
        )

# 需要导入模块: from amqpstorm import Channel [as 别名]
# 或者: from amqpstorm.Channel import set_state [as 别名]
    def test_basic_cancel_invalid_parameter(self):
        channel = Channel(0, FakeConnection(), 360)
        channel.set_state(Channel.OPEN)
        basic = Basic(channel)

        self.assertRaisesRegexp(
            exception.AMQPInvalidArgument,
            'consumer_tag should be a string',
            basic.cancel, None
        )

# 需要导入模块: from amqpstorm import Channel [as 别名]
# 或者: from amqpstorm.Channel import set_state [as 别名]
    def test_channel_flow_frame(self):
        connection = FakeConnection()
        connection.set_state(connection.OPEN)
        channel = Channel(0, connection, rpc_timeout=360)
        channel.set_state(channel.OPEN)

        channel.on_frame(specification.Channel.Flow())

        self.assertIsInstance(connection.frames_out[0][1],
                              specification.Channel.FlowOk)

# 需要导入模块: from amqpstorm import Channel [as 别名]
# 或者: from amqpstorm.Channel import set_state [as 别名]
    def test_channel_throw_exception_check_for_error(self):
        channel = Channel(0, FakeConnection(), 360)
        channel.set_state(channel.OPEN)
        channel.exceptions.append(AMQPConnectionError('travis-ci'))

        self.assertRaisesRegexp(
            AMQPConnectionError,
            'travis-ci',
            channel.check_for_errors
        )