Merge lp:~corey.bryant/charms/trusty/keystone/amulet-basic into lp:~openstack-charmers-archive/charms/trusty/keystone/trunk

[Corey Bryant]

[James Page (james-page)]

Hey Corey

Looks like a good start - here's some general and specific feedback.

1) testing supported openstack versions

I think that when I ran 'make amulet-test' amulet decided to choose precise, and hence the essex openstack packages; this entire test is valid for essex, folsom, grizzly, havana and icehouse on precise and icehouse on trusty; I suggest refactoring into a class which can be called with various different configurations to represent the series that the charm supports deploying - something like:

   ks = KeyStoneDeployment(series="precise", openstack="folsom")
   ks.runtests()

that's rough - but gives you an idea of what I was thinking about! You could then have 10-basic-precise-essex, 10-basic-precise-folsom etc....

regression testing ftw!

2) service status

utils.run_command(mysql_unit, 'service mysql status')

Does this actually validate that mysql is running? I'm pretty sure status always returns 0 via the service wrapper - calling "status mysql" might do something better.

3) inspecting relationships

In addition to testing that services are running and that keystone is usable, it would be nice to ensure that the expected relation data has been set between keystone <-> mysql.

3) adding an additional service

To exercise all relations, you might want to add something like cinder into the mix to ensure that the catalog contains both keystone and cinder endpoints post deployment.

4) logging

sys.stderr.write feels bad - how about using python logging instead? that gives timestamps etc.. and can write to stderr.

[lp:~corey.bryant/charms/trusty/keystone/amulet-basic]

64. By James Page on 2014-05-21

[tribaal,r=james-page,t=james-page]

Resync helpers to pickup fixes for apt lock races and better block device detection and handling.

65. By James Page on 2014-05-21

[trivial] Ensure lint and test pass before publish

[Corey Bryant (corey.bryant)]

Hey James,

Thanks for reviewing. I've pushed a new version of the code, with your comments accounted for. I still need to do some cleanup but I think it's in good enough shape for another review. In terms of cleanup, I have a bunch of notes scattered in comments to do some regex comparisons for relation and endpoint data to get more accurate checking. Also I can make some of this code more reusable (for example, TestDeployment class could inherit from another class that at least defines run()).

Corey

[James Page (james-page)]

Corey

Looks like a good step forward - like the re-use for series of Ubuntu and OpenStack.

Re the testing of services, endpoints and relation state - might be worth trying to work that into dictionaries of data which you could just then write a generic validator for rather than having lots of if .... : for each check.

That could work back into charm-helpers as part of amulet test supporting stuff.

Also the __init__ function looks quite big; it might be better to just construct the class with init and (maybe create the Deployment object) and then have extra functions for deploying services and configuring. That way some of that code could be shared as well.

Looking good tho!

[James Page (james-page)]

Hi Corey

Really like the rework - its looking good. I made a few specific inline comments re superclass calls.

Its probably also worth calling the AmuletDeployment class OpenStackAmuletDeployment - it appears todo alot of OpenStack specific things so lets not confuse the default namespace for the time being.

review: Needs Fixing

[Corey Bryant (corey.bryant)]

Hi James,

Thanks for the review. I might just keep AmuletDeployment as a more generic class and create OpenStackAmulet(AmuletDeployment) that includes the openstack specific differences.

Off I go to rework.

Corey

[Corey Bryant (corey.bryant)]

Hi James,

I've pushed this again with fixes for your most recent comments plus the following:
 *I added logging support in amulet_utils.py
 *I updated the config option used in test_restart_on_config_change()

python-amulet isn't available yet though so I don't think this can be merged until that's available.

Corey

[lp:~corey.bryant/charms/trusty/keystone/amulet-basic]

66. By James Page on 2014-06-04

resync helpers for juno support

67. By James Page on 2014-06-05

[mikemc,r=james-page] Add product-streams service catalog type.

[Corey Bryant (corey.bryant)]

I've pushed a new version with the following updates:
 *Makefile - Use standard target names test and unit_test per https://docs.google.com/a/canonical.com/document/d/1Lb86vjXG7ZnVqDq8idNa5-rx_VB728Qacxm4U7IutgE/edit#
 *amulet_utils.py - Change get_logger() defaults.
 *amulet_utils.py - Added validate_flavor_data() and _validate_list_data() (used by nova-cloud-controller charm)
 *amulet_utils.py - Added -f option to pgrep in _get_proc_start_time() to match against full command line (not just process name) and only use first pid found
 *amulet_utils.py - Added more code to validate_endpoint_data(), making calls to this function simpler
 *basic_deployment.py - Simplified code in test_keystone_endpoint() and test_cinder_endpoint()
 *basic_deployment.py - test_keystone_shared_db_relation() - changed expected 'auth_host' value to utils.valid_ip
 *basic_deployment.py - Changed test_restart_on_config_change() to check for restart of keystone-all service instead of keystone

[Corey Bryant (corey.bryant)]

I've pushed a new version with the following updates:
  *amulet_utils.py - Changed pgrep to return only the oldest matching
                     pid in _get_proc_start_time()
  *amulet_utils.py - Changed sleep(5) to sleep(10) in
                     service_restarted()

[Corey Bryant (corey.bryant)]

I've pushed a new version with the following updates:
  *tests/README - Added README file
  *tests/amulet_deployment.py - Added support to _add_services() to allows
                                number of service units to be specified
  *tests/amulet_utils.py - Added tenant_exists(), authenticate_keystone_admin(),
                           and authenticate_keystone_user()
  *tests/basic_deployment.py - Added support to _add_services() to specify
                               number of service units
  *tests/basic_deployment.py - Reduce _initialize_tests() code by using
                               authenticate_keystone_admin() and
                               authenticate_keystone_user()
  *tests/basic_deployment.py - Make _initialize_tests() idempotent by not
                               adding demo tenant/role/user if they already
                               exist

[Corey Bryant (corey.bryant)]

I've pushed a new version with the following updates:
  * tests/00-setup - install python-amulet as it just became available via packaging

[Corey Bryant (corey.bryant)]

I've pushed a new version now that I've moved all common code to charm-helpers.

[lp:~corey.bryant/charms/trusty/keystone/amulet-basic]

68. By Corey Bryant on 2014-06-24

Move charm-helpers.yaml to charm-helpers-hooks.yaml and
add charm-helpers-tests.yaml.

69. By Corey Bryant on 2014-06-24

Sync with charm-helpers

70. By Corey Bryant on 2014-06-24

Add initial Amulet basic tests

Unmerged revisions

=== modified file 'Makefile'
--- Makefile	2014-05-21 10:13:58 +0000
+++ Makefile	2014-06-20 13:39:25 +0000
@@ -1,13 +1,26 @@
 #!/usr/bin/make
 PYTHON := /usr/bin/env python
 
