From 5c6f3000e3a5486b03977719161fc9e430a51ffa Mon Sep 17 00:00:00 2001 From: "Jay Lau (Guangya Liu)" Date: Mon, 5 Jan 2015 21:18:34 -0500 Subject: [PATCH] Add more unit test for replication controller Change-Id: Icf7251c9abc3b9b92c9e2c38506c49ea9de03bf7 --- magnum/db/api.py | 8 + magnum/db/sqlalchemy/api.py | 38 +++- magnum/tests/db/test_replicationcontroller.py | 171 ++++++++++++++++++ 3 files changed, 209 insertions(+), 8 deletions(-) create mode 100644 magnum/tests/db/test_replicationcontroller.py diff --git a/magnum/db/api.py b/magnum/db/api.py index 12ed45f467..69c0b29de3 100644 --- a/magnum/db/api.py +++ b/magnum/db/api.py @@ -521,6 +521,14 @@ class Connection(object): :returns: A list of tuples of the specified columns. """ + @abc.abstractmethod + def get_rcs_by_bay_uuid(self, bay_uuid): + """List all the ReplicationControllers for a given bay. + + :param bay_uuid: The uuid of a bay. + :returns: A list of ReplicationControllers. + """ + @abc.abstractmethod def create_rc(self, values): """Create a new ReplicationController. diff --git a/magnum/db/sqlalchemy/api.py b/magnum/db/sqlalchemy/api.py index 940e5bb6f1..c6d1dbb092 100644 --- a/magnum/db/sqlalchemy/api.py +++ b/magnum/db/sqlalchemy/api.py @@ -845,16 +845,28 @@ class Connection(api.Connection): if filters is None: filters = [] - if 'associated' in filters: - if filters['associated']: - query = query.filter( - models.ReplicationController.instance_uuid is not None) - else: - query = query.filter( - models.ReplicationController.instance_uuid is None) + if 'bay_uuid' in filters: + query = query.filter_by(bay_uuid=filters['bay_uuid']) + if 'name' in filters: + query = query.filter_by(name=filters['name']) + if 'replicas' in filters: + query = query.filter_by(replicas=filters['replicas']) return query + def get_rcinfo_list(self, columns=None, filters=None, limit=None, + marker=None, sort_key=None, sort_dir=None): + if columns is None: + columns = [models.ReplicationController.id] + else: + columns = [getattr(models.ReplicationController, c) + for c in columns] + + query = model_query(*columns, base_model=models.ReplicationController) + query = self._add_rcs_filters(query, filters) + return _paginate_query(models.ReplicationController, limit, marker, + sort_key, sort_dir, query) + def get_rc_list(self, filters=None, limit=None, marker=None, sort_key=None, sort_dir=None): query = model_query(models.ReplicationController) @@ -895,6 +907,14 @@ class Connection(api.Connection): except NoResultFound: raise exception.ReplicationControllerNotFound(rc=rc_uuid) + def get_rcs_by_bay_uuid(self, bay_uuid): + query = model_query(models.ReplicationController).filter_by( + bay_uuid=bay_uuid) + try: + return query.all() + except NoResultFound: + raise exception.ReplicationControllerNotFound(bay=bay_uuid) + def get_rc_by_name(self, rc_name): query = model_query(models.ReplicationController).filter_by( name=rc_name) @@ -908,7 +928,9 @@ class Connection(api.Connection): with session.begin(): query = model_query(models.ReplicationController, session=session) query = add_identity_filter(query, rc_id) - query.delete() + count = query.delete() + if count != 1: + raise exception.ReplicationControllerNotFound(rc_id) def update_rc(self, rc_id, values): if 'uuid' in values: diff --git a/magnum/tests/db/test_replicationcontroller.py b/magnum/tests/db/test_replicationcontroller.py new file mode 100644 index 0000000000..1b84522941 --- /dev/null +++ b/magnum/tests/db/test_replicationcontroller.py @@ -0,0 +1,171 @@ +# Copyright 2015 OpenStack Foundation +# All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +"""Tests for manipulating Services via the DB API""" + +import six + +from magnum.common import exception +from magnum.common import utils as magnum_utils +from magnum.tests.db import base +from magnum.tests.db import utils as utils + + +class DbRCTestCase(base.DbTestCase): + + def setUp(self): + # This method creates a replication controller for every test and + # replaces a test for creating a replication controller. + super(DbRCTestCase, self).setUp() + self.bay = utils.create_test_bay() + self.rc = utils.create_test_rc(bay_uuid=self.bay.uuid) + + def test_create_rc_duplicated_uuid(self): + self.assertRaises(exception.ReplicationControllerAlreadyExists, + utils.create_test_rc, + uuid=self.rc.uuid, + bay_uuid=self.bay.uuid) + + def test_get_rc_by_id(self): + rc = self.dbapi.get_rc_by_id(self.rc.id) + self.assertEqual(self.rc.id, rc.id) + self.assertEqual(self.rc.uuid, rc.uuid) + + def test_get_rc_by_uuid(self): + rc = self.dbapi.get_rc_by_uuid(self.rc.uuid) + self.assertEqual(self.rc.id, rc.id) + self.assertEqual(self.rc.uuid, rc.uuid) + + def test_get_rc_that_does_not_exist(self): + self.assertRaises(exception.ReplicationControllerNotFound, + self.dbapi.get_rc_by_id, 999) + self.assertRaises(exception.ReplicationControllerNotFound, + self.dbapi.get_rc_by_uuid, + magnum_utils.generate_uuid()) + + def test_get_rc_list_defaults(self): + rc_id_list = [self.rc.id] + for i in range(1, 6): + rc = utils.create_test_rc(bay_uuid=self.bay.uuid, + uuid=magnum_utils.generate_uuid()) + rc_id_list.append(rc.id) + rc = [i[0] for i in self.dbapi.get_rcinfo_list()] + self.assertEqual(sorted(rc), sorted(rc_id_list)) + + def test_get_rcinfo_list_with_cols(self): + uuids = {self.rc.id: self.rc.uuid} + rc_replicas = {self.rc.id: self.rc.replicas} + for i in range(1, 6): + uuid = magnum_utils.generate_uuid() + replicas = i + rc = utils.create_test_rc(replicas=replicas, uuid=uuid, + bay_uuid=self.bay.uuid) + uuids[rc.id] = uuid + rc_replicas[rc.id] = replicas + rc = self.dbapi.get_rcinfo_list(columns=['id', 'uuid', 'replicas']) + self.assertEqual(uuids, dict((r[0], r[1]) for r in rc)) + self.assertEqual(rc_replicas, dict((r[0], r[2]) for r in rc)) + + def test_get_rcinfo_list_with_filters(self): + bay1 = utils.get_test_bay(id=11, uuid=magnum_utils.generate_uuid()) + bay2 = utils.get_test_bay(id=12, uuid=magnum_utils.generate_uuid()) + + self.dbapi.create_bay(bay1) + self.dbapi.create_bay(bay2) + + rc1 = utils.create_test_rc(name='rc-one', + uuid=magnum_utils.generate_uuid(), + bay_uuid=bay1['uuid'], + replicas=2) + rc2 = utils.create_test_rc(name='rc-two', + uuid=magnum_utils.generate_uuid(), + bay_uuid=bay2['uuid'], + replicas=3) + + rc = self.dbapi.get_rcinfo_list( + filters={'bay_uuid': bay1['uuid']}) + self.assertEqual([rc1.id], [r.id for r in rc]) + + rc = self.dbapi.get_rcinfo_list( + filters={'bay_uuid': bay2['uuid']}) + self.assertEqual([rc2.id], [r.id for r in rc]) + + rc = self.dbapi.get_rcinfo_list(filters={'name': 'rc-one'}) + self.assertEqual([rc1.id], [r[0] for r in rc]) + + rc = self.dbapi.get_rcinfo_list(filters={'name': 'bad-rc'}) + self.assertEqual([], [r[0] for r in rc]) + + rc = self.dbapi.get_rcinfo_list(filters={'replicas': 2}) + self.assertEqual([rc1.id], [r[0] for r in rc]) + + def test_get_rc_list(self): + uuids = [self.rc.uuid] + for i in range(1, 6): + rc = utils.create_test_rc(bay_uuid=self.bay.uuid, + uuid=magnum_utils.generate_uuid()) + uuids.append(six.text_type(rc.uuid)) + rc = self.dbapi.get_rc_list() + rc_uuids = [r.uuid for r in rc] + self.assertEqual(sorted(uuids), sorted(rc_uuids)) + + def test_get_rc_list_bay_not_exist(self): + rc = self.dbapi.get_rc_list({'bay_uuid': self.bay.uuid}) + self.assertEqual(1, len(rc)) + rc = self.dbapi.get_rc_list({ + 'bay_uuid': magnum_utils.generate_uuid()}) + self.assertEqual(0, len(rc)) + + def test_get_rcs_by_bay_uuid(self): + rc = self.dbapi.get_rcs_by_bay_uuid(self.bay.uuid) + self.assertEqual(self.rc.id, rc[0].id) + + def test_get_rcs_by_bay_uuid_that_does_not_exist(self): + res = self.dbapi.get_rcs_by_bay_uuid(magnum_utils.generate_uuid()) + self.assertEqual([], res) + + def test_destroy_rc(self): + self.dbapi.destroy_rc(self.rc.id) + self.assertRaises(exception.ReplicationControllerNotFound, + self.dbapi.get_rc_by_id, self.rc.id) + + def test_destroy_rc_by_uuid(self): + self.assertIsNotNone(self.dbapi.get_rc_by_uuid(self.rc.uuid)) + self.dbapi.destroy_rc(self.rc.uuid) + self.assertRaises(exception.ReplicationControllerNotFound, + self.dbapi.get_rc_by_uuid, self.rc.uuid) + + def test_destroy_rc_that_does_not_exist(self): + self.assertRaises(exception.ReplicationControllerNotFound, + self.dbapi.destroy_rc, + magnum_utils.generate_uuid()) + + def test_update_rc(self): + old_name = self.rc.name + new_name = 'new-rc' + self.assertNotEqual(old_name, new_name) + res = self.dbapi.update_rc(self.rc.id, {'name': new_name}) + self.assertEqual(new_name, res.name) + + def test_update_rc_not_found(self): + rc_uuid = magnum_utils.generate_uuid() + self.assertRaises(exception.ReplicationControllerNotFound, + self.dbapi.update_rc, + rc_uuid, {'replica': 4}) + + def test_update_rc_uuid(self): + self.assertRaises(exception.InvalidParameterValue, + self.dbapi.update_rc, self.rc.id, + {'uuid': ''})