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_unblocked(self):
connection = amqpstorm.Connection('localhost',
'guest',
'guest',
lazy=True)
channel = Channel0(connection)
channel.on_frame(Connection.Blocked())
self.assertTrue(channel.is_blocked)
channel.on_frame(Connection.Unblocked())
self.assertFalse(channel.is_blocked)
self.assertEqual(self.logging_handler.messages['info'][0],
'Connection is no longer blocked by remote server')
def _send_open_connection(self):
"""Send Open Connection frame.
:return:
"""
open_frame = pamqp_connection.Open(
virtual_host=self.parameters['virtual_host'])
self._write_frame(open_frame)
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(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_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_frame(
Connection.Start(mechanisms='CRAM-MD5 SCRAM-SHA-1 SCRAM-SHA-256'))
self.assertRaises(AMQPConnectionError, connection.check_for_errors)
def _send_tune_ok_frame(self):
"""Send Tune OK frame.
:return:
"""
tune_ok_frame = pamqp_connection.TuneOk(channel_max=MAX_CHANNELS,
frame_max=FRAME_MAX,
heartbeat=self._heartbeat)
self._write_frame(tune_ok_frame)
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_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.assertEqual(connection.exceptions, [])
self.assertTrue(connection.is_closed)
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_open_ok_frame(self):
connection = amqpstorm.Connection('localhost',
'guest',
'guest',
lazy=True)
channel = Channel0(connection)
self.assertFalse(connection.is_open)
channel.on_frame(Connection.OpenOk())
self.assertTrue(connection.is_open)
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_send_start_ok_frame(self):
connection = FakeConnection()
connection.parameters['username'] = '******'
connection.parameters['password'] = '******'
channel = Channel0(connection)
channel._send_start_ok_frame(Connection.Start(mechanisms=b'PLAIN'))
self.assertNotEqual(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_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_is_blocked(self):
connection = amqpstorm.Connection('localhost',
'guest',
'guest',
lazy=True)
channel = Channel0(connection)
self.assertFalse(channel.is_blocked)
channel.on_frame(Connection.Blocked('unit-test'))
self.assertTrue(channel.is_blocked)
self.assertEqual(self.logging_handler.messages['warning'][0],
'Connection is blocked by remote server: unit-test')
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_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_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_on_close_frame(self):
connection = amqpstorm.Connection('localhost',
'guest',
'guest',
lazy=True)
connection.set_state(connection.OPEN)
channel = Channel0(connection)
self.assertFalse(connection.exceptions)
channel.on_frame(Connection.Close())
self.assertTrue(connection.exceptions)
self.assertTrue(connection.is_closed)
self.assertRaisesRegexp(AMQPConnectionError,
'Connection was closed by remote server: ',
connection.check_for_errors)
def _send_start_ok_frame(self, frame_in):
"""Send Start OK frame.
:param pamqp_spec.Connection.StartOk frame_in: Amqp frame.
:return:
"""
if 'PLAIN' not in try_utf8_decode(frame_in.mechanisms):
exception = AMQPConnectionError('Unsupported Security Mechanism(s)'
': %s' % frame_in.mechanisms)
self._connection.exceptions.append(exception)
return
credentials = self._plain_credentials()
start_ok_frame = pamqp_connection.StartOk(
mechanism=AUTH_MECHANISM,
client_properties=self._client_properties(),
response=credentials,
locale=LOCALE)
self._write_frame(start_ok_frame)