another trunk merge

7 files changed, 567 insertions, 19 deletions

diff --git a/nova/tests/api/openstack/test_images.py b/nova/tests/api/openstack/test_images.py
index 8e2e3f390..38495bbe7 100644
--- a/nova/tests/api/openstack/test_images.py
+++ b/nova/tests/api/openstack/test_images.py
@@ -1049,6 +1049,16 @@ class ImageControllerWithGlanceServiceTest(test.TestCase):
         response = req.get_response(fakes.wsgi_app())
         self.assertEqual(400, response.status_int)
 
+    def test_create_image_snapshots_disabled(self):
+        self.flags(allow_instance_snapshots=False)
+        body = dict(image=dict(serverId='123', name='Snapshot 1'))
+        req = webob.Request.blank('/v1.0/images')
+        req.method = 'POST'
+        req.body = json.dumps(body)
+        req.headers["content-type"] = "application/json"
+        response = req.get_response(fakes.wsgi_app())
+        self.assertEqual(400, response.status_int)
+
     @classmethod
     def _make_image_fixtures(cls):
         image_id = 123
diff --git a/nova/tests/api/openstack/test_server_actions.py b/nova/tests/api/openstack/test_server_actions.py
index 562cefe90..bf18bc1b0 100644
--- a/nova/tests/api/openstack/test_server_actions.py
+++ b/nova/tests/api/openstack/test_server_actions.py
@@ -458,6 +458,7 @@ class ServerActionsTestV11(test.TestCase):
         self.service.delete_all()
         self.sent_to_glance = {}
         fakes.stub_out_glance_add_image(self.stubs, self.sent_to_glance)
+        self.flags(allow_instance_snapshots=True)
 
     def tearDown(self):
         self.stubs.UnsetAll()
@@ -475,6 +476,21 @@ class ServerActionsTestV11(test.TestCase):
         self.assertEqual(mock_method.instance_id, '1')
         self.assertEqual(mock_method.password, '1234pass')
 
+    def test_server_change_password_xml(self):
+        mock_method = MockSetAdminPassword()
+        self.stubs.Set(nova.compute.api.API, 'set_admin_password', mock_method)
+        req = webob.Request.blank('/v1.1/servers/1/action')
+        req.method = 'POST'
+        req.content_type = "application/xml"
+        req.body = """<?xml version="1.0" encoding="UTF-8"?>
+                    <changePassword
+                        xmlns="http://docs.openstack.org/compute/api/v1.1"
+                        adminPass="1234pass"/>"""
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 202)
+        self.assertEqual(mock_method.instance_id, '1')
+        self.assertEqual(mock_method.password, '1234pass')
+
     def test_server_change_password_not_a_string(self):
         body = {'changePassword': {'adminPass': 1234}}
         req = webob.Request.blank('/v1.1/servers/1/action')
@@ -511,6 +527,42 @@ class ServerActionsTestV11(test.TestCase):
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 400)
 
