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'])