Initial Commit

test_repo/compute/functional/servers/__init__.py

@@ -0,0 +1,16 @@
+"""
+Copyright 2013 Rackspace
+
+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_repo/compute/functional/servers/actions/__init__.py

@@ -0,0 +1,16 @@
+"""
+Copyright 2013 Rackspace
+
+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_repo/compute/functional/servers/actions/test_change_password.py

@@ -0,0 +1,53 @@
+"""
+Copyright 2013 Rackspace
+
+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 cafe.drivers.unittest.decorators import tags
+from test_repo.compute.fixtures import CreateServerFixture
+
+
+class ChangeServerPasswordTests(CreateServerFixture):
+
+    @classmethod
+    def setUpClass(cls):
+        super(ChangeServerPasswordTests, cls).setUpClass()
+        cls.server = cls.server_response.entity
+        cls.new_password = "newslice129690TuG72Bgj2"
+
+        # Change password and wait for server to return to active state
+        cls.compute_provider.change_password_and_await(cls.server.id,
+                                                       cls.new_password)
+
+    @classmethod
+    def tearDownClass(cls):
+        super(ChangeServerPasswordTests, cls).tearDownClass()
+
+    @tags(type='smoke', net='yes')
+    def test_can_log_in_with_new_password(self):
+        '''Verify the admin user can log in with the new password'''
+
+        '''Get server details '''
+        response = self.servers_client.get_server(self.server.id)
+        self.server = response.entity
+        '''Set the server's adminPass attribute to the new password,vas this field is not set in getServer'''
+        self.server.adminPass = self.new_password
+
+        public_address = self.compute_provider.get_public_ip_address(self.server)
+        '''Get an instance of the remote client '''
+        remote_client = self.compute_provider.get_remote_instance_client(self.server, public_address)
+
+        self.assertTrue(remote_client.can_connect_to_public_ip(),
+                        "Could not connect to server (%s) using new admin password %s" %
+                        (public_address, self.new_password))

test_repo/compute/functional/servers/actions/test_reboot_server_hard.py

@@ -0,0 +1,50 @@
+"""
+Copyright 2013 Rackspace
+
+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 time
+
+from cafe.drivers.unittest.decorators import tags
+from cloudcafe.compute.common.types import NovaServerRebootTypes
+from test_repo.compute.fixtures import ComputeFixture
+
+
+class RebootServerHardTests(ComputeFixture):
+
+    @classmethod
+    def setUpClass(cls):
+        super(RebootServerHardTests, cls).setUpClass()
+        response = cls.compute_provider.create_active_server()
+        cls.server = response.entity
+        cls.resources.add(cls.server.id, cls.servers_client.delete_server)
+
+    @classmethod
+    def tearDownClass(cls):
+        super(RebootServerHardTests, cls).tearDownClass()
+
+    @tags(type='smoke', net='yes')
+    def test_reboot_server_hard(self):
+        """ The server should be power cycled """
+        public_address = self.compute_provider.get_public_ip_address(self.server)
+        remote_instance = self.compute_provider.get_remote_instance_client(self.server, public_address)
+        uptime_start = remote_instance.get_uptime()
+        start = time.time()
+
+        self.compute_provider.reboot_and_await(self.server.id, NovaServerRebootTypes.HARD)
+        remote_client = self.compute_provider.get_remote_instance_client(self.server, public_address)
+        finish = time.time()
+        uptime_post_reboot = remote_client.get_uptime()
+        self.assertLess(uptime_post_reboot, (uptime_start + (finish - start)))
+

test_repo/compute/functional/servers/actions/test_reboot_server_soft.py

@@ -0,0 +1,49 @@
+"""
+Copyright 2013 Rackspace
+
+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 time
+
+from cafe.drivers.unittest.decorators import tags
+from cloudcafe.compute.common.types import NovaServerRebootTypes
+from test_repo.compute.fixtures import ComputeFixture
+
+
+class RebootServerSoftTests(ComputeFixture):
+
+    @classmethod
+    def setUpClass(cls):
+        super(RebootServerSoftTests, cls).setUpClass()
+        response = cls.compute_provider.create_active_server()
+        cls.server = response.entity
+        cls.resources.add(cls.server.id, cls.servers_client.delete_server)
+
+    @classmethod
+    def tearDownClass(cls):
+        super(RebootServerSoftTests, cls).tearDownClass()
+
+    @tags(type='smoke', net='yes')
+    def test_reboot_server_soft(self):
+        """ The server should be signaled to reboot gracefully """
+        public_address = self.compute_provider.get_public_ip_address(self.server)
+        remote_instance = self.compute_provider.get_remote_instance_client(self.server, public_address)
+        uptime_start = remote_instance.get_uptime()
+        start = time.time()
+
+        self.compute_provider.reboot_and_await(self.server.id, NovaServerRebootTypes.SOFT)
+        remote_client = self.compute_provider.get_remote_instance_client(self.server, public_address)
+        finish = time.time()
+        uptime_post_reboot = remote_client.get_uptime()
+        self.assertLess(uptime_post_reboot, (uptime_start + (finish - start)))

test_repo/compute/functional/servers/actions/test_rebuild_server.py

@@ -0,0 +1,115 @@
+"""
+Copyright 2013 Rackspace
+
+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 base64
+import unittest2 as unittest
+
+from cafe.drivers.unittest.decorators import tags
+from cloudcafe.compute.common.types import NovaServerStatusTypes
+from cloudcafe.compute.common.datagen import rand_name
+from test_repo.compute.fixtures import ComputeFixture
+
+
+
+class RebuildServerTests(ComputeFixture):
+
+    @classmethod
+    def setUpClass(cls):
+        super(RebuildServerTests, cls).setUpClass()
+        response = cls.compute_provider.create_active_server()
+        cls.server = response.entity
+        response = cls.flavors_client.get_flavor_details(cls.flavor_ref)
+        cls.flavor = response.entity
+        cls.resources.add(cls.server.id, cls.servers_client.delete_server)
+        cls.metadata = {'key': 'value'}
+        cls.name = rand_name('testserver')
+        file_contents = 'Test server rebuild.'
+        personality = [{'path': '/etc/rebuild.txt',
+                        'contents': base64.b64encode(file_contents)}]
+        cls.password = 'rebuild'
+
+        rebuilt_server_response = cls.servers_client.rebuild(cls.server.id,
+                                                             cls.image_ref_alt,
+                                                             name=cls.name,
+                                                             metadata=cls.metadata,
+                                                             personality=personality,
+                                                             admin_pass=cls.password)
+        cls.rebuilt_server_response = cls.compute_provider.wait_for_server_status(cls.server.id,
+                                                                                  NovaServerStatusTypes.ACTIVE)
+
+    @classmethod
+    def tearDownClass(cls):
+        super(RebuildServerTests, cls).tearDownClass()
+
+    @tags(type='smoke', net='no')
+    def test_verify_rebuild_server_response(self):
+        #Verify the properties in the initial response are correct
+        rebuilt_server = self.rebuilt_server_response.entity
+
+        if rebuilt_server.addresses.public is not None:
+            v4_address = rebuilt_server.addresses.public.ipv4
+            v6_address = rebuilt_server.addresses.public.ipv6
+            self.assertEqual(v4_address, self.server.accessIPv4,
+                             msg="AccessIPv4 did not match")
+            self.assertEqual(v6_address, self.server.accessIPv6,
+                             msg="AccessIPv6 did not match")
+
+        self.assertEquals(rebuilt_server.tenant_id, self.config.compute_api.tenant_id,
+                          msg="Tenant id did not match")
+        self.assertEqual(rebuilt_server.name, self.name,
+                         msg="Server name did not match")
+        self.assertTrue(rebuilt_server.hostId is not None,
+                        msg="Host id was not set")
+        self.assertEqual(rebuilt_server.image.id, self.image_ref_alt,
+                         msg="Image id did not match")
+        self.assertEqual(rebuilt_server.flavor.id, self.flavor_ref,
+                         msg="Flavor id did not match")
+        self.assertEqual(rebuilt_server.id, self.server.id, msg="Server id did not match")
+
+        self.assertEqual(rebuilt_server.links.bookmark, self.server.links.bookmark, msg="Bookmark links do not match")
+        self.assertEqual(self.server.links.self, self.rebuilt_server_response['location'],
+                         msg="Location url did not match a valid link for the server")
+        self.assertEqual(rebuilt_server.metadata.key, 'value')
+        self.assertEqual(rebuilt_server.created, self.server.created,
+                         msg="Server Created date changed after rebuild")
+        self.assertTrue(rebuilt_server.updated != self.server.updated,
+                        msg="Server Updated date not changed after rebuild")
+        self.assertEquals(rebuilt_server.addresses, self.server.addresses,
+                          msg="Server IP addresses changed after rebuild")
+
+    @tags(type='positive', net='yes')
+    @unittest.skip('V1 Bug:I-04125')
+    def test_server_hostname_after_rebuild(self):
+        server = self.rebuilt_server_response.entity
+        rebuilt_server = self.rebuilt_server_response.entity
+        public_address = self.compute_provider.get_public_ip_address(rebuilt_server)
+        server.adminPass = self.password
+        remote_instance = self.compute_provider.get_remote_instance_client(server, public_address)
+
+        # Verify that the server hostname is set to the new server name
+        hostname = remote_instance.get_hostname()
+        self.assertEqual(hostname, server.name,
+                         msg="The hostname was not same as the server name after rebuild")
+
+    @tags(type='smoke', net='yes')
+    def test_can_log_into_server_after_rebuild(self):
+        server = self.rebuilt_server_response.entity
+        rebuilt_server = self.rebuilt_server_response.entity
+        public_address = self.compute_provider.get_public_ip_address(rebuilt_server)
+        server.adminPass = self.password
+        remote_instance = self.compute_provider.get_remote_instance_client(server, public_address)
+        self.assertTrue(remote_instance.can_connect_to_public_ip(),
+                        msg="Could not connect to server (%s) using new admin password %s" % (public_address, server.adminPass))

