openstack
/
tempest
Code Issues Proposed changes

Migrate scenario tests ssh-auth-strategy 

Migrate the scenario tests to the new ssh-auth-strategy.

Partially implements: blueprint ssh-auth-strategy

Change-Id: I50759d32e47d975ec64ca129a13b2ae4459917e4
This commit is contained in:
lanoux 2015-09-21 08:17:35 +00:00 committed by lanoux
parent ee627bee90
commit 5fc14522c6
15 changed files with 176 additions and 218 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

202
tempest/scenario/manager.py
View File

@ -23,7 +23,7 @@ import six
from tempest_lib.common.utils import misc as misc_utils
from tempest_lib import exceptions as lib_exc
from tempest.common import fixed_network
from tempest.common import compute
from tempest.common.utils import data_utils
from tempest.common.utils.linux import remote_client
from tempest.common import waiters
@ -158,52 +158,100 @@ class ScenarioTest(tempest.test.BaseTestCase):
return body['keypair']
def create_server(self, name=None, image=None, flavor=None,
wait_on_boot=True, wait_on_delete=True,
create_kwargs=None):
"""Creates VM instance.
validatable=False, wait_until=None,
wait_on_delete=True, clients=None, **kwargs):
"""Wrapper utility that returns a test server.
@param image: image from which to create the instance
@param wait_on_boot: wait for status ACTIVE before continue
@param wait_on_delete: force synchronous delete on cleanup
@param create_kwargs: additional details for instance creation
@return: server dict
This wrapper utility calls the common create test server and
returns a test server. The purpose of this wrapper is to minimize
the impact on the code of the tests already using this
function.
"""
if name is None:
name = data_utils.rand_name(self.__class__.__name__)
if image is None:
image = CONF.compute.image_ref
if flavor is None:
flavor = CONF.compute.flavor_ref
if create_kwargs is None:
create_kwargs = {}
network = self.get_tenant_network()
create_kwargs = fixed_network.set_networks_kwarg(network,
create_kwargs)
LOG.debug("Creating a server (name: %s, image: %s, flavor: %s)",
name, image, flavor)
server = self.servers_client.create_server(name=name, imageRef=image,
flavorRef=flavor,
**create_kwargs)['server']
# NOTE(jlanoux): As a first step, ssh checks in the scenario
# tests need to be run regardless of the run_validation and
# validatable parameters and thus until the ssh validation job
# becomes voting in CI. The test resources management and IP
# association are taken care of in the scenario tests.
# Therefore, the validatable parameter is set to false in all
# those tests. In this way create_server just return a standard
# server and the scenario tests always perform ssh checks.
# Needed for the cross_tenant_traffic test:
if clients is None:
clients = self.manager
vnic_type = CONF.network.port_vnic_type
# If vnic_type is configured create port for
# every network
if vnic_type:
ports = []
networks = []
create_port_body = {'binding:vnic_type': vnic_type,
'namestart': 'port-smoke'}
if kwargs:
# Convert security group names to security group ids
# to pass to create_port
if 'security_groups' in kwargs:
security_groups =\
clients.network_client.list_security_groups(
).get('security_groups')
sec_dict = dict([(s['name'], s['id'])
for s in security_groups])
sec_groups_names = [s['name'] for s in kwargs.pop(
'security_groups')]
security_groups_ids = [sec_dict[s]
for s in sec_groups_names]
if security_groups_ids:
create_port_body[
'security_groups'] = security_groups_ids
networks = kwargs.pop('networks')
# If there are no networks passed to us we look up
# for the tenant's private networks and create a port
# if there is only one private network. The same behaviour
# as we would expect when passing the call to the clients
# with no networks
if not networks:
networks = clients.networks_client.list_networks(
filters={'router:external': False})
self.assertEqual(1, len(networks),
"There is more than one"
" network for the tenant")
for net in networks:
net_id = net['uuid']
port = self._create_port(network_id=net_id,
client=clients.ports_client,
**create_port_body)
ports.append({'port': port.id})
if ports:
kwargs['networks'] = ports
self.ports = ports
tenant_network = self.get_tenant_network()
body, servers = compute.create_test_server(
clients,
tenant_network=tenant_network,
wait_until=wait_until,
**kwargs)
# TODO(jlanoux) Move wait_on_delete in compute.py
if wait_on_delete:
self.addCleanup(waiters.wait_for_server_termination,
self.servers_client,
server['id'])
clients.servers_client,
body['id'])
self.addCleanup_with_wait(
waiter_callable=waiters.wait_for_server_termination,
thing_id=server['id'], thing_id_param='server_id',
thing_id=body['id'], thing_id_param='server_id',
cleanup_callable=self.delete_wrapper,
cleanup_args=[self.servers_client.delete_server, server['id']],
waiter_client=self.servers_client)
if wait_on_boot:
waiters.wait_for_server_status(self.servers_client,
server_id=server['id'],
status='ACTIVE')
# The instance retrieved on creation is missing network
# details, necessitating retrieval after it becomes active to
# ensure correct details.
server = self.servers_client.show_server(server['id'])['server']
self.assertEqual(server['name'], name)
cleanup_args=[clients.servers_client.delete_server, body['id']],
waiter_client=clients.servers_client)
server = clients.servers_client.show_server(body['id'])['server']
return server
def create_volume(self, size=None, name=None, snapshot_id=None,
@ -321,7 +369,7 @@ class ScenarioTest(tempest.test.BaseTestCase):
username = CONF.scenario.ssh_user
# Set this with 'keypair' or others to log in with keypair or
# username/password.
if CONF.compute.ssh_auth_method == 'keypair':
if CONF.validation.auth_method == 'keypair':
password = None
if private_key is None:
private_key = self.keypair['private_key']
@ -491,7 +539,7 @@ class ScenarioTest(tempest.test.BaseTestCase):
def ping_ip_address(self, ip_address, should_succeed=True,
ping_timeout=None):
timeout = ping_timeout or CONF.compute.ping_timeout
timeout = ping_timeout or CONF.validation.ping_timeout
cmd = ['ping', '-c1', '-w1', ip_address]
def ping():
@ -884,7 +932,7 @@ class NetworkScenarioTest(ScenarioTest):
return should_succeed
return tempest.test.call_until_true(ping_remote,
CONF.compute.ping_timeout,
CONF.validation.ping_timeout,
1)
def _create_security_group(self, client=None, tenant_id=None,
@ -1135,71 +1183,6 @@ class NetworkScenarioTest(ScenarioTest):
subnet.add_to_router(router.id)
return network, subnet, router
def create_server(self, name=None, image=None, flavor=None,
wait_on_boot=True, wait_on_delete=True,
network_client=None, networks_client=None,
ports_client=None, create_kwargs=None):
if network_client is None:
network_client = self.network_client
if networks_client is None:
networks_client = self.networks_client
if ports_client is None:
ports_client = self.ports_client
vnic_type = CONF.network.port_vnic_type
# If vnic_type is configured create port for
# every network
if vnic_type:
ports = []
networks = []
create_port_body = {'binding:vnic_type': vnic_type,
'namestart': 'port-smoke'}
if create_kwargs:
# Convert security group names to security group ids
# to pass to create_port
if create_kwargs.get('security_groups'):
security_groups = network_client.list_security_groups(
).get('security_groups')
sec_dict = dict([(s['name'], s['id'])
for s in security_groups])
sec_groups_names = [s['name'] for s in create_kwargs.get(
'security_groups')]
security_groups_ids = [sec_dict[s]
for s in sec_groups_names]
if security_groups_ids:
create_port_body[
'security_groups'] = security_groups_ids
networks = create_kwargs.get('networks')
# If there are no networks passed to us we look up
# for the tenant's private networks and create a port
# if there is only one private network. The same behaviour
# as we would expect when passing the call to the clients
# with no networks
if not networks:
networks = networks_client.list_networks(filters={
'router:external': False})
self.assertEqual(1, len(networks),
"There is more than one"
" network for the tenant")
for net in networks:
net_id = net['uuid']
port = self._create_port(network_id=net_id,
client=ports_client,
**create_port_body)
ports.append({'port': port.id})
if ports:
create_kwargs['networks'] = ports
self.ports = ports
return super(NetworkScenarioTest, self).create_server(
name=name, image=image, flavor=flavor,
wait_on_boot=wait_on_boot, wait_on_delete=wait_on_delete,
create_kwargs=create_kwargs)
# power/provision states as of icehouse
class BaremetalPowerStates(object):
@ -1322,11 +1305,8 @@ class BaremetalScenarioTest(ScenarioTest):
dest.validate_authentication()
def boot_instance(self):
create_kwargs = {
'key_name': self.keypair['name']
}
self.instance = self.create_server(
wait_on_boot=False, create_kwargs=create_kwargs)
key_name=self.keypair['name'])
self.wait_node(self.instance['id'])
self.node = self.get_node(instance_id=self.instance['id'])

2
tempest/scenario/test_baremetal_basic_ops.py
View File

@ -113,7 +113,7 @@ class BaremetalBasicOps(manager.BaremetalScenarioTest):
self.boot_instance()
self.validate_ports()
self.verify_connectivity()
if CONF.compute.ssh_connect_method == 'floating':
if CONF.validation.connect_method == 'floating':
floating_ip = self.create_floating_ip(self.instance)['ip']
self.verify_connectivity(ip=floating_ip)

5
tempest/scenario/test_encrypted_cinder_volumes.py
View File

@ -45,8 +45,9 @@ class TestEncryptedCinderVolumes(manager.EncryptionScenarioTest):
image = self.glance_image_create()
keypair = self.create_keypair()
return self.create_server(image=image,
create_kwargs={'key_name': keypair['name']})
return self.create_server(image_id=image,
key_name=keypair['name'],
wait_until='ACTIVE')
def create_encrypted_volume(self, encryption_provider, volume_type):
volume_type = self.create_volume_type(name=volume_type)

6
tempest/scenario/test_minimum_basic.py
View File

@ -117,9 +117,9 @@ class TestMinimumBasicScenario(manager.ScenarioTest):
image = self.glance_image_create()
keypair = self.create_keypair()
create_kwargs = {'key_name': keypair['name']}
server = self.create_server(image=image,
create_kwargs=create_kwargs)
server = self.create_server(image_id=image,
key_name=keypair['name'],
wait_until='ACTIVE')
servers = self.nova_list()
self.assertIn(server['id'], [x['id'] for x in servers])

15
tempest/scenario/test_network_advanced_server_ops.py
View File

@ -57,16 +57,13 @@ class TestNetworkAdvancedServerOps(manager.NetworkScenarioTest):
security_group = self._create_security_group()
network, subnet, router = self.create_networks()
public_network_id = CONF.network.public_network_id
create_kwargs = {
'networks': [
{'uuid': network.id},
],
'key_name': keypair['name'],
'security_groups': [{'name': security_group['name']}],
}
server_name = data_utils.rand_name('server-smoke')
server = self.create_server(name=server_name,
create_kwargs=create_kwargs)
server = self.create_server(
name=server_name,
networks=[{'uuid': network.id}],
key_name=keypair['name'],
security_groups=[{'name': security_group['name']}],
wait_until='ACTIVE')
floating_ip = self.create_floating_ip(server, public_network_id)
# Verify that we can indeed connect to the server before we mess with
# it's state

18
tempest/scenario/test_network_basic_ops.py
View File

@ -155,16 +155,16 @@ class TestNetworkBasicOps(manager.NetworkScenarioTest):
keypair = self.create_keypair()
self.keypairs[keypair['name']] = keypair
security_groups = [{'name': self.security_group['name']}]
create_kwargs = {
'networks': [
{'uuid': network.id},
],
'key_name': keypair['name'],
'security_groups': security_groups,
}
network = {'uuid': network.id}
if port_id is not None:
create_kwargs['networks'][0]['port'] = port_id
server = self.create_server(name=name, create_kwargs=create_kwargs)
network['port'] = port_id
server = self.create_server(
name=name,
networks=[network],
key_name=keypair['name'],
security_groups=security_groups,
wait_until='ACTIVE')
self.servers.append(server)
return server

15
tempest/scenario/test_network_v6.py
View File

@ -65,9 +65,6 @@ class TestGettingAddress(manager.NetworkScenarioTest):
super(TestGettingAddress, self).setUp()
self.keypair = self.create_keypair()
self.sec_grp = self._create_security_group(tenant_id=self.tenant_id)
self.srv_kwargs = {
'key_name': self.keypair['name'],
'security_groups': [{'name': self.sec_grp['name']}]}
def prepare_network(self, address6_mode, n_subnets6=1, dualnet=False):
"""Prepare network
@ -119,11 +116,13 @@ class TestGettingAddress(manager.NetworkScenarioTest):
def prepare_server(self, networks=None):
username = CONF.compute.image_ssh_user
create_kwargs = self.srv_kwargs
networks = networks or [self.network]
create_kwargs['networks'] = [{'uuid': n.id} for n in networks]
srv = self.create_server(create_kwargs=create_kwargs)
srv = self.create_server(
key_name=self.keypair['name'],
security_groups=[{'name': self.sec_grp['name']}],
networks=[{'uuid': n.id} for n in networks],
wait_until='ACTIVE')
fip = self.create_floating_ip(thing=srv)
ips = self.define_server_ips(srv=srv)
ssh = self.get_remote_client(
@ -181,10 +180,10 @@ class TestGettingAddress(manager.NetworkScenarioTest):
guest_has_address, sshv4_2, ips_from_api_2['6'][i])
self.assertTrue(test.call_until_true(srv1_v6_addr_assigned,
CONF.compute.ping_timeout, 1))
CONF.validation.ping_timeout, 1))
self.assertTrue(test.call_until_true(srv2_v6_addr_assigned,
CONF.compute.ping_timeout, 1))
CONF.validation.ping_timeout, 1))
self._check_connectivity(sshv4_1, ips_from_api_2['4'])
self._check_connectivity(sshv4_2, ips_from_api_1['4'])

