merge from trunk

5 files changed, 47 insertions, 150 deletions

diff --git a/nova/tests/api_unittest.py b/nova/tests/api_unittest.py
index fdb9e21d8..0732c39bb 100644
--- a/nova/tests/api_unittest.py
+++ b/nova/tests/api_unittest.py
@@ -23,60 +23,12 @@ from boto.ec2 import regioninfo
 import httplib
 import random
 import StringIO
-from tornado import httpserver
-from twisted.internet import defer
+import webob
 
-from nova import flags
 from nova import test
+from nova import api
+from nova.api.ec2 import cloud
 from nova.auth import manager
-from nova.endpoint import api
-from nova.endpoint import cloud
-
-
-FLAGS = flags.FLAGS
-
-
-# NOTE(termie): These are a bunch of helper methods and classes to short
-#               circuit boto calls and feed them into our tornado handlers,
-#               it's pretty damn circuitous so apologies if you have to fix
-#               a bug in it
-# NOTE(jaypipes) The pylint disables here are for R0913 (too many args) which
-#                isn't controllable since boto's HTTPRequest needs that many
-#                args, and for the version-differentiated import of tornado's
-#                httputil.
-# NOTE(jaypipes): The disable-msg=E1101 and E1103 below is because pylint is
-#                 unable to introspect the deferred's return value properly
-
-def boto_to_tornado(method, path, headers, data, # pylint: disable-msg=R0913
-                    host, connection=None):
-    """ translate boto requests into tornado requests
-
-    connection should be a FakeTornadoHttpConnection instance
-    """
-    try:
-        headers = httpserver.HTTPHeaders()
-    except AttributeError:
-        from tornado import httputil # pylint: disable-msg=E0611
-        headers = httputil.HTTPHeaders()
-    for k, v in headers.iteritems():
-        headers[k] = v
-
-    req = httpserver.HTTPRequest(method=method,
-                                 uri=path,
-                                 headers=headers,
-                                 body=data,
-                                 host=host,
-                                 remote_ip='127.0.0.1',
-                                 connection=connection)
-    return req
-
-
-def raw_to_httpresponse(response_string):
-    """translate a raw tornado http response into an httplib.HTTPResponse"""
-    sock = FakeHttplibSocket(response_string)
-    resp = httplib.HTTPResponse(sock)
-    resp.begin()
-    return resp
 
 
 class FakeHttplibSocket(object):
@@ -89,85 +41,35 @@ class FakeHttplibSocket(object):
         return self._buffer
 
 
-class FakeTornadoStream(object):
-    """a fake stream to satisfy tornado's assumptions, trivial"""
-    def set_close_callback(self, _func):
-        """Dummy callback for stream"""
-        pass
-
-
-class FakeTornadoConnection(object):
-    """A fake connection object for tornado to pass to its handlers
-
-    web requests are expected to write to this as they get data and call
-    finish when they are done with the request, we buffer the writes and
-    kick off a callback when it is done so that we can feed the result back
-    into boto.
-    """
-    def __init__(self, deferred):
-        self._deferred = deferred
-        self._buffer = StringIO.StringIO()
-
-    def write(self, chunk):
-        """Writes a chunk of data to the internal buffer"""
-        self._buffer.write(chunk)
-
-    def finish(self):
-        """Finalizes the connection and returns the buffered data via the
-        deferred callback.
-        """
-        data = self._buffer.getvalue()
-        self._deferred.callback(data)
-
-    xheaders = None
-
-    @property
-    def stream(self): # pylint: disable-msg=R0201
-        """Required property for interfacing with tornado"""
-        return FakeTornadoStream()
-
-
 class FakeHttplibConnection(object):
     """A fake httplib.HTTPConnection for boto to use
 
     requests made via this connection actually get translated and routed into
-    our tornado app, we then wait for the response and turn it back into
+    our WSGI app, we then wait for the response and turn it back into
     the httplib.HTTPResponse that boto expects.
     """
     def __init__(self, app, host, is_secure=False):
         self.app = app
         self.host = host
-        self.deferred = defer.Deferred()
 
     def request(self, method, path, data, headers):
