Merge lp:~jaypipes/glance/teller-api into lp:~hudson-openstack/glance/trunk

[Jay Pipes]

    * Changes Teller API to use REST with opaque ID sent in
      API calls instead of a "parallax URI". This hides the
      URI stuff behind the API layer in communication between
      Parallax and Teller.
    * Adds unit tests for the only complete Teller API call so
      far: GET images/<ID>, which returns a gzip'd string of
      image data

      I want to get feedback on these new unit tests and the
      changes to the Teller API to remove the parallax URI from
      the API calls.

[Rick Harris (rconradharris)]

lgtm

I'm fine with the idea of using sequential id's for now and one registry per installation. However, down the line (prob beyond cactus), we're going to want to discuss how to federate the registries, whether it's using the registry URI as the ID (which has some neat interoperability implications), or using a UUID with some peer-lookup algorithm.

Tests look good and still run fast.

[Rick Harris (rconradharris)]

Marking as approved.

review: Approve

[Michael Gundlach (gundlach)]

lgtm.

review: Approve

=== modified file 'glance/client.py'
--- glance/client.py	2010-11-23 18:12:11 +0000
+++ glance/client.py	2010-12-01 17:19:12 +0000
@@ -73,6 +73,20 @@
         self.protocol = url.scheme
         self.connection = None
 
+    def get_connection_type(self):
+        """
+        Returns the proper connection type
+        """
+        try:
+            connection_type = {'http': httplib.HTTPConnection,
+                               'https': httplib.HTTPSConnection}\
+                               [self.protocol]
+            return connection_type
+        except KeyError:
+            raise UnsupportedProtocolError("Unsupported protocol %s. Unable "
+                                           " to connect to server."
+                                           % self.protocol)
+
     def do_request(self, method, action, body=None):
         """
         Connects to the server and issues a request.  Handles converting
@@ -86,14 +100,7 @@
         :param data: string of data to send, or None (default)
         """
         try:
-            connection_type = {'http': httplib.HTTPConnection,
-                               'https': httplib.HTTPSConnection}\
-                               [self.protocol]
-        except KeyError:
-            raise UnsupportedProtocolError("Unsupported protocol %s. Unable "
-                                           " to connect to server."
-                                           % self.protocol)
-        try:
+            connection_type = self.get_connection_type()
             c = connection_type(self.netloc, self.port)
             c.request(method, action, body)
             res = c.getresponse()
@@ -116,8 +123,6 @@
         except (socket.error, IOError), e:
             raise ClientConnectionError("Unable to connect to "
                                         "server. Got error: %s" % e)
-        finally:
-            c.close()
 
     def get_status_code(self, response):
         """
@@ -132,7 +137,7 @@
 
 class TellerClient(BaseClient):
 
-    """A client for the Teller image caching service"""
+    """A client for the Teller image caching and delivery service"""
 
     DEFAULT_ADDRESS = 'http://127.0.0.1'
     DEFAULT_PORT = 9191
@@ -148,6 +153,20 @@
         """
         super(TellerClient, self).__init__(**kwargs)
 
+    def get_image(self, image_id):
+        """
+        Returns the raw disk image as a mime-encoded blob stream for the
+        supplied opaque image identifier.
+
+        :param image_id: The opaque image identifier
+
+        :raises exception.NotFound if image is not found
+        """
+        # TODO(jaypipes): Handle other registries than Parallax...
+
+        res = self.do_request("GET", "images/%s" % image_id)
+        return res.read()
+
 
 class ParallaxClient(BaseClient):
 

=== modified file 'glance/parallax/controllers.py'
--- glance/parallax/controllers.py	2010-11-23 18:12:11 +0000
+++ glance/parallax/controllers.py	2010-12-01 17:19:12 +0000
@@ -61,7 +61,7 @@
         
         """
         images = db.image_get_all_public(None)
-        image_dicts = [self._make_image_dict(i) for i in images]
+        image_dicts = [make_image_dict(i) for i in images]
         return dict(images=image_dicts)
 
     def show(self, req, id):
@@ -71,7 +71,7 @@
         except exception.NotFound:
             raise exc.HTTPNotFound()
         
-        return dict(image=self._make_image_dict(image))
+        return dict(image=make_image_dict(image))
 
     def delete(self, req, id):
         """Deletes an existing image with the registry.
@@ -133,31 +133,6 @@
         except exception.NotFound:
             return exc.HTTPNotFound()
 
