def test_api_connection_close(self):
reason = 'travis-ci'
api = ManagementApi(HTTP_URL, USERNAME, PASSWORD, timeout=1)
self.assertEqual(len(api.connection.list()), 0,
'found an open connection, test will fail')
connection = Connection(HOST, USERNAME, PASSWORD, timeout=1)
connections = retry_function_wrapper(api.connection.list)
self.assertIsNotNone(connections)
self.assertEqual(len(connections), 1)
for conn in api.connection.list():
self.assertEqual(api.connection.close(conn['name'], reason=reason),
None)
time.sleep(1)
self.assertRaisesRegexp(
AMQPConnectionError, 'Connection was closed by remote server: '
'CONNECTION_FORCED - %s' % reason, connection.check_for_errors)
self.assertEqual(len(api.connection.list()), 0)
connection.close()
def test_api_user_get(self):
api = ManagementApi(HTTP_URL, USERNAME, PASSWORD)
user = api.user.get(USERNAME)
self.assertIsInstance(user, dict)
self.assertEqual(user['name'], USERNAME)
self.assertEqual(user['tags'], 'administrator')
def test_api_whoami(self):
api = ManagementApi(HTTP_URL, USERNAME, PASSWORD)
result = api.whoami()
self.assertIsInstance(result, dict)
self.assertEqual(result['name'], USERNAME)
self.assertEqual(result['tags'], 'administrator')
def test_api_exchange_declare_passive_exists(self):
exchange = 'test_queue_declare_passive_exists'
api = ManagementApi(HTTP_URL, USERNAME, PASSWORD)
api.exchange.declare(exchange)
self.assertIsNotNone(api.exchange.declare(exchange, passive=True))
def test_api_overview(self):
api = ManagementApi(HTTP_URL, USERNAME, PASSWORD)
result = api.overview()
self.assertIsInstance(result, dict)
self.assertIn('node', result)
self.assertIn('management_version', result)
def test_api_connection_get(self):
api = ManagementApi(HTTP_URL, USERNAME, PASSWORD)
connections = retry_function_wrapper(api.connection.list)
self.assertTrue(connections)
for conn in connections:
self.assertIsInstance(api.connection.get(conn['name']), dict)
def test_api_connection_list(self):
api = ManagementApi(HTTP_URL, USERNAME, PASSWORD)
connections = retry_function_wrapper(api.connection.list)
self.assertIsNotNone(connections)
self.assertEqual(len(connections), 1)
self.assertIsInstance(connections[0], dict)
def test_channel_get(self):
api = ManagementApi(HTTP_URL, USERNAME, PASSWORD)
channels = retry_function_wrapper(api.channel.list)
self.assertIsNotNone(channels)
for channel in channels:
self.assertIsInstance(api.channel.get(channel['name']), dict)
def test_api_with_inaccessible(self):
api = ManagementApi('http://192.168.1.50',
USERNAME,
PASSWORD,
timeout=0.1)
self.assertRaisesRegexp(ApiConnectionError,
'Max retries exceeded with url',
api.aliveness_test)
def test_healthtests_get_with_node_name(self):
api = ManagementApi(HTTP_URL, USERNAME, PASSWORD)
node_name = api.overview()['contexts'][0]['node']
result = api.healthchecks.get(node_name)
self.assertIsInstance(result, dict)
self.assertEqual(result['status'], 'ok')
def test_api_basic_publish(self):
api = ManagementApi(HTTP_URL, USERNAME, PASSWORD)
api.queue.declare(self.queue_name)
try:
self.assertEqual(api.basic.publish(self.message, self.queue_name),
{'routed': True})
finally:
api.queue.delete(self.queue_name)
def test_api_queue_get(self):
api = ManagementApi(HTTP_URL, USERNAME, PASSWORD)
api.queue.declare(self.queue_name)
queue = api.queue.get(self.queue_name)
self.assertIsInstance(queue, dict)
self.assertIn('name', queue)
self.assertIn('auto_delete', queue)
def test_api_queue_declare(self):
api = ManagementApi(HTTP_URL, USERNAME, PASSWORD)
self.assertIsNone(api.queue.declare(self.queue_name, durable=True))
result = api.queue.get(self.queue_name)
self.assertIsInstance(result, dict)
self.assertEqual(result['name'], self.queue_name)
self.assertEqual(result['auto_delete'], False)
self.assertEqual(result['durable'], True)
def test_channel_list(self):
api = ManagementApi(HTTP_URL, USERNAME, PASSWORD)
channels = retry_function_wrapper(api.channel.list)
self.assertIsNotNone(channels)
self.assertIsInstance(channels, list)
self.assertIsInstance(channels[0], dict)
self.channel.close()
def test_api_virtual_host_list(self):
api = ManagementApi(HTTP_URL, USERNAME, PASSWORD)
virtual_hosts = api.virtual_host.list()
self.assertIsInstance(virtual_hosts, list)
self.assertGreater(len(virtual_hosts), 0)
for vhost in virtual_hosts:
self.assertIsInstance(vhost, dict)
self.assertIn('name', vhost)
def test_api_user_get_permission(self):
api = ManagementApi(HTTP_URL, USERNAME, PASSWORD)
permission = api.user.get_permission(USERNAME, '/')
self.assertIsInstance(permission, dict)
self.assertEqual(permission['read'], '.*')
self.assertEqual(permission['write'], '.*')
self.assertEqual(permission['configure'], '.*')
self.assertEqual(permission['user'], USERNAME)
self.assertEqual(permission['vhost'], '/')
def test_api_basic_get_message_to_dict(self):
api = ManagementApi(HTTP_URL, USERNAME, PASSWORD)
api.queue.declare(self.queue_name)
self.assertEqual(api.basic.publish(self.message, self.queue_name),
{'routed': True})
result = api.basic.get(self.queue_name, requeue=False, to_dict=True)
self.assertIsInstance(result, list)
self.assertIsInstance(result[0], dict)
self.assertEqual(result[0]['payload'], self.message)
def test_api_virtual_host_permissions(self):
api = ManagementApi(HTTP_URL, USERNAME, PASSWORD)
permissions = api.virtual_host.get_permissions('/')
self.assertIsInstance(permissions, list)
self.assertIsInstance(permissions[0], dict)
self.assertEqual(permissions[0]['read'], '.*')
self.assertEqual(permissions[0]['write'], '.*')
self.assertEqual(permissions[0]['configure'], '.*')
self.assertEqual(permissions[0]['user'], 'guest')
self.assertEqual(permissions[0]['vhost'], '/')
def test_api_queue_declare_passive(self):
expected_error_message = ('NOT-FOUND - The client attempted to work '
'with a server entity that does not exist.')
api = ManagementApi(HTTP_URL, USERNAME, PASSWORD)
try:
api.queue.declare(self.queue_name, passive=True)
except ApiError as why:
self.assertEqual(str(why), expected_error_message)
self.assertEqual(why.error_type, 'NOT-FOUND')
self.assertEqual(why.error_code, 404)
def test_api_queue_delete(self):
api = ManagementApi(HTTP_URL, USERNAME, PASSWORD)
try:
api.queue.declare(self.queue_name, durable=True)
self.assertIsInstance(api.queue.get(self.queue_name), dict)
finally:
api.queue.delete(self.queue_name)
try:
api.queue.declare(self.queue_name, passive=True)
except ApiError as why:
self.assertEqual(why.error_code, 404)
def healthcheck_response(api_status):
"""Content and format health status response."""
health_status = dict([('framingService', api_status)])
API = ManagementApi('http://{0}:15672'.format(broker['host']),
broker['user'], broker['pass'])
try:
result = API.aliveness_test('/')
if result['status'] == 'ok':
health_status['messageBroker'] = "Running"
except Exception:
health_status['messageBroker'] = "Not Running"
return json.dumps(health_status, indent=1, sort_keys=True)
def test_api_user_list(self):
api = ManagementApi(HTTP_URL, USERNAME, PASSWORD)
users = api.user.list()
self.assertIsInstance(users, list)
self.assertGreater(len(users), 0)
for user in users:
self.assertIsInstance(user, dict)
self.assertIn('name', user)
self.assertIn('password_hash', user)
self.assertIn('tags', user)
def test_api_exchange_list_all(self):
api = ManagementApi(HTTP_URL, USERNAME, PASSWORD)
exchanges = api.exchange.list(show_all=True)
self.assertIsInstance(exchanges, list)
self.assertGreater(len(exchanges), 0)
for exchange in exchanges:
self.assertIsInstance(exchange, dict)
self.assertIn('name', exchange)
self.assertIn('type', exchange)
self.assertIn('auto_delete', exchange)
def test_api_virtual_host_create(self):
vhost_name = 'test_api_virtual_host_create'
api = ManagementApi(HTTP_URL, USERNAME, PASSWORD)
try:
self.assertIsNone(api.virtual_host.create(vhost_name))
virtual_host = api.virtual_host.get(vhost_name)
self.assertIsInstance(virtual_host, dict)
self.assertEqual(virtual_host['name'], vhost_name)
api.user.set_permission('guest', vhost_name)
finally:
api.virtual_host.delete(vhost_name)
def test_api_user_create(self):
username = '******'
password = str(uuid.uuid4())
api = ManagementApi(HTTP_URL, USERNAME, PASSWORD)
try:
self.assertIsNone(
api.user.create(username, password, tags='monitor'))
user = api.user.get(username)
self.assertEqual(user['name'], username)
self.assertEqual(user['tags'], 'monitor')
finally:
api.user.delete(username)
def test_api_basic_get_message_requeue(self):
api = ManagementApi(HTTP_URL, USERNAME, PASSWORD)
api.queue.declare(self.queue_name)
self.assertEqual(api.basic.publish(self.message, self.queue_name),
{'routed': True})
result = api.basic.get(self.queue_name, requeue=True)
self.assertIsInstance(result, list)
self.assertIsInstance(result[0], Message)
self.assertEqual(result[0].body, self.message)
# Make sure the message was re-queued.
self.assertTrue(api.basic.get(self.queue_name, requeue=False))
def healthcheck_response(api_status):
"""Content and format health status response."""
elastic = ElasticIndex()
health_status = dict([('indexService', api_status)])
health_status['elasticsearch'] = ''.join(
elastic._healthcheck().get("status"))
API = ManagementApi('http://{0}:15672'.format(broker['host']),
broker['user'], broker['pass'])
try:
result = API.aliveness_test('/')
if result['status'] == 'ok':
health_status['messageBroker'] = "Running"
except Exception:
health_status['messageBroker'] = "Not Running"
return json.dumps(health_status, indent=1, sort_keys=True)
def test_api_queue_bind(self):
exchange_name = 'amq.direct'
api = ManagementApi(HTTP_URL, USERNAME, PASSWORD)
api.queue.declare(self.queue_name)
bindings = len(api.queue.bindings(self.queue_name))
self.assertIsNone(api.queue.bind(queue=self.queue_name,
exchange=exchange_name,
routing_key=self.queue_name,
arguments=None))
self.assertEqual(len(api.queue.bindings(self.queue_name)),
bindings + 1)
def test_api_top(self):
def on_get(name):
if name == 'nodes':
return [{'name': 'node1'}]
elif name == 'top/node1':
return {'node': 'node1', 'processes': [{'status': u'running'}]}
api = ManagementApi('url', 'guest', 'guest')
api.http_client = FakeHTTPClient(on_get)
top = api.top()
self.assertIsInstance(top, list)
self.assertIsInstance(top[0], dict)
self.assertEqual(top[0]['node'], 'node1')
self.assertIn('processes', top[0])
def test_api_exchange_delete(self):
exchange_type = 'direct'
api = ManagementApi(HTTP_URL, USERNAME, PASSWORD)
api.exchange.declare(self.exchange_name,
exchange_type,
passive=False,
durable=True)
self.assertIsNone(api.exchange.delete(self.exchange_name))
self.assertRaisesRegexp(
ApiError, 'NOT-FOUND - The client attempted to work '
'with a server entity that does not exist.', api.exchange.get,
self.exchange_name)
