Merge Trunk

11 files changed, 282 insertions, 38 deletions

diff --git a/nova/tests/access_unittest.py b/nova/tests/access_unittest.py
index c8a49d2ca..4b40ffd0a 100644
--- a/nova/tests/access_unittest.py
+++ b/nova/tests/access_unittest.py
@@ -31,7 +31,7 @@ FLAGS = flags.FLAGS
 class Context(object):
     pass
 
-class AccessTestCase(test.BaseTestCase):
+class AccessTestCase(test.TrialTestCase):
     def setUp(self):
         super(AccessTestCase, self).setUp()
         um = manager.AuthManager()
diff --git a/nova/tests/api/rackspace/auth.py b/nova/tests/api/rackspace/auth.py
index 429c22ad2..a6e10970f 100644
--- a/nova/tests/api/rackspace/auth.py
+++ b/nova/tests/api/rackspace/auth.py
@@ -15,8 +15,8 @@ class Test(unittest.TestCase):
             '__init__', test_helper.fake_auth_init)
         test_helper.FakeAuthManager.auth_data = {}
         test_helper.FakeAuthDatabase.data = {}
-        self.stubs.Set(nova.api.rackspace, 'RateLimitingMiddleware',
-            test_helper.FakeRateLimiter)
+        test_helper.stub_out_rate_limiting(self.stubs)
+        test_helper.stub_for_testing(self.stubs)
 
     def tearDown(self):
         self.stubs.UnsetAll()
diff --git a/nova/tests/api/rackspace/flavors.py b/nova/tests/api/rackspace/flavors.py
index fb8ba94a5..7bd1ea1c4 100644
--- a/nova/tests/api/rackspace/flavors.py
+++ b/nova/tests/api/rackspace/flavors.py
@@ -16,19 +16,32 @@
 #    under the License.
 
 import unittest
+import stubout
 
+import nova.api
 from nova.api.rackspace import flavors
+from nova.tests.api.rackspace import test_helper
 from nova.tests.api.test_helper import *
 
 class FlavorsTest(unittest.TestCase):
     def setUp(self):
         self.stubs = stubout.StubOutForTesting()
+        test_helper.FakeAuthManager.auth_data = {}
+        test_helper.FakeAuthDatabase.data = {}
+        test_helper.stub_for_testing(self.stubs)
+        test_helper.stub_out_rate_limiting(self.stubs)
+        test_helper.stub_out_auth(self.stubs)
 
     def tearDown(self):
         self.stubs.UnsetAll()
 
     def test_get_flavor_list(self):
-        pass
+        req = webob.Request.blank('/v1.0/flavors')
+        res = req.get_response(nova.api.API())
+        print res
 
     def test_get_flavor_by_id(self):
         pass
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/nova/tests/api/rackspace/servers.py b/nova/tests/api/rackspace/servers.py
index 6d628e78a..9fd8e5e88 100644
--- a/nova/tests/api/rackspace/servers.py
+++ b/nova/tests/api/rackspace/servers.py
@@ -15,44 +15,168 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+import json
 import unittest
 
+import stubout
+
+from nova import db
+from nova import flags
+import nova.api.rackspace
 from nova.api.rackspace import servers
+import nova.db.api
+from nova.db.sqlalchemy.models import Instance
 from nova.tests.api.test_helper import *
+from nova.tests.api.rackspace import test_helper
+
+FLAGS = flags.FLAGS
+
+def return_server(context, id):
+    return stub_instance(id)
+
+def return_servers(context, user_id=1):
+    return [stub_instance(i, user_id) for i in xrange(5)]
+
+
+def stub_instance(id, user_id=1):
+    return Instance(
+        id=id, state=0, image_id=10, server_name='server%s'%id,
+        user_id=user_id
+    )
 
 class ServersTest(unittest.TestCase):
     def setUp(self):
         self.stubs = stubout.StubOutForTesting()
