Merging trunk

6 files changed, 391 insertions, 31 deletions

diff --git a/nova/tests/api/openstack/__init__.py b/nova/tests/api/openstack/__init__.py
index 14eaaa62c..77b1dd37f 100644
--- a/nova/tests/api/openstack/__init__.py
+++ b/nova/tests/api/openstack/__init__.py
@@ -92,31 +92,3 @@ class RateLimitingMiddlewareTest(unittest.TestCase):
         self.assertEqual(middleware.limiter.__class__.__name__, "Limiter")
         middleware = RateLimitingMiddleware(simple_wsgi, service_host='foobar')
         self.assertEqual(middleware.limiter.__class__.__name__, "WSGIAppProxy")
-
-
-class LimiterTest(unittest.TestCase):
-
-    def test_limiter(self):
-        items = range(2000)
-        req = Request.blank('/')
-        self.assertEqual(limited(items, req), items[:1000])
-        req = Request.blank('/?offset=0')
-        self.assertEqual(limited(items, req), items[:1000])
-        req = Request.blank('/?offset=3')
-        self.assertEqual(limited(items, req), items[3:1003])
-        req = Request.blank('/?offset=2005')
-        self.assertEqual(limited(items, req), [])
-        req = Request.blank('/?limit=10')
-        self.assertEqual(limited(items, req), items[:10])
-        req = Request.blank('/?limit=0')
-        self.assertEqual(limited(items, req), items[:1000])
-        req = Request.blank('/?limit=3000')
-        self.assertEqual(limited(items, req), items[:1000])
-        req = Request.blank('/?offset=1&limit=3')
-        self.assertEqual(limited(items, req), items[1:4])
-        req = Request.blank('/?offset=3&limit=0')
-        self.assertEqual(limited(items, req), items[3:1003])
-        req = Request.blank('/?offset=3&limit=1500')
-        self.assertEqual(limited(items, req), items[3:1003])
-        req = Request.blank('/?offset=3000&limit=10')
-        self.assertEqual(limited(items, req), [])
diff --git a/nova/tests/api/openstack/test_common.py b/nova/tests/api/openstack/test_common.py
new file mode 100644
index 000000000..9d9837cc9
--- /dev/null
+++ b/nova/tests/api/openstack/test_common.py
@@ -0,0 +1,161 @@
+# 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.
+
+"""
+Test suites for 'common' code used throughout the OpenStack HTTP API.
+"""
+
+import unittest
+
+from webob import Request
+
+from nova.api.openstack.common import limited
+
+
+class LimiterTest(unittest.TestCase):
+    """
+    Unit tests for the `nova.api.openstack.common.limited` method which takes
+    in a list of items and, depending on the 'offset' and 'limit' GET params,
+    returns a subset or complete set of the given items.
+    """
+
+    def setUp(self):
+        """
+        Run before each test.
+        """
+        self.tiny = range(1)
+        self.small = range(10)
+        self.medium = range(1000)
+        self.large = range(10000)
+
+    def test_limiter_offset_zero(self):
+        """
+        Test offset key works with 0.
+        """
+        req = Request.blank('/?offset=0')
+        self.assertEqual(limited(self.tiny, req), self.tiny)
+        self.assertEqual(limited(self.small, req), self.small)
+        self.assertEqual(limited(self.medium, req), self.medium)
+        self.assertEqual(limited(self.large, req), self.large[:1000])
+
+    def test_limiter_offset_medium(self):
+        """
+        Test offset key works with a medium sized number.
+        """
+        req = Request.blank('/?offset=10')
+        self.assertEqual(limited(self.tiny, req), [])
+        self.assertEqual(limited(self.small, req), self.small[10:])
+        self.assertEqual(limited(self.medium, req), self.medium[10:])
+        self.assertEqual(limited(self.large, req), self.large[10:1010])
+
+    def test_limiter_offset_over_max(self):
+        """
+        Test offset key works with a number over 1000 (max_limit).
+        """
+        req = Request.blank('/?offset=1001')
+        self.assertEqual(limited(self.tiny, req), [])
+        self.assertEqual(limited(self.small, req), [])
+        self.assertEqual(limited(self.medium, req), [])
+        self.assertEqual(limited(self.large, req), self.large[1001:2001])
+
+    def test_limiter_offset_blank(self):
+        """
+        Test offset key works with a blank offset.
+        """
+        req = Request.blank('/?offset=')
+        self.assertEqual(limited(self.tiny, req), self.tiny)
+        self.assertEqual(limited(self.small, req), self.small)
+        self.assertEqual(limited(self.medium, req), self.medium)
+        self.assertEqual(limited(self.large, req), self.large[:1000])
+
+    def test_limiter_offset_bad(self):
+        """
+        Test offset key works with a BAD offset.
+        """
+        req = Request.blank(u'/?offset=\u0020aa')
+        self.assertEqual(limited(self.tiny, req), self.tiny)
+        self.assertEqual(limited(self.small, req), self.small)
+        self.assertEqual(limited(self.medium, req), self.medium)
+        self.assertEqual(limited(self.large, req), self.large[:1000])
+
+    def test_limiter_nothing(self):
+        """
+        Test request with no offset or limit
+        """
+        req = Request.blank('/')
+        self.assertEqual(limited(self.tiny, req), self.tiny)
+        self.assertEqual(limited(self.small, req), self.small)
+        self.assertEqual(limited(self.medium, req), self.medium)
+        self.assertEqual(limited(self.large, req), self.large[:1000])
+
+    def test_limiter_limit_zero(self):
+        """
+        Test limit of zero.
+        """
+        req = Request.blank('/?limit=0')
+        self.assertEqual(limited(self.tiny, req), self.tiny)
+        self.assertEqual(limited(self.small, req), self.small)
+        self.assertEqual(limited(self.medium, req), self.medium)
+        self.assertEqual(limited(self.large, req), self.large[:1000])
+
+    def test_limiter_limit_medium(self):
+        """
+        Test limit of 10.
+        """
+        req = Request.blank('/?limit=10')
+        self.assertEqual(limited(self.tiny, req), self.tiny)
+        self.assertEqual(limited(self.small, req), self.small)
+        self.assertEqual(limited(self.medium, req), self.medium[:10])
+        self.assertEqual(limited(self.large, req), self.large[:10])
+
+    def test_limiter_limit_over_max(self):
+        """
+        Test limit of 3000.
+        """
+        req = Request.blank('/?limit=3000')
+        self.assertEqual(limited(self.tiny, req), self.tiny)
+        self.assertEqual(limited(self.small, req), self.small)
+        self.assertEqual(limited(self.medium, req), self.medium)
+        self.assertEqual(limited(self.large, req), self.large[:1000])
+
+    def test_limiter_limit_and_offset(self):
+        """
+        Test request with both limit and offset.
+        """
+        items = range(2000)
+        req = Request.blank('/?offset=1&limit=3')
+        self.assertEqual(limited(items, req), items[1:4])
+        req = Request.blank('/?offset=3&limit=0')
+        self.assertEqual(limited(items, req), items[3:1003])
+        req = Request.blank('/?offset=3&limit=1500')
+        self.assertEqual(limited(items, req), items[3:1003])
+        req = Request.blank('/?offset=3000&limit=10')
+        self.assertEqual(limited(items, req), [])
+
+    def test_limiter_custom_max_limit(self):
+        """
+        Test a max_limit other than 1000.
+        """
+        items = range(2000)
+        req = Request.blank('/?offset=1&limit=3')
+        self.assertEqual(limited(items, req, max_limit=2000), items[1:4])
+        req = Request.blank('/?offset=3&limit=0')
+        self.assertEqual(limited(items, req, max_limit=2000), items[3:])
+        req = Request.blank('/?offset=3&limit=2500')
+        self.assertEqual(limited(items, req, max_limit=2000), items[3:])
+        req = Request.blank('/?offset=3000&limit=10')
+        self.assertEqual(limited(items, req, max_limit=2000), [])
diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index 724f14f19..a7be0796e 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -15,6 +15,7 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+import datetime
 import json
 import unittest
 