+prereq:
+	@[ -z "`dpkg -l | grep python-flake8 -q`" ] && \
+		sudo apt-get install --yes python-flake8
+	@[ -z "`dpkg -l | grep charm-tools -q`" ] && \
+		sudo apt-get install --yes charm-tools
+
 lint:
-	@flake8 --exclude hooks/charmhelpers hooks unit_tests
+	@flake8 --exclude hooks/charmhelpers hooks unit_tests tests
 	@charm proof
 
+unit_test:
+	@echo Starting unit tests...
+	@$(PYTHON) /usr/bin/nosetests --nologcapture --with-coverage  unit_tests
+
 test:
-	@echo Starting tests...
-	@$(PYTHON) /usr/bin/nosetests --nologcapture --with-coverage  unit_tests
+	@echo Starting Amulet tests...
+	# coreycb note: The -v should only be temporary until Amulet sends
+	# raise_status() messages to stderr:
+	#   https://bugs.launchpad.net/amulet/+bug/1320357
+	@juju test -v
 
 sync:
 	@charm-helper-sync -c charm-helpers.yaml

=== modified file 'charm-helpers.yaml'
--- charm-helpers.yaml	2014-03-28 10:39:49 +0000
+++ charm-helpers.yaml	2014-06-20 13:39:25 +0000
@@ -11,3 +11,7 @@
     - contrib.unison
     - payload.execd
     - contrib.peerstorage
+destination: tests/charmhelpers
+include:
+    - contrib.amulet
+    - contrib.openstack.amulet

=== modified file 'hooks/charmhelpers/contrib/openstack/utils.py'
--- hooks/charmhelpers/contrib/openstack/utils.py	2014-05-19 11:42:30 +0000
+++ hooks/charmhelpers/contrib/openstack/utils.py	2014-06-20 13:39:25 +0000
@@ -3,7 +3,6 @@
 # Common python helper functions used for OpenStack charms.
 from collections import OrderedDict
 
-import apt_pkg as apt
 import subprocess
 import os
 import socket
@@ -41,7 +40,8 @@
     ('quantal', 'folsom'),
     ('raring', 'grizzly'),
     ('saucy', 'havana'),
-    ('trusty', 'icehouse')
+    ('trusty', 'icehouse'),
+    ('utopic', 'juno'),
 ])
 
 
@@ -52,6 +52,7 @@
     ('2013.1', 'grizzly'),
     ('2013.2', 'havana'),
     ('2014.1', 'icehouse'),
+    ('2014.2', 'juno'),
 ])
 
 # The ugly duckling
@@ -130,6 +131,7 @@
 
 def get_os_codename_package(package, fatal=True):
     '''Derive OpenStack release codename from an installed package.'''
+    import apt_pkg as apt
     apt.init()
 
     # Tell apt to build an in-memory cache to prevent race conditions (if
@@ -273,6 +275,9 @@
             'icehouse': 'precise-updates/icehouse',
             'icehouse/updates': 'precise-updates/icehouse',
             'icehouse/proposed': 'precise-proposed/icehouse',
+            'juno': 'trusty-updates/juno',
+            'juno/updates': 'trusty-updates/juno',
+            'juno/proposed': 'trusty-proposed/juno',
         }
 
         try:
