x/cloudroast
Code Issues Proposed changes

Merge "Implements optional kepair auth into all tests"

Browse Source
This commit is contained in:
Jenkins
2013-06-18 03:27:53 +00:00
committed by Gerrit Code Review
parent 6c980271e4 2070af82c9
commit e7a37bccc4
9 changed files with 98 additions and 70 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
test_repo/compute/functional/servers/actions/test_change_password.py
View File

@@ -20,6 +20,7 @@ from cafe.drivers.unittest.decorators import tags
from cloudcafe.compute.common.types import ComputeHypervisors
from cloudcafe.compute.common.types import NovaServerStatusTypes as \
ServerStates
from cloudcafe.compute.common.types import InstanceAuthStrategies
from cloudcafe.compute.config import ComputeConfig
from test_repo.compute.fixtures import CreateServerFixture
@@ -65,7 +66,8 @@ class ChangeServerPasswordTests(CreateServerFixture):
public_address = self.server_behaviors.get_public_ip_address(server)
# Get an instance of the remote client
remote_client = self.server_behaviors.get_remote_instance_client(
server, config=self.servers_config)
server, config=self.servers_config,
auth_strategy=InstanceAuthStrategies.PASSWORD)
self.assertTrue(
remote_client.can_connect_to_public_ip(),

12
test_repo/compute/functional/servers/actions/test_reboot_server_hard.py
View File

@@ -17,6 +17,7 @@ limitations under the License.
import time
from cafe.drivers.unittest.decorators import tags
from cloudcafe.compute.common.datagen import rand_name
from cloudcafe.compute.common.types import NovaServerRebootTypes
from test_repo.compute.fixtures import ComputeFixture
@@ -26,7 +27,8 @@ class RebootServerHardTests(ComputeFixture):
@classmethod
def setUpClass(cls):
super(RebootServerHardTests, cls).setUpClass()
response = cls.server_behaviors.create_active_server()
cls.key = cls.keypairs_client.create_keypair(rand_name("key")).entity
response = cls.server_behaviors.create_active_server(key_name=cls.key.name)
cls.server = response.entity
cls.resources.add(cls.server.id, cls.servers_client.delete_server)
@@ -37,14 +39,14 @@ class RebootServerHardTests(ComputeFixture):
@tags(type='smoke', net='yes')
def test_reboot_server_hard(self):
""" The server should be power cycled """
remote_instance = self.server_behaviors.get_remote_instance_client(self.server,
config=self.servers_config)
remote_instance = self.server_behaviors.get_remote_instance_client(
self.server, config=self.servers_config, key=self.key.private_key)
uptime_start = remote_instance.get_uptime()
start = time.time()
self.server_behaviors.reboot_and_await(self.server.id, NovaServerRebootTypes.HARD)
remote_client = self.server_behaviors.get_remote_instance_client(self.server,
config=self.servers_config)
remote_client = self.server_behaviors.get_remote_instance_client(
self.server, config=self.servers_config, key=self.key.private_key)
finish = time.time()
uptime_post_reboot = remote_client.get_uptime()
self.assertLess(uptime_post_reboot, (uptime_start + (finish - start)))

13
test_repo/compute/functional/servers/actions/test_reboot_server_soft.py
View File

@@ -17,6 +17,7 @@ limitations under the License.
import time
from cafe.drivers.unittest.decorators import tags
from cloudcafe.compute.common.datagen import rand_name
from cloudcafe.compute.common.types import NovaServerRebootTypes
from test_repo.compute.fixtures import ComputeFixture
@@ -26,7 +27,8 @@ class RebootServerSoftTests(ComputeFixture):
@classmethod
def setUpClass(cls):
super(RebootServerSoftTests, cls).setUpClass()
response = cls.server_behaviors.create_active_server()
cls.key = cls.keypairs_client.create_keypair(rand_name("key")).entity
response = cls.server_behaviors.create_active_server(key_name=cls.key.name)
cls.server = response.entity
cls.resources.add(cls.server.id, cls.servers_client.delete_server)
@@ -37,15 +39,14 @@ class RebootServerSoftTests(ComputeFixture):
@tags(type='smoke', net='yes')
def test_reboot_server_soft(self):
""" The server should be signaled to reboot gracefully """
public_address = self.server_behaviors.get_public_ip_address(self.server)
remote_instance = self.server_behaviors.get_remote_instance_client(self.server,
config=self.servers_config)
remote_instance = self.server_behaviors.get_remote_instance_client(
self.server, config=self.servers_config, key=self.key.private_key)
uptime_start = remote_instance.get_uptime()
start = time.time()
self.server_behaviors.reboot_and_await(self.server.id, NovaServerRebootTypes.SOFT)
remote_client = self.server_behaviors.get_remote_instance_client(self.server,
config=self.servers_config)
remote_client = self.server_behaviors.get_remote_instance_client(
self.server, config=self.servers_config, key=self.key.private_key)
finish = time.time()
uptime_post_reboot = remote_client.get_uptime()
self.assertLess(uptime_post_reboot, (uptime_start + (finish - start)))

23
test_repo/compute/functional/servers/actions/test_rebuild_server.py
View File

@@ -33,7 +33,8 @@ class RebuildServerTests(ComputeFixture):
@classmethod
def setUpClass(cls):
super(RebuildServerTests, cls).setUpClass()
response = cls.server_behaviors.create_active_server()
cls.key = cls.keypairs_client.create_keypair(rand_name("key")).entity
response = cls.server_behaviors.create_active_server(key_name=cls.key.name)
cls.server = response.entity
response = cls.flavors_client.get_flavor_details(cls.flavor_ref)
cls.flavor = response.entity
@@ -48,7 +49,7 @@ class RebuildServerTests(ComputeFixture):
cls.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)
admin_pass=cls.password, key_name=cls.key.name)
cls.server_behaviors.wait_for_server_status(
cls.server.id, NovaServerStatusTypes.ACTIVE)
@@ -95,7 +96,8 @@ class RebuildServerTests(ComputeFixture):
public_address = self.server_behaviors.get_public_ip_address(
rebuilt_server)
remote_instance = self.server_behaviors.get_remote_instance_client(
server, config=self.servers_config, password=self.password)
server, config=self.servers_config, password=self.password,
key=self.key.private_key)
self.assertTrue(
remote_instance.can_connect_to_public_ip(),
msg="Could not connect to server (%s) using new admin password %s"
@@ -106,7 +108,8 @@ class RebuildServerTests(ComputeFixture):
"""Verify the number of vCPUs reported is the correct after rebuild"""
remote_client = self.server_behaviors.get_remote_instance_client(
self.server, config=self.servers_config, password=self.password)
self.server, config=self.servers_config, password=self.password,
key=self.key.private_key)
server_actual_vcpus = remote_client.get_number_of_vcpus()
self.assertEqual(
server_actual_vcpus, self.flavor.vcpus,
@@ -117,7 +120,8 @@ class RebuildServerTests(ComputeFixture):
def test_rebuilt_server_disk_size(self):
"""Verify the size of the virtual disk after the server rebuild"""
remote_client = self.server_behaviors.get_remote_instance_client(
self.server, self.servers_config, password=self.password)
self.server, self.servers_config, password=self.password,
key=self.key.private_key)
disk_size = remote_client.get_disk_size_in_gb(
self.servers_config.instance_disk_path)
self.assertEqual(disk_size, self.flavor.disk,
@@ -127,7 +131,8 @@ class RebuildServerTests(ComputeFixture):
@tags(type='smoke', net='yes')
def test_server_ram_after_rebuild(self):
remote_instance = self.server_behaviors.get_remote_instance_client(
self.server, self.servers_config, password=self.password)
self.server, self.servers_config, password=self.password,
key=self.key.private_key)
lower_limit = int(self.flavor.ram) - (int(self.flavor.ram) * .1)
server_ram_size = int(remote_instance.get_ram_size_in_mb())
self.assertTrue((int(self.flavor.ram) == server_ram_size
@@ -145,7 +150,8 @@ class RebuildServerTests(ComputeFixture):
"""
remote_client = self.server_behaviors.get_remote_instance_client(
self.server, self.servers_config, password=self.password)
self.server, self.servers_config, password=self.password,
key=self.key.private_key)
self.assertTrue(remote_client.is_file_present('/rebuild.txt'))
self.assertEqual(
remote_client.get_file_details('/rebuild.txt').content,
@@ -188,7 +194,8 @@ class RebuildServerTests(ComputeFixture):
"""Verify the provided metadata was set for the server"""
remote_client = self.server_behaviors.get_remote_instance_client(
self.server, self.servers_config, password=self.password)
self.server, self.servers_config, password=self.password,
key=self.key.private_key)
xen_meta = remote_client.get_xen_user_metadata()
for key, value in self.metadata.iteritems():
self.assertEqual(xen_meta[key], value)

14
test_repo/compute/functional/servers/actions/test_rescue_server.py
View File

@@ -15,6 +15,7 @@ limitations under the License.
"""
from cafe.drivers.unittest.decorators import tags
from cloudcafe.compute.common.types import InstanceAuthStrategies
from test_repo.compute.fixtures import ComputeFixture
@@ -44,13 +45,15 @@ class ServerRescueTests(ComputeFixture):
msg="The password did not change after Rescue.")
#Enter rescue mode
rescue_server_response = self.server_behaviors.wait_for_server_status(self.server.id, 'RESCUE')
rescue_server_response = self.server_behaviors.wait_for_server_status(
self.server.id, 'RESCUE')
rescue_server = rescue_server_response.entity
rescue_server.admin_pass = changed_password
#Verify if hard drives are attached
remote_client = self.server_behaviors.get_remote_instance_client(rescue_server,
self.servers_config)
remote_client = self.server_behaviors.get_remote_instance_client(
rescue_server, self.servers_config,
auth_strategy=InstanceAuthStrategies.PASSWORD)
partitions = remote_client.get_partition_details()
self.assertEqual(3, len(partitions))
@@ -60,7 +63,8 @@ class ServerRescueTests(ComputeFixture):
msg="The response code while unrescuing a server is %s instead of 202" % rescue_response.status_code)
self.server_behaviors.wait_for_server_status(self.server.id, 'ACTIVE')
remote_client = self.server_behaviors.get_remote_instance_client(self.server,
self.servers_config)
remote_client = self.server_behaviors.get_remote_instance_client(
self.server, self.servers_config,
auth_strategy=InstanceAuthStrategies.PASSWORD)
partitions = remote_client.get_partition_details()
self.assertEqual(2, len(partitions), msg="The number of partitions after unrescue were not two.")