-    @staticmethod
-    def _make_image_dict(image):
-        """Create a dict representation of an image which we can use to
-        serialize the image.
-        
-        """
-        
-        def _fetch_attrs(d, attrs):
-            return dict([(a, d[a]) for a in attrs])
-
-        files = [_fetch_attrs(f, db.IMAGE_FILE_ATTRS) for f in image['files']]
-
-        # TODO(sirp): should this be a dict, or a list of dicts?
-        # A plain dict is more convenient, but list of dicts would provide
-        # access to created_at, etc
-        properties = dict((p['key'], p['value'])
-                          for p in image['properties']
-                          if not p['deleted'])
-
-        image_dict = _fetch_attrs(image, db.IMAGE_ATTRS)
-
-        image_dict['files'] = files
-        image_dict['properties'] = properties
-        return image_dict
-
 
 class API(wsgi.Router):
     """WSGI entry point for all Parallax requests."""
@@ -169,3 +144,29 @@
                        collection={'detail': 'GET'})
         mapper.connect("/", controller=ImageController(), action="index")
         super(API, self).__init__(mapper)
+
+
+def make_image_dict(image):
+    """
+    Create a dict representation of an image which we can use to
+    serialize the image.
+    """
+    
+    def _fetch_attrs(d, attrs):
+        return dict([(a, d[a]) for a in attrs
+                    if a in d.keys()])
+
+    files = [_fetch_attrs(f, db.IMAGE_FILE_ATTRS) for f in image['files']]
+
+    # TODO(sirp): should this be a dict, or a list of dicts?
+    # A plain dict is more convenient, but list of dicts would provide
+    # access to created_at, etc
+    properties = dict((p['key'], p['value'])
+                      for p in image['properties']
+                      if 'deleted' in p.keys() and not p['deleted'])
+
+    image_dict = _fetch_attrs(image, db.IMAGE_ATTRS)
+
+    image_dict['files'] = files
+    image_dict['properties'] = properties
+    return image_dict

=== modified file 'glance/teller/controllers.py'
--- glance/teller/controllers.py	2010-10-12 18:01:12 +0000
+++ glance/teller/controllers.py	2010-12-01 17:19:12 +0000
@@ -31,9 +31,9 @@
 
 
 class ImageController(wsgi.Controller):
-    """Image Controller """
+    """Image Controller"""
 
-    def index(self, req):
+    def show(self, req, id):
         """
         Query the parallax service for the image registry for the passed in 
         req['uri']. If it exists, we connect to the appropriate backend as
@@ -43,44 +43,40 @@
         Optionally, we can pass in 'registry' which will use a given
         RegistryAdapter for the request. This is useful for testing.
         """
-        try:
-            uri = req.str_GET['uri']
-        except KeyError:
-            return exc.HTTPBadRequest(body="Missing uri", request=req,
-                                      content_type="text/plain")
 
         registry = req.str_GET.get('registry', 'parallax')
 
         try:
-            image = registries.lookup_by_registry(registry, uri)
-            logging.debug("Found image registry for URI: %s. Got: %s", uri, image)
+            image = registries.lookup_by_registry(registry, id)
         except registries.UnknownImageRegistry:
+            logging.debug("Could not find image registry: %s.", registry)
             return exc.HTTPBadRequest(body="Unknown registry '%s'" % registry,
                                       request=req,
                                       content_type="text/plain")
-
-        if not image:
+        except exception.NotFound:
             raise exc.HTTPNotFound(body='Image not found', request=req,
                                    content_type='text/plain')
 
         def image_iterator():
             for file in image['files']:
-                chunks = backends.get_from_backend(
-                    file['location'], expected_size=file['size'])
+                chunks = backends.get_from_backend(file['location'],
+                                                   expected_size=file['size'])
 
                 for chunk in chunks:
                     yield chunk
 
-        return req.get_response(Response(app_iter=image_iterator()))
+        res = Response(app_iter=image_iterator(),
+                       content_type="text/plain")
+        return req.get_response(res)
     
+    def index(self, req):
+        """Index is not currently supported """
+        raise exc.HTTPNotImplemented()
+
     def detail(self, req):
         """Detail is not currently supported """
         raise exc.HTTPNotImplemented()
 
-    def show(self, req):
-        """Show is not currently supported """
-        raise exc.HTTPNotImplemented()
-
     def delete(self, req, id):
         """Delete is not currently supported """
         raise exc.HTTPNotImplemented()
@@ -95,10 +91,12 @@
 
 
 class API(wsgi.Router):