+        test_helper.FakeAuthManager.auth_data = {}
+        test_helper.FakeAuthDatabase.data = {}
+        test_helper.stub_for_testing(self.stubs)
+        test_helper.stub_out_rate_limiting(self.stubs)
+        test_helper.stub_out_auth(self.stubs)
+        self.stubs.Set(nova.db.api, 'instance_get_all', return_servers)
+        self.stubs.Set(nova.db.api, 'instance_get', return_server)
+        self.stubs.Set(nova.db.api, 'instance_get_all_by_user', 
+            return_servers)
 
     def tearDown(self):
         self.stubs.UnsetAll()
 
-    def test_get_server_list(self):
-        pass
-
-    def test_create_instance(self):
-        pass
-
     def test_get_server_by_id(self):
-        pass
+        req = webob.Request.blank('/v1.0/servers/1')
+        res = req.get_response(nova.api.API())
+        res_dict = json.loads(res.body)
+        self.assertEqual(res_dict['server']['id'], '1')
+        self.assertEqual(res_dict['server']['name'], 'server1')
 
     def test_get_backup_schedule(self):
         pass
 
-    def test_get_server_details(self):
+    def test_get_server_list(self):
+        req = webob.Request.blank('/v1.0/servers')
+        res = req.get_response(nova.api.API())
+        res_dict = json.loads(res.body)
+        
+        i = 0
+        for s in res_dict['servers']:
+            self.assertEqual(s['id'], i)
+            self.assertEqual(s['name'], 'server%d'%i)
+            self.assertEqual(s.get('imageId', None), None)
+            i += 1
+
+    #def test_create_instance(self):
+    #    test_helper.stub_out_image_translator(self.stubs)
+    #    body = dict(server=dict(
+    #        name='server_test', imageId=2, flavorId=2, metadata={},
+    #        personality = {}
+    #    ))
+    #    req = webob.Request.blank('/v1.0/servers')
+    #    req.method = 'POST'
+    #    req.body = json.dumps(body)
+
+    #    res = req.get_response(nova.api.API())
+
+    #    print res
+    def test_update_server_password(self):
         pass
 
-    def test_get_server_ips(self):
+    def test_update_server_name(self):
         pass
 
+    def test_create_backup_schedules(self):
+        req = webob.Request.blank('/v1.0/servers/1/backup_schedules')
+        req.method = 'POST'
+        res = req.get_response(nova.api.API())
+        self.assertEqual(res.status, '404 Not Found')
+
+    def test_delete_backup_schedules(self):
+        req = webob.Request.blank('/v1.0/servers/1/backup_schedules')
+        req.method = 'DELETE'
+        res = req.get_response(nova.api.API())
+        self.assertEqual(res.status, '404 Not Found')
+
+    def test_get_server_backup_schedules(self):
+        req = webob.Request.blank('/v1.0/servers/1/backup_schedules')
+        res = req.get_response(nova.api.API())
+        self.assertEqual(res.status, '404 Not Found')
+
+    def test_get_all_server_details(self):
+        req = webob.Request.blank('/v1.0/servers/detail')
+        res = req.get_response(nova.api.API())
+        res_dict = json.loads(res.body)
+        
+        i = 0
+        for s in res_dict['servers']:
+            self.assertEqual(s['id'], i)
+            self.assertEqual(s['name'], 'server%d'%i)
+            self.assertEqual(s['imageId'], 10)
+            i += 1
+
     def test_server_reboot(self):
-        pass
+        body = dict(server=dict(
+            name='server_test', imageId=2, flavorId=2, metadata={},
+            personality = {}
+        ))
+        req = webob.Request.blank('/v1.0/servers/1/action')
+        req.method = 'POST'
+        req.content_type= 'application/json'
+        req.body = json.dumps(body)
+        res = req.get_response(nova.api.API())
 
     def test_server_rebuild(self):
-        pass
+        body = dict(server=dict(
+            name='server_test', imageId=2, flavorId=2, metadata={},
+            personality = {}
+        ))
+        req = webob.Request.blank('/v1.0/servers/1/action')
+        req.method = 'POST'
+        req.content_type= 'application/json'
+        req.body = json.dumps(body)
+        res = req.get_response(nova.api.API())
 
     def test_server_resize(self):
