def test_io_set_ssl_verify_req(self):
connection = FakeConnection()
connection.parameters['ssl_options'] = {'verify_mode': 'required'}
io = IO(connection.parameters)
sock = io._ssl_wrap_socket(socket.socket())
self.assertEqual(sock.context.verify_mode, ssl.CERT_REQUIRED)
def __init__(self, hostname, username, password, port=5672, **kwargs):
"""
:param str hostname: Hostname
:param str username: Username
:param str password: Password
:param int port: Server port
:param str virtual_host: Virtualhost
:param int heartbeat: RabbitMQ Heartbeat interval
:param int|float timeout: Socket timeout
:param bool ssl: Enable SSL
:param dict ssl_options: SSL kwargs (from ssl.wrap_socket)
:param bool lazy: Lazy initialize the connection
:return:
"""
super(Connection, self).__init__()
self.parameters = {
'hostname': hostname,
'username': username,
'password': password,
'port': port,
'virtual_host': kwargs.get('virtual_host', '/'),
'heartbeat': kwargs.get('heartbeat', 60),
'timeout': kwargs.get('timeout', 30),
'ssl': kwargs.get('ssl', False),
'ssl_options': kwargs.get('ssl_options', {})
}
self._validate_parameters()
self.heartbeat = Heartbeat(self.parameters['heartbeat'])
self._io = IO(self.parameters, on_read=self._read_buffer)
self._channel0 = Channel0(self)
self._channels = {}
if not kwargs.get('lazy', False):
self.open()
def test_connection_close_when_already_closed(self):
connection = Connection('127.0.0.1', 'guest', 'guest', lazy=True)
connection.set_state(connection.OPEN)
io = IO(connection.parameters, [])
io.socket = Mock(name='socket', spec=socket.socket)
connection._io = io
connection.set_state(connection.CLOSED)
# Create some fake channels.
for index in range(10):
connection._channels[index + 1] = Channel(
index + 1, connection, 360)
def state_set(state):
self.assertEqual(state, connection.CLOSED)
connection.set_state = state_set
self.assertTrue(connection.is_closed)
connection.close()
# Make sure all the fake channels were closed as well.
for index in range(10):
self.assertNotIn(index + 1, connection._channels)
self.assertFalse(connection._channels)
self.assertTrue(connection.is_closed)
def __init__(self, hostname, username, password, port=5672, **kwargs):
super(Connection, self).__init__()
self.parameters = {
'hostname': hostname,
'username': username,
'password': password,
'port': port,
'virtual_host': kwargs.get('virtual_host', DEFAULT_VIRTUAL_HOST),
'heartbeat': kwargs.get('heartbeat', DEFAULT_HEARTBEAT_INTERVAL),
'timeout': kwargs.get('timeout', DEFAULT_SOCKET_TIMEOUT),
'ssl': kwargs.get('ssl', False),
'ssl_options': kwargs.get('ssl_options', {}),
'client_properties': kwargs.get('client_properties', {})
}
self._validate_parameters()
self._io = IO(self.parameters,
exceptions=self._exceptions,
on_read_impl=self._read_buffer)
self._channel0 = Channel0(self, self.parameters['client_properties'])
self._channels = {}
self._last_channel_id = None
self.heartbeat = Heartbeat(self.parameters['heartbeat'],
self._channel0.send_heartbeat)
if not kwargs.get('lazy', False):
self.open()
def test_connection_close(self):
connection = Connection('127.0.0.1', 'guest', 'guest', lazy=True)
connection.set_state(connection.OPEN)
io = IO(connection.parameters, [])
io.socket = Mock(name='socket', spec=socket.socket)
connection._io = io
# Create some fake channels.
for index in range(10):
connection._channels[index + 1] = Channel(
index + 1, connection, 360)
def on_write(frame_out):
self.assertIsInstance(frame_out, specification.Connection.Close)
connection._channel0._close_connection_ok()
connection._channel0._write_frame = on_write
self.assertFalse(connection.is_closed)
connection.close()
# Make sure all the fake channels were closed as well.
for index in range(10):
self.assertNotIn(index + 1, connection._channels)
self.assertTrue(connection.is_closed)
def test_connection_close_handles_raise_on_write(self):
connection = Connection('127.0.0.1', 'guest', 'guest', lazy=True)
connection.set_state(connection.OPEN)
io = IO(connection.parameters, [])
io.socket = Mock(name='socket', spec=socket.socket)
connection._io = io
# Create some fake channels.
for index in range(10):
connection._channels[index + 1] = Channel(
index + 1, connection, 360)
def raise_on_write(_):
raise AMQPConnectionError('travis-ci')
connection._channel0._write_frame = raise_on_write
self.assertFalse(connection.is_closed)
connection.close()
# Make sure all the fake channels were closed as well.
for index in range(10):
self.assertNotIn(index + 1, connection._channels)
self.assertFalse(connection._channels)
self.assertTrue(connection.is_closed)
def test_io_receive_raises_socket_timeout(self):
connection = FakeConnection()
io = IO(connection.parameters)
io.socket = mock.Mock(name='socket', spec=socket.socket)
io.socket.recv.side_effect = socket.timeout('timeout')
io._receive()
self.assertIsNone(connection.check_for_errors())
def test_io_socket_close(self):
connection = FakeConnection()
io = IO(connection.parameters)
io.socket = Mock(name='socket', spec=socket.socket)
io.close()
self.assertIsNone(io.socket)
def test_io_simple_receive(self):
connection = FakeConnection()
io = IO(connection.parameters)
io.socket = MagicMock(name='socket', spec=socket.socket)
io.socket.recv.return_value = '12345'
self.assertEqual(io._receive(), '12345')
def test_io_raises_gaierror(self, _):
connection = FakeConnection()
connection.parameters['hostname'] = 'localhost'
connection.parameters['port'] = 1234
parameters = connection.parameters
io = IO(parameters)
self.assertRaisesRegexp(AMQPConnectionError, 'could not connect',
io._get_socket_addresses)
def test_io_normal_connection_without_ssl_library(self, _):
connection = FakeConnection()
connection.parameters['hostname'] = 'localhost'
connection.parameters['port'] = 1234
parameters = connection.parameters
io = IO(parameters)
self.assertRaisesRegexp(AMQPConnectionError,
'Could not connect to localhost:1234', io.open)
def test_io_shutdown_with_io_error(self):
connection = FakeConnection()
io = IO(connection.parameters)
io._exceptions = []
io.socket = mock.Mock(name='socket', spec=socket.socket)
io.socket.shutdown.side_effect = OSError()
io._close_socket()
def test_io_receive_raises_ssl_want_read_error(self):
connection = FakeConnection()
io = IO(connection.parameters, exceptions=connection.exceptions)
io.socket = mock.Mock(name='socket', spec=socket.socket)
io.socket.recv.side_effect = compatibility.SSLWantReadError()
io._receive()
self.assertIsNone(connection.check_for_errors())
def test_io_receive_does_not_raise_on_block(self):
connection = FakeConnection()
io = IO(connection.parameters, exceptions=connection.exceptions)
io.socket = mock.Mock(name='socket', spec=socket.socket)
io.socket.recv.side_effect = socket.error(EWOULDBLOCK)
io._receive()
self.assertIsNone(connection.check_for_errors())
def test_io_set_ssl_context_no_hostname_provided(self):
connection = FakeConnection()
connection.parameters['ssl_options'] = {
'context': ssl.create_default_context(),
}
io = IO(connection.parameters)
self.assertRaises(ValueError, io._ssl_wrap_socket, socket.socket())
def test_connection_fileno_property(self):
connection = Connection('127.0.0.1', 'guest', 'guest', lazy=True)
connection.set_state(connection.OPENING)
io = IO(connection.parameters, [])
io.socket = Mock(name='socket', spec=socket.socket)
connection._io = io
io.socket.fileno.return_value = 5
self.assertEqual(connection.fileno, 5)
def test_io_simple_receive_when_socket_not_set(self):
connection = FakeConnection()
io = IO(connection.parameters, exceptions=connection.exceptions)
self.assertFalse(io.use_ssl)
self.assertEqual(io._receive(), bytes())
self.assertRaisesRegexp(AMQPConnectionError, 'connection/socket error',
connection.check_for_errors)
def test_io_get_socket_address(self):
connection = FakeConnection()
connection.parameters['hostname'] = '127.0.0.1'
connection.parameters['port'] = 5672
io = IO(connection.parameters)
addresses = io._get_socket_addresses()
sock_address_tuple = addresses[0]
self.assertEqual(sock_address_tuple[4], ('127.0.0.1', 5672))
def test_io_set_ssl_context(self):
connection = FakeConnection()
connection.parameters['ssl_options'] = {
'context': ssl.create_default_context(),
'server_hostname': 'localhost',
}
io = IO(connection.parameters)
self.assertTrue(io._ssl_wrap_socket(socket.socket()))
def test_io_simple_send_with_io_error(self):
connection = FakeConnection()
io = IO(connection.parameters)
io._exceptions = []
io.socket = None
io.write_to_socket(self.message)
self.assertTrue(io._exceptions)
def test_io_receive_raises_socket_error(self):
connection = FakeConnection()
io = IO(connection.parameters, exceptions=connection.exceptions)
io.socket = mock.Mock(name='socket', spec=socket.socket)
io.socket.recv.side_effect = socket.error('travis-ci')
io._receive()
self.assertRaisesRegexp(AMQPConnectionError, 'travis-ci',
connection.check_for_errors)
def test_io_receive_raises_socket_error(self):
connection = FakeConnection()
io = IO(connection.parameters)
io._exceptions = []
io.socket = MagicMock(name='socket', spec=socket.socket)
io.socket.recv.side_effect = socket.error('error')
io._receive()
self.assertIsInstance(io._exceptions[0], AMQPConnectionError)
def test_io_socket_read_fails_with_ssl(self):
connection = FakeConnection()
parameters = FakeConnection().parameters
parameters['ssl'] = True
io = IO(parameters, exceptions=connection.exceptions)
self.assertTrue(io.use_ssl)
self.assertRaisesRegexp(socket.error, 'connection/socket error',
io._read_from_socket)
def test_io_simple_send_zero_bytes_sent(self):
connection = FakeConnection()
io = IO(connection.parameters, exceptions=connection.exceptions)
io.socket = Mock(name='socket', spec=socket.socket)
io.socket.send.return_value = 0
io.write_to_socket(self.message)
self.assertRaisesRegexp(AMQPConnectionError, 'connection/socket error',
connection.check_for_errors)
def test_io_simple_send_with_error(self):
connection = FakeConnection()
io = IO(connection.parameters)
io._exceptions = []
io.socket = mock.Mock(name='socket', spec=socket.socket)
io.socket.send.side_effect = socket.error('error')
io.write_to_socket(self.message)
self.assertIsInstance(io._exceptions[0], AMQPConnectionError)
def test_connection_wait_for_connection_raises_on_timeout(self):
connection = Connection('127.0.0.1', 'guest', 'guest', timeout=0.1,
lazy=True)
connection.set_state(connection.OPENING)
io = IO(connection.parameters, [])
io.socket = MagicMock(name='socket', spec=socket.socket)
connection._io = io
self.assertRaises(AMQPConnectionError,
connection._wait_for_connection_to_open)
def test_io_simple_send_zero_bytes_sent(self):
connection = FakeConnection()
io = IO(connection.parameters)
io._exceptions = []
io.socket = MagicMock(name='socket', spec=socket.socket)
io.poller = MagicMock(name='poller', spec=amqpstorm.io.Poller)
io.socket.send.return_value = 0
io.write_to_socket('afasffa')
self.assertIsInstance(io._exceptions[0], AMQPConnectionError)
def test_io_simple_send_with_error(self):
connection = FakeConnection()
io = IO(connection.parameters)
io._exceptions = []
io.socket = MagicMock(name='socket', spec=socket.socket)
io.poller = MagicMock(name='poller', spec=amqpstorm.io.Poller)
io.socket.send.side_effect = socket.error('error')
io.write_to_socket('12345')
self.assertIsInstance(io._exceptions[0], AMQPConnectionError)
def test_io_use_defined_ssl_version(self):
connection = FakeConnection()
connection.parameters['ssl_options'] = {'ssl_version': 'travis-ci'}
sock = Mock(name='socket', spec=socket.socket)
sock.fileno.return_value = 1
io = IO(connection.parameters)
self.assertRaises(Exception, io._ssl_wrap_socket, sock)
self.assertEqual(connection.parameters['ssl_options']['ssl_version'],
'travis-ci')
def test_io_sets_default_ssl_version(self):
connection = FakeConnection()
connection.parameters['ssl_options'] = {}
sock = Mock(name='socket', spec=socket.socket)
sock.fileno.return_value = 1
io = IO(connection.parameters)
self.assertRaises(Exception, io._ssl_wrap_socket, sock)
self.assertEqual(connection.parameters['ssl_options']['ssl_version'],
compatibility.DEFAULT_SSL_VERSION)