+
     """WSGI entry point for all Teller requests."""
 
     def __init__(self):
         mapper = routes.Mapper()
-        mapper.resource("image", "image", controller=ImageController(),
-                        collection={'detail': 'GET'})
+        mapper.resource("image", "images", controller=ImageController(),
+                       collection={'detail': 'GET'})
+        mapper.connect("/", controller=ImageController(), action="index")
         super(API, self).__init__(mapper)

=== modified file 'glance/teller/registries.py'
--- glance/teller/registries.py	2010-10-11 18:28:35 +0000
+++ glance/teller/registries.py	2010-12-01 17:19:12 +0000
@@ -19,6 +19,8 @@
 import json
 import urlparse
 
+from glance import client
+
 
 class ImageRegistryException(Exception):
     """ Base class for all RegistryAdapter exceptions """
@@ -47,38 +49,17 @@
     """
 
     @classmethod
-    def lookup(cls, parsed_uri):
+    def lookup(cls, image_id):
         """
-        Takes a parsed_uri, checks if that image is registered in Parallax,
+        Takes an image ID and checks if that image is registered in Parallax,
         and if so, returns the image metadata. If the image does not exist,
-        we return None.
+        we raise NotFound
         """
-        scheme = parsed_uri.scheme
-        if scheme == 'http':
-            conn_class = httplib.HTTPConnection
-        elif scheme == 'https':
-            conn_class = httplib.HTTPSConnection
-        else:
-            raise ImageRegistryException(
-                "Unrecognized scheme '%s'" % scheme)
-
-        conn = conn_class(parsed_uri.netloc)
-        try:
-            conn.request('GET', parsed_uri.path, "", {})
-            response = conn.getresponse()
-
-            # The image exists
-            if response.status == 200: 
-                result = response.read()
-                image_json = json.loads(result)
-                try:
-                    return image_json["image"]
-                except KeyError:
-                    raise ImageRegistryException("Missing 'image' key")
-        except Exception: # gaierror
-            return None
-        finally:
-            conn.close()
+        # TODO(jaypipes): Make parallax client configurable via options.
+        # Unfortunately, the decision to make all adapters have no state
+        # hinders this...
+        c = client.ParallaxClient()
+        return c.get_image(image_id)
 
 
 REGISTRY_ADAPTERS = {
@@ -86,12 +67,17 @@
 }
 
 
-def lookup_by_registry(registry, image_uri):
-    """ Convenience function to lookup based on a registry protocol """
+def lookup_by_registry(registry, image_id):
+    """
+    Convenience function to lookup image metadata for the given
+    opaque image identifier and registry.
+
+    :param registry: String name of registry to use for lookups
+    :param image_id: Opaque image identifier
+    """
     try:
         adapter = REGISTRY_ADAPTERS[registry]
     except KeyError:
         raise UnknownImageRegistry("'%s' not found" % registry)
     
-    parsed_uri = urlparse.urlparse(image_uri)
-    return adapter.lookup(parsed_uri)
+    return adapter.lookup(image_id)

=== modified file 'tests/stubs.py'
--- tests/stubs.py	2010-11-23 18:12:11 +0000
+++ tests/stubs.py	2010-12-01 17:19:12 +0000
@@ -19,18 +19,26 @@
 
 import datetime
 import httplib
+import os
+import shutil
 import StringIO
 import sys
+import gzip
 
 import stubout
 import webob
 
 from glance.common import exception
 from glance.parallax import controllers as parallax_controllers
+from glance.teller import controllers as teller_controllers
+import glance.teller.backends
 import glance.teller.backends.swift
 import glance.parallax.db.sqlalchemy.api
 
 
+FAKE_FILESYSTEM_ROOTDIR = os.path.join('/tmp', 'glance-tests')
+
+
 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
@@ -63,24 +71,61 @@
               fake_http_conn.getresponse)
 
 
+def clean_out_fake_filesystem_backend():
+    """
+    Removes any leftover directories used in fake filesystem
+    backend
+    """
+    if os.path.exists(FAKE_FILESYSTEM_ROOTDIR):
+        shutil.rmtree(FAKE_FILESYSTEM_ROOTDIR, ignore_errors=True)
+
+
 def stub_out_filesystem_backend(stubs):
-    """Stubs out the Filesystem Teller service to return fake
+    """
+    Stubs out the Filesystem Teller service to return fake
     data from files.
 
-    The stubbed service always yields the following fixture::
-
-        //chunk0
-        //chunk1
+    We establish a few fake images in a directory under /tmp/glance-tests
+    and ensure that this directory contains the following files:
+
+        /acct/2.gz.0 <-- zipped tarfile containing "chunk0"
+        /acct/2.gz.1 <-- zipped tarfile containing "chunk42"
+
+    The stubbed service yields the data in the above files.
 
     :param stubs: Set of stubout stubs
 
     """