test_repo/compute/functional/servers/actions/test_rescue_server.py

@@ -0,0 +1,68 @@
+"""
+Copyright 2013 Rackspace
+
+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 cafe.drivers.unittest.decorators import tags
+from test_repo.compute.fixtures import ComputeFixture
+
+
+class ServerRescueTests(ComputeFixture):
+
+    @classmethod
+    def setUpClass(cls):
+        super(ServerRescueTests, cls).setUpClass()
+        server_response = cls.compute_provider.create_active_server()
+        cls.server = server_response.entity
+        cls.resources.add(cls.server.id, cls.servers_client.delete_server)
+        flavor_response = cls.flavors_client.get_flavor_details(cls.flavor_ref)
+        cls.flavor = flavor_response.entity
+
+    @classmethod
+    def tearDownClass(cls):
+        super(ServerRescueTests, cls).tearDownClass()
+
+    @tags(type='smoke', net='yes')
+    def test_rescue_and_unrescue_server_test(self):
+        """Verify that a server can enter and exit rescue mode"""
+        rescue_response = self.servers_client.rescue(self.server.id)
+        changed_password = rescue_response.entity.adminPass
+        self.assertTrue(rescue_response.status_code is 200,
+                        msg="The response code while rescuing a server is %s instead of 200" % rescue_response.status_code)
+        self.assertTrue(self.server.adminPass is not changed_password,
+                        msg="The password did not change after Rescue.")
+
+        #Enter rescue mode
+        rescue_server_response = self.compute_provider.wait_for_server_status(self.server.id, 'RESCUE')
+        rescue_server = rescue_server_response.entity
+        rescue_server.adminPass = changed_password
+
+        remote_client = self.compute_provider.get_remote_instance_client(rescue_server)
+
+        #Verify if hard drives are attached
+        remote_client = self.compute_provider.get_remote_instance_client(rescue_server)
+        partitions = remote_client.get_partition_details()
+        self.assertEqual(3, len(partitions))
+
+        #Exit rescue mode
+        unrescue_response = self.servers_client.unrescue(self.server.id)
+        self.assertTrue(unrescue_response.status_code == 202,
+                        msg="The response code while unrescuing a server is %s instead of 202" % rescue_response.status_code)
+
+        self.compute_provider.wait_for_server_status(self.server.id, 'ACTIVE')
+        remote_client = self.compute_provider.get_remote_instance_client(self.server)
+        partitions = remote_client.get_partition_details()
+        self.assertEqual(2, len(partitions), msg="The number of partitions after unrescue were not two.")
+        result, message = remote_client.verify_partitions(self.flavor.disk, self.flavor.swap, 'active', partitions)
+        self.assertTrue(result, msg=message)

test_repo/compute/functional/servers/actions/test_resize_server_confirm.py

@@ -0,0 +1,131 @@
+"""
+Copyright 2013 Rackspace
+
+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 cafe.drivers.unittest.decorators import tags
+from cloudcafe.compute.common.types import NovaServerStatusTypes
+from cloudcafe.compute.common.equality_tools import EqualityTools
+from test_repo.compute.fixtures import ComputeFixture
+
+
+class ResizeServerUpConfirmTests(ComputeFixture):
+
+    @classmethod
+    def setUpClass(cls):
+        super(ResizeServerUpConfirmTests, cls).setUpClass()
+        server_response = cls.compute_provider.create_active_server()
+        server_to_resize = server_response.entity
+        cls.resources.add(server_to_resize.id, cls.servers_client.delete_server)
+
+        # resize server and confirm
+        cls.servers_client.resize(server_to_resize.id, cls.flavor_ref_alt)
+        cls.compute_provider.wait_for_server_status(server_to_resize.id,
+                                                    NovaServerStatusTypes.VERIFY_RESIZE)
+
+        cls.servers_client.confirm_resize(server_to_resize.id)
+        cls.compute_provider.wait_for_server_status(server_to_resize.id,
+                                                    NovaServerStatusTypes.ACTIVE)
+        resized_server_response = cls.servers_client.get_server(server_to_resize.id)
+        cls.resized_server = resized_server_response.entity
+        cls.resized_server.adminPass = server_to_resize.adminPass
+
+    @classmethod
+    def tearDownClass(cls):
+        super(ResizeServerUpConfirmTests, cls).tearDownClass()
+
+    @tags(type='smoke', net='no')
+    def test_verify_confirm_resize_response(self):
+        pass
+
+    @tags(type='smoke', net='no')
+    def test_server_properties_after_resize(self):
+        self.assertEqual(self.flavor_ref_alt, self.resized_server.flavor.id)
+
+    @tags(type='smoke', net='yes')
+    def test_ram_and_disk_size_on_resize_up_server_confirm_test(self):
+        """
+        The server's RAM and disk space should be modified to that of
+        the provided flavor
+        """
+
+        new_flavor = self.flavors_client.get_flavor_details(self.flavor_ref_alt).entity
+        public_address = self.compute_provider.get_public_ip_address(self.resized_server)
+
+        remote_instance = self.compute_provider.get_remote_instance_client(self.resized_server, public_address)
+
+        lower_limit = int(new_flavor.ram) - (int(new_flavor.ram) * .1)
+        server_ram_size = int(remote_instance.get_ram_size_in_mb())
+        server_swap_size = int(remote_instance.get_swap_size_in_mb())
+        self.assertTrue(int(new_flavor.ram) == server_ram_size or lower_limit <= server_ram_size,
+                        msg="Ram size after confirm-resize did not match. Expected ram size : %s, Actual ram size : %s" % (new_flavor.ram, server_ram_size))
+        self.assertEquals(int(new_flavor.swap), server_swap_size,
+                          msg="Swap size after confirm-resize did not match. Expected swap size : %s, Actual swap size : %s" % (new_flavor.swap, server_swap_size))
+        self.assertTrue(EqualityTools.are_sizes_equal(new_flavor.disk, remote_instance.get_disk_size_in_gb(), 0.5),
+                        msg="Disk size %s after confirm-resize did not match size %s" % (remote_instance.get_disk_size_in_gb(), new_flavor.disk))
+
+
+class ResizeServerDownConfirmTests(ComputeFixture):
+
+    @classmethod
+    def setUpClass(cls):
+        super(ResizeServerDownConfirmTests, cls).setUpClass()
+        server_response = cls.compute_provider.create_active_server(flavor_ref=cls.flavor_ref_alt)
+        server_to_resize = server_response.entity
+        cls.resources.add(server_to_resize.id, cls.servers_client.delete_server)
+
+        # resize server and confirm
+        cls.servers_client.resize(server_to_resize.id, cls.flavor_ref)
+        cls.compute_provider.wait_for_server_status(server_to_resize.id,
+                                                    NovaServerStatusTypes.VERIFY_RESIZE)
+
+        cls.servers_client.confirm_resize(server_to_resize.id)
+        cls.compute_provider.wait_for_server_status(server_to_resize.id,
+                                                    NovaServerStatusTypes.ACTIVE)
+        resized_server_response = cls.servers_client.get_server(server_to_resize.id)
+        cls.resized_server = resized_server_response.entity
+        cls.resized_server.adminPass = server_to_resize.adminPass
+
+    @classmethod
+    def tearDownClass(cls):
+        super(ResizeServerDownConfirmTests, cls).tearDownClass()
+
+    @tags(type='smoke', net='no')
+    def test_verify_confirm_resize_response(self):
+        pass
+
+    @tags(type='smoke', net='no')
+    def test_server_properties_after_resize(self):
+        self.assertEqual(self.flavor_ref, self.resized_server.flavor.id)
+
+    @tags(type='smoke', net='yes')
+    def test_ram_and_disk_size_on_resize_up_server_confirm_test(self):
+        """
+        The server's RAM and disk space should be modified to that of
+        the provided flavor
+        """
+
+        new_flavor = self.flavors_client.get_flavor_details(self.flavor_ref).entity
+        public_address = self.compute_provider.get_public_ip_address(self.resized_server)
+        remote_instance = self.compute_provider.get_remote_instance_client(self.resized_server, public_address)
+
+        lower_limit = int(new_flavor.ram) - (int(new_flavor.ram) * .1)
+        server_ram_size = int(remote_instance.get_ram_size_in_mb())
+        server_swap_size = int(remote_instance.get_swap_size_in_mb())
+        self.assertTrue(int(new_flavor.ram) == server_ram_size or lower_limit <= server_ram_size,
+                        msg="Ram size after confirm-resize did not match. Expected ram size : %s, Actual ram size : %s" % (new_flavor.ram, server_ram_size))
+        self.assertEquals(int(new_flavor.swap), server_swap_size,
+                          msg="Swap size after confirm-resize did not match. Expected swap size: %s, Actual swap size: %s" % (new_flavor.swap, server_swap_size))
+        self.assertTrue(EqualityTools.are_sizes_equal(new_flavor.disk, remote_instance.get_disk_size_in_gb(), 0.5),
+                        msg="Disk size %s after confirm-resize did not match size %s" % (remote_instance.get_disk_size_in_gb(), new_flavor.disk))

