This patch adds flavor filtering, specifically the ability to flavor on minRam, minDisk, or both, per the 1.1 OSAPI spec.

In addition, this patch refactors instance_type_get_all to return a *list* of instance_types instead of a *dict*. This makes it more consistent with the rest of the DB API.

10 files changed, 357 insertions, 83 deletions

diff --git a/nova/api/ec2/admin.py b/nova/api/ec2/admin.py
index 75e029509..c1b1fa53a 100644
--- a/nova/api/ec2/admin.py
+++ b/nova/api/ec2/admin.py
@@ -126,8 +126,9 @@ class AdminController(object):
 
     def describe_instance_types(self, context, **_kwargs):
         """Returns all active instance types data (vcpus, memory, etc.)"""
-        return {'instanceTypeSet': [instance_dict(v) for v in
-                                   db.instance_type_get_all(context).values()]}
+        inst_types = db.instance_type_get_all(context)
+        inst_type_dicts = [instance_dict(i) for i in inst_types]
+        return {'instanceTypeSet': inst_type_dicts}
 
     def describe_user(self, _context, name, **_kwargs):
         """Returns user data, including access and secret keys."""
diff --git a/nova/api/openstack/flavors.py b/nova/api/openstack/flavors.py
index 8a310c900..b9dd96f4e 100644
--- a/nova/api/openstack/flavors.py
+++ b/nova/api/openstack/flavors.py
@@ -43,11 +43,24 @@ class Controller(object):
 
     def _get_flavors(self, req, is_detail=True):
         """Helper function that returns a list of flavor dicts."""
+        filters = {}
+        if 'minRam' in req.params:
+            try:
+                filters['min_memory_mb'] = int(req.params['minRam'])
+            except ValueError:
+                pass  # ignore bogus values per spec
+
+        if 'minDisk' in req.params:
+            try:
+                filters['min_local_gb'] = int(req.params['minDisk'])
+            except ValueError:
+                pass  # ignore bogus values per spec
+
         ctxt = req.environ['nova.context']
-        flavors = db.api.instance_type_get_all(ctxt)
+        inst_types = db.api.instance_type_get_all(ctxt, filters=filters)
         builder = self._get_view_builder(req)
-        items = [builder.build(flavor, is_detail=is_detail)
-                 for flavor in flavors.values()]
+        items = [builder.build(inst_type, is_detail=is_detail)
+                 for inst_type in inst_types]
         return items
 
     def show(self, req, id):
diff --git a/nova/compute/instance_types.py b/nova/compute/instance_types.py
index 824416514..ffbefb24c 100644
--- a/nova/compute/instance_types.py
+++ b/nova/compute/instance_types.py
@@ -91,8 +91,12 @@ def get_all_types(inactive=0):
     Pass true as argument if you want deleted instance types returned also.
 
     """
-    return db.instance_type_get_all(context.get_admin_context(), inactive)
-
+    ctxt = context.get_admin_context()
+    inst_types = db.instance_type_get_all(ctxt, inactive)
+    inst_type_dict = {}
+    for inst_type in inst_types:
+        inst_type_dict[inst_type['name']] = inst_type
+    return inst_type_dict
 
 get_all_flavors = get_all_types
 
diff --git a/nova/db/api.py b/nova/db/api.py
index 8c4c78374..f776953db 100644
--- a/nova/db/api.py
+++ b/nova/db/api.py
@@ -1349,9 +1349,10 @@ def instance_type_create(context, values):
     return IMPL.instance_type_create(context, values)
 
 
-def instance_type_get_all(context, inactive=False):
+def instance_type_get_all(context, inactive=False, filters=None):
     """Get all instance types."""
-    return IMPL.instance_type_get_all(context, inactive)
+    return IMPL.instance_type_get_all(
+        context, inactive=inactive, filters=filters)
 
 
 def instance_type_get(context, id):
diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index aa9fbda75..c91fa8c0d 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -3323,27 +3323,27 @@ def _dict_with_extra_specs(inst_type_query):
 
 
 @require_context
-def instance_type_get_all(context, inactive=False):
+def instance_type_get_all(context, inactive=False, filters=None):
     """
