openstack
/
nova
Code Issues Proposed changes

Remove deprecated 'default_flavor' config option 

The deprecated 'default_flavor' option has been removed.
The following methods in nova/compute/flavors.py
have been removed because they are only used in unit tests.

* get_default_flavor
* get_flavor_by_name

Change-Id: If1e461da382f707be2b5ba89f74f77269f0909dd
This commit is contained in:
Takashi NATSUME 2019-03-22 12:44:45 +09:00
parent ce5ef763b5
commit 7cf16e317b
17 changed files with 199 additions and 295 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
nova/compute/flavors.py
View File

@ -125,23 +125,6 @@ def create(name, memory, vcpus, root_gb, ephemeral_gb=0, flavorid=None,
return flavor return flavor
def get_default_flavor():
"""Get the default flavor."""
name = CONF.default_flavor
return get_flavor_by_name(name)
def get_flavor_by_name(name, ctxt=None):
"""Retrieves single flavor by name."""
if name is None:
return get_default_flavor()
if ctxt is None:
ctxt = context.get_admin_context()
return objects.Flavor.get_by_name(ctxt, name)
# TODO(termie): flavor-specific code should probably be in the API that uses # TODO(termie): flavor-specific code should probably be in the API that uses
# flavors. # flavors.
def get_flavor_by_flavor_id(flavorid, ctxt=None, read_deleted="yes"): def get_flavor_by_flavor_id(flavorid, ctxt=None, read_deleted="yes"):

2
nova/conf/__init__.py
View File

@ -33,7 +33,6 @@ from nova.conf import consoleauth
from nova.conf import database from nova.conf import database
from nova.conf import devices from nova.conf import devices
from nova.conf import ephemeral_storage from nova.conf import ephemeral_storage
from nova.conf import flavors
from nova.conf import glance from nova.conf import glance
from nova.conf import guestfs from nova.conf import guestfs
from nova.conf import hyperv from nova.conf import hyperv
@ -88,7 +87,6 @@ consoleauth.register_opts(CONF)
database.register_opts(CONF) database.register_opts(CONF)
devices.register_opts(CONF) devices.register_opts(CONF)
ephemeral_storage.register_opts(CONF) ephemeral_storage.register_opts(CONF)
flavors.register_opts(CONF)
glance.register_opts(CONF) glance.register_opts(CONF)
guestfs.register_opts(CONF) guestfs.register_opts(CONF)
hyperv.register_opts(CONF) hyperv.register_opts(CONF)

38
nova/conf/flavors.py
View File

@ -1,38 +0,0 @@
# Copyright 2016 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.
from oslo_config import cfg
flavor_opts = [
cfg.StrOpt(
"default_flavor",
default="m1.small",
deprecated_for_removal=True,
deprecated_since="14.0.0",
deprecated_reason="The EC2 API is deprecated.",
help="""
Default flavor to use for the EC2 API only.
The Nova API does not support a default flavor.
"""),
]
def register_opts(conf):
conf.register_opts(flavor_opts)
def list_opts():
return {"DEFAULT": flavor_opts}

5
nova/tests/unit/api/openstack/compute/test_disk_config.py
View File

@ -21,9 +21,9 @@ import six
from nova.api.openstack import compute from nova.api.openstack import compute
from nova.compute import api as compute_api from nova.compute import api as compute_api
from nova.compute import flavors
from nova import context as nova_context from nova import context as nova_context
from nova import exception from nova import exception
from nova import objects
from nova import test from nova import test
from nova.tests.unit.api.openstack import fakes from nova.tests.unit.api.openstack import fakes
from nova.tests.unit import fake_instance from nova.tests.unit import fake_instance
@ -83,7 +83,8 @@ class DiskConfigTestCaseV21(test.TestCase):
'vm_state': '', 'vm_state': '',
'auto_disk_config': inst_['auto_disk_config'], 'auto_disk_config': inst_['auto_disk_config'],
'security_groups': inst_['security_groups'], 'security_groups': inst_['security_groups'],
'instance_type': flavors.get_default_flavor(), 'instance_type': objects.Flavor.get_by_name(context,
'm1.small'),
}) })
return inst return inst

3
nova/tests/unit/api/openstack/fakes.py
View File