-        pass
+        body = dict(server=dict(
+            name='server_test', imageId=2, flavorId=2, metadata={},
+            personality = {}
+        ))
+        req = webob.Request.blank('/v1.0/servers/1/action')
+        req.method = 'POST'
+        req.content_type= 'application/json'
+        req.body = json.dumps(body)
+        res = req.get_response(nova.api.API())
 
     def test_delete_server_instance(self):
-        pass
+        req = webob.Request.blank('/v1.0/servers/1')
+        req.method = 'DELETE'
+
+        self.server_delete_called = False
+        def instance_destroy_mock(context, id):
+            self.server_delete_called = True 
+
+        self.stubs.Set(nova.db.api, 'instance_destroy',
+            instance_destroy_mock)
+
+        res = req.get_response(nova.api.API())
+        self.assertEqual(res.status, '202 Accepted')
+        self.assertEqual(self.server_delete_called, True)
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/nova/tests/api/rackspace/test_helper.py b/nova/tests/api/rackspace/test_helper.py
index be14e2de8..aa7fb382c 100644
--- a/nova/tests/api/rackspace/test_helper.py
+++ b/nova/tests/api/rackspace/test_helper.py
@@ -1,8 +1,17 @@
+import datetime
+import json
+
 import webob
 import webob.dec
-import datetime
-from nova.wsgi import Router
+
 from nova import auth
+from nova import utils
+from nova import flags
+import nova.api.rackspace.auth
+import nova.api.rackspace._id_translator
+from nova.wsgi import Router
+
+FLAGS = flags.FLAGS
 
 class Context(object): 
     pass
@@ -24,6 +33,53 @@ def fake_auth_init(self):
     self.auth = FakeAuthManager()
     self.host = 'foo'
 
+@webob.dec.wsgify
+def fake_wsgi(self, req):
+    req.environ['nova.context'] = dict(user=dict(id=1))
+    if req.body:
+        req.environ['inst_dict'] = json.loads(req.body)
+    return self.application
+
+def stub_out_image_translator(stubs):
+    class FakeTranslator(object):
+        def __init__(self, id_type, service_name):
+            pass
+        
+        def to_rs_id(self, id):
+            return id
+
+        def from_rs_id(self, id):
+            return id
+
+    stubs.Set(nova.api.rackspace._id_translator,
+        'RackspaceAPIIdTranslator', FakeTranslator)
+
+def stub_out_auth(stubs):
+    def fake_auth_init(self, app):
+        self.application = app
+    
+    stubs.Set(nova.api.rackspace.AuthMiddleware, 
+        '__init__', fake_auth_init) 
+    stubs.Set(nova.api.rackspace.AuthMiddleware, 
+        '__call__', fake_wsgi) 
+
+def stub_out_rate_limiting(stubs):
+    def fake_rate_init(self, app):
+        super(nova.api.rackspace.RateLimitingMiddleware, self).__init__(app)
+        self.application = app
+
+    stubs.Set(nova.api.rackspace.RateLimitingMiddleware,
+        '__init__', fake_rate_init)
+
+    stubs.Set(nova.api.rackspace.RateLimitingMiddleware,
+        '__call__', fake_wsgi)
+
+def stub_for_testing(stubs):
+    def get_my_ip():
+        return '127.0.0.1' 
+    stubs.Set(nova.utils, 'get_my_ip', get_my_ip)
+    FLAGS.FAKE_subdomain = 'rs'
+
 class FakeAuthDatabase(object):
     data = {}
 
diff --git a/nova/tests/api/test_helper.py b/nova/tests/api/test_helper.py
index 8151a4af6..d0a2cc027 100644
--- a/nova/tests/api/test_helper.py
+++ b/nova/tests/api/test_helper.py
@@ -1,4 +1,5 @@
 import webob.dec
+from nova import wsgi
 
 class APIStub(object):
     """Class to verify request and mark it was called."""