@@ -320,6 +325,7 @@
 
     """
 
+    import apt_pkg as apt
     src = config('openstack-origin')
     cur_vers = get_os_version_package(package)
     available_vers = get_os_version_install_source(src)

=== added file 'hooks/charmhelpers/core/fstab.py'
--- hooks/charmhelpers/core/fstab.py	1970-01-01 00:00:00 +0000
+++ hooks/charmhelpers/core/fstab.py	2014-06-20 13:39:25 +0000
@@ -0,0 +1,116 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+__author__ = 'Jorge Niedbalski R. <[e-mail]>'
+
+import os
+
+
+class Fstab(file):
+    """This class extends file in order to implement a file reader/writer
+    for file `/etc/fstab`
+    """
+
+    class Entry(object):
+        """Entry class represents a non-comment line on the `/etc/fstab` file
+        """
+        def __init__(self, device, mountpoint, filesystem,
+                     options, d=0, p=0):
+            self.device = device
+            self.mountpoint = mountpoint
+            self.filesystem = filesystem
+
+            if not options:
+                options = "defaults"
+
+            self.options = options
+            self.d = d
+            self.p = p
+
+        def __eq__(self, o):
+            return str(self) == str(o)
+
+        def __str__(self):
+            return "{} {} {} {} {} {}".format(self.device,
+                                              self.mountpoint,
+                                              self.filesystem,
+                                              self.options,
+                                              self.d,
+                                              self.p)
+
+    DEFAULT_PATH = os.path.join(os.path.sep, 'etc', 'fstab')
+
+    def __init__(self, path=None):
+        if path:
+            self._path = path
+        else:
+            self._path = self.DEFAULT_PATH
+        file.__init__(self, self._path, 'r+')
+
+    def _hydrate_entry(self, line):
+        # NOTE: use split with no arguments to split on any
+        #       whitespace including tabs
+        return Fstab.Entry(*filter(
+            lambda x: x not in ('', None),
+            line.strip("\n").split()))
+
+    @property
+    def entries(self):
+        self.seek(0)
+        for line in self.readlines():
+            try:
+                if not line.startswith("#"):
+                    yield self._hydrate_entry(line)
+            except ValueError:
+                pass
+
+    def get_entry_by_attr(self, attr, value):
+        for entry in self.entries:
+            e_attr = getattr(entry, attr)
+            if e_attr == value:
+                return entry
+        return None
+
+    def add_entry(self, entry):
+        if self.get_entry_by_attr('device', entry.device):
+            return False
+
+        self.write(str(entry) + '\n')
+        self.truncate()
+        return entry
+
+    def remove_entry(self, entry):
+        self.seek(0)
+
+        lines = self.readlines()
+
+        found = False
+        for index, line in enumerate(lines):
+            if not line.startswith("#"):
+                if self._hydrate_entry(line) == entry:
+                    found = True
+                    break
+
+        if not found:
+            return False
+
+        lines.remove(line)
+
+        self.seek(0)
+        self.write(''.join(lines))
+        self.truncate()
+        return True
+
+    @classmethod
+    def remove_by_mountpoint(cls, mountpoint, path=None):
+        fstab = cls(path=path)
+        entry = fstab.get_entry_by_attr('mountpoint', mountpoint)
+        if entry:
+            return fstab.remove_entry(entry)
+        return False
+
+    @classmethod
+    def add(cls, device, mountpoint, filesystem, options=None, path=None):
+        return cls(path=path).add_entry(Fstab.Entry(device,
+                                                    mountpoint, filesystem,
+                                                    options=options))

=== modified file 'hooks/charmhelpers/core/host.py'
--- hooks/charmhelpers/core/host.py	2014-05-19 11:42:30 +0000
+++ hooks/charmhelpers/core/host.py	2014-06-20 13:39:25 +0000
@@ -12,11 +12,11 @@
 import string
 import subprocess
 import hashlib
-import apt_pkg
 
 from collections import OrderedDict
 
 from hookenv import log
+from fstab import Fstab
 
 
 def service_start(service_name):
@@ -35,7 +35,8 @@
 
 
 def service_reload(service_name, restart_on_failure=False):
-    """Reload a system service, optionally falling back to restart if reload fails"""
+    """Reload a system service, optionally falling back to restart if
+    reload fails"""
     service_result = service('reload', service_name)
     if not service_result and restart_on_failure:
         service_result = service('restart', service_name)
@@ -144,7 +145,19 @@
         target.write(content)
 
 
-def mount(device, mountpoint, options=None, persist=False):
+def fstab_remove(mp):
+    """Remove the given mountpoint entry from /etc/fstab
+    """
+    return Fstab.remove_by_mountpoint(mp)
+
+
+def fstab_add(dev, mp, fs, options=None):
+    """Adds the given device entry to the /etc/fstab file
+    """
+    return Fstab.add(dev, mp, fs, options=options)
+
+
+def mount(device, mountpoint, options=None, persist=False, filesystem="ext3"):
     """Mount a filesystem at a particular mountpoint"""
     cmd_args = ['mount']
     if options is not None:
@@ -155,9 +168,9 @@
     except subprocess.CalledProcessError, e:
         log('Error mounting {} at {}\n{}'.format(device, mountpoint, e.output))
         return False
+
     if persist:
-        # TODO: update fstab
-        pass
+        return fstab_add(device, mountpoint, filesystem, options=options)
     return True
 
 
@@ -169,9 +182,9 @@
     except subprocess.CalledProcessError, e:
         log('Error unmounting {}\n{}'.format(mountpoint, e.output))
         return False
+
     if persist:
-        # TODO: update fstab
-        pass
+        return fstab_remove(mountpoint)
     return True
 
 
@@ -304,6 +317,7 @@
        0 => Installed revno is the same as supplied arg
       -1 => Installed revno is less than supplied arg
     '''
+    import apt_pkg
     if not pkgcache:
         apt_pkg.init()
         pkgcache = apt_pkg.Cache()

=== modified file 'hooks/charmhelpers/fetch/__init__.py'
--- hooks/charmhelpers/fetch/__init__.py	2014-05-19 11:42:30 +0000
+++ hooks/charmhelpers/fetch/__init__.py	2014-06-20 13:39:25 +0000
@@ -13,7 +13,6 @@
     config,
     log,
 )
-import apt_pkg
 import os
 
 
@@ -56,6 +55,15 @@
     'icehouse/proposed': 'precise-proposed/icehouse',
     'precise-icehouse/proposed': 'precise-proposed/icehouse',
     'precise-proposed/icehouse': 'precise-proposed/icehouse',
+    # Juno
+    'juno': 'trusty-updates/juno',
+    'trusty-juno': 'trusty-updates/juno',
+    'trusty-juno/updates': 'trusty-updates/juno',
+    'trusty-updates/juno': 'trusty-updates/juno',
+    'juno/proposed': 'trusty-proposed/juno',
+    'juno/proposed': 'trusty-proposed/juno',
+    'trusty-juno/proposed': 'trusty-proposed/juno',
+    'trusty-proposed/juno': 'trusty-proposed/juno',
 }
 
 # The order of this list is very important. Handlers should be listed in from
@@ -108,6 +116,7 @@
 
 def filter_installed_packages(packages):
     """Returns a list of packages that require installation"""
+    import apt_pkg
     apt_pkg.init()
 
     # Tell apt to build an in-memory cache to prevent race conditions (if

=== modified file 'hooks/charmhelpers/fetch/bzrurl.py'
--- hooks/charmhelpers/fetch/bzrurl.py	2014-03-27 10:54:38 +0000
+++ hooks/charmhelpers/fetch/bzrurl.py	2014-06-20 13:39:25 +0000
@@ -39,7 +39,8 @@
     def install(self, source):
         url_parts = self.parse_url(source)
         branch_name = url_parts.path.strip("/").split("/")[-1]
-        dest_dir = os.path.join(os.environ.get('CHARM_DIR'), "fetched", branch_name)
+        dest_dir = os.path.join(os.environ.get('CHARM_DIR'), "fetched",
+                                branch_name)
         if not os.path.exists(dest_dir):
             mkdir(dest_dir, perms=0755)
         try:

=== added directory 'tests'
=== added file 'tests/00-setup'
--- tests/00-setup	1970-01-01 00:00:00 +0000
+++ tests/00-setup	2014-06-20 13:39:25 +0000
@@ -0,0 +1,8 @@
+#!/bin/bash
+
+set -ex
+
+sudo add-apt-repository --yes ppa:juju/stable
+sudo apt-get update --yes
+sudo apt-get install --yes python-amulet
+sudo apt-get install --yes python-keystoneclient

=== added file 'tests/10-basic-precise-essex'
--- tests/10-basic-precise-essex	1970-01-01 00:00:00 +0000
+++ tests/10-basic-precise-essex	2014-06-20 13:39:25 +0000
@@ -0,0 +1,9 @@
+#!/usr/bin/python
+
+"""Amulet tests on a basic keystone deployment on precise-essex."""
+
+from basic_deployment import KeystoneBasicDeployment
+
+if __name__ == '__main__':
+    deployment = KeystoneBasicDeployment(series='precise')
+    deployment.run_tests()

=== added file 'tests/11-basic-precise-folsom'
--- tests/11-basic-precise-folsom	1970-01-01 00:00:00 +0000
+++ tests/11-basic-precise-folsom	2014-06-20 13:39:25 +0000
@@ -0,0 +1,10 @@
+#!/usr/bin/python
+
+"""Amulet tests on a basic keystone deployment on precise-folsom."""
+
+from basic_deployment import KeystoneBasicDeployment
+
+if __name__ == '__main__':
+    deployment = KeystoneBasicDeployment(series='precise',
+                                         openstack='cloud:precise-folsom')
+    deployment.run_tests()

=== added file 'tests/12-basic-precise-grizzly'
--- tests/12-basic-precise-grizzly	1970-01-01 00:00:00 +0000
+++ tests/12-basic-precise-grizzly	2014-06-20 13:39:25 +0000
@@ -0,0 +1,10 @@
+#!/usr/bin/python
+
+"""Amulet tests on a basic keystone deployment on precise-grizzly."""
+
+from basic_deployment import KeystoneBasicDeployment
+
+if __name__ == '__main__':
+    deployment = KeystoneBasicDeployment(series='precise',
+                                         openstack='cloud:precise-grizzly')
+    deployment.run_tests()

=== added file 'tests/13-basic-precise-havana'
--- tests/13-basic-precise-havana	1970-01-01 00:00:00 +0000
+++ tests/13-basic-precise-havana	2014-06-20 13:39:25 +0000
@@ -0,0 +1,10 @@
+#!/usr/bin/python
+
+"""Amulet tests on a basic keystone deployment on precise-havana."""
+
+from basic_deployment import KeystoneBasicDeployment
+
+if __name__ == '__main__':
+    deployment = KeystoneBasicDeployment(series='precise',
+                                         openstack='cloud:precise-havana')
+    deployment.run_tests()

=== added file 'tests/14-basic-precise-icehouse'
--- tests/14-basic-precise-icehouse	1970-01-01 00:00:00 +0000
+++ tests/14-basic-precise-icehouse	2014-06-20 13:39:25 +0000
@@ -0,0 +1,10 @@
+#!/usr/bin/python
+
+"""Amulet tests on a basic keystone deployment on precise-icehouse."""
+
+from basic_deployment import KeystoneBasicDeployment
+
+if __name__ == '__main__':
+    deployment = KeystoneBasicDeployment(series='precise',
+                                         openstack='cloud:precise-icehouse')
+    deployment.run_tests()

=== added file 'tests/15-basic-trusty-icehouse'
--- tests/15-basic-trusty-icehouse	1970-01-01 00:00:00 +0000
+++ tests/15-basic-trusty-icehouse	2014-06-20 13:39:25 +0000
@@ -0,0 +1,9 @@
+#!/usr/bin/python
+
+"""Amulet tests on a basic keystone deployment on trusty-icehouse."""
+
+from basic_deployment import KeystoneBasicDeployment
+
+if __name__ == '__main__':
+    deployment = KeystoneBasicDeployment(series='trusty')
+    deployment.run_tests()

=== added file 'tests/README'
--- tests/README	1970-01-01 00:00:00 +0000
+++ tests/README	2014-06-20 13:39:25 +0000
@@ -0,0 +1,28 @@
+This directory provides Amulet tests that focus on verification of Keystone
+deployments.
+
+The following examples demonstrate different ways that tests can be executed.
+All examples are run from the charm's root directory.
+
+  * To run all tests (starting with 00-setup):
+
+      make test
+
+  * To run a specific test module (or modules):
+
+      juju test -v 15-basic-trusty-icehouse
+
+  * To run a specific test module (or modules), and keep the environment
+    deployed after a failure:
+
+      juju test --set-e -v 15-basic-trusty-icehouse
+
+  * To re-run a test module against an already deployed environment (one
+    that was deployed by a previous call to 'juju test --set-e'):
+
+      ./tests/15-basic-trusty-icehouse
+
+For debugging and test development purposes, all code should be idempotent.
+In other words, the code should have the ability to be re-run without changing
+the results beyond the initial run.  This enables editing and re-running of a
+test module against an already deployed environment, as described above.

=== added file 'tests/basic_deployment.py'
--- tests/basic_deployment.py	1970-01-01 00:00:00 +0000
+++ tests/basic_deployment.py	2014-06-20 13:39:25 +0000
@@ -0,0 +1,328 @@
+#!/usr/bin/python
+
+import amulet
+
+from charmhelpers.contrib.openstack.amulet.deployment import (
+    OpenStackAmuletDeployment
+)
+
+from charmhelpers.contrib.openstack.amulet.utils import (
+    OpenStackAmuletUtils,
+    DEBUG, # flake8: noqa
+    ERROR
+)
+
+# Use DEBUG to turn on debug logging
+u = OpenStackAmuletUtils(ERROR)
+
+
+class KeystoneBasicDeployment(OpenStackAmuletDeployment):
+    """Amulet tests on a basic keystone deployment."""
+
+    def __init__(self, series=None, openstack=None):
+        """Deploy the entire test environment."""
+        super(KeystoneBasicDeployment, self).__init__(series, openstack)
+        self._add_services()
+        self._add_relations()
+        self._configure_services()
+        self._deploy()
+        self._initialize_tests()
+
+    def _add_services(self):
+        """Add the services that we're testing, including the number of units,
+           where keystone is local, and mysql and cinder are from the charm
+           store."""
+        this_service = ('keystone', 1)
+        other_services = [('mysql', 1), ('cinder', 1)]
+        super(KeystoneBasicDeployment, self)._add_services(this_service,
+                                                           other_services)
+
+    def _add_relations(self):
+        """Add all of the relations for the services."""
+        relations = {'keystone:shared-db': 'mysql:shared-db',
+                     'cinder:identity-service': 'keystone:identity-service'}
+        super(KeystoneBasicDeployment, self)._add_relations(relations)
+
+    def _configure_services(self):
+        """Configure all of the services."""
+        keystone_config = {'admin-password': 'openstack',
+                           'admin-token': 'ubuntutesting'}
+        mysql_config = {'dataset-size': '50%'}
+        cinder_config = {'block-device': 'None'}
+        configs = {'keystone': keystone_config,
+                   'mysql': mysql_config,
+                   'cinder': cinder_config}
+        super(KeystoneBasicDeployment, self)._configure_services(configs)
+
+    def _initialize_tests(self):
+        """Perform final initialization before tests get run."""
+        # Access the sentries for inspecting service units
+        self.mysql_sentry = self.d.sentry.unit['mysql/0']
+        self.keystone_sentry = self.d.sentry.unit['keystone/0']
+        self.cinder_sentry = self.d.sentry.unit['cinder/0']
+
+        # Authenticate admin with keystone
+        self.keystone = u.authenticate_keystone_admin(self.keystone_sentry,
+                                                      user='admin',
+                                                      password='openstack',
+                                                      tenant='admin')
+
+        # Create a demo tenant/role/user
+        self.demo_tenant = 'demoTenant'
+        self.demo_role = 'demoRole'
+        self.demo_user = 'demoUser'
+        if not u.tenant_exists(self.keystone, self.demo_tenant):
+            tenant = self.keystone.tenants.create(tenant_name=self.demo_tenant,
+                                                  description='demo tenant',
+                                                  enabled=True)
+            self.keystone.roles.create(name=self.demo_role)
+            self.keystone.users.create(name=self.demo_user, password='password',
+                                       tenant_id=tenant.id,
+                                       email='[e-mail]')
+
+        # Authenticate demo user with keystone
+        self.keystone_demo = u.authenticate_keystone_user(self.keystone,
+                                                        user=self.demo_user,
+                                                        password='password',
+                                                        tenant=self.demo_tenant)
+
+    def test_services(self):
+        """Verify the expected services are running on the corresponding
+           service units."""
+        commands = {
+            self.mysql_sentry: 'status mysql',
+            self.keystone_sentry: 'status keystone',
+            self.cinder_sentry: 'status cinder-api',
+            self.cinder_sentry: 'status cinder-scheduler',
+            self.cinder_sentry: 'status cinder-volume'
+        }
+        ret = u.validate_services(commands)
+        if ret:
+            amulet.raise_status(amulet.FAIL, msg=ret)
+
+    def test_tenants(self):
+        """Verify all existing tenants."""
+        tenant1 = {'enabled': True,
+                   'description': 'Created by Juju',
+                   'name': 'services',
+                   'id': u.not_null}
+        tenant2 = {'enabled': True,
+                   'description': 'demo tenant',
+                   'name': 'demoTenant',
+                   'id': u.not_null}
+        tenant3 = {'enabled': True,
+                   'description': 'Created by Juju',
+                   'name': 'admin',
+                   'id': u.not_null}
+        expected = [tenant1, tenant2, tenant3]
+        actual = self.keystone.tenants.list()
+
+        ret = u.validate_tenant_data(expected, actual)
+        if ret:
+            amulet.raise_status(amulet.FAIL, msg=ret)
+
+    def test_roles(self):
+        """Verify all existing roles."""
+        role1 = {'name': 'demoRole', 'id': u.not_null}
+        role2 = {'name': 'KeystoneAdmin', 'id': u.not_null}
+        role3 = {'name': 'KeystoneServiceAdmin', 'id': u.not_null}
+        role4 = {'name': 'Admin', 'id': u.not_null}
+        expected = [role1, role2, role3, role4]
+        actual = self.keystone.roles.list()
+
+        ret = u.validate_role_data(expected, actual)
+        if ret:
+            amulet.raise_status(amulet.FAIL, msg=ret)
+
+    def test_users(self):
+        """Verify all existing roles."""
+        user1 = {'name': 'demoUser',
+                 'enabled': True,
+                 'tenantId': u.not_null,
+                 'id': u.not_null,
+                 'email': '[e-mail]'}
+        user2 = {'name': 'admin',
+                 'enabled': True,
+                 'tenantId': u.not_null,
+                 'id': u.not_null,
+                 'email': 'juju@localhost'}
+        user3 = {'name': 'cinder',
+                 'enabled': True,
+                 'tenantId': u.not_null,
+                 'id': u.not_null,
+                 'email': u'juju@localhost'}
+        expected = [user1, user2, user3]
+        actual = self.keystone.users.list()
+
+        ret = u.validate_user_data(expected, actual)
+        if ret:
+            amulet.raise_status(amulet.FAIL, msg=ret)
+
+    def test_service_catalog(self):
+        """Verify that the service catalog endpoint data is valid."""
+        endpoint_vol = {'adminURL': u.valid_url,
+                        'region': 'RegionOne',
+                        'publicURL': u.valid_url,
+                        'internalURL': u.valid_url}
+        endpoint_id = {'adminURL': u.valid_url,
+                       'region': 'RegionOne',
+                       'publicURL': u.valid_url,
+                       'internalURL': u.valid_url}
+        if self._get_openstack_release() > self.precise_essex:
+            endpoint_vol['id'] = u.not_null
+            endpoint_id['id'] = u.not_null
+        expected = {'volume': [endpoint_vol], 'identity': [endpoint_id]}
+        actual = self.keystone_demo.service_catalog.get_endpoints()
+
+        ret = u.validate_svc_catalog_endpoint_data(expected, actual)
+        if ret:
+            amulet.raise_status(amulet.FAIL, msg=ret)
+
+    def test_keystone_endpoint(self):
+        """Verify the keystone endpoint data."""
+        endpoints = self.keystone.endpoints.list()
+        admin_port = '35357'
+        internal_port = public_port = '5000'
+        expected = {'id': u.not_null,
+                    'region': 'RegionOne',
+                    'adminurl': u.valid_url,
+                    'internalurl': u.valid_url,
+                    'publicurl': u.valid_url,
+                    'service_id': u.not_null}
+        ret = u.validate_endpoint_data(endpoints, admin_port, internal_port,
+                                       public_port, expected)
+        if ret:
+            amulet.raise_status(amulet.FAIL,
+                                msg='keystone endpoint: {}'.format(ret))
+
+    def test_cinder_endpoint(self):
+        """Verify the cinder endpoint data."""
+        endpoints = self.keystone.endpoints.list()
+        admin_port = internal_port = public_port = '8776'
+        expected = {'id': u.not_null,
+                    'region': 'RegionOne',
+                    'adminurl': u.valid_url,
+                    'internalurl': u.valid_url,
+                    'publicurl': u.valid_url,
+                    'service_id': u.not_null}
+        ret = u.validate_endpoint_data(endpoints, admin_port, internal_port,
+                                       public_port, expected)
+        if ret:
+            amulet.raise_status(amulet.FAIL,
+                                msg='cinder endpoint: {}'.format(ret))
+
+    def test_keystone_shared_db_relation(self):
+        """Verify the keystone shared-db relation data"""
+        unit = self.keystone_sentry
+        relation = ['shared-db', 'mysql:shared-db']
+        expected = {
+            'username': 'keystone',
+            'private-address': u.valid_ip,
+            'hostname': u.valid_ip,
+            'database': 'keystone'
+        }
+        ret = u.validate_relation_data(unit, relation, expected)
+        if ret:
+            message = u.relation_error('keystone shared-db', ret)
+            amulet.raise_status(amulet.FAIL, msg=message)
+
+    def test_mysql_shared_db_relation(self):
+        """Verify the mysql shared-db relation data"""
+        unit = self.mysql_sentry
+        relation = ['shared-db', 'keystone:shared-db']
+        expected_data = {
+            'private-address': u.valid_ip,
+            'password': u.not_null,
+            'db_host': u.valid_ip
+        }
+        ret = u.validate_relation_data(unit, relation, expected_data)
+        if ret:
+            message = u.relation_error('mysql shared-db', ret)
+            amulet.raise_status(amulet.FAIL, msg=message)
+
+    def test_keystone_identity_service_relation(self):
+        """Verify the keystone identity-service relation data"""
+        unit = self.keystone_sentry
+        relation = ['identity-service', 'cinder:identity-service']
+        expected = {
+            'service_protocol': 'http',
+            'service_tenant': 'services',
+            'admin_token': 'ubuntutesting',
+            'service_password': u.not_null,
+            'service_port': '5000',
+            'auth_port': '35357',
+            'auth_protocol': 'http',
+            'private-address': u.valid_ip,
+            'https_keystone': 'False',
+            'auth_host': u.valid_ip,
+            'service_username': 'cinder',
+            'service_tenant_id': u.not_null,
+            'service_host': u.valid_ip
+        }
+        ret = u.validate_relation_data(unit, relation, expected)
+        if ret:
+            message = u.relation_error('cinder identity-service', ret)
+            amulet.raise_status(amulet.FAIL, msg=message)
+
+    def test_cinder_identity_service_relation(self):
+        """Verify the cinder identity-service relation data"""
+        unit = self.cinder_sentry
+        relation = ['identity-service', 'keystone:identity-service']
+        expected = {
+            'service': 'cinder',
+            'region': 'RegionOne',
+            'public_url': u.valid_url,
+            'internal_url': u.valid_url,
+            'private-address': u.valid_ip,
+            'admin_url': u.valid_url
+        }
+        ret = u.validate_relation_data(unit, relation, expected)
+        if ret:
+            message = u.relation_error('cinder identity-service', ret)
+            amulet.raise_status(amulet.FAIL, msg=message)
+
+    def test_restart_on_config_change(self):
+        """Verify that keystone is restarted when the config is changed."""
+        self.d.configure('keystone', {'verbose': 'True'})
+        if not u.service_restarted(self.keystone_sentry, 'keystone-all',
+                                   '/etc/keystone/keystone.conf'):
+            message = "keystone service didn't restart after config change"
+            amulet.raise_status(amulet.FAIL, msg=message)
+        self.d.configure('keystone', {'verbose': 'False'})
+
+    def test_default_config(self):
+        """Verify the data in the keystone config file's default section,
+           comparing some of the variables vs relation data."""
+        unit = self.keystone_sentry
+        conf = '/etc/keystone/keystone.conf'
+        relation = unit.relation('identity-service', 'cinder:identity-service')
+        expected = {'admin_token': relation['admin_token'],
+                    'admin_port': relation['auth_port'],
+                    'public_port': relation['service_port'],
+                    'use_syslog': 'False',
+                    'log_config': '/etc/keystone/logging.conf',
+                    'debug': 'False',
+                    'verbose': 'False'}
+
+        ret = u.validate_config_data(unit, conf, 'DEFAULT', expected)
+        if ret:
+            message = "keystone config error: {}".format(ret)
+            amulet.raise_status(amulet.FAIL, msg=message)
+
+    def test_database_config(self):
+        """Verify the data in the keystone config file's database (or sql
+           depending on release) section, comparing vs relation data."""
+        unit = self.keystone_sentry
+        conf = '/etc/keystone/keystone.conf'
+        relation = self.mysql_sentry.relation('shared-db', 'keystone:shared-db')
+        db_uri = "mysql://{}:{}@{}/{}".format('keystone', relation['password'],
+                                              relation['db_host'], 'keystone')
+        expected = {'connection': db_uri, 'idle_timeout': '200'}
+
+        if self._get_openstack_release() > self.precise_havana:
+            ret = u.validate_config_data(unit, conf, 'database', expected)
+        else:
+            ret = u.validate_config_data(unit, conf, 'sql', expected)
+        if ret:
+            message = "keystone config error: {}".format(ret)
+            amulet.raise_status(amulet.FAIL, msg=message)

=== added directory 'tests/charmhelpers'
=== added file 'tests/charmhelpers/__init__.py'
=== added directory 'tests/charmhelpers/contrib'
=== added file 'tests/charmhelpers/contrib/__init__.py'
=== added directory 'tests/charmhelpers/contrib/amulet'
=== added file 'tests/charmhelpers/contrib/amulet/__init__.py'
=== added file 'tests/charmhelpers/contrib/amulet/deployment.py'
--- tests/charmhelpers/contrib/amulet/deployment.py	1970-01-01 00:00:00 +0000
+++ tests/charmhelpers/contrib/amulet/deployment.py	2014-06-20 13:39:25 +0000
@@ -0,0 +1,58 @@
+import amulet
+
+
+class AmuletDeployment(object):
+    """This class provides generic Amulet deployment and test runner
+       methods."""
+
+    def __init__(self, series=None):
+        """Initialize the deployment environment."""
+        self.series = None
+
+        if series:
+            self.series = series
+            self.d = amulet.Deployment(series=self.series)
+        else:
+            self.d = amulet.Deployment()
+
+    def _add_services(self, this_service, other_services):
+        """Add services to the deployment where this_service is the local charm
+           that we're focused on testing and other_services are the other
+           charms that come from the charm store."""
+        name, units = range(2)
+        self.this_service = this_service[name]
+        self.d.add(this_service[name], units=this_service[units])
+
+        for svc in other_services:
+            if self.series:
+                self.d.add(svc[name],
+                           charm='cs:{}/{}'.format(self.series, svc[name]),
+                           units=svc[units])
+            else:
+                self.d.add(svc[name], units=svc[units])
+
+    def _add_relations(self, relations):
+        """Add all of the relations for the services."""
+        for k, v in relations.iteritems():
+            self.d.relate(k, v)
+
+    def _configure_services(self, configs):
+        """Configure all of the services."""
+        for service, config in configs.iteritems():
+            self.d.configure(service, config)
+
+    def _deploy(self):
+        """Deploy environment and wait for all hooks to finish executing."""
+        try:
+            self.d.setup()
+            self.d.sentry.wait()
+        except amulet.helpers.TimeoutError:
+            amulet.raise_status(amulet.FAIL, msg="Deployment timed out")
+        except:
+            raise
+
+    def run_tests(self):
+        """Run all of the methods that are prefixed with 'test_'."""
+        for test in dir(self):
+            if test.startswith('test_'):
+                getattr(self, test)()

=== added file 'tests/charmhelpers/contrib/amulet/utils.py'
--- tests/charmhelpers/contrib/amulet/utils.py	1970-01-01 00:00:00 +0000
+++ tests/charmhelpers/contrib/amulet/utils.py	2014-06-20 13:39:25 +0000
@@ -0,0 +1,153 @@
+import ConfigParser
+import io
+import logging
+import re
+import sys
+from time import sleep
+
+
+class AmuletUtils(object):
+    """This class provides common utility functions that are used by Amulet
+       tests."""
+
+    def __init__(self, log_level=logging.ERROR):
+        self.log = self.get_logger(level=log_level)
+
+    def get_logger(self, name="amulet-logger", level=logging.DEBUG):
+        """Get a logger object that will log to stdout."""
+        log = logging
+        logger = log.getLogger(name)
+        fmt = \
+            log.Formatter("%(asctime)s %(funcName)s %(levelname)s: %(message)s")
+
+        handler = log.StreamHandler(stream=sys.stdout)
+        handler.setLevel(level)
+        handler.setFormatter(fmt)
+
+        logger.addHandler(handler)
+        logger.setLevel(level)
+
+        return logger
+
+    def valid_ip(self, ip):
+        if re.match(r"^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$", ip):
+            return True
+        else:
+            return False
+
+    def valid_url(self, url):
+        p = re.compile(
+            r'^(?:http|ftp)s?://'
+            r'(?:(?:[A-Z0-9](?:[A-Z0-9-]{0,61}[A-Z0-9])?\.)+(?:[A-Z]{2,6}\.?|[A-Z0-9-]{2,}\.?)|' # flake8: noqa
+            r'localhost|'
+            r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})'
+            r'(?::\d+)?'
+            r'(?:/?|[/?]\S+)$',
+            re.IGNORECASE)
+        if p.match(url):
+            return True
+        else:
+            return False
+
+    def validate_services(self, commands):
+        """Verify the specified services are running on the corresponding
+           service units."""
+        for k, v in commands.iteritems():
+            output, code = k.run(v)
+            if code != 0:
+                return "command `{}` returned {}".format(v, str(code))
+        return None
+
+    def _get_config(self, unit, filename):
+        """Get a ConfigParser object for parsing a unit's config file."""
+        file_contents = unit.file_contents(filename)
+        config = ConfigParser.ConfigParser()
+        config.readfp(io.StringIO(file_contents))
+        return config
+
+    def validate_config_data(self, sentry_unit, config_file, section, expected):
+        """Verify that the specified section of the config file contains
+           the expected option key:value pairs."""
+        config = self._get_config(sentry_unit, config_file)
+
+        if section != 'DEFAULT' and not config.has_section(section):
+            return "section [{}] does not exist".format(section)
+
+        for k in expected.keys():
+            if not config.has_option(section, k):
+                return "section [{}] is missing option {}".format(section, k)
+            if config.get(section, k) != expected[k]:
+                return "section [{}] {}:{} != expected {}:{}".format(section,
+                       k, config.get(section, k), k, expected[k])
+        return None
+
+    def _validate_dict_data(self, expected, actual):
+        """Compare expected dictionary data vs actual dictionary data.
+           The values in the 'expected' dictionary can be strings, bools, ints,
+           longs, or can be a function that evaluate a variable and returns a
+           bool."""
+        for k, v in expected.iteritems():
+            if k in actual:
+                if isinstance(v, basestring) or \
+                   isinstance(v, bool) or \
+                   isinstance(v, (int, long)):
+                    if v != actual[k]:
+                        return "{}:{}".format(k, actual[k])
+                elif not v(actual[k]):
+                    return "{}:{}".format(k, actual[k])
+            else:
+                return "key '{}' does not exist".format(k)
+        return None
+
+    def validate_relation_data(self, sentry_unit, relation, expected):
+        """Validate actual relation data based on expected relation data."""
+        actual = sentry_unit.relation(relation[0], relation[1])
+        self.log.debug('actual: {}'.format(repr(actual)))
+        return self._validate_dict_data(expected, actual)
+
+    def _validate_list_data(self, expected, actual):
+        """Compare expected list vs actual list data."""
+        for e in expected:
+            if e not in actual:
+                return "expected item {} not found in actual list".format(e)
+        return None
+
+    def not_null(self, string):
+        if string != None:
+            return True
+        else:
+            return False
+
+    def _get_file_mtime(self, sentry_unit, filename):
+        """Get last modification time of file."""
+        return sentry_unit.file_stat(filename)['mtime']
+
+    def _get_dir_mtime(self, sentry_unit, directory):
+        """Get last modification time of directory."""
+        return sentry_unit.directory_stat(directory)['mtime']
+
+    def _get_proc_start_time(self, sentry_unit, service):
+        """Determine start time of the process based on the last modification
+           time of the /proc/pid directory.  The servie string will be matched
+           against any substring in the full command line, choosing the oldest
+           process."""
+        cmd = 'pgrep -f -o {}'.format(service)
+        proc_dir = '/proc/{}'.format(sentry_unit.run(cmd)[0].strip())
+        return self._get_dir_mtime(sentry_unit, proc_dir)
+
+    def service_restarted(self, sentry_unit, service, filename):
+        """Compare a service's start time vs a file's last modification time
+           (such as a config file for that service) to determine if the service
+           has been restarted."""
+        sleep(10)
+        if self._get_proc_start_time(sentry_unit, service) >= \
+           self._get_file_mtime(sentry_unit, filename):
+            return True
+        else:
+            return False
+
+    def relation_error(self, name, data):
+        return 'unexpected relation data in {} - {}'.format(name, data)
+
+    def endpoint_error(self, name, data):
+        return 'unexpected endpoint data in {} - {}'.format(name, data)