20
test_repo/compute/functional/servers/actions/test_resize_server_confirm.py
View File

@@ -17,6 +17,7 @@ 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.types import NovaServerStatusTypes
from test_repo.compute.fixtures import ComputeFixture
@@ -26,7 +27,8 @@ class ResizeServerUpConfirmTests(ComputeFixture):
@classmethod
def setUpClass(cls):
super(ResizeServerUpConfirmTests, cls).setUpClass()
server_response = cls.server_behaviors.create_active_server()
cls.key = cls.keypairs_client.create_keypair(rand_name("key")).entity
server_response = cls.server_behaviors.create_active_server(key_name=cls.key.name)
server_to_resize = server_response.entity
cls.resources.add(server_to_resize.id, cls.servers_client.delete_server)
@@ -62,8 +64,8 @@ class ResizeServerUpConfirmTests(ComputeFixture):
def test_resized_server_vcpus(self):
"""Verify the number of vCPUs is modified to the value of the new flavor"""
remote_client = self.server_behaviors.get_remote_instance_client(self.server,
config=self.servers_config)
remote_client = self.server_behaviors.get_remote_instance_client(
self.server, config=self.servers_config, key=self.key.private_key)
server_actual_vcpus = remote_client.get_number_of_vcpus()
self.assertEqual(server_actual_vcpus, self.resized_flavor.vcpus,
msg="Expected number of vcpus to be {0}, was {1}.".format(
@@ -72,8 +74,8 @@ class ResizeServerUpConfirmTests(ComputeFixture):
@tags(type='smoke', net='yes')
def test_created_server_disk_size(self):
"""Verify the size of the virtual disk matches that of the new flavor"""
remote_client = self.server_behaviors.get_remote_instance_client(self.server,
config=self.servers_config)
remote_client = self.server_behaviors.get_remote_instance_client(
self.server, config=self.servers_config, key=self.key.private_key)
disk_size = remote_client.get_disk_size_in_gb(self.servers_config.instance_disk_path)
self.assertEqual(disk_size, self.resized_flavor.disk,
msg="Expected disk to be {0} GB, was {1} GB".format(
@@ -82,8 +84,8 @@ class ResizeServerUpConfirmTests(ComputeFixture):
@tags(type='smoke', net='yes')
def test_can_log_into_resized_server(self):
"""Tests that we can log into the created server after resizing"""
remote_client = self.server_behaviors.get_remote_instance_client(self.server,
config=self.servers_config)
remote_client = self.server_behaviors.get_remote_instance_client(
self.server, config=self.servers_config, key=self.key.private_key)
self.assertTrue(remote_client.can_connect_to_public_ip(),
msg="Cannot connect to server using public ip")
@@ -91,8 +93,8 @@ class ResizeServerUpConfirmTests(ComputeFixture):
def test_server_ram_after_resize(self):
"""The server's RAM and should be modified to that of the new flavor"""
remote_instance = self.server_behaviors.get_remote_instance_client(self.server,
self.servers_config)
remote_instance = self.server_behaviors.get_remote_instance_client(
self.server, self.servers_config, key=self.key.private_key)
lower_limit = int(self.resized_flavor.ram) - (int(self.resized_flavor.ram) * .1)
server_ram_size = int(remote_instance.get_ram_size_in_mb())
self.assertTrue(int(self.resized_flavor.ram) == server_ram_size or lower_limit <= server_ram_size,

22
test_repo/compute/functional/servers/actions/test_resize_server_down.py
View File

@@ -17,6 +17,7 @@ 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.types import NovaServerStatusTypes
from test_repo.compute.fixtures import ComputeFixture
@@ -26,8 +27,9 @@ class ResizeServerDownConfirmTests(ComputeFixture):
@classmethod
def setUpClass(cls):
super(ResizeServerDownConfirmTests, cls).setUpClass()
cls.key = cls.keypairs_client.create_keypair(rand_name("key")).entity
server_response = cls.server_behaviors.create_active_server(
flavor_ref=cls.flavor_ref_alt)
flavor_ref=cls.flavor_ref_alt, key_name=cls.key.name)
server_to_resize = server_response.entity
cls.resources.add(server_to_resize.id, cls.servers_client.delete_server)
@@ -53,14 +55,14 @@ class ResizeServerDownConfirmTests(ComputeFixture):
@tags(type='positive', net='no')
def test_server_properties_after_resize(self):
self.assertEqual(self.flavor_ref_alt, self.server.flavor.id)
self.assertEqual(self.server.flavor.id, self.resized_flavor.id)
@tags(type='positive', net='yes')
def test_resized_server_vcpus(self):
"""Verify the number of vCPUs is modified to the value of the new flavor"""
remote_client = self.server_behaviors.get_remote_instance_client(self.server,
config=self.servers_config)
remote_client = self.server_behaviors.get_remote_instance_client(
self.server, config=self.servers_config, key=self.key.private_key)
server_actual_vcpus = remote_client.get_number_of_vcpus()
self.assertEqual(server_actual_vcpus, self.resized_flavor.vcpus,
msg="Expected number of vcpus to be {0}, was {1}.".format(
@@ -69,8 +71,8 @@ class ResizeServerDownConfirmTests(ComputeFixture):
@tags(type='positive', net='yes')
def test_created_server_disk_size(self):
"""Verify the size of the virtual disk matches that of the new flavor"""
remote_client = self.server_behaviors.get_remote_instance_client(self.server,
config=self.servers_config)
remote_client = self.server_behaviors.get_remote_instance_client(
self.server, config=self.servers_config, key=self.key.private_key)
disk_size = remote_client.get_disk_size_in_gb(self.servers_config.instance_disk_path)
self.assertEqual(disk_size, self.resized_flavor.disk,
msg="Expected disk to be {0} GB, was {1} GB".format(
@@ -79,8 +81,8 @@ class ResizeServerDownConfirmTests(ComputeFixture):
@tags(type='positive', net='yes')
def test_can_log_into_resized_server(self):
"""Tests that we can log into the created server after resizing"""
remote_client = self.server_behaviors.get_remote_instance_client(self.server,
config=self.servers_config)
remote_client = self.server_behaviors.get_remote_instance_client(
self.server, config=self.servers_config, key=self.key.private_key)
self.assertTrue(remote_client.can_connect_to_public_ip(),
msg="Cannot connect to server using public ip")
@@ -88,8 +90,8 @@ class ResizeServerDownConfirmTests(ComputeFixture):
def test_server_ram_after_resize(self):
"""The server's RAM and should be modified to that of the new flavor"""
remote_instance = self.server_behaviors.get_remote_instance_client(self.server,
self.servers_config)
remote_instance = self.server_behaviors.get_remote_instance_client(
self.server, self.servers_config, key=self.key.private_key)
lower_limit = int(self.resized_flavor.ram) - (int(self.resized_flavor.ram) * .1)
server_ram_size = int(remote_instance.get_ram_size_in_mb())
self.assertTrue(int(self.resized_flavor.ram) == server_ram_size or lower_limit <= server_ram_size,

41
test_repo/compute/functional/servers/actions/test_resize_server_revert.py
View File

@@ -17,6 +17,7 @@ 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.types import NovaServerStatusTypes
from test_repo.compute.fixtures import ComputeFixture
@@ -26,24 +27,29 @@ class ResizeServerUpRevertTests(ComputeFixture):
@classmethod
def setUpClass(cls):
super(ResizeServerUpRevertTests, cls).setUpClass()
server_response = cls.server_behaviors.create_active_server()
cls.key = cls.keypairs_client.create_keypair(rand_name("key")).entity
server_response = cls.server_behaviors.create_active_server(
key_name=cls.key.name)
server_to_resize = server_response.entity
cls.resources.add(server_to_resize.id, cls.servers_client.delete_server)
cls.resources.add(
server_to_resize.id, cls.servers_client.delete_server)
# resize server and confirm
cls.resize_resp = cls.servers_client.resize(
server_to_resize.id, cls.flavor_ref_alt)
cls.server_behaviors.wait_for_server_status(server_to_resize.id,
NovaServerStatusTypes.VERIFY_RESIZE)
cls.server_behaviors.wait_for_server_status(
server_to_resize.id, NovaServerStatusTypes.VERIFY_RESIZE)
cls.revert_resize_resp = cls.servers_client.revert_resize(
server_to_resize.id)
cls.server_behaviors.wait_for_server_status(server_to_resize.id,
NovaServerStatusTypes.ACTIVE)
resized_server_response = cls.servers_client.get_server(server_to_resize.id)
cls.server_behaviors.wait_for_server_status(
server_to_resize.id, NovaServerStatusTypes.ACTIVE)
resized_server_response = cls.servers_client.get_server(
server_to_resize.id)
cls.server = resized_server_response.entity
cls.server.admin_pass = server_to_resize.admin_pass
cls.flavor = cls.flavors_client.get_flavor_details(cls.flavor_ref).entity
cls.flavor = cls.flavors_client.get_flavor_details(
cls.flavor_ref).entity
@classmethod
def tearDownClass(cls):
@@ -57,8 +63,8 @@ class ResizeServerUpRevertTests(ComputeFixture):
def test_resize_reverted_server_vcpus(self):
"""Verify the number of vCPUs reported matches the amount set by the original flavor"""
remote_client = self.server_behaviors.get_remote_instance_client(self.server,
config=self.servers_config)
remote_client = self.server_behaviors.get_remote_instance_client(
self.server, config=self.servers_config, key=self.key.private_key)
server_actual_vcpus = remote_client.get_number_of_vcpus()
self.assertEqual(server_actual_vcpus, self.flavor.vcpus,
msg="Expected number of vcpus to be {0}, was {1}.".format(
@@ -67,9 +73,10 @@ class ResizeServerUpRevertTests(ComputeFixture):
@tags(type='smoke', net='yes')
def test_resize_reverted_server_disk_size(self):
"""Verify the size of the virtual disk matches the size set by the original flavor"""
remote_client = self.server_behaviors.get_remote_instance_client(self.server,
config=self.servers_config)
disk_size = remote_client.get_disk_size_in_gb(self.servers_config.instance_disk_path)
remote_client = self.server_behaviors.get_remote_instance_client(
self.server, config=self.servers_config, key=self.key.private_key)
disk_size = remote_client.get_disk_size_in_gb(
self.servers_config.instance_disk_path)
self.assertEqual(disk_size, self.flavor.disk,
msg="Expected disk to be {0} GB, was {1} GB".format(
self.flavor.disk, disk_size))
@@ -77,8 +84,8 @@ class ResizeServerUpRevertTests(ComputeFixture):
@tags(type='smoke', net='yes')
def test_can_log_into_resize_reverted_server(self):
"""Tests that we can log into the created server after reverting the resize"""
remote_client = self.server_behaviors.get_remote_instance_client(self.server,
config=self.servers_config)
remote_client = self.server_behaviors.get_remote_instance_client(
self.server, config=self.servers_config, key=self.key.private_key)
self.assertTrue(remote_client.can_connect_to_public_ip(),
msg="Cannot connect to server using public ip")
@@ -86,8 +93,8 @@ class ResizeServerUpRevertTests(ComputeFixture):
def test_ram_after_resize_revert(self):
"""The server's RAM should still be set to the amount from the original flavor"""
remote_instance = self.server_behaviors.get_remote_instance_client(self.server,
self.servers_config)
remote_instance = self.server_behaviors.get_remote_instance_client(
self.server, self.servers_config, key=self.key.private_key)
lower_limit = int(self.flavor.ram) - (int(self.flavor.ram) * .1)
server_ram_size = int(remote_instance.get_ram_size_in_mb())
self.assertTrue(int(self.flavor.ram) == server_ram_size or lower_limit <= server_ram_size,

19
test_repo/compute/functional/servers/test_create_server.py
View File

@@ -39,9 +39,10 @@ class CreateServerTest(ComputeFixture):
cls.file_contents = 'This is a test file.'
files = [{'path': '/test.txt', 'contents': base64.b64encode(
cls.file_contents)}]
cls.key = cls.keypairs_client.create_keypair(rand_name("key")).entity
cls.create_resp = cls.servers_client.create_server(
cls.name, cls.image_ref, cls.flavor_ref,
metadata=cls.metadata, personality=files)
cls.name, cls.image_ref, cls.flavor_ref, metadata=cls.metadata,
personality=files, key_name=cls.key.name)
created_server = cls.create_resp.entity
cls.resources.add(created_server.id,
cls.servers_client.delete_server)
@@ -124,7 +125,7 @@ class CreateServerTest(ComputeFixture):
"""
remote_client = self.server_behaviors.get_remote_instance_client(
self.server, self.servers_config)
self.server, self.servers_config, key=self.key.private_key)
server_actual_vcpus = remote_client.get_number_of_vcpus()
self.assertEqual(
server_actual_vcpus, self.flavor.vcpus,
@@ -138,7 +139,7 @@ class CreateServerTest(ComputeFixture):
set by the flavor
"""
remote_client = self.server_behaviors.get_remote_instance_client(
self.server, self.servers_config)
self.server, self.servers_config, key=self.key.private_key)
disk_size = remote_client.get_disk_size_in_gb(
self.servers_config.instance_disk_path)
self.assertEqual(disk_size, self.flavor.disk,
@@ -153,7 +154,7 @@ class CreateServerTest(ComputeFixture):
"""
remote_instance = self.server_behaviors.get_remote_instance_client(
self.server, self.servers_config)
self.server, self.servers_config, key=self.key.private_key)
lower_limit = int(self.flavor.ram) - (int(self.flavor.ram) * .1)
server_ram_size = int(remote_instance.get_ram_size_in_mb())
self.assertTrue(
@@ -170,7 +171,7 @@ class CreateServerTest(ComputeFixture):
the server name
"""
remote_client = self.server_behaviors.get_remote_instance_client(
self.server, self.servers_config)
self.server, self.servers_config, key=self.key.private_key)
hostname = remote_client.get_hostname()
self.assertEqual(hostname, self.name,
msg="Expected hostname to be {0}, was {1}".format(
@@ -180,7 +181,7 @@ class CreateServerTest(ComputeFixture):
def test_can_log_into_created_server(self):
"""Validate that the server instance can be accessed"""
remote_client = self.server_behaviors.get_remote_instance_client(
self.server, self.servers_config)
self.server, self.servers_config, key=self.key.private_key)
self.assertTrue(remote_client.can_connect_to_public_ip(),
msg="Cannot connect to server using public ip")
@@ -192,7 +193,7 @@ class CreateServerTest(ComputeFixture):
"""
remote_client = self.server_behaviors.get_remote_instance_client(
self.server, self.servers_config)
self.server, self.servers_config, key=self.key.private_key)
self.assertTrue(remote_client.is_file_present('/test.txt'))
self.assertEqual(
remote_client.get_file_details('/test.txt').content,
@@ -236,7 +237,7 @@ class CreateServerTest(ComputeFixture):
"""Verify the provided metadata was set for the server"""
remote_client = self.server_behaviors.get_remote_instance_client(
self.server, self.servers_config)
self.server, self.servers_config, key=self.key.private_key)
xen_meta = remote_client.get_xen_user_metadata()
for key, value in self.metadata.iteritems():
self.assertEqual(xen_meta[key], value)