+
     class FakeFilesystemBackend(object):
 
+        CHUNKSIZE = 100
+
         @classmethod
-        def get(cls, parsed_uri, expected_size, conn_class=None):
-
-            return StringIO.StringIO(parsed_uri.path)
+        def get(cls, parsed_uri, expected_size, opener=None):
+            filepath = os.path.join('/',
+                                    parsed_uri.netloc,
+                                    parsed_uri.path.strip(os.path.sep))
+            f = gzip.open(filepath, 'rb')
+            data = f.read()
+            f.close()
+            return data
+
+    # Establish a clean faked filesystem with dummy images
+    if os.path.exists(FAKE_FILESYSTEM_ROOTDIR):
+        shutil.rmtree(FAKE_FILESYSTEM_ROOTDIR, ignore_errors=True)
+    os.mkdir(FAKE_FILESYSTEM_ROOTDIR)
+    os.mkdir(os.path.join(FAKE_FILESYSTEM_ROOTDIR, 'acct'))
+
+    f = gzip.open(os.path.join(FAKE_FILESYSTEM_ROOTDIR, 'acct', '2.gz.0'),
+                  "wb")
+    f.write("chunk0")
+    f.close()
+
+    f = gzip.open(os.path.join(FAKE_FILESYSTEM_ROOTDIR, 'acct', '2.gz.1'),
+                  "wb")
+    f.write("chunk42")
+    f.close()
 
     fake_filesystem_backend = FakeFilesystemBackend()
     stubs.Set(glance.teller.backends.FilesystemBackend, 'get',
@@ -156,25 +201,16 @@
               fake_parallax_registry.lookup)
 
 
-def stub_out_parallax_server(stubs):
+def stub_out_parallax_and_teller_server(stubs):
     """
-    Mocks httplib calls to 127.0.0.1:9292 for testing so
-    that a real Parallax server does not need to be up and
+    Mocks calls to 127.0.0.1 on 9191 and 9292 for testing so
+    that a real Teller server does not need to be up and
     running
     """
 
-    def fake_http_connection_constructor(address, port):
-        """
-        Returns either a faked connection or a real
-        one depending on if the connection is to a parallax
-        server or not...
-        """
-        return FakeParallaxConnection()
-
-
     class FakeParallaxConnection(object):
 
-        def __init__(self):
+        def __init__(self, *args, **kwargs):
             pass
 
         def connect(self):
@@ -199,8 +235,54 @@
             setattr(res, 'read', fake_reader)
             return res
 
-    stubs.Set(httplib, 'HTTPConnection',
-              fake_http_connection_constructor)
+    class FakeTellerConnection(object):
+
+        def __init__(self, *args, **kwargs):
+            pass
+
+        def connect(self):
+            return True
+
+        def close(self):
+            return True
+
+        def request(self, method, url, body=None):
+            self.req = webob.Request.blank("/" + url.lstrip("/"))
+            self.req.method = method
+            if body:
+                self.req.body = body
+
+        def getresponse(self):
+            res = self.req.get_response(teller_controllers.API())
+
+            # httplib.Response has a read() method...fake it out
+            def fake_reader():
+                return res.body
+
+            setattr(res, 'read', fake_reader)
+            return res
+
+    def fake_get_connection_type(client):
+        """
+        Returns the proper connection type
+        """
+        if client.port == 9191 and client.netloc == '127.0.0.1':
+            return FakeTellerConnection
+        if client.port == 9292 and client.netloc == '127.0.0.1':
+            return FakeParallaxConnection
+        else:
+            try:
+                connection_type = {'http': httplib.HTTPConnection,
+                                   'https': httplib.HTTPSConnection}\
+                                   [client.protocol]
+                return connection_type
+            except KeyError:
+                raise UnsupportedProtocolError("Unsupported protocol %s. Unable "
+                                               " to connect to server."
+                                               % self.protocol)
+
+    stubs.Set(glance.client.BaseClient, 'get_connection_type',
+              fake_get_connection_type)
 
 
 def stub_out_parallax_db_image_api(stubs):
@@ -225,7 +307,11 @@
                 'updated_at': datetime.datetime.utcnow(),
                 'deleted_at': None,
                 'deleted': False,
