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)