@ -487,7 +487,8 @@ def stub_instance(id=1, user_id=None, project_id=None, host=None,
info_cache = create_info_cache(nw_cache) info_cache = create_info_cache(nw_cache)
if instance_type is None: if instance_type is None:
instance_type = flavors.get_default_flavor() instance_type = objects.Flavor.get_by_name(
context.get_admin_context(), 'm1.small')
flavorinfo = jsonutils.dumps({ flavorinfo = jsonutils.dumps({
'cur': instance_type.obj_to_primitive(), 'cur': instance_type.obj_to_primitive(),
'old': None, 'old': None,

201
nova/tests/unit/compute/test_compute.py
View File

@ -288,7 +288,7 @@ class BaseTestCase(test.TestCase):
def _create_fake_instance_obj(self, params=None, type_name='m1.tiny', def _create_fake_instance_obj(self, params=None, type_name='m1.tiny',
services=False, ctxt=None): services=False, ctxt=None):
ctxt = ctxt or self.context ctxt = ctxt or self.context
flavor = flavors.get_flavor_by_name(type_name) flavor = objects.Flavor.get_by_name(ctxt, type_name)
inst = objects.Instance(context=ctxt) inst = objects.Instance(context=ctxt)
inst.vm_state = vm_states.ACTIVE inst.vm_state = vm_states.ACTIVE
inst.task_state = None inst.task_state = None
@ -1514,6 +1514,9 @@ class ComputeTestCase(BaseTestCase,
self.useFixture(fixtures.SynchronousThreadPoolExecutorFixture()) self.useFixture(fixtures.SynchronousThreadPoolExecutorFixture())
self.image_api = image_api.API() self.image_api = image_api.API()
self.default_flavor = objects.Flavor.get_by_name(self.context,
'm1.small')
self.tiny_flavor = objects.Flavor.get_by_name(self.context, 'm1.tiny')
def test_wrap_instance_fault(self): def test_wrap_instance_fault(self):
inst = {"uuid": uuids.instance} inst = {"uuid": uuids.instance}
@ -1703,8 +1706,6 @@ class ComputeTestCase(BaseTestCase,
self.assertEqual(768, cn.local_gb_used) self.assertEqual(768, cn.local_gb_used)
def test_create_multiple_instance_with_neutron_port(self): def test_create_multiple_instance_with_neutron_port(self):
instance_type = flavors.get_default_flavor()
def fake_is_neutron(): def fake_is_neutron():
return True return True
self.stub_out('nova.utils.is_neutron', fake_is_neutron) self.stub_out('nova.utils.is_neutron', fake_is_neutron)
@ -1713,7 +1714,7 @@ class ComputeTestCase(BaseTestCase,
self.assertRaises(exception.MultiplePortsNotApplicable, self.assertRaises(exception.MultiplePortsNotApplicable,
self.compute_api.create, self.compute_api.create,
self.context, self.context,
instance_type=instance_type, instance_type=self.default_flavor,
image_href=None, image_href=None,
max_count=2, max_count=2,
requested_networks=requested_networks) requested_networks=requested_networks)
@ -2442,8 +2443,8 @@ class ComputeTestCase(BaseTestCase,
self.assertEqual(payload['user_id'], self.user_id) self.assertEqual(payload['user_id'], self.user_id)
self.assertEqual(payload['instance_id'], instance.uuid) self.assertEqual(payload['instance_id'], instance.uuid)
self.assertEqual(payload['instance_type'], 'm1.tiny') self.assertEqual(payload['instance_type'], 'm1.tiny')
type_id = flavors.get_flavor_by_name('m1.tiny')['id'] self.assertEqual(str(self.tiny_flavor.id),
self.assertEqual(str(payload['instance_type_id']), str(type_id)) str(payload['instance_type_id']))
self.assertIn('display_name', payload) self.assertIn('display_name', payload)
self.assertIn('created_at', payload) self.assertIn('created_at', payload)
self.assertIn('launched_at', payload) self.assertIn('launched_at', payload)
@ -2493,8 +2494,8 @@ class ComputeTestCase(BaseTestCase,
self.assertEqual(payload['user_id'], self.user_id) self.assertEqual(payload['user_id'], self.user_id)
self.assertEqual(payload['instance_id'], instance.uuid) self.assertEqual(payload['instance_id'], instance.uuid)
self.assertEqual(payload['instance_type'], 'm1.tiny') self.assertEqual(payload['instance_type'], 'm1.tiny')
type_id = flavors.get_flavor_by_name('m1.tiny')['id'] self.assertEqual(str(self.tiny_flavor.id),
self.assertEqual(str(payload['instance_type_id']), str(type_id)) str(payload['instance_type_id']))
self.assertIn('display_name', payload) self.assertIn('display_name', payload)
self.assertIn('created_at', payload) self.assertIn('created_at', payload)
self.assertIn('launched_at', payload) self.assertIn('launched_at', payload)
@ -3079,13 +3080,13 @@ class ComputeTestCase(BaseTestCase,
power_state=10003, power_state=10003,
vm_state=vm_states.ACTIVE, vm_state=vm_states.ACTIVE,
task_state=expected_task, task_state=expected_task,
instance_type=flavors.get_default_flavor(), instance_type=self.default_flavor,
launched_at=timeutils.utcnow())) launched_at=timeutils.utcnow()))
updated_dbinstance2 = fake_instance.fake_db_instance( updated_dbinstance2 = fake_instance.fake_db_instance(
**dict(uuid=uuids.db_instance_2, **dict(uuid=uuids.db_instance_2,
power_state=10003, power_state=10003,
vm_state=vm_states.ACTIVE, vm_state=vm_states.ACTIVE,
instance_type=flavors.get_default_flavor(), instance_type=self.default_flavor,
task_state=expected_task, task_state=expected_task,
launched_at=timeutils.utcnow())) launched_at=timeutils.utcnow()))
@ -4390,10 +4391,10 @@ class ComputeTestCase(BaseTestCase,
self.assertEqual(payload['user_id'], self.user_id) self.assertEqual(payload['user_id'], self.user_id)
self.assertEqual(payload['instance_id'], instance['uuid']) self.assertEqual(payload['instance_id'], instance['uuid'])
self.assertEqual(payload['instance_type'], 'm1.tiny') self.assertEqual(payload['instance_type'], 'm1.tiny')
type_id = flavors.get_flavor_by_name('m1.tiny')['id'] self.assertEqual(str(self.tiny_flavor.id),
self.assertEqual(str(payload['instance_type_id']), str(type_id)) str(payload['instance_type_id']))
flavor_id = flavors.get_flavor_by_name('m1.tiny')['flavorid'] self.assertEqual(str(self.tiny_flavor.flavorid),
self.assertEqual(str(payload['instance_flavor_id']), str(flavor_id)) str(payload['instance_flavor_id']))
self.assertEqual(payload['state'], 'active') self.assertEqual(payload['state'], 'active')
self.assertIn('display_name', payload) self.assertIn('display_name', payload)
self.assertIn('created_at', payload) self.assertIn('created_at', payload)
@ -4524,10 +4525,10 @@ class ComputeTestCase(BaseTestCase,
self.assertEqual(payload['user_id'], self.user_id) self.assertEqual(payload['user_id'], self.user_id)
self.assertEqual(payload['instance_id'], instance['uuid']) self.assertEqual(payload['instance_id'], instance['uuid'])
self.assertEqual(payload['instance_type'], 'm1.tiny') self.assertEqual(payload['instance_type'], 'm1.tiny')
type_id = flavors.get_flavor_by_name('m1.tiny')['id'] self.assertEqual(str(self.tiny_flavor.id),
self.assertEqual(str(payload['instance_type_id']), str(type_id)) str(payload['instance_type_id']))
flavor_id = flavors.get_flavor_by_name('m1.tiny')['flavorid'] self.assertEqual(str(self.tiny_flavor.flavorid),
self.assertEqual(str(payload['instance_flavor_id']), str(flavor_id)) str(payload['instance_flavor_id']))
self.assertIn('display_name', payload) self.assertIn('display_name', payload)
self.assertIn('created_at', payload) self.assertIn('created_at', payload)
self.assertIn('launched_at', payload) self.assertIn('launched_at', payload)
@ -4837,10 +4838,10 @@ class ComputeTestCase(BaseTestCase,
instance = self._create_fake_instance_obj(params) instance = self._create_fake_instance_obj(params)
image = {} image = {}
disk_info = 'fake-disk-info' disk_info = 'fake-disk-info'
instance_type = flavors.get_default_flavor() instance_type = self.default_flavor
if not resize_instance: if not resize_instance:
old_instance_type = flavors.get_flavor_by_name('m1.tiny') old_instance_type = self.tiny_flavor
instance_type['root_gb'] = old_instance_type['root_gb'] instance_type['root_gb'] = old_instance_type['root_gb']
instance_type['swap'] = old_instance_type['swap'] instance_type['swap'] = old_instance_type['swap']
instance_type['ephemeral_gb'] = old_instance_type['ephemeral_gb'] instance_type['ephemeral_gb'] = old_instance_type['ephemeral_gb']
@ -5082,7 +5083,7 @@ class ComputeTestCase(BaseTestCase,
jsonutils.dumps(connection_info)) jsonutils.dumps(connection_info))
# begin resize # begin resize
instance_type = flavors.get_default_flavor() instance_type = self.default_flavor
instance.task_state = task_states.RESIZE_PREP instance.task_state = task_states.RESIZE_PREP
instance.save() instance.save()
self.compute.prep_resize(self.context, instance=instance, self.compute.prep_resize(self.context, instance=instance,
@ -5173,7 +5174,7 @@ class ComputeTestCase(BaseTestCase,
old_flavor_name = 'm1.tiny' old_flavor_name = 'm1.tiny'
instance = self._create_fake_instance_obj(type_name=old_flavor_name) instance = self._create_fake_instance_obj(type_name=old_flavor_name)
instance_type = flavors.get_flavor_by_name('m1.small') instance_type = objects.Flavor.get_by_name(self.context, 'm1.small')
self.compute.prep_resize(self.context, instance=instance, self.compute.prep_resize(self.context, instance=instance,
instance_type=instance_type, instance_type=instance_type,
@ -5196,7 +5197,7 @@ class ComputeTestCase(BaseTestCase,
instance.refresh() instance.refresh()
self.assertEqual(vm_states.ERROR, instance.vm_state) self.assertEqual(vm_states.ERROR, instance.vm_state)
old_flavor = flavors.get_flavor_by_name(old_flavor_name) old_flavor = objects.Flavor.get_by_name(self.context, old_flavor_name)
self.assertEqual(old_flavor['memory_mb'], instance.memory_mb) self.assertEqual(old_flavor['memory_mb'], instance.memory_mb)
self.assertEqual(old_flavor['vcpus'], instance.vcpus) self.assertEqual(old_flavor['vcpus'], instance.vcpus)
self.assertEqual(old_flavor['root_gb'], instance.root_gb) self.assertEqual(old_flavor['root_gb'], instance.root_gb)
@ -5208,7 +5209,7 @@ class ComputeTestCase(BaseTestCase,
old_flavor_name = 'm1.tiny' old_flavor_name = 'm1.tiny'
new_flavor_name = 'm1.small' new_flavor_name = 'm1.small'
instance = self._create_fake_instance_obj(type_name=old_flavor_name) instance = self._create_fake_instance_obj(type_name=old_flavor_name)
new_flavor = flavors.get_flavor_by_name(new_flavor_name) new_flavor = objects.Flavor.get_by_name(self.context, new_flavor_name)
self.compute._set_instance_info(instance, new_flavor.obj_clone()) self.compute._set_instance_info(instance, new_flavor.obj_clone())
@ -5280,10 +5281,10 @@ class ComputeTestCase(BaseTestCase,
self.assertEqual(payload['user_id'], self.user_id) self.assertEqual(payload['user_id'], self.user_id)
self.assertEqual(payload['instance_id'], inst_ref['uuid']) self.assertEqual(payload['instance_id'], inst_ref['uuid'])
self.assertEqual(payload['instance_type'], 'm1.tiny') self.assertEqual(payload['instance_type'], 'm1.tiny')
type_id = flavors.get_flavor_by_name('m1.tiny')['id'] self.assertEqual(str(self.tiny_flavor.id),
self.assertEqual(str(payload['instance_type_id']), str(type_id)) str(payload['instance_type_id']))
flavor_id = flavors.get_flavor_by_name('m1.tiny')['flavorid'] self.assertEqual(str(self.tiny_flavor.flavorid),
self.assertEqual(str(payload['instance_flavor_id']), str(flavor_id)) str(payload['instance_flavor_id']))
self.assertIn('display_name', payload) self.assertIn('display_name', payload)
self.assertIn('created_at', payload) self.assertIn('created_at', payload)
self.assertIn('launched_at', payload) self.assertIn('launched_at', payload)
@ -5297,7 +5298,7 @@ class ComputeTestCase(BaseTestCase,
cur_time = datetime.datetime(2012, 12, 21, 12, 21) cur_time = datetime.datetime(2012, 12, 21, 12, 21)
time_fixture = self.useFixture(utils_fixture.TimeFixture(old_time)) time_fixture = self.useFixture(utils_fixture.TimeFixture(old_time))
instance = self._create_fake_instance_obj() instance = self._create_fake_instance_obj()
new_type = flavors.get_flavor_by_name('m1.small') new_type = objects.Flavor.get_by_name(self.context, 'm1.small')
new_type_id = new_type['id'] new_type_id = new_type['id']
flavor_id = new_type['flavorid'] flavor_id = new_type['flavorid']
self.compute.build_and_run_instance(self.context, instance, {}, {}, {}, self.compute.build_and_run_instance(self.context, instance, {}, {}, {},
@ -5368,9 +5369,8 @@ class ComputeTestCase(BaseTestCase,
instance.task_state = task_states.RESIZE_PREP instance.task_state = task_states.RESIZE_PREP
instance.save() instance.save()
instance_type = flavors.get_default_flavor()
self.compute.prep_resize(self.context, instance=instance, self.compute.prep_resize(self.context, instance=instance,
instance_type=instance_type, image={}, instance_type=self.default_flavor, image={},
request_spec={}, filter_properties={}, node=None, request_spec={}, filter_properties={}, node=None,
clean_shutdown=True, migration=None, host_list=[]) clean_shutdown=True, migration=None, host_list=[])
db.migration_get_by_instance_and_status(self.context.elevated(), db.migration_get_by_instance_and_status(self.context.elevated(),
@ -5393,10 +5393,10 @@ class ComputeTestCase(BaseTestCase,
self.assertEqual(payload['user_id'], self.user_id) self.assertEqual(payload['user_id'], self.user_id)
self.assertEqual(payload['instance_id'], instance.uuid) self.assertEqual(payload['instance_id'], instance.uuid)
self.assertEqual(payload['instance_type'], 'm1.tiny') self.assertEqual(payload['instance_type'], 'm1.tiny')
type_id = flavors.get_flavor_by_name('m1.tiny')['id'] self.assertEqual(str(self.tiny_flavor.id),
self.assertEqual(str(payload['instance_type_id']), str(type_id)) str(payload['instance_type_id']))
flavor_id = flavors.get_flavor_by_name('m1.tiny')['flavorid'] self.assertEqual(str(self.tiny_flavor.flavorid),
self.assertEqual(str(payload['instance_flavor_id']), str(flavor_id)) str(payload['instance_flavor_id']))
self.assertIn('display_name', payload) self.assertIn('display_name', payload)
self.assertIn('created_at', payload) self.assertIn('created_at', payload)
self.assertIn('launched_at', payload) self.assertIn('launched_at', payload)
@ -5406,9 +5406,9 @@ class ComputeTestCase(BaseTestCase,
self.compute.terminate_instance(self.context, instance, []) self.compute.terminate_instance(self.context, instance, [])
mock_notify.assert_has_calls([ mock_notify.assert_has_calls([
mock.call(self.context, instance, 'fake-mini', 'start', mock.call(self.context, instance, 'fake-mini', 'start',
instance_type), self.default_flavor),
mock.call(self.context, instance, 'fake-mini', 'end', mock.call(self.context, instance, 'fake-mini', 'end',
instance_type)]) self.default_flavor)])
def test_prep_resize_instance_migration_error_on_none_host(self): def test_prep_resize_instance_migration_error_on_none_host(self):
"""Ensure prep_resize raises a migration error if destination host is """Ensure prep_resize raises a migration error if destination host is
@ -5420,11 +5420,10 @@ class ComputeTestCase(BaseTestCase,
block_device_mapping=[]) block_device_mapping=[])
instance.host = None instance.host = None
instance.save() instance.save()
instance_type = flavors.get_default_flavor()
self.assertRaises(exception.MigrationError, self.compute.prep_resize, self.assertRaises(exception.MigrationError, self.compute.prep_resize,
self.context, instance=instance, self.context, instance=instance,
instance_type=instance_type, image={}, instance_type=self.default_flavor, image={},
request_spec={}, request_spec={},
filter_properties={}, node=None, filter_properties={}, node=None,
clean_shutdown=True, migration=mock.Mock(), clean_shutdown=True, migration=mock.Mock(),
@ -5441,14 +5440,13 @@ class ComputeTestCase(BaseTestCase,
throw_up) throw_up)
instance = self._create_fake_instance_obj() instance = self._create_fake_instance_obj()
instance_type = flavors.get_default_flavor()
self.compute.build_and_run_instance(self.context, instance, {}, {}, {}, self.compute.build_and_run_instance(self.context, instance, {}, {}, {},
block_device_mapping=[]) block_device_mapping=[])
instance.host = 'foo' instance.host = 'foo'
instance.save() instance.save()
self.compute.prep_resize(self.context, instance=instance, self.compute.prep_resize(self.context, instance=instance,
instance_type=instance_type, image={}, instance_type=self.default_flavor, image={},
request_spec={}, request_spec={},
filter_properties={}, node=None, filter_properties={}, node=None,
clean_shutdown=True, migration=None, clean_shutdown=True, migration=None,
@ -5463,7 +5461,8 @@ class ComputeTestCase(BaseTestCase,
self.assertRaises(test.TestingException, self.compute.resize_instance, self.assertRaises(test.TestingException, self.compute.resize_instance,
self.context, instance=instance, self.context, instance=instance,
migration=migration, image={}, migration=migration, image={},
instance_type=jsonutils.to_primitive(instance_type), instance_type=jsonutils.to_primitive(
self.default_flavor),
clean_shutdown=True) clean_shutdown=True)
# NOTE(comstud): error path doesn't use objects, so our object # NOTE(comstud): error path doesn't use objects, so our object
# is not updated. Refresh and compare against the DB. # is not updated. Refresh and compare against the DB.
@ -5481,13 +5480,12 @@ class ComputeTestCase(BaseTestCase,
throw_up) throw_up)
instance = self._create_fake_instance_obj() instance = self._create_fake_instance_obj()
instance_type = flavors.get_default_flavor()
self.compute.build_and_run_instance(self.context, instance, {}, {}, {}, self.compute.build_and_run_instance(self.context, instance, {}, {}, {},
block_device_mapping=[]) block_device_mapping=[])
instance.host = 'foo' instance.host = 'foo'
instance.save() instance.save()
self.compute.prep_resize(self.context, instance=instance, self.compute.prep_resize(self.context, instance=instance,
instance_type=instance_type, image={}, instance_type=self.default_flavor, image={},
request_spec={}, request_spec={},
filter_properties={}, node=None, filter_properties={}, node=None,
migration=None, host_list=[], migration=None, host_list=[],
@ -5502,7 +5500,8 @@ class ComputeTestCase(BaseTestCase,
self.assertRaises(test.TestingException, self.compute.resize_instance, self.assertRaises(test.TestingException, self.compute.resize_instance,
self.context, instance=instance, self.context, instance=instance,
migration=migration, image={}, migration=migration, image={},
instance_type=jsonutils.to_primitive(instance_type), instance_type=jsonutils.to_primitive(
self.default_flavor),
clean_shutdown=True) clean_shutdown=True)
# NOTE(comstud): error path doesn't use objects, so our object # NOTE(comstud): error path doesn't use objects, so our object
# is not updated. Refresh and compare against the DB. # is not updated. Refresh and compare against the DB.
@ -5514,14 +5513,13 @@ class ComputeTestCase(BaseTestCase,
def _test_resize_instance(self, clean_shutdown=True): def _test_resize_instance(self, clean_shutdown=True):
# Ensure instance can be migrated/resized. # Ensure instance can be migrated/resized.
instance = self._create_fake_instance_obj() instance = self._create_fake_instance_obj()
instance_type = flavors.get_default_flavor()
self.compute.build_and_run_instance(self.context, instance, {}, {}, {}, self.compute.build_and_run_instance(self.context, instance, {}, {}, {},
block_device_mapping=[]) block_device_mapping=[])
instance.host = 'foo' instance.host = 'foo'
instance.save() instance.save()
self.compute.prep_resize(self.context, instance=instance, self.compute.prep_resize(self.context, instance=instance,
instance_type=instance_type, image={}, instance_type=self.default_flavor, image={},
request_spec={}, filter_properties={}, node=None, request_spec={}, filter_properties={}, node=None,
clean_shutdown=True, migration=None, host_list=[]) clean_shutdown=True, migration=None, host_list=[])
@ -5558,7 +5556,7 @@ class ComputeTestCase(BaseTestCase,
mock_check_is_bfv): mock_check_is_bfv):
self.compute.resize_instance(self.context, instance=instance, self.compute.resize_instance(self.context, instance=instance,
migration=migration, image={}, migration=migration, image={},
instance_type=jsonutils.to_primitive(instance_type), instance_type=jsonutils.to_primitive(self.default_flavor),
clean_shutdown=clean_shutdown) clean_shutdown=clean_shutdown)
mock_notify_action.assert_has_calls([ mock_notify_action.assert_has_calls([
mock.call(self.context, instance, 'fake-mini', mock.call(self.context, instance, 'fake-mini',
@ -6141,14 +6139,12 @@ class ComputeTestCase(BaseTestCase,
instance = self._create_fake_instance_obj() instance = self._create_fake_instance_obj()
instance_type = flavors.get_default_flavor()
self.compute.build_and_run_instance(self.context, instance, {}, {}, {}, self.compute.build_and_run_instance(self.context, instance, {}, {}, {},
block_device_mapping=[]) block_device_mapping=[])
instance.host = 'foo' instance.host = 'foo'
instance.save() instance.save()
self.compute.prep_resize(self.context, instance=instance, self.compute.prep_resize(self.context, instance=instance,
instance_type=instance_type, instance_type=self.default_flavor,
image={}, image={},
request_spec={}, filter_properties={}, request_spec={}, filter_properties={},
node=None, clean_shutdown=True, node=None, clean_shutdown=True,
@ -6161,7 +6157,8 @@ class ComputeTestCase(BaseTestCase,
self.assertRaises(test.TestingException, self.compute.resize_instance, self.assertRaises(test.TestingException, self.compute.resize_instance,
self.context, instance=instance, self.context, instance=instance,
migration=migration, image={}, migration=migration, image={},
instance_type=jsonutils.to_primitive(instance_type), instance_type=jsonutils.to_primitive(
self.default_flavor),
clean_shutdown=True) clean_shutdown=True)
# NOTE(comstud): error path doesn't use objects, so our object # NOTE(comstud): error path doesn't use objects, so our object
# is not updated. Refresh and compare against the DB. # is not updated. Refresh and compare against the DB.
@ -8632,6 +8629,10 @@ class ComputeAPITestCase(BaseTestCase):
fake_validate_networks) fake_validate_networks)
validate_nets_patch.start() validate_nets_patch.start()
self.addCleanup(validate_nets_patch.stop) self.addCleanup(validate_nets_patch.stop)
self.default_flavor = objects.Flavor.get_by_name(self.context,
'm1.small')
self.tiny_flavor = objects.Flavor.get_by_name(self.context,
'm1.tiny')
def _run_instance(self, params=None): def _run_instance(self, params=None):
instance = self._create_fake_instance_obj(params, services=True) instance = self._create_fake_instance_obj(params, services=True)
@ -8646,7 +8647,7 @@ class ComputeAPITestCase(BaseTestCase):
def test_create_with_too_little_ram(self): def test_create_with_too_little_ram(self):
# Test an instance type with too little memory. # Test an instance type with too little memory.
inst_type = flavors.get_default_flavor() inst_type = self.default_flavor
inst_type['memory_mb'] = 1 inst_type['memory_mb'] = 1
self.fake_image['min_ram'] = 2 self.fake_image['min_ram'] = 2
@ -8665,7 +8666,7 @@ class ComputeAPITestCase(BaseTestCase):
def test_create_with_too_little_disk(self): def test_create_with_too_little_disk(self):
# Test an instance type with too little disk space. # Test an instance type with too little disk space.
inst_type = flavors.get_default_flavor() inst_type = self.default_flavor
inst_type['root_gb'] = 1 inst_type['root_gb'] = 1
self.fake_image['min_disk'] = 2 self.fake_image['min_disk'] = 2
@ -8684,7 +8685,7 @@ class ComputeAPITestCase(BaseTestCase):
def test_create_with_too_large_image(self): def test_create_with_too_large_image(self):
# Test an instance type with too little disk space. # Test an instance type with too little disk space.
inst_type = flavors.get_default_flavor() inst_type = self.default_flavor
inst_type['root_gb'] = 1 inst_type['root_gb'] = 1
self.fake_image['size'] = '1073741825' self.fake_image['size'] = '1073741825'
@ -8704,7 +8705,7 @@ class ComputeAPITestCase(BaseTestCase):
def test_create_just_enough_ram_and_disk(self): def test_create_just_enough_ram_and_disk(self):
# Test an instance type with just enough ram and disk space. # Test an instance type with just enough ram and disk space.
inst_type = flavors.get_default_flavor() inst_type = self.default_flavor
inst_type['root_gb'] = 2 inst_type['root_gb'] = 2
inst_type['memory_mb'] = 2 inst_type['memory_mb'] = 2
@ -8720,7 +8721,7 @@ class ComputeAPITestCase(BaseTestCase):
def test_create_with_no_ram_and_disk_reqs(self): def test_create_with_no_ram_and_disk_reqs(self):
# Test an instance type with no min_ram or min_disk. # Test an instance type with no min_ram or min_disk.
inst_type = flavors.get_default_flavor() inst_type = self.default_flavor
inst_type['root_gb'] = 1 inst_type['root_gb'] = 1
inst_type['memory_mb'] = 1 inst_type['memory_mb'] = 1
@ -8733,8 +8734,6 @@ class ComputeAPITestCase(BaseTestCase):
def test_create_with_deleted_image(self): def test_create_with_deleted_image(self):
# If we're given a deleted image by glance, we should not be able to # If we're given a deleted image by glance, we should not be able to
# build from it # build from it
inst_type = flavors.get_default_flavor()
self.fake_image['name'] = 'fake_name' self.fake_image['name'] = 'fake_name'
self.fake_image['status'] = 'DELETED' self.fake_image['status'] = 'DELETED'
self.stub_out('nova.tests.unit.image.fake._FakeImageService.show', self.stub_out('nova.tests.unit.image.fake._FakeImageService.show',
@ -8745,13 +8744,11 @@ class ComputeAPITestCase(BaseTestCase):
self.fake_image['id']}) self.fake_image['id']})
with testtools.ExpectedException(exception.ImageNotActive, with testtools.ExpectedException(exception.ImageNotActive,
expected_message): expected_message):
self.compute_api.create(self.context, inst_type, self.compute_api.create(self.context, self.default_flavor,
self.fake_image['id']) self.fake_image['id'])
@mock.patch('nova.virt.hardware.numa_get_constraints') @mock.patch('nova.virt.hardware.numa_get_constraints')
def test_create_with_numa_topology(self, numa_constraints_mock): def test_create_with_numa_topology(self, numa_constraints_mock):
inst_type = flavors.get_default_flavor()
numa_topology = objects.InstanceNUMATopology( numa_topology = objects.InstanceNUMATopology(
cells=[objects.InstanceNUMACell( cells=[objects.InstanceNUMACell(
id=0, cpuset=set([1, 2]), memory=512), id=0, cpuset=set([1, 2]), memory=512),
@ -8760,11 +8757,12 @@ class ComputeAPITestCase(BaseTestCase):
numa_topology.obj_reset_changes() numa_topology.obj_reset_changes()
numa_constraints_mock.return_value = numa_topology numa_constraints_mock.return_value = numa_topology
instances, resv_id = self.compute_api.create(self.context, inst_type, instances, resv_id = self.compute_api.create(self.context,
self.default_flavor,
self.fake_image['id']) self.fake_image['id'])
numa_constraints_mock.assert_called_once_with( numa_constraints_mock.assert_called_once_with(
inst_type, test.MatchType(objects.ImageMeta)) self.default_flavor, test.MatchType(objects.ImageMeta))
self.assertEqual( self.assertEqual(
numa_topology.cells[0].obj_to_primitive(), numa_topology.cells[0].obj_to_primitive(),
instances[0].numa_topology.cells[0].obj_to_primitive()) instances[0].numa_topology.cells[0].obj_to_primitive())
@ -8777,7 +8775,7 @@ class ComputeAPITestCase(BaseTestCase):
cases = [dict(), dict(display_name=None)] cases = [dict(), dict(display_name=None)]
for instance in cases: for instance in cases:
(ref, resv_id) = self.compute_api.create(self.context, (ref, resv_id) = self.compute_api.create(self.context,
flavors.get_default_flavor(), self.default_flavor,
'f5000000-0000-0000-0000-000000000000', **instance) 'f5000000-0000-0000-0000-000000000000', **instance)
self.assertIsNotNone(ref[0]['display_name']) self.assertIsNotNone(ref[0]['display_name'])
@ -8787,7 +8785,7 @@ class ComputeAPITestCase(BaseTestCase):
'schedule_and_build_instances') as mock_sbi: 'schedule_and_build_instances') as mock_sbi:
(ref, resv_id) = self.compute_api.create( (ref, resv_id) = self.compute_api.create(
self.context, self.context,
instance_type=flavors.get_default_flavor(), instance_type=self.default_flavor,
image_href='f5000000-0000-0000-0000-000000000000') image_href='f5000000-0000-0000-0000-000000000000')
build_call = mock_sbi.call_args_list[0] build_call = mock_sbi.call_args_list[0]
@ -8803,16 +8801,16 @@ class ComputeAPITestCase(BaseTestCase):
def test_create_saves_flavor(self): def test_create_saves_flavor(self):
with mock.patch.object(self.compute_api.compute_task_api, with mock.patch.object(self.compute_api.compute_task_api,
'schedule_and_build_instances') as mock_sbi: 'schedule_and_build_instances') as mock_sbi:
instance_type = flavors.get_default_flavor()
(ref, resv_id) = self.compute_api.create( (ref, resv_id) = self.compute_api.create(
self.context, self.context,
instance_type=instance_type, instance_type=self.default_flavor,
image_href=uuids.image_href_id) image_href=uuids.image_href_id)
build_call = mock_sbi.call_args_list[0] build_call = mock_sbi.call_args_list[0]
instance = build_call[1]['build_requests'][0].instance instance = build_call[1]['build_requests'][0].instance
self.assertIn('flavor', instance) self.assertIn('flavor', instance)
self.assertEqual(instance_type.flavorid, instance.flavor.flavorid) self.assertEqual(self.default_flavor.flavorid,
instance.flavor.flavorid)
self.assertNotIn('instance_type_id', instance.system_metadata) self.assertNotIn('instance_type_id', instance.system_metadata)
def test_create_instance_associates_security_groups(self): def test_create_instance_associates_security_groups(self):
@ -8822,7 +8820,7 @@ class ComputeAPITestCase(BaseTestCase):
'schedule_and_build_instances') as mock_sbi: 'schedule_and_build_instances') as mock_sbi:
(ref, resv_id) = self.compute_api.create( (ref, resv_id) = self.compute_api.create(
self.context, self.context,
instance_type=flavors.get_default_flavor(), instance_type=self.default_flavor,
image_href=uuids.image_href_id, image_href=uuids.image_href_id,
security_groups=['testgroup']) security_groups=['testgroup'])
@ -8833,13 +8831,11 @@ class ComputeAPITestCase(BaseTestCase):
self.assertEqual(group.name, reqspec.security_groups[0].name) self.assertEqual(group.name, reqspec.security_groups[0].name)
def test_create_instance_with_invalid_security_group_raises(self): def test_create_instance_with_invalid_security_group_raises(self):
instance_type = flavors.get_default_flavor()
pre_build_len = len(db.instance_get_all(self.context)) pre_build_len = len(db.instance_get_all(self.context))
self.assertRaises(exception.SecurityGroupNotFoundForProject, self.assertRaises(exception.SecurityGroupNotFoundForProject,
self.compute_api.create, self.compute_api.create,
self.context, self.context,
instance_type=instance_type, instance_type=self.default_flavor,
image_href=None, image_href=None,
security_groups=['this_is_a_fake_sec_group']) security_groups=['this_is_a_fake_sec_group'])
self.assertEqual(pre_build_len, self.assertEqual(pre_build_len,
@ -8848,21 +8844,16 @@ class ComputeAPITestCase(BaseTestCase):
def test_create_with_malformed_user_data(self): def test_create_with_malformed_user_data(self):
# Test an instance type with malformed user data. # Test an instance type with malformed user data.
inst_type = flavors.get_default_flavor()
self.fake_image['min_ram'] = 2 self.fake_image['min_ram'] = 2
self.stub_out('nova.tests.unit.image.fake._FakeImageService.show', self.stub_out('nova.tests.unit.image.fake._FakeImageService.show',
self.fake_show) self.fake_show)
self.assertRaises(exception.InstanceUserDataMalformed, self.assertRaises(exception.InstanceUserDataMalformed,
self.compute_api.create, self.context, inst_type, self.compute_api.create, self.context, self.default_flavor,
self.fake_image['id'], user_data=b'banana') self.fake_image['id'], user_data=b'banana')
def test_create_with_base64_user_data(self): def test_create_with_base64_user_data(self):
# Test an instance type with ok much user data. # Test an instance type with ok much user data.
inst_type = flavors.get_default_flavor()
self.fake_image['min_ram'] = 2 self.fake_image['min_ram'] = 2
self.stub_out('nova.tests.unit.image.fake._FakeImageService.show', self.stub_out('nova.tests.unit.image.fake._FakeImageService.show',
self.fake_show) self.fake_show)
@ -8870,7 +8861,7 @@ class ComputeAPITestCase(BaseTestCase):
# NOTE(mikal): a string of length 48510 encodes to 65532 characters of # NOTE(mikal): a string of length 48510 encodes to 65532 characters of
# base64 # base64
(refs, resv_id) = self.compute_api.create( (refs, resv_id) = self.compute_api.create(
self.context, inst_type, self.fake_image['id'], self.context, self.default_flavor, self.fake_image['id'],
user_data=base64.encode_as_text(b'1' * 48510)) user_data=base64.encode_as_text(b'1' * 48510))
def test_populate_instance_for_create(self, num_instances=1): def test_populate_instance_for_create(self, num_instances=1):
@ -8880,14 +8871,13 @@ class ComputeAPITestCase(BaseTestCase):
'uuid': uuids.instance} 'uuid': uuids.instance}
instance = objects.Instance() instance = objects.Instance()
instance.update(base_options) instance.update(base_options)
inst_type = flavors.get_flavor_by_name("m1.tiny")
instance = self.compute_api._populate_instance_for_create( instance = self.compute_api._populate_instance_for_create(
self.context, self.context,
instance, instance,
self.fake_image, self.fake_image,
1, 1,
security_groups=objects.SecurityGroupList(), security_groups=objects.SecurityGroupList(),
instance_type=inst_type, instance_type=self.tiny_flavor,
num_instances=num_instances, num_instances=num_instances,
shutdown_terminate=False) shutdown_terminate=False)
self.assertEqual(str(base_options['image_ref']), self.assertEqual(str(base_options['image_ref']),
@ -8914,7 +8904,6 @@ class ComputeAPITestCase(BaseTestCase):
'uuid': uuids.instance} 'uuid': uuids.instance}
instance = objects.Instance() instance = objects.Instance()
instance.update(base_options) instance.update(base_options)
inst_type = flavors.get_flavor_by_name("m1.tiny")
self.compute_api.key_manager = key_manager.API() self.compute_api.key_manager = key_manager.API()
index = 1 index = 1
instance = self.compute_api._populate_instance_for_create( instance = self.compute_api._populate_instance_for_create(
@ -8923,7 +8912,7 @@ class ComputeAPITestCase(BaseTestCase):
self.fake_image, self.fake_image,
index, index,
security_groups=objects.SecurityGroupList(), security_groups=objects.SecurityGroupList(),
instance_type=inst_type, instance_type=self.tiny_flavor,
num_instances=num_instances, num_instances=num_instances,
shutdown_terminate=False) shutdown_terminate=False)
self.assertIsNotNone(instance.ephemeral_key_uuid) self.assertIsNotNone(instance.ephemeral_key_uuid)
@ -8946,7 +8935,7 @@ class ComputeAPITestCase(BaseTestCase):
('hello_server', 'hello-server')] ('hello_server', 'hello-server')]
for display_name, hostname in cases: for display_name, hostname in cases:
(ref, resv_id) = self.compute_api.create(self.context, (ref, resv_id) = self.compute_api.create(self.context,
flavors.get_default_flavor(), self.default_flavor,
image_href=uuids.image_href_id, image_href=uuids.image_href_id,
display_name=display_name) display_name=display_name)
@ -8964,9 +8953,8 @@ class ComputeAPITestCase(BaseTestCase):
group.create() group.create()
get_group_mock.return_value = group get_group_mock.return_value = group
inst_type = flavors.get_default_flavor()
(refs, resv_id) = self.compute_api.create( (refs, resv_id) = self.compute_api.create(
self.context, inst_type, self.fake_image['id'], self.context, self.default_flavor, self.fake_image['id'],
scheduler_hints={'group': group.uuid}) scheduler_hints={'group': group.uuid})
self.assertEqual(len(refs), len(group.members)) self.assertEqual(len(refs), len(group.members))
@ -8993,9 +8981,8 @@ class ComputeAPITestCase(BaseTestCase):
group.create() group.create()
get_group_mock.return_value = group get_group_mock.return_value = group
inst_type = flavors.get_default_flavor()
self.assertRaises(exception.QuotaError, self.compute_api.create, self.assertRaises(exception.QuotaError, self.compute_api.create,
self.context, inst_type, self.fake_image['id'], self.context, self.default_flavor, self.fake_image['id'],
scheduler_hints={'group': group.uuid}, scheduler_hints={'group': group.uuid},
check_server_group_quota=True) check_server_group_quota=True)
@ -9029,9 +9016,8 @@ class ComputeAPITestCase(BaseTestCase):
group.create() group.create()
get_group_mock.return_value = group get_group_mock.return_value = group
inst_type = flavors.get_default_flavor()
(refs, resv_id) = self.compute_api.create( (refs, resv_id) = self.compute_api.create(
self.context, inst_type, self.fake_image['id'], self.context, self.default_flavor, self.fake_image['id'],
scheduler_hints={'group': group.uuid}, scheduler_hints={'group': group.uuid},
check_server_group_quota=True) check_server_group_quota=True)
self.assertEqual(len(refs), len(group.members)) self.assertEqual(len(refs), len(group.members))
@ -9040,8 +9026,8 @@ class ComputeAPITestCase(BaseTestCase):
# members. # members.
self.assertEqual(2, check_deltas_mock.call_count) self.assertEqual(2, check_deltas_mock.call_count)
call1 = mock.call(self.context, {'instances': 1, call1 = mock.call(self.context, {'instances': 1,
'cores': inst_type.vcpus, 'cores': self.default_flavor.vcpus,
'ram': inst_type.memory_mb}, 'ram': self.default_flavor.memory_mb},
self.context.project_id, self.context.project_id,
user_id=None, user_id=None,
check_project_id=self.context.project_id, check_project_id=self.context.project_id,
@ -9057,12 +9043,11 @@ class ComputeAPITestCase(BaseTestCase):
self.stub_out('nova.tests.unit.image.fake._FakeImageService.show', self.stub_out('nova.tests.unit.image.fake._FakeImageService.show',
self.fake_show) self.fake_show)
inst_type = flavors.get_default_flavor()
self.assertRaises( self.assertRaises(
exception.InstanceGroupNotFound, exception.InstanceGroupNotFound,
self.compute_api.create, self.compute_api.create,
self.context, self.context,
inst_type, self.default_flavor,
self.fake_image['id'], self.fake_image['id'],
scheduler_hints={'group': scheduler_hints={'group':
'5b674f73-c8cf-40ef-9965-3b6fe4b304b1'}) '5b674f73-c8cf-40ef-9965-3b6fe4b304b1'})
@ -9314,9 +9299,8 @@ class ComputeAPITestCase(BaseTestCase):
def test_hostname_create(self): def test_hostname_create(self):
# Ensure instance hostname is set during creation. # Ensure instance hostname is set during creation.
inst_type = flavors.get_flavor_by_name('m1.tiny')
(instances, _) = self.compute_api.create(self.context, (instances, _) = self.compute_api.create(self.context,
inst_type, self.tiny_flavor,
image_href=uuids.image_href_id, image_href=uuids.image_href_id,
display_name='test host') display_name='test host')
@ -9949,7 +9933,7 @@ class ComputeAPITestCase(BaseTestCase):
matches return value from create. matches return value from create.
""" """
(refs, resv_id) = self.compute_api.create(self.context, (refs, resv_id) = self.compute_api.create(self.context,
flavors.get_default_flavor(), self.default_flavor,
image_href=uuids.image_href_id) image_href=uuids.image_href_id)
self.assertEqual(len(refs), 1) self.assertEqual(len(refs), 1)
self.assertEqual(refs[0]['reservation_id'], resv_id) self.assertEqual(refs[0]['reservation_id'], resv_id)
@ -9960,7 +9944,7 @@ class ComputeAPITestCase(BaseTestCase):
in both instances. in both instances.
""" """
(refs, resv_id) = self.compute_api.create(self.context, (refs, resv_id) = self.compute_api.create(self.context,
flavors.get_default_flavor(), self.default_flavor,
image_href=uuids.image_href_id, image_href=uuids.image_href_id,
min_count=2, max_count=2) min_count=2, max_count=2)
self.assertEqual(len(refs), 2) self.assertEqual(len(refs), 2)
@ -9976,7 +9960,7 @@ class ComputeAPITestCase(BaseTestCase):
# cells v1 # cells v1
num_instances = 1 num_instances = 1
refs, _ = self.compute_api.create(self.context, refs, _ = self.compute_api.create(self.context,
flavors.get_default_flavor(), self.default_flavor,
image_href=uuids.image_href_id, image_href=uuids.image_href_id,
min_count=num_instances, max_count=num_instances, min_count=num_instances, max_count=num_instances,
display_name='x') display_name='x')
@ -9992,7 +9976,7 @@ class ComputeAPITestCase(BaseTestCase):
# cells v1 # cells v1
num_instances = 2 num_instances = 2
refs, _ = self.compute_api.create(self.context, refs, _ = self.compute_api.create(self.context,
flavors.get_default_flavor(), self.default_flavor,
image_href=uuids.image_href_id, image_href=uuids.image_href_id,
min_count=num_instances, max_count=num_instances, min_count=num_instances, max_count=num_instances,
display_name='x') display_name='x')
@ -11581,8 +11565,7 @@ class ComputeAPITestCase(BaseTestCase):
inst['project_id'] = self.project_id inst['project_id'] = self.project_id
inst['host'] = 'fake_host' inst['host'] = 'fake_host'
inst['node'] = NODENAME inst['node'] = NODENAME
type_id = flavors.get_flavor_by_name('m1.tiny')['id'] inst['instance_type_id'] = self.tiny_flavor.id
inst['instance_type_id'] = type_id
inst['ami_launch_index'] = 0 inst['ami_launch_index'] = 0
inst['memory_mb'] = 0 inst['memory_mb'] = 0
inst['vcpus'] = 0 inst['vcpus'] = 0
@ -12692,7 +12675,7 @@ class DisabledInstanceTypesTestCase(BaseTestCase):
def setUp(self): def setUp(self):
super(DisabledInstanceTypesTestCase, self).setUp() super(DisabledInstanceTypesTestCase, self).setUp()
self.compute_api = compute.API() self.compute_api = compute.API()
self.inst_type = flavors.get_default_flavor() self.inst_type = objects.Flavor.get_by_name(self.context, 'm1.small')
def test_can_build_instance_from_visible_instance_type(self): def test_can_build_instance_from_visible_instance_type(self):
self.inst_type['disabled'] = False self.inst_type['disabled'] = False
@ -12815,8 +12798,8 @@ class ComputeRescheduleResizeOrReraiseTestCase(BaseTestCase):
super(ComputeRescheduleResizeOrReraiseTestCase, self).setUp() super(ComputeRescheduleResizeOrReraiseTestCase, self).setUp()
self.instance = self._create_fake_instance_obj() self.instance = self._create_fake_instance_obj()
self.instance_uuid = self.instance['uuid'] self.instance_uuid = self.instance['uuid']
self.instance_type = flavors.get_flavor_by_name( self.instance_type = objects.Flavor.get_by_name(
"m1.tiny") context.get_admin_context(), 'm1.tiny')
@mock.patch('nova.compute.manager.ComputeManager._prep_resize', @mock.patch('nova.compute.manager.ComputeManager._prep_resize',
side_effect=test.TestingException) side_effect=test.TestingException)
@ -12938,7 +12921,8 @@ class ComputeInactiveImageTestCase(BaseTestCase):
def test_create_instance_with_deleted_image(self): def test_create_instance_with_deleted_image(self):
# Make sure we can't start an instance with a deleted image. # Make sure we can't start an instance with a deleted image.
inst_type = flavors.get_flavor_by_name('m1.tiny') inst_type = objects.Flavor.get_by_name(context.get_admin_context(),
'm1.tiny')
self.assertRaises(exception.ImageNotActive, self.assertRaises(exception.ImageNotActive,
self.compute_api.create, self.compute_api.create,
self.context, inst_type, uuids.image_instance) self.context, inst_type, uuids.image_instance)
@ -13443,7 +13427,8 @@ class CheckRequestedImageTestCase(test.TestCase):
self.context = context.RequestContext( self.context = context.RequestContext(
'fake_user_id', 'fake_project_id') 'fake_user_id', 'fake_project_id')
self.instance_type = flavors.get_default_flavor() self.instance_type = objects.Flavor.get_by_name(self.context,
'm1.small')
self.instance_type['memory_mb'] = 64 self.instance_type['memory_mb'] = 64
self.instance_type['root_gb'] = 1 self.instance_type['root_gb'] = 1

6
nova/tests/unit/compute/test_compute_cells.py
View File

@ -176,7 +176,7 @@ class CellsComputeAPITestCase(test_compute.ComputeAPITestCase):
headroom=fake_headroom, usages=fake_usages) headroom=fake_headroom, usages=fake_usages)
check_deltas_mock.side_effect = [None, exc] check_deltas_mock.side_effect = [None, exc]
inst_type = flavors.get_default_flavor() inst_type = objects.Flavor.get_by_name(self.context, 'm1.small')
# Try to create 3 instances. # Try to create 3 instances.
self.assertRaises(exception.QuotaError, self.compute_api.create, self.assertRaises(exception.QuotaError, self.compute_api.create,
self.context, inst_type, self.fake_image['id'], min_count=3) self.context, inst_type, self.fake_image['id'], min_count=3)
@ -220,7 +220,7 @@ class CellsComputeAPITestCase(test_compute.ComputeAPITestCase):
# Disable recheck_quota. # Disable recheck_quota.
self.flags(recheck_quota=False, group='quota') self.flags(recheck_quota=False, group='quota')
inst_type = flavors.get_default_flavor() inst_type = objects.Flavor.get_by_name(self.context, 'm1.small')
(refs, resv_id) = self.compute_api.create(self.context, (refs, resv_id) = self.compute_api.create(self.context,
inst_type, inst_type,
self.fake_image['id']) self.fake_image['id'])
@ -550,7 +550,7 @@ class CellsShelveComputeAPITestCase(test_shelve.ShelveComputeAPITestCase):
def _create_fake_instance_obj(self, params=None, type_name='m1.tiny', def _create_fake_instance_obj(self, params=None, type_name='m1.tiny',
services=False, context=None): services=False, context=None):
flavor = flavors.get_flavor_by_name(type_name) flavor = objects.Flavor.get_by_name(self.context, type_name)
inst = objects.Instance(context=context or self.context) inst = objects.Instance(context=context or self.context)
inst.cell_name = 'api!child' inst.cell_name = 'api!child'
inst.vm_state = vm_states.ACTIVE inst.vm_state = vm_states.ACTIVE

79
nova/tests/unit/compute/test_compute_utils.py
View File

@ -27,7 +27,6 @@ from oslo_utils.fixture import uuidsentinel as uuids
from oslo_utils import uuidutils from oslo_utils import uuidutils
import six import six
from nova.compute import flavors
from nova.compute import manager from nova.compute import manager
from nova.compute import power_state from nova.compute import power_state
from nova.compute import task_states from nova.compute import task_states
@ -60,7 +59,7 @@ CONF = nova.conf.CONF
def create_instance(context, user_id='fake', project_id='fake', params=None): def create_instance(context, user_id='fake', project_id='fake', params=None):
"""Create a test instance.""" """Create a test instance."""
flavor = flavors.get_flavor_by_name('m1.tiny') flavor = objects.Flavor.get_by_name(context, 'm1.tiny')
net_info = model.NetworkInfo([]) net_info = model.NetworkInfo([])
info_cache = objects.InstanceInfoCache(network_info=net_info) info_cache = objects.InstanceInfoCache(network_info=net_info)
inst = objects.Instance(context=context, inst = objects.Instance(context=context,
@ -410,6 +409,7 @@ class UsageInfoTestCase(test.TestCase):
self.user_id = 'fake' self.user_id = 'fake'
self.project_id = 'fake' self.project_id = 'fake'
self.context = context.RequestContext(self.user_id, self.project_id) self.context = context.RequestContext(self.user_id, self.project_id)
self.flavor = objects.Flavor.get_by_name(self.context, 'm1.tiny')
def fake_show(meh, context, id, **kwargs): def fake_show(meh, context, id, **kwargs):
return {'id': 1, 'properties': {'kernel_id': 1, 'ramdisk_id': 1}} return {'id': 1, 'properties': {'kernel_id': 1, 'ramdisk_id': 1}}
@ -440,9 +440,9 @@ class UsageInfoTestCase(test.TestCase):
self.assertEqual(payload['user_id'], self.user_id) self.assertEqual(payload['user_id'], self.user_id)
self.assertEqual(payload['instance_id'], instance['uuid']) self.assertEqual(payload['instance_id'], instance['uuid'])
self.assertEqual(payload['instance_type'], 'm1.tiny') self.assertEqual(payload['instance_type'], 'm1.tiny')
type_id = flavors.get_flavor_by_name('m1.tiny')['id'] type_id = self.flavor.id
self.assertEqual(str(payload['instance_type_id']), str(type_id)) self.assertEqual(str(payload['instance_type_id']), str(type_id))
flavor_id = flavors.get_flavor_by_name('m1.tiny')['flavorid'] flavor_id = self.flavor.flavorid
self.assertEqual(str(payload['instance_flavor_id']), str(flavor_id)) self.assertEqual(str(payload['instance_flavor_id']), str(flavor_id))
for attr in ('display_name', 'created_at', 'launched_at', for attr in ('display_name', 'created_at', 'launched_at',
'state', 'state_description', 'state', 'state_description',
@ -473,7 +473,7 @@ class UsageInfoTestCase(test.TestCase):
self.assertEqual(payload['uuid'], instance['uuid']) self.assertEqual(payload['uuid'], instance['uuid'])
flavor = payload['flavor']['nova_object.data'] flavor = payload['flavor']['nova_object.data']
self.assertEqual(flavor['name'], 'm1.tiny') self.assertEqual(flavor['name'], 'm1.tiny')
flavorid = flavors.get_flavor_by_name('m1.tiny')['flavorid'] flavorid = self.flavor.flavorid
self.assertEqual(str(flavor['flavorid']), str(flavorid)) self.assertEqual(str(flavor['flavorid']), str(flavorid))
for attr in ('display_name', 'created_at', 'launched_at', for attr in ('display_name', 'created_at', 'launched_at',
@ -504,9 +504,9 @@ class UsageInfoTestCase(test.TestCase):
self.assertEqual(payload['user_id'], self.user_id) self.assertEqual(payload['user_id'], self.user_id)
self.assertEqual(payload['instance_id'], instance['uuid']) self.assertEqual(payload['instance_id'], instance['uuid'])
self.assertEqual(payload['instance_type'], 'm1.tiny') self.assertEqual(payload['instance_type'], 'm1.tiny')
type_id = flavors.get_flavor_by_name('m1.tiny')['id'] type_id = self.flavor.id
self.assertEqual(str(payload['instance_type_id']), str(type_id)) self.assertEqual(str(payload['instance_type_id']), str(type_id))
flavor_id = flavors.get_flavor_by_name('m1.tiny')['flavorid'] flavor_id = self.flavor.flavorid
self.assertEqual(str(payload['instance_flavor_id']), str(flavor_id)) self.assertEqual(str(payload['instance_flavor_id']), str(flavor_id))
for attr in ('display_name', 'created_at', 'launched_at', for attr in ('display_name', 'created_at', 'launched_at',
'state', 'state_description', 'state', 'state_description',
@ -552,9 +552,9 @@ class UsageInfoTestCase(test.TestCase):
self.assertEqual(payload['user_id'], self.user_id) self.assertEqual(payload['user_id'], self.user_id)
self.assertEqual(payload['uuid'], instance['uuid']) self.assertEqual(payload['uuid'], instance['uuid'])
flavorid = flavors.get_flavor_by_name('m1.tiny')['flavorid'] self.assertEqual(
flavor = payload['flavor']['nova_object.data'] self.flavor.flavorid,
self.assertEqual(str(flavor['flavorid']), flavorid) str(payload['flavor']['nova_object.data']['flavorid']))
for attr in ('display_name', 'created_at', 'launched_at', for attr in ('display_name', 'created_at', 'launched_at',
'state', 'task_state', 'display_description', 'locked', 'state', 'task_state', 'display_description', 'locked',
@ -598,7 +598,7 @@ class UsageInfoTestCase(test.TestCase):
self.assertEqual('fake', payload['user_id']) self.assertEqual('fake', payload['user_id'])
self.assertEqual(instance['uuid'], payload['uuid']) self.assertEqual(instance['uuid'], payload['uuid'])
flavorid = flavors.get_flavor_by_name('m1.tiny')['flavorid'] flavorid = self.flavor.flavorid
flavor = payload['flavor']['nova_object.data'] flavor = payload['flavor']['nova_object.data']
self.assertEqual(flavorid, str(flavor['flavorid'])) self.assertEqual(flavorid, str(flavor['flavorid']))
@ -641,9 +641,9 @@ class UsageInfoTestCase(test.TestCase):
self.assertEqual('fake', payload['user_id']) self.assertEqual('fake', payload['user_id'])
self.assertEqual(instance['uuid'], payload['uuid']) self.assertEqual(instance['uuid'], payload['uuid'])
flavorid = flavors.get_flavor_by_name('m1.tiny')['flavorid'] self.assertEqual(
flavor = payload['flavor']['nova_object.data'] self.flavor.flavorid,
self.assertEqual(flavorid, str(flavor['flavorid'])) str(payload['flavor']['nova_object.data']['flavorid']))
self.assertEqual(0, len(payload['keypairs'])) self.assertEqual(0, len(payload['keypairs']))
for attr in ('display_name', 'created_at', 'launched_at', for attr in ('display_name', 'created_at', 'launched_at',
@ -680,9 +680,9 @@ class UsageInfoTestCase(test.TestCase):
self.assertEqual('fake', payload['user_id']) self.assertEqual('fake', payload['user_id'])
self.assertEqual(instance.uuid, payload['uuid']) self.assertEqual(instance.uuid, payload['uuid'])
flavorid = flavors.get_flavor_by_name('m1.tiny')['flavorid'] self.assertEqual(
flavor = payload['flavor']['nova_object.data'] self.flavor.flavorid,
self.assertEqual(flavorid, str(flavor['flavorid'])) str(payload['flavor']['nova_object.data']['flavorid']))
self.assertEqual(0, len(payload['keypairs'])) self.assertEqual(0, len(payload['keypairs']))
for attr in ('display_name', 'created_at', 'launched_at', for attr in ('display_name', 'created_at', 'launched_at',
@ -718,9 +718,9 @@ class UsageInfoTestCase(test.TestCase):
self.assertEqual(self.user_id, payload['user_id']) self.assertEqual(self.user_id, payload['user_id'])
self.assertEqual(instance['uuid'], payload['uuid']) self.assertEqual(instance['uuid'], payload['uuid'])
flavorid = flavors.get_flavor_by_name('m1.tiny')['flavorid'] self.assertEqual(
flavor = payload['flavor']['nova_object.data'] self.flavor.flavorid,
self.assertEqual(flavorid, str(flavor['flavorid'])) str(payload['flavor']['nova_object.data']['flavorid']))
for attr in ('display_name', 'created_at', 'launched_at', for attr in ('display_name', 'created_at', 'launched_at',
'state', 'task_state'): 'state', 'task_state'):
@ -760,9 +760,9 @@ class UsageInfoTestCase(test.TestCase):
self.assertEqual(self.user_id, payload['user_id']) self.assertEqual(self.user_id, payload['user_id'])
self.assertEqual(instance['uuid'], payload['uuid']) self.assertEqual(instance['uuid'], payload['uuid'])
flavorid = flavors.get_flavor_by_name('m1.tiny')['flavorid'] self.assertEqual(
flavor = payload['flavor']['nova_object.data'] self.flavor.flavorid,
self.assertEqual(flavorid, str(flavor['flavorid'])) str(payload['flavor']['nova_object.data']['flavorid']))
for attr in ('display_name', 'created_at', 'launched_at', for attr in ('display_name', 'created_at', 'launched_at',
'state', 'task_state'): 'state', 'task_state'):
@ -808,9 +808,9 @@ class UsageInfoTestCase(test.TestCase):
self.assertEqual(payload['user_id'], self.user_id) self.assertEqual(payload['user_id'], self.user_id)
self.assertEqual(payload['uuid'], instance['uuid']) self.assertEqual(payload['uuid'], instance['uuid'])
flavorid = flavors.get_flavor_by_name('m1.tiny')['flavorid'] self.assertEqual(
flavor = payload['flavor']['nova_object.data'] self.flavor.flavorid,
self.assertEqual(str(flavor['flavorid']), flavorid) str(payload['flavor']['nova_object.data']['flavorid']))
for attr in ('display_name', 'created_at', 'launched_at', for attr in ('display_name', 'created_at', 'launched_at',
'state', 'task_state', 'display_description', 'locked', 'state', 'task_state', 'display_description', 'locked',
@ -823,7 +823,7 @@ class UsageInfoTestCase(test.TestCase):
def test_notify_about_resize_prep_instance(self): def test_notify_about_resize_prep_instance(self):
instance = create_instance(self.context) instance = create_instance(self.context)
new_flavor = flavors.get_flavor_by_name('m1.small') new_flavor = objects.Flavor.get_by_name(self.context, 'm1.small')
compute_utils.notify_about_resize_prep_instance( compute_utils.notify_about_resize_prep_instance(
self.context, instance, 'fake-compute', 'start', new_flavor) self.context, instance, 'fake-compute', 'start', new_flavor)
@ -842,9 +842,9 @@ class UsageInfoTestCase(test.TestCase):
self.assertEqual(payload['user_id'], self.user_id) self.assertEqual(payload['user_id'], self.user_id)
self.assertEqual(payload['uuid'], instance['uuid']) self.assertEqual(payload['uuid'], instance['uuid'])
flavorid = flavors.get_flavor_by_name('m1.tiny')['flavorid'] self.assertEqual(
flavor = payload['flavor']['nova_object.data'] self.flavor.flavorid,
self.assertEqual(str(flavor['flavorid']), flavorid) str(payload['flavor']['nova_object.data']['flavorid']))
for attr in ('display_name', 'created_at', 'launched_at', for attr in ('display_name', 'created_at', 'launched_at',
'state', 'task_state', 'display_description', 'locked', 'state', 'task_state', 'display_description', 'locked',
@ -869,10 +869,10 @@ class UsageInfoTestCase(test.TestCase):
self.assertEqual(payload['user_id'], self.user_id) self.assertEqual(payload['user_id'], self.user_id)
self.assertEqual(payload['instance_id'], instance['uuid']) self.assertEqual(payload['instance_id'], instance['uuid'])
self.assertEqual(payload['instance_type'], 'm1.tiny') self.assertEqual(payload['instance_type'], 'm1.tiny')
type_id = flavors.get_flavor_by_name('m1.tiny')['id'] self.assertEqual(str(self.flavor.id),
self.assertEqual(str(payload['instance_type_id']), str(type_id)) str(payload['instance_type_id']))
flavor_id = flavors.get_flavor_by_name('m1.tiny')['flavorid'] self.assertEqual(str(self.flavor.flavorid),
self.assertEqual(str(payload['instance_flavor_id']), str(flavor_id)) str(payload['instance_flavor_id']))
for attr in ('display_name', 'created_at', 'launched_at', for attr in ('display_name', 'created_at', 'launched_at',
'state', 'state_description', 'state', 'state_description',
'bandwidth', 'audit_period_beginning', 'bandwidth', 'audit_period_beginning',
@ -943,10 +943,9 @@ class UsageInfoTestCase(test.TestCase):
self.assertEqual(payload['user_id'], self.user_id) self.assertEqual(payload['user_id'], self.user_id)
self.assertEqual(payload['instance_id'], instance['uuid']) self.assertEqual(payload['instance_id'], instance['uuid'])
self.assertEqual(payload['instance_type'], 'm1.tiny') self.assertEqual(payload['instance_type'], 'm1.tiny')
type_id = flavors.get_flavor_by_name('m1.tiny')['id'] self.assertEqual(str(self.flavor.id), str(payload['instance_type_id']))
self.assertEqual(str(payload['instance_type_id']), str(type_id)) self.assertEqual(str(self.flavor.flavorid),
flavor_id = flavors.get_flavor_by_name('m1.tiny')['flavorid'] str(payload['instance_flavor_id']))
self.assertEqual(str(payload['instance_flavor_id']), str(flavor_id))
for attr in ('display_name', 'created_at', 'launched_at', for attr in ('display_name', 'created_at', 'launched_at',
'state', 'state_description', 'image_meta'): 'state', 'state_description', 'image_meta'):
self.assertIn(attr, payload, "Key %s not in payload" % attr) self.assertIn(attr, payload, "Key %s not in payload" % attr)
@ -1299,8 +1298,8 @@ class ComputeUtilsQuotaTestCase(test.TestCase):
self.context = context.RequestContext('fake', 'fake') self.context = context.RequestContext('fake', 'fake')
def test_upsize_quota_delta(self): def test_upsize_quota_delta(self):
old_flavor = flavors.get_flavor_by_name('m1.tiny') old_flavor = objects.Flavor.get_by_name(self.context, 'm1.tiny')
new_flavor = flavors.get_flavor_by_name('m1.medium') new_flavor = objects.Flavor.get_by_name(self.context, 'm1.medium')
expected_deltas = { expected_deltas = {
'cores': new_flavor['vcpus'] - old_flavor['vcpus'], 'cores': new_flavor['vcpus'] - old_flavor['vcpus'],

68
nova/tests/unit/conductor/test_conductor.py
View File

@ -386,7 +386,7 @@ class _BaseTaskTestCase(object):
inst_obj = objects.Instance._from_db_object( inst_obj = objects.Instance._from_db_object(
self.context, objects.Instance(), inst, []) self.context, objects.Instance(), inst, [])
inst_obj.system_metadata = {'image_hw_disk_bus': 'scsi'} inst_obj.system_metadata = {'image_hw_disk_bus': 'scsi'}
flavor = flavors.get_default_flavor() flavor = objects.Flavor.get_by_name(self.context, 'm1.small')
flavor.extra_specs = {'extra_specs': 'fake'} flavor.extra_specs = {'extra_specs': 'fake'}
inst_obj.flavor = flavor inst_obj.flavor = flavor
@ -435,7 +435,7 @@ class _BaseTaskTestCase(object):
""" """
fake_spec = objects.RequestSpec() fake_spec = objects.RequestSpec()
mock_fp.return_value = fake_spec mock_fp.return_value = fake_spec
instance_type = flavors.get_default_flavor() instance_type = objects.Flavor.get_by_name(self.context, 'm1.small')
# NOTE(danms): Avoid datetime timezone issues with converted flavors # NOTE(danms): Avoid datetime timezone issues with converted flavors
instance_type.created_at = None instance_type.created_at = None
instances = [objects.Instance(context=self.context, instances = [objects.Instance(context=self.context,
@ -1651,6 +1651,7 @@ class ConductorTaskTestCase(_BaseTaskTestCase, test_compute.BaseTestCase):
tag = objects.Tag(self.ctxt, tag='tag1') tag = objects.Tag(self.ctxt, tag='tag1')
params['tags'] = objects.TagList(objects=[tag]) params['tags'] = objects.TagList(objects=[tag])
self.params = params self.params = params
self.flavor = objects.Flavor.get_by_name(self.ctxt, 'm1.tiny')
@mock.patch('nova.availability_zones.get_host_availability_zone') @mock.patch('nova.availability_zones.get_host_availability_zone')
@mock.patch('nova.compute.rpcapi.ComputeAPI.build_and_run_instance') @mock.patch('nova.compute.rpcapi.ComputeAPI.build_and_run_instance')
@ -2394,12 +2395,11 @@ class ConductorTaskTestCase(_BaseTaskTestCase, test_compute.BaseTestCase):
def test_migrate_server_fails_with_flavor(self, get_im): def test_migrate_server_fails_with_flavor(self, get_im):
get_im.return_value.cell_mapping = ( get_im.return_value.cell_mapping = (
objects.CellMappingList.get_all(self.context)[0]) objects.CellMappingList.get_all(self.context)[0])
flavor = flavors.get_flavor_by_name('m1.tiny')
instance = fake_instance.fake_instance_obj(self.context, instance = fake_instance.fake_instance_obj(self.context,
vm_state=vm_states.ACTIVE, vm_state=vm_states.ACTIVE,
flavor=flavor) flavor=self.flavor)
self.assertRaises(NotImplementedError, self.conductor.migrate_server, self.assertRaises(NotImplementedError, self.conductor.migrate_server,
self.context, instance, None, True, False, flavor, None, None) self.context, instance, None, True, False, self.flavor, None, None)
def _build_request_spec(self, instance): def _build_request_spec(self, instance):
return { return {
@ -2528,15 +2528,14 @@ class ConductorTaskTestCase(_BaseTaskTestCase, test_compute.BaseTestCase):
def test_cold_migrate_no_valid_host_back_in_active_state( def test_cold_migrate_no_valid_host_back_in_active_state(
self, _preallocate_migration, rollback_mock, notify_mock, self, _preallocate_migration, rollback_mock, notify_mock,
select_dest_mock, metadata_mock, sig_mock, spec_fc_mock, im_mock): select_dest_mock, metadata_mock, sig_mock, spec_fc_mock, im_mock):
flavor = flavors.get_flavor_by_name('m1.tiny')
inst_obj = objects.Instance( inst_obj = objects.Instance(
image_ref='fake-image_ref', image_ref='fake-image_ref',
instance_type_id=flavor['id'], instance_type_id=self.flavor.id,
vm_state=vm_states.ACTIVE, vm_state=vm_states.ACTIVE,
system_metadata={}, system_metadata={},
uuid=uuids.instance, uuid=uuids.instance,
user_id=fakes.FAKE_USER_ID, user_id=fakes.FAKE_USER_ID,
flavor=flavor, flavor=self.flavor,
availability_zone=None, availability_zone=None,
pci_requests=None, pci_requests=None,
numa_topology=None, numa_topology=None,
@ -2557,7 +2556,7 @@ class ConductorTaskTestCase(_BaseTaskTestCase, test_compute.BaseTestCase):
self.assertRaises(exc.NoValidHost, self.assertRaises(exc.NoValidHost,
self.conductor._cold_migrate, self.conductor._cold_migrate,
self.context, inst_obj, self.context, inst_obj,
flavor, {}, self.flavor, {},
True, None, None) True, None, None)
metadata_mock.assert_called_with({}) metadata_mock.assert_called_with({})
sig_mock.assert_called_once_with(self.context, fake_spec) sig_mock.assert_called_once_with(self.context, fake_spec)
@ -2579,15 +2578,14 @@ class ConductorTaskTestCase(_BaseTaskTestCase, test_compute.BaseTestCase):
def test_cold_migrate_no_valid_host_back_in_stopped_state( def test_cold_migrate_no_valid_host_back_in_stopped_state(
self, _preallocate_migration, rollback_mock, notify_mock, self, _preallocate_migration, rollback_mock, notify_mock,
select_dest_mock, metadata_mock, spec_fc_mock, sig_mock, im_mock): select_dest_mock, metadata_mock, spec_fc_mock, sig_mock, im_mock):
flavor = flavors.get_flavor_by_name('m1.tiny')
inst_obj = objects.Instance( inst_obj = objects.Instance(
image_ref='fake-image_ref', image_ref='fake-image_ref',
vm_state=vm_states.STOPPED, vm_state=vm_states.STOPPED,
instance_type_id=flavor['id'], instance_type_id=self.flavor.id,
system_metadata={}, system_metadata={},
uuid=uuids.instance, uuid=uuids.instance,
user_id=fakes.FAKE_USER_ID, user_id=fakes.FAKE_USER_ID,
flavor=flavor, flavor=self.flavor,
numa_topology=None, numa_topology=None,
pci_requests=None, pci_requests=None,
availability_zone=None, availability_zone=None,
@ -2609,7 +2607,7 @@ class ConductorTaskTestCase(_BaseTaskTestCase, test_compute.BaseTestCase):
self.assertRaises(exc.NoValidHost, self.assertRaises(exc.NoValidHost,
self.conductor._cold_migrate, self.conductor._cold_migrate,
self.context, inst_obj, self.context, inst_obj,
flavor, {}, self.flavor, {},
True, None, None) True, None, None)
metadata_mock.assert_called_with({}) metadata_mock.assert_called_with({})
sig_mock.assert_called_once_with(self.context, fake_spec) sig_mock.assert_called_once_with(self.context, fake_spec)
@ -2620,11 +2618,10 @@ class ConductorTaskTestCase(_BaseTaskTestCase, test_compute.BaseTestCase):
rollback_mock.assert_called_once_with() rollback_mock.assert_called_once_with()
def test_cold_migrate_no_valid_host_error_msg(self): def test_cold_migrate_no_valid_host_error_msg(self):
flavor = flavors.get_flavor_by_name('m1.tiny')
inst_obj = objects.Instance( inst_obj = objects.Instance(
image_ref='fake-image_ref', image_ref='fake-image_ref',
vm_state=vm_states.STOPPED, vm_state=vm_states.STOPPED,
instance_type_id=flavor['id'], instance_type_id=self.flavor.id,
system_metadata={}, system_metadata={},
uuid=uuids.instance, uuid=uuids.instance,
user_id=fakes.FAKE_USER_ID) user_id=fakes.FAKE_USER_ID)
@ -2643,7 +2640,7 @@ class ConductorTaskTestCase(_BaseTaskTestCase, test_compute.BaseTestCase):
task_rollback_mock): task_rollback_mock):
nvh = self.assertRaises(exc.NoValidHost, nvh = self.assertRaises(exc.NoValidHost,
self.conductor._cold_migrate, self.context, self.conductor._cold_migrate, self.context,
inst_obj, flavor, {}, inst_obj, self.flavor, {},
True, fake_spec, None) True, fake_spec, None)
self.assertIn('cold migrate', nvh.message) self.assertIn('cold migrate', nvh.message)
@ -2659,16 +2656,15 @@ class ConductorTaskTestCase(_BaseTaskTestCase, test_compute.BaseTestCase):
task_rollback_mock, task_rollback_mock,
task_exec_mock, task_exec_mock,
image_mock): image_mock):
flavor = flavors.get_flavor_by_name('m1.tiny')
inst_obj = objects.Instance( inst_obj = objects.Instance(
image_ref='fake-image_ref', image_ref='fake-image_ref',
vm_state=vm_states.STOPPED, vm_state=vm_states.STOPPED,
instance_type_id=flavor['id'], instance_type_id=self.flavor.id,
system_metadata={}, system_metadata={},
uuid=uuids.instance, uuid=uuids.instance,
project_id=fakes.FAKE_PROJECT_ID, project_id=fakes.FAKE_PROJECT_ID,
user_id=fakes.FAKE_USER_ID, user_id=fakes.FAKE_USER_ID,
flavor=flavor, flavor=self.flavor,
numa_topology=None, numa_topology=None,
pci_requests=None, pci_requests=None,
availability_zone=None) availability_zone=None)
@ -2682,16 +2678,17 @@ class ConductorTaskTestCase(_BaseTaskTestCase, test_compute.BaseTestCase):
self.assertRaises(exc.UnsupportedPolicyException, self.assertRaises(exc.UnsupportedPolicyException,
self.conductor._cold_migrate, self.context, self.conductor._cold_migrate, self.context,
inst_obj, flavor, {}, True, None, None) inst_obj, self.flavor, {}, True, None, None)
updates = {'vm_state': vm_states.STOPPED, 'task_state': None} updates = {'vm_state': vm_states.STOPPED, 'task_state': None}
set_vm_mock.assert_called_once_with(self.context, inst_obj.uuid, set_vm_mock.assert_called_once_with(self.context, inst_obj.uuid,
'migrate_server', updates, 'migrate_server', updates,
exception, fake_spec) exception, fake_spec)
spec_fc_mock.assert_called_once_with( spec_fc_mock.assert_called_once_with(
self.context, inst_obj.uuid, image, flavor, inst_obj.numa_topology, self.context, inst_obj.uuid, image, self.flavor,
inst_obj.pci_requests, {}, None, inst_obj.availability_zone, inst_obj.numa_topology, inst_obj.pci_requests, {}, None,
project_id=inst_obj.project_id, user_id=inst_obj.user_id) inst_obj.availability_zone, project_id=inst_obj.project_id,
user_id=inst_obj.user_id)
@mock.patch.object(objects.InstanceMapping, 'get_by_instance_uuid') @mock.patch.object(objects.InstanceMapping, 'get_by_instance_uuid')
@mock.patch.object(scheduler_utils, 'setup_instance_group') @mock.patch.object(scheduler_utils, 'setup_instance_group')
@ -2707,15 +2704,14 @@ class ConductorTaskTestCase(_BaseTaskTestCase, test_compute.BaseTestCase):
self, _preallocate_migration, prep_resize_mock, rollback_mock, self, _preallocate_migration, prep_resize_mock, rollback_mock,
notify_mock, select_dest_mock, metadata_mock, spec_fc_mock, notify_mock, select_dest_mock, metadata_mock, spec_fc_mock,
sig_mock, im_mock): sig_mock, im_mock):
flavor = flavors.get_flavor_by_name('m1.tiny')
inst_obj = objects.Instance( inst_obj = objects.Instance(
image_ref='fake-image_ref', image_ref='fake-image_ref',
vm_state=vm_states.STOPPED, vm_state=vm_states.STOPPED,
instance_type_id=flavor['id'], instance_type_id=self.flavor.id,
system_metadata={}, system_metadata={},
uuid=uuids.instance, uuid=uuids.instance,
user_id=fakes.FAKE_USER_ID, user_id=fakes.FAKE_USER_ID,
flavor=flavor, flavor=self.flavor,
availability_zone=None, availability_zone=None,
pci_requests=None, pci_requests=None,
numa_topology=None, numa_topology=None,
@ -2738,7 +2734,7 @@ class ConductorTaskTestCase(_BaseTaskTestCase, test_compute.BaseTestCase):
prep_resize_mock.side_effect = exc_info prep_resize_mock.side_effect = exc_info
self.assertRaises(test.TestingException, self.assertRaises(test.TestingException,
self.conductor._cold_migrate, self.conductor._cold_migrate,
self.context, inst_obj, flavor, self.context, inst_obj, self.flavor,
{}, True, None, None) {}, True, None, None)
# Filter properties are populated during code execution # Filter properties are populated during code execution
@ -2753,7 +2749,7 @@ class ConductorTaskTestCase(_BaseTaskTestCase, test_compute.BaseTestCase):
[inst_obj.uuid], return_objects=True, return_alternates=True) [inst_obj.uuid], return_objects=True, return_alternates=True)
prep_resize_mock.assert_called_once_with( prep_resize_mock.assert_called_once_with(
self.context, inst_obj, fake_spec.image, self.context, inst_obj, fake_spec.image,
flavor, hosts[0]['host'], _preallocate_migration.return_value, self.flavor, hosts[0]['host'], _preallocate_migration.return_value,
request_spec=fake_spec, request_spec=fake_spec,
filter_properties=legacy_filter_props, filter_properties=legacy_filter_props,
node=hosts[0]['nodename'], clean_shutdown=True, host_list=[]) node=hosts[0]['nodename'], clean_shutdown=True, host_list=[])
@ -2769,15 +2765,14 @@ class ConductorTaskTestCase(_BaseTaskTestCase, test_compute.BaseTestCase):
image_mock, image_mock,
task_exec_mock, task_exec_mock,
spec_save_mock): spec_save_mock):
flavor = flavors.get_flavor_by_name('m1.tiny')
inst_obj = objects.Instance( inst_obj = objects.Instance(
image_ref='fake-image_ref', image_ref='fake-image_ref',
vm_state=vm_states.STOPPED, vm_state=vm_states.STOPPED,
instance_type_id=flavor['id'], instance_type_id=self.flavor.id,
system_metadata={}, system_metadata={},
uuid=uuids.instance, uuid=uuids.instance,
user_id=fakes.FAKE_USER_ID, user_id=fakes.FAKE_USER_ID,
flavor=flavor, flavor=self.flavor,
availability_zone=None, availability_zone=None,
pci_requests=None, pci_requests=None,
numa_topology=None) numa_topology=None)
@ -2787,22 +2782,21 @@ class ConductorTaskTestCase(_BaseTaskTestCase, test_compute.BaseTestCase):
image_mock.return_value = image image_mock.return_value = image
# Just make sure we have an original flavor which is different from # Just make sure we have an original flavor which is different from
# the new one # the new one
self.assertNotEqual(flavor, fake_spec.flavor) self.assertNotEqual(self.flavor, fake_spec.flavor)
self.conductor._cold_migrate(self.context, inst_obj, flavor, {}, self.conductor._cold_migrate(self.context, inst_obj, self.flavor, {},
True, fake_spec, None) True, fake_spec, None)
# Now the RequestSpec should be updated... # Now the RequestSpec should be updated...
self.assertEqual(flavor, fake_spec.flavor) self.assertEqual(self.flavor, fake_spec.flavor)
# ...and persisted # ...and persisted
spec_save_mock.assert_called_once_with() spec_save_mock.assert_called_once_with()
def test_resize_no_valid_host_error_msg(self): def test_resize_no_valid_host_error_msg(self):
flavor = flavors.get_flavor_by_name('m1.tiny') flavor_new = objects.Flavor.get_by_name(self.ctxt, 'm1.small')
flavor_new = flavors.get_flavor_by_name('m1.small')
inst_obj = objects.Instance( inst_obj = objects.Instance(
image_ref='fake-image_ref', image_ref='fake-image_ref',
vm_state=vm_states.STOPPED, vm_state=vm_states.STOPPED,
instance_type_id=flavor['id'], instance_type_id=self.flavor.id,
system_metadata={}, system_metadata={},
uuid=uuids.instance, uuid=uuids.instance,
user_id=fakes.FAKE_USER_ID) user_id=fakes.FAKE_USER_ID)

5
nova/tests/unit/network/test_api.py
View File

@ -22,7 +22,6 @@ import mock
from oslo_utils.fixture import uuidsentinel as uuids from oslo_utils.fixture import uuidsentinel as uuids
from oslo_utils import uuidutils from oslo_utils import uuidutils
from nova.compute import flavors
from nova import context from nova import context
from nova import exception from nova import exception
from nova import network from nova import network
@ -140,7 +139,7 @@ class ApiTestCase(test.TestCase):
'macs'], 'macs'],
itertools.repeat(mock.ANY))) itertools.repeat(mock.ANY)))
mock_alloc.return_value = [] mock_alloc.return_value = []
flavor = flavors.get_default_flavor() flavor = objects.Flavor.get_by_name(self.context, 'm1.small')
flavor['rxtx_factor'] = 0 flavor['rxtx_factor'] = 0
instance = objects.Instance(id=1, uuid=uuids.instance, instance = objects.Instance(id=1, uuid=uuids.instance,
project_id='project_id', project_id='project_id',
@ -254,7 +253,7 @@ class ApiTestCase(test.TestCase):
self.context.project_id) self.context.project_id)
def _stub_migrate_instance_calls(self, method, multi_host, info): def _stub_migrate_instance_calls(self, method, multi_host, info):
fake_flavor = flavors.get_default_flavor() fake_flavor = objects.Flavor.get_by_name(self.context, 'm1.small')
fake_flavor['rxtx_factor'] = 1.21 fake_flavor['rxtx_factor'] = 1.21
fake_instance = objects.Instance( fake_instance = objects.Instance(
uuid=uuidutils.generate_uuid(dashed=False), uuid=uuidutils.generate_uuid(dashed=False),

3
nova/tests/unit/network/test_neutronv2.py
View File

@ -36,7 +36,6 @@ import requests_mock
import six import six
from six.moves import range from six.moves import range
from nova.compute import flavors
from nova import context from nova import context
from nova.db.sqlalchemy import api as db_api from nova.db.sqlalchemy import api as db_api
from nova import exception from nova import exception
@ -3101,7 +3100,7 @@ class TestNeutronv2WithMock(TestNeutronv2Base):
mock_get_client.return_value = mocked_client mock_get_client.return_value = mocked_client
mocked_client.list_extensions.return_value = { mocked_client.list_extensions.return_value = {
'extensions': [{'name': constants.QOS_QUEUE}]} 'extensions': [{'name': constants.QOS_QUEUE}]}
flavor = flavors.get_default_flavor() flavor = objects.Flavor.get_by_name(self.context, 'm1.small')
flavor['rxtx_factor'] = 1 flavor['rxtx_factor'] = 1
instance = objects.Instance(system_metadata={}) instance = objects.Instance(system_metadata={})
instance.flavor = flavor instance.flavor = flavor

5
nova/tests/unit/objects/test_instance.py
View File

@ -22,7 +22,6 @@ from oslo_utils.fixture import uuidsentinel as uuids
from oslo_utils import timeutils from oslo_utils import timeutils
from nova.cells import rpcapi as cells_rpcapi from nova.cells import rpcapi as cells_rpcapi
from nova.compute import flavors
from nova.compute import task_states from nova.compute import task_states
from nova.compute import vm_states from nova.compute import vm_states
from nova.db import api as db from nova.db import api as db
@ -1359,13 +1358,13 @@ class _TestInstanceObject(object):
self.assertIsNotNone(instance.pci_requests) self.assertIsNotNone(instance.pci_requests)
def test_get_flavor(self): def test_get_flavor(self):
db_flavor = flavors.get_default_flavor() db_flavor = objects.Flavor.get_by_name(self.context, 'm1.small')
inst = objects.Instance(flavor=db_flavor) inst = objects.Instance(flavor=db_flavor)
self.assertEqual(db_flavor['flavorid'], self.assertEqual(db_flavor['flavorid'],
inst.get_flavor().flavorid) inst.get_flavor().flavorid)
def test_get_flavor_namespace(self): def test_get_flavor_namespace(self):
db_flavor = flavors.get_default_flavor() db_flavor = objects.Flavor.get_by_name(self.context, 'm1.small')
inst = objects.Instance(old_flavor=db_flavor) inst = objects.Instance(old_flavor=db_flavor)
self.assertEqual(db_flavor['flavorid'], self.assertEqual(db_flavor['flavorid'],
inst.get_flavor('old').flavorid) inst.get_flavor('old').flavorid)

33
nova/tests/unit/test_flavors.py
View File

@ -24,25 +24,6 @@ from nova import test
class InstanceTypeTestCase(test.TestCase): class InstanceTypeTestCase(test.TestCase):
"""Test cases for flavor code.""" """Test cases for flavor code."""
def test_will_not_get_bad_default_instance_type(self):
# ensures error raised on bad default flavor.
self.flags(default_flavor='unknown_flavor')
self.assertRaises(exception.FlavorNotFound,
flavors.get_default_flavor)
def test_flavor_get_by_None_name_returns_default(self):
# Ensure get by name returns default flavor with no name.
default = flavors.get_default_flavor()
actual = flavors.get_flavor_by_name(None)
self.assertIsInstance(default, objects.Flavor)
self.assertIsInstance(actual, objects.Flavor)
self.assertEqual(default.flavorid, actual.flavorid)
def test_will_not_get_flavor_with_bad_name(self):
# Ensure get by name returns default flavor with bad name.
self.assertRaises(exception.FlavorNotFound,
flavors.get_flavor_by_name, 10000)
def test_will_not_get_instance_by_unknown_flavor_id(self): def test_will_not_get_instance_by_unknown_flavor_id(self):
# Ensure get by flavor raises error with wrong flavorid. # Ensure get by flavor raises error with wrong flavorid.
self.assertRaises(exception.FlavorNotFound, self.assertRaises(exception.FlavorNotFound,
@ -50,7 +31,8 @@ class InstanceTypeTestCase(test.TestCase):
'unknown_flavor') 'unknown_flavor')
def test_will_get_instance_by_flavor_id(self): def test_will_get_instance_by_flavor_id(self):
default_instance_type = flavors.get_default_flavor() default_instance_type = objects.Flavor.get_by_name(
context.get_admin_context(), 'm1.small')
flavorid = default_instance_type.flavorid flavorid = default_instance_type.flavorid
fetched = flavors.get_flavor_by_flavor_id(flavorid) fetched = flavors.get_flavor_by_flavor_id(flavorid)
self.assertIsInstance(fetched, objects.Flavor) self.assertIsInstance(fetched, objects.Flavor)
@ -58,11 +40,16 @@ class InstanceTypeTestCase(test.TestCase):
class InstanceTypeToolsTest(test.TestCase): class InstanceTypeToolsTest(test.TestCase):
def setUp(self):
super(InstanceTypeToolsTest, self).setUp()
self.context = context.get_admin_context()
def _dict_to_metadata(self, data): def _dict_to_metadata(self, data):
return [{'key': key, 'value': value} for key, value in data.items()] return [{'key': key, 'value': value} for key, value in data.items()]
def _test_extract_flavor(self, prefix): def _test_extract_flavor(self, prefix):
instance_type = flavors.get_default_flavor() instance_type = objects.Flavor.get_by_name(self.context, 'm1.small')
instance_type_p = obj_base.obj_to_primitive(instance_type) instance_type_p = obj_base.obj_to_primitive(instance_type)
metadata = {} metadata = {}
@ -92,7 +79,7 @@ class InstanceTypeToolsTest(test.TestCase):
self._test_extract_flavor('foo_') self._test_extract_flavor('foo_')
def test_save_flavor_info(self): def test_save_flavor_info(self):
instance_type = flavors.get_default_flavor() instance_type = objects.Flavor.get_by_name(self.context, 'm1.small')
example = {} example = {}
example_prefix = {} example_prefix = {}
@ -110,7 +97,7 @@ class InstanceTypeToolsTest(test.TestCase):
self.assertEqual(example_prefix, metadata) self.assertEqual(example_prefix, metadata)
def test_flavor_numa_extras_are_saved(self): def test_flavor_numa_extras_are_saved(self):
instance_type = flavors.get_default_flavor() instance_type = objects.Flavor.get_by_name(self.context, 'm1.small')
instance_type['extra_specs'] = { instance_type['extra_specs'] = {
'hw:numa_mem.0': '123', 'hw:numa_mem.0': '123',
'hw:numa_cpus.0': '456', 'hw:numa_cpus.0': '456',

3
nova/tests/unit/test_metadata.py
View File

@ -44,7 +44,6 @@ from nova.api.metadata import handler
from nova.api.metadata import password from nova.api.metadata import password
from nova.api.metadata import vendordata_dynamic from nova.api.metadata import vendordata_dynamic
from nova import block_device from nova import block_device
from nova.compute import flavors
from nova import context from nova import context
from nova import exception from nova import exception
from nova.network import model as network_model from nova.network import model as network_model
@ -101,7 +100,7 @@ def fake_inst_obj(context):
inst.info_cache = objects.InstanceInfoCache(context=context, inst.info_cache = objects.InstanceInfoCache(context=context,
instance_uuid=inst.uuid, instance_uuid=inst.uuid,
network_info=nwinfo) network_info=nwinfo)
inst.flavor = flavors.get_default_flavor() inst.flavor = objects.Flavor.get_by_name(context, 'm1.small')
return inst return inst

3
nova/tests/unit/test_notifications.py
View File

@ -24,7 +24,6 @@ from oslo_context import fixture as o_fixture
from oslo_utils.fixture import uuidsentinel as uuids from oslo_utils.fixture import uuidsentinel as uuids
from oslo_utils import timeutils from oslo_utils import timeutils
from nova.compute import flavors
from nova.compute import task_states from nova.compute import task_states
from nova.compute import vm_states from nova.compute import vm_states
from nova import context from nova import context
@ -77,7 +76,7 @@ class NotificationsTestCase(test.TestCase):
self.decorated_function_called = False self.decorated_function_called = False
def _wrapped_create(self, params=None): def _wrapped_create(self, params=None):
instance_type = flavors.get_flavor_by_name('m1.tiny') instance_type = objects.Flavor.get_by_name(self.context, 'm1.tiny')
inst = objects.Instance(image_ref=uuids.image_ref, inst = objects.Instance(image_ref=uuids.image_ref,
user_id=self.user_id, user_id=self.user_id,
project_id=self.project_id, project_id=self.project_id,

19
nova/tests/unit/test_quota.py
View File

@ -19,7 +19,6 @@ from oslo_db.sqlalchemy import enginefacade
from six.moves import range from six.moves import range
from nova import compute from nova import compute
from nova.compute import flavors
import nova.conf import nova.conf
from nova import context from nova import context
from nova.db import api as db from nova.db import api as db
@ -68,6 +67,7 @@ class QuotaIntegrationTestCase(test.TestCase):
self.context = context.RequestContext(self.user_id, self.context = context.RequestContext(self.user_id,
self.project_id, self.project_id,
is_admin=True) is_admin=True)
self.inst_type = objects.Flavor.get_by_name(self.context, 'm1.small')
nova.tests.unit.image.fake.stub_out_image_service(self) nova.tests.unit.image.fake.stub_out_image_service(self)
@ -94,7 +94,7 @@ class QuotaIntegrationTestCase(test.TestCase):
inst.reservation_id = 'r-fakeres' inst.reservation_id = 'r-fakeres'
inst.user_id = self.user_id inst.user_id = self.user_id
inst.project_id = self.project_id inst.project_id = self.project_id
inst.flavor = flavors.get_flavor_by_name(flavor_name) inst.flavor = objects.Flavor.get_by_name(cctxt, flavor_name)
# This is needed for instance quota counting until we have the # This is needed for instance quota counting until we have the
# ability to count allocations in placement. # ability to count allocations in placement.
inst.vcpus = inst.flavor.vcpus inst.vcpus = inst.flavor.vcpus
@ -111,11 +111,10 @@ class QuotaIntegrationTestCase(test.TestCase):
def test_too_many_instances(self): def test_too_many_instances(self):
for i in range(CONF.quota.instances): for i in range(CONF.quota.instances):
self._create_instance() self._create_instance()
inst_type = flavors.get_flavor_by_name('m1.small')
image_uuid = 'cedef40a-ed67-4d10-800e-17455edce175' image_uuid = 'cedef40a-ed67-4d10-800e-17455edce175'
try: try:
self.compute_api.create(self.context, min_count=1, max_count=1, self.compute_api.create(self.context, min_count=1, max_count=1,
instance_type=inst_type, instance_type=self.inst_type,
image_href=image_uuid) image_href=image_uuid)
except exception.QuotaError as e: except exception.QuotaError as e:
expected_kwargs = {'code': 413, expected_kwargs = {'code': 413,
@ -129,11 +128,10 @@ class QuotaIntegrationTestCase(test.TestCase):
def test_too_many_cores(self): def test_too_many_cores(self):
self._create_instance() self._create_instance()
inst_type = flavors.get_flavor_by_name('m1.small')
image_uuid = 'cedef40a-ed67-4d10-800e-17455edce175' image_uuid = 'cedef40a-ed67-4d10-800e-17455edce175'
try: try:
self.compute_api.create(self.context, min_count=1, max_count=1, self.compute_api.create(self.context, min_count=1, max_count=1,
instance_type=inst_type, instance_type=self.inst_type,
image_href=image_uuid) image_href=image_uuid)
except exception.QuotaError as e: except exception.QuotaError as e:
expected_kwargs = {'code': 413, expected_kwargs = {'code': 413,
@ -199,30 +197,27 @@ class QuotaIntegrationTestCase(test.TestCase):
metadata = {} metadata = {}
for i in range(CONF.quota.metadata_items + 1): for i in range(CONF.quota.metadata_items + 1):
metadata['key%s' % i] = 'value%s' % i metadata['key%s' % i] = 'value%s' % i
inst_type = flavors.get_flavor_by_name('m1.small')
image_uuid = 'cedef40a-ed67-4d10-800e-17455edce175' image_uuid = 'cedef40a-ed67-4d10-800e-17455edce175'
self.assertRaises(exception.QuotaError, self.compute_api.create, self.assertRaises(exception.QuotaError, self.compute_api.create,
self.context, self.context,
min_count=1, min_count=1,
max_count=1, max_count=1,
instance_type=inst_type, instance_type=self.inst_type,
image_href=image_uuid, image_href=image_uuid,
metadata=metadata) metadata=metadata)
def _create_with_injected_files(self, files): def _create_with_injected_files(self, files):
api = self.compute_api api = self.compute_api
inst_type = flavors.get_flavor_by_name('m1.small')
image_uuid = 'cedef40a-ed67-4d10-800e-17455edce175' image_uuid = 'cedef40a-ed67-4d10-800e-17455edce175'
api.create(self.context, min_count=1, max_count=1, api.create(self.context, min_count=1, max_count=1,
instance_type=inst_type, image_href=image_uuid, instance_type=self.inst_type, image_href=image_uuid,
injected_files=files) injected_files=files)
def test_no_injected_files(self): def test_no_injected_files(self):
api = self.compute_api api = self.compute_api
inst_type = flavors.get_flavor_by_name('m1.small')
image_uuid = 'cedef40a-ed67-4d10-800e-17455edce175' image_uuid = 'cedef40a-ed67-4d10-800e-17455edce175'
api.create(self.context, api.create(self.context,
instance_type=inst_type, instance_type=self.inst_type,
image_href=image_uuid) image_href=image_uuid)
def test_max_injected_files(self): def test_max_injected_files(self):

4
releasenotes/notes/remove-deprecated-default-flavor-opt-a3dfafe59b076153.yaml Normal file
View File

@ -0,0 +1,4 @@
---
upgrade:
- The ``[DEFAULT]/default_flavor`` option deprecated in 14.0.0 (Newton)
has been removed.