-                'files': [],
+                'files': [
+                    {"location": "swift://user:passwd@acct/container/obj.tar.gz.0",
+                     "size": 6},
+                    {"location": "swift://user:passwd@acct/container/obj.tar.gz.1",
+                     "size": 7}],
                 'properties': []},
             {'id': 2,
                 'name': 'fake image #2',
@@ -236,7 +322,11 @@
                 'updated_at': datetime.datetime.utcnow(),
                 'deleted_at': None,
                 'deleted': False,
-                'files': [],
+                'files': [
+                    {"location": "file://tmp/glance-tests/acct/2.gz.0",
+                     "size": 6},
+                    {"location": "file://tmp/glance-tests/acct/2.gz.1",
+                     "size": 7}],
                 'properties': []}]
 
         VALID_STATUSES = ('available', 'disabled', 'pending')

=== modified file 'tests/unit/test_clients.py'
--- tests/unit/test_clients.py	2010-11-23 18:12:11 +0000
+++ tests/unit/test_clients.py	2010-12-01 17:19:12 +0000
@@ -47,13 +47,16 @@
 
 class TestParallaxClient(unittest.TestCase):
 
-    """Test proper actions made for both valid and invalid requests"""
+    """
+    Test proper actions made for both valid and invalid requests
+    against a Parallax service
+    """
 
     def setUp(self):
         """Establish a clean test environment"""
         self.stubs = stubout.StubOutForTesting()
         stubs.stub_out_parallax_db_image_api(self.stubs)
-        stubs.stub_out_parallax_server(self.stubs)
+        stubs.stub_out_parallax_and_teller_server(self.stubs)
         self.client = client.ParallaxClient()
 
     def tearDown(self):
@@ -76,27 +79,61 @@
                    'name': 'fake image #2',
                    'is_public': True,
                    'image_type': 'kernel',
-                   'status': 'available'
-                  }
+                   'status': 'available',
+                   'files': [
+                        {"location": "file://tmp/glance-tests/acct/2.gz.0",
+                         "size": 6},
+                        {"location": "file://tmp/glance-tests/acct/2.gz.1",
+                         "size": 7}],
+                   'properties': []}
+
+        expected = {'id': 2,
+                   'name': 'fake image #2',
+                   'is_public': True,
+                   'image_type': 'kernel',
+                   'status': 'available',
+                   'files': [
+                        {"location": "file://tmp/glance-tests/acct/2.gz.0",
+                         "size": 6},
+                        {"location": "file://tmp/glance-tests/acct/2.gz.1",
+                         "size": 7}],
+                   'properties': {}}
 
         images = self.client.get_images_detailed()
         self.assertEquals(len(images), 1)
 
-        for k,v in fixture.iteritems():
+        for k,v in expected.iteritems():
             self.assertEquals(v, images[0][k])
 
-    def test_get_image_metadata(self):
+    def test_get_image(self):
         """Tests that the detailed info about an image returned"""
         fixture = {'id': 2,
                    'name': 'fake image #2',
                    'is_public': True,
                    'image_type': 'kernel',
-                   'status': 'available'
-                  }
+                   'status': 'available',
+                   'files': [
+                        {"location": "file://tmp/glance-tests/acct/2.gz.0",
+                         "size": 6},
+                        {"location": "file://tmp/glance-tests/acct/2.gz.1",
+                         "size": 7}],
+                   'properties': []}
+
+        expected = {'id': 2,
+                   'name': 'fake image #2',
+                   'is_public': True,
+                   'image_type': 'kernel',
+                   'status': 'available',
+                   'files': [
+                        {"location": "file://tmp/glance-tests/acct/2.gz.0",
+                         "size": 6},
+                        {"location": "file://tmp/glance-tests/acct/2.gz.1",
+                         "size": 7}],
+                   'properties': {}}
 
         data = self.client.get_image(2)
 
-        for k,v in fixture.iteritems():
+        for k,v in expected.iteritems():
             self.assertEquals(v, data[k])
 
     def test_get_image_non_existing(self):
@@ -106,7 +143,7 @@
                           self.client.get_image,
                           42)
 
