diff --git a/neutron/db/flavors_db.py b/neutron/db/flavors_db.py index 6f47348d0ad..0b075485901 100644 --- a/neutron/db/flavors_db.py +++ b/neutron/db/flavors_db.py @@ -14,8 +14,6 @@ from oslo_db import exception as db_exc from oslo_log import log as logging -from oslo_utils import uuidutils -from sqlalchemy.orm import exc as sa_exc from neutron.common import _deprecate from neutron.db import _utils as db_utils @@ -24,6 +22,8 @@ from neutron.db import common_db_mixin from neutron.db.models import flavor as flavor_models from neutron.db import servicetype_db as sdb from neutron.extensions import flavors as ext_flavors +from neutron.objects import base as base_obj +from neutron.objects import flavor as obj_flavor _deprecate._moved_global('Flavor', new_module=flavor_models) _deprecate._moved_global('ServiceProfile', new_module=flavor_models) @@ -39,41 +39,37 @@ class FlavorsDbMixin(common_db_mixin.CommonDbMixin): """Class to support flavors and service profiles.""" def _get_flavor(self, context, flavor_id): - try: - return self._get_by_id(context, flavor_models.Flavor, flavor_id) - except sa_exc.NoResultFound: + flavor = obj_flavor.Flavor.get_object(context, id=flavor_id) + if not flavor: raise ext_flavors.FlavorNotFound(flavor_id=flavor_id) + return flavor def _get_service_profile(self, context, sp_id): - try: - return self._get_by_id( - context, flavor_models.ServiceProfile, sp_id) - except sa_exc.NoResultFound: + service_profile = obj_flavor.ServiceProfile.get_object( + context, id=sp_id) + if not service_profile: raise ext_flavors.ServiceProfileNotFound(sp_id=sp_id) + return service_profile @staticmethod - def _make_flavor_dict(flavor_db, fields=None): - res = {'id': flavor_db['id'], - 'name': flavor_db['name'], - 'description': flavor_db['description'], - 'service_type': flavor_db['service_type'], - 'enabled': flavor_db['enabled'], - 'service_profiles': []} - if flavor_db.service_profiles: - res['service_profiles'] = [sp['service_profile_id'] - for sp in flavor_db.service_profiles] + def _make_flavor_dict(flavor_obj, fields=None): + res = {'id': flavor_obj['id'], + 'name': flavor_obj['name'], + 'description': flavor_obj['description'], + 'service_type': flavor_obj['service_type'], + 'enabled': flavor_obj['enabled'], + 'service_profiles': list(flavor_obj['service_profile_ids'])} + return db_utils.resource_fields(res, fields) @staticmethod - def _make_service_profile_dict(sp_db, fields=None): - res = {'id': sp_db['id'], - 'description': sp_db['description'], - 'driver': sp_db['driver'], - 'enabled': sp_db['enabled'], - 'metainfo': sp_db['metainfo']} - if sp_db.flavors: - res['flavors'] = [fl['flavor_id'] - for fl in sp_db.flavors] + def _make_service_profile_dict(sp_obj, fields=None): + res = {'id': sp_obj['id'], + 'description': sp_obj['description'], + 'driver': sp_obj['driver'], + 'enabled': sp_obj['enabled'], + 'metainfo': sp_obj['metainfo'], + 'flavors': list(sp_obj['flavor_ids'])} return db_utils.resource_fields(res, fields) def _ensure_flavor_not_in_use(self, context, flavor_id): @@ -89,9 +85,8 @@ class FlavorsDbMixin(common_db_mixin.CommonDbMixin): def _ensure_service_profile_not_in_use(self, context, sp_id): """Ensures no current bindings to flavors exist.""" - fl = (context.session.query(flavor_models.FlavorServiceProfileBinding). - filter_by(service_profile_id=sp_id).first()) - if fl: + if obj_flavor.FlavorServiceProfileBinding.objects_exist( + context, service_profile_id=sp_id): raise ext_flavors.ServiceProfileInUse(sp_id=sp_id) def _validate_driver(self, context, driver): @@ -106,22 +101,19 @@ class FlavorsDbMixin(common_db_mixin.CommonDbMixin): def create_flavor(self, context, flavor): fl = flavor['flavor'] - with db_api.context_manager.writer.using(context): - fl_db = flavor_models.Flavor(id=uuidutils.generate_uuid(), - name=fl['name'], - description=fl['description'], - service_type=fl['service_type'], - enabled=fl['enabled']) - context.session.add(fl_db) - return self._make_flavor_dict(fl_db) + obj = obj_flavor.Flavor( + context, name=fl['name'], description=fl['description'], + service_type=fl['service_type'], enabled=fl['enabled']) + obj.create() + return self._make_flavor_dict(obj) def update_flavor(self, context, flavor_id, flavor): - fl = flavor['flavor'] with db_api.context_manager.writer.using(context): self._ensure_flavor_not_in_use(context, flavor_id) - fl_db = self._get_flavor(context, flavor_id) - fl_db.update(fl) - return self._make_flavor_dict(fl_db) + fl_obj = self._get_flavor(context, flavor_id) + fl_obj.update_fields(flavor['flavor']) + fl_obj.update() + return self._make_flavor_dict(fl_obj) def get_flavor(self, context, flavor_id, fields=None): fl = self._get_flavor(context, flavor_id) @@ -135,65 +127,49 @@ class FlavorsDbMixin(common_db_mixin.CommonDbMixin): try: with db_api.context_manager.writer.using(context): self._ensure_flavor_not_in_use(context, flavor_id) - fl_db = self._get_flavor(context, flavor_id) - context.session.delete(fl_db) + self._get_flavor(context, flavor_id).delete() except db_exc.DBReferenceError: raise ext_flavors.FlavorInUse(flavor_id=flavor_id) def get_flavors(self, context, filters=None, fields=None, sorts=None, limit=None, marker=None, page_reverse=False): - return self._get_collection(context, flavor_models.Flavor, - self._make_flavor_dict, - filters=filters, fields=fields, - sorts=sorts, limit=limit, - marker_obj=marker, - page_reverse=page_reverse) + pager = base_obj.Pager(sorts, limit, page_reverse, marker) + filters = filters or {} + flavor_objs = obj_flavor.Flavor.get_objects(context, _pager=pager, + **filters) + return [self._make_flavor_dict(flavor_object, fields) + for flavor_object in flavor_objs] def create_flavor_service_profile(self, context, service_profile, flavor_id): sp = service_profile['service_profile'] with db_api.context_manager.writer.using(context): - bind_qry = context.session.query( - flavor_models.FlavorServiceProfileBinding) - binding = bind_qry.filter_by(service_profile_id=sp['id'], - flavor_id=flavor_id).first() - if binding: + if obj_flavor.FlavorServiceProfileBinding.objects_exist( + context, service_profile_id=sp['id'], flavor_id=flavor_id): raise ext_flavors.FlavorServiceProfileBindingExists( sp_id=sp['id'], fl_id=flavor_id) - binding = flavor_models.FlavorServiceProfileBinding( - service_profile_id=sp['id'], - flavor_id=flavor_id) - context.session.add(binding) - fl_db = self._get_flavor(context, flavor_id) - return self._make_flavor_dict(fl_db) + obj_flavor.FlavorServiceProfileBinding( + context, service_profile_id=sp['id'], + flavor_id=flavor_id).create() + fl_obj = self._get_flavor(context, flavor_id) + return self._make_flavor_dict(fl_obj) def delete_flavor_service_profile(self, context, service_profile_id, flavor_id): - with db_api.context_manager.writer.using(context): - binding = ( - context.session.query( - flavor_models.FlavorServiceProfileBinding). - filter_by(service_profile_id=service_profile_id, - flavor_id=flavor_id). - first()) - if not binding: - raise ext_flavors.FlavorServiceProfileBindingNotFound( - sp_id=service_profile_id, fl_id=flavor_id) - context.session.delete(binding) + if (obj_flavor.FlavorServiceProfileBinding.delete_objects( + context, service_profile_id=service_profile_id, + flavor_id=flavor_id) == 0): + raise ext_flavors.FlavorServiceProfileBindingNotFound( + sp_id=service_profile_id, fl_id=flavor_id) @staticmethod def get_flavor_service_profile(context, service_profile_id, flavor_id, fields=None): - with db_api.context_manager.reader.using(context): - binding = ( - context.session.query( - flavor_models.FlavorServiceProfileBinding). - filter_by(service_profile_id=service_profile_id, - flavor_id=flavor_id). - first()) - if not binding: - raise ext_flavors.FlavorServiceProfileBindingNotFound( - sp_id=service_profile_id, fl_id=flavor_id) + if not obj_flavor.FlavorServiceProfileBinding.objects_exist( + context, service_profile_id=service_profile_id, + flavor_id=flavor_id): + raise ext_flavors.FlavorServiceProfileBindingNotFound( + sp_id=service_profile_id, fl_id=flavor_id) res = {'service_profile_id': service_profile_id, 'flavor_id': flavor_id} return db_utils.resource_fields(res, fields) @@ -207,14 +183,11 @@ class FlavorsDbMixin(common_db_mixin.CommonDbMixin): if not sp['metainfo']: raise ext_flavors.ServiceProfileEmpty() - with db_api.context_manager.writer.using(context): - sp_db = flavor_models.ServiceProfile(id=uuidutils.generate_uuid(), - description=sp['description'], - driver=sp['driver'], - enabled=sp['enabled'], - metainfo=sp['metainfo']) - context.session.add(sp_db) - return self._make_service_profile_dict(sp_db) + obj = obj_flavor.ServiceProfile( + context, description=sp['description'], driver=sp['driver'], + enabled=sp['enabled'], metainfo=sp['metainfo']) + obj.create() + return self._make_service_profile_dict(obj) def update_service_profile(self, context, service_profile_id, service_profile): @@ -226,9 +199,10 @@ class FlavorsDbMixin(common_db_mixin.CommonDbMixin): with db_api.context_manager.writer.using(context): self._ensure_service_profile_not_in_use(context, service_profile_id) - sp_db = self._get_service_profile(context, service_profile_id) - sp_db.update(sp) - return self._make_service_profile_dict(sp_db) + sp_obj = self._get_service_profile(context, service_profile_id) + sp_obj.update_fields(sp) + sp_obj.update() + return self._make_service_profile_dict(sp_obj) def get_service_profile(self, context, sp_id, fields=None): sp_db = self._get_service_profile(context, sp_id) @@ -237,18 +211,17 @@ class FlavorsDbMixin(common_db_mixin.CommonDbMixin): def delete_service_profile(self, context, sp_id): with db_api.context_manager.writer.using(context): self._ensure_service_profile_not_in_use(context, sp_id) - sp_db = self._get_service_profile(context, sp_id) - context.session.delete(sp_db) + self._get_service_profile(context, sp_id).delete() def get_service_profiles(self, context, filters=None, fields=None, sorts=None, limit=None, marker=None, page_reverse=False): - return self._get_collection(context, flavor_models.ServiceProfile, - self._make_service_profile_dict, - filters=filters, fields=fields, - sorts=sorts, limit=limit, - marker_obj=marker, - page_reverse=page_reverse) + pager = base_obj.Pager(sorts, limit, page_reverse, marker) + filters = filters or {} + sp_objs = obj_flavor.ServiceProfile.get_objects(context, _pager=pager, + **filters) + return [self._make_service_profile_dict(sp_obj, fields) + for sp_obj in sp_objs] def get_flavor_next_provider(self, context, flavor_id, filters=None, fields=None, @@ -256,35 +229,32 @@ class FlavorsDbMixin(common_db_mixin.CommonDbMixin): marker=None, page_reverse=False): """From flavor, choose service profile and find provider for driver.""" - with db_api.context_manager.reader.using(context): - bind_qry = context.session.query( - flavor_models.FlavorServiceProfileBinding) - binding = bind_qry.filter_by(flavor_id=flavor_id).first() - if not binding: - raise ext_flavors.FlavorServiceProfileBindingNotFound( - sp_id='', fl_id=flavor_id) - + objs = obj_flavor.FlavorServiceProfileBinding.get_objects(context, + flavor_id=flavor_id) + if not objs: + raise ext_flavors.FlavorServiceProfileBindingNotFound( + sp_id='', fl_id=flavor_id) # Get the service profile from the first binding # TODO(jwarendt) Should become a scheduling framework instead - sp_db = self._get_service_profile(context, - binding['service_profile_id']) + sp_obj = self._get_service_profile(context, objs[0].service_profile_id) - if not sp_db.enabled: + if not sp_obj.enabled: raise ext_flavors.ServiceProfileDisabled() - LOG.debug("Found driver %s.", sp_db.driver) + LOG.debug("Found driver %s.", sp_obj.driver) service_type_manager = sdb.ServiceTypeManager.get_instance() providers = service_type_manager.get_service_providers( context, - filters={'driver': sp_db.driver}) + filters={'driver': sp_obj.driver}) if not providers: - raise ext_flavors.ServiceProfileDriverNotFound(driver=sp_db.driver) + raise ext_flavors.ServiceProfileDriverNotFound( + driver=sp_obj.driver) LOG.debug("Found providers %s.", providers) - res = {'driver': sp_db.driver, + res = {'driver': sp_obj.driver, 'provider': providers[0].get('name')} return [db_utils.resource_fields(res, fields)] diff --git a/neutron/objects/flavor.py b/neutron/objects/flavor.py new file mode 100644 index 00000000000..b0f539000a5 --- /dev/null +++ b/neutron/objects/flavor.py @@ -0,0 +1,97 @@ +# Copyright (c) 2016 Intel Corporation. +# 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. + +from oslo_versionedobjects import base as obj_base +from oslo_versionedobjects import fields as obj_fields + +from neutron.db.models import flavor as models +from neutron.objects import base +from neutron.objects import common_types + + +@obj_base.VersionedObjectRegistry.register +class FlavorServiceProfileBinding(base.NeutronDbObject): + # Version 1.0: Initial version + VERSION = '1.0' + + db_model = models.FlavorServiceProfileBinding + + primary_keys = ['flavor_id', 'service_profile_id'] + + fields = { + 'flavor_id': common_types.UUIDField(), + 'service_profile_id': common_types.UUIDField(), + } + + +@obj_base.VersionedObjectRegistry.register +class ServiceProfile(base.NeutronDbObject): + # Version 1.0: Initial version + VERSION = '1.0' + + db_model = models.ServiceProfile + + synthetic_fields = ['flavor_ids'] + + fields = { + 'id': common_types.UUIDField(), + 'description': obj_fields.StringField(nullable=True), + 'driver': obj_fields.StringField(), + 'enabled': obj_fields.BooleanField(default=True), + 'metainfo': obj_fields.StringField(nullable=True), + 'flavor_ids': common_types.SetOfUUIDsField(nullable=True, default=None) + } + + def from_db_object(self, db_obj): + super(ServiceProfile, self).from_db_object(db_obj) + if db_obj.get('flavors', []): + self.flavor_ids = { + fl.flavor_id + for fl in db_obj.flavors + } + else: + self.flavor_ids = set() + self.obj_reset_changes(['flavor_ids']) + + +@obj_base.VersionedObjectRegistry.register +class Flavor(base.NeutronDbObject): + # Version 1.0: Initial version + VERSION = '1.0' + + db_model = models.Flavor + + synthetic_fields = ['service_profile_ids'] + + fields = { + 'id': common_types.UUIDField(), + 'name': obj_fields.StringField(nullable=True), + 'description': obj_fields.StringField(nullable=True), + 'enabled': obj_fields.BooleanField(default=True), + 'service_type': obj_fields.StringField(nullable=True), + 'service_profile_ids': common_types.SetOfUUIDsField(nullable=True, + default=None) + } + + def from_db_object(self, db_obj): + super(Flavor, self).from_db_object(db_obj) + if db_obj.get('service_profiles', []): + self.service_profile_ids = { + sp.service_profile_id + for sp in db_obj.service_profiles + } + else: + self.service_profile_ids = set() + self.obj_reset_changes(['service_profile_ids']) diff --git a/neutron/tests/unit/extensions/test_flavors.py b/neutron/tests/unit/extensions/test_flavors.py index 06951b1aa9d..2336ad5c0fd 100644 --- a/neutron/tests/unit/extensions/test_flavors.py +++ b/neutron/tests/unit/extensions/test_flavors.py @@ -24,10 +24,10 @@ from webob import exc from neutron import context from neutron.db import api as dbapi -from neutron.db.models import flavor as flavor_models from neutron.db.models import l3 as l3_models from neutron.db import servicetype_db from neutron.extensions import flavors +from neutron.objects import flavor as flavor_obj from neutron.plugins.common import constants from neutron.services.flavors import flavors_plugin from neutron.services import provider_configuration as provconf @@ -409,10 +409,6 @@ class FlavorExtensionTestCase(extension.ExtensionTestCase): status=exc.HTTPBadRequest.code) -class DummyCorePlugin(object): - pass - - class DummyServicePlugin(object): def driver_loaded(self, driver, service_profile): @@ -442,9 +438,6 @@ class FlavorPluginTestCase(test_db_base_plugin_v2.NeutronDbPluginV2TestCase, super(FlavorPluginTestCase, self).setUp() self.config_parse() - cfg.CONF.set_override( - 'core_plugin', - 'neutron.tests.unit.extensions.test_flavors.DummyCorePlugin') cfg.CONF.set_override( 'service_plugins', ['neutron.tests.unit.extensions.test_flavors.DummyServicePlugin']) @@ -476,7 +469,7 @@ class FlavorPluginTestCase(test_db_base_plugin_v2.NeutronDbPluginV2TestCase, def test_create_flavor(self): self._create_flavor() - res = self.ctx.session.query(flavor_models.Flavor).all() + res = flavor_obj.Flavor.get_objects(self.ctx) self.assertEqual(1, len(res)) self.assertEqual('GOLD', res[0]['name']) self.assertEqual(constants.DUMMY, res[0]['service_type']) @@ -486,19 +479,17 @@ class FlavorPluginTestCase(test_db_base_plugin_v2.NeutronDbPluginV2TestCase, flavor = {'flavor': {'name': 'Silver', 'enabled': False}} self.plugin.update_flavor(self.ctx, fl['id'], flavor) - res = (self.ctx.session.query(flavor_models.Flavor). - filter_by(id=fl['id']).one()) + res = flavor_obj.Flavor.get_object(self.ctx, id=fl['id']) self.assertEqual('Silver', res['name']) self.assertFalse(res['enabled']) def test_delete_flavor(self): - fl, data = self._create_flavor() + fl, _ = self._create_flavor() self.plugin.delete_flavor(self.ctx, fl['id']) - res = (self.ctx.session.query(flavor_models.Flavor).all()) - self.assertFalse(res) + self.assertFalse(flavor_obj.Flavor.objects_exist(self.ctx)) def test_show_flavor(self): - fl, data = self._create_flavor() + fl, _ = self._create_flavor() show_fl = self.plugin.get_flavor(self.ctx, fl['id']) self.assertEqual(fl, show_fl) @@ -521,10 +512,10 @@ class FlavorPluginTestCase(test_db_base_plugin_v2.NeutronDbPluginV2TestCase, def test_create_service_profile(self): sp, data = self._create_service_profile() - res = (self.ctx.session.query(flavor_models.ServiceProfile). - filter_by(id=sp['id']).one()) - self.assertEqual(data['service_profile']['driver'], res['driver']) - self.assertEqual(data['service_profile']['metainfo'], res['metainfo']) + res = flavor_obj.ServiceProfile.get_object(self.ctx, id=sp['id']) + self.assertIsNotNone(res) + self.assertEqual(data['service_profile']['driver'], res.driver) + self.assertEqual(data['service_profile']['metainfo'], res.metainfo) def test_create_service_profile_empty_driver(self): data = {'service_profile': @@ -534,10 +525,10 @@ class FlavorPluginTestCase(test_db_base_plugin_v2.NeutronDbPluginV2TestCase, 'metainfo': '{"data": "value"}'}} sp = self.plugin.create_service_profile(self.ctx, data) - res = (self.ctx.session.query(flavor_models.ServiceProfile). - filter_by(id=sp['id']).one()) - self.assertEqual(data['service_profile']['driver'], res['driver']) - self.assertEqual(data['service_profile']['metainfo'], res['metainfo']) + res = flavor_obj.ServiceProfile.get_object(self.ctx, id=sp['id']) + self.assertIsNotNone(res) + self.assertEqual(data['service_profile']['driver'], res.driver) + self.assertEqual(data['service_profile']['metainfo'], res.metainfo) def test_create_service_profile_invalid_driver(self): data = {'service_profile': @@ -566,14 +557,13 @@ class FlavorPluginTestCase(test_db_base_plugin_v2.NeutronDbPluginV2TestCase, data['service_profile']['metainfo'] = '{"data": "value1"}' sp = self.plugin.update_service_profile(self.ctx, sp['id'], data) - res = (self.ctx.session.query(flavor_models.ServiceProfile). - filter_by(id=sp['id']).one()) + res = flavor_obj.ServiceProfile.get_object(self.ctx, id=sp['id']) self.assertEqual(data['service_profile']['metainfo'], res['metainfo']) def test_delete_service_profile(self): sp, data = self._create_service_profile() self.plugin.delete_service_profile(self.ctx, sp['id']) - res = self.ctx.session.query(flavor_models.ServiceProfile).all() + res = flavor_obj.ServiceProfile.get_objects(self.ctx) self.assertFalse(res) def test_show_service_profile(self): @@ -593,9 +583,8 @@ class FlavorPluginTestCase(test_db_base_plugin_v2.NeutronDbPluginV2TestCase, self.ctx, {'service_profile': {'id': sp['id']}}, fl['id']) - binding = ( - self.ctx.session.query(flavor_models.FlavorServiceProfileBinding). - first()) + binding = flavor_obj.FlavorServiceProfileBinding.get_objects( + self.ctx)[0] self.assertEqual(fl['id'], binding['flavor_id']) self.assertEqual(sp['id'], binding['service_profile_id']) @@ -615,10 +604,8 @@ class FlavorPluginTestCase(test_db_base_plugin_v2.NeutronDbPluginV2TestCase, {'service_profile': {'id': sp['id']}}, fl['id']) self.plugin.delete_flavor(self.ctx, fl['id']) - binding = ( - self.ctx.session.query(flavor_models.FlavorServiceProfileBinding). - first()) - self.assertIsNone(binding) + self.assertFalse( + flavor_obj.FlavorServiceProfileBinding.objects_exist(self.ctx)) def test_associate_service_profile_with_flavor_exists(self): sp, data = self._create_service_profile() @@ -642,10 +629,9 @@ class FlavorPluginTestCase(test_db_base_plugin_v2.NeutronDbPluginV2TestCase, fl['id']) self.plugin.delete_flavor_service_profile( self.ctx, sp['id'], fl['id']) - binding = ( - self.ctx.session.query(flavor_models.FlavorServiceProfileBinding). - first()) - self.assertIsNone(binding) + + self.assertFalse( + flavor_obj.FlavorServiceProfileBinding.objects_exist(self.ctx)) self.assertRaises( flavors.FlavorServiceProfileBindingNotFound, diff --git a/neutron/tests/unit/objects/test_base.py b/neutron/tests/unit/objects/test_base.py index a3af98892e5..408fbc1552d 100644 --- a/neutron/tests/unit/objects/test_base.py +++ b/neutron/tests/unit/objects/test_base.py @@ -40,6 +40,7 @@ from neutron.objects import base from neutron.objects import common_types from neutron.objects.db import api as obj_db_api from neutron.objects import exceptions as o_exc +from neutron.objects import flavor from neutron.objects import network as net_obj from neutron.objects import ports from neutron.objects import rbac_db @@ -1335,6 +1336,18 @@ class BaseDbObjectTestCase(_BaseObjectTestCase, self.assertEqual( model.standard_attr_id, retrieved_obj.standard_attr_id) + def _create_test_flavor(self): + attrs = self.get_random_object_fields(obj_cls=flavor.Flavor) + self._flavor = flavor.Flavor(self.context, **attrs) + self._flavor.create() + return self._flavor + + def _create_test_service_profile(self): + attrs = self.get_random_object_fields(obj_cls=flavor.ServiceProfile) + self._service_profile = flavor.ServiceProfile(self.context, **attrs) + self._service_profile.create() + return self._service_profile + def _make_object(self, fields): fields = get_non_synthetic_fields(self._test_class, fields) return self._test_class(self.context, diff --git a/neutron/tests/unit/objects/test_flavor.py b/neutron/tests/unit/objects/test_flavor.py new file mode 100644 index 00000000000..7c507ac01f9 --- /dev/null +++ b/neutron/tests/unit/objects/test_flavor.py @@ -0,0 +1,72 @@ +# Copyright 2016 Intel Corporation. +# 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. + +from neutron.objects import flavor +from neutron.tests.unit.objects import test_base as obj_test_base +from neutron.tests.unit import testlib_api + + +class FlavorServiceProfileBindingIfaceObjectTestCase( + obj_test_base.BaseObjectIfaceTestCase): + + _test_class = flavor.FlavorServiceProfileBinding + + +class FlavorServiceProfileBindingDbObjectTestCase( + obj_test_base.BaseDbObjectTestCase, testlib_api.SqlTestCase): + + _test_class = flavor.FlavorServiceProfileBinding + + def setUp(self): + super(FlavorServiceProfileBindingDbObjectTestCase, self).setUp() + self.update_obj_fields( + {'flavor_id': lambda: self._create_test_flavor().id}) + self.update_obj_fields( + {'service_profile_id': lambda: self._create_test_service_profile( + ).id}) + + +class ServiceProfileIfaceObjectTestCase(obj_test_base.BaseObjectIfaceTestCase): + + _test_class = flavor.ServiceProfile + + +class ServiceProfileDbObjectTestCase(obj_test_base.BaseDbObjectTestCase, + testlib_api.SqlTestCase): + + _test_class = flavor.ServiceProfile + + def test_get_objects_queries_constant(self): + # FIXME(electrocucaracha): There are no lazy loading for flavors + # relationship in ServiceProfile model db disable this UT to avoid + # failing + pass + + +class FlavorIfaceObjectTestCase(obj_test_base.BaseObjectIfaceTestCase): + + _test_class = flavor.Flavor + + +class FlavorDbObjectTestCase(obj_test_base.BaseDbObjectTestCase, + testlib_api.SqlTestCase): + + _test_class = flavor.Flavor + + def test_get_objects_queries_constant(self): + # FIXME(electrocucaracha): There are no lazy loading for + # service_profiles relationship in Flavor model db disable this UT to + # avoid failing + pass diff --git a/neutron/tests/unit/objects/test_objects.py b/neutron/tests/unit/objects/test_objects.py index 2ff40f96ff9..09cdcf376d4 100644 --- a/neutron/tests/unit/objects/test_objects.py +++ b/neutron/tests/unit/objects/test_objects.py @@ -35,6 +35,8 @@ object_data = { 'DNSNameServer': '1.0-bf87a85327e2d812d1666ede99d9918b', 'ExtraDhcpOpt': '1.0-632f689cbeb36328995a7aed1d0a78d3', 'FlatAllocation': '1.0-bf666f24f4642b047eeca62311fbcb41', + 'Flavor': '1.0-82194de5c9aafce08e8527bb7977f5c6', + 'FlavorServiceProfileBinding': '1.0-a2c8731e16cefdac4571f80abf1f8930', 'FloatingIPDNS': '1.0-ee3db848500fa1825235f701828c06d5', 'GeneveAllocation': '1.0-d5f76e8eac60a778914d61dd8e23e90f', 'GeneveEndpoint': '1.0-040f026996b5952e2ae4ccd40ac61ca6', @@ -64,6 +66,7 @@ object_data = { 'SecurityGroup': '1.0-e26b90c409b31fd2e3c6fcec402ac0b9', 'SecurityGroupRule': '1.0-e9b8dace9d48b936c62ad40fe1f339d5', 'SegmentHostMapping': '1.0-521597cf82ead26217c3bd10738f00f0', + 'ServiceProfile': '1.0-9beafc9e7d081b8258f3c5cb66ac5eed', 'Subnet': '1.0-9c19023a61b42d29fbf3766df380e5b7', 'SubnetPool': '1.0-e8300bfbc4762cc88a7f6205b52da2f8', 'SubnetPoolPrefix': '1.0-13c15144135eb869faa4a76dc3ee3b6c',