-        """Creates a connection to a fake tornado and sets
-        up a deferred request with the supplied data and
-        headers"""
-        conn = FakeTornadoConnection(self.deferred)
-        request = boto_to_tornado(connection=conn,
-                                  method=method,
-                                  path=path,
-                                  headers=headers,
-                                  data=data,
-                                  host=self.host)
-        self.app(request)
-        self.deferred.addCallback(raw_to_httpresponse)
+        req = webob.Request.blank(path)
+        req.method = method
+        req.body = data
+        req.headers = headers
+        req.headers['Accept'] = 'text/html'
+        req.host = self.host
+        # Call the WSGI app, get the HTTP response
+        resp = str(req.get_response(self.app))
+        # For some reason, the response doesn't have "HTTP/1.0 " prepended; I
+        # guess that's a function the web server usually provides.
+        resp = "HTTP/1.0 %s" % resp
+        sock = FakeHttplibSocket(resp)
+        self.http_response = httplib.HTTPResponse(sock)
+        self.http_response.begin()
 
     def getresponse(self):
-        """A bit of deferred magic for catching the response
-        from the previously deferred request"""
-        @defer.inlineCallbacks
-        def _waiter():
-            """Callback that simply yields the deferred's
-            return value."""
-            result = yield self.deferred
-            defer.returnValue(result)
-        d = _waiter()
-        # NOTE(termie): defer.returnValue above should ensure that
-        #               this deferred has already been called by the time
-        #               we get here, we are going to cheat and return
-        #               the result of the callback
-        return d.result # pylint: disable-msg=E1101
+        return self.http_response
 
     def close(self):
         """Required for compatibility with boto/tornado"""
@@ -180,17 +82,16 @@ class ApiEc2TestCase(test.BaseTestCase):
         super(ApiEc2TestCase, self).setUp()
 
         self.manager = manager.AuthManager()
-        self.cloud = cloud.CloudController()
 
         self.host = '127.0.0.1'
 
-        self.app = api.APIServerApplication({'Cloud': self.cloud})
+        self.app = api.API()
         self.ec2 = boto.connect_ec2(
                 aws_access_key_id='fake',
                 aws_secret_access_key='fake',
                 is_secure=False,
                 region=regioninfo.RegionInfo(None, 'test', self.host),
-                port=FLAGS.cc_port,
+                port=8773,
                 path='/services/Cloud')
 
         self.mox.StubOutWithMock(self.ec2, 'new_http_connection')
@@ -198,7 +99,7 @@ class ApiEc2TestCase(test.BaseTestCase):
     def expect_http(self, host=None, is_secure=False):
         """Returns a new EC2 connection"""
         http = FakeHttplibConnection(
-                self.app, '%s:%d' % (self.host, FLAGS.cc_port), False)
+                self.app, '%s:8773' % (self.host), False)
         # pylint: disable-msg=E1103
         self.ec2.new_http_connection(host, is_secure).AndReturn(http)
         return http
diff --git a/nova/tests/auth_unittest.py b/nova/tests/auth_unittest.py
index cbf7b22e2..3235dea39 100644
--- a/nova/tests/auth_unittest.py
+++ b/nova/tests/auth_unittest.py
@@ -24,7 +24,7 @@ from nova import crypto
 from nova import flags
 from nova import test
 from nova.auth import manager
-from nova.endpoint import cloud
+from nova.api.ec2 import cloud
 
 FLAGS = flags.FLAGS
 
diff --git a/nova/tests/cloud_unittest.py b/nova/tests/cloud_unittest.py
index 317200e01..2f22982eb 100644
--- a/nova/tests/cloud_unittest.py
+++ b/nova/tests/cloud_unittest.py
@@ -35,8 +35,8 @@ from nova import test
 from nova import utils
 from nova.auth import manager
 from nova.compute import power_state
-from nova.endpoint import api
-from nova.endpoint import cloud
+from nova.api.ec2 import context
+from nova.api.ec2 import cloud
 
 
 FLAGS = flags.FLAGS
@@ -63,9 +63,8 @@ class CloudTestCase(test.BaseTestCase):
         self.manager = manager.AuthManager()
         self.user = self.manager.create_user('admin', 'admin', 'admin', True)
         self.project = self.manager.create_project('proj', 'admin', 'proj')
-        self.context = api.APIRequestContext(handler=None,
-                                             user=self.user,
-                                             project=self.project)
+        self.context = context.APIRequestContext(user=self.user,
+                                                 project=self.project)
 
     def tearDown(self):
         self.manager.delete_project(self.project)