+    def test_server_reboot_hard(self):
+        body = dict(reboot=dict(type="HARD"))
+        req = webob.Request.blank('/v1.1/servers/1/action')
+        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_reboot_soft(self):
+        body = dict(reboot=dict(type="SOFT"))
+        req = webob.Request.blank('/v1.1/servers/1/action')
+        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_reboot_incorrect_type(self):
+        body = dict(reboot=dict(type="NOT_A_TYPE"))
+        req = webob.Request.blank('/v1.1/servers/1/action')
+        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, 400)
+
+    def test_server_reboot_missing_type(self):
+        body = dict(reboot=dict())
+        req = webob.Request.blank('/v1.1/servers/1/action')
+        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, 400)
+
     def test_server_rebuild_accepted_minimum(self):
         body = {
             "rebuild": {
@@ -653,6 +705,62 @@ class ServerActionsTestV11(test.TestCase):
         self.assertEqual(res.status_int, 202)
         self.assertEqual(self.resize_called, True)
 
+    def test_resize_server_no_flavor(self):
+        req = webob.Request.blank('/v1.1/servers/1/action')
+        req.content_type = 'application/json'
+        req.method = 'POST'
+        body_dict = dict(resize=dict())
+        req.body = json.dumps(body_dict)
+
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 400)
+
+    def test_resize_server_no_flavor_ref(self):
+        req = webob.Request.blank('/v1.1/servers/1/action')
+        req.content_type = 'application/json'
+        req.method = 'POST'
+        body_dict = dict(resize=dict(flavorRef=None))
+        req.body = json.dumps(body_dict)
+
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 400)
+
+    def test_confirm_resize_server(self):
+        req = webob.Request.blank('/v1.1/servers/1/action')
+        req.content_type = 'application/json'
+        req.method = 'POST'
+        body_dict = dict(confirmResize=None)
+        req.body = json.dumps(body_dict)
+
+        self.confirm_resize_called = False
+
+        def cr_mock(*args):
+            self.confirm_resize_called = True
+
+        self.stubs.Set(nova.compute.api.API, 'confirm_resize', cr_mock)
+
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 204)
+        self.assertEqual(self.confirm_resize_called, True)
+
+    def test_revert_resize_server(self):
+        req = webob.Request.blank('/v1.1/servers/1/action')
+        req.content_type = 'application/json'
+        req.method = 'POST'
+        body_dict = dict(revertResize=None)
+        req.body = json.dumps(body_dict)
+
+        self.revert_resize_called = False
+
+        def revert_mock(*args):
+            self.revert_resize_called = True
+
+        self.stubs.Set(nova.compute.api.API, 'revert_resize', revert_mock)
+
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 202)
+        self.assertEqual(self.revert_resize_called, True)
+
     def test_create_image(self):
         body = {
             'createImage': {
@@ -668,6 +776,23 @@ class ServerActionsTestV11(test.TestCase):
         location = response.headers['Location']
         self.assertEqual('http://localhost/v1.1/images/123', location)
 
+    def test_create_image_snapshots_disabled(self):
+        """Don't permit a snapshot if the allow_instance_snapshots flag is
+        False
+        """
+        self.flags(allow_instance_snapshots=False)
+        body = {
+            'createImage': {
+                'name': 'Snapshot 1',
+            },
+        }
+        req = webob.Request.blank('/v1.1/servers/1/action')
+        req.method = 'POST'
+        req.body = json.dumps(body)
+        req.headers["content-type"] = "application/json"
+        response = req.get_response(fakes.wsgi_app())
+        self.assertEqual(400, response.status_int)
+
     def test_create_image_with_metadata(self):
         body = {
             'createImage': {
@@ -730,10 +855,10 @@ class ServerActionsTestV11(test.TestCase):
         self.assertTrue(response.headers['Location'])
 
 
-class TestServerActionXMLDeserializer(test.TestCase):
+class TestServerActionXMLDeserializerV11(test.TestCase):
 
     def setUp(self):
-        self.deserializer = create_instance_helper.ServerXMLDeserializer()
+        self.deserializer = create_instance_helper.ServerXMLDeserializerV11()
 
     def tearDown(self):
         pass
@@ -746,7 +871,6 @@ class TestServerActionXMLDeserializer(test.TestCase):
         expected = {
             "createImage": {
                 "name": "new-server-test",
-                "metadata": {},
             },
         }
         self.assertEquals(request['body'], expected)
@@ -767,3 +891,147 @@ class TestServerActionXMLDeserializer(test.TestCase):
             },
         }
         self.assertEquals(request['body'], expected)
+
+    def test_change_pass(self):
+        serial_request = """<?xml version="1.0" encoding="UTF-8"?>
+                <changePassword
+                    xmlns="http://docs.openstack.org/compute/api/v1.1"
+                    adminPass="1234pass"/> """
+        request = self.deserializer.deserialize(serial_request, 'action')
+        expected = {
+            "changePassword": {
+                "adminPass": "1234pass",
+            },
+        }
+        self.assertEquals(request['body'], expected)
+
+    def test_change_pass_no_pass(self):
+        serial_request = """<?xml version="1.0" encoding="UTF-8"?>
+                <changePassword
+                    xmlns="http://docs.openstack.org/compute/api/v1.1"/> """
+        self.assertRaises(AttributeError,
+                          self.deserializer.deserialize,
+                          serial_request,
+                          'action')
+
+    def test_reboot(self):
+        serial_request = """<?xml version="1.0" encoding="UTF-8"?>
+                <reboot
+                    xmlns="http://docs.openstack.org/compute/api/v1.1"
+                    type="HARD"/>"""
+        request = self.deserializer.deserialize(serial_request, 'action')
+        expected = {
+            "reboot": {
+                "type": "HARD",
+            },
+        }
+        self.assertEquals(request['body'], expected)
+
+    def test_reboot_no_type(self):
+        serial_request = """<?xml version="1.0" encoding="UTF-8"?>
+                <reboot
+                    xmlns="http://docs.openstack.org/compute/api/v1.1"/>"""
+        self.assertRaises(AttributeError,
+                          self.deserializer.deserialize,
+                          serial_request,
+                          'action')
+
+    def test_resize(self):
+        serial_request = """<?xml version="1.0" encoding="UTF-8"?>
+                <resize
+                    xmlns="http://docs.openstack.org/compute/api/v1.1"
+                    flavorRef="http://localhost/flavors/3"/>"""
+        request = self.deserializer.deserialize(serial_request, 'action')
+        expected = {
+            "resize": {
+                "flavorRef": "http://localhost/flavors/3"
+            },
+        }
+        self.assertEquals(request['body'], expected)
+
+    def test_resize_no_flavor_ref(self):
+        serial_request = """<?xml version="1.0" encoding="UTF-8"?>
+                <resize
+                    xmlns="http://docs.openstack.org/compute/api/v1.1"/>"""
+        self.assertRaises(AttributeError,
+                          self.deserializer.deserialize,
+                          serial_request,
+                          'action')
+
+    def test_confirm_resize(self):
+        serial_request = """<?xml version="1.0" encoding="UTF-8"?>
+                <confirmResize
+                    xmlns="http://docs.openstack.org/compute/api/v1.1"/>"""
+        request = self.deserializer.deserialize(serial_request, 'action')
+        expected = {
+            "confirmResize": None,
+        }
+        self.assertEquals(request['body'], expected)
+
+    def test_revert_resize(self):
+        serial_request = """<?xml version="1.0" encoding="UTF-8"?>
+                <revertResize
+                   xmlns="http://docs.openstack.org/compute/api/v1.1"/>"""
+        request = self.deserializer.deserialize(serial_request, 'action')
+        expected = {
+            "revertResize": None,
+        }
+        self.assertEquals(request['body'], expected)
+
+    def test_rebuild(self):
+        serial_request = """<?xml version="1.0" encoding="UTF-8"?>
+                <rebuild
+                    xmlns="http://docs.openstack.org/compute/api/v1.1"
+                    name="new-server-test"
+                    imageRef="http://localhost/images/1">
+                    <metadata>
+                        <meta key="My Server Name">Apache1</meta>
+                    </metadata>
+                    <personality>
+                        <file path="/etc/banner.txt">Mg==</file>
+                    </personality>
+                </rebuild>"""
+        request = self.deserializer.deserialize(serial_request, 'action')
+        expected = {
+            "rebuild": {
+                "name": "new-server-test",
+                "imageRef": "http://localhost/images/1",
+                "metadata": {
+                    "My Server Name": "Apache1",
+                },
+                "personality": [
+                    {"path": "/etc/banner.txt", "contents": "Mg=="},
+                ],
+            },
+        }
+        self.assertDictMatch(request['body'], expected)
+
+    def test_rebuild_minimum(self):
+        serial_request = """<?xml version="1.0" encoding="UTF-8"?>
+                <rebuild
+                    xmlns="http://docs.openstack.org/compute/api/v1.1"
+                    imageRef="http://localhost/images/1"/>"""
+        request = self.deserializer.deserialize(serial_request, 'action')
+        expected = {
+            "rebuild": {
+                "imageRef": "http://localhost/images/1",
+            },
+        }
+        self.assertDictMatch(request['body'], expected)
+
+    def test_rebuild_no_imageRef(self):
+        serial_request = """<?xml version="1.0" encoding="UTF-8"?>
+                <rebuild
+                    xmlns="http://docs.openstack.org/compute/api/v1.1"
+                    name="new-server-test">
+                    <metadata>
+                        <meta key="My Server Name">Apache1</meta>
+                    </metadata>
+                    <personality>
+                        <file path="/etc/banner.txt">Mg==</file>
+                    </personality>
+                </rebuild>"""
+        self.assertRaises(AttributeError,
+                          self.deserializer.deserialize,
+                          serial_request,
+                          'action')
diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index 0477f6d92..fd06b2e64 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -2177,7 +2177,7 @@ class TestServerCreateRequestXMLDeserializerV11(test.TestCase):
 
     def setUp(self):
         super(TestServerCreateRequestXMLDeserializerV11, self).setUp()
-        self.deserializer = create_instance_helper.ServerXMLDeserializer()
+        self.deserializer = create_instance_helper.ServerXMLDeserializerV11()
 
     def test_minimal_request(self):
         serial_request = """
@@ -2191,8 +2191,6 @@ class TestServerCreateRequestXMLDeserializerV11(test.TestCase):
                 "name": "new-server-test",
                 "imageRef": "1",
                 "flavorRef": "2",
-                "metadata": {},
-                "personality": [],
             },
         }
         self.assertEquals(request['body'], expected)
@@ -2211,8 +2209,6 @@ class TestServerCreateRequestXMLDeserializerV11(test.TestCase):
                 "imageRef": "1",
                 "flavorRef": "2",
                 "adminPass": "1234",
-                "metadata": {},
-                "personality": [],
             },
         }
         self.assertEquals(request['body'], expected)
@@ -2229,8 +2225,6 @@ class TestServerCreateRequestXMLDeserializerV11(test.TestCase):
                 "name": "new-server-test",
                 "imageRef": "http://localhost:8774/v1.1/images/2",
                 "flavorRef": "3",
-                "metadata": {},
-                "personality": [],
             },
         }
         self.assertEquals(request['body'], expected)
@@ -2247,8 +2241,6 @@ class TestServerCreateRequestXMLDeserializerV11(test.TestCase):
                 "name": "new-server-test",
                 "imageRef": "1",
                 "flavorRef": "http://localhost:8774/v1.1/flavors/3",
-                "metadata": {},
-                "personality": [],
             },
         }
         self.assertEquals(request['body'], expected)
@@ -2292,7 +2284,6 @@ class TestServerCreateRequestXMLDeserializerV11(test.TestCase):
                 "imageRef": "1",
                 "flavorRef": "2",
                 "metadata": {"one": "two", "open": "snack"},
-                "personality": [],
             },
         }
         self.assertEquals(request['body'], expected)
@@ -2314,7 +2305,6 @@ class TestServerCreateRequestXMLDeserializerV11(test.TestCase):
                 "name": "new-server-test",
                 "imageRef": "1",
                 "flavorRef": "2",
-                "metadata": {},
                 "personality": [
                     {"path": "/etc/banner.txt", "contents": "MQ=="},
                     {"path": "/etc/hosts", "contents": "Mg=="},
diff --git a/nova/tests/scheduler/test_zone_aware_scheduler.py b/nova/tests/scheduler/test_zone_aware_scheduler.py
index 7833028c3..788efca52 100644
--- a/nova/tests/scheduler/test_zone_aware_scheduler.py
+++ b/nova/tests/scheduler/test_zone_aware_scheduler.py
@@ -21,7 +21,9 @@ import json
 import nova.db
 
 from nova import exception
+from nova import rpc
 from nova import test
+from nova.compute import api as compute_api
 from nova.scheduler import driver
 from nova.scheduler import zone_aware_scheduler
 from nova.scheduler import zone_manager
@@ -114,7 +116,7 @@ def fake_provision_resource_from_blob(context, item, instance_id,
 
 
 def fake_decrypt_blob_returns_local_info(blob):
-    return {'foo': True}  # values aren't important.
+    return {'hostname': 'foooooo'}  # values aren't important.
 
 
 def fake_decrypt_blob_returns_child_info(blob):
@@ -283,14 +285,29 @@ class ZoneAwareSchedulerTestCase(test.TestCase):
         global was_called
         sched = FakeZoneAwareScheduler()
         was_called = False
+
+        def fake_create_db_entry_for_new_instance(self, context,
+                image, base_options, security_group,
+                block_device_mapping, num=1):
+            global was_called
+            was_called = True
+            # return fake instances
+            return {'id': 1, 'uuid': 'f874093c-7b17-49c0-89c3-22a5348497f9'}
+
+        def fake_rpc_cast(*args, **kwargs):
+            pass
+
         self.stubs.Set(sched, '_decrypt_blob',
                        fake_decrypt_blob_returns_local_info)
-        self.stubs.Set(sched, '_provision_resource_locally',
-                       fake_provision_resource_locally)
+        self.stubs.Set(compute_api.API,
+                'create_db_entry_for_new_instance',
+                fake_create_db_entry_for_new_instance)
+        self.stubs.Set(rpc, 'cast', fake_rpc_cast)
 
-        request_spec = {'blob': "Non-None blob data"}
+        build_plan_item = {'blob': "Non-None blob data"}
+        request_spec = {'image': {}, 'instance_properties': {}}
 
-        sched._provision_resource_from_blob(None, request_spec, 1,
+        sched._provision_resource_from_blob(None, build_plan_item, 1,
                                             request_spec, {})
         self.assertTrue(was_called)
 
diff --git a/nova/tests/test_image.py b/nova/tests/test_image.py
new file mode 100644
index 000000000..9680d6f2b
--- /dev/null
+++ b/nova/tests/test_image.py
@@ -0,0 +1,134 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+#    Copyright 2011 OpenStack LLC
+#    Author: Soren Hansen
+#
+#    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 datetime
+
+from nova import context
+from nova import exception
+from nova import test
+import nova.image
+
+
+class _ImageTestCase(test.TestCase):
+    def setUp(self):
+        super(_ImageTestCase, self).setUp()
+        self.context = context.get_admin_context()
+
+    def test_index(self):
+        res = self.image_service.index(self.context)
+        for image in res:
+            self.assertEquals(set(image.keys()), set(['id', 'name']))
+
+    def test_detail(self):
+        res = self.image_service.detail(self.context)
+        for image in res:
+            keys = set(image.keys())
+            self.assertEquals(keys, set(['id', 'name', 'created_at',
+                                         'updated_at', 'deleted_at', 'deleted',
+                                         'status', 'is_public', 'properties']))
+            self.assertTrue(isinstance(image['created_at'], datetime.datetime))
+            self.assertTrue(isinstance(image['updated_at'], datetime.datetime))
+
+            if not (isinstance(image['deleted_at'], datetime.datetime) or
+                                      image['deleted_at'] is None):
+                self.fail('image\'s "deleted_at" attribute was neither a '
+                          'datetime object nor None')
+
+            def check_is_bool(image, key):
+                val = image.get('deleted')
+                if not isinstance(val, bool):
+                    self.fail('image\'s "%s" attribute wasn\'t '
+                              'a bool: %r' % (key, val))
+
+            check_is_bool(image, 'deleted')
+            check_is_bool(image, 'is_public')
+
+    def test_index_and_detail_have_same_results(self):
+        index = self.image_service.index(self.context)
+        detail = self.image_service.detail(self.context)
+        index_set = set([(i['id'], i['name']) for i in index])
+        detail_set = set([(i['id'], i['name']) for i in detail])
+        self.assertEqual(index_set, detail_set)
+
+    def test_show_raises_imagenotfound_for_invalid_id(self):
+        self.assertRaises(exception.ImageNotFound,
+                          self.image_service.show,
+                          self.context,
+                          'this image does not exist')
+
+    def test_show_by_name(self):
+        self.assertRaises(exception.ImageNotFound,
+                          self.image_service.show_by_name,
+                          self.context,
+                          'this image does not exist')
+
+    def test_create_adds_id(self):
+        index = self.image_service.index(self.context)
+        image_count = len(index)
+
+        self.image_service.create(self.context, {})
+
+        index = self.image_service.index(self.context)
+        self.assertEquals(len(index), image_count + 1)
+
+        self.assertTrue(index[0]['id'])
+
+    def test_create_keeps_id(self):
+        self.image_service.create(self.context, {'id': '34'})
+        self.image_service.show(self.context, '34')
+
+    def test_create_rejects_duplicate_ids(self):
+        self.image_service.create(self.context, {'id': '34'})
+        self.assertRaises(exception.Duplicate,
+                          self.image_service.create,
+                          self.context,
+                          {'id': '34'})
+
+        # Make sure there's still one left
+        self.image_service.show(self.context, '34')
+
+    def test_update(self):
+        self.image_service.create(self.context,
+                                  {'id': '34', 'foo': 'bar'})
+
+        self.image_service.update(self.context, '34',
+                                  {'id': '34', 'foo': 'baz'})
+
+        img = self.image_service.show(self.context, '34')
+        self.assertEquals(img['foo'], 'baz')
+
+    def test_delete(self):
+        self.image_service.create(self.context, {'id': '34', 'foo': 'bar'})
+        self.image_service.delete(self.context, '34')
+        self.assertRaises(exception.NotFound,
+                          self.image_service.show,
+                          self.context,
+                          '34')
+
+    def test_delete_all(self):
+        self.image_service.create(self.context, {'id': '32', 'foo': 'bar'})
+        self.image_service.create(self.context, {'id': '33', 'foo': 'bar'})
+        self.image_service.create(self.context, {'id': '34', 'foo': 'bar'})
+        self.image_service.delete_all()
+        index = self.image_service.index(self.context)
+        self.assertEquals(len(index), 0)
+
+
+class FakeImageTestCase(_ImageTestCase):
+    def setUp(self):
+        super(FakeImageTestCase, self).setUp()
+        self.image_service = nova.image.fake.FakeImageService()
diff --git a/nova/tests/test_nova_manage.py b/nova/tests/test_nova_manage.py
new file mode 100644
index 000000000..9c6563f14
--- /dev/null
+++ b/nova/tests/test_nova_manage.py
@@ -0,0 +1,82 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+#    Copyright 2011 OpenStack LLC
+#    Copyright 2011 Ilya Alekseyev
+#
+#    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 os
+import sys
+
+TOPDIR = os.path.normpath(os.path.join(
+                            os.path.dirname(os.path.abspath(__file__)),
+                            os.pardir,
+                            os.pardir))
+NOVA_MANAGE_PATH = os.path.join(TOPDIR, 'bin', 'nova-manage')
+
+sys.dont_write_bytecode = True
+import imp
+nova_manage = imp.load_source('nova_manage.py', NOVA_MANAGE_PATH)
+sys.dont_write_bytecode = False
+
+import netaddr
+from nova import context
+from nova import db
+from nova import flags
+from nova import test
+
+FLAGS = flags.FLAGS
+
+
+class FixedIpCommandsTestCase(test.TestCase):
+    def setUp(self):
+        super(FixedIpCommandsTestCase, self).setUp()
+        cidr = '10.0.0.0/24'
+        net = netaddr.IPNetwork(cidr)
+        net_info = {'bridge': 'fakebr',
+               'bridge_interface': 'fakeeth',
+               'dns': FLAGS.flat_network_dns,
+               'cidr': cidr,
+               'netmask': str(net.netmask),
+               'gateway': str(net[1]),
+               'broadcast': str(net.broadcast),
+               'dhcp_start': str(net[2])}
+        self.network = db.network_create_safe(context.get_admin_context(),
+                                              net_info)
+        num_ips = len(net)
+        for index in range(num_ips):
+            address = str(net[index])
+            reserved = (index == 1 or index == 2)
+            db.fixed_ip_create(context.get_admin_context(),
+                               {'network_id': self.network['id'],
+                                'address': address,
+                                'reserved': reserved})
+        self.commands = nova_manage.FixedIpCommands()
+
+    def tearDown(self):
+        db.network_delete_safe(context.get_admin_context(), self.network['id'])
+        super(FixedIpCommandsTestCase, self).tearDown()
+
+    def test_reserve(self):
+        self.commands.reserve('10.0.0.100')
+        address = db.fixed_ip_get_by_address(context.get_admin_context(),
+                                             '10.0.0.100')
+        self.assertEqual(address['reserved'], True)
+
+    def test_unreserve(self):
+        db.fixed_ip_update(context.get_admin_context(), '10.0.0.100',
+                           {'reserved': True})
+        self.commands.unreserve('10.0.0.100')
+        address = db.fixed_ip_get_by_address(context.get_admin_context(),
+                                             '10.0.0.100')
+        self.assertEqual(address['reserved'], False)
diff --git a/nova/tests/test_skip_examples.py b/nova/tests/test_skip_examples.py
new file mode 100644
index 000000000..8ca203442
--- /dev/null
+++ b/nova/tests/test_skip_examples.py
@@ -0,0 +1,47 @@
+# 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.
+#
+#    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.
+
+from nova import test
+
+
+class ExampleSkipTestCase(test.TestCase):
+    test_counter = 0
+
+    @test.skip_test("Example usage of @test.skip_test()")
+    def test_skip_test_example(self):
+        self.fail("skip_test failed to work properly.")
+
+    @test.skip_if(True, "Example usage of @test.skip_if()")
+    def test_skip_if_example(self):
+        self.fail("skip_if failed to work properly.")
+
+    @test.skip_unless(False, "Example usage of @test.skip_unless()")
+    def test_skip_unless_example(self):
+        self.fail("skip_unless failed to work properly.")
+
+    @test.skip_if(False, "This test case should never be skipped.")
+    def test_001_increase_test_counter(self):
+        ExampleSkipTestCase.test_counter += 1
+
+    @test.skip_unless(True, "This test case should never be skipped.")
+    def test_002_increase_test_counter(self):
+        ExampleSkipTestCase.test_counter += 1
+
+    def test_003_verify_test_counter(self):
+        self.assertEquals(ExampleSkipTestCase.test_counter, 2,
+                          "Tests were not skipped appropriately")