Merge lp:~jaypipes/glance/testing-overhaul into lp:~hudson-openstack/glance/trunk

[Jay Pipes]

This patch overhauls the testing in Glance:

* Adds Nova-like run_tests.sh and tools/* files to automatically run unit tests in a virtual environment. Just do ./run_tests.sh -V from project root. All required dependencies will be installed into a new virtual environment at .glance-venv.
* Adds proper mocking and stubouts using pymox. This removes the need for all the FakeParallaxAdapter and similar code. Unit tests now call stubs.stub_out_parallax(), etc instead of having swiftfakehttp.py and similar code.

[lp:~jaypipes/glance/testing-overhaul]

14. By Jay Pipes on 2010-10-11

unittest2 -> unittest. For now, since not using unittest2 features yet.

[Rick Harris (rconradharris)]

Excellent work. I really like:

* Renaming the Adapter classes to something a little less verbose
* Axing the TestStrBackend :) That was a nasty hack.
* The use of `PyMox`. Was not familiar with that, will have to read up on it. Looks very clean.
* run-tests, obviously, very handy

I was going to add a small nit with the aliasing of unittest2 as unittest since unlike cString and cPickle they aren't entirely compatible API's. However, looks like you *just* removed it entirely, so we're good.

review: Approve

[Jay Pipes (jaypipes)]

ya, see the IRC convo with mtaylor about unittest2. Wasn't using it's features yet, so I axed it.

=== modified file '.bzrignore'
--- .bzrignore	2010-09-27 22:43:04 +0000
+++ .bzrignore	2010-10-11 19:36:15 +0000
@@ -1,2 +1,3 @@
 *.pyc
 glance.egg-info
+glance.sqlite

=== modified file 'glance/parallax/controllers.py'
--- glance/parallax/controllers.py	2010-10-04 22:18:12 +0000
+++ glance/parallax/controllers.py	2010-10-11 19:36:15 +0000
@@ -97,11 +97,3 @@
         mapper.resource("image", "images", controller=ImageController(),
                         collection={'detail': 'GET'})
         super(API, self).__init__(mapper)
-
-
-
-
-
-
-
-

=== modified file 'glance/teller/backends/__init__.py'
--- glance/teller/backends/__init__.py	2010-10-04 22:18:12 +0000
+++ glance/teller/backends/__init__.py	2010-10-11 19:36:15 +0000
@@ -39,20 +39,9 @@
     CHUNKSIZE = 4096
 
 
-class TestStrBackend(Backend):
-    """ Backend used for testing """
-
-    @classmethod
-    def get(cls, parsed_uri, expected_size):
-        """
-        teststr://data
-        """
-        yield parsed_uri.path
-
-
 class FilesystemBackend(Backend):
     @classmethod
-    def get(cls, parsed_uri, expected_size, opener=lambda p: open(p, "b")):
+    def get(cls, parsed_uri, expected_size, opener=lambda p: open(p, "rb")):
         """ Filesystem-based backend
 
         file:///path/to/file.tar.gz.0
@@ -72,8 +61,7 @@
         "file": FilesystemBackend,
         "http": HTTPBackend,
         "https": HTTPBackend,
-        "swift": SwiftBackend,
-        "teststr": TestStrBackend
+        "swift": SwiftBackend
     }
 
     parsed_uri = urlparse.urlparse(uri)
@@ -85,4 +73,3 @@
         raise UnsupportedBackend("No backend found for '%s'" % scheme)
 
     return backend.get(parsed_uri, **kwargs)
-

=== modified file 'glance/teller/backends/http.py'
--- glance/teller/backends/http.py	2010-10-04 22:18:12 +0000
+++ glance/teller/backends/http.py	2010-10-11 19:36:15 +0000
@@ -43,5 +43,3 @@
             return backends._file_iter(conn.getresponse(), cls.CHUNKSIZE)
         finally:
             conn.close()
-
-

=== modified file 'glance/teller/backends/swift.py'
--- glance/teller/backends/swift.py	2010-10-04 22:18:12 +0000
+++ glance/teller/backends/swift.py	2010-10-11 19:36:15 +0000
@@ -15,7 +15,6 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-import cloudfiles
 from glance.teller.backends import Backend, BackendException
 
 
@@ -39,6 +38,10 @@
         if conn_class:
             pass # Use the provided conn_class
         else:
+            # Import cloudfiles here because stubout will replace this call
+            # with a faked swift client in the unittests, avoiding import
+            # errors if the test system does not have cloudfiles installed
+            import cloudfiles
             conn_class = cloudfiles
 
         swift_conn = conn_class.get_connection(username=user, api_key=api_key,
@@ -64,14 +67,15 @@
             3) reassemble authurl
         """
         path = parsed_uri.path.lstrip('//')
+        netloc = parsed_uri.netloc
 
         try:
-            creds, path = path.split('@')
+            creds, netloc = netloc.split('@')
             user, api_key = creds.split(':')
             path_parts = path.split('/')
             file = path_parts.pop()
             container = path_parts.pop()
-        except ValueError:
+        except (ValueError, IndexError):
             raise BackendException(
                  "Expected four values to unpack in: swift:%s. "
                  "Should have received something like: %s."
@@ -80,5 +84,3 @@
         authurl = "https://%s" % '/'.join(path_parts)
 
         return user, api_key, authurl, container, file
-
-

=== modified file 'glance/teller/controllers.py'
--- glance/teller/controllers.py	2010-10-04 22:18:12 +0000
+++ glance/teller/controllers.py	2010-10-11 19:36:15 +0000
@@ -18,8 +18,11 @@
 Teller Image controller
 """
 
+import logging
+
 import routes
 from webob import exc, Response
+
 from glance.common import wsgi
 from glance.common import exception
 from glance.parallax import db
@@ -50,7 +53,8 @@
 
         try:
             image = registries.lookup_by_registry(registry, uri)
-        except registries.UnknownRegistryAdapter:
+            logging.debug("Found image registry for URI: %s. Got: %s", uri, image)
+        except registries.UnknownImageRegistry:
             return exc.HTTPBadRequest(body="Unknown registry '%s'" % registry,
                                       request=req,
                                       content_type="text/plain")
@@ -98,4 +102,3 @@
         mapper.resource("image", "image", controller=ImageController(),
                         collection={'detail': 'GET'})
         super(API, self).__init__(mapper)
-

=== modified file 'glance/teller/registries.py'
--- glance/teller/registries.py	2010-10-04 22:18:12 +0000
+++ glance/teller/registries.py	2010-10-11 19:36:15 +0000
@@ -20,17 +20,17 @@
 import urlparse
 
 
-class RegistryAdapterException(Exception):
+class ImageRegistryException(Exception):
     """ Base class for all RegistryAdapter exceptions """
     pass
 
 
-class UnknownRegistryAdapter(RegistryAdapterException):
+class UnknownImageRegistry(ImageRegistryException):
     """ Raised if we don't recognize the requested Registry protocol """
     pass
 
 
-class RegistryAdapter(object):
+class ImageRegistry(object):
     """ Base class for all image endpoints """
 
     @classmethod
@@ -41,9 +41,9 @@
         raise NotImplementedError
 
 
-class ParallaxAdapter(RegistryAdapter):
+class Parallax(ImageRegistry):
     """
-    ParallaxAdapter stuff
+    Parallax stuff
     """
 
     @classmethod
@@ -59,7 +59,7 @@
         elif scheme == 'https':
             conn_class = httplib.HTTPSConnection
         else:
-            raise RegistryAdapterException(
+            raise ImageRegistryException(
                 "Unrecognized scheme '%s'" % scheme)
 
         conn = conn_class(parsed_uri.netloc)
@@ -74,40 +74,24 @@
                 try:
                     return image_json["image"]
                 except KeyError:
-                    raise RegistryAdapterException("Missing 'image' key")
+                    raise ImageRegistryException("Missing 'image' key")
+        except Exception: # gaierror
+            return None
         finally:
             conn.close()
 
 
-class FakeParallaxAdapter(ParallaxAdapter):
-    """
-    A Mock ParallaxAdapter returns a mocked response for any uri with 
-    one or more 'success' and None for everything else.
-    """
-
-    @classmethod
-    def lookup(cls, parsed_uri):
-        if parsed_uri.netloc.count("success"):
-            # A successful attempt
-            files = [dict(location="teststr://chunk0", size=1235),
-                     dict(location="teststr://chunk1", size=12345)]
-            
-            return dict(files=files)
-
-
 REGISTRY_ADAPTERS = {
-    'parallax': ParallaxAdapter,
-    'fake_parallax': FakeParallaxAdapter
+    'parallax': Parallax
 }
 
+
 def lookup_by_registry(registry, image_uri):
     """ Convenience function to lookup based on a registry protocol """
     try:
         adapter = REGISTRY_ADAPTERS[registry]
     except KeyError:
-        raise UnknownRegistryAdapter("'%s' not found" % registry)
+        raise UnknownImageRegistry("'%s' not found" % registry)
     
     parsed_uri = urlparse.urlparse(image_uri)
     return adapter.lookup(parsed_uri)
-
-

=== added file 'run_tests.sh'
--- run_tests.sh	1970-01-01 00:00:00 +0000
+++ run_tests.sh	2010-10-11 19:36:15 +0000
@@ -0,0 +1,66 @@
+#!/bin/bash
+
+function usage {
+  echo "Usage: $0 [OPTION]..."
+  echo "Run Glance's test suite(s)"
+  echo ""
+  echo "  -V, --virtual-env        Always use virtualenv.  Install automatically if not present"
+  echo "  -N, --no-virtual-env     Don't use virtualenv.  Run tests in local environment"
+  echo "  -h, --help               Print this usage message"
+  echo ""
+  echo "Note: with no options specified, the script will try to run the tests in a virtual environment,"
+  echo "      If no virtualenv is found, the script will ask if you would like to create one.  If you "
+  echo "      prefer to run tests NOT in a virtual environment, simply pass the -N option."
+  exit
+}
+
+function process_options {
+  array=$1
+  elements=${#array[@]}
+  for (( x=0;x<$elements;x++)); do
+    process_option ${array[${x}]}
+  done
+}
+
+function process_option {
+  option=$1
+  case $option in
+    -h|--help) usage;;
+    -V|--virtual-env) let always_venv=1; let never_venv=0;;
+    -N|--no-virtual-env) let always_venv=0; let never_venv=1;;
+  esac
+}
+
+venv=.glance-venv
+with_venv=tools/with_venv.sh
+always_venv=0
+never_venv=0
+options=("$@")
+
+process_options $options
+
+if [ $never_venv -eq 1 ]; then
+  # Just run the test suites in current environment
+  python run_tests.py
+  exit
+fi
+
+if [ -e ${venv} ]; then
+  ${with_venv} nosetests
+else  
+  if [ $always_venv -eq 1 ]; then
+    # Automatically install the virtualenv
+    python tools/install_venv.py
+  else
+    echo -e "No virtual environment found...create one? (Y/n) \c"
+    read use_ve
+    if [ "x$use_ve" = "xY" ]; then
+      # Install the virtualenv and run the test suite in it
+      python tools/install_venv.py
+    else
+      nosetests
+      exit
+    fi
+  fi
+  ${with_venv} nosetests
+fi

=== added file 'tests/stubs.py'
--- tests/stubs.py	1970-01-01 00:00:00 +0000
+++ tests/stubs.py	2010-10-11 19:36:15 +0000
@@ -0,0 +1,149 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 OpenStack, LLC
+# 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.
+
+"""Stubouts, mocks and fixtures for the test suite"""
+
+import httplib
+import StringIO
+
+import stubout
+
+import glance.teller.backends.swift
+
+def stub_out_http_backend(stubs):
+    """Stubs out the httplib.HTTPRequest.getresponse to return
+    faked-out data instead of grabbing actual contents of a resource
+
+    The stubbed getresponse() returns an iterator over 
+    the data "I am a teapot, short and stout\n"
+
+    :param stubs: Set of stubout stubs
+
+    """
+
+    class FakeHTTPConnection(object):
+
+        DATA = 'I am a teapot, short and stout\n'
+
+        def getresponse(self):
+            return StringIO.StringIO(self.DATA)
+
+        def request(self, *_args, **_kwargs):
+            pass
+
+    fake_http_conn = FakeHTTPConnection()
+    stubs.Set(httplib.HTTPConnection, 'request',
+              fake_http_conn.request)
+    stubs.Set(httplib.HTTPSConnection, 'request',
+              fake_http_conn.request)
+    stubs.Set(httplib.HTTPConnection, 'getresponse',
+              fake_http_conn.getresponse)
+    stubs.Set(httplib.HTTPSConnection, 'getresponse',
+              fake_http_conn.getresponse)
+
+
+def stub_out_filesystem_backend(stubs):
+    """Stubs out the Filesystem Teller service to return fake
+    data from files.
+
+    The stubbed service always yields the following fixture::
+
+        //chunk0
+        //chunk1
+
+    :param stubs: Set of stubout stubs
+
+    """
+    class FakeFilesystemBackend(object):
+
+        @classmethod
+        def get(cls, parsed_uri, expected_size, conn_class=None):
+
+            return StringIO.StringIO(parsed_uri.path)
+
+    fake_filesystem_backend = FakeFilesystemBackend()
+    stubs.Set(glance.teller.backends.FilesystemBackend, 'get',
+              fake_filesystem_backend.get)
+
+
+def stub_out_swift_backend(stubs):
+    """Stubs out the Swift Teller backend with fake data
+    and calls.
+
+    The stubbed swift backend provides back an iterator over
+    the data "I am a teapot, short and stout\n"
+
+    :param stubs: Set of stubout stubs
+
+    """
+    class FakeSwiftAuth(object):
+        pass
+    class FakeSwiftConnection(object):
+        pass
+
+    class FakeSwiftBackend(object):
+
+        CHUNK_SIZE = 2
+        DATA = 'I am a teapot, short and stout\n'
+
+        @classmethod
+        def get(cls, parsed_uri, expected_size, conn_class=None):
+            SwiftBackend = glance.teller.backends.swift.SwiftBackend
+
+            # raise BackendException if URI is bad.
+            (user, api_key, authurl, container, file) = \
+                SwiftBackend.parse_swift_tokens(parsed_uri)
+
+            def chunk_it():
+                for i in xrange(0, len(cls.DATA), cls.CHUNK_SIZE):
+                    yield cls.DATA[i:i+cls.CHUNK_SIZE]
+            
+            return chunk_it()
+
+    fake_swift_backend = FakeSwiftBackend()
+    stubs.Set(glance.teller.backends.swift.SwiftBackend, 'get',
+              fake_swift_backend.get)
+
+
+def stub_out_parallax(stubs):
+    """Stubs out the Parallax registry with fake data returns.
+
+    The stubbed Parallax always returns the following fixture::
+
+        {'files': [
+          {'location': 'file:///chunk0', 'size': 12345},
+          {'location': 'file:///chunk1', 'size': 1235}
+        ]}
+
+    :param stubs: Set of stubout stubs
+
+    """
+    class FakeParallax(object):
+
+        DATA = \
+            {'files': [
+              {'location': 'file:///chunk0', 'size': 12345},
+              {'location': 'file:///chunk1', 'size': 1235}
+            ]}
+
+        @classmethod
+        def lookup(cls, _parsed_uri):
+            return cls.DATA
+
+    fake_parallax_registry = FakeParallax()
+    stubs.Set(glance.teller.registries.Parallax, 'lookup',
+              fake_parallax_registry.lookup)

=== modified file 'tests/unit/test_teller_api.py'
--- tests/unit/test_teller_api.py	2010-10-01 23:07:46 +0000
+++ tests/unit/test_teller_api.py	2010-10-11 19:36:15 +0000
@@ -1,11 +1,38 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 OpenStack, LLC
+# 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 stubout
 import unittest
 from webob import Request, exc
+
 from glance.teller import controllers
+from tests import stubs
+
 
 class TestImageController(unittest.TestCase):
     def setUp(self):
+        """Establish a clean test environment"""
+        self.stubs = stubout.StubOutForTesting()
         self.image_controller = controllers.ImageController()
 
+    def tearDown(self):
+        """Clear the test environment"""
+        self.stubs.UnsetAll()
+
     def test_index_image_with_no_uri_should_raise_http_bad_request(self):
         # uri must be specified
         request = Request.blank("/image")
@@ -21,21 +48,18 @@
 
     def test_index_image_where_image_exists_should_return_the_data(self):
         # FIXME: need urllib.quote here?
-        image_uri = "http://parallax-success/myacct/my-image"
+        stubs.stub_out_parallax(self.stubs)
+        stubs.stub_out_filesystem_backend(self.stubs)
+        image_uri = "http://parallax/myacct/my-image"
         request = self._make_request(image_uri)
         response = self.image_controller.index(request)
-        self.assertEqual("//chunk0//chunk1", response.body)
+        self.assertEqual("/chunk0/chunk1", response.body)
 
     def test_index_image_where_image_doesnt_exist_should_raise_not_found(self):
-        image_uri = "http://parallax-failure/myacct/does-not-exist"
+        image_uri = "http://bad-parallax-uri/myacct/does-not-exist"
         request = self._make_request(image_uri)
         self.assertRaises(exc.HTTPNotFound, self.image_controller.index,
                           request)
 
-    def _make_request(self, image_uri, registry="fake_parallax"):
-        return Request.blank(
-            "/image?uri=%s&registry=%s" % (image_uri, registry))
-
-
-if __name__ == "__main__":
-    unittest.main()
+    def _make_request(self, image_uri, registry="parallax"):
+        return Request.blank("/image?uri=%s&registry=%s" % (image_uri, registry))

=== modified file 'tests/unit/test_teller_backends.py'
--- tests/unit/test_teller_backends.py	2010-10-02 03:36:15 +0000
+++ tests/unit/test_teller_backends.py	2010-10-11 19:36:15 +0000
@@ -16,20 +16,29 @@
 #    under the License.
 
 from StringIO import StringIO
+
+import stubout
 import unittest
 
-from cloudfiles import Connection
-from cloudfiles.authentication import MockAuthentication as Auth
-
-from swiftfakehttp import CustomHTTPConnection
+from glance.teller.backends.swift import SwiftBackend
 from glance.teller.backends import Backend, BackendException, get_from_backend
-
-
-class TestBackends(unittest.TestCase):
+from tests import stubs
+
+Backend.CHUNKSIZE = 2
+
+class TestBackend(unittest.TestCase):
     def setUp(self):
-        Backend.CHUNKSIZE = 2
-
-    def test_filesystem_get_from_backend(self):
+        """Establish a clean test environment"""
+        self.stubs = stubout.StubOutForTesting()
+
+    def tearDown(self):
+        """Clear the test environment"""
+        self.stubs.UnsetAll()
+
+
+class TestFilesystemBackend(TestBackend):
+
+    def test_get(self):
         class FakeFile(object):
             def __enter__(self, *args, **kwargs):
                 return StringIO('fakedata')
@@ -43,65 +52,57 @@
         chunks = [c for c in fetcher]
         self.assertEqual(chunks, ["fa", "ke", "da", "ta"])
 
-    def test_http_get_from_backend(self):
-        class FakeHTTPConnection(object):
-            def __init__(self, *args, **kwargs):
-                pass
-            def request(self, *args, **kwargs):
-                pass
-            def getresponse(self):
-                return StringIO('fakedata')
-            def close(self):
-                pass
-
-        fetcher = get_from_backend("http://netloc/path/to/file.tar.gz",
-                                   expected_size=8,
-                                   conn_class=FakeHTTPConnection)
-
-        chunks = [c for c in fetcher]
-        self.assertEqual(chunks, ["fa", "ke", "da", "ta"])
-
-    def test_swift_get_from_backend(self):
-        class FakeSwift(object):
-            def __init__(self, *args, **kwargs): 
-                pass
-
-            @classmethod
-            def get_connection(self, *args, **kwargs):
-                auth = Auth("user", "password")
-                conn = Connection(auth=auth)
-                conn.connection = CustomHTTPConnection("localhost", 8000)
-                return conn
+
+class TestHTTPBackend(TestBackend):
+
+    def setUp(self):
+        super(TestHTTPBackend, self).setUp()
+        stubs.stub_out_http_backend(self.stubs)
+
+    def test_http_get(self):
+        url = "http://netloc/path/to/file.tar.gz"
+        expected_returns = ['I ', 'am', ' a', ' t', 'ea', 'po', 't,', ' s', 
+                            'ho', 'rt', ' a', 'nd', ' s', 'to', 'ut', '\n']
+        fetcher = get_from_backend(url,
+                                   expected_size=8)
+
+        chunks = [c for c in fetcher]
+        self.assertEqual(chunks, expected_returns)
+
+    def test_https_get(self):
+        url = "https://netloc/path/to/file.tar.gz"
+        expected_returns = ['I ', 'am', ' a', ' t', 'ea', 'po', 't,', ' s', 
+                            'ho', 'rt', ' a', 'nd', ' s', 'to', 'ut', '\n']
+        fetcher = get_from_backend(url,
+                                   expected_size=8)
+
+        chunks = [c for c in fetcher]
+        self.assertEqual(chunks, expected_returns)
+
+
+class TestSwiftBackend(TestBackend):
+
+    def setUp(self):
+        super(TestSwiftBackend, self).setUp()
+        stubs.stub_out_swift_backend(self.stubs)
+
+    def test_get(self):
 
         swift_uri = "swift://user:password@localhost/container1/file.tar.gz"
-        swift_returns = ['I ', 'am', ' a', ' t', 'ea', 'po', 't,', ' s', 
-                         'ho', 'rt', ' a', 'nd', ' s', 'to', 'ut', '\n']
+        expected_returns = ['I ', 'am', ' a', ' t', 'ea', 'po', 't,', ' s', 
+                            'ho', 'rt', ' a', 'nd', ' s', 'to', 'ut', '\n']
 
         fetcher = get_from_backend(swift_uri,
                                    expected_size=21,
-                                   conn_class=FakeSwift)
+                                   conn_class=SwiftBackend)
 
         chunks = [c for c in fetcher]
 
-        self.assertEqual(chunks, swift_returns)
-
-    def test_swift_get_from_backend_with_bad_uri(self):
-        class FakeSwift(object):
-            def __init__(self, *args, **kwargs): 
-                pass
-
-            @classmethod
-            def get_connection(self, *args, **kwargs):
-                auth = Auth("user", "password")
-                conn = Connection(auth=auth)
-                conn.connection = CustomHTTPConnection("localhost", 8000)
-                return conn
+        self.assertEqual(chunks, expected_returns)
+
+    def test_get_bad_uri(self):
 
         swift_url = "swift://localhost/container1/file.tar.gz"
 
         self.assertRaises(BackendException, get_from_backend, 
                           swift_url, expected_size=21)
-
-
-if __name__ == "__main__":
-    unittest.main()

=== added file 'tests/utils.py'
--- tests/utils.py	1970-01-01 00:00:00 +0000
+++ tests/utils.py	2010-10-11 19:36:15 +0000
@@ -0,0 +1,27 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 OpenStack, LLC
+# 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.
+
+"""Common utilities used in testing"""
+
+
+def is_cloudfiles_available():
+    """Returns True if Swift/Cloudfiles is importable"""
+    try:
+        import cloudfiles
+        return True
+    except ImportError:
+        return False

=== added directory 'tools'
=== added file 'tools/install_venv.py'
--- tools/install_venv.py	1970-01-01 00:00:00 +0000
+++ tools/install_venv.py	2010-10-11 19:36:15 +0000
@@ -0,0 +1,136 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 United States Government as represented by the
+# Administrator of the National Aeronautics and Space Administration.
+# All Rights Reserved.
+#
+# Copyright 2010 OpenStack, LLC
+#
+#    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.
+
+"""
+Installation script for Glance's development virtualenv
+"""
+
+import os
+import subprocess
+import sys
+
+
+ROOT = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
+VENV = os.path.join(ROOT, '.glance-venv')
+PIP_REQUIRES = os.path.join(ROOT, 'tools', 'pip-requires')
+TWISTED_NOVA='http://nova.openstack.org/Twisted-10.0.0Nova.tar.gz'
+
+def die(message, *args):
+  print >>sys.stderr, message % args
+  sys.exit(1)
+
+
+def run_command(cmd, redirect_output=True, check_exit_code=True):
+  """
+  Runs a command in an out-of-process shell, returning the
+  output of that command.  Working directory is ROOT.
+  """
+  if redirect_output:
+    stdout = subprocess.PIPE
+  else:
+    stdout = None
+
+  proc = subprocess.Popen(cmd, cwd=ROOT, stdout=stdout)
+  output = proc.communicate()[0]
+  if check_exit_code and proc.returncode != 0:
+    die('Command "%s" failed.\n%s', ' '.join(cmd), output)
+  return output
+
+
+HAS_EASY_INSTALL = bool(run_command(['which', 'easy_install'], check_exit_code=False).strip())
+HAS_VIRTUALENV = bool(run_command(['which', 'virtualenv'], check_exit_code=False).strip())
+
+
+def check_dependencies():
+  """Make sure virtualenv is in the path."""
+
+  if not HAS_VIRTUALENV:
+    print 'not found.'
+    # Try installing it via easy_install...
+    if HAS_EASY_INSTALL:
+      print 'Installing virtualenv via easy_install...',
+      if not run_command(['which', 'easy_install']):
+        die('ERROR: virtualenv not found.\n\nGlance development requires virtualenv,'
+            ' please install it using your favorite package management tool')
+      print 'done.'
+  print 'done.'
+
+
+def create_virtualenv(venv=VENV):
+  """Creates the virtual environment and installs PIP only into the
+  virtual environment
+  """
+  print 'Creating venv...',
+  run_command(['virtualenv', '-q', '--no-site-packages', VENV])
+  print 'done.'
+  print 'Installing pip in virtualenv...',
+  if not run_command(['tools/with_venv.sh', 'easy_install', 'pip']).strip():
+    die("Failed to install pip.")
+  print 'done.'
+
+
+def install_dependencies(venv=VENV):
+  print 'Installing dependencies with pip (this can take a while)...'
+
+  # Install greenlet by hand - just listing it in the requires file does not
+  # get it in stalled in the right order
+  run_command(['tools/with_venv.sh', 'pip', 'install', '-E', venv, 'greenlet'],
+              redirect_output=False)
+  run_command(['tools/with_venv.sh', 'pip', 'install', '-E', venv, '-r', PIP_REQUIRES],
+              redirect_output=False)
+  run_command(['tools/with_venv.sh', 'pip', 'install', '-E', venv, TWISTED_NOVA],
+              redirect_output=False)
+
+  # Tell the virtual env how to "import glance"
+  pthfile = os.path.join(venv, "lib", "python2.6", "site-packages", "glance.pth")
+  f = open(pthfile, 'w')
+  f.write("%s\n" % ROOT)
+
+
+def print_help():
+  help = """
+ Glance development environment setup is complete.
+
+ Glance development uses virtualenv to track and manage Python dependencies
+ while in development and testing.
+
+ To activate the Glance virtualenv for the extent of your current shell session
+ you can run:
+
+ $ source .glance-venv/bin/activate 
+
+ Or, if you prefer, you can run commands in the virtualenv on a case by case
+ basis by running:
+
+ $ tools/with_venv.sh <your command>
+
+ Also, make test will automatically use the virtualenv.
+  """
+  print help
+
+
+def main(argv):
+  check_dependencies()
+  create_virtualenv()
+  install_dependencies()
+  print_help()
+
+if __name__ == '__main__':
+  main(sys.argv)

=== added file 'tools/pip-requires'
--- tools/pip-requires	1970-01-01 00:00:00 +0000
+++ tools/pip-requires	2010-10-11 19:36:15 +0000
@@ -0,0 +1,16 @@
+greenlet>=0.3.1
+SQLAlchemy>=0.6.3
+pep8==0.5.0
+pylint==0.19
+anyjson
+eventlet>=0.9.12
+lockfile
+python-daemon==1.5.5
+python-gflags>=1.3
+routes
+webob
+wsgiref
+zope.interface
+nose
+mox==0.5.0
+-f http://pymox.googlecode.com/files/mox-0.5.0.tar.gz

=== added file 'tools/with_venv.sh'
--- tools/with_venv.sh	1970-01-01 00:00:00 +0000
+++ tools/with_venv.sh	2010-10-11 19:36:15 +0000
@@ -0,0 +1,4 @@
+#!/bin/bash
+TOOLS=`dirname $0`
+VENV=$TOOLS/../.glance-venv
+source $VENV/bin/activate && $@