Merge sync branch and trunk

10 files changed, 300 insertions, 16 deletions

diff --git a/nova/tests/api/openstack/test_common.py b/nova/tests/api/openstack/test_common.py
index 59d850157..92023362c 100644
--- a/nova/tests/api/openstack/test_common.py
+++ b/nova/tests/api/openstack/test_common.py
@@ -19,6 +19,7 @@
 Test suites for 'common' code used throughout the OpenStack HTTP API.
 """
 
+import webob.exc
 
 from webob import Request
 
@@ -160,3 +161,23 @@ class LimiterTest(test.TestCase):
         self.assertEqual(limited(items, req, max_limit=2000), items[3:])
         req = Request.blank('/?offset=3000&limit=10')
         self.assertEqual(limited(items, req, max_limit=2000), [])
+
+    def test_limiter_negative_limit(self):
+        """
+        Test a negative limit.
+        """
+        def _limit_large():
+            limited(self.large, req, max_limit=2000)
+
+        req = Request.blank('/?limit=-3000')
+        self.assertRaises(webob.exc.HTTPBadRequest, _limit_large)
+
+    def test_limiter_negative_offset(self):
+        """
+        Test a negative offset.
+        """
+        def _limit_large():
+            limited(self.large, req, max_limit=2000)
+
+        req = Request.blank('/?offset=-30')
+        self.assertRaises(webob.exc.HTTPBadRequest, _limit_large)
diff --git a/nova/tests/api/openstack/test_flavors.py b/nova/tests/api/openstack/test_flavors.py
index 761265965..319767bb5 100644
--- a/nova/tests/api/openstack/test_flavors.py
+++ b/nova/tests/api/openstack/test_flavors.py
@@ -20,6 +20,8 @@ import webob
 
 from nova import test
 import nova.api
+from nova import context
+from nova import db
 from nova.api.openstack import flavors
 from nova.tests.api.openstack import fakes
 
@@ -33,6 +35,7 @@ class FlavorsTest(test.TestCase):
         fakes.stub_out_networking(self.stubs)
         fakes.stub_out_rate_limiting(self.stubs)
         fakes.stub_out_auth(self.stubs)
+        self.context = context.get_admin_context()
 
     def tearDown(self):
         self.stubs.UnsetAll()
@@ -41,6 +44,9 @@ class FlavorsTest(test.TestCase):
     def test_get_flavor_list(self):
         req = webob.Request.blank('/v1.0/flavors')
         res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 200)
 
     def test_get_flavor_by_id(self):
-        pass
+        req = webob.Request.blank('/v1.0/flavors/1')
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 200)
diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index 7a25abe9d..78beb7df9 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -297,11 +297,45 @@ class ServersTest(test.TestCase):
         i = 0
         for s in res_dict['servers']:
             self.assertEqual(s['id'], i)
+            self.assertEqual(s['hostId'], '')
             self.assertEqual(s['name'], 'server%d' % i)
             self.assertEqual(s['imageId'], 10)
             self.assertEqual(s['metadata']['seq'], i)
             i += 1
 
+    def test_get_all_server_details_with_host(self):
+        '''
+        We want to make sure that if two instances are on the same host, then
+        they return the same hostId. If two instances are on different hosts,
+        they should return different hostId's. In this test, there are 5
+        instances - 2 on one host and 3 on another.
+        '''
+
+        def stub_instance(id, user_id=1):
+            return Instance(id=id, state=0, image_id=10, user_id=user_id,
+                display_name='server%s' % id, host='host%s' % (id % 2))
+
+        def return_servers_with_host(context, user_id=1):
+            return [stub_instance(i) for i in xrange(5)]
+
+        self.stubs.Set(nova.db.api, 'instance_get_all_by_user',
+            return_servers_with_host)
+
+        req = webob.Request.blank('/v1.0/servers/detail')
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+
+        server_list = res_dict['servers']
+        host_ids = [server_list[0]['hostId'], server_list[1]['hostId']]
+        self.assertTrue(host_ids[0] and host_ids[1])
+        self.assertNotEqual(host_ids[0], host_ids[1])
+
+        for i, s in enumerate(res_dict['servers']):
+            self.assertEqual(s['id'], i)
+            self.assertEqual(s['hostId'], host_ids[i % 2])
+            self.assertEqual(s['name'], 'server%d' % i)
+            self.assertEqual(s['imageId'], 10)
+
     def test_server_pause(self):
         FLAGS.allow_admin_api = True
         body = dict(server=dict(
diff --git a/nova/tests/db/fakes.py b/nova/tests/db/fakes.py
index 05bdd172e..d760dc456 100644
--- a/nova/tests/db/fakes.py
+++ b/nova/tests/db/fakes.py
@@ -20,13 +20,22 @@
 import time
 
 from nova import db
+from nova import test
 from nova import utils
-from nova.compute import instance_types
 
 
 def stub_out_db_instance_api(stubs):
     """ Stubs out the db API for creating Instances """
 
+    INSTANCE_TYPES = {
+        'm1.tiny': dict(memory_mb=512, vcpus=1, local_gb=0, flavorid=1),
+        'm1.small': dict(memory_mb=2048, vcpus=1, local_gb=20, flavorid=2),
+        'm1.medium':
+            dict(memory_mb=4096, vcpus=2, local_gb=40, flavorid=3),
+        'm1.large': dict(memory_mb=8192, vcpus=4, local_gb=80, flavorid=4),
+        'm1.xlarge':
+            dict(memory_mb=16384, vcpus=8, local_gb=160, flavorid=5)}
+
     class FakeModel(object):
         """ Stubs out for model """
         def __init__(self, values):
@@ -41,10 +50,16 @@ def stub_out_db_instance_api(stubs):
             else:
                 raise NotImplementedError()
 
+    def fake_instance_type_get_all(context, inactive=0):
+        return INSTANCE_TYPES
+
+    def fake_instance_type_get_by_name(context, name):
+        return INSTANCE_TYPES[name]
+
     def fake_instance_create(values):
         """ Stubs out the db.instance_create method """
 
-        type_data = instance_types.INSTANCE_TYPES[values['instance_type']]
+        type_data = INSTANCE_TYPES[values['instance_type']]
 
         base_options = {
             'name': values['name'],
@@ -73,3 +88,5 @@ def stub_out_db_instance_api(stubs):
 
     stubs.Set(db, 'instance_create', fake_instance_create)
     stubs.Set(db, 'network_get_by_instance', fake_network_get_by_instance)
+    stubs.Set(db, 'instance_type_get_all', fake_instance_type_get_all)
+    stubs.Set(db, 'instance_type_get_by_name', fake_instance_type_get_by_name)
diff --git a/nova/tests/glance/stubs.py b/nova/tests/glance/stubs.py
index f182b857a..3ff8d7ce5 100644
--- a/nova/tests/glance/stubs.py
+++ b/nova/tests/glance/stubs.py
@@ -26,12 +26,40 @@ def stubout_glance_client(stubs, cls):
 
 
 class FakeGlance(object):
+    IMAGE_MACHINE = 1
+    IMAGE_KERNEL = 2
+    IMAGE_RAMDISK = 3
+    IMAGE_RAW = 4
+    IMAGE_VHD = 5
+
+    IMAGE_FIXTURES = {
+        IMAGE_MACHINE: {
+            'image_meta': {'name': 'fakemachine', 'size': 0,
+                           'type': 'machine'},
+            'image_data': StringIO.StringIO('')},
+        IMAGE_KERNEL: {
+            'image_meta': {'name': 'fakekernel', 'size': 0,
+                           'type': 'kernel'},
+            'image_data': StringIO.StringIO('')},
+        IMAGE_RAMDISK: {
+            'image_meta': {'name': 'fakeramdisk', 'size': 0,
+                           'type': 'ramdisk'},
+            'image_data': StringIO.StringIO('')},
+        IMAGE_RAW: {
+            'image_meta': {'name': 'fakeraw', 'size': 0,
+                           'type': 'raw'},
+            'image_data': StringIO.StringIO('')},
+        IMAGE_VHD: {
+            'image_meta': {'name': 'fakevhd', 'size': 0,
+                           'type': 'vhd'},
+            'image_data': StringIO.StringIO('')}}
+
     def __init__(self, host, port=None, use_ssl=False):
         pass
 
-    def get_image(self, image):
-        meta = {
-            'size': 0,
-            }
-        image_file = StringIO.StringIO('')
-        return meta, image_file
+    def get_image_meta(self, image_id):
+        return self.IMAGE_FIXTURES[image_id]['image_meta']
+
+    def get_image(self, image_id):
+        image = self.IMAGE_FIXTURES[image_id]
+        return image['image_meta'], image['image_data']
diff --git a/nova/tests/test_compute.py b/nova/tests/test_compute.py
index b049ac943..949b5e6eb 100644
--- a/nova/tests/test_compute.py
+++ b/nova/tests/test_compute.py
@@ -30,6 +30,7 @@ from nova import log as logging
 from nova import test
 from nova import utils
 from nova.auth import manager
+from nova.compute import instance_types
 
 
 LOG = logging.getLogger('nova.tests.compute')
@@ -266,3 +267,10 @@ class ComputeTestCase(test.TestCase):
         self.assertEqual(ret_val, None)
 
         self.compute.terminate_instance(self.context, instance_id)
+
+    def test_get_by_flavor_id(self):
+        type = instance_types.get_by_flavor_id(1)
+        self.assertEqual(type, 'm1.tiny')
+
+        type = instance_types.get_by_flavor_id("1")
+        self.assertEqual(type, 'm1.tiny')
diff --git a/nova/tests/test_instance_types.py b/nova/tests/test_instance_types.py
new file mode 100644
index 000000000..edc538879
--- /dev/null
+++ b/nova/tests/test_instance_types.py
@@ -0,0 +1,86 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 Ken Pepple
+#    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.
+"""
+Unit Tests for instance types code
+"""
+import time
+
+from nova import context
+from nova import db
+from nova import exception
+from nova import flags
+from nova import log as logging
+from nova import test
+from nova import utils
+from nova.compute import instance_types
+from nova.db.sqlalchemy.session import get_session
+from nova.db.sqlalchemy import models
+
+FLAGS = flags.FLAGS
+LOG = logging.getLogger('nova.tests.compute')
+
+
+class InstanceTypeTestCase(test.TestCase):
+    """Test cases for instance type code"""
+    def setUp(self):
+        super(InstanceTypeTestCase, self).setUp()
+        session = get_session()
+        max_flavorid = session.query(models.InstanceTypes).\
+                                     order_by("flavorid desc").\
+                                     first()
+        self.flavorid = max_flavorid["flavorid"] + 1
+        self.name = str(int(time.time()))
+
+    def test_instance_type_create_then_delete(self):
+        """Ensure instance types can be created"""
+        starting_inst_list = instance_types.get_all_types()
+        instance_types.create(self.name, 256, 1, 120, self.flavorid)
+        new = instance_types.get_all_types()
+        self.assertNotEqual(len(starting_inst_list),
+                            len(new),
+                            'instance type was not created')
+        instance_types.destroy(self.name)
+        self.assertEqual(1,
+                    instance_types.get_instance_type(self.name)["deleted"])
+        self.assertEqual(starting_inst_list, instance_types.get_all_types())
+        instance_types.purge(self.name)
+        self.assertEqual(len(starting_inst_list),
+                         len(instance_types.get_all_types()),
+                         'instance type not purged')
+
+    def test_get_all_instance_types(self):
+        """Ensures that all instance types can be retrieved"""
+        session = get_session()
+        total_instance_types = session.query(models.InstanceTypes).\
+                                            count()
+        inst_types = instance_types.get_all_types()
+        self.assertEqual(total_instance_types, len(inst_types))
+
+    def test_invalid_create_args_should_fail(self):
+        """Ensures that instance type creation fails with invalid args"""
+        self.assertRaises(
+                exception.InvalidInputException,
+                instance_types.create, self.name, 0, 1, 120, self.flavorid)
+        self.assertRaises(
+                exception.InvalidInputException,
+                instance_types.create, self.name, 256, -1, 120, self.flavorid)
+        self.assertRaises(
+                exception.InvalidInputException,
+                instance_types.create, self.name, 256, 1, "aa", self.flavorid)
+
+    def test_non_existant_inst_type_shouldnt_delete(self):
+        """Ensures that instance type creation fails with invalid args"""
+        self.assertRaises(exception.ApiError,
+                          instance_types.destroy, "sfsfsdfdfs")
diff --git a/nova/tests/test_quota.py b/nova/tests/test_quota.py
index 1e42fddf3..4ecb36b54 100644
--- a/nova/tests/test_quota.py
+++ b/nova/tests/test_quota.py
@@ -74,19 +74,30 @@ class QuotaTestCase(test.TestCase):
         vol['size'] = size
         return db.volume_create(self.context, vol)['id']
 
+    def _get_instance_type(self, name):
+        instance_types = {
+            'm1.tiny': dict(memory_mb=512, vcpus=1, local_gb=0, flavorid=1),
+            'm1.small': dict(memory_mb=2048, vcpus=1, local_gb=20, flavorid=2),
+            'm1.medium':
+                dict(memory_mb=4096, vcpus=2, local_gb=40, flavorid=3),
+            'm1.large': dict(memory_mb=8192, vcpus=4, local_gb=80, flavorid=4),
+            'm1.xlarge':
+                dict(memory_mb=16384, vcpus=8, local_gb=160, flavorid=5)}
+        return instance_types[name]
+
     def test_quota_overrides(self):
         """Make sure overriding a projects quotas works"""
         num_instances = quota.allowed_instances(self.context, 100,
-            instance_types.INSTANCE_TYPES['m1.small'])
+            self._get_instance_type('m1.small'))
         self.assertEqual(num_instances, 2)
         db.quota_create(self.context, {'project_id': self.project.id,
                                        'instances': 10})
         num_instances = quota.allowed_instances(self.context, 100,
-            instance_types.INSTANCE_TYPES['m1.small'])
+            self._get_instance_type('m1.small'))
         self.assertEqual(num_instances, 4)
         db.quota_update(self.context, self.project.id, {'cores': 100})
         num_instances = quota.allowed_instances(self.context, 100,
-            instance_types.INSTANCE_TYPES['m1.small'])
+            self._get_instance_type('m1.small'))
         self.assertEqual(num_instances, 10)
 
         # metadata_items
diff --git a/nova/tests/test_xenapi.py b/nova/tests/test_xenapi.py
index 2cbe58aab..106c0bd6f 100644
--- a/nova/tests/test_xenapi.py
+++ b/nova/tests/test_xenapi.py
@@ -31,6 +31,7 @@ from nova.compute import power_state
 from nova.virt import xenapi_conn
 from nova.virt.xenapi import fake as xenapi_fake
 from nova.virt.xenapi import volume_utils
+from nova.virt.xenapi import vm_utils
 from nova.virt.xenapi.vmops import SimpleDH
 from nova.virt.xenapi.vmops import VMOps
 from nova.tests.db import fakes as db_fakes
@@ -232,7 +233,7 @@ class XenAPIVMTestCase(test.TestCase):
         vm = vms[0]
 
         # Check that m1.large above turned into the right thing.
-        instance_type = instance_types.INSTANCE_TYPES['m1.large']
+        instance_type = db.instance_type_get_by_name(conn, 'm1.large')
         mem_kib = long(instance_type['memory_mb']) << 10
         mem_bytes = str(mem_kib << 10)
         vcpus = instance_type['vcpus']
@@ -284,11 +285,17 @@ class XenAPIVMTestCase(test.TestCase):
 
     def test_spawn_raw_glance(self):
         FLAGS.xenapi_image_service = 'glance'
-        self._test_spawn(1, None, None)
+        self._test_spawn(glance_stubs.FakeGlance.IMAGE_RAW, None, None)
+
+    def test_spawn_vhd_glance(self):
+        FLAGS.xenapi_image_service = 'glance'
+        self._test_spawn(glance_stubs.FakeGlance.IMAGE_VHD, None, None)
 
     def test_spawn_glance(self):
         FLAGS.xenapi_image_service = 'glance'
-        self._test_spawn(1, 2, 3)
+        self._test_spawn(glance_stubs.FakeGlance.IMAGE_MACHINE,
+                         glance_stubs.FakeGlance.IMAGE_KERNEL,
+                         glance_stubs.FakeGlance.IMAGE_RAMDISK)
 
     def tearDown(self):
         super(XenAPIVMTestCase, self).tearDown()
@@ -337,3 +344,63 @@ class XenAPIDiffieHellmanTestCase(test.TestCase):
 
     def tearDown(self):
         super(XenAPIDiffieHellmanTestCase, self).tearDown()
+
+
+class XenAPIDetermineDiskImageTestCase(test.TestCase):
+    """
+    Unit tests for code that detects the ImageType
+    """
+    def setUp(self):
+        super(XenAPIDetermineDiskImageTestCase, self).setUp()
+        glance_stubs.stubout_glance_client(self.stubs,
+                                           glance_stubs.FakeGlance)
+
+        class FakeInstance(object):
+            pass
+
+        self.fake_instance = FakeInstance()
+        self.fake_instance.id = 42
+
+    def assert_disk_type(self, disk_type):
+        dt = vm_utils.VMHelper.determine_disk_image_type(
+            self.fake_instance)
+        self.assertEqual(disk_type, dt)
+
+    def test_instance_disk(self):
+        """
+        If a kernel is specified then the image type is DISK (aka machine)
+        """
+        FLAGS.xenapi_image_service = 'objectstore'
+        self.fake_instance.image_id = glance_stubs.FakeGlance.IMAGE_MACHINE
+        self.fake_instance.kernel_id = glance_stubs.FakeGlance.IMAGE_KERNEL
+        self.assert_disk_type(vm_utils.ImageType.DISK)
+
+    def test_instance_disk_raw(self):
+        """
+        If the kernel isn't specified, and we're not using Glance, then
+        DISK_RAW is assumed.
+        """
+        FLAGS.xenapi_image_service = 'objectstore'
+        self.fake_instance.image_id = glance_stubs.FakeGlance.IMAGE_RAW
+        self.fake_instance.kernel_id = None
+        self.assert_disk_type(vm_utils.ImageType.DISK_RAW)
+
+    def test_glance_disk_raw(self):
+        """
+        If we're using Glance, then defer to the image_type field, which in
+        this case will be 'raw'.
+        """
+        FLAGS.xenapi_image_service = 'glance'
+        self.fake_instance.image_id = glance_stubs.FakeGlance.IMAGE_RAW
+        self.fake_instance.kernel_id = None
+        self.assert_disk_type(vm_utils.ImageType.DISK_RAW)
+
+    def test_glance_disk_vhd(self):
+        """
+        If we're using Glance, then defer to the image_type field, which in
+        this case will be 'vhd'.
+        """
+        FLAGS.xenapi_image_service = 'glance'
+        self.fake_instance.image_id = glance_stubs.FakeGlance.IMAGE_VHD
+        self.fake_instance.kernel_id = None
+        self.assert_disk_type(vm_utils.ImageType.DISK_VHD)
diff --git a/nova/tests/xenapi/stubs.py b/nova/tests/xenapi/stubs.py
index 4fec2bd75..3de73d617 100644
--- a/nova/tests/xenapi/stubs.py
+++ b/nova/tests/xenapi/stubs.py
@@ -27,7 +27,7 @@ def stubout_instance_snapshot(stubs):
     def fake_fetch_image(cls, session, instance_id, image, user, project,
                          type):
         # Stubout wait_for_task
-        def fake_wait_for_task(self, id, task):
+        def fake_wait_for_task(self, task, id):
             class FakeEvent:
 
                 def send(self, value):
@@ -177,6 +177,12 @@ class FakeSessionForVMTests(fake.SessionBase):
     def VM_destroy(self, session_ref, vm_ref):
         fake.destroy_vm(vm_ref)
 
+    def SR_scan(self, session_ref, sr_ref):
+        pass
+
+    def VDI_set_name_label(self, session_ref, vdi_ref, name_label):
+        pass
+
 
 class FakeSessionForVolumeTests(fake.SessionBase):
     """ Stubs out a XenAPISession for Volume tests """