def _assert_is_replica(self, instance_id, master_id):
instance = self.get_instance(instance_id)
self.assert_client_code(200)
CheckInstance(instance._info).replica_of()
self.assert_equal(master_id, instance._info['replica_of']['id'],
'Unexpected replication master ID')
self._validate_replica(instance_id)
def test_get_master_instance(self):
instance = instance_info.dbaas.instances.get(instance_info.id)
assert_equal(200, instance_info.dbaas.last_http_code)
instance_dict = instance._info
print("instance_dict=%s" % instance_dict)
CheckInstance(instance_dict).slaves()
assert_equal(slave_instance.id, instance_dict['replicas'][0]['id'])
def _assert_is_master(self, instance_id, replica_ids):
instance = self.get_instance(instance_id)
self.assert_client_code(200)
CheckInstance(instance._info).slaves()
self.assert_true(
set(replica_ids).issubset(self._get_replica_set(instance_id)))
self._validate_master(instance_id)
def test_storage_on_host(self):
if not FAKE_MODE:
raise SkipTest("Volume driver currently not working.")
storage = self.client.storage.index()
print("storage : %r" % storage)
print("instance_info.storage : %r" % instance_info.storage)
allowed_attrs = ['name', 'type', 'used', 'provision', 'capacity']
for index, device in enumerate(storage):
CheckInstance(None).contains_allowed_attrs(device._info,
allowed_attrs,
msg="Storage")
asserts.assert_equal(device.name,
instance_info.storage[index].name)
asserts.assert_equal(device.used,
instance_info.storage[index].used)
asserts.assert_equal(device.type,
instance_info.storage[index].type)
provision = instance_info.storage[index].provision
asserts.assert_equal(device.provision['available'],
provision['available'])
asserts.assert_equal(device.provision['percent'],
provision['percent'])
asserts.assert_equal(device.provision['total'], provision['total'])
capacity = instance_info.storage[index].capacity
asserts.assert_equal(device.capacity['available'],
capacity['available'])
asserts.assert_equal(device.capacity['total'], capacity['total'])
def validate_master(master, slaves):
new_master = instance_info.dbaas.instances.get(master.id)
assert_equal(200, instance_info.dbaas.last_http_code)
nm_dict = new_master._info
CheckInstance(nm_dict).slaves()
master_ids = set([replica['id'] for replica in nm_dict['replicas']])
asserted_ids = set([slave.id for slave in slaves])
assert_true(asserted_ids.issubset(master_ids))
def validate_slave(master, slave):
new_slave = instance_info.dbaas.instances.get(slave.id)
assert_equal(200, instance_info.dbaas.last_http_code)
ns_dict = new_slave._info
CheckInstance(ns_dict).replica_of()
assert_equal(master.id, ns_dict['replica_of']['id'])
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]
# 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)
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 = InstanceTestInfo()
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
shared_network = CONFIG.get('shared_network', None)
if shared_network:
instance_info.nics = [{'net-id': shared_network}]
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.")
else:
self.report.log("Creating a new instance.")
instance = self.auth_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_instance_action(instance.id, expected_states[0:1],
expected_http_code)
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