diff --git a/nova/tests/network_unittest.py b/nova/tests/network_unittest.py
index dc5277f02..da65b50a2 100644
--- a/nova/tests/network_unittest.py
+++ b/nova/tests/network_unittest.py
@@ -28,7 +28,7 @@ from nova import flags
 from nova import test
 from nova import utils
 from nova.auth import manager
-from nova.endpoint import api
+from nova.api.ec2 import context
 
 FLAGS = flags.FLAGS
 
@@ -49,7 +49,7 @@ class NetworkTestCase(test.TrialTestCase):
         self.user = self.manager.create_user('netuser', 'netuser', 'netuser')
         self.projects = []
         self.network = utils.import_object(FLAGS.network_manager)
-        self.context = api.APIRequestContext(None, project=None, user=self.user)
+        self.context = context.APIRequestContext(project=None, user=self.user)
         for i in range(5):
             name = 'project%s' % i
             self.projects.append(self.manager.create_project(name,
diff --git a/nova/tests/quota_unittest.py b/nova/tests/quota_unittest.py
index cab9f663d..370ccd506 100644
--- a/nova/tests/quota_unittest.py
+++ b/nova/tests/quota_unittest.py
@@ -25,8 +25,8 @@ from nova import quota
 from nova import test
 from nova import utils
 from nova.auth import manager
-from nova.endpoint import cloud
-from nova.endpoint import api
+from nova.api.ec2 import cloud
+from nova.api.ec2 import context
 
 
 FLAGS = flags.FLAGS
@@ -48,9 +48,8 @@ class QuotaTestCase(test.TrialTestCase):
         self.user = self.manager.create_user('admin', 'admin', 'admin', True)
         self.project = self.manager.create_project('admin', 'admin', 'admin')
         self.network = utils.import_object(FLAGS.network_manager)
-        self.context = api.APIRequestContext(handler=None,
-                                             project=self.project,
-                                             user=self.user)
+        self.context = context.APIRequestContext(project=self.project,
+                                                 user=self.user)
 
     def tearDown(self):  # pylint: disable-msg=C0103
         manager.AuthManager().delete_project(self.project)
@@ -95,11 +94,11 @@ class QuotaTestCase(test.TrialTestCase):
         for i in range(FLAGS.quota_instances):
             instance_id = self._create_instance()
             instance_ids.append(instance_id)
-        self.assertFailure(self.cloud.run_instances(self.context,
-                                                    min_count=1,
-                                                    max_count=1,
-                                                    instance_type='m1.small'),
-                           cloud.QuotaError)
+        self.assertRaises(cloud.QuotaError, self.cloud.run_instances, 
+                                            self.context,
+                                            min_count=1,
+                                            max_count=1,
+                                            instance_type='m1.small')
         for instance_id in instance_ids:
             db.instance_destroy(self.context, instance_id)
 
@@ -107,11 +106,11 @@ class QuotaTestCase(test.TrialTestCase):
         instance_ids = []
         instance_id = self._create_instance(cores=4)
         instance_ids.append(instance_id)
-        self.assertFailure(self.cloud.run_instances(self.context,
-                                                    min_count=1,
-                                                    max_count=1,
-                                                    instance_type='m1.small'),
-                           cloud.QuotaError)
+        self.assertRaises(cloud.QuotaError, self.cloud.run_instances, 
+                                            self.context,
+                                            min_count=1,
+                                            max_count=1,
+                                            instance_type='m1.small')
         for instance_id in instance_ids:
             db.instance_destroy(self.context, instance_id)
 
@@ -120,10 +119,9 @@ class QuotaTestCase(test.TrialTestCase):
         for i in range(FLAGS.quota_volumes):
             volume_id = self._create_volume()
             volume_ids.append(volume_id)
-        self.assertRaises(cloud.QuotaError,
-                          self.cloud.create_volume,
-                          self.context,
-                          size=10)
+        self.assertRaises(cloud.QuotaError, self.cloud.create_volume,
+                                            self.context,
+                                            size=10)
         for volume_id in volume_ids:
             db.volume_destroy(self.context, volume_id)
 
@@ -151,5 +149,4 @@ class QuotaTestCase(test.TrialTestCase):
         #             make an rpc.call, the test just finishes with OK. It
         #             appears to be something in the magic inline callbacks
         #             that is breaking.
-        self.assertFailure(self.cloud.allocate_address(self.context),
-                           cloud.QuotaError)
+        self.assertRaises(cloud.QuotaError, self.cloud.allocate_address, self.context)