Merge lp:~justin-fathomdb/nova/test-openstack-api-servers into lp:~hudson-openstack/nova/trunk

[justinsb]

Basic unit testing of the OpenStack API for /servers.

[Rick Harris (rconradharris)]

Overall this looks good.

The known_bugs addition looks pretty nifty (but I worry a bit about the added complexity of it). The fake image service looks like a really nice addition.

Below are a few femto-nits:

658 + # Not supported till Python 2.7 / 3.1
659 + #@unittest.skipIf(
660 + # 'server_create_metadata_throws_unhashable_type' in KNOWN_BUGS,
661 + # 'KNOWN_BUG:server_create_metadata_throws_unhashable_type')

If we're going to go this route, perhaps we could roll our own decorator which the TestRunner can use to skip the relevant tests. This would make adoption of this under 2.6 just as easy as 2.7+.

Something along the lines of:

@tests_known_bug("my_known_bug")
def test_my_known_bug(self):
    self.assert_(False)

586 +# print driver.LoggingVolumeDriver.all_logs()
587 +#
588 +#
589 +# create_actions = driver.LoggingVolumeDriver.logs_like(
590 +# 'create_volume',
591 +# id=created_volume_id)
592 +# print create_actions
593 +# self.assertEquals(1, len(create_actions))
594 +# create_action = create_actions[0]
595 +# self.assertEquals(create_action['id'], created_server_id)
596 +# self.assertEquals(create_action['availability_zone'], 'nova')
597 +# self.assertEquals(create_action['size'], 1)
598 +#
599 +# export_actions = driver.LoggingVolumeDriver.logs_like(
600 +# 'create_export',
601 +# id=created_server_id)
602 +# self.assertEquals(1, len(export_actions))
603 +# export_action = export_actions[0]
604 +# self.assertEquals(export_action['id'], created_server_id)
605 +# self.assertEquals(export_action['availability_zone'], 'nova')
606 +#
607 +# delete_actions = driver.LoggingVolumeDriver.logs_like(
608 +# 'delete_volume',
609 +# id=created_server_id)
610 +# self.assertEquals(1, len(delete_actions))
611 +# delete_action = export_actions[0]
612 +# self.assertEquals(delete_action['id'], created_server_id)

Was this left in on purpose? If so, it probably should have a TODO with it.

> 509 + def test_get_servers(self):
> 510 + """Simple check that listing servers works"""
> 511 + servers = self.api.get_servers()
> 512 + for server in servers:
> 513 + print("server: %s" % server)

Can we put an assert in here? Perhaps just a assertNotRaises or something.

> 334 + raise exception.Error("No way to create an image through API??")

This line (and a few others) need i18n treatment, the _("blah").

> 628 + #if found_server['status'] != 'deleting':
> 629 + # break

Left in by accident, or does that need a TODO/FIXME?

> 129 + raise exception.NotFound