=== added directory 'tests/charmhelpers/contrib/openstack'
=== added file 'tests/charmhelpers/contrib/openstack/__init__.py'
=== added directory 'tests/charmhelpers/contrib/openstack/amulet'
=== added file 'tests/charmhelpers/contrib/openstack/amulet/__init__.py'
=== added file 'tests/charmhelpers/contrib/openstack/amulet/deployment.py'
--- tests/charmhelpers/contrib/openstack/amulet/deployment.py	1970-01-01 00:00:00 +0000
+++ tests/charmhelpers/contrib/openstack/amulet/deployment.py	2014-06-20 13:39:25 +0000
@@ -0,0 +1,38 @@
+from charmhelpers.contrib.amulet.deployment import (
+    AmuletDeployment
+)
+
+
+class OpenStackAmuletDeployment(AmuletDeployment):
+    """This class inherits from AmuletDeployment and has additional support
+       that is specifically for use by OpenStack charms."""
+
+    def __init__(self, series=None, openstack=None):
+        """Initialize the deployment environment."""
+        self.openstack = None
+        super(OpenStackAmuletDeployment, self).__init__(series)
+
+        if openstack:
+            self.openstack = openstack
+
+    def _configure_services(self, configs):
+        """Configure all of the services."""
+        for service, config in configs.iteritems():
+            if service == self.this_service:
+                config['openstack-origin'] = self.openstack
+            self.d.configure(service, config)
+
+    def _get_openstack_release(self):
+        """Return an integer representing the enum value of the openstack
+           release."""
+        self.precise_essex, self.precise_folsom, self.precise_grizzly, \
+            self.precise_havana, self.precise_icehouse, \
+            self.trusty_icehouse = range(6)
+        releases = {
+            ('precise', None): self.precise_essex,
+            ('precise', 'cloud:precise-folsom'): self.precise_folsom,
+            ('precise', 'cloud:precise-grizzly'): self.precise_grizzly,
+            ('precise', 'cloud:precise-havana'): self.precise_havana,
+            ('precise', 'cloud:precise-icehouse'): self.precise_icehouse,
+            ('trusty', None): self.trusty_icehouse}
+        return releases[(self.series, self.openstack)]

