openstack
/
charm-trove
Code Issues Proposed changes

We have the amulet test cases up and they need to be run against the code.

This commit is contained in:
Jonathan Arrance 2016-09-12 21:18:14 -04:00
parent fe12173835
commit 27d07ec4dc
1 changed files with 72 additions and 140 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

212
src/tests/basic_deployment.py
View File

@ -32,17 +32,11 @@ u = os_amulet_utils.OpenStackAmuletUtils(os_amulet_utils.DEBUG)
class TroveBasicDeployment(amulet_deployment.OpenStackAmuletDeployment):
"""Amulet tests on a basic designate deployment."""
TEST_DOMAIN = 'amuletexample.com.'
TEST_WWW_RECORD = "www.{}".format(TEST_DOMAIN)
TEST_RECORD = {TEST_WWW_RECORD: '10.0.0.23'}
TEST_NS1_RECORD = 'ns1.amuletexample.com.'
TEST_NS2_RECORD = 'ns2.amuletexample.com.'
"""Amulet tests on a basic trove deployment."""
def __init__(self, series, openstack=None, source=None, stable=False):
"""Deploy the entire test environment."""
super(DesignateBasicDeployment, self).__init__(series, openstack,
super(TroveBasicDeployment, self).__init__(series, openstack,
source, stable)
self._add_services()
self._add_relations()
@ -58,35 +52,33 @@ class TroveBasicDeployment(amulet_deployment.OpenStackAmuletDeployment):
def _add_services(self):
"""Add services
Add the services that we're testing, where designate is local,
Add the services that we're testing, where trove is local,
and the rest of the service are from lp branches that are
compatible with the local charm (e.g. stable or next).
"""
this_service = {'name': 'designate'}
this_service = {'name': 'trove'}
other_services = [{'name': 'mysql'},
{'name': 'rabbitmq-server'},
{'name': 'keystone'},
{'name': 'designate-bind'}]
super(DesignateBasicDeployment, self)._add_services(this_service,
{'name': 'keystone'},]
super(TroveBasicDeployment, self)._add_services(this_service,
other_services)
def _add_relations(self):
"""Add all of the relations for the services."""
relations = {
'designate:shared-db': 'mysql:shared-db',
'designate:amqp': 'rabbitmq-server:amqp',
'designate:identity-service': 'keystone:identity-service',
'trove:shared-db': 'mysql:shared-db',
'trove:amqp': 'rabbitmq-server:amqp',
'trove:identity-service': 'keystone:identity-service',
'keystone:shared-db': 'mysql:shared-db',
'designate:dns-backend': 'designate-bind:dns-backend',
}
super(DesignateBasicDeployment, self)._add_relations(relations)
super(TroveBasicDeployment, self)._add_relations(relations)
def _configure_services(self):
"""Configure all of the services."""
keystone_config = {'admin-password': 'openstack',
'admin-token': 'ubuntutesting'}
configs = {'keystone': keystone_config}
super(DesignateBasicDeployment, self)._configure_services(configs)
super(TroveBasicDeployment, self)._configure_services(configs)
def _get_token(self):
return self.keystone.service_catalog.catalog['token']['id']
@ -94,8 +86,7 @@ class TroveBasicDeployment(amulet_deployment.OpenStackAmuletDeployment):
def _initialize_tests(self):
"""Perform final initialization before tests get run."""
# Access the sentries for inspecting service units
self.designate_sentry = self.d.sentry['designate'][0]
self.designate_bind_sentry = self.d.sentry['designate-bind'][0]
self.trove_sentry = self.d.sentry['trove'][0]
self.mysql_sentry = self.d.sentry['mysql'][0]
self.keystone_sentry = self.d.sentry['keystone'][0]
self.rabbitmq_sentry = self.d.sentry['rabbitmq-server'][0]
@ -103,14 +94,7 @@ class TroveBasicDeployment(amulet_deployment.OpenStackAmuletDeployment):
self._get_openstack_release()))
u.log.debug('openstack release str: {}'.format(
self._get_openstack_release_string()))
self.dns_slave_ip = self.designate_bind_sentry.relation(
'dns-backend',
'designate:dns-backend')['private-address']
self.designate_svcs = [
'designate-agent', 'designate-api', 'designate-central',
'designate-mdns', 'designate-pool-manager', 'designate-sink',
'designate-zone-manager',
]
self.trove_svcs = ['trove-api', 'trove-taskmanager', 'trove-conductor',]
# Authenticate admin with keystone endpoint
self.keystone = u.authenticate_keystone_admin(self.keystone_sentry,
@ -118,20 +102,20 @@ class TroveBasicDeployment(amulet_deployment.OpenStackAmuletDeployment):
password='openstack',
tenant='admin')
# Authenticate admin with designate endpoint
designate_ep = self.keystone.service_catalog.url_for(
service_type='dns',
# Authenticate admin with trove endpoint
trove_ep = self.keystone.service_catalog.url_for(
service_type='trove',
endpoint_type='publicURL')
keystone_ep = self.keystone.service_catalog.url_for(
service_type='identity',
endpoint_type='publicURL')
self.designate = designate_client.Client(
self.trove = trove_client.Client(
version='1',
auth_url=keystone_ep,
username="admin",
password="openstack",
tenant_name="admin",
endpoint=designate_ep)
endpoint=trove_ep)
def check_and_wait(self, check_command, interval=2, max_wait=200,
desc=None):
@ -176,7 +160,7 @@ class TroveBasicDeployment(amulet_deployment.OpenStackAmuletDeployment):
u.log.debug('Checking system services on units...')
service_names = {
self.designate_sentry: self.designate_svcs,
self.trove_sentry: self.trove_svcs,
}
ret = u.validate_services_by_name(service_names)
@ -206,9 +190,9 @@ class TroveBasicDeployment(amulet_deployment.OpenStackAmuletDeployment):
u.log.debug('OK')
def test_114_designate_api_endpoint(self):
"""Verify the designate api endpoint data."""
u.log.debug('Checking designate api endpoint data...')
def test_114_trove_api_endpoint(self):
"""Verify the trove api endpoint data."""
u.log.debug('Checking trove api endpoint data...')
endpoints = self.keystone.endpoints.list()
u.log.debug(endpoints)
admin_port = internal_port = public_port = '9001'
@ -222,45 +206,45 @@ class TroveBasicDeployment(amulet_deployment.OpenStackAmuletDeployment):
ret = u.validate_endpoint_data(endpoints, admin_port, internal_port,
public_port, expected)
if ret:
message = 'Designate endpoint: {}'.format(ret)
message = 'Trove endpoint: {}'.format(ret)
amulet.raise_status(amulet.FAIL, msg=message)
u.log.debug('OK')
def test_200_designate_identity_relation(self):
"""Verify the designate to keystone identity-service relation data"""
u.log.debug('Checking designate to keystone identity-service '
def test_200_trove_identity_relation(self):
"""Verify the trove to keystone identity-service relation data"""
u.log.debug('Checking trove to keystone identity-service '
'relation data...')
unit = self.designate_sentry
unit = self.trove_sentry
relation = ['identity-service', 'keystone:identity-service']
designate_ip = unit.relation(
trove_ip = unit.relation(
'identity-service',
'keystone:identity-service')['private-address']
designate_endpoint = "http://%s:9001" % (designate_ip)
trove_endpoint = "http://%s:8779" % (trove_ip)
expected = {
'admin_url': designate_endpoint,
'internal_url': designate_endpoint,
'private-address': designate_ip,
'public_url': designate_endpoint,
'admin_url': trove_endpoint,
'internal_url': trove_endpoint,
'private-address': trove_ip,
'public_url': trove_endpoint,
'region': 'RegionOne',
'service': 'designate',
'service': 'trove',
}
ret = u.validate_relation_data(unit, relation, expected)
if ret:
message = u.relation_error('designate identity-service', ret)
message = u.relation_error('trove identity-service', ret)
amulet.raise_status(amulet.FAIL, msg=message)
u.log.debug('OK')
def test_201_keystone_designate_identity_relation(self):
"""Verify the keystone to designate identity-service relation data"""
u.log.debug('Checking keystone:designate identity relation data...')
def test_201_keystone_trove_identity_relation(self):
"""Verify the keystone to trove identity-service relation data"""
u.log.debug('Checking keystone:trove identity relation data...')
unit = self.keystone_sentry
relation = ['identity-service', 'designate:identity-service']
relation = ['identity-service', 'trove:identity-service']
id_relation = unit.relation('identity-service',
'designate:identity-service')
'trove:identity-service')
id_ip = id_relation['private-address']
expected = {
'admin_token': 'ubuntutesting',
@ -274,7 +258,7 @@ class TroveBasicDeployment(amulet_deployment.OpenStackAmuletDeployment):
'service_protocol': 'http',
'service_tenant': 'services',
'service_tenant_id': u.not_null,
'service_username': 'designate',
'service_username': 'trove',
}
ret = u.validate_relation_data(unit, relation, expected)
if ret:
@ -283,29 +267,29 @@ class TroveBasicDeployment(amulet_deployment.OpenStackAmuletDeployment):
u.log.debug('OK')
def test_203_designate_amqp_relation(self):
"""Verify the designate to rabbitmq-server amqp relation data"""
u.log.debug('Checking designate:rabbitmq amqp relation data...')
unit = self.designate_sentry
def test_203_trove_amqp_relation(self):
"""Verify the trove to rabbitmq-server amqp relation data"""
u.log.debug('Checking trove:rabbitmq amqp relation data...')
unit = self.trove_sentry
relation = ['amqp', 'rabbitmq-server:amqp']
expected = {
'username': 'designate',
'username': 'trove',
'private-address': u.valid_ip,
'vhost': 'openstack'
}
ret = u.validate_relation_data(unit, relation, expected)
if ret:
message = u.relation_error('designate amqp', ret)
message = u.relation_error('trove amqp', ret)
amulet.raise_status(amulet.FAIL, msg=message)
u.log.debug('OK')
def test_204_amqp_designate_relation(self):
"""Verify the rabbitmq-server to designate amqp relation data"""
u.log.debug('Checking rabbitmq:designate amqp relation data...')
def test_204_amqp_trove_relation(self):
"""Verify the rabbitmq-server to trove amqp relation data"""
u.log.debug('Checking rabbitmq:trove amqp relation data...')
unit = self.rabbitmq_sentry
relation = ['amqp', 'designate:amqp']
relation = ['amqp', 'trove:amqp']
expected = {
'hostname': u.valid_ip,
'private-address': u.valid_ip,
@ -319,27 +303,27 @@ class TroveBasicDeployment(amulet_deployment.OpenStackAmuletDeployment):
u.log.debug('OK')
def test_205_designate_designate_bind_relation(self):
"""Verify the designate to designate-bind dns-backend relation data"""
u.log.debug('Checking designate:designate-bind dns-backend relation'
def test_205_trove_trove_bind_relation(self):
"""Verify the trove to trove-bind dns-backend relation data"""
u.log.debug('Checking trove:trove-bind dns-backend relation'
'data...')
unit = self.designate_sentry
relation = ['dns-backend', 'designate-bind:dns-backend']
unit = self.trove_sentry
relation = ['dns-backend', 'trove-bind:dns-backend']
expected = {
'private-address': u.valid_ip,
}
ret = u.validate_relation_data(unit, relation, expected)
if ret:
message = u.relation_error('designate dns-backend', ret)
message = u.relation_error('trove dns-backend', ret)
amulet.raise_status(amulet.FAIL, msg=message)
def test_206_designate_bind_designate_relation(self):
"""Verify the designate_bind to designate dns-backend relation data"""
u.log.debug('Checking designate-bind:designate dns-backend relation'
def test_206_trove_bind_trove_relation(self):
"""Verify the trove_bind to trove dns-backend relation data"""
u.log.debug('Checking trove-bind:trove dns-backend relation'
'data...')
unit = self.designate_bind_sentry
relation = ['dns-backend', 'designate:dns-backend']
unit = self.trove_bind_sentry
relation = ['dns-backend', 'trove:dns-backend']
expected = {
'private-address': u.valid_ip,
'rndckey': u.not_null,
@ -348,12 +332,12 @@ class TroveBasicDeployment(amulet_deployment.OpenStackAmuletDeployment):
ret = u.validate_relation_data(unit, relation, expected)
if ret:
message = u.relation_error('designate dns-backend', ret)
message = u.relation_error('trove dns-backend', ret)
amulet.raise_status(amulet.FAIL, msg=message)
def get_server_id(self, server_name):
server_id = None
for server in self.designate.servers.list():
for server in self.trove.servers.list():
if server.name == server_name:
server_id = server.id
break
@ -367,83 +351,31 @@ class TroveBasicDeployment(amulet_deployment.OpenStackAmuletDeployment):
def test_400_server_creation(self):
"""Simple api calls to create domain"""
# Designate does not allow the last server to be delete so ensure ns1
# Trove does not allow the last server to be delete so ensure ns1
# always present
if not self.get_server_id(self.TEST_NS1_RECORD):
server = servers.Server(name=self.TEST_NS1_RECORD)
new_server = self.designate.servers.create(server)
new_server = self.trove.servers.create(server)
u.log.debug('Checking if server exists before trying to create it')
old_server_id = self.get_test_server_id()
if old_server_id:
u.log.debug('Deleting old server')
self.designate.servers.delete(old_server_id)
self.trove.servers.delete(old_server_id)
self.check_and_wait(
self.check_test_server_gone,
desc='Waiting for server to disappear')
u.log.debug('Creating new server')
server = servers.Server(name=self.TEST_NS2_RECORD)
new_server = self.designate.servers.create(server)
new_server = self.trove.servers.create(server)
assert(new_server is not None)
def get_domain_id(self, domain_name):
domain_id = None
for dom in self.designate.domains.list():
if dom.name == domain_name:
domain_id = dom.id
break
return domain_id
def get_test_domain_id(self):
return self.get_domain_id(self.TEST_DOMAIN)
def check_test_domain_gone(self):
return not self.get_test_domain_id()
def check_slave_resolve_test_record(self):
lookup_cmd = [
'dig', '+short', '@{}'.format(self.dns_slave_ip),
self.TEST_WWW_RECORD]
cmd_out = subprocess.check_output(lookup_cmd).rstrip('\r\n')
return self.TEST_RECORD[self.TEST_WWW_RECORD] == cmd_out
def test_410_domain_creation(self):
"""Simple api calls to create domain"""
u.log.debug('Checking if domain exists before trying to create it')
old_dom_id = self.get_test_domain_id()
if old_dom_id:
u.log.debug('Deleting old domain')
self.designate.domains.delete(old_dom_id)
self.check_and_wait(
self.check_test_domain_gone,
desc='Waiting for domain to disappear')
u.log.debug('Creating new domain')
domain = domains.Domain(
name=self.TEST_DOMAIN,
email="fred@amuletexample.com")
new_domain = self.designate.domains.create(domain)
assert(new_domain is not None)
u.log.debug('Creating new test record')
_record = records.Record(
name=self.TEST_WWW_RECORD,
type="A",
data=self.TEST_RECORD[self.TEST_WWW_RECORD])
self.designate.records.create(new_domain.id, _record)
self.check_and_wait(
self.check_slave_resolve_test_record,
desc='Waiting for dns record to propagate')
u.log.debug('Tidy up delete test record')
self.designate.domains.delete(new_domain.id)
u.log.debug('OK')
def test_900_restart_on_config_change(self):
"""Verify that the specified services are restarted when the config
is changed.
"""
sentry = self.designate_sentry
juju_service = 'designate'
sentry = self.trove_sentry
juju_service = 'trove'
# Expected default and alternate values
set_default = {'debug': 'False'}
@ -451,8 +383,8 @@ class TroveBasicDeployment(amulet_deployment.OpenStackAmuletDeployment):
# Services which are expected to restart upon config change,
# and corresponding config files affected by the change
conf_file = '/etc/designate/designate.conf'
services = {svc: conf_file for svc in self.designate_svcs}
conf_file = '/etc/trove/trove.conf'
services = {svc: conf_file for svc in self.trove_svcs}
# Make config change, check for service restarts
u.log.debug('Making config change on {}...'.format(juju_service))