test_repo/compute/functional/servers/actions/test_resize_server_revert.py

@@ -0,0 +1,101 @@
+"""
+Copyright 2013 Rackspace
+
+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 cafe.drivers.unittest.decorators import tags
+from cloudcafe.compute.common.types import NovaServerStatusTypes
+from cloudcafe.compute.common.datagen import rand_name
+from cloudcafe.compute.common.equality_tools import EqualityTools
+from test_repo.compute.fixtures import ComputeFixture
+
+
+class ResizeServerUpRevertTests(ComputeFixture):
+
+    @classmethod
+    def setUpClass(cls):
+        super(ResizeServerUpRevertTests, cls).setUpClass()
+        response = cls.compute_provider.create_active_server()
+        cls.server = response.entity
+        cls.remote_instance = cls.compute_provider.get_remote_instance_client(cls.server)
+        file_name = rand_name('file') + '.txt'
+        file_content = 'This is a test file'
+        cls.file_details = cls. remote_instance.create_file(file_name, file_content)
+        response = cls.flavors_client.get_flavor_details(cls.flavor_ref)
+        cls.flavor = response.entity
+        cls.resources.add(cls.server.id, cls.servers_client.delete_server)
+
+    @classmethod
+    def tearDownClass(cls):
+        super(ResizeServerUpRevertTests, cls).tearDownClass()
+
+    @tags(type='smoke', net='yes')
+    def test_ram_and_disk_size_on_resize_up_server_revert(self):
+        """
+        The server's RAM and disk space should return to its original
+        values after a resize is reverted
+        """
+        server_response = self.compute_provider.create_active_server()
+        server_to_resize = server_response.entity
+        self.resources.add(server_to_resize.id, self.servers_client.delete_server)
+        remote_instance = self.compute_provider.get_remote_instance_client(server_to_resize)
+        file_name = rand_name('file') + '.txt'
+        file_content = 'This is a test file'
+        file_details = remote_instance.create_file(file_name, file_content)
+
+        #resize server and revert
+        self.servers_client.resize(server_to_resize.id, self.flavor_ref_alt)
+        self.compute_provider.wait_for_server_status(server_to_resize.id, NovaServerStatusTypes.VERIFY_RESIZE)
+
+        self.servers_client.revert_resize(server_to_resize.id)
+        reverted_server_response = self.compute_provider.wait_for_server_status(server_to_resize.id, NovaServerStatusTypes.ACTIVE)
+        reverted_server = reverted_server_response.entity
+        flavor_response = self.flavors_client.get_flavor_details(self.flavor_ref)
+        flavor = flavor_response.entity
+
+        '''Verify that the server resize was reverted '''
+        public_address = self.compute_provider.get_public_ip_address(reverted_server)
+        reverted_server.adminPass = server_to_resize.adminPass
+        remote_instance = self.compute_provider.get_remote_instance_client(reverted_server, public_address)
+        actual_file_content = remote_instance.get_file_details(file_details.name)
+
+        '''Verify that the file content does not change after resize revert'''
+        self.assertEqual(actual_file_content, file_details, msg="file changed after resize revert")
+
+        self.assertEqual(self.flavor_ref, reverted_server.flavor.id,
+                         msg="Flavor id not reverted")
+        lower_limit = int(flavor.ram) - (int(flavor.ram) * .1)
+        server_ram_size = int(remote_instance.get_ram_size_in_mb())
+        self.assertTrue(int(flavor.ram) == server_ram_size or lower_limit <= server_ram_size,
+                        msg="Ram size after revert did not match.Expected ram size : %s, Actual ram size : %s" % (flavor.ram, server_ram_size))
+
+        self.assertTrue(EqualityTools.are_sizes_equal(flavor.disk, remote_instance.get_disk_size_in_gb(), 0.5),
+                        msg="Disk size %s after revert did not match %s" % (remote_instance.get_disk_size_in_gb(), flavor.disk))
+
+    def _assert_server_details(self, server, expected_name, expected_accessIPv4, expected_accessIPv6, expected_id, expected_image_ref):
+        self.assertEqual(expected_accessIPv4, server.accessIPv4,
+                         msg="AccessIPv4 did not match")
+        self.assertEqual(expected_accessIPv6, server.accessIPv6,
+                         msg="AccessIPv6 did not match")
+        self.assertEquals(self.config.nova.tenant_id, server.tenant_id,
+                          msg="Tenant id did not match")
+        self.assertEqual(expected_name, server.name,
+                         msg="Server name did not match")
+        self.assertTrue(server.host_id is not None,
+                        msg="Host id was not set")
+        self.assertEqual(expected_image_ref, server.image.id,
+                         msg="Image id did not match")
+        self.assertEqual(self.flavor_ref, server.flavor.id,
+                         msg="Flavor id did not match")
+        self.assertEqual(expected_id, server.id, msg="Server id did not match")

test_repo/compute/functional/servers/test_create_server.py

@@ -0,0 +1,96 @@
+"""
+Copyright 2013 Rackspace
+
+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 base64
+
+from cafe.drivers.unittest.decorators import tags
+from cloudcafe.compute.common.types import NovaServerStatusTypes
+from cloudcafe.compute.common.datagen import rand_name
+from test_repo.compute.fixtures import ComputeFixture
+from cafe.engine.clients.remote_instance.instance_client import InstanceClientFactory
+
+
+class CreateServerTest(ComputeFixture):
+
+    @classmethod
+    def setUpClass(cls):
+        super(CreateServerTest, cls).setUpClass()
+        cls.name = rand_name("cctestserver")
+        cls.metadata = {'meta_key_1': 'meta_value_1',
+                        'meta_key_2': 'meta_value_2'}
+        cls.create_resp = cls.servers_client.create_server(cls.name, cls.image_ref, cls.flavor_ref,
+                                                           metadata=cls.metadata)
+        created_server = cls.create_resp.entity
+        wait_response = cls.server_behaviors.wait_for_server_status(created_server.id,
+                                                                    NovaServerStatusTypes.ACTIVE)
+        wait_response.entity.admin_pass = created_server.admin_pass
+        cls.image = cls.images_client.get_image(cls.image_ref).entity
+        cls.flavor = cls.flavors_client.get_flavor_details(cls.flavor_ref).entity
+        cls.server = wait_response.entity
+
+    @classmethod
+    def tearDownClass(cls):
+        super(CreateServerTest, cls).tearDownClass()
+
+    @tags(type='smoke', net='no')
+    def test_create_server_response(self):
+        """Verify the parameters are correct in the initial response"""
+
+        self.assertTrue(self.server.id is not None,
+                        msg="Server id was not set in the response")
+        self.assertTrue(self.server.admin_pass is not None,
+                        msg="Admin password was not set in the response")
+        self.assertTrue(self.server.links is not None,
+                        msg="Server links were not set in the response")
+
+    @tags(type='smoke', net='no')
+    def test_created_server_fields(self):
+        """Verify that a created server has all expected fields"""
+        message = "Expected {0} to be {1}, was {2}."
+
+        self.assertEqual(self.server.name, self.name,
+                         msg=message.format('server name', self.server.name,
+                                            self.name))
+        self.assertEqual(self.image_ref, self.server.image.id,
+                         msg=message.format('image id', self.image_ref,
+                                            self.server.image.id))
+        self.assertEqual(self.server.flavor.id, self.flavor_ref,
+                         msg=message.format('flavor id', self.flavor_ref,
+                                            self.server.flavor.id))
+        self.assertTrue(self.server.created is not None,
+                        msg="Expected server created date to be set, was null.")
+        self.assertTrue(self.server.updated is not None,
+                        msg="Expected server updated date to be set, was null.")
+        self.assertGreaterEqual(self.server.updated, self.server.created,
+                                msg="Expected server updated date to be before the created date.")
+
+    @tags(type='smoke', net='no')
+    def test_server_access_addresses(self):
+        """If the server has public addresses, the access IP addresses should be same as the public addresses"""
+        addresses = self.server.addresses
+        if addresses.public is not None:
+            self.assertTrue(addresses.public.ipv4 is not None,
+                            msg="Expected server to have a public IPv4 address set.")
+            self.assertTrue(addresses.public.ipv6 is not None,
+                            msg="Expected server to have a public IPv6 address set.")
+            self.assertTrue(addresses.private.ipv4 is not None,
+                            msg="Expected server to have a private IPv4 address set.")
+            self.assertEqual(addresses.public.ipv4, self.server.accessIPv4,
+                             msg="Expected access IPv4 address to be {0}, was {1}.".format(
+                                 addresses.public.ipv4, self.server.accessIPv4))
+            self.assertEqual(addresses.public.ipv6, self.server.accessIPv6,
+                             msg="Expected access IPv6 address to be {0}, was {1}.".format(
+                                 addresses.public.ipv6, self.server.accessIPv6))

