342 lines
15 KiB
Python
342 lines
15 KiB
Python
# Copyright 2015 Tesora Inc.
|
|
# All Rights Reserved.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
|
# not use this file except in compliance with the License. You may obtain
|
|
# a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
# License for the specific language governing permissions and limitations
|
|
# under the License.
|
|
|
|
from proboscis import SkipTest
|
|
|
|
from trove.tests.config import CONFIG
|
|
from trove.tests.scenario.helpers.test_helper import DataType
|
|
from trove.tests.scenario.runners.test_runners import CheckInstance
|
|
from trove.tests.scenario.runners.test_runners import InstanceTestInfo
|
|
from trove.tests.scenario.runners.test_runners import TestRunner
|
|
|
|
|
|
class InstanceCreateRunner(TestRunner):
|
|
|
|
def __init__(self):
|
|
super(InstanceCreateRunner, self).__init__()
|
|
self.init_inst_info = None
|
|
self.init_inst_dbs = None
|
|
self.init_inst_users = None
|
|
self.init_inst_host = None
|
|
self.init_inst_data = None
|
|
self.init_inst_config_group_id = None
|
|
self.config_group_id = None
|
|
|
|
def run_empty_instance_create(
|
|
self, expected_states=['BUILD', 'ACTIVE'], expected_http_code=200):
|
|
name = self.instance_info.name
|
|
flavor = self.get_instance_flavor()
|
|
volume_size = self.instance_info.volume_size
|
|
|
|
instance_info = self.assert_instance_create(
|
|
name, flavor, volume_size, [], [], None, None,
|
|
CONFIG.dbaas_datastore, CONFIG.dbaas_datastore_version,
|
|
expected_states, expected_http_code, create_helper_user=True,
|
|
locality='affinity')
|
|
|
|
# Update the shared instance info.
|
|
self.instance_info.id = instance_info.id
|
|
self.instance_info.name = instance_info.name
|
|
self.instance_info.databases = instance_info.databases
|
|
self.instance_info.users = instance_info.users
|
|
self.instance_info.dbaas_datastore = instance_info.dbaas_datastore
|
|
self.instance_info.dbaas_datastore_version = (
|
|
instance_info.dbaas_datastore_version)
|
|
self.instance_info.dbaas_flavor_href = instance_info.dbaas_flavor_href
|
|
self.instance_info.volume = instance_info.volume
|
|
self.instance_info.helper_user = instance_info.helper_user
|
|
self.instance_info.helper_database = instance_info.helper_database
|
|
|
|
def run_initial_configuration_create(self, expected_http_code=200):
|
|
group_id, _ = self.create_initial_configuration(expected_http_code)
|
|
if group_id:
|
|
self.config_group_id = group_id
|
|
else:
|
|
raise SkipTest("No groups defined.")
|
|
|
|
def run_initialized_instance_create(
|
|
self, with_dbs=True, with_users=True, configuration_id=None,
|
|
expected_states=['BUILD', 'ACTIVE'], expected_http_code=200,
|
|
create_helper_user=True, name_suffix='_init'):
|
|
if self.is_using_existing_instance:
|
|
# The user requested to run the tests using an existing instance.
|
|
# We therefore skip any scenarios that involve creating new
|
|
# test instances.
|
|
raise SkipTest("Using an existing instance.")
|
|
|
|
configuration_id = configuration_id or self.config_group_id
|
|
name = self.instance_info.name + name_suffix
|
|
flavor = self.get_instance_flavor()
|
|
volume_size = self.instance_info.volume_size
|
|
self.init_inst_dbs = (self.test_helper.get_valid_database_definitions()
|
|
if with_dbs else [])
|
|
self.init_inst_users = (self.test_helper.get_valid_user_definitions()
|
|
if with_users else [])
|
|
self.init_inst_config_group_id = configuration_id
|
|
if (self.init_inst_dbs or self.init_inst_users or configuration_id):
|
|
info = self.assert_instance_create(
|
|
name, flavor, volume_size,
|
|
self.init_inst_dbs, self.init_inst_users,
|
|
configuration_id, None,
|
|
CONFIG.dbaas_datastore, CONFIG.dbaas_datastore_version,
|
|
expected_states, expected_http_code,
|
|
create_helper_user=create_helper_user)
|
|
|
|
self.init_inst_info = info
|
|
else:
|
|
# There is no need to run this test as it's effectively the same as
|
|
# the empty instance test.
|
|
raise SkipTest("No testable initial properties provided.")
|
|
|
|
def assert_instance_create(
|
|
self, name, flavor, trove_volume_size,
|
|
database_definitions, user_definitions,
|
|
configuration_id, root_password, datastore, datastore_version,
|
|
expected_states, expected_http_code, create_helper_user=False,
|
|
locality=None):
|
|
"""This assert method executes a 'create' call and verifies the server
|
|
response. It neither waits for the instance to become available
|
|
nor it performs any other validations itself.
|
|
It has been designed this way to increase test granularity
|
|
(other tests may run while the instance is building) and also to allow
|
|
its reuse in other runners.
|
|
"""
|
|
databases = database_definitions
|
|
users = [{'name': item['name'], 'password': item['password']}
|
|
for item in user_definitions]
|
|
|
|
instance_info = InstanceTestInfo()
|
|
|
|
# Here we add helper user/database if any.
|
|
if create_helper_user:
|
|
helper_db_def, helper_user_def, root_def = self.build_helper_defs()
|
|
if helper_db_def:
|
|
self.report.log(
|
|
"Appending a helper database '%s' to the instance "
|
|
"definition." % helper_db_def['name'])
|
|
databases.append(helper_db_def)
|
|
instance_info.helper_database = helper_db_def
|
|
if helper_user_def:
|
|
self.report.log(
|
|
"Appending a helper user '%s:%s' to the instance "
|
|
"definition."
|
|
% (helper_user_def['name'], helper_user_def['password']))
|
|
users.append(helper_user_def)
|
|
instance_info.helper_user = helper_user_def
|
|
|
|
instance_info.name = name
|
|
instance_info.databases = databases
|
|
instance_info.users = users
|
|
instance_info.dbaas_datastore = CONFIG.dbaas_datastore
|
|
instance_info.dbaas_datastore_version = CONFIG.dbaas_datastore_version
|
|
instance_info.dbaas_flavor_href = self.get_flavor_href(flavor)
|
|
if self.VOLUME_SUPPORT:
|
|
instance_info.volume = {'size': trove_volume_size}
|
|
else:
|
|
instance_info.volume = None
|
|
instance_info.nics = self.instance_info.nics
|
|
|
|
self.report.log("Testing create instance: %s"
|
|
% {'name': name,
|
|
'flavor': flavor.id,
|
|
'volume': trove_volume_size,
|
|
'nics': instance_info.nics,
|
|
'databases': databases,
|
|
'users': users,
|
|
'configuration': configuration_id,
|
|
'root password': root_password,
|
|
'datastore': datastore,
|
|
'datastore version': datastore_version})
|
|
|
|
instance = self.get_existing_instance()
|
|
if instance:
|
|
self.report.log("Using an existing instance: %s" % instance.id)
|
|
self.assert_equal(expected_states[-1], instance.status,
|
|
"Given instance is in a bad state.")
|
|
instance_info.name = instance.name
|
|
else:
|
|
self.report.log("Creating a new instance.")
|
|
client = self.auth_client
|
|
instance = client.instances.create(
|
|
instance_info.name,
|
|
instance_info.dbaas_flavor_href,
|
|
instance_info.volume,
|
|
instance_info.databases,
|
|
instance_info.users,
|
|
nics=instance_info.nics,
|
|
configuration=configuration_id,
|
|
availability_zone="nova",
|
|
datastore=instance_info.dbaas_datastore,
|
|
datastore_version=instance_info.dbaas_datastore_version,
|
|
locality=locality)
|
|
self.assert_client_code(client, expected_http_code)
|
|
self.assert_instance_action(instance.id, expected_states[0:1])
|
|
self.register_debug_inst_ids(instance.id)
|
|
|
|
instance_info.id = instance.id
|
|
|
|
with CheckInstance(instance._info) as check:
|
|
check.flavor()
|
|
check.datastore()
|
|
check.links(instance._info['links'])
|
|
if self.VOLUME_SUPPORT:
|
|
check.volume()
|
|
self.assert_equal(trove_volume_size,
|
|
instance._info['volume']['size'],
|
|
"Unexpected Trove volume size")
|
|
|
|
self.assert_equal(instance_info.name, instance._info['name'],
|
|
"Unexpected instance name")
|
|
self.assert_equal(flavor.id,
|
|
int(instance._info['flavor']['id']),
|
|
"Unexpected instance flavor")
|
|
self.assert_equal(instance_info.dbaas_datastore,
|
|
instance._info['datastore']['type'],
|
|
"Unexpected instance datastore version")
|
|
self.assert_equal(instance_info.dbaas_datastore_version,
|
|
instance._info['datastore']['version'],
|
|
"Unexpected instance datastore version")
|
|
self.assert_configuration_group(instance_info.id, configuration_id)
|
|
if locality:
|
|
self.assert_equal(locality, instance._info['locality'],
|
|
"Unexpected locality")
|
|
|
|
return instance_info
|
|
|
|
def run_wait_for_instance(
|
|
self, expected_states=['BUILD', 'ACTIVE']):
|
|
instances = [self.instance_info.id]
|
|
self.assert_all_instance_states(instances, expected_states)
|
|
self.instance_info.srv_grp_id = self.assert_server_group_exists(
|
|
self.instance_info.id)
|
|
self.wait_for_test_helpers(self.instance_info)
|
|
|
|
def run_wait_for_init_instance(
|
|
self, expected_states=['BUILD', 'ACTIVE']):
|
|
if self.init_inst_info:
|
|
instances = [self.init_inst_info.id]
|
|
self.assert_all_instance_states(instances, expected_states)
|
|
self.wait_for_test_helpers(self.init_inst_info)
|
|
|
|
def wait_for_test_helpers(self, inst_info):
|
|
self.report.log("Waiting for helper users and databases to be "
|
|
"created on instance: %s" % inst_info.id)
|
|
client = self.auth_client
|
|
if inst_info.helper_user:
|
|
self.wait_for_user_create(client, inst_info.id,
|
|
[inst_info.helper_user])
|
|
if inst_info.helper_database:
|
|
self.wait_for_database_create(client, inst_info.id,
|
|
[inst_info.helper_database])
|
|
self.report.log("Test helpers are ready.")
|
|
|
|
def run_add_initialized_instance_data(self):
|
|
if self.init_inst_info:
|
|
self.init_inst_data = DataType.small
|
|
self.init_inst_host = self.get_instance_host(
|
|
self.init_inst_info.id)
|
|
self.test_helper.add_data(self.init_inst_data, self.init_inst_host)
|
|
|
|
def run_validate_initialized_instance(self):
|
|
if self.init_inst_info:
|
|
self.assert_instance_properties(
|
|
self.init_inst_info.id, self.init_inst_dbs,
|
|
self.init_inst_users, self.init_inst_config_group_id,
|
|
self.init_inst_data)
|
|
|
|
def assert_instance_properties(
|
|
self, instance_id, expected_dbs_definitions,
|
|
expected_user_definitions, expected_config_group_id,
|
|
expected_data_type):
|
|
if expected_dbs_definitions:
|
|
self.assert_database_list(instance_id, expected_dbs_definitions)
|
|
else:
|
|
self.report.log("No databases to validate for instance: %s"
|
|
% instance_id)
|
|
if expected_user_definitions:
|
|
self.assert_user_list(instance_id, expected_user_definitions)
|
|
else:
|
|
self.report.log("No users to validate for instance: %s"
|
|
% instance_id)
|
|
self.assert_configuration_group(instance_id, expected_config_group_id)
|
|
|
|
if self.init_inst_host:
|
|
self.test_helper.verify_data(
|
|
expected_data_type, self.init_inst_host)
|
|
else:
|
|
self.report.log("No data to validate for instance: %s"
|
|
% instance_id)
|
|
|
|
def assert_configuration_group(self, instance_id, expected_group_id):
|
|
instance = self.get_instance(instance_id)
|
|
if expected_group_id:
|
|
self.assert_equal(expected_group_id, instance.configuration['id'],
|
|
"Wrong configuration group attached")
|
|
else:
|
|
self.assert_false(hasattr(instance, 'configuration'),
|
|
"No configuration group expected")
|
|
|
|
def assert_database_list(self, instance_id, expected_databases):
|
|
self.wait_for_database_create(self.auth_client,
|
|
instance_id, expected_databases)
|
|
|
|
def _get_names(self, definitions):
|
|
return [item['name'] for item in definitions]
|
|
|
|
def assert_user_list(self, instance_id, expected_users):
|
|
self.wait_for_user_create(self.auth_client,
|
|
instance_id, expected_users)
|
|
# Verify that user definitions include only created databases.
|
|
all_databases = self._get_names(
|
|
self.test_helper.get_valid_database_definitions())
|
|
for user in expected_users:
|
|
if 'databases' in user:
|
|
self.assert_is_sublist(
|
|
self._get_names(user['databases']), all_databases,
|
|
"Definition of user '%s' specifies databases not included "
|
|
"in the list of initial databases." % user['name'])
|
|
|
|
def run_initialized_instance_delete(self, expected_http_code=202):
|
|
if self.init_inst_info:
|
|
client = self.auth_client
|
|
client.instances.delete(self.init_inst_info.id)
|
|
self.assert_client_code(client, expected_http_code)
|
|
else:
|
|
raise SkipTest("Cleanup is not required.")
|
|
|
|
def run_wait_for_init_delete(self, expected_states=['SHUTDOWN']):
|
|
delete_ids = []
|
|
if self.init_inst_info:
|
|
delete_ids.append(self.init_inst_info.id)
|
|
if delete_ids:
|
|
self.assert_all_gone(delete_ids, expected_states[-1])
|
|
else:
|
|
raise SkipTest("Cleanup is not required.")
|
|
self.init_inst_info = None
|
|
self.init_inst_dbs = None
|
|
self.init_inst_users = None
|
|
self.init_inst_host = None
|
|
self.init_inst_data = None
|
|
self.init_inst_config_group_id = None
|
|
|
|
def run_initial_configuration_delete(self, expected_http_code=202):
|
|
if self.config_group_id:
|
|
client = self.auth_client
|
|
client.configurations.delete(self.config_group_id)
|
|
self.assert_client_code(client, expected_http_code)
|
|
else:
|
|
raise SkipTest("Cleanup is not required.")
|
|
self.config_group_id = None
|