Might be helpful to pass in a string with the Exception which includes the Id of the image not found. Something like

  raise exception.NotFound(_("Image %(image_id)s not found) % locals())

> 489 +import time

Should be moved up to top section of imports (per HACKING)

> 641 + #TODO(justinsb): This is FUBAR

Agree wit...

[Soren Hansen (soren)]

What's the status of this? There are concrete comments here, but the branch hasn't been touched for more than a week. Perhaps just set it back to Work in Progress?

[justinsb (justin-fathomdb)]

Soren: The branch has got unmerged pre-reqs. Here be dragons.

[justinsb (justin-fathomdb)]

Dragons slayed. There are still unmerged pre-reqs though, so reviewers please focus on those first!

Unmerged revisions

732. By justinsb on 2011-03-08

PEP8 fun

731. By justinsb on 2011-03-08

Finally figured out how to work around the latest flip-flops on what the image service should be returning

730. By justinsb on 2011-03-08

More changing of print -> LOG.debug

729. By justinsb on 2011-03-08

Removed known_bugs based on community opinion. Commented out the test cases that otherwise won't work.

728. By justinsb on 2011-03-08

Merged with head, fixing up bazaar's pathetic attempts at conflict resolution.

727. By justinsb on 2011-02-24

PEP8 fix

726. By justinsb on 2011-02-24

Need spurious import to pull in flags

725. By justinsb on 2011-02-24

Scale up rate limits for tests massively, to effectively turn them off

724. By justinsb on 2011-02-24

More careful checking of servers detail vs non-detail views

723. By justinsb on 2011-02-24

Add integrated unit tests for server metadata. Also add KNOWN_BUGS list, so that we can test bugs separately from fixing them

=== modified file 'nova/api/openstack/ratelimiting/__init__.py'
--- nova/api/openstack/ratelimiting/__init__.py	2011-01-06 18:57:48 +0000
+++ nova/api/openstack/ratelimiting/__init__.py	2011-03-08 02:57:47 +0000
@@ -23,9 +23,15 @@
 import webob.dec
 import webob.exc
 
+from nova import flags
 from nova import wsgi
 from nova.api.openstack import faults
 
+
+FLAGS = flags.FLAGS
+flags.DEFINE_integer('rate_limit_multiplier', 1,
+                     'Factor by which to scale up rate-limits')
+
 # Convenience constants for the limits dictionary passed to Limiter().
 PER_SECOND = 1
 PER_MINUTE = 60
@@ -44,14 +50,16 @@
         at the given host+port to keep rate counters.
         """
         if not service_host:
+            scale = FLAGS.rate_limit_multiplier
+
             #TODO(gundlach): These limits were based on limitations of Cloud
             #Servers.  We should revisit them in Nova.
             self.limiter = Limiter(limits={
-                    'DELETE': (100, PER_MINUTE),
-                    'PUT': (10, PER_MINUTE),
-                    'POST': (10, PER_MINUTE),
-                    'POST servers': (50, PER_DAY),
-                    'GET changes-since': (3, PER_MINUTE),
+                    'DELETE': (100 * scale, PER_MINUTE),
+                    'PUT': (10 * scale, PER_MINUTE),
+                    'POST': (10 * scale, PER_MINUTE),
+                    'POST servers': (50 * scale, PER_DAY),
+                    'GET changes-since': (3 * scale, PER_MINUTE),
                 })
         else:
             self.limiter = WSGIAppProxy(service_host)

=== added file 'nova/image/fake.py'
--- nova/image/fake.py	1970-01-01 00:00:00 +0000
+++ nova/image/fake.py	2011-03-08 02:57:47 +0000
@@ -0,0 +1,108 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 Justin Santa Barbara
+# 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.
+"""Implementation of an fake image service"""
+
+from nova import exception
+from nova import flags
+from nova import log as logging
+from nova.image import service
+
+
+LOG = logging.getLogger('nova.image.fake')
+
+FLAGS = flags.FLAGS
+
+
+class MockImageService(service.BaseImageService):
+    """Mock (fake) image service for unit testing"""
+
+    def __init__(self):
+        self.images = {}
+        # NOTE(justinsb): The OpenStack API can't upload an image???
+        # So, make sure we've got one..
+        image = {'id': '123456',
+                 'status': 'active',
+                 'type': 'machine',
+                 'properties': {'kernel_id': FLAGS.null_kernel,
+                                'ramdisk_id': FLAGS.null_kernel,
+                               }
+                }
+        self.create(None, image)
+        super(MockImageService, self).__init__()
+
+    def index(self, context):
+        """Returns list of images"""
+        return self.images.values()
+
+    def detail(self, context):
+        """Return list of detailed image information"""
+        return self.images.values()
+
+    def show(self, context, image_id):
+        """
+        Returns a dict containing image data for the given opaque image id.
+        """
+        image_id = int(image_id)
+        image = self.images.get(image_id)
+        if image:
+            return image
+        LOG.warn("Unable to find image id %s.  Have images: %s",
+                 image_id, self.images)
+        raise exception.NotFound
+
+    def create(self, context, data):
+        """
+        Store the image data and return the new image id.
+
+        :raises AlreadyExists if the image already exist.
+
+        """
+        image_id = int(data['id'])
+        if self.images.get(image_id):
+            #TODO(justinsb): Where is this AlreadyExists exception??
+            raise exception.Error("AlreadyExists")
+
+        self.images[image_id] = data
+
+    def update(self, context, image_id, data):
+        """Replace the contents of the given image with the new data.
+
+        :raises NotFound if the image does not exist.
+
+        """
+        image_id = int(image_id)
+        if not self.images.get(image_id):
+            raise exception.NotFound
+        self.images[image_id] = data
+
+    def delete(self, context, image_id):
+        """
+        Delete the given image.
+
+        :raises NotFound if the image does not exist.
+
+        """
+        image_id = int(image_id)
+        removed = self.images.pop(image_id, None)
+        if not removed:
+            raise exception.NotFound
+
+    def delete_all(self):
+        """
+        Clears out all images
+        """
+        self.images.clear()

=== modified file 'nova/tests/integrated/api/client.py'
--- nova/tests/integrated/api/client.py	2011-03-08 02:57:47 +0000
+++ nova/tests/integrated/api/client.py	2011-03-08 02:57:47 +0000
@@ -88,6 +88,9 @@
         if parsed_url.query:
             relative_url = relative_url + parsed_url.query
         LOG.info(_("Doing %(method)s on %(relative_url)s") % locals())
+        if body:
+            LOG.info(_("Body: %s") % body)
+
         conn.request(method, relative_url, body, headers)
         response = conn.getresponse()
         return response
@@ -182,3 +185,40 @@
 
     def delete_volume(self, volume_id):
         return self.api_delete('/volumes/%s' % volume_id)
+
+    def get_server(self, server_id):
+        return self.api_get('/servers/%s' % server_id)['server']
+
+    def get_servers(self, detail=True):
+        rel_url = '/servers/detail' if detail else '/servers'
+        return self.api_get(rel_url)['servers']
+
+    def post_server(self, server):
+        return self.api_post('/servers', server)['server']
+
+    def delete_server(self, server_id):
+        return self.api_delete('/servers/%s' % server_id)
+
+    def get_image(self, image_id):
+        return self.api_get('/images/%s' % image_id)['image']
+
+    def get_images_detail(self):
+        return self.api_get('/images/detail')['images']
+
+    def post_image(self, image):
+        return self.api_post('/images', image)['image']
+
+    def delete_image(self, image_id):
+        return self.api_delete('/images/%s' % image_id)
+
+    def get_flavor(self, flavor_id):
+        return self.api_get('/flavors/%s' % flavor_id)['flavor']
+
+    def get_flavors_detail(self):
+        return self.api_get('/flavors/detail')['flavors']
+
+    def post_flavor(self, flavor):
+        return self.api_post('/flavors', flavor)['flavor']
+
+    def delete_flavor(self, flavor_id):
+        return self.api_delete('/flavors/%s' % flavor_id)

=== modified file 'nova/tests/integrated/integrated_helpers.py'
--- nova/tests/integrated/integrated_helpers.py	2011-03-08 02:57:47 +0000
+++ nova/tests/integrated/integrated_helpers.py	2011-03-08 02:57:47 +0000
@@ -26,29 +26,89 @@
 from nova import flags
 from nova import service
 from nova.api import openstack  # For FLAGS.allow_testing_api
+from nova.api.openstack import ratelimiting  # For FLAGS.rate_limit_multiplier
 from nova.auth import manager
 from nova.exception import Error
 from nova.log import logging
 from nova.tests.integrated.api import client
 
+
 FLAGS = flags.FLAGS
 
 
 def generate_random_alphanumeric(length):
-    """Creates a random string of specified length"""
+    """Creates a random alphanumeric string of specified length"""
     return ''.join(random.choice(string.ascii_uppercase + string.digits)
                    for _x in range(length))
 
 
-def generate_new_element(items, prefix):
+def generate_random_numeric(length):
+    """Creates a random numeric string of specified length"""
+    return ''.join(random.choice(string.digits)
+                   for _x in range(length))
+
+
+def generate_new_element(items, prefix, numeric=False):
     """Creates a random string with prefix, that is not in 'items' list"""
     while True:
-        candidate = prefix + generate_random_alphanumeric(8)
+        if numeric:
+            candidate = prefix + generate_random_numeric(8)
+        else:
+            candidate = prefix + generate_random_alphanumeric(8)
         if not candidate in items:
             return candidate
         print "Random collision on %s" % candidate
 
 
+class TestUser(object):
+    def __init__(self, name, secret, auth_url):
+        self.name = name
+        self.secret = secret
+
+        if not auth_url:
+            raise exception.Error("auth_url is required")
+        self.openstack_api = client.TestOpenStackClient(self.name,
+                                                self.secret,
+                                                auth_url)
+
+        self.key_pairs = None
+
+    def get_key_pair(self, create=False):
+        if self.key_pairs is None:
+            self.key_pairs = self.openstack_api.get_keys_detail()
+        if create and not self.key_pairs:
+            key = {'key': {'name': 'key0'}}
+            created_key = self.openstack_api.post_key(key)
+            self.key_pairs.append(created_key)
+
+        if self.key_pairs:
+            return self.key_pairs[0]
+
+        return None
+
+    def get_unused_server_name(self, create=False):
+        servers = self.openstack_api.get_servers()
+        server_names = [server['name'] for server in servers]
+        return generate_new_element(server_names, 'server')
+
+    def get_invalid_image(self):
+        images = self.openstack_api.get_images_detail()
+        image_ids = [image['id'] for image in images]
+        return generate_new_element(image_ids, '', numeric=True)
+
+    def get_valid_image(self, create=False):
+        images = self.openstack_api.get_images_detail()
+        if create and not images:
+            # TODO(justinsb): No way to create an image through API???
+            #created_image = self.openstack_api.post_image(image)
+            #images.append(created_image)
+            raise exception.Error("No way to create an image through API??")
+
+        if images:
+            return images[0]
+        return None
+
+
 class IntegratedUnitTestContext(object):
     __INSTANCE = None
 
@@ -62,20 +122,17 @@
         self.saved_flags = {}
         self.services = []
         self.auth_url = None
-        self.auth_user = None
-        self.auth_key = None
         self.project_name = None
-        self.openstack_api = None
 
         self.setup()
 
     def setup(self):
         self._configure_flags()
 
+        self._start_services()
+
         self._create_test_user()
 
-        self._start_services()
-
     def _configure_flags(self):
         self._overwrite_flag('allow_testing_api', True)
         if not FLAGS.allow_testing_api:
@@ -88,6 +145,11 @@
         self._overwrite_flag('fake_rabbit', False)
         self._overwrite_flag('volume_driver',
                              'nova.volume.driver.LoggingVolumeDriver')
+        self._overwrite_flag('image_service',
+                             'nova.image.fake.MockImageService')
+        self._overwrite_flag('connection_type', 'fake')
+        # Scale up rate limits by 10000x; effectively turning them off
+        self._overwrite_flag('rate_limit_multiplier', 10000)
 
     def _overwrite_flag(self, flag_key, flag_value):
         self.saved_flags[flag_key] = FLAGS[flag_key].value
@@ -100,11 +162,11 @@
         self.saved_flags.clear()
 
     def _create_test_user(self):
-        self.auth_user, self.auth_key = self._create_unittest_user()
+        self.test_user = self._create_unittest_user()
 
         # No way to currently pass this through the OpenStack API
         self.project_name = 'openstack'
-        self._configure_project(self.project_name)
+        self._configure_project(self.project_name, self.test_user)
 
     def _start_services(self):
         # WSGI shutdown broken :-(
@@ -114,10 +176,6 @@
         self._start_volume_service()
         self._start_scheduler_service()
 
-        self.openstack_api = client.TestOpenStackClient(self.auth_user,
-                                                        self.auth_key,
-                                                        self.auth_url)
-
     def cleanup(self):
         for service in self.services:
             service.kill()
@@ -127,7 +185,7 @@
         # self.wsgi_server.terminate()
         # self.wsgi_server = None
         self._restore_flags()
-        self.openstack_api = None
+        self.test_user = None
 
     def _create_unittest_user(self):
         users = self.auth_manager.get_users()
@@ -139,18 +197,18 @@
         auth_key = auth_name
 
         self.auth_manager.create_user(auth_name, auth_name, auth_key, False)
-        return auth_name, auth_key
+        return TestUser(auth_name, auth_key, self.auth_url)
 
-    def _configure_project(self, project_name):
+    def _configure_project(self, project_name, user):
         projects = self.auth_manager.get_projects()
         project_names = [project.name for project in projects]
         if not project_name in project_names:
             project = self.auth_manager.create_project(project_name,
-                                                       self.auth_user,
+                                                       user.name,
                                                        description=None,
                                                        member_users=None)
         else:
-            self.auth_manager.add_to_project(self.auth_user, project_name)
+            self.auth_manager.add_to_project(user.name, project_name)
 
     def _start_api_service(self):
         api_service = service.ApiService.create()
@@ -179,9 +237,6 @@
         self.services.append(scheduler_service)
         return scheduler_service
 
-    def get_openstack_api(self):
-        return self.openstack_api
-
     # WSGI shutdown broken :-(
     #@staticmethod
     #def get():

=== modified file 'nova/tests/integrated/test_keys.py'
--- nova/tests/integrated/test_keys.py	2011-03-08 02:57:47 +0000
+++ nova/tests/integrated/test_keys.py	2011-03-08 02:57:47 +0000
@@ -28,7 +28,8 @@
 class KeysTest(unittest.TestCase):
     def setUp(self):
         context = integrated_helpers.IntegratedUnitTestContext.startup()
-        self.api = context.get_openstack_api()
+        self.user = context.test_user
+        self.api = self.user.openstack_api
 
     def tearDown(self):
         integrated_helpers.IntegratedUnitTestContext.shutdown()

=== added file 'nova/tests/integrated/test_servers.py'
--- nova/tests/integrated/test_servers.py	1970-01-01 00:00:00 +0000
+++ nova/tests/integrated/test_servers.py	2011-03-08 02:57:47 +0000
@@ -0,0 +1,216 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 Justin Santa Barbara
+# 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.
+
+import unittest
+
+from nova import flags
+from nova import test  # For the flags
+from nova.log import logging
+from nova.tests.integrated import integrated_helpers
+from nova.tests.integrated.api import client
+import time
+
+
+LOG = logging.getLogger('nova.tests.integrated')
+
+FLAGS = flags.FLAGS
+FLAGS.verbose = True
+
+
+class ServersTest(unittest.TestCase):
+    def setUp(self):
+        context = integrated_helpers.IntegratedUnitTestContext.startup()
+        self.user = context.test_user
+        self.api = self.user.openstack_api
+
+        # Make sure we have a key. API defaults to using this key
+        self.key = self.user.get_key_pair(create=True)
+
+    def tearDown(self):
+        integrated_helpers.IntegratedUnitTestContext.shutdown()
+
+    def test_get_servers(self):
+        """Simple check that listing servers works"""
+        servers = self.api.get_servers()
+        for server in servers:
+            LOG.debug("server: %s" % server)
+
+    def test_create_and_delete_server(self):
+        """Creates and deletes a server"""
+
+        # Create server
+
+        # Build the server data gradually, checking errors along the way
+        server = {}
+        good_server = self._build_minimal_create_server_request()
+
+        post = {'server': server}
+
+        # Without an imageId, this throws 500.
+        # TODO(justinsb): Check whatever the spec says should be thrown here
+        self.assertRaises(client.OpenstackApiException,
+                          self.api.post_server, post)
+
+        # With an invalid imageId, this throws 500.
+        server['imageId'] = self.user.get_invalid_image()
+        # TODO(justinsb): Check whatever the spec says should be thrown here
+        self.assertRaises(client.OpenstackApiException,
+                          self.api.post_server, post)
+
+        # Add a valid imageId
+        server['imageId'] = good_server['imageId']
+
+        # Without flavorId, this throws 500
+        # TODO(justinsb): Check whatever the spec says should be thrown here
+        self.assertRaises(client.OpenstackApiException,
+                          self.api.post_server, post)
+
+        # Set a valid flavorId
+        server['flavorId'] = good_server['flavorId']
+
+        # Without a name, this throws 500
+        # TODO(justinsb): Check whatever the spec says should be thrown here
+        self.assertRaises(client.OpenstackApiException,
+                          self.api.post_server, post)
+
+        # Set a valid server name
+        server['name'] = good_server['name']
+
+        created_server = self.api.post_server(post)
+        LOG.debug("created_server: %s" % created_server)
+        self.assertTrue(created_server['id'])
+        created_server_id = created_server['id']
+
+        # Check it's there
+        found_server = self.api.get_server(created_server_id)
+        self.assertEqual(created_server_id, found_server['id'])
+
+        # It should also be in the all-servers list
+        servers = self.api.get_servers()
+        server_ids = [server['id'] for server in servers]
+        self.assertTrue(created_server_id in server_ids)
+
+        # Wait (briefly) for creation
+        retries = 0
+        while found_server['status'] == 'build':
+            LOG.debug("found server: %s" % found_server)
+            time.sleep(1)
+            found_server = self.api.get_server(created_server_id)
+            retries = retries + 1
+            if retries > 5:
+                break
+
+        # It should be available...
+        # TODO(justinsb): Mock doesn't yet do this...
+        #self.assertEqual('available', found_server['status'])
+
+        self._delete_server(created_server_id)
+
+    def _delete_server(self, server_id):
+        # Delete the server
+        self.api.delete_server(server_id)
+
+        # Wait (briefly) for deletion
+        for _retries in range(5):
+            try:
+                found_server = self.api.get_server(server_id)
+            except client.OpenstackApiNotFoundException:
+                found_server = None
+                LOG.debug("Got 404, proceeding")
+                break
+
+            LOG.debug("Found_server=%s" % found_server)
+
+            # TODO(justinsb): Mock doesn't yet do accurate state changes
+            #if found_server['status'] != 'deleting':
+            #    break
+            time.sleep(1)
+
+        # Should be gone
+        self.assertFalse(found_server)
+
+    def _build_minimal_create_server_request(self):
+        server = {}
+
+        image = self.user.get_valid_image(create=True)
+        image_id = image['id']
+
+        #TODO(justinsb): This is FUBAR
+        image_id = abs(hash(image_id))
+
+        # We now have a valid imageId
+        server['imageId'] = image_id
+
+        # Set a valid flavorId
+        flavor = self.api.get_flavors_detail()[0]
+        LOG.debug("Using flavor: %s" % flavor)
+        server['flavorId'] = flavor['id']
+
+        # Set a valid server name
+        server_name = self.user.get_unused_server_name()
+        server['name'] = server_name
+
+        return server
+
+# TODO(justinsb): Enable this unit test when the metadata bug is fixed
+#    def test_create_server_with_metadata(self):
+#        """Creates a server with metadata"""
+#
+#        # Build the server data gradually, checking errors along the way
+#        server = self._build_minimal_create_server_request()
+#
+#        for metadata_count in range(30):
+#            metadata = {}
+#            for i in range(metadata_count):
+#                metadata['key_%s' % i] = 'value_%s' % i
+#            server['metadata'] = metadata
+#
+#            post = {'server': server}
+#            created_server = self.api.post_server(post)
+#            LOG.debug("created_server: %s" % created_server)
+#            self.assertTrue(created_server['id'])
+#            created_server_id = created_server['id']
+#            # Reenable when bug fixed
+#            # self.assertEqual(metadata, created_server.get('metadata'))
+#
+#            # Check it's there
+#            found_server = self.api.get_server(created_server_id)
+#            self.assertEqual(created_server_id, found_server['id'])
+#            self.assertEqual(metadata, found_server.get('metadata'))
+#
+#            # The server should also be in the all-servers details list
+#            servers = self.api.get_servers(detail=True)
+#            server_map = dict((server['id'], server) for server in servers)
+#            found_server = server_map.get(created_server_id)
+#            self.assertTrue(found_server)
+#            # Details do include metadata
+#            self.assertEqual(metadata, found_server.get('metadata'))
+#
+#            # The server should also be in the all-servers summary list
+#            servers = self.api.get_servers(detail=False)
+#            server_map = dict((server['id'], server) for server in servers)
+#            found_server = server_map.get(created_server_id)
+#            self.assertTrue(found_server)
+#            # Summary should not include metadata
+#            self.assertFalse(found_server.get('metadata'))
+#
+#            # Cleanup
+#            self._delete_server(created_server_id)
+
+
+if __name__ == "__main__":
+    unittest.main()

=== modified file 'nova/tests/integrated/test_volumes.py'
--- nova/tests/integrated/test_volumes.py	2011-03-08 02:57:47 +0000
+++ nova/tests/integrated/test_volumes.py	2011-03-08 02:57:47 +0000
@@ -31,7 +31,8 @@
 class VolumesTest(unittest.TestCase):
     def setUp(self):
         context = integrated_helpers.IntegratedUnitTestContext.startup()
-        self.api = context.get_openstack_api()
+        self.user = context.test_user
+        self.api = self.user.openstack_api
 
     def tearDown(self):
         integrated_helpers.IntegratedUnitTestContext.shutdown()