def test_node_create_with_bad_cluster(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'create', True) body = { 'node': { 'name': 'test_node', 'profile_id': 'xxxx-yyyy-zzzz', 'cluster_id': 'non-existent-cluster', 'role': None, 'metadata': {}, } } req = self._post('/nodes', jsonutils.dumps(body)) error = senlin_exc.ClusterNotFound(cluster='non-existent-cluster') mock_call = self.patchobject(rpc_client.EngineClient, 'call', side_effect=error) resp = shared.request_with_middleware(fault.FaultWrapper, self.controller.create, req, body=body) mock_call.assert_called_once_with(req.context, ('node_create', body['node'])) self.assertEqual(404, resp.json['code']) self.assertEqual('ClusterNotFound', resp.json['error']['type'])
def test_node_action_join_cluster_not_found(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'action', True) node_id = 'test-node-1' cluster_id = 'unknown-cluster' body = { 'join': { 'cluster_id': cluster_id, } } req = self._put('/nodes/%(node_id)s/action' % {'node_id': node_id}, json.dumps(body)) error = senlin_exc.ClusterNotFound(cluster=cluster_id) mock_call = self.patchobject(rpc_client.EngineClient, 'call') mock_call.side_effect = shared.to_remote_error(error) resp = shared.request_with_middleware(fault.FaultWrapper, self.controller.action, req, tenant_id=self.project, node_id=node_id, body=body) self.assertEqual(404, resp.json['code']) self.assertEqual('ClusterNotFound', resp.json['error']['type'])
def test_receiver_create_with_cluster_id_notfound(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'create', True) cluster_id = 'FAKE_ID' body = { 'receiver': { 'name': 'test_receiver', 'type': 'webhook', 'cluster_id': cluster_id, 'action': 'test_action', } } req = self._post('/receivers', jsonutils.dumps(body)) error = senlin_exc.ClusterNotFound(cluster=cluster_id) mock_call = self.patchobject(rpc_client.EngineClient, 'call', side_effect=error) resp = shared.request_with_middleware(fault.FaultWrapper, self.controller.create, req, body=body) expected_args = body['receiver'] type_name = expected_args.pop('type') expected_args['type_name'] = type_name expected_args['actor'] = None expected_args['params'] = None mock_call.assert_called_once_with(req.context, ('receiver_create', expected_args)) self.assertEqual(404, resp.json['code']) self.assertEqual('ClusterNotFound', resp.json['error']['type'])
def test_receiver_create_cluster_not_found(self, mock_find): mock_find.side_effect = exc.ClusterNotFound(cluster='C1') ex = self.assertRaises(rpc.ExpectedException, self.eng.receiver_create, self.ctx, 'r1', 'webhook', 'C1', 'whatever') self.assertEqual(exc.BadRequest, ex.exc_info[0]) self.assertEqual( "The request is malformed: The referenced cluster " "'C1' is not found.", six.text_type(ex.exc_info[1]))
def test_action_create_cluster_not_found(self, mock_find): mock_find.side_effect = exc.ClusterNotFound(cluster='C1') ex = self.assertRaises(rpc.ExpectedException, self.eng.action_create, self.ctx, 'a1', 'C1', 'OBJECT_ACTION') self.assertEqual(exc.ClusterNotFound, ex.exc_info[0]) mock_find.assert_called_once_with(self.ctx, 'C1')
def test_cluster_policy_list_cluster_not_found(self, mock_find): mock_find.side_effect = exc.ClusterNotFound(cluster='Bogus') ex = self.assertRaises(rpc.ExpectedException, self.eng.cluster_policy_list, self.ctx, 'Bogus') self.assertEqual("The cluster (Bogus) could not be found.", six.text_type(ex.exc_info[1]))
def cluster_update(context, cluster_id, values): with session_for_write() as session: cluster = session.query(models.Cluster).get(cluster_id) if not cluster: raise exception.ClusterNotFound(cluster=cluster_id) cluster.update(values) cluster.save(session)
def load(cls, context, cluster_id=None, dbcluster=None, project_safe=True): '''Retrieve a cluster from database.''' if dbcluster is None: dbcluster = co.Cluster.get(context, cluster_id, project_safe=project_safe) if dbcluster is None: raise exception.ClusterNotFound(cluster=cluster_id) return cls._from_object(context, dbcluster)
def load(cls, context, cluster_id=None, cluster=None, project_safe=True): '''Retrieve a cluster from database.''' if cluster is None: cluster = db_api.cluster_get(context, cluster_id, project_safe=project_safe) if cluster is None: raise exception.ClusterNotFound(cluster=cluster_id) return cls._from_db_record(context, cluster)
def load(cls, context, cluster_id=None, cluster=None, show_deleted=False): '''Retrieve a cluster from database.''' if cluster is None: cluster = db_api.cluster_get(context, cluster_id, show_deleted=show_deleted) if cluster is None: raise exception.ClusterNotFound(cluster=cluster_id) return cls._from_db_record(context, cluster)
def test_cluster_policy_detach_cluster_not_found(self, mock_cluster): mock_cluster.side_effect = exc.ClusterNotFound(cluster='Bogus') ex = self.assertRaises(rpc.ExpectedException, self.eng.cluster_policy_detach, self.ctx, 'Bogus', 'POLICY_ID') self.assertEqual(exc.ClusterNotFound, ex.exc_info[0]) self.assertEqual("The cluster (Bogus) could not be found.", six.text_type(ex.exc_info[1])) mock_cluster.assert_called_once_with(self.ctx, 'Bogus')
def test_node_list_cluster_not_found(self, mock_find): mock_find.side_effect = exc.ClusterNotFound(cluster='BOGUS') ex = self.assertRaises(rpc.ExpectedException, self.eng.node_list, self.ctx, cluster_id='BOGUS') self.assertEqual(exc.ClusterNotFound, ex.exc_info[0]) self.assertEqual("The cluster (BOGUS) could not be found.", six.text_type(ex.exc_info[1])) mock_find.assert_called_once_with(self.ctx, 'BOGUS')
def test_webhook_trigger_cluster_not_found(self, mock_cluster, mock_find): receiver = mock.Mock() receiver.cluster_id = 'BOGUS' mock_find.return_value = receiver mock_cluster.side_effect = exception.ClusterNotFound(cluster='BOGUS') ex = self.assertRaises(rpc.ExpectedException, self.eng.webhook_trigger, self.ctx, 'RRR') self.assertEqual(exception.BadRequest, ex.exc_info[0]) self.assertEqual( 'The request is malformed: The referenced cluster ' '(BOGUS) is not found.', six.text_type(ex.exc_info[1])) mock_find.assert_called_once_with(self.ctx, 'RRR') mock_cluster.assert_called_once_with(self.ctx, 'BOGUS')
def test_node_index_cluster_not_found(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'index', True) cluster_id = 'non-existent' req = self._get('/nodes', {'cluster_id': cluster_id}) error = senlin_exc.ClusterNotFound(cluster=cluster_id) self.patchobject(rpc_client.EngineClient, 'call', side_effect=shared.to_remote_error(error)) resp = shared.request_with_middleware(fault.FaultWrapper, self.controller.index, req) self.assertEqual(404, resp.json['code']) self.assertEqual('ClusterNotFound', resp.json['error']['type'])
def test_openstack_exception_with_kwargs(self): wrapper = fault.FaultWrapper(None) msg = wrapper._error(senlin_exc.ClusterNotFound(cluster='a')) expected = { 'code': 404, 'error': { 'code': 404, 'message': 'The cluster (a) could not be found.', 'type': 'ClusterNotFound' }, 'explanation': 'The resource could not be found.', 'title': 'Not Found' } self.assertEqual(expected, msg)
def test_node_create_cluster_not_found(self, mock_profile, mock_cluster): mock_profile.return_value = mock.Mock() mock_cluster.side_effect = exc.ClusterNotFound(cluster='Bogus') ex = self.assertRaises(rpc.ExpectedException, self.eng.node_create, self.ctx, 'node-1', 'FAKE_PROFILE', cluster_id='Bogus') self.assertEqual(exc.BadRequest, ex.exc_info[0]) self.assertEqual( "The request is malformed: The specified cluster " "(Bogus) is not found.", six.text_type(ex.exc_info[1])) mock_profile.assert_called_once_with(self.ctx, 'FAKE_PROFILE') mock_cluster.assert_called_once_with(self.ctx, 'Bogus')
def cluster_delete(context, cluster_id): with session_for_write() as session: cluster = session.query(models.Cluster).get(cluster_id) if cluster is None: raise exception.ClusterNotFound(cluster=cluster_id) query = session.query(models.Node).filter_by(cluster_id=cluster_id) nodes = query.all() if len(nodes) != 0: for node in nodes: session.delete(node) # Delete all related cluster_policies records for cp in cluster.policies: session.delete(cp) # Delete cluster session.delete(cluster)
def test_remote_exception(self): cfg.CONF.set_override('debug', True, enforce_type=True) error = senlin_exc.ClusterNotFound(cluster='a') exc_info = (type(error), error, None) serialized = rpc_common.serialize_remote_exception(exc_info) remote_error = rpc_common.deserialize_remote_exception( serialized, ["senlin.common.exception"]) wrapper = fault.FaultWrapper(None) msg = wrapper._error(remote_error) expected_message = six.text_type(remote_error).split('\n', 1)[0] expected = { 'code': 404, 'error': { 'code': 404, 'message': expected_message, 'type': 'ClusterNotFound' }, 'explanation': 'The resource could not be found.', 'title': 'Not Found' } self.assertEqual(expected, msg)
def test_webhook_create_with_obj_id_notfound(self, mock_enforce): self._mock_enforce_setup(mock_enforce, 'create', True) obj_id = 'false_obj_id' body = { 'webhook': { 'name': 'test_webhook', 'obj_type': 'cluster', 'obj_id': obj_id, 'action': 'test_action', 'credential': { 'user_id': 'test_user_id', 'password': '******', }, 'params': { 'test_param': 'test_value' }, } } req = self._post('/webhooks', json.dumps(body)) error = senlin_exc.ClusterNotFound(cluster=obj_id) mock_call = self.patchobject(rpc_client.EngineClient, 'call', side_effect=error) resp = shared.request_with_middleware(fault.FaultWrapper, self.controller.create, req, tenant_id=self.project, body=body) expected_args = body['webhook'] mock_call.assert_called_once_with(req.context, ('webhook_create', expected_args)) self.assertEqual(404, resp.json['code']) self.assertEqual('ClusterNotFound', resp.json['error']['type']) self.assertIsNone(resp.json['error']['traceback'])