-    Returns a dict describing all instance_types with name as key.
+    Returns all instance types.
     """
+    filters = filters or {}
     session = get_session()
-    if inactive:
-        inst_types = session.query(models.InstanceTypes).\
-                        options(joinedload('extra_specs')).\
-                        order_by("name").\
-                        all()
-    else:
-        inst_types = session.query(models.InstanceTypes).\
-                        options(joinedload('extra_specs')).\
-                        filter_by(deleted=False).\
-                        order_by("name").\
-                        all()
-    inst_dict = {}
-    if inst_types:
-        for i in inst_types:
-            inst_dict[i['name']] = _dict_with_extra_specs(i)
-    return inst_dict
+    partial = session.query(models.InstanceTypes)\
+                     .options(joinedload('extra_specs'))
+    if not inactive:
+        partial = partial.filter_by(deleted=False)
+
+    if 'min_memory_mb' in filters:
+        partial = partial.filter(
+                models.InstanceTypes.memory_mb >= filters['min_memory_mb'])
+    if 'min_local_gb' in filters:
+        partial = partial.filter(
+                models.InstanceTypes.local_gb >= filters['min_local_gb'])
+
+    inst_types = partial.order_by("name").all()
+
+    return [_dict_with_extra_specs(i) for i in inst_types]
 
 
 @require_context
diff --git a/nova/tests/api/openstack/test_flavors.py b/nova/tests/api/openstack/test_flavors.py
index 348042bfe..743dddfc4 100644
--- a/nova/tests/api/openstack/test_flavors.py
+++ b/nova/tests/api/openstack/test_flavors.py
@@ -32,25 +32,43 @@ NS = "{http://docs.openstack.org/compute/api/v1.1}"
 ATOMNS = "{http://www.w3.org/2005/Atom}"
 
 
-def stub_flavor(flavorid, name, memory_mb="256", local_gb="10"):
-    return {
-        "flavorid": str(flavorid),
-        "name": name,
-        "memory_mb": memory_mb,
-        "local_gb": local_gb,
-    }
+FAKE_FLAVORS = {
+    'flavor 1': {
+        "flavorid": '1',
+        "name": 'flavor 1',
+        "memory_mb": '256',
+        "local_gb": '10'
+    },
+    'flavor 2': {
+        "flavorid": '2',
+        "name": 'flavor 2',
+        "memory_mb": '512',
+        "local_gb": '20'
+    },
+}
 
 
-def return_instance_type_by_flavor_id(context, flavorid):
-    return stub_flavor(flavorid, "flavor %s" % (flavorid,))
+def fake_instance_type_get_by_flavor_id(context, flavorid):
+    return FAKE_FLAVORS['flavor %s' % flavorid]
 
 
-def return_instance_types(context, num=2):
-    instance_types = {}
-    for i in xrange(1, num + 1):
-        name = "flavor %s" % (i,)
-        instance_types[name] = stub_flavor(i, name)
-    return instance_types
+def fake_instance_type_get_all(context, inactive=False, filters=None):
+    def reject_min(db_attr, filter_attr):
+        return filter_attr in filters and\
+               int(flavor[db_attr]) < int(filters[filter_attr])
+
+    filters = filters or {}
+    for flavor in FAKE_FLAVORS.values():
+        if reject_min('memory_mb', 'min_memory_mb'):
+            continue
+        elif reject_min('local_gb', 'min_local_gb'):
+            continue
+
+        yield flavor
+
+
+def empty_instance_type_get_all(context, inactive=False, filters=None):
+    return {}
 
 
 def return_instance_type_not_found(context, flavor_id):
@@ -63,9 +81,9 @@ class FlavorsTest(test.TestCase):
         fakes.stub_out_networking(self.stubs)
         fakes.stub_out_rate_limiting(self.stubs)
         self.stubs.Set(nova.db.api, "instance_type_get_all",
-                       return_instance_types)
+                       fake_instance_type_get_all)
         self.stubs.Set(nova.db.api, "instance_type_get_by_flavor_id",
-                       return_instance_type_by_flavor_id)
+                       fake_instance_type_get_by_flavor_id)
 
     def tearDown(self):
         self.stubs.UnsetAll()
@@ -89,10 +107,8 @@ class FlavorsTest(test.TestCase):
         self.assertEqual(flavors, expected)
 
     def test_get_empty_flavor_list_v1_0(self):
-        def _return_empty(self):
-            return {}
         self.stubs.Set(nova.db.api, "instance_type_get_all",
-                       _return_empty)
+                       empty_instance_type_get_all)
 
         req = webob.Request.blank('/v1.0/flavors')
         res = req.get_response(fakes.wsgi_app())
@@ -120,8 +136,8 @@ class FlavorsTest(test.TestCase):
             {
                 "id": "2",
                 "name": "flavor 2",
-                "ram": "256",
-                "disk": "10",
+                "ram": "512",
+                "disk": "20",
                 "rxtx_cap": "",
                 "rxtx_quota": "",
                 "swap": "",
@@ -131,13 +147,13 @@ class FlavorsTest(test.TestCase):
         self.assertEqual(flavors, expected)
 
     def test_get_flavor_by_id_v1_0(self):
-        req = webob.Request.blank('/v1.0/flavors/12')
+        req = webob.Request.blank('/v1.0/flavors/1')
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 200)
         flavor = json.loads(res.body)["flavor"]
         expected = {
-            "id": "12",
-            "name": "flavor 12",
+            "id": "1",
+            "name": "flavor 1",
             "ram": "256",
             "disk": "10",
             "rxtx_cap": "",
@@ -155,15 +171,15 @@ class FlavorsTest(test.TestCase):
         self.assertEqual(res.status_int, 404)
 
     def test_get_flavor_by_id_v1_1(self):
-        req = webob.Request.blank('/v1.1/fake/flavors/12')
+        req = webob.Request.blank('/v1.1/fake/flavors/1')
         req.environ['api.version'] = '1.1'
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 200)
         flavor = json.loads(res.body)
         expected = {
             "flavor": {
-                "id": "12",
-                "name": "flavor 12",
+                "id": "1",
+                "name": "flavor 1",
                 "ram": "256",
                 "disk": "10",
                 "rxtx_cap": "",
@@ -173,11 +189,11 @@ class FlavorsTest(test.TestCase):
                 "links": [
                     {
                         "rel": "self",
-                        "href": "http://localhost/v1.1/fake/flavors/12",
+                        "href": "http://localhost/v1.1/fake/flavors/1",
                     },
                     {
                         "rel": "bookmark",
-                        "href": "http://localhost/fake/flavors/12",
+                        "href": "http://localhost/fake/flavors/1",
                     },
                 ],
             },
@@ -255,8 +271,8 @@ class FlavorsTest(test.TestCase):
                 {
                     "id": "2",
                     "name": "flavor 2",
-                    "ram": "256",
-                    "disk": "10",
+                    "ram": "512",
+                    "disk": "20",
                     "rxtx_cap": "",
                     "rxtx_quota": "",
                     "swap": "",
@@ -277,9 +293,8 @@ class FlavorsTest(test.TestCase):
         self.assertEqual(flavor, expected)
 
     def test_get_empty_flavor_list_v1_1(self):
-        def _return_empty(self):
-            return {}
-        self.stubs.Set(nova.db.api, "instance_type_get_all", _return_empty)
+        self.stubs.Set(nova.db.api, "instance_type_get_all",
+                       empty_instance_type_get_all)
 
         req = webob.Request.blank('/v1.1/fake/flavors')
         res = req.get_response(fakes.wsgi_app())
@@ -288,6 +303,204 @@ class FlavorsTest(test.TestCase):
         expected = []
         self.assertEqual(flavors, expected)
 
+    def test_get_flavor_list_filter_min_ram_v1_1(self):
+        """Flavor lists may be filtered by minRam"""
+        req = webob.Request.blank('/v1.1/fake/flavors?minRam=512')
+        req.environ['api.version'] = '1.1'
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 200)
+        flavor = json.loads(res.body)
+        expected = {
+            "flavors": [
+                {
+                    "id": "2",
+                    "name": "flavor 2",
+                    "links": [
+                        {
+                            "rel": "self",
+                            "href": "http://localhost/v1.1/fake/flavors/2",
+                        },
+                        {
+                            "rel": "bookmark",
+                            "href": "http://localhost/fake/flavors/2",
+                        },
+                    ],
+                },
+            ],
+        }
+        self.assertEqual(flavor, expected)
+
+    def test_get_flavor_list_filter_min_disk(self):
+        """Flavor lists may be filtered by minRam"""
+        req = webob.Request.blank('/v1.1/fake/flavors?minDisk=20')
+        req.environ['api.version'] = '1.1'
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 200)
+        flavor = json.loads(res.body)
+        expected = {
+            "flavors": [
+                {
+                    "id": "2",
+                    "name": "flavor 2",
+                    "links": [
+                        {
+                            "rel": "self",
+                            "href": "http://localhost/v1.1/fake/flavors/2",
+                        },
+                        {
+                            "rel": "bookmark",
+                            "href": "http://localhost/fake/flavors/2",
+                        },
+                    ],
+                },
+            ],
+        }
+        self.assertEqual(flavor, expected)
+
+    def test_get_flavor_list_detail_min_ram_and_min_disk_v1_1(self):
+        """Tests that filtering work on flavor details and that minRam and
+        minDisk filters can be combined
+        """
+        req = webob.Request.blank(
+            '/v1.1/fake/flavors/detail?minRam=256&minDisk=20')
+        req.environ['api.version'] = '1.1'
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 200)
+        flavor = json.loads(res.body)
+        expected = {
+            "flavors": [
+                {
+                    "id": "2",
+                    "name": "flavor 2",
+                    "ram": "512",
+                    "disk": "20",
+                    "rxtx_cap": "",
+                    "rxtx_quota": "",
+                    "swap": "",
+                    "vcpus": "",
+                    "links": [
+                        {
+                            "rel": "self",
+                            "href": "http://localhost/v1.1/fake/flavors/2",
+                        },
+                        {
+                            "rel": "bookmark",
+                            "href": "http://localhost/fake/flavors/2",
+                        },
+                    ],
+                },
+            ],
+        }
+        self.assertEqual(flavor, expected)
+
+    def test_get_flavor_list_detail_bogus_min_ram_v1_1(self):
+        """Tests that bogus minRam filtering values are ignored"""
+        req = webob.Request.blank(
+            '/v1.1/fake/flavors/detail?minRam=16GB')
+        req.environ['api.version'] = '1.1'
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 200)
+        flavor = json.loads(res.body)
+        expected = {
+            "flavors": [
+                {
+                    "id": "1",
+                    "name": "flavor 1",
+                    "ram": "256",
+                    "disk": "10",
+                    "rxtx_cap": "",
+                    "rxtx_quota": "",
+                    "swap": "",
+                    "vcpus": "",
+                    "links": [
+                        {
+                            "rel": "self",
+                            "href": "http://localhost/v1.1/fake/flavors/1",
+                        },
+                        {
+                            "rel": "bookmark",
+                            "href": "http://localhost/fake/flavors/1",
+                        },
+                    ],
+                },
+                {
+                    "id": "2",
+                    "name": "flavor 2",
+                    "ram": "512",
+                    "disk": "20",
+                    "rxtx_cap": "",
+                    "rxtx_quota": "",
+                    "swap": "",
+                    "vcpus": "",
+                    "links": [
+                        {
+                            "rel": "self",
+                            "href": "http://localhost/v1.1/fake/flavors/2",
+                        },
+                        {
+                            "rel": "bookmark",
+                            "href": "http://localhost/fake/flavors/2",
+                        },
+                    ],
+                },
+            ],
+        }
+        self.assertEqual(flavor, expected)
+
+    def test_get_flavor_list_detail_bogus_min_disk_v1_1(self):
+        """Tests that bogus minDisk filtering values are ignored"""
+        req = webob.Request.blank(
+            '/v1.1/fake/flavors/detail?minDisk=16GB')
+        req.environ['api.version'] = '1.1'
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 200)
+        flavor = json.loads(res.body)
+        expected = {
+            "flavors": [
+                {
+                    "id": "1",
+                    "name": "flavor 1",
+                    "ram": "256",
+                    "disk": "10",
+                    "rxtx_cap": "",
+                    "rxtx_quota": "",
+                    "swap": "",
+                    "vcpus": "",
+                    "links": [
+                        {
+                            "rel": "self",
+                            "href": "http://localhost/v1.1/fake/flavors/1",
+                        },
+                        {
+                            "rel": "bookmark",
+                            "href": "http://localhost/fake/flavors/1",
+                        },
+                    ],
+                },
+                {
+                    "id": "2",
+                    "name": "flavor 2",
+                    "ram": "512",
+                    "disk": "20",
+                    "rxtx_cap": "",
+                    "rxtx_quota": "",
+                    "swap": "",
+                    "vcpus": "",
+                    "links": [
+                        {
+                            "rel": "self",
+                            "href": "http://localhost/v1.1/fake/flavors/2",
+                        },
+                        {
+                            "rel": "bookmark",
+                            "href": "http://localhost/fake/flavors/2",
+                        },
+                    ],
+                },
+            ],
+        }
+        self.assertEqual(flavor, expected)
+
 
 class FlavorsXMLSerializationTest(test.TestCase):
 
diff --git a/nova/tests/db/fakes.py b/nova/tests/db/fakes.py
index cdbfba63a..6e6253c1d 100644
--- a/nova/tests/db/fakes.py
+++ b/nova/tests/db/fakes.py
@@ -411,8 +411,8 @@ def stub_out_db_instance_api(stubs, injected=True):
                        'address_v6': 'fe80::a00:3',
                        'network_id': 'fake_flat'}
 
-    def fake_instance_type_get_all(context, inactive=0):
-        return INSTANCE_TYPES
+    def fake_instance_type_get_all(context, inactive=0, filters=None):
+        return INSTANCE_TYPES.values()
 
     def fake_instance_type_get_by_name(context, name):
         return INSTANCE_TYPES[name]
diff --git a/nova/tests/test_instance_types.py b/nova/tests/test_instance_types.py
index 09f532239..1ed34fba3 100644
--- a/nova/tests/test_instance_types.py
+++ b/nova/tests/test_instance_types.py
@@ -161,3 +161,40 @@ class InstanceTypeTestCase(test.TestCase):
         self.assertRaises(exception.InstanceTypeNotFound,
                           instance_types.get_instance_type_by_name,
                           self._nonexistent_flavor_id())
+
+
+class InstanceTypeFilteringTest(test.TestCase):
+    """Test cases for the filter option available for instance_type_get_all"""
+    def setUp(self):
+        super(InstanceTypeFilteringTest, self).setUp()
+        self.context = context.get_admin_context()
+
+    def assertFilterResults(self, filters, expected):
+        inst_types = db.api.instance_type_get_all(
+                self.context, filters=filters)
+        inst_names = [i['name'] for i in inst_types]
+        self.assertEqual(inst_names, expected)
+
+    def test_no_filters(self):
+        filters = None
+        expected = ['m1.large', 'm1.medium', 'm1.small', 'm1.tiny',
+                    'm1.xlarge']
+        self.assertFilterResults(filters, expected)
+
+    def test_min_memory_mb_filter(self):
+        """Exclude tiny instance which is 512 MB"""
+        filters = dict(min_memory_mb=513)
+        expected = ['m1.large', 'm1.medium', 'm1.small', 'm1.xlarge']
+        self.assertFilterResults(filters, expected)
+
+    def test_min_local_gb_filter(self):
+        """Exclude everything but large and xlarge which have >= 80 GB"""
+        filters = dict(min_local_gb=80)
+        expected = ['m1.large', 'm1.xlarge']
+        self.assertFilterResults(filters, expected)
+
+    def test_min_memory_mb_AND_local_gb_filter(self):
+        """Exclude everything but large and xlarge which have >= 80 GB"""
+        filters = dict(min_memory_mb=16384, min_local_gb=80)
+        expected = ['m1.xlarge']
+        self.assertFilterResults(filters, expected)
diff --git a/nova/tests/test_instance_types_extra_specs.py b/nova/tests/test_instance_types_extra_specs.py
index 205601277..b4b642944 100644
--- a/nova/tests/test_instance_types_extra_specs.py
+++ b/nova/tests/test_instance_types_extra_specs.py
@@ -45,7 +45,7 @@ class InstanceTypeExtraSpecsTestCase(test.TestCase):
 
     def tearDown(self):
         # Remove the instance type from the database
-        db.api.instance_type_purge(context.get_admin_context(), "cg1.4xlarge")
+        db.api.instance_type_purge(self.context, "cg1.4xlarge")
         super(InstanceTypeExtraSpecsTestCase, self).tearDown()
 
     def test_instance_type_specs_get(self):
@@ -55,7 +55,7 @@ class InstanceTypeExtraSpecsTestCase(test.TestCase):
                                  xpus="2",
                                  xpu_model="Tesla 2050")
         actual_specs = db.api.instance_type_extra_specs_get(
-                              context.get_admin_context(),
+                              self.context,
                               self.instance_type_id)
         self.assertEquals(expected_specs, actual_specs)
 
@@ -64,11 +64,11 @@ class InstanceTypeExtraSpecsTestCase(test.TestCase):
                                  cpu_model="Nehalem",
                                  xpu_arch="fermi",
                                  xpus="2")
-        db.api.instance_type_extra_specs_delete(context.get_admin_context(),
+        db.api.instance_type_extra_specs_delete(self.context,
                                       self.instance_type_id,
                                       "xpu_model")
         actual_specs = db.api.instance_type_extra_specs_get(
-                              context.get_admin_context(),
+                              self.context,
                               self.instance_type_id)
         self.assertEquals(expected_specs, actual_specs)
 
@@ -79,11 +79,11 @@ class InstanceTypeExtraSpecsTestCase(test.TestCase):
                                  xpus="2",
                                  xpu_model="Tesla 2050")
         db.api.instance_type_extra_specs_update_or_create(
-                              context.get_admin_context(),
+                              self.context,
                               self.instance_type_id,
                               dict(cpu_model="Sandy Bridge"))
         actual_specs = db.api.instance_type_extra_specs_get(
-                              context.get_admin_context(),
+                              self.context,
                               self.instance_type_id)
         self.assertEquals(expected_specs, actual_specs)
 
@@ -96,18 +96,18 @@ class InstanceTypeExtraSpecsTestCase(test.TestCase):
                                  net_arch="ethernet",
                                  net_mbps="10000")
         db.api.instance_type_extra_specs_update_or_create(
-                              context.get_admin_context(),
+                              self.context,
                               self.instance_type_id,
                               dict(net_arch="ethernet",
                                    net_mbps=10000))
         actual_specs = db.api.instance_type_extra_specs_get(
-                              context.get_admin_context(),
+                              self.context,
                               self.instance_type_id)
         self.assertEquals(expected_specs, actual_specs)
 
     def test_instance_type_get_with_extra_specs(self):
         instance_type = db.api.instance_type_get(
-                            context.get_admin_context(),
+                            self.context,
                             self.instance_type_id)
         self.assertEquals(instance_type['extra_specs'],
                           dict(cpu_arch="x86_64",
@@ -116,13 +116,13 @@ class InstanceTypeExtraSpecsTestCase(test.TestCase):
                                xpus="2",
                                xpu_model="Tesla 2050"))
         instance_type = db.api.instance_type_get(
-                            context.get_admin_context(),
+                            self.context,
                             5)
         self.assertEquals(instance_type['extra_specs'], {})
 
     def test_instance_type_get_by_name_with_extra_specs(self):
         instance_type = db.api.instance_type_get_by_name(
-                            context.get_admin_context(),
+                            self.context,
                             "cg1.4xlarge")
         self.assertEquals(instance_type['extra_specs'],
                           dict(cpu_arch="x86_64",
@@ -132,13 +132,13 @@ class InstanceTypeExtraSpecsTestCase(test.TestCase):
                                xpu_model="Tesla 2050"))
 
         instance_type = db.api.instance_type_get_by_name(
-                            context.get_admin_context(),
+                            self.context,
                             "m1.small")
         self.assertEquals(instance_type['extra_specs'], {})
 
     def test_instance_type_get_by_flavor_id_with_extra_specs(self):
         instance_type = db.api.instance_type_get_by_flavor_id(
-                            context.get_admin_context(),
+                            self.context,
                             105)
         self.assertEquals(instance_type['extra_specs'],
                           dict(cpu_arch="x86_64",
@@ -148,7 +148,7 @@ class InstanceTypeExtraSpecsTestCase(test.TestCase):
                                xpu_model="Tesla 2050"))
 
         instance_type = db.api.instance_type_get_by_flavor_id(
-                            context.get_admin_context(),
+                            self.context,
                             2)
         self.assertEquals(instance_type['extra_specs'], {})
 
@@ -159,7 +159,12 @@ class InstanceTypeExtraSpecsTestCase(test.TestCase):
                         xpus='2',
                         xpu_model="Tesla 2050")
 
-        types = db.api.instance_type_get_all(context.get_admin_context())
+        types = db.api.instance_type_get_all(self.context)
 
-        self.assertEquals(types['cg1.4xlarge']['extra_specs'], specs)
-        self.assertEquals(types['m1.small']['extra_specs'], {})
+        name2specs = {}
+        for instance_type in types:
+            name = instance_type['name']
+            name2specs[name] = instance_type['extra_specs']
+
+        self.assertEquals(name2specs['cg1.4xlarge'], specs)
+        self.assertEquals(name2specs['m1.small'], {})
diff --git a/nova/tests/vmwareapi/db_fakes.py b/nova/tests/vmwareapi/db_fakes.py
index 0d896239a..575109f90 100644
--- a/nova/tests/vmwareapi/db_fakes.py
+++ b/nova/tests/vmwareapi/db_fakes.py
@@ -99,8 +99,8 @@ def stub_out_db_instance_api(stubs):
         """Stubs out the db.instance_get_fixed_address method."""

         return '10.10.10.10'

 

-    def fake_instance_type_get_all(context, inactive=0):

-        return INSTANCE_TYPES

+    def fake_instance_type_get_all(context, inactive=0, filters=None):

+        return INSTANCE_TYPES.values()

 

     def fake_instance_type_get_by_name(context, name):

         return INSTANCE_TYPES[name]