22
tempest/scenario/test_security_groups_basic_ops.py
View File

@ -234,23 +234,16 @@ class TestSecurityGroupsBasicOps(manager.NetworkScenarioTest):
def _create_server(self, name, tenant, security_groups=None):
"""creates a server and assigns to security group"""
self._set_compute_context(tenant)
if security_groups is None:
security_groups = [tenant.security_groups['default']]
security_groups_names = [{'name': s['name']} for s in security_groups]
create_kwargs = {
'networks': [
{'uuid': tenant.network.id},
],
'key_name': tenant.keypair['name'],
'security_groups': security_groups_names
}
server = self.create_server(
name=name,
network_client=tenant.manager.network_client,
networks_client=tenant.manager.networks_client,
ports_client=tenant.manager.ports_client,
create_kwargs=create_kwargs)
networks=[{'uuid': tenant.network.id}],
key_name=tenant.keypair['name'],
security_groups=security_groups_names,
wait_until='ACTIVE',
clients=tenant.manager)
self.assertEqual(
sorted([s['name'] for s in security_groups]),
sorted([s['name'] for s in server['security_groups']]))
@ -293,10 +286,6 @@ class TestSecurityGroupsBasicOps(manager.NetworkScenarioTest):
subnets_client=tenant.manager.subnets_client)
tenant.set_network(network, subnet, router)
def _set_compute_context(self, tenant):
self.servers_client = tenant.manager.servers_client
return self.servers_client
def _deploy_tenant(self, tenant_or_id):
"""creates:
@ -310,7 +299,6 @@ class TestSecurityGroupsBasicOps(manager.NetworkScenarioTest):
tenant = self.tenants[tenant_or_id]
else:
tenant = tenant_or_id
self._set_compute_context(tenant)
self._create_tenant_keypairs(tenant)
self._create_tenant_network(tenant)
self._create_tenant_security_groups(tenant)

4
tempest/scenario/test_server_advanced_ops.py
View File

@ -53,7 +53,7 @@ class TestServerAdvancedOps(manager.ScenarioTest):
@test.services('compute')
def test_resize_server_confirm(self):
# We create an instance for use in this test
instance = self.create_server()
instance = self.create_server(wait_until='ACTIVE')
instance_id = instance['id']
resize_flavor = CONF.compute.flavor_ref_alt
LOG.debug("Resizing instance %s from flavor %s to flavor %s",
@ -74,7 +74,7 @@ class TestServerAdvancedOps(manager.ScenarioTest):
@test.services('compute')
def test_server_sequence_suspend_resume(self):
# We create an instance for use in this test
instance = self.create_server()
instance = self.create_server(wait_until='ACTIVE')
instance_id = instance['id']
LOG.debug("Suspending instance %s. Current status: %s",
instance_id, instance['status'])

25
tempest/scenario/test_server_basic_ops.py
View File

@ -72,20 +72,6 @@ class TestServerBasicOps(manager.ScenarioTest):
def add_keypair(self):
self.keypair = self.create_keypair()
def boot_instance(self):
# Create server with image and flavor from input scenario
security_groups = [{'name': self.security_group['name']}]
self.md = {'meta1': 'data1', 'meta2': 'data2', 'metaN': 'dataN'}
create_kwargs = {
'key_name': self.keypair['name'],
'security_groups': security_groups,
'config_drive': CONF.compute_feature_enabled.config_drive,
'metadata': self.md
}
self.instance = self.create_server(image=self.image_ref,
flavor=self.flavor_ref,
create_kwargs=create_kwargs)
def verify_ssh(self):
if self.run_ssh:
# Obtain a floating IP
@ -139,7 +125,16 @@ class TestServerBasicOps(manager.ScenarioTest):
def test_server_basicops(self):
self.add_keypair()
self.security_group = self._create_security_group()
self.boot_instance()
security_groups = [{'name': self.security_group['name']}]
self.md = {'meta1': 'data1', 'meta2': 'data2', 'metaN': 'dataN'}
self.instance = self.create_server(
image_id=self.image_ref,
flavor=self.flavor_ref,
key_name=self.keypair['name'],
security_groups=security_groups,
config_drive=CONF.compute_feature_enabled.config_drive,
metadata=self.md,
wait_until='ACTIVE')
self.verify_ssh()
self.verify_metadata()
self.verify_metadata_on_config_drive()

10
tempest/scenario/test_server_multinode.py
View File

@ -60,15 +60,11 @@ class TestServerMultinode(manager.ScenarioTest):
servers = []
for host in hosts[:CONF.compute.min_compute_nodes]:
create_kwargs = {
'availability_zone': '%(zone)s:%(host_name)s' % host
}
# by getting to active state here, this means this has
# landed on the host in question.
inst = self.create_server(image=CONF.compute.image_ref,
flavor=CONF.compute.flavor_ref,
create_kwargs=create_kwargs)
inst = self.create_server(
availability_zone='%(zone)s:%(host_name)s' % host,
wait_until='ACTIVE')
server = self.servers_client.show_server(inst['id'])['server']
servers.append(server)

18
tempest/scenario/test_shelve_instance.py
View File

@ -59,10 +59,6 @@ class TestShelveInstance(manager.ScenarioTest):
security_group = self._create_security_group()
security_groups = [{'name': security_group['name']}]
create_kwargs = {
'key_name': keypair['name'],
'security_groups': security_groups
}
if boot_from_volume:
volume = self.create_volume(size=CONF.volume.volume_size,
@ -72,11 +68,17 @@ class TestShelveInstance(manager.ScenarioTest):
'volume_id': volume['id'],
'delete_on_termination': '0'}]
create_kwargs['block_device_mapping'] = bd_map
server = self.create_server(create_kwargs=create_kwargs)
server = self.create_server(
key_name=keypair['name'],
security_groups=security_groups,
block_device_mapping=bd_map,
wait_until='ACTIVE')
else:
server = self.create_server(image=CONF.compute.image_ref,
create_kwargs=create_kwargs)
server = self.create_server(
image_id=CONF.compute.image_ref,
key_name=keypair['name'],
security_groups=security_groups,
wait_until='ACTIVE')
instance_ip = self.get_server_or_ip(server)
timestamp = self.create_timestamp(instance_ip,

23
tempest/scenario/test_snapshot_pattern.py
View File

@ -36,14 +36,6 @@ class TestSnapshotPattern(manager.ScenarioTest):
"""
def _boot_image(self, image_id, keypair, security_group):
security_groups = [{'name': security_group['name']}]
create_kwargs = {
'key_name': keypair['name'],
'security_groups': security_groups
}
return self.create_server(image=image_id, create_kwargs=create_kwargs)
@test.idempotent_id('608e604b-1d63-4a82-8e3e-91bc665c90b4')
@testtools.skipUnless(CONF.compute_feature_enabled.snapshot,
'Snapshotting is not available.')
@ -54,8 +46,12 @@ class TestSnapshotPattern(manager.ScenarioTest):
security_group = self._create_security_group()
# boot an instance and create a timestamp file in it
server = self._boot_image(CONF.compute.image_ref, keypair,
security_group)
server = self.create_server(
image_id=CONF.compute.image_ref,
key_name=keypair['name'],
security_groups=[{'name': security_group['name']}],
wait_until='ACTIVE')
instance_ip = self.get_server_or_ip(server)
timestamp = self.create_timestamp(instance_ip,
private_key=keypair['private_key'])
@ -64,8 +60,11 @@ class TestSnapshotPattern(manager.ScenarioTest):
snapshot_image = self.create_server_snapshot(server=server)
# boot a second instance from the snapshot
server_from_snapshot = self._boot_image(snapshot_image['id'],
keypair, security_group)
server_from_snapshot = self.create_server(
image_id=snapshot_image['id'],
key_name=keypair['name'],
security_groups=[{'name': security_group['name']}],
wait_until='ACTIVE')
# check the existence of the timestamp file in the second instance
server_from_snapshot_ip = self.get_server_or_ip(server_from_snapshot)