test_repo/compute/functional/servers/test_list_servers.py

@@ -0,0 +1,282 @@
+"""
+Copyright 2013 Rackspace
+
+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 cafe.drivers.unittest.decorators import tags
+from test_repo.compute.fixtures import ComputeFixture
+
+
+class ServerListTest(ComputeFixture):
+
+    @classmethod
+    def setUpClass(cls):
+        super(ServerListTest, cls).setUpClass()
+        # Creation of 3 servers needed for the tests
+        active_server_response = cls.server_behaviors.create_active_server()
+        cls.server = active_server_response.entity
+        active_server_response = cls.server_behaviors.create_active_server()
+        cls.server_second = active_server_response.entity
+        active_server_response = cls.server_behaviors.create_active_server(
+            image_ref=cls.image_ref_alt,
+            flavor_ref=cls.flavor_ref_alt)
+
+        cls.server_third = active_server_response.entity
+        cls.resources.add(cls.server.id,
+                          cls.servers_client.delete_server)
+        cls.resources.add(cls.server_second.id,
+                          cls.servers_client.delete_server)
+        cls.resources.add(cls.server_third.id,
+                          cls.servers_client.delete_server)
+
+    @classmethod
+    def tearDownClass(cls):
+        super(ServerListTest, cls).tearDownClass()
+
+    @tags(type='smoke', net='no')
+    def test_get_server(self):
+        """Return the full details of a single server"""
+        server_info_response = self.servers_client.get_server(self.server.id)
+        server_info = server_info_response.entity
+        self.assertEqual(200, server_info_response.status_code)
+        self.assertEqual(self.server.name, server_info.name,
+                         msg="Server name did not match")
+        self.assertEqual(self.image_ref, server_info.image.id,
+                         msg="Image id did not match")
+        self.assertEqual(self.flavor_ref, server_info.flavor.id,
+                         msg="Flavor id did not match")
+
+    @tags(type='smoke', net='no')
+    def test_list_servers(self):
+        """All servers should be returned"""
+        list_servers_response = self.servers_client.list_servers()
+        list_servers = list_servers_response.entity
+        self.assertEqual(200, list_servers_response.status_code)
+        self.assertTrue(self.server.min_details() in
+                        list_servers, msg="Server with id %s was not found in the list" % self.server.id)
+        self.assertTrue(self.server_second.min_details() in
+                        list_servers, msg="Server with id %s was not found in the list" % self.server_second.id)
+        self.assertTrue(self.server_third.min_details() in
+                        list_servers, msg="Server with id %s was not found in the list" % self.server_third.id)
+
+    @tags(type='smoke', net='no')
+    def test_list_servers_with_detail(self):
+        """Return a detailed list of all servers"""
+        list_servers_detail_response = self.servers_client.list_servers_with_detail()
+        list_servers_detail = list_servers_detail_response.entity
+        self.assertEqual(200, list_servers_detail_response.status_code)
+        servers_lists = []
+        for i in list_servers_detail:
+            servers_lists.append(i.id)
+        self.assertTrue(self.server.id in servers_lists,
+                        msg="Server with id %s was not found in the list" % self.server.id)
+        self.assertTrue(self.server_second.id in servers_lists,
+                        msg="Server with id %s was not found in the list" % self.server_second.id)
+        self.assertTrue(self.server_third.id in servers_lists,
+                        msg="Server with id %s was not found in the list" % self.server_third.id)
+
+    @tags(type='positive', net='no')
+    def test_list_server_details_using_marker(self):
+        """The list of servers should start from the provided marker"""
+        list_server_detail_response = self.servers_client.list_servers_with_detail()
+        list_server_detail = list_server_detail_response.entity
+        first_server = list_server_detail[0]
+
+        # Verify the list of servers doesn't contain the server used as a marker
+        params = first_server.id
+        filtered_servers = self.servers_client.list_servers_with_detail(marker=params)
+        self.assertEqual(200, filtered_servers.status_code)
+        self.assertTrue(first_server not in filtered_servers.entity,
+                        msg="The server id used as marker found in the server list")
+
+    @tags(type='positive', net='no')
+    def test_list_servers_using_marker(self):
+        """The list of servers should start from the provided marker"""
+        list_server_info_response = self.servers_client.list_servers()
+        list_server_info = list_server_info_response.entity
+        first_server = list_server_info[0]
+
+        # Verify the list of servers doesn't contain the server used as a marker
+        params = first_server.id
+        filtered_servers = self.servers_client.list_servers(marker=params)
+        self.assertEqual(200, filtered_servers.status_code)
+        self.assertTrue(first_server not in filtered_servers.entity,
+                        msg="The server id used as marker found in the server list")
+
+    @tags(type='positive', net='no')
+    def test_list_server_with_detail_limit_results(self):
+        """Verify only the expected number of results (with full details) are returned"""
+        limit = 1
+        params = limit
+        server_with_limit = self.servers_client.list_servers_with_detail(limit=params)
+        self.assertEqual(limit, len(server_with_limit.entity),
+                         msg="The number of servers returned (%s) was more than the limit (%s)" % (len(server_with_limit.entity), limit))
+
+    @tags(type='positive', net='no')
+    def test_list_servers_filter_by_image(self):
+        """Filter the list of servers by image"""
+        params = self.image_ref
+        list_servers_response = self.servers_client.list_servers(image=params)
+        list_servers = list_servers_response.entity
+        self.assertEqual(200, list_servers_response.status_code)
+
+        self.assertTrue(self.server.min_details() in
+                        list_servers, msg="Server with id %s was not found in the list" % self.server.image.id)
+        self.assertTrue(self.server_second.min_details() in
+                        list_servers, msg="Server with id %s was not found in the list" % self.server_second.image.id)
+        self.assertTrue(self.server_third.min_details() not in
+                        list_servers, msg="Server with id %s and image id %s was found in the list filtered by image id %s" % (self.server_third.id, self.server_third.image.id, self.image_ref))
+
+    @tags(type='positive', net='no')
+    def test_list_servers_filter_by_flavor(self):
+        """Filter the list of servers by flavor"""
+        params = self.flavor_ref_alt
+        list_servers_response = self.servers_client.list_servers(flavor=params)
+        list_servers = list_servers_response.entity
+        self.assertEqual(200, list_servers_response.status_code)
+
+        self.assertTrue(self.server.min_details() not in list_servers,
+                        msg="Server with id %s and flavor id %s was found in the list filtered by flavor id %s" % (self.server.id, self.server.flavor.id, self.flavor_ref_alt))
+        self.assertTrue(self.server_second.min_details() not in list_servers,
+                        msg="Server with id %s and flavor id %s was found in the list filtered by flavor id %s" % (self.server_second.id, self.server_second.flavor.id, self.flavor_ref_alt))
+        self.assertTrue(self.server_third.min_details() in list_servers,
+                        msg="Server with id %s was not found in the list" % self.server_third.id)
+
+    @tags(type='positive', net='no')
+    def test_list_servers_filter_by_server_name(self):
+        """ Filter the list of servers by name """
+        params = self.server.name
+        list_servers_response = self.servers_client.list_servers(name=params)
+        list_servers = list_servers_response.entity
+        self.assertEqual(200, list_servers_response.status_code)
+        self.assertTrue(self.server.min_details() in list_servers,
+                        msg="Server with id %s was not found in the list" % self.server.id)
+        self.assertTrue(self.server_second.min_details() not in list_servers,
+                        msg="Server with id %s and name %s was found in the list filtered by name %s" % (self.server.id, self.server_second.name, self.server.name))
+        self.assertTrue(self.server_third.min_details() not in list_servers,
+                        msg="Server with id %s and name %s was found in the list filtered by name %s" % (self.server_third.id, self.server_third.name, self.server.name))
+
+    @tags(type='positive', net='no')
+    def test_list_servers_filter_by_server_status(self):
+        """ Filter the list of servers by server status """
+        params = 'active'
+        list_servers_response = self.servers_client.list_servers(status=params)
+        list_servers = list_servers_response.entity
+        self.assertEqual(200, list_servers_response.status_code)
+        self.assertTrue(self.server.min_details() in
+                        list_servers, msg="Server with id %s was not found in the list" % self.server.id)
+        self.assertTrue(self.server_second.min_details() in
+                        list_servers, msg="Server with id %s was not found in the list" % self.server_second.id)
+        self.assertTrue(self.server_third.min_details() in
+                        list_servers, msg="Server with id %s was not found in the list" % self.server_third.id)
+
+    @tags(type='positive', net='no')
+    def test_list_servers_filter_by_changes_since(self):
+        """Filter the list of servers by changes-since"""
+        change_time = self.server_second.created
+        params = change_time
+        servers = self.servers_client.list_servers(changes_since=params)
+        self.assertEqual(200, servers.status_code)
+        servers_ids_list = []
+        for i in servers.entity:
+            servers_ids_list.append(i.id)
+        self.assertTrue(self.server.id not in servers_ids_list,
+                        msg="Server with id %s was found in the list" % self.server.id)
+        self.assertTrue(self.server_second.id in servers_ids_list,
+                        msg="Server with id %s was not found in the list" % self.server_second.id)
+        self.assertTrue(self.server_third.id in servers_ids_list,
+                        msg="Server with id %s was not found in the list" % self.server_third.id)
+
+    @tags(type='positive', net='no')
+    def test_list_servers_detailed_filter_by_image(self):
+        """Filter the detailed list of servers by image"""
+        params = self.image_ref
+        servers_response = self.servers_client.list_servers_with_detail(image=params)
+        self.assertEqual(200, servers_response.status_code)
+        servers_list = []
+        for i in servers_response.entity:
+            servers_list.append(i.id)
+        self.assertTrue(self.server.id in servers_list,
+                        msg="Server with id %s was not found in the list" % self.server.id)
+        self.assertTrue(self.server_second.id in servers_list,
+                        msg="Server with id %s was not found in the list" % self.server_second.id)
+        self.assertTrue(self.server_third.id not in servers_list,
+                        msg="Server with id %s and image id %s was found in the list filtered by image id %s" % (self.server_third.id, self.server_third.image.id, self.image_ref))
+
+    @tags(type='positive', net='no')
+    def test_list_servers_detailed_filter_by_flavor(self):
+        """Filter the detailed list of servers by flavor"""
+        params = self.flavor_ref_alt
+        filtered_servers_response = self.servers_client.list_servers_with_detail(flavor=params)
+        filtered_servers = filtered_servers_response.entity
+        self.assertEqual(200, filtered_servers_response.status_code)
+
+        self.assertTrue(self.server not in filtered_servers,
+                        msg="Server with id %s and flavor id %s was found in the list filtered by flavor id %s" % (self.server.id, self.server.flavor.id, self.flavor_ref_alt))
+        self.assertTrue(self.server_second not in filtered_servers,
+                        msg="Server with id %s and flavor id %s was found in the list filtered by flavor id %s" % (self.server_second.id, self.server.flavor.id, self.flavor_ref_alt))
+        self.assertTrue(self.server_third in filtered_servers,
+                        msg="Server with id %s was not found in the list" % self.server_third.id,)
+
+    @tags(type='positive', net='no')
+    def test_list_servers_detailed_filter_by_server_name(self):
+        """Filter the detailed list of servers by server name"""
+        params = self.server.name
+        filtered_servers_response = self.servers_client.list_servers_with_detail(name=params)
+        filtered_servers = filtered_servers_response.entity
+        self.assertEqual(200, filtered_servers_response.status_code)
+
+        self.assertTrue(self.server in filtered_servers,
+                        msg="Server with id %s was not found in the list" % self.server.id)
+        self.assertTrue(self.server_second not in filtered_servers,
+                        msg="Server with id %s and name %s was found in the list filtered by name %s" % (self.server_second.id, self.server_second.name, self.server.name))
+        self.assertTrue(self.server_third not in filtered_servers,
+                        msg="Server with id %s and name %s was found in the list filtered by name %s" % (self.server_third.id, self.server_third.name, self.server.name))
+
+    @tags(type='positive', net='no')
+    def test_list_servers_detailed_filter_by_server_status(self):
+        """Filter the detailed list of servers by server status"""
+        params = 'active'
+        filtered_servers_response = self.servers_client.list_servers_with_detail(status=params)
+        filtered_servers = filtered_servers_response.entity
+        self.assertEqual(200, filtered_servers_response.status_code)
+        servers_list = []
+        for i in filtered_servers:
+            servers_list.append(i.id)
+        self.assertTrue(self.server.id in servers_list,
+                        msg="Server with id %s was not found in the list" % self.server.id)
+        self.assertTrue(self.server_second.id in servers_list,
+                        msg="Server with id %s was not found in the list" % self.server_second.id)
+        self.assertTrue(self.server_third.id in servers_list,
+                        msg="Server with id %s was not found in the list" % self.server_third.id)
+
+    @tags(type='positive', net='no')
+    def test_list_servers_detailed_filter_by_changes_since(self):
+        """Create a filter for the server with the second server created date"""
+        change_time = self.server_second.created
+        params = change_time
+
+        # Filter the detailed list of servers by changes-since
+        filtered_servers_response = self.servers_client.list_servers_with_detail(changes_since=params)
+        filtered_servers = filtered_servers_response.entity
+        self.assertEqual(200, filtered_servers_response.status_code)
+        servers_list = []
+        for i in filtered_servers:
+            servers_list.append(i.id)
+        self.assertTrue(self.server.id not in servers_list,
+                        msg="Server with id %s was found in the list" % self.server.id)
+        self.assertTrue(self.server_second.id in servers_list,
+                        msg="Server with id %s was not found in the list" % self.server_second.id)
+        self.assertTrue(self.server_third.id in servers_list,
+                        msg="Server with id %s was not found in the list" % self.server_third.id)

test_repo/compute/functional/servers/test_server_metadata.py

@@ -0,0 +1,194 @@
+"""
+Copyright 2013 Rackspace
+
+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 unittest2 as unittest
+
+from cafe.drivers.unittest.decorators import tags
+from cloudcafe.compute.common.datagen import rand_name
+from cloudcafe.compute.common.exceptions import ItemNotFound
+from test_repo.compute.fixtures import ComputeFixture
+
+
+class ServerMetadataTest(ComputeFixture):
+
+    @classmethod
+    def setUpClass(cls):
+        super(ServerMetadataTest, cls).setUpClass()
+        server_response = cls.server_behaviors.create_active_server()
+        cls.server = server_response.entity
+        cls.resources.add(cls.server.id, cls.servers_client.delete_server)
+
+    @classmethod
+    def tearDownClass(cls):
+        super(ServerMetadataTest, cls).tearDownClass()
+
+    def setUp(self):
+        super(ServerMetadataTest, self).setUp()
+        self.meta = {'meta_key_1': 'meta_value_1', 'meta_key_2': 'meta_value_2'}
+        self.servers_client.set_server_metadata(self.server.id, self.meta)
+
+    @tags(type='positive', net='no')
+    def test_list_server_metadata(self):
+        """All metadata key/value pairs for a server should be returned"""
+        metadata_response = self.servers_client.list_server_metadata(self.server.id)
+        metadata = metadata_response.entity
+        self.assertEqual(200, metadata_response.status_code,
+                         "List server metadata call response was: %s" % (metadata_response.status_code))
+        self.assertEqual('meta_value_1', metadata.meta_key_1,
+                         "Metadata Item not found on server %s. Expected Item Key : meta_key_1, Value : meta_value_1" % self.server.id)
+        self.assertEqual('meta_value_2', metadata.meta_key_2,
+                         "Metadata Item not found on server %s. Expected Item Key : meta_key_2, Value : meta_value_2" % self.server.id)
+
+    @tags(type='positive', net='no')
+    def test_set_server_metadata(self):
+        """The server's metadata should be replaced with the provided values"""
+        meta = {'meta1': 'data1'}
+        server_response = self.server_behaviors.create_active_server(metadata=meta)
+        server = server_response.entity
+        self.resources.add(server.id, self.servers_client.delete_server)
+
+        new_meta = {'meta2': 'data2', 'meta3': 'data3'}
+        metadata_response = self.servers_client.set_server_metadata(server.id,
+                                                                    new_meta)
+        metadata = metadata_response.entity
+        self.assertEqual(200, metadata_response.status_code,
+                         "Set server metadata call response was: %s" % (metadata_response.status_code))
+        self.assertEqual('data2', metadata.meta2,
+                         "Metadata Item not found on server %s. Expected Item Key : meta2, Value : data2" % server.id)
+        self.assertEqual('data3', metadata.meta3,
+                         "Metadata Item not found on server %s. Expected Item Key : meta3, Value : data3" % server.id)
+        self.assertFalse(hasattr(metadata, 'meta1'),
+                         "The already existing metadata(Key : meta1) is not removed during Set metadata")
+
+        actual_metadata_response = self.servers_client.list_server_metadata(server.id)
+        actual_metadata = actual_metadata_response.entity
+        self.assertEqual('data2', actual_metadata.meta2,
+                         "Metadata Item not found on server %s. Expected Item Key : meta2, Value : data2" % server.id)
+        self.assertEqual('data3', actual_metadata.meta3,
+                         "Metadata Item not found on server %s. Expected Item Key : meta3, Value : data3" % server.id)
+        self.assertFalse(hasattr(actual_metadata, 'meta1'),
+                         "The already existing metadata(Key : meta1) is not removed during Set metadata")
+
+    @tags(type='positive', net='no')
+    def test_update_server_metadata(self):
+        """The server's metadata values should be updated to the provided values"""
+        meta = {'key1': 'alt1', 'key2': 'alt2', 'meta_key_1': 'alt3'}
+        metadata_response = self.servers_client.update_server_metadata(self.server.id, meta)
+        metadata = metadata_response.entity
+        self.assertEqual(200, metadata_response.status_code,
+                         "Update server metadata call response was: %s" % (metadata_response.status_code))
+        self.assertEqual('alt1', metadata.key1,
+                         "Metadata Item not found on server %s. Expected Item Key : key1, Value : alt1" % self.server.id)
+        self.assertEqual('alt2', metadata.key2,
+                         "Metadata Item not found on server %s. Expected Item Key : key2, Value : alt2" % self.server.id)
+        self.assertEqual('alt3', metadata.meta_key_1,
+                         "Metadata Item not found on server %s. Expected Item Key : meta_key_1, Value : alt3" % self.server.id)
+        self.assertEqual('meta_value_2', metadata.meta_key_2,
+                         "Metadata Item not found on server %s. Expected Item Key : meta_key_2, Value : meta_value_2" % self.server.id)
+
+        #Verify the values have been updated to the proper values
+        actual_metadata_response = self.servers_client.list_server_metadata(self.server.id)
+        actual_metadata = actual_metadata_response.entity
+        self.assertEqual('alt1', actual_metadata.key1,
+                         "Metadata Item not found on server %s. Expected Item Key : key1, Value : alt1" % self.server.id)
+        self.assertEqual('alt2', actual_metadata.key2,
+                         "Metadata Item not found on server %s. Expected Item Key : key2, Value : alt2" % self.server.id)
+        self.assertEqual('alt3', actual_metadata.meta_key_1,
+                         "Metadata Item not found on server %s. Expected Item Key : meta_key_1, Value : alt3" % self.server.id)
+        self.assertEqual('meta_value_2', actual_metadata.meta_key_2,
+                         "Metadata Item not found on server %s. Expected Item Key : meta_key_2, Value : meta_value_2" % self.server.id)
+
+    @tags(type='positive', net='no')
+    def test_get_server_metadata_item(self):
+        """The value for a specific metadata key should be returned"""
+        metadata_response = self.servers_client.get_server_metadata_item(self.server.id,
+                                                                         'meta_key_1')
+        metadata = metadata_response.entity
+        self.assertEqual('meta_value_1', metadata.meta_key_1,
+                         msg="Metadata Item not found on server %s. Expected Item Key : meta_key_1, Value : meta_value_1" % self.server.id)
+
+    @tags(type='positive', net='no')
+    def test_set_server_metadata_item(self):
+        """The value provided for the given meta item should be set for the server"""
+        meta = {'meta_key_2': 'nova'}
+        metadata_response = self.servers_client.set_server_metadata_item(self.server.id,
+                                                                         'meta_key_2', 'nova')
+        metadata = metadata_response.entity
+        self.assertEqual(200, metadata_response.status_code,
+                         "Set server metadata item call response was: %s" % (metadata_response.status_code))
+        self.assertEqual('nova', metadata.meta_key_2,
+                         "Metadata Item not found on server %s. Expected Item Key : meta_key_2, Value : nova" % self.server.id)
+
+        actual_metadata_response = self.servers_client.list_server_metadata(self.server.id)
+        actual_metadata = actual_metadata_response.entity
+        self.assertEqual('nova', actual_metadata.meta_key_2,
+                         "Metadata Item not found on server %s. Expected Item Key : meta_key_2, Value : nova" % self.server.id)
+        self.assertEqual('meta_value_1', actual_metadata.meta_key_1,
+                         "Metadata Item not found on server %s. Expected Item Key : meta_key_1, Value : meta_value_1" % self.server.id)
+
+    @tags(type='positive', net='no')
+    def test_add_new_server_metadata_item(self):
+        """ The metadata item should be added to the server"""
+        meta = {'meta_key_3': 'meta_value_3'}
+        metadata_response = self.servers_client.set_server_metadata_item(self.server.id,
+                                                                         'meta_key_3', 'meta_value_3')
+        metadata = metadata_response.entity
+        self.assertEqual(200, metadata_response.status_code, "Add server metadata item call response was: %s" % (metadata_response.status_code))
+        self.assertEqual('meta_value_3', metadata.meta_key_3,
+                         "Metadata Item not found on server %s. Expected Item Key : meta_key_3, Value : meta_value_3" % self.server.id)
+
+        actual_metadata_response = self.servers_client.list_server_metadata(self.server.id)
+        actual_metadata = actual_metadata_response.entity
+        self.assertEqual('meta_value_3', actual_metadata.meta_key_3,
+                         "Metadata Item not found on server %s. Expected Item Key : meta_key_3, Value : meta_value_3" % self.server.id)
+        self.assertEqual('meta_value_2', actual_metadata.meta_key_2,
+                         "Metadata Item not found on server %s. Expected Item Key : meta_key_2, Value : meta_value_2" % self.server.id)
+        self.assertEqual('meta_value_1', actual_metadata.meta_key_1,
+                         "Metadata Item not found on server %s. Expected Item Key : meta_key_1, Value : meta_value_1" % self.server.id)
+
+    @tags(type='positive', net='no')
+    def test_delete_server_metadata_item(self):
+        """The metadata value/key pair should be deleted from the server"""
+
+        response = self.servers_client.delete_server_metadata_item(self.server.id,
+                                                                   'meta_key_1')
+        self.assertEqual(204, response.status_code, "Delete server metadata item call response was: %s" % (response.status_code))
+        metadata_response = self.servers_client.list_server_metadata(self.server.id)
+        metadata = metadata_response.entity
+        self.assertFalse(hasattr(metadata, 'meta_key_1'), "The server\
+                            metadata item (Key: meta_key_1) is not deleted")
+
+    @tags(type='negative', net='no')
+    def test_delete_nonexistent_server_metadata_item(self):
+        with self.assertRaises(ItemNotFound):
+            self.servers_client.delete_server_metadata_item(self.server.id,
+                                                            'meta_key_5')
+
+    @tags(type='negative', net='no')
+    def test_get_nonexistent_server_metadata_item(self):
+        with self.assertRaises(ItemNotFound):
+            self.servers_client.get_server_metadata_item(self.server.id,
+                                                         'meta_key_5')
+
+    @tags(type='negative', net='no')
+    @unittest.skip('Failing, under review')
+    def test_set_blank_metadata_dict(self):
+        blank_meta = {'': ''}
+        create_server_response = self.servers_client.create_server(rand_name('testserver'), self.image_ref, self.flavor_ref, metadata=blank_meta)
+        server_response = self.servers_client.get_server(create_server_response.entity.id)
+        server = server_response.entity
+        self.assertEqual("", server.metadata[''])
+