-    def test_add_image_metadata_basic(self):
+    def test_add_image_basic(self):
         """Tests that we can add image metadata and returns the new id"""
         fixture = {'name': 'fake public image',
                    'is_public': True,
@@ -128,7 +165,7 @@
         self.assertTrue('status' in data.keys())
         self.assertEquals('available', data['status'])
 
-    def test_add_image_metadata_with_properties(self):
+    def test_add_image_with_properties(self):
         """Tests that we can add image metadata with properties"""
         fixture = {'name': 'fake public image',
                    'is_public': True,
@@ -231,3 +268,31 @@
         self.assertRaises(exception.NotFound,
                           self.client.delete_image,
                           3)
+
+
+class TestTellerClient(unittest.TestCase):
+
+    """
+    Test proper actions made for both valid and invalid requests
+    against a Teller service
+    """
+
+    def setUp(self):
+        """Establish a clean test environment"""
+        self.stubs = stubout.StubOutForTesting()
+        stubs.stub_out_parallax_db_image_api(self.stubs)
+        stubs.stub_out_parallax_and_teller_server(self.stubs)
+        stubs.stub_out_filesystem_backend(self.stubs)
+        self.client = client.TellerClient()
+
+    def tearDown(self):
+        """Clear the test environment"""
+        stubs.clean_out_fake_filesystem_backend()
+        self.stubs.UnsetAll()
+
+    def test_get_image(self):
+        """Test a simple file backend retrieval works as expected"""
+        expected = 'chunk0chunk42'
+        image = self.client.get_image(2)
+
+        self.assertEquals(expected, image)

=== modified file 'tests/unit/test_teller_api.py'
--- tests/unit/test_teller_api.py	2010-10-11 19:34:10 +0000
+++ tests/unit/test_teller_api.py	2010-12-01 17:19:12 +0000
@@ -15,9 +15,10 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+import unittest
+
 import stubout
-import unittest
-from webob import Request, exc
+import webob
 
 from glance.teller import controllers
 from tests import stubs
@@ -27,39 +28,42 @@
     def setUp(self):
         """Establish a clean test environment"""
         self.stubs = stubout.StubOutForTesting()
+        stubs.stub_out_parallax_and_teller_server(self.stubs)
+        stubs.stub_out_parallax_db_image_api(self.stubs)
+        stubs.stub_out_filesystem_backend(self.stubs)
         self.image_controller = controllers.ImageController()
 
     def tearDown(self):
         """Clear the test environment"""
+        stubs.clean_out_fake_filesystem_backend()
         self.stubs.UnsetAll()
 
-    def test_index_image_with_no_uri_should_raise_http_bad_request(self):
-        # uri must be specified
-        request = Request.blank("/image")
-        response = self.image_controller.index(request)
-        self.assertEqual(response.status_int, 400) # should be 422?
-
-    def test_index_image_unrecognized_registry_adapter(self):
-        # FIXME: need urllib.quote here?
-        image_uri = "http://parallax-success/myacct/my-image"
-        request = self._make_request(image_uri, "unknownregistry")
-        response = self.image_controller.index(request)
-        self.assertEqual(response.status_int, 400) # should be 422?
-
-    def test_index_image_where_image_exists_should_return_the_data(self):
-        # FIXME: need urllib.quote here?
-        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)
-
-    def test_index_image_where_image_doesnt_exist_should_raise_not_found(self):
-        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="parallax"):
-        return Request.blank("/image?uri=%s&registry=%s" % (image_uri, registry))
+    def test_index_raises_not_implemented(self):
+        req = webob.Request.blank("/images")
+        res = req.get_response(controllers.API())
+        self.assertEquals(res.status_int, webob.exc.HTTPNotImplemented.code)
+
+    def test_blank_raises_not_implemented(self):
+        req = webob.Request.blank("/")
+        res = req.get_response(controllers.API())
+        self.assertEquals(res.status_int, webob.exc.HTTPNotImplemented.code)
+
+    def test_detail_raises_not_implemented(self):
+        req = webob.Request.blank("/images/detail")
+        res = req.get_response(controllers.API())
+        self.assertEquals(res.status_int, webob.exc.HTTPNotImplemented.code)
+
+    def test_show_image_unrecognized_registry_adapter(self):
+        req = webob.Request.blank("/images/1?registry=unknown")
+        res = req.get_response(controllers.API())
+        self.assertEquals(res.status_int, webob.exc.HTTPBadRequest.code)
+
+    def test_show_image_basic(self):
+        req = webob.Request.blank("/images/2")
+        res = req.get_response(controllers.API())
+        self.assertEqual('chunk0chunk42', res.body)
+
+    def test_show_non_exists_image(self):
+        req = webob.Request.blank("/images/42")
+        res = req.get_response(controllers.API())
+        self.assertEquals(res.status_int, webob.exc.HTTPNotFound.code)