21
tempest/scenario/test_stamp_pattern.py
View File

@ -64,14 +64,6 @@ class TestStampPattern(manager.ScenarioTest):
self.snapshots_client.wait_for_snapshot_status(volume_snapshot['id'],
status)
def _boot_image(self, image_id, keypair, security_group):
security_groups = [{'name': security_group['name']}]
create_kwargs = {
'key_name': keypair['name'],
'security_groups': security_groups
}
return self.create_server(image=image_id, create_kwargs=create_kwargs)
def _create_volume_snapshot(self, volume):
snapshot_name = data_utils.rand_name('scenario-snapshot')
snapshot = self.snapshots_client.create_snapshot(
@ -135,8 +127,11 @@ class TestStampPattern(manager.ScenarioTest):
# boot an instance and create a timestamp file in it
volume = self._create_volume()
server = self._boot_image(CONF.compute.image_ref, keypair,
security_group)
server = self.create_server(
image_id=CONF.compute.image_ref,
key_name=keypair['name'],
security_groups=security_group,
wait_until='ACTIVE')
# create and add floating IP to server1
ip_for_server = self.get_server_or_ip(server)
@ -160,8 +155,10 @@ class TestStampPattern(manager.ScenarioTest):
snapshot_id=volume_snapshot['id'])
# boot second instance from the snapshot(instance2)
server_from_snapshot = self._boot_image(snapshot_image['id'],
keypair, security_group)
server_from_snapshot = self.create_server(
image_id=snapshot_image['id'],
key_name=keypair['name'],
security_groups=security_group)
# create and add floating IP to server_from_snapshot
ip_for_snapshot = self.get_server_or_ip(server_from_snapshot)

8
tempest/scenario/test_volume_boot_pattern.py
View File

@ -69,7 +69,10 @@ class TestVolumeBootPattern(manager.ScenarioTest):
{'name': security_group['name']}]
create_kwargs.update(self._get_bdm(
vol_id, delete_on_termination=delete_on_termination))
return self.create_server(image='', create_kwargs=create_kwargs)
return self.create_server(
image='',
wait_until='ACTIVE',
**create_kwargs)
def _create_snapshot_from_volume(self, vol_id):
snap_name = data_utils.rand_name('snapshot')
@ -158,7 +161,8 @@ class TestVolumeBootPattern(manager.ScenarioTest):
self._delete_server(instance)
# boot instance from EBS image
instance = self.create_server(image=image['id'])
instance = self.create_server(
image_id=image['id'])
# just ensure that instance booted
# delete instance