@@ -39,6 +40,13 @@ def return_server(context, id):
     return stub_instance(id)
 
 
+def return_server_with_addresses(private, public):
+    def _return_server(context, id):
+        return stub_instance(id, private_address=private,
+                             public_addresses=public)
+    return _return_server
+
+
 def return_servers(context, user_id=1):
     return [stub_instance(i, user_id) for i in xrange(5)]
 
@@ -55,9 +63,45 @@ def instance_address(context, instance_id):
     return None
 
 
-def stub_instance(id, user_id=1):
-    return Instance(id=id, state=0, image_id=10, user_id=user_id,
-                    display_name='server%s' % id)
+def stub_instance(id, user_id=1, private_address=None, public_addresses=None):
+    if public_addresses == None:
+        public_addresses = list()
+
+    instance = {
+        "id": id,
+        "admin_pass": "",
+        "user_id": user_id,
+        "project_id": "",
+        "image_id": 10,
+        "kernel_id": "",
+        "ramdisk_id": "",
+        "launch_index": 0,
+        "key_name": "",
+        "key_data": "",
+        "state": 0,
+        "state_description": "",
+        "memory_mb": 0,
+        "vcpus": 0,
+        "local_gb": 0,
+        "hostname": "",
+        "host": "",
+        "instance_type": "",
+        "user_data": "",
+        "reservation_id": "",
+        "mac_address": "",
+        "scheduled_at": datetime.datetime.now(),
+        "launched_at": datetime.datetime.now(),
+        "terminated_at": datetime.datetime.now(),
+        "availability_zone": "",
+        "display_name": "server%s" % id,
+        "display_description": "",
+        "locked": False}
+
+    instance["fixed_ip"] = {
+        "address": private_address,
+        "floating_ips": [{"address":ip} for ip in public_addresses]}
+
+    return instance
 
 
 def fake_compute_api(cls, req, id):