test_repo/compute/functional/servers/test_servers.py

@@ -0,0 +1,330 @@
+"""
+Copyright 2013 Rackspace
+
+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 base64
+import time
+
+from cafe.drivers.unittest.decorators import tags
+from cloudcafe.compute.common.models.metadata import Metadata
+from cloudcafe.compute.common.datagen import rand_name
+from cloudcafe.compute.common.types import NovaServerStatusTypes
+from test_repo.compute.fixtures import ComputeFixture
+
+
+class ServersTest(ComputeFixture):
+
+    @classmethod
+    def setUpClass(cls):
+        super(ServersTest, cls).setUpClass()
+        cls.file_contents = 'This is a test file.'
+        cls.personality = [{'path': '/root/.csivh',
+                            'contents': base64.b64encode(cls.file_contents)}]
+        cls.meta = {'meta_key_1': 'meta_value_1', 'meta_key_2': 'meta_value_2'}
+        cls.accessIPv4 = '192.168.32.16'
+        cls.accessIPv6 = '3ffe:1900:4545:3:200:f8ff:fe21:67cf'
+
+    @classmethod
+    def tearDownClass(cls):
+        super(ServersTest, cls).tearDownClass()
+
+    @tags(type='smoke', net='no')
+    def test_update_server_details(self):
+        """The server name and access ip addresses should be changed to the provided values"""
+        active_server_response = self.server_behaviors.create_active_server()
+        active_server = active_server_response.entity
+        updated_server_response = self.servers_client.update_server(active_server.id,
+                                                                    name='newname',
+                                                                    accessIPv4=self.accessIPv4,
+                                                                    accessIPv6=self.accessIPv6)
+        updated_server = updated_server_response.entity
+        updated_server_details_response = self.servers_client.get_server(active_server.id)
+        updated_server_details = updated_server_details_response.entity
+        self.server_behaviors.wait_for_server_status(active_server.id,
+                                                     NovaServerStatusTypes.ACTIVE)
+        # Verify the name and access IPs of the server have changed
+        self.assertEqual('newname', updated_server.name,
+                         msg="The name was not updated")
+        self.assertEqual(self.accessIPv4, updated_server.accessIPv4,
+                         msg="AccessIPv4 was not updated")
+        self.assertEqual(self.accessIPv6, updated_server.accessIPv6,
+                         msg="AccessIPv6 was not updated")
+        self.assertEqual(active_server.created, updated_server.created,
+                         msg="The creation date was updated")
+
+        # Verify details changed on get updated server call
+        self.assertEqual('newname', updated_server_details.name,
+                         msg="The name was not updated")
+        self.assertEqual(self.accessIPv4, updated_server_details.accessIPv4,
+                         msg="AccessIPv4 was not updated")
+        self.assertEqual(self.accessIPv6, updated_server_details.accessIPv6,
+                         msg="AccessIPv6 was not updated")
+        self.assertEqual(active_server.created, updated_server_details.created,
+                         msg="The creation date was updated")
+        self.assertNotEqual(active_server.updated, updated_server_details.updated,
+                            msg="Server %s updated time did not change after a modification to the server." % updated_server_details.id)
+
+        #Teardown
+        self.servers_client.delete_server(updated_server_details.id)
+
+    def _assert_server_details(self, server, expected_name,
+                               expected_accessIPv4, expected_accessIPv6,
+                               expected_flavor):
+        self.assertEqual(expected_accessIPv4, server.accessIPv4,
+                         msg="AccessIPv4 did not match")
+        self.assertEqual(expected_accessIPv6, server.accessIPv6,
+                         msg="AccessIPv6 did not match")
+        self.assertEqual(expected_name, server.name,
+                         msg="Server name did not match")
+        self.assertEqual(self.image_ref, server.image.id,
+                         msg="Image id did not match")
+        self.assertEqual(expected_flavor, server.flavor.id,
+                         msg="Flavor id did not match")
+        self.assertTrue(server.created is not None,
+                        msg="Server created date was not set")
+        self.assertTrue(server.updated is not None,
+                        msg="Server updated date was not set")
+        self.assertGreaterEqual(server.updated, server.created,
+                                msg="Server updated date was before the created date")
+        self.assertEqual(self.meta, Metadata._obj_to_dict(server.metadata),
+                         msg="Metadata did not match")
+
+    def _assert_public_address_is_valid(self, addresses):
+
+        self.assertTrue(len(addresses.public.addresses) == 2,
+                        msg="Server does not have a Public IPs set")
+        ipv4_public_address = None
+        ipv6_public_address = None
+        if self.config.misc.serializer == "xml":
+            for address in addresses.public.addresses:
+                if address.version == '4':
+                    ipv4_public_address = address
+                else:
+                    ipv6_public_address = address
+            self.assertTrue(ipv4_public_address.version == '4' and
+                            ipv4_public_address.addr is not None,
+                            msg="Server does not have a Public IPv4 set")
+            self.assertTrue(ipv6_public_address.version == '6' and
+                            ipv6_public_address.addr is not None,
+                            msg="Server does not have a Public IPv6 set")
+        else:
+            for address in addresses.public.addresses:
+                if address.version == 4:
+                    ipv4_public_address = address
+                else:
+                    ipv6_public_address = address
+                self.assertTrue(ipv4_public_address.version == 4 and
+                                ipv4_public_address.addr is not None,
+                                msg="Server does not have a Public IPv4 set")
+                self.assertTrue(ipv6_public_address.version == 6 and
+                                ipv6_public_address.addr is not None,
+                                msg="Server does not have a Public IPv6 set")
+
+    @tags(type='positive', net='no')
+    def test_delete_server(self):
+        """A server should be built using the specified image and flavor"""
+        active_server_response = self.server_behaviors.create_active_server()
+        active_server = active_server_response.entity
+        deleted_server_response = self.servers_client.delete_server(active_server.id)
+        self.assertEqual(204, deleted_server_response.status_code,
+                         msg='The delete call response was: %s'
+                             % (deleted_server_response.status_code))
+        self.server_behaviors.wait_for_server_status(active_server.id,
+                                                     NovaServerStatusTypes.DELETED)
+        # Verify the server is now in deleted status
+        parameter = str(active_server.created)
+        list_servers = self.servers_client.list_servers_with_detail(changes_since=parameter)
+        found = False
+        for server in list_servers.entity:
+            if server.id == active_server.id:
+                deleted_server = server
+                found = True
+
+        self.assertTrue(found,
+                        msg="The server which was deleted was not found in the server list")
+        self.assertEqual('DELETED', deleted_server.status,
+                         msg="The server which was deleted was not in DELETED status")
+
+    @tags(type='positive', net='yes')
+    def test_create_server_with_admin_password(self):
+        """
+        If an admin password is provided on server creation, the server's root
+        password should be set to that password.
+        """
+        name = rand_name("testserver")
+        admin_password = 'oldslice129690TuG72Bgj2'
+        create_server_response = self.servers_client.create_server(name, self.image_ref, self.flavor_ref, admin_pass=admin_password)
+        created_server = create_server_response.entity
+
+        self.assertEqual(admin_password, created_server.admin_pass,
+                         msg='Verify that given adminPass equals with actual one')
+        active_server = self.server_behaviors.wait_for_server_status(created_server.id, NovaServerStatusTypes.ACTIVE)
+
+
+    @tags(type='positive', net='no')
+    def test_create_server_with_image_and_flavor_self_link(self):
+        """Create a server using image and flavor self links"""
+        name = rand_name("testserver")
+        image = self.images_client.get_image(self.image_ref)
+        image_self_link = image.entity.id
+        flavor = self.flavors_client.get_flavor_details(self.flavor_ref)
+        flavor_self_link = flavor.entity.id
+
+        create_server_response = self.servers_client.create_server(name,
+                                                                   image_self_link,
+                                                                   flavor_self_link)
+        created_server = create_server_response.entity
+        #Verify the parameters are correct in the initial response
+        self.assertTrue(created_server.id is not None,
+                        msg="The server id was not set in response")
+        self.assertTrue(created_server.admin_pass is not None,
+                        msg="Admin password was not set in response")
+        self.assertTrue(created_server.links is not None,
+                        msg="Server links were not set in response")
+
+        '''Wait for the server to become active'''
+        active_server_response = self.server_behaviors.wait_for_server_status(created_server.id,
+                                                                              NovaServerStatusTypes.ACTIVE)
+        active_server = active_server_response.entity
+        get_server_info_response = self.servers_client.get_server(created_server.id)
+        get_server_info = get_server_info_response.entity
+
+        '''Verify that the image Id of the image ref link which is used to create server
+        is same as the image id of the created server'''
+        self.assertEqual(get_server_info.image.id, self._parse_link_to_retrieve_id(image_self_link),
+                         msg="The image does not match to the image mentioned during create")
+
+        '''Verify that the flavor Id of the flavor ref link which is used to create server
+        is same as the flavor id of the created server'''
+        self.assertEqual(get_server_info.flavor.id, self._parse_link_to_retrieve_id(flavor_self_link),
+                         msg="The flavor does not match to the flavor mentioned during create")
+
+        self.servers_client.delete_server(active_server.id)
+
+    def _parse_link_to_retrieve_id(self, ref):
+        temp = ref.rsplit('/')
+        #Return the last item, which is the image id
+        return temp[len(temp) - 1]
+
+    @tags(type='positive', net='no')
+    def test_create_server_with_image_and_flavor_bookmark_link(self):
+        """Create a server using image and flavor bookmark links"""
+        name = rand_name("testserver")
+        image = self.images_client.get_image(self.image_ref)
+        image_bookmark_link = image.entity.links.links.get('bookmark')
+        flavor = self.flavors_client.get_flavor_details(self.flavor_ref)
+        flavor_bookmark_link = flavor.entity.links.links.get('bookmark')
+        create_server_response = self.servers_client.create_server(name,
+                                                                   image_bookmark_link,
+                                                                   flavor_bookmark_link)
+        created_server = create_server_response.entity
+
+        '''Verify the parameters are correct in the initial response'''
+        self.assertTrue(created_server.id is not None,
+                        msg="The server id was not set in the response")
+        self.assertTrue(created_server.admin_pass is not None,
+                        msg="Admin password was not set in the response")
+        self.assertTrue(created_server.links is not None,
+                        msg="Server links were not set in the response")
+
+        '''Wait for the server to become active'''
+        active_server_response = self.server_behaviors.wait_for_server_status(created_server.id,
+                                                                              NovaServerStatusTypes.ACTIVE)
+        active_server = active_server_response.entity
+        get_server_info_response = self.servers_client.get_server(created_server.id)
+        get_server_info = get_server_info_response.entity
+        '''Verify that the correct image and flavor refs were used'''
+        self.assertEqual(get_server_info.image.id, self._parse_link_to_retrieve_id(image_bookmark_link),
+                         msg="The image does not match to the image mentioned during create")
+        self.assertEqual(get_server_info.flavor.id, self._parse_link_to_retrieve_id(flavor_bookmark_link),
+                         msg="The flavor does not match to the flavor mentioned during create")
+
+        self.servers_client.delete_server(active_server.id)
+
+    @tags(type='positive', net='no')
+    def test_update_server_using_server_self_link(self):
+        """Update a server using the server self link"""
+        name = rand_name("testserver")
+        stored_name = name
+        '''Create an active server'''
+        active_server_response = self.server_behaviors.create_active_server()
+        active_server = active_server_response.entity
+        '''Need to ensure there is atleast one second gap between creating and
+        updating a server. The test failed once without the sleep.'''
+        time.sleep(1)
+        '''Some processing'''
+        link = str(active_server.links.self)
+        link_list = link.split('/')
+        server_id = link_list[6]
+        '''Use server self link to update the server'''
+        updated_server_response = self.servers_client.update_server(server_id,
+                                                                    name,
+                                                                    accessIPv4=self.accessIPv4,
+                                                                    accessIPv6=self.accessIPv6)
+        updated_server = updated_server_response.entity
+        self.server_behaviors.wait_for_server_status(updated_server.id, NovaServerStatusTypes.ACTIVE)
+
+        '''Verify the name and access ips of the server have changed'''
+        get_server_info = self.servers_client.get_server(updated_server.id)
+        self.assertEqual(stored_name, get_server_info.entity.name,
+                         msg="The name was not updated")
+        self.assertEqual(self.accessIPv4, get_server_info.entity.accessIPv4,
+                         msg="AccessIPv4 was not updated")
+        self.assertEqual(self.accessIPv6, get_server_info.entity.accessIPv6,
+                         msg="AccessIPv6 was not updated")
+        self.assertEqual(active_server.created, get_server_info.entity.created,
+                         msg="The creation date was updated")
+        self.assertTrue(active_server.updated != get_server_info.entity.updated,
+                        msg="Server %s updated time did not change after a modification to the server." % updated_server.id)
+
+        self.servers_client.delete_server(get_server_info.entity.id)
+
+    @tags(type='positive', net='no')
+    def test_update_server_using_server_bookmark_link(self):
+        """Update a server using the server bookmark link"""
+        name = rand_name("testserver")
+        stored_name = name
+        #        Create an active server
+        active_server_response = self.server_behaviors.create_active_server()
+        active_server = active_server_response.entity
+        '''Need to ensure there is atleast one second gap between creating
+        and updating a server. The test failed once without the sleep.'''
+        time.sleep(1)
+        #Some processing
+        link = str(active_server.links.bookmark)
+        link_list = link.split('/')
+        server_id = link_list[5]
+        '''Use server bookmark's link to update the server'''
+        updated_server_response = self.servers_client.update_server(server_id,
+                                                                    name,
+                                                                    accessIPv4=self.accessIPv4,
+                                                                    accessIPv6=self.accessIPv6)
+        updated_server = updated_server_response.entity
+        self.server_behaviors.wait_for_server_status(updated_server.id, NovaServerStatusTypes.ACTIVE)
+
+        '''Verify the name and access ips of the server have changed'''
+        get_server_info = self.servers_client.get_server(updated_server.id)
+        self.assertEqual(stored_name, get_server_info.entity.name,
+                         msg="The name was not updated")
+        self.assertEqual(self.accessIPv4, get_server_info.entity.accessIPv4,
+                         msg="AccessIPv4 was not updated")
+        self.assertEqual(self.accessIPv6, get_server_info.entity.accessIPv6,
+                         msg="AccessIPv6 was not updated")
+        self.assertEqual(active_server.created, get_server_info.entity.created,
+                         msg="The creation date was updated")
+        self.assertTrue(active_server.updated != get_server_info.entity.updated,
+                        msg="Server %s updated time did not change after a modification to the server." % updated_server.id)
+
+        self.servers_client.delete_server(get_server_info.entity.id)

test_repo/compute/functional/servers/test_servers_negative.py

@@ -0,0 +1,163 @@
+"""
+Copyright 2013 Rackspace
+
+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 cafe.drivers.unittest.decorators import tags
+from cloudcafe.compute.common.exceptions import BadRequest, ItemNotFound
+from cloudcafe.compute.common.datagen import rand_name
+from test_repo.compute.fixtures import ComputeFixture
+
+
+class ServersNegativeTest(ComputeFixture):
+
+    @classmethod
+    def setUpClass(cls):
+        super(ServersNegativeTest, cls).setUpClass()
+
+
+    @classmethod
+    def tearDownClass(cls):
+        super(ServersNegativeTest, cls).tearDownClass()
+
+    @tags(type='negative', net='no')
+    def test_server_name_blank(self):
+        with self.assertRaises(BadRequest):
+            self.servers_client.create_server('', self.image_ref, self.flavor_ref)
+
+    @tags(type='negative', net='no')
+    def test_personality_file_contents_not_encoded(self):
+        """Server should not get created with a personality file whose content is not encoded"""
+        file_contents = 'This is a test file.'
+        personality = [{'path': '/etc/testfile.txt',
+                        'contents': file_contents}]
+        with self.assertRaises(BadRequest):
+            server = self.servers_client.create_server('blankfile',
+                                                       self.image_ref, self.flavor_ref,
+                                                       personality=personality)
+
+    @tags(type='negative', net='no')
+    def test_invalid_ip_v4_access_address(self):
+        """Negative test: Server should not get created with invalid ipv4 address"""
+        accessIPv4 = '1.1.1.1.1.1'
+        name = rand_name("testserver")
+        with self.assertRaises(BadRequest):
+            server_response = self.servers_client.create_server(name,
+                                                                self.image_ref,
+                                                                self.flavor_ref,
+                                                                accessIPv4=accessIPv4)
+
+    @tags(type='negative', net='no')
+    def test_invalid_ip_v6_access_address(self):
+        """Negative test: Server should not get created with invalid ipv6 address"""
+        accessIPv6 = '2.2.2.2'
+        name = rand_name("testserver")
+        with self.assertRaises(BadRequest):
+            server_response = self.servers_client.create_server(name,
+                                                                self.image_ref,
+                                                                self.flavor_ref,
+                                                                accessIPv6=accessIPv6)
+
+    @tags(type='negative', net='no')
+    def test_server_metadata_item_nonexistent_server(self):
+        """Negative test: GET on nonexistent server should not succeed"""
+        with self.assertRaises(ItemNotFound):
+            self.servers_client.get_server_metadata_item(999, 'test2')
+
+    @tags(type='negative', net='no')
+    def test_list_server_metadata_nonexistent_server(self):
+        """List metadata on a non existent server should not succeed"""
+        with self.assertRaises(ItemNotFound):
+            self.servers_client.list_server_metadata(999)
+
+    @tags(type='negative', net='no')
+    def test_set_server_metadata_nonexistent_server(self):
+        """Set metadata on a non existent server should not succeed"""
+        meta = {'meta1': 'data1'}
+
+        with self.assertRaises(ItemNotFound):
+            metadata_response = self.servers_client.set_server_metadata(999, meta)
+
+    @tags(type='negative', net='no')
+    def test_update_server_metadata_nonexistent_server(self):
+        """An update should not happen for a non existent image"""
+        meta = {'key1': 'value1', 'key2': 'value2'}
+        with self.assertRaises(ItemNotFound):
+            self.servers_client.update_server_metadata(999, meta)
+
+    @tags(type='negative', net='no')
+    def test_delete_server_metadata_item_nonexistent_server(self):
+        """Should not be able to delete metadata item from a non existent server"""
+        with self.assertRaises(ItemNotFound):
+            self.servers_client.delete_server_metadata_item(999, 'delkey')
+
+    @tags(type='negative', net='no')
+    def test_create_server_with_unknown_flavor(self):
+        """Server creation with a flavor ID which does not exist, should not be allowed"""
+        with self.assertRaises(BadRequest):
+            self.servers_client.create_server('testserver', self.image_ref, 999)
+
+    @tags(type='negative', net='no')
+    def test_create_server_with_unknown_image(self):
+        """Server creation with an image ID which does not exist,should not be allowed"""
+        with self.assertRaises(BadRequest):
+            self.servers_client.create_server('testserver', 999, self.flavor_ref)
+
+    @tags(type='negative', net='no')
+    def test_get_nonexistent_server_fails(self):
+        """Making a get request for a server that does not exist should cause a 404"""
+        with self.assertRaises(ItemNotFound):
+            self.servers_client.get_server(999)
+
+    @tags(type='negative', net='no')
+    def test_delete_nonexistent_server_fails(self):
+        """Making a delete request for a server that does not exist should cause a 404"""
+        with self.assertRaises(ItemNotFound):
+            self.servers_client.delete_server(999)
+
+    @tags(type='negative', net='no')
+    def test_list_addresses_for_nonexistant_server_fails(self):
+        """Making a list address request for a server that does not exist should cause a 404"""
+        with self.assertRaises(ItemNotFound):
+            self.servers_client.list_addresses(999)
+
+    @tags(type='negative', net='no')
+    def test_list_addresses_for_invalid_network_id_fails(self):
+        """Making a list address request for a server that does not exist should cause a 404"""
+        server_response = self.server_behaviors.create_active_server()
+        server = server_response.entity
+        with self.assertRaises(ItemNotFound):
+            self.servers_client.list_addresses_by_network(server.id, 999)
+
+    @tags(type='negative', net='no')
+    def test_list_addresses_by_network_for_nonexistant_server_fails(self):
+        """Making a list address by network request for a server that does not exist should cause a 404"""
+        with self.assertRaises(ItemNotFound):
+            self.servers_client.list_addresses_by_network(999, 'public')
+
+    @tags(type='negative', net='no')
+    def test_cannot_get_deleted_server(self):
+        """A 400 response should be returned when you get a server which is deleted"""
+        server = self.server_behaviors.create_active_server()
+        delete_resp = self.servers_client.delete_server(server.entity.id)
+        self.assertEqual(204, delete_resp.status_code)
+        self.server_behaviors.wait_for_server_to_be_deleted(server.entity.id)
+        with self.assertRaises(ItemNotFound):
+            self.servers_client.get_server(server.entity.id)
+
+    @tags(type='negative', net='no')
+    def test_create_server_with_invalid_name(self):
+        """Server creation with a blank/invalid name should not be allowed"""
+        with self.assertRaises(BadRequest):
+            self.servers_client.create_server('', self.image_ref, self.flavor_ref)