def test_channel0_unblocked(self):
channel = Channel0(self.connection)
channel.on_frame(Connection.Blocked())
self.assertTrue(channel.is_blocked)
channel.on_frame(Connection.Unblocked())
self.assertFalse(channel.is_blocked)
self.assertEqual(self.get_last_log(),
'Connection is blocked by remote server: ')
def test_channel0_send_tune_ok_negotiate(self):
channel = Channel0(FakeConnection())
channel._send_tune_ok(
Connection.Tune(frame_max=MAX_FRAME_SIZE,
channel_max=MAX_CHANNELS))
self.assertEqual(channel.max_frame_size, MAX_FRAME_SIZE)
self.assertEqual(channel.max_allowed_channels, MAX_CHANNELS)
def test_channel0_open_ok_frame(self):
channel = Channel0(self.connection)
self.assertFalse(self.connection.is_open)
channel.on_frame(Connection.OpenOk())
self.assertTrue(self.connection.is_open)
def test_channel0_send_tune_ok_negotiate_use_max(self):
"""Test to make sure that we use the highest acceptable value when
the server returns zero.
"""
channel = Channel0(FakeConnection())
channel._send_tune_ok(Connection.Tune())
self.assertEqual(channel.max_frame_size, MAX_FRAME_SIZE)
self.assertEqual(channel.max_allowed_channels, MAX_CHANNELS)
def test_channel0_on_close_ok_frame(self):
self.connection.set_state(self.connection.OPEN)
channel = Channel0(self.connection)
self.assertFalse(self.connection.is_closed)
channel.on_frame(Connection.CloseOk())
self.assertTrue(self.connection.is_closed)
def test_channel0_tune_frame(self):
connection = FakeConnection()
connection.parameters['virtual_host'] = '/'
channel = Channel0(connection)
channel.on_frame(Connection.Tune())
self.assertIsInstance(connection.get_last_frame(), Connection.TuneOk)
self.assertIsInstance(connection.get_last_frame(), Connection.Open)
def test_channel0_invalid_authentication_mechanism(self):
connection = amqpstorm.Connection('localhost',
'guest',
'guest',
lazy=True)
channel = Channel0(connection)
channel._send_start_ok(
Connection.Start(mechanisms='CRAM-MD5 SCRAM-SHA-1 SCRAM-SHA-256'))
self.assertRaises(AMQPConnectionError, connection.check_for_errors)
def test_channel0_send_tune_ok_negotiate_use_server(self):
"""Test to make sure that we use the highest acceptable value from
the servers perspective.
"""
channel = Channel0(FakeConnection())
channel._send_tune_ok(Connection.Tune(frame_max=16384,
channel_max=200))
self.assertEqual(channel.max_frame_size, 16384)
self.assertEqual(channel.max_allowed_channels, 200)
def test_channel0_forcefully_closed_connection(self):
connection = amqpstorm.Connection('localhost',
'guest',
'guest',
lazy=True)
connection.set_state(connection.OPEN)
channel = Channel0(connection)
channel._close_connection(
Connection.Close(reply_text=b'', reply_code=500))
self.assertTrue(connection.is_closed)
self.assertRaises(AMQPConnectionError, connection.check_for_errors)
def test_channel0_close_connection(self):
connection = FakeConnection()
connection.set_state(connection.OPEN)
channel = Channel0(connection)
self.assertTrue(connection.is_open)
channel._close_connection(
Connection.Close(reply_text=b'', reply_code=200))
self.assertFalse(connection.exceptions)
self.assertTrue(connection.is_closed)
def test_channel0_start_invalid_auth_frame(self):
connection = FakeConnection()
connection.parameters['username'] = '******'
connection.parameters['password'] = '******'
channel = Channel0(connection)
channel.on_frame(Connection.Start(mechanisms='invalid'))
self.assertRaisesRegexp(
AMQPConnectionError,
'Unsupported Security Mechanism\(s\): invalid',
connection.check_for_errors)
def test_channel0_start_frame(self):
connection = FakeConnection()
connection.parameters['username'] = '******'
connection.parameters['password'] = '******'
channel = Channel0(connection)
properties = {'version': 0}
channel.on_frame(Connection.Start(server_properties=properties))
self.assertEqual(channel.server_properties, properties)
self.assertIsInstance(connection.get_last_frame(), Connection.StartOk)
def test_channel0_send_start_ok_external(self):
connection = FakeConnection()
channel = Channel0(connection)
channel._send_start_ok(Connection.Start(mechanisms=b'EXTERNAL'))
self.assertTrue(connection.frames_out)
channel_id, frame_out = connection.frames_out.pop()
self.assertEqual(channel_id, 0)
self.assertIsInstance(frame_out, Connection.StartOk)
self.assertNotEqual(frame_out.locale, '')
self.assertIsNotNone(frame_out.locale)
def test_channel0_on_close_frame(self):
self.connection.set_state(self.connection.OPEN)
channel = Channel0(self.connection)
self.assertFalse(self.connection.exceptions)
channel.on_frame(Connection.Close())
self.assertTrue(self.connection.exceptions)
self.assertTrue(self.connection.is_closed)
self.assertRaisesRegexp(AMQPConnectionError,
'Connection was closed by remote server: ',
self.connection.check_for_errors)
def test_channel0_send_tune_ok(self):
connection = FakeConnection()
channel = Channel0(connection)
channel._send_tune_ok(Connection.Tune())
self.assertTrue(connection.frames_out)
channel_id, frame_out = connection.frames_out.pop()
self.assertEqual(channel_id, 0)
self.assertIsInstance(frame_out, Connection.TuneOk)
self.assertEqual(frame_out.channel_max, MAX_CHANNELS)
self.assertEqual(frame_out.frame_max, MAX_FRAME_SIZE)
def test_channel0_send_start_ok_plain(self):
connection = FakeConnection()
connection.parameters['username'] = '******'
connection.parameters['password'] = '******'
channel = Channel0(connection)
channel._send_start_ok(Connection.Start(mechanisms=b'PLAIN'))
self.assertTrue(connection.frames_out)
channel_id, frame_out = connection.frames_out.pop()
self.assertEqual(channel_id, 0)
self.assertIsInstance(frame_out, Connection.StartOk)
self.assertNotEqual(frame_out.locale, '')
self.assertIsNotNone(frame_out.locale)