@@ -105,6 +149,22 @@ class ServersTest(unittest.TestCase):
         self.assertEqual(res_dict['server']['id'], '1')
         self.assertEqual(res_dict['server']['name'], 'server1')
 
+    def test_get_server_by_id_with_addresses(self):
+        private = "192.168.0.3"
+        public = ["1.2.3.4"]
+        new_return_server = return_server_with_addresses(private, public)
+        self.stubs.Set(nova.db.api, 'instance_get', new_return_server)
+        req = webob.Request.blank('/v1.0/servers/1')
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+        self.assertEqual(res_dict['server']['id'], '1')
+        self.assertEqual(res_dict['server']['name'], 'server1')
+        addresses = res_dict['server']['addresses']
+        self.assertEqual(len(addresses["public"]), len(public))
+        self.assertEqual(addresses["public"][0], public[0])
+        self.assertEqual(len(addresses["private"]), 1)
+        self.assertEqual(addresses["private"][0], private)
+
     def test_get_server_list(self):
         req = webob.Request.blank('/v1.0/servers')
         res = req.get_response(fakes.wsgi_app())
@@ -281,6 +341,18 @@ class ServersTest(unittest.TestCase):
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 202)
 
+    def test_server_reset_network(self):
+        FLAGS.allow_admin_api = True
+        body = dict(server=dict(
+            name='server_test', imageId=2, flavorId=2, metadata={},
+            personality={}))
+        req = webob.Request.blank('/v1.0/servers/1/reset_network')
+        req.method = 'POST'
+        req.content_type = 'application/json'
+        req.body = json.dumps(body)
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 202)
+
     def test_server_diagnostics(self):
         req = webob.Request.blank("/v1.0/servers/1/diagnostics")
         req.method = "GET"