=== added file 'tests/charmhelpers/contrib/openstack/amulet/utils.py'
--- tests/charmhelpers/contrib/openstack/amulet/utils.py	1970-01-01 00:00:00 +0000
+++ tests/charmhelpers/contrib/openstack/amulet/utils.py	2014-06-20 13:39:25 +0000
@@ -0,0 +1,151 @@
+import logging
+
+import glanceclient.v1.client as glance_client
+import keystoneclient.v2_0 as keystone_client
+import novaclient.v1_1.client as nova_client
+
+from charmhelpers.contrib.amulet.utils import (
+    AmuletUtils
+)
+
+DEBUG = logging.DEBUG
+ERROR = logging.ERROR
+
+
+class OpenStackAmuletUtils(AmuletUtils):
+    """This class inherits from AmuletUtils and has additional support
+       that is specifically for use by OpenStack charms."""
+
+    def __init__(self, log_level=ERROR):
+        """Initialize the deployment environment."""
+        super(OpenStackAmuletUtils, self).__init__(log_level)
+
+    def validate_endpoint_data(self, endpoints, admin_port, internal_port,
+                               public_port, expected):
+        """Validate actual endpoint data vs expected endpoint data. The ports
+           are used to find the matching endpoint."""
+        found = False
+        for ep in endpoints:
+            self.log.debug('endpoint: {}'.format(repr(ep)))
+            if admin_port in ep.adminurl and internal_port in ep.internalurl \
+               and public_port in ep.publicurl:
+                found = True
+                actual = {'id': ep.id,
+                          'region': ep.region,
+                          'adminurl': ep.adminurl,
+                          'internalurl': ep.internalurl,
+                          'publicurl': ep.publicurl,
+                          'service_id': ep.service_id}
+                ret = self._validate_dict_data(expected, actual)
+                if ret:
+                    return 'unexpected endpoint data - {}'.format(ret)
+
+        if not found:
+            return 'endpoint not found'
+
+    def validate_svc_catalog_endpoint_data(self, expected, actual):
+        """Validate a list of actual service catalog endpoints vs a list of
+           expected service catalog endpoints."""
+        self.log.debug('actual: {}'.format(repr(actual)))
+        for k, v in expected.iteritems():
+            if k in actual:
+                ret = self._validate_dict_data(expected[k][0], actual[k][0])
+                if ret:
+                    return self.endpoint_error(k, ret)
+            else:
+                return "endpoint {} does not exist".format(k)
+        return ret
+
+    def validate_tenant_data(self, expected, actual):
+        """Validate a list of actual tenant data vs list of expected tenant
+           data."""
+        self.log.debug('actual: {}'.format(repr(actual)))
+        for e in expected:
+            found = False
+            for act in actual:
+                a = {'enabled': act.enabled, 'description': act.description,
+                     'name': act.name, 'id': act.id}
+                if e['name'] == a['name']:
+                    found = True
+                    ret = self._validate_dict_data(e, a)
+                    if ret:
+                        return "unexpected tenant data - {}".format(ret)
+            if not found:
+                return "tenant {} does not exist".format(e.name)
+        return ret
+
+    def validate_role_data(self, expected, actual):
+        """Validate a list of actual role data vs a list of expected role
+           data."""
+        self.log.debug('actual: {}'.format(repr(actual)))
+        for e in expected:
+            found = False
+            for act in actual:
+                a = {'name': act.name, 'id': act.id}
+                if e['name'] == a['name']:
+                    found = True
+                    ret = self._validate_dict_data(e, a)
+                    if ret:
+                        return "unexpected role data - {}".format(ret)
+            if not found:
+                return "role {} does not exist".format(e.name)
+        return ret
+
+    def validate_user_data(self, expected, actual):
+        """Validate a list of actual user data vs a list of expected user
+           data."""
+        self.log.debug('actual: {}'.format(repr(actual)))
+        for e in expected:
+            found = False
+            for act in actual:
+                a = {'enabled': act.enabled, 'name': act.name,
+                     'email': act.email, 'tenantId': act.tenantId,
+                     'id': act.id}
+                if e['name'] == a['name']:
+                    found = True
+                    ret = self._validate_dict_data(e, a)
+                    if ret:
+                        return "unexpected user data - {}".format(ret)
+            if not found:
+                return "user {} does not exist".format(e.name)
+        return ret
+
+    def validate_flavor_data(self, expected, actual):
+        """Validate a list of actual flavors vs a list of expected flavors."""
+        self.log.debug('actual: {}'.format(repr(actual)))
+        act = [a.name for a in actual]
+        return self._validate_list_data(expected, act)
+
+    def tenant_exists(self, keystone, tenant):
+        """Return True if tenant exists"""
+        return tenant in [t.name for t in keystone.tenants.list()]
+
+    def authenticate_keystone_admin(self, keystone_sentry, user, password,
+                                    tenant):
+        """Authenticates admin user with the keystone admin endpoint."""
+        service_ip = \
+            keystone_sentry.relation('shared-db',
+                                     'mysql:shared-db')['private-address']
+        ep = "http://{}:35357/v2.0".format(service_ip.strip().decode('utf-8'))
+        return keystone_client.Client(username=user, password=password,
+                                      tenant_name=tenant, auth_url=ep)
+
+    def authenticate_keystone_user(self, keystone, user, password, tenant):
+        """Authenticates a regular user with the keystone public endpoint."""
+        ep = keystone.service_catalog.url_for(service_type='identity',
+                                              endpoint_type='publicURL')
+        return keystone_client.Client(username=user, password=password,
+                                      tenant_name=tenant, auth_url=ep)
+
+    def authenticate_glance_admin(self, keystone):
+        """Authenticates admin user with glance."""
+        ep = keystone.service_catalog.url_for(service_type='image',
+                                              endpoint_type='adminURL')
+        return glance_client.Client(ep, token=keystone.auth_token)
+
+    def authenticate_nova_user(self, keystone, user, password, tenant):
+        """Authenticates a regular user with nova-api."""
+        ep = keystone.service_catalog.url_for(service_type='identity',
+                                              endpoint_type='publicURL')
+        return nova_client.Client(username=user, api_key=password,
+                                  project_id=tenant, auth_url=ep)