diff --git a/nova/tests/api/wsgi_test.py b/nova/tests/api/wsgi_test.py
index 786dc1bce..9425b01d0 100644
--- a/nova/tests/api/wsgi_test.py
+++ b/nova/tests/api/wsgi_test.py
@@ -91,6 +91,57 @@ class Test(unittest.TestCase):
         result = webob.Request.blank('/test/123').get_response(Router())
         self.assertNotEqual(result.body, "123")
 
-    def test_serializer(self):
-        # TODO(eday): Placeholder for serializer testing.
-        pass
+
+class SerializerTest(unittest.TestCase):
+
+    def match(self, url, accept, expect):
+        input_dict = dict(servers=dict(a=(2,3)))
+        expected_xml = '<servers><a>(2,3)</a></servers>'
+        expected_json = '{"servers":{"a":[2,3]}}'
+        req = webob.Request.blank(url, headers=dict(Accept=accept))
+        result = wsgi.Serializer(req.environ).to_content_type(input_dict)
+        result = result.replace('\n', '').replace(' ', '')
+        if expect == 'xml':
+            self.assertEqual(result, expected_xml)
+        elif expect == 'json':
+            self.assertEqual(result, expected_json)
+        else:
+            raise "Bad expect value"
+
+    def test_basic(self):
+        self.match('/servers/4.json', None, expect='json')
+        self.match('/servers/4', 'application/json', expect='json')
+        self.match('/servers/4', 'application/xml', expect='xml')
+        self.match('/servers/4.xml',  None, expect='xml')
+
+    def test_defaults_to_json(self):
+        self.match('/servers/4', None, expect='json')
+        self.match('/servers/4', 'text/html', expect='json')
+
+    def test_suffix_takes_precedence_over_accept_header(self):
+        self.match('/servers/4.xml', 'application/json', expect='xml')
+        self.match('/servers/4.xml.', 'application/json', expect='json')
+
+    def test_deserialize(self):
+        xml = """
+            <a a1="1" a2="2">
+              <bs><b>1</b><b>2</b><b>3</b><b><c c1="1"/></b></bs>
+              <d><e>1</e></d>
+              <f>1</f>
+            </a>
+            """.strip()
+        as_dict = dict(a={
+                'a1': '1',
+                'a2': '2',
+                'bs': ['1', '2', '3', {'c': dict(c1='1')}],
+                'd': {'e': '1'},
+                'f': '1'})
+        metadata = {'application/xml': dict(plurals={'bs': 'b', 'ts': 't'})}
+        serializer = wsgi.Serializer({}, metadata)
+        self.assertEqual(serializer.deserialize(xml), as_dict)
+
+    def test_deserialize_empty_xml(self):
+        xml = """<a></a>"""
+        as_dict = {"a": {}}
+        serializer = wsgi.Serializer({})
+        self.assertEqual(serializer.deserialize(xml), as_dict)
diff --git a/nova/tests/auth_unittest.py b/nova/tests/auth_unittest.py
index c3efc577f..1955bb417 100644
--- a/nova/tests/auth_unittest.py
+++ b/nova/tests/auth_unittest.py
@@ -75,7 +75,7 @@ class user_and_project_generator(object):
         self.manager.delete_user(self.user)
         self.manager.delete_project(self.project)
 
-class AuthManagerTestCase(test.BaseTestCase):
+class AuthManagerTestCase(test.TrialTestCase):
     def setUp(self):
         super(AuthManagerTestCase, self).setUp()
         self.flags(connection_type='fake')
diff --git a/nova/tests/cloud_unittest.py b/nova/tests/cloud_unittest.py
index 756ce519e..e8ff42fc5 100644
--- a/nova/tests/cloud_unittest.py
+++ b/nova/tests/cloud_unittest.py
@@ -41,7 +41,7 @@ from nova.api.ec2 import cloud
 FLAGS = flags.FLAGS
 
 
