def test_handle_status_in_progress(self, *_):
svc = IntegratedToolsSvc(
BllRequest(action='GET',
operation='vcenters',
auth_token=get_mock_token()))
output = svc.handle()
self.assertEqual(output['status'], 'complete')
def test_query_parameters(self, _token_helper):
base_url = randomurl()
data = randomdict()
path = "my/path"
# The token_helper constructor returns an object with
# a get_service_endpoint function that we want to override
_token_helper.return_value.get_service_endpoint.return_value = base_url
svc = ArdSvc(
BllRequest(operation="do_path_operation",
auth_token=get_mock_token(),
action="GET",
data={
'path': path,
'request_data': data,
'request_parameters': ['key=value']
}))
svc._request = mock.Mock()
svc.handle()
# Verify that the proper values are going to be passed to the requests
# library
svc._request.assert_called_once_with(path, {"key": "value"},
data,
action='GET')
def test_playbook_cycle(self, *_):
svc = ArdSvc(
BllRequest(operation='run_playbook',
auth_token=get_mock_token(),
action='POST',
data={
'playbook_name': 'some_playbook',
}))
# Kick off the playbook
resp = svc.handle()
txn_id = resp[api.TXN_ID]
# We now should be busy running the playbook
status = get_job_status(txn_id)
self.assertTrue(status['status'], api.STATUS_INPROGRESS)
svc.update_job_status()
self.assertTrue(status['status'], api.STATUS_INPROGRESS)
# Now pretend we are done
svc.update_job_status('done', percentage_complete=100, txn_id=txn_id)
svc.sc_complete()
self.assertTrue(status['status'], api.COMPLETE)
self.assertFalse(status[api.DATA]['alive'])
self.assertEquals(status[api.DATA]['code'], 0)
def test_hypervisor_list(self, _mock_nova_client, _mock_endpoints,
_mock_serv_end, _mock_ks_client):
_mock_nova_client.return_value = self.mock_novaclient
_mock_serv_end.return_value = None
_mock_ks_client.return_value = self.mock_ksclient
_mock_endpoints.return_value = self.mock_get_endpoints
svc = NovaSvc(
BllRequest(auth_token=get_mock_token(),
data={api.OPERATION: 'hypervisor-list'}))
# build up a list of ping statuses
statuses = {}
for hyp in self.hyp_list:
statuses[hyp.hypervisor_hostname] = 'up'
with patch('bll.plugins.service.SvcBase.call_service',
return_value=statuses):
reply = svc.handle()
self.assertEqual(api.COMPLETE, reply[api.STATUS])
# 4 hypervisors
hyp_list = reply[api.DATA]
self.assertEqual(len(self.hyp_list), len(hyp_list))
known_id_list = [x.id for x in self.hyp_list]
for hyp in hyp_list:
self.assertTrue(hyp['hypervisor_id'] in known_id_list)
self.assertEqual(hyp['ping_status'], 'up')
def test_get_vcenter_count(self, *_):
svc = IntegratedToolsSvc(
BllRequest(action='GET',
operation='count_vcenters',
auth_token=get_mock_token()))
output = svc.handle()
self.assertEqual(output['data'], 1)
def test_generic_get(self, _mock_endpoints, _mock_get_func):
mock_client = mock.MagicMock()
mock_client.node = mock.create_autospec(NodeManager)
_mock_endpoints.return_value = [{
'region': randomword(),
'url': randomurl()
}]
nodeid = randomhex()
res = self.MockResource({
'instance_uuid': randomhex(),
'uuid': nodeid,
'driver': 'agent_ilo',
'name': randomword(),
'power_state': 'power on',
'provision_state': 'active',
})
mock_client.node.get.return_value = res
_mock_get_func.return_value = mock_client
svc = IronicSvc(
BllRequest(operation='node.get',
auth_token=get_mock_token(),
data={'node_id': randomhex}))
data = svc.handle()[api.DATA]
self.assertIsInstance(data, dict)
self.assertEqual(data['driver'], 'agent_ilo')
self.assertEqual(data['uuid'], nodeid)
def test_service_inc_metrics_statistics(self, _mock_nova_client,
_mock_monasca_client,
_mock_endpoints, _mock_serv_end,
_mock_ks_client):
_mock_nova_client.return_value = self.mock_novaclient
_mock_serv_end.return_value = None
_mock_ks_client.return_value = self.mock_ksclient
_mock_monasca_client.return_value = self.mock_monasca_client
_mock_endpoints.return_value = self.mock_get_endpoints
req_data = {
api.OPERATION: 'instance-list',
'monasca_metrics': ['some.metric'],
'monasca_data': {
'operation': 'metric_statistics'
}
}
svc = NovaSvc(BllRequest(auth_token=get_mock_token(), data=req_data))
reply = svc.handle()
self.assertEqual(reply[api.STATUS], api.COMPLETE)
self.mock_monasca_client.metrics.list_statistics.assert_called_with(
name='some.metric')
self.assertIn(api.DATA, reply)
data = reply[api.DATA]
self.assertIn('instances', data)
self.assertIsInstance(data['instances'], list)
self.assertTrue(len(data['instances']) > 0)
self.assertIn('metrics', data['instances'][0])
self.assertIn('some.metric', data['instances'][0]['metrics'])
some_metric = data['instances'][0]['metrics']['some.metric']
self.assertEquals(some_metric[0]['statistics'][0][1], 31)
def test_get_enterprise_app_endpoints(self, mock_get_service_endpoint):
svc = CatalogSvc(
BllRequest(operation='get_enterprise_app_endpoints',
auth_token=get_mock_token()))
output = svc.handle()
self.assertGreater(len(output['data']), 0)
def test_activate_resource_success_esx(self, *_):
body = {
"type": "esxcluster",
"network_config": {
'mgmt_trunk': [{
'nics': 'vmnic0',
'name': 'MGMT-DVS-SH',
'mtu': '1500'
}],
'cloud_trunks': [{
'nics': 'vmnic1',
'network_name': 'VxLAN-R1',
'name': 'DATA-DVS',
'mtu': '1500'
}]
},
"id": "12345"
}
svc = EONSvc(
BllRequest(operation="activate_resource",
action="POST",
auth_token=get_mock_token(),
data={'data': body}))
svc.handle()
reply = svc.complete()
self.assertEqual(reply[api.STATUS], api.COMPLETE)
def test_no_playbook(self, *_):
svc = ArdSvc(
BllRequest(operation='run_playbook',
auth_token=get_mock_token(),
action='POST',
data={}))
with self.assertRaises(InvalidBllRequestException):
svc.handle()
def test_unregister_vcenter_error_missing_ids(self, *_):
svc = IntegratedToolsSvc(
BllRequest(action='DELETE',
operation='vcenters',
auth_token=get_mock_token()))
output = svc.complete()
self.assertEqual('error', output['status'])
self.assertEqual(REGISTERED_STATE, get_vcenter_state(id))
def test_prepare_template_fail_no_resource_type(self, *_):
svc = EONSvc(
BllRequest(operation="prepare_activate_template",
auth_token=get_mock_token(),
data={'data': {}}))
with self.assertRaisesRegexp(Exception, "Invalid Resource Type"):
svc.handle()
body = {'type': 'xyz'}
svc = EONSvc(
BllRequest(operation="prepare_activate_template",
auth_token=get_mock_token(),
data={'data': body}))
with self.assertRaisesRegexp(Exception, "Invalid Resource Type"):
svc.handle()
def test_get(self, *_):
svc = compute_service.ComputeSvc(BllRequest(
action='GET',
operation='get_compute_list',
auth_token=get_mock_token()))
reply = svc.handle()
self.assertEqual(api.COMPLETE, reply[api.STATUS])
self.assertEqual(1, len(reply['data']))
def test_get_network_data(self, *_):
svc = ArdSvc(
BllRequest(operation='get_network_data',
auth_token=get_mock_token()))
networks = svc.handle()['data']
# should be 3 networks here
self.assertEqual(len(networks), 3)
for network in networks:
self.assertIsNone(network.get('addr', None))
self.assertIsNone(network.get('endpoints', None))
def test_activate_resource_fail_esx(self, *_):
body = {"type": "esxcluster", "network_config": {}}
svc = EONSvc(
BllRequest(operation="activate_resource",
action="POST",
auth_token=get_mock_token(),
data={'data': body}))
svc.handle()
reply = svc.complete()
self.assertEqual(reply[api.STATUS], api.STATUS_ERROR)
def test_prepare_activate_template_success_hyperv(self, *_):
body = {'type': 'hyperv'}
svc = EONSvc(
BllRequest(operation="prepare_activate_template",
auth_token=get_mock_token(),
data={'data': body}))
reply = svc.handle()
resp = reply[api.DATA]
self.assertEqual(reply[api.STATUS], api.COMPLETE)
self.assertGreater(len(resp['server_roles']), 0)
self.assertGreater(len(resp['server_groups']), 0)
def test_unregister_vcenter(self, *_):
svc = IntegratedToolsSvc(
BllRequest(action='DELETE',
operation='vcenters',
auth_token=get_mock_token(),
ids={vcenter_id: vcenter_name}))
output = svc.complete()
self.assertEqual('complete', output['status'])
self.assertEqual('complete', output['data'][0]['status'])
self.assertEqual(REGISTERED_STATE, get_vcenter_state(id))
def handle(self, action, user='******', prefs=None):
req_dict = {
api.TARGET: 'preferences',
api.AUTH_TOKEN: get_mock_token(),
api.ACTION: action
}
req_dict[api.DATA] = {"user": user}
if prefs:
req_dict[api.DATA]["prefs"] = prefs
return SvcBase.spawn_service(BllRequest(req_dict))
def test_two_regions(self, _mock_endpoints):
"""
In a two-region setup, a call to get one client must return just one
client, while a call to get all clients should return a list with that
client and one other. Also, calling them in either order (list first
or single client first) must generate no unnecessary calls to the
create function.
"""
_mock_endpoints.return_value = [
{'region': randomidentifier(), 'url': randomurl()},
{'region': randomidentifier(), 'url': randomurl()}]
#
# Get all clients first, then get just a single client
#
create_func = mock.Mock()
client = RegionClient(randomidentifier(), create_func,
get_mock_token(), randomidentifier())
client_list = list(client.get_clients())
self.assertEqual(2, create_func.call_count)
single_client = client.get_client()
self.assertEqual(2, create_func.call_count)
self.assertEqual(2, len(client_list))
self.assertIn(single_client, client_list)
#
# Get single client first, then get all clients
#
create_func = mock.Mock()
client = RegionClient(randomidentifier(), create_func,
get_mock_token(), randomidentifier())
single_client = client.get_client()
self.assertEqual(1, create_func.call_count)
client_list = list(client.get_clients())
self.assertEqual(2, create_func.call_count)
self.assertEqual(2, len(client_list))
self.assertIn(single_client, client_list)
def test_prepare_activate_template_success_esx(self, *_):
body = {'type': 'esxcluster'}
svc = EONSvc(
BllRequest(operation="prepare_activate_template",
auth_token=get_mock_token(),
data={'data': body}))
reply = svc.handle()
resp = reply[api.DATA]
self.assertEqual(reply[api.STATUS], api.COMPLETE)
self.assertGreater(resp['mgmt_trunk'], 0)
self.assertGreater(resp['cloud_trunk'], 0)
self.assertGreater(len(resp['network_names']), 0)
def test_single_region(self, _mock_endpoints):
"""
In a single-region setup, a call to get one client must return a list
containing just the single client, and calling them in either order
(the list first then the single, or vise-versa) must result in just a
single call to the create function.
"""
_mock_endpoints.return_value = [{'region': randomidentifier(),
'url': randomurl()}]
#
# Get all clients first, then get just a single client
#
create_func = mock.Mock()
client = RegionClient(randomidentifier(), create_func,
get_mock_token(), randomidentifier())
client_list = list(client.get_clients())
self.assertEqual(1, create_func.call_count)
single_client = client.get_client()
self.assertEqual(1, create_func.call_count)
self.assertEqual(1, len(client_list))
self.assertEqual(single_client, client_list[0])
#
# Get one client first, then get all clients
#
create_func = mock.Mock()
client = RegionClient(randomidentifier(), create_func,
get_mock_token(), randomidentifier())
single_client = client.get_client()
self.assertEqual(1, create_func.call_count)
client_list = list(client.get_clients())
self.assertEqual(1, create_func.call_count)
self.assertEqual(1, len(client_list))
self.assertEqual(single_client, client_list[0])
def _test_get_swift_clusters(self):
request = {
'target': 'catalog',
'data': {
'operation': 'get_swift_clusters'
},
'auth_token': get_mock_token()
}
svc = CatalogSvc(bll_request=BllRequest(request))
data = svc.handle()[api.DATA]
self.assertTrue('ccp:cluster1' in data)
self.assertEqual(len(data['ccp:cluster1']), 4)
self.assertTrue('standard-ccp-c1-m1-mgmt' in data['ccp:cluster1'])
self.assertTrue('some_host' in data['ccp:cluster1'])
def test_service_delete_good_input(self, _mock_nova_client,
_mock_endpoints, _mock_serv_end,
_mock_ks_client):
_mock_nova_client.return_value = self.mock_novaclient
_mock_serv_end.return_value = None
_mock_ks_client.return_value = self.mock_ksclient
_mock_endpoints.return_value = self.mock_get_endpoints
svc = NovaSvc(
BllRequest(auth_token=get_mock_token(),
operation='service-delete',
data={'hostname': 'myhost1'}))
reply = svc.handle()
self.assertEqual(reply[api.STATUS], api.COMPLETE)
def test_service_delete_bad_input(self, _mock_nova_client, _mock_endpoints,
_mock_serv_end, _mock_ks_client):
_mock_nova_client.return_value = self.mock_novaclient
_mock_serv_end.return_value = None
_mock_ks_client.return_value = self.mock_ksclient
_mock_endpoints.return_value = self.mock_get_endpoints
with log_level(logging.CRITICAL, 'bll'):
svc = NovaSvc(
BllRequest(auth_token=get_mock_token(),
operation='service-delete',
data={'hostname': 'badhost'}))
with self.assertRaises(Exception):
svc.handle()
def test_monasca_transform_notavail(self, mock_serv, mock_conf):
mon_comps = None
mock_conf.return_value = mon_comps
mock_serv.return_value = []
request = {
'target': 'catalog',
'data': {
'operation': 'get_plugins'
},
'auth_token': get_mock_token()
}
svc = CatalogSvc(bll_request=BllRequest(request))
data = svc.handle()[api.DATA]
self.assertNotIn('monasca-transform', data)
def _test_get_compute_clusters(self):
request = {
'target': 'catalog',
'data': {
'operation': 'get_compute_clusters'
},
'auth_token': get_mock_token()
}
svc = CatalogSvc(bll_request=BllRequest(request))
data = svc.handle()[api.DATA]
self.assertTrue('ccp:compute' in data)
self.assertEqual(len(data['ccp:compute']), 2)
self.assertTrue('standard-ccp-comp0001-mgmt' in data['ccp:compute'])
self.assertTrue(
'standard-ccp-comp0003-mgmt' not in data['ccp:compute'])
def test_list_baremetal(self, mock_get_token_for_project,
mock_get_service_endpoint, mock_client):
mock_get_token_for_project.return_value = "admin"
mock_get_service_endpoint.return_value = "http://localhost:8070/v2.0"
eonclient_obj = EonClientBaremetal()
mock_client.return_value = eonclient_obj
request = {
api.TARGET: 'baremetal',
api.AUTH_TOKEN: get_mock_token(),
api.ACTION: 'GET',
api.DATA: {
api.OPERATION: 'list_baremetal',
}
}
svc = BaremetalSvc(bll_request=BllRequest(request))
output = svc.list_baremetal()
self.assertEqual(output[0]['name'], 'MyBaremetal')
def test_activate_resource_success_hyperv(self, *_):
body = {
"type": "hyperv",
"network_config": {
"server_group": "RACK1",
"server_role": "KVM-COMPUTE-ROLE"
},
"id": "12345"
}
svc = EONSvc(
BllRequest(operation="activate_resource",
action="POST",
auth_token=get_mock_token(),
data={'data': body}))
svc.handle()
reply = svc.complete()
self.assertEqual(reply[api.STATUS], api.COMPLETE)
def test_get_non_eon_details(self, *_):
svc = compute_service.ComputeSvc(BllRequest(
auth_token=get_mock_token(),
operation='details',
region='region1',
data={
'data': {
'id': '1',
'type': 'kvm'
}
}))
reply = svc.handle()
self.assertEqual(reply['data']['ardana']['server-group'], 'some_group')
self.assertEqual(reply['data']['monasca']['used_cpu_perc'], 123)
self.assertEqual(reply['data']['instances'], 2)
self.assertEqual(reply[api.STATUS], api.COMPLETE)
def test_service_inc_metrics_dimension_prop(self,
_mock_nova_client,
_mock_monasca_client,
_mock_endpoints,
_mock_serv_end,
_mock_ks_client):
_mock_nova_client.return_value = self.mock_novaclient
_mock_serv_end.return_value = None
_mock_ks_client.return_value = self.mock_ksclient
_mock_monasca_client.return_value = self.mock_monasca_client
_mock_endpoints.return_value = self.mock_get_endpoints
req_data = {
api.OPERATION: 'instance-list',
'project_id': self.project_list[0].id,
'monasca_metrics': ['some.metric'],
'monasca_dimensions': {
'resource_id': {
'property': 'tenant_id'
}
},
'monasca_data': {
'operation': 'metric_statistics'
}
}
svc = NovaSvc(BllRequest(auth_token=get_mock_token(),
data=req_data))
reply = svc.handle()
self.assertEqual(reply[api.STATUS], api.COMPLETE)
self.mock_monasca_client.metrics.list_statistics \
.assert_called_with(
name='some.metric',
dimensions={
'resource_id': self.server_list[4].id
}
)
self.assertIn(api.DATA, reply)
data = reply[api.DATA]
self.assertIn('instances', data)
self.assertIsInstance(data['instances'], list)
self.assertTrue(len(data['instances']) > 0)
self.assertIn('metrics', data['instances'][0])
self.assertIn('some.metric', data['instances'][0]['metrics'])