diff --git a/nova/tests/api/openstack/test_zones.py b/nova/tests/api/openstack/test_zones.py
new file mode 100644
index 000000000..5542a1cf3
--- /dev/null
+++ b/nova/tests/api/openstack/test_zones.py
@@ -0,0 +1,141 @@
+# 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 unittest
+
+import stubout
+import webob
+import json
+
+import nova.db
+from nova import context
+from nova import flags
+from nova.api.openstack import zones
+from nova.tests.api.openstack import fakes
+
+
+FLAGS = flags.FLAGS
+FLAGS.verbose = True
+
+
+def zone_get(context, zone_id):
+    return dict(id=1, api_url='http://foo.com', username='bob',
+                password='xxx')
+
+
+def zone_create(context, values):
+    zone = dict(id=1)
+    zone.update(values)
+    return zone
+
+
+def zone_update(context, zone_id, values):
+    zone = dict(id=zone_id, api_url='http://foo.com', username='bob',
+                password='xxx')
+    zone.update(values)
+    return zone
+
+
+def zone_delete(context, zone_id):
+    pass
+
+
+def zone_get_all(context):
+    return [
+        dict(id=1, api_url='http://foo.com', username='bob',
+                 password='xxx'),
+        dict(id=2, api_url='http://blah.com', username='alice',
+                 password='qwerty')
+    ]
+
+
+class ZonesTest(unittest.TestCase):
+    def setUp(self):
+        self.stubs = stubout.StubOutForTesting()
+        fakes.FakeAuthManager.auth_data = {}
+        fakes.FakeAuthDatabase.data = {}
+        fakes.stub_out_networking(self.stubs)
+        fakes.stub_out_rate_limiting(self.stubs)
+        fakes.stub_out_auth(self.stubs)
+
+        self.allow_admin = FLAGS.allow_admin_api
+        FLAGS.allow_admin_api = True
+
+        self.stubs.Set(nova.db, 'zone_get', zone_get)
+        self.stubs.Set(nova.db, 'zone_get_all', zone_get_all)
+        self.stubs.Set(nova.db, 'zone_update', zone_update)
+        self.stubs.Set(nova.db, 'zone_create', zone_create)
+        self.stubs.Set(nova.db, 'zone_delete', zone_delete)
+
+    def tearDown(self):
+        self.stubs.UnsetAll()
+        FLAGS.allow_admin_api = self.allow_admin
+
+    def test_get_zone_list(self):
+        req = webob.Request.blank('/v1.0/zones')
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+
+        self.assertEqual(res.status_int, 200)
+        self.assertEqual(len(res_dict['zones']), 2)
+
+    def test_get_zone_by_id(self):
+        req = webob.Request.blank('/v1.0/zones/1')
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+
+        self.assertEqual(res_dict['zone']['id'], 1)
+        self.assertEqual(res_dict['zone']['api_url'], 'http://foo.com')
+        self.assertFalse('password' in res_dict['zone'])
+        self.assertEqual(res.status_int, 200)
+
+    def test_zone_delete(self):
+        req = webob.Request.blank('/v1.0/zones/1')
+        res = req.get_response(fakes.wsgi_app())
+
+        self.assertEqual(res.status_int, 200)
+
+    def test_zone_create(self):
+        body = dict(zone=dict(api_url='http://blah.zoo', username='fred',
+                        password='fubar'))
+        req = webob.Request.blank('/v1.0/zones')
+        req.method = 'POST'
+        req.body = json.dumps(body)
+
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+
+        self.assertEqual(res.status_int, 200)
+        self.assertEqual(res_dict['zone']['id'], 1)
+        self.assertEqual(res_dict['zone']['api_url'], 'http://blah.zoo')
+        self.assertFalse('username' in res_dict['zone'])
+
+    def test_zone_update(self):
+        body = dict(zone=dict(username='zeb', password='sneaky'))
+        req = webob.Request.blank('/v1.0/zones/1')
+        req.method = 'PUT'
+        req.body = json.dumps(body)
+
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+
+        self.assertEqual(res.status_int, 200)
+        self.assertEqual(res_dict['zone']['id'], 1)
+        self.assertEqual(res_dict['zone']['api_url'], 'http://foo.com')
+        self.assertFalse('username' in res_dict['zone'])
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/nova/tests/test_compute.py b/nova/tests/test_compute.py
index 2aa0690e7..b049ac943 100644
--- a/nova/tests/test_compute.py
+++ b/nova/tests/test_compute.py
@@ -202,6 +202,14 @@ class ComputeTestCase(test.TestCase):
         self.compute.set_admin_password(self.context, instance_id)
         self.compute.terminate_instance(self.context, instance_id)
 
+    def test_inject_file(self):
+        """Ensure we can write a file to an instance"""
+        instance_id = self._create_instance()
+        self.compute.run_instance(self.context, instance_id)
+        self.compute.inject_file(self.context, instance_id, "/tmp/test",
+                "File Contents")
+        self.compute.terminate_instance(self.context, instance_id)
+
     def test_snapshot(self):
         """Ensure instance can be snapshotted"""
         instance_id = self._create_instance()
diff --git a/nova/tests/test_xenapi.py b/nova/tests/test_xenapi.py
index f8a3d72c4..66e578e3a 100644
--- a/nova/tests/test_xenapi.py
+++ b/nova/tests/test_xenapi.py
@@ -33,6 +33,7 @@ from nova.virt.xenapi import fake as xenapi_fake
 from nova.virt.xenapi import volume_utils
 from nova.virt.xenapi import vm_utils
 from nova.virt.xenapi.vmops import SimpleDH
+from nova.virt.xenapi.vmops import VMOps
 from nova.tests.db import fakes as db_fakes
 from nova.tests.xenapi import stubs
 from nova.tests.glance import stubs as glance_stubs
@@ -142,6 +143,10 @@ class XenAPIVolumeTestCase(test.TestCase):
         self.stubs.UnsetAll()
 
 
+def reset_network(*args):
+    pass
+
+
 class XenAPIVMTestCase(test.TestCase):
     """
     Unit tests for VM operations
@@ -164,6 +169,7 @@ class XenAPIVMTestCase(test.TestCase):
         stubs.stubout_get_this_vm_uuid(self.stubs)
         stubs.stubout_stream_disk(self.stubs)
         stubs.stubout_lookup_image(self.stubs)
+        self.stubs.Set(VMOps, 'reset_network', reset_network)
         glance_stubs.stubout_glance_client(self.stubs,
                                            glance_stubs.FakeGlance)
         self.conn = xenapi_conn.get_connection(False)