diff --git a/nova/tests/test_instance_types.py b/nova/tests/test_instance_types.py index 5c8b4be1..5afa4005 100644 --- a/nova/tests/test_instance_types.py +++ b/nova/tests/test_instance_types.py @@ -17,7 +17,7 @@ Unit Tests for instance types code """ import time -from nova.compute import instance_types +from nova.compute import flavors from nova import context from nova import db from nova.db.sqlalchemy import models @@ -31,7 +31,7 @@ class InstanceTypeTestCase(test.TestCase): def _generate_name(self): """return a name not in the DB.""" nonexistent_flavor = str(int(time.time())) - flavors = instance_types.get_all_types() + flavors = flavors.get_all_types() while nonexistent_flavor in flavors: nonexistent_flavor += "z" else: @@ -41,7 +41,7 @@ class InstanceTypeTestCase(test.TestCase): """return a flavorid not in the DB.""" nonexistent_flavor = 2700 flavor_ids = [value["id"] for key, value in - instance_types.get_all_types().iteritems()] + flavors.get_all_types().iteritems()] while nonexistent_flavor in flavor_ids: nonexistent_flavor += 1 else: @@ -49,17 +49,17 @@ class InstanceTypeTestCase(test.TestCase): def _existing_flavor(self): """return first instance type name.""" - return instance_types.get_all_types().keys()[0] + return flavors.get_all_types().keys()[0] def test_instance_type_create(self): # Ensure instance types can be created. name = 'Instance create test' flavor_id = '512' - original_list = instance_types.get_all_types() + original_list = flavors.get_all_types() # create new type and make sure values stick - inst_type = instance_types.create(name, 256, 1, 120, + inst_type = flavors.create(name, 256, 1, 120, flavorid=flavor_id) self.assertEqual(inst_type['flavorid'], flavor_id) self.assertEqual(inst_type['name'], name) @@ -71,7 +71,7 @@ class InstanceTypeTestCase(test.TestCase): self.assertEqual(inst_type['rxtx_factor'], 1.0) # make sure new type shows up in list - new_list = instance_types.get_all_types() + new_list = flavors.get_all_types() self.assertNotEqual(len(original_list), len(new_list), 'instance type was not created') @@ -80,10 +80,10 @@ class InstanceTypeTestCase(test.TestCase): name = 'Small Flavor' flavorid = 'flavor1' - original_list = instance_types.get_all_types() + original_list = flavors.get_all_types() # create new type and make sure values stick - inst_type = instance_types.create(name, 256, 1, 120, 100, flavorid) + inst_type = flavors.create(name, 256, 1, 120, 100, flavorid) inst_type_id = inst_type['id'] self.assertEqual(inst_type['flavorid'], flavorid) self.assertEqual(inst_type['name'], name) @@ -95,21 +95,21 @@ class InstanceTypeTestCase(test.TestCase): self.assertEqual(inst_type['rxtx_factor'], 1.0) # make sure new type shows up in list - new_list = instance_types.get_all_types() + new_list = flavors.get_all_types() self.assertNotEqual(len(original_list), len(new_list), 'instance type was not created') - instance_types.destroy(name) + flavors.destroy(name) self.assertRaises(exception.InstanceTypeNotFound, - instance_types.get_instance_type, inst_type_id) + flavors.get_instance_type, inst_type_id) # deleted instance should not be in list anymoer - new_list = instance_types.get_all_types() + new_list = flavors.get_all_types() self.assertEqual(original_list, new_list) def test_instance_type_create_without_flavorid(self): name = 'Small Flavor' - inst_type = instance_types.create(name, 256, 1, 120, 100) + inst_type = flavors.create(name, 256, 1, 120, 100) self.assertNotEqual(inst_type['flavorid'], None) self.assertEqual(inst_type['name'], name) self.assertEqual(inst_type['memory_mb'], 256) @@ -123,7 +123,7 @@ class InstanceTypeTestCase(test.TestCase): # Ensure that auto-generated uuid is assigned. name = 'Empty String ID Flavor' flavorid = '' - inst_type = instance_types.create(name, 256, 1, 120, 100, flavorid) + inst_type = flavors.create(name, 256, 1, 120, 100, flavorid) self.assertEqual(len(inst_type['flavorid']), 36) self.assertEqual(inst_type['name'], name) self.assertEqual(inst_type['memory_mb'], 256) @@ -135,7 +135,7 @@ class InstanceTypeTestCase(test.TestCase): def test_instance_type_create_with_custom_rxtx_factor(self): name = 'Custom RXTX Factor' - inst_type = instance_types.create(name, 256, 1, 120, 100, + inst_type = flavors.create(name, 256, 1, 120, 100, rxtx_factor=9.9) self.assertNotEqual(inst_type['flavorid'], None) self.assertEqual(inst_type['name'], name) @@ -150,18 +150,18 @@ class InstanceTypeTestCase(test.TestCase): # Ensure instance types raises InvalidInput for invalid characters. name = "foo.bar!@#$%^-test_name" flavorid = "flavor1" - self.assertRaises(exception.InvalidInput, instance_types.create, + self.assertRaises(exception.InvalidInput, flavors.create, name, 256, 1, 120, 100, flavorid) def test_instance_type_create_with_long_flavor_name(self): # Flavor name with 255 characters or less is valid. name = 'a' * 255 - inst_type = instance_types.create(name, 64, 1, 120, flavorid=11) + inst_type = flavors.create(name, 64, 1, 120, flavorid=11) self.assertEqual(inst_type['name'], name) # Flavor name which is more than 255 characters will cause error. name = 'a' * 256 - self.assertRaises(exception.InvalidInput, instance_types.create, + self.assertRaises(exception.InvalidInput, flavors.create, name, 64, 1, 120, flavorid=11) def test_add_instance_type_access(self): @@ -169,9 +169,9 @@ class InstanceTypeTestCase(test.TestCase): project_id = 'fake' ctxt = context.RequestContext(user_id, project_id, is_admin=True) flavor_id = 'flavor1' - type_ref = instance_types.create('some flavor', 256, 1, 120, 100, + type_ref = flavors.create('some flavor', 256, 1, 120, 100, flavorid=flavor_id) - access_ref = instance_types.add_instance_type_access(flavor_id, + access_ref = flavors.add_instance_type_access(flavor_id, project_id, ctxt=ctxt) self.assertEqual(access_ref["project_id"], project_id) @@ -182,13 +182,13 @@ class InstanceTypeTestCase(test.TestCase): project_id = 'fake' ctxt = context.RequestContext(user_id, project_id, is_admin=True) flavor_id = 'flavor1' - type_ref = instance_types.create('some flavor', 256, 1, 120, 100, + type_ref = flavors.create('some flavor', 256, 1, 120, 100, flavorid=flavor_id) - access_ref = instance_types.add_instance_type_access(flavor_id, + access_ref = flavors.add_instance_type_access(flavor_id, project_id, ctxt=ctxt) self.assertRaises(exception.FlavorAccessExists, - instance_types.add_instance_type_access, + flavors.add_instance_type_access, flavor_id, project_id, ctxt) def test_add_instance_type_access_invalid_flavor(self): @@ -197,7 +197,7 @@ class InstanceTypeTestCase(test.TestCase): ctxt = context.RequestContext(user_id, project_id, is_admin=True) flavor_id = 'no_such_flavor' self.assertRaises(exception.FlavorNotFound, - instance_types.add_instance_type_access, + flavors.add_instance_type_access, flavor_id, project_id, ctxt) def test_remove_instance_type_access(self): @@ -205,13 +205,14 @@ class InstanceTypeTestCase(test.TestCase): project_id = 'fake' ctxt = context.RequestContext(user_id, project_id, is_admin=True) flavor_id = 'flavor1' - it = instance_types - type_ref = it.create('some flavor', 256, 1, 120, 100, + type_ref = flavors.create('some flavor', 256, 1, 120, 100, flavorid=flavor_id) - access_ref = it.add_instance_type_access(flavor_id, project_id, ctxt) - it.remove_instance_type_access(flavor_id, project_id, ctxt) + access_ref = flavors.add_instance_type_access(flavor_id, project_id, + ctxt) + flavors.remove_instance_type_access(flavor_id, project_id, ctxt) - projects = it.get_instance_type_access_by_flavor_id(flavor_id, ctxt) + projects = flavors.get_instance_type_access_by_flavor_id(flavor_id, + ctxt) self.assertEqual([], projects) def test_remove_instance_type_access_doesnt_exists(self): @@ -219,17 +220,17 @@ class InstanceTypeTestCase(test.TestCase): project_id = 'fake' ctxt = context.RequestContext(user_id, project_id, is_admin=True) flavor_id = 'flavor1' - type_ref = instance_types.create('some flavor', 256, 1, 120, 100, + type_ref = flavors.create('some flavor', 256, 1, 120, 100, flavorid=flavor_id) self.assertRaises(exception.FlavorAccessNotFound, - instance_types.remove_instance_type_access, + flavors.remove_instance_type_access, flavor_id, project_id, ctxt=ctxt) def test_get_all_instance_types(self): # Ensures that all instance types can be retrieved. session = sql_session.get_session() total_instance_types = session.query(models.InstanceTypes).count() - inst_types = instance_types.get_all_types() + inst_types = flavors.get_all_types() self.assertEqual(total_instance_types, len(inst_types)) def test_invalid_create_args_should_fail(self): @@ -257,78 +258,78 @@ class InstanceTypeTestCase(test.TestCase): for (args, kwargs) in invalid_sigs: self.assertRaises(exception.InvalidInput, - instance_types.create, *args, **kwargs) + flavors.create, *args, **kwargs) def test_non_existent_inst_type_shouldnt_delete(self): # Ensures that instance type creation fails with invalid args. self.assertRaises(exception.InstanceTypeNotFoundByName, - instance_types.destroy, + flavors.destroy, 'unknown_flavor') def test_duplicate_names_fail(self): # Ensures that name duplicates raise InstanceTypeCreateFailed. name = 'some_name' - instance_types.create(name, 256, 1, 120, 200, 'flavor1') + flavors.create(name, 256, 1, 120, 200, 'flavor1') self.assertRaises(exception.InstanceTypeExists, - instance_types.create, + flavors.create, name, 256, 1, 120, 200, 'flavor2') def test_duplicate_flavorids_fail(self): # Ensures that flavorid duplicates raise InstanceTypeCreateFailed. flavorid = 'flavor1' - instance_types.create('name one', 256, 1, 120, 200, flavorid) + flavors.create('name one', 256, 1, 120, 200, flavorid) self.assertRaises(exception.InstanceTypeIdExists, - instance_types.create, + flavors.create, 'name two', 256, 1, 120, 200, flavorid) def test_will_not_destroy_with_no_name(self): # Ensure destroy said path of no name raises error. self.assertRaises(exception.InstanceTypeNotFoundByName, - instance_types.destroy, None) + flavors.destroy, None) def test_will_not_get_bad_default_instance_type(self): # ensures error raised on bad default instance type. self.flags(default_instance_type='unknown_flavor') self.assertRaises(exception.InstanceTypeNotFound, - instance_types.get_default_instance_type) + flavors.get_default_instance_type) def test_will_get_instance_type_by_id(self): - default_instance_type = instance_types.get_default_instance_type() + default_instance_type = flavors.get_default_instance_type() instance_type_id = default_instance_type['id'] - fetched = instance_types.get_instance_type(instance_type_id) + fetched = flavors.get_instance_type(instance_type_id) self.assertEqual(default_instance_type, fetched) def test_will_not_get_instance_type_by_unknown_id(self): # Ensure get by name returns default flavor with no name. self.assertRaises(exception.InstanceTypeNotFound, - instance_types.get_instance_type, 10000) + flavors.get_instance_type, 10000) def test_will_not_get_instance_type_with_bad_id(self): # Ensure get by name returns default flavor with bad name. self.assertRaises(exception.InstanceTypeNotFound, - instance_types.get_instance_type, 'asdf') + flavors.get_instance_type, 'asdf') def test_instance_type_get_by_None_name_returns_default(self): # Ensure get by name returns default flavor with no name. - default = instance_types.get_default_instance_type() - actual = instance_types.get_instance_type_by_name(None) + default = flavors.get_default_instance_type() + actual = flavors.get_instance_type_by_name(None) self.assertEqual(default, actual) def test_will_not_get_instance_type_with_bad_name(self): # Ensure get by name returns default flavor with bad name. self.assertRaises(exception.InstanceTypeNotFound, - instance_types.get_instance_type_by_name, 10000) + flavors.get_instance_type_by_name, 10000) def test_will_not_get_instance_by_unknown_flavor_id(self): # Ensure get by flavor raises error with wrong flavorid. self.assertRaises(exception.FlavorNotFound, - instance_types.get_instance_type_by_flavor_id, + flavors.get_instance_type_by_flavor_id, 'unknown_flavor') def test_will_get_instance_by_flavor_id(self): - default_instance_type = instance_types.get_default_instance_type() + default_instance_type = flavors.get_default_instance_type() flavorid = default_instance_type['flavorid'] - fetched = instance_types.get_instance_type_by_flavor_id(flavorid) + fetched = flavors.get_instance_type_by_flavor_id(flavorid) self.assertEqual(default_instance_type, fetched) def test_can_read_deleted_types_using_flavor_id(self): @@ -336,15 +337,15 @@ class InstanceTypeTestCase(test.TestCase): inst_type_name = "test" inst_type_flavor_id = "test1" - inst_type = instance_types.create(inst_type_name, 256, 1, 120, 100, + inst_type = flavors.create(inst_type_name, 256, 1, 120, 100, inst_type_flavor_id) self.assertEqual(inst_type_name, inst_type["name"]) # NOTE(jk0): The deleted flavor will show up here because the context # in get_instance_type_by_flavor_id() is set to use read_deleted by # default. - instance_types.destroy(inst_type["name"]) - deleted_inst_type = instance_types.get_instance_type_by_flavor_id( + flavors.destroy(inst_type["name"]) + deleted_inst_type = flavors.get_instance_type_by_flavor_id( inst_type_flavor_id) self.assertEqual(inst_type_name, deleted_inst_type["name"]) @@ -354,11 +355,11 @@ class InstanceTypeTestCase(test.TestCase): example when creating a server and attempting to translate from flavorid to instance_type_id. """ - instance_types.create("instance_type1", 256, 1, 120, 100, "test1") - instance_types.destroy("instance_type1") - instance_types.create("instance_type1_redo", 256, 1, 120, 100, "test1") + flavors.create("instance_type1", 256, 1, 120, 100, "test1") + flavors.destroy("instance_type1") + flavors.create("instance_type1_redo", 256, 1, 120, 100, "test1") - instance_type = instance_types.get_instance_type_by_flavor_id( + instance_type = flavors.get_instance_type_by_flavor_id( "test1", read_deleted="no") self.assertEqual("instance_type1_redo", instance_type["name"]) @@ -368,15 +369,15 @@ class InstanceTypeToolsTest(test.TestCase): return [{'key': key, 'value': value} for key, value in data.items()] def _test_extract_instance_type(self, prefix): - instance_type = instance_types.get_default_instance_type() + instance_type = flavors.get_default_instance_type() metadata = {} - instance_types.save_instance_type_info(metadata, instance_type, + flavors.save_instance_type_info(metadata, instance_type, prefix) instance = {'system_metadata': self._dict_to_metadata(metadata)} - _instance_type = instance_types.extract_instance_type(instance, prefix) + _instance_type = flavors.extract_instance_type(instance, prefix) - props = instance_types.system_metadata_instance_type_props.keys() + props = flavors.system_metadata_instance_type_props.keys() for key in instance_type.keys(): if key not in props: del instance_type[key] @@ -390,29 +391,29 @@ class InstanceTypeToolsTest(test.TestCase): self._test_extract_instance_type('foo_') def test_save_instance_type_info(self): - instance_type = instance_types.get_default_instance_type() + instance_type = flavors.get_default_instance_type() example = {} example_prefix = {} - for key in instance_types.system_metadata_instance_type_props.keys(): + for key in flavors.system_metadata_instance_type_props.keys(): example['instance_type_%s' % key] = instance_type[key] example_prefix['fooinstance_type_%s' % key] = instance_type[key] metadata = {} - instance_types.save_instance_type_info(metadata, instance_type) + flavors.save_instance_type_info(metadata, instance_type) self.assertEqual(example, metadata) metadata = {} - instance_types.save_instance_type_info(metadata, instance_type, 'foo') + flavors.save_instance_type_info(metadata, instance_type, 'foo') self.assertEqual(example_prefix, metadata) def test_delete_instance_type_info(self): - instance_type = instance_types.get_default_instance_type() + instance_type = flavors.get_default_instance_type() metadata = {} - instance_types.save_instance_type_info(metadata, instance_type) - instance_types.save_instance_type_info(metadata, instance_type, '_') - instance_types.delete_instance_type_info(metadata, '', '_') + flavors.save_instance_type_info(metadata, instance_type) + flavors.save_instance_type_info(metadata, instance_type, '_') + flavors.delete_instance_type_info(metadata, '', '_') self.assertEqual(metadata, {}) diff --git a/nova/tests/test_libvirt.py b/nova/tests/test_libvirt.py index a955d2f3..35b65d76 100644 --- a/nova/tests/test_libvirt.py +++ b/nova/tests/test_libvirt.py @@ -31,7 +31,7 @@ from oslo.config import cfg from xml.dom import minidom from nova.api.ec2 import cloud -from nova.compute import instance_types +from nova.compute import flavors from nova.compute import power_state from nova.compute import task_states from nova.compute import vm_mode @@ -320,7 +320,7 @@ class LibvirtConnTestCase(test.TestCase): lambda *a, **k: self.conn) instance_type = db.instance_type_get(self.context, 5) - sys_meta = instance_types.save_instance_type_info({}, instance_type) + sys_meta = flavors.save_instance_type_info({}, instance_type) nova.tests.image.fake.stub_out_image_service(self.stubs) self.test_instance = { @@ -2557,7 +2557,7 @@ class LibvirtConnTestCase(test.TestCase): instance_ref['image_ref'] = 123456 # we send an int to test sha1 call instance_type = db.instance_type_get(self.context, instance_ref['instance_type_id']) - sys_meta = instance_types.save_instance_type_info({}, instance_type) + sys_meta = flavors.save_instance_type_info({}, instance_type) instance_ref['system_metadata'] = sys_meta instance = db.instance_create(self.context, instance_ref) @@ -4724,8 +4724,8 @@ class LibvirtDriverTestCase(test.TestCase): if not params: params = {} - sys_meta = instance_types.save_instance_type_info( - {}, instance_types.get_instance_type_by_name('m1.tiny')) + sys_meta = flavors.save_instance_type_info( + {}, flavors.get_instance_type_by_name('m1.tiny')) inst = {} inst['image_ref'] = '1' @@ -4733,7 +4733,7 @@ class LibvirtDriverTestCase(test.TestCase): inst['launch_time'] = '10' inst['user_id'] = 'fake' inst['project_id'] = 'fake' - type_id = instance_types.get_instance_type_by_name('m1.tiny')['id'] + type_id = flavors.get_instance_type_by_name('m1.tiny')['id'] inst['instance_type_id'] = type_id inst['ami_launch_index'] = 0 inst['host'] = 'host1' diff --git a/nova/tests/test_libvirt_blockinfo.py b/nova/tests/test_libvirt_blockinfo.py index eef2deb5..aae5bec5 100644 --- a/nova/tests/test_libvirt_blockinfo.py +++ b/nova/tests/test_libvirt_blockinfo.py @@ -16,7 +16,7 @@ # under the License. from nova import block_device -from nova.compute import instance_types +from nova.compute import flavors from nova import context from nova import db from nova import exception @@ -34,7 +34,7 @@ class LibvirtBlockInfoTest(test.TestCase): self.project_id = 'fake' self.context = context.get_admin_context() instance_type = db.instance_type_get(self.context, 2) - sys_meta = instance_types.save_instance_type_info({}, instance_type) + sys_meta = flavors.save_instance_type_info({}, instance_type) nova.tests.image.fake.stub_out_image_service(self.stubs) self.test_instance = { 'uuid': '32dfcb37-5af1-552b-357c-be8c3aa38310', diff --git a/nova/tests/test_powervm.py b/nova/tests/test_powervm.py index 73299f23..2a2a072b 100644 --- a/nova/tests/test_powervm.py +++ b/nova/tests/test_powervm.py @@ -24,7 +24,7 @@ from nova import context from nova import db from nova import test -from nova.compute import instance_types +from nova.compute import flavors from nova.compute import power_state from nova.compute import task_states from nova.network import model as network_model @@ -180,7 +180,7 @@ class PowerVMDriverTestCase(test.TestCase): fake.stub_out_image_service(self.stubs) ctxt = context.get_admin_context() instance_type = db.instance_type_get(ctxt, 1) - sys_meta = instance_types.save_instance_type_info({}, instance_type) + sys_meta = flavors.save_instance_type_info({}, instance_type) return db.instance_create(ctxt, {'user_id': 'fake', 'project_id': 'fake', diff --git a/nova/tests/test_xenapi.py b/nova/tests/test_xenapi.py index 3490a5db..091bf472 100644 --- a/nova/tests/test_xenapi.py +++ b/nova/tests/test_xenapi.py @@ -26,7 +26,7 @@ import re from oslo.config import cfg from nova.compute import api as compute_api -from nova.compute import instance_types +from nova.compute import flavors from nova.compute import power_state from nova.compute import task_states from nova.compute import vm_states @@ -179,7 +179,7 @@ def stub_vm_utils_with_vdi_attached_here(function, should_return=True): def create_instance_with_system_metadata(context, instance_values): instance_type = db.instance_type_get(context, instance_values['instance_type_id']) - sys_meta = instance_types.save_instance_type_info({}, + sys_meta = flavors.save_instance_type_info({}, instance_type) instance_values['system_metadata'] = sys_meta return db.instance_create(context, instance_values) @@ -1188,7 +1188,7 @@ class XenAPIVMTestCase(stubs.XenAPITestBase): def test_per_instance_usage_running(self): instance = self._create_instance(spawn=True) - instance_type = instance_types.get_instance_type(3) + instance_type = flavors.get_instance_type(3) expected = {instance['uuid']: {'memory_mb': instance_type['memory_mb'], 'uuid': instance['uuid']}} @@ -1461,7 +1461,7 @@ class XenAPIMigrateInstance(stubs.XenAPITestBase): self.assertEqual(self.fake_vm_start_called, True) def test_finish_migrate_no_local_storage(self): - tiny_type = instance_types.get_instance_type_by_name('m1.tiny') + tiny_type = flavors.get_instance_type_by_name('m1.tiny') tiny_type_id = tiny_type['id'] self.instance_values.update({'instance_type_id': tiny_type_id, 'root_gb': 0})