-class CloudTestCase(test.BaseTestCase):
+class CloudTestCase(test.TrialTestCase):
     def setUp(self):
         super(CloudTestCase, self).setUp()
         self.flags(connection_type='fake')
@@ -55,9 +55,9 @@ class CloudTestCase(test.BaseTestCase):
         # set up a service
         self.compute = utils.import_class(FLAGS.compute_manager)
         self.compute_consumer = rpc.AdapterConsumer(connection=self.conn,
-                                                     topic=FLAGS.compute_topic,
-                                                     proxy=self.compute)
-        self.injected.append(self.compute_consumer.attach_to_tornado(self.ioloop))
+                                                    topic=FLAGS.compute_topic,
+                                                    proxy=self.compute)
+        self.compute_consumer.attach_to_twisted()
 
         self.manager = manager.AuthManager()
         self.user = self.manager.create_user('admin', 'admin', 'admin', True)
@@ -68,7 +68,7 @@ class CloudTestCase(test.BaseTestCase):
     def tearDown(self):
         self.manager.delete_project(self.project)
         self.manager.delete_user(self.user)
-        super(CloudTestCase, self).setUp()
+        super(CloudTestCase, self).tearDown()
 
     def _create_key(self, name):
         # NOTE(vish): create depends on pool, so just call helper directly
diff --git a/nova/tests/objectstore_unittest.py b/nova/tests/objectstore_unittest.py
index dece4b5d5..b5970d405 100644
--- a/nova/tests/objectstore_unittest.py
+++ b/nova/tests/objectstore_unittest.py
@@ -53,7 +53,7 @@ os.makedirs(os.path.join(OSS_TEMPDIR, 'images'))
 os.makedirs(os.path.join(OSS_TEMPDIR, 'buckets'))
 
 
-class ObjectStoreTestCase(test.BaseTestCase):
+class ObjectStoreTestCase(test.TrialTestCase):
     """Test objectstore API directly."""
 
     def setUp(self): # pylint: disable-msg=C0103
diff --git a/nova/tests/rpc_unittest.py b/nova/tests/rpc_unittest.py
index e12a28fbc..9652841f2 100644
--- a/nova/tests/rpc_unittest.py
+++ b/nova/tests/rpc_unittest.py
@@ -30,7 +30,7 @@ from nova import test
 FLAGS = flags.FLAGS
 
 
-class RpcTestCase(test.BaseTestCase):
+class RpcTestCase(test.TrialTestCase):
     """Test cases for rpc"""
     def setUp(self):  # pylint: disable-msg=C0103
         super(RpcTestCase, self).setUp()
@@ -39,14 +39,13 @@ class RpcTestCase(test.BaseTestCase):
         self.consumer = rpc.AdapterConsumer(connection=self.conn,
                                             topic='test',
                                             proxy=self.receiver)
-
-        self.injected.append(self.consumer.attach_to_tornado(self.ioloop))
+        self.consumer.attach_to_twisted()
 
     def test_call_succeed(self):
         """Get a value through rpc call"""
         value = 42
-        result = yield rpc.call('test', {"method": "echo",
-                                         "args": {"value": value}})
+        result = yield rpc.call_twisted('test', {"method": "echo",
+                                                 "args": {"value": value}})
         self.assertEqual(value, result)
 
     def test_call_exception(self):
@@ -57,12 +56,12 @@ class RpcTestCase(test.BaseTestCase):
         to an int in the test.
         """
         value = 42
-        self.assertFailure(rpc.call('test', {"method": "fail",
-                                             "args": {"value": value}}),
+        self.assertFailure(rpc.call_twisted('test', {"method": "fail",
+                                                     "args": {"value": value}}),
                            rpc.RemoteError)
         try:
-            yield rpc.call('test', {"method": "fail",
-                                    "args": {"value": value}})
+            yield rpc.call_twisted('test', {"method": "fail",
+                                            "args": {"value": value}})
             self.fail("should have thrown rpc.RemoteError")
         except rpc.RemoteError as exc:
             self.assertEqual(int(exc.value), value)