update amulet test, remove tests for eol releases

tests/basic_deployment.py

@@ -2,6 +2,7 @@
 
 import amulet
 import swiftclient
+import time
 
 from charmhelpers.contrib.openstack.amulet.deployment import (
     OpenStackAmuletDeployment
@@ -37,8 +38,10 @@ class SwiftProxyBasicDeployment(OpenStackAmuletDeployment):
            compatible with the local charm (e.g. stable or next).
            """
         this_service = {'name': 'swift-proxy'}
-        other_services = [{'name': 'mysql'}, {'name': 'keystone'},
+        other_services = [{'name': 'mysql'},
-                          {'name': 'glance'}, {'name': 'swift-storage'}]
+                          {'name': 'keystone'},
+                          {'name': 'glance'},
+                          {'name': 'swift-storage'}]
         super(SwiftProxyBasicDeployment, self)._add_services(this_service,
                                                              other_services)
 
@@ -86,6 +89,14 @@ class SwiftProxyBasicDeployment(OpenStackAmuletDeployment):
         self.swift_proxy_sentry = self.d.sentry.unit['swift-proxy/0']
         self.swift_storage_sentry = self.d.sentry.unit['swift-storage/0']
 
+        u.log.debug('openstack release val: {}'.format(
+            self._get_openstack_release()))
+        u.log.debug('openstack release str: {}'.format(
+            self._get_openstack_release_string()))
+
+        # Let things settle a bit before moving forward
+        time.sleep(30)
+
         # Authenticate admin with keystone
         self.keystone = u.authenticate_keystone_admin(self.keystone_sentry,
                                                       user='admin',
@@ -127,39 +138,39 @@ class SwiftProxyBasicDeployment(OpenStackAmuletDeployment):
                                          password='password',
                                          tenant=self.demo_tenant)
 
-    def test_services(self):
+    def test_100_services(self):
         """Verify the expected services are running on the corresponding
            service units."""
-        swift_storage_services = ['status swift-account',
+        u.log.debug('Checking system services...')
-                                  'status swift-account-auditor',
+        swift_storage_services = ['swift-account',
-                                  'status swift-account-reaper',
+                                  'swift-account-auditor',
-                                  'status swift-account-replicator',
+                                  'swift-account-reaper',
-                                  'status swift-container',
+                                  'swift-account-replicator',
-                                  'status swift-container-auditor',
+                                  'swift-container',
-                                  'status swift-container-replicator',
+                                  'swift-container-auditor',
-                                  'status swift-container-updater',
+                                  'swift-container-replicator',
-                                  'status swift-object',
+                                  'swift-container-updater',
-                                  'status swift-object-auditor',
+                                  'swift-object',
-                                  'status swift-object-replicator',
+                                  'swift-object-auditor',
-                                  'status swift-object-updater']
+                                  'swift-object-replicator',
-        if self._get_openstack_release() >= self.precise_icehouse:
+                                  'swift-object-updater',
-            swift_storage_services.append('status swift-container-sync')
+                                  'swift-container-sync']
-
+        service_names = {
-        commands = {
+            self.mysql_sentry: ['mysql'],
-            self.mysql_sentry: ['status mysql'],
+            self.keystone_sentry: ['keystone'],
-            self.keystone_sentry: ['status keystone'],
+            self.glance_sentry: ['glance-registry',
-            self.glance_sentry: ['status glance-registry',
+                                 'glance-api'],
-                                 'status glance-api'],
+            self.swift_proxy_sentry: ['swift-proxy'],
-            self.swift_proxy_sentry: ['status swift-proxy'],
             self.swift_storage_sentry: swift_storage_services
         }
 
-        ret = u.validate_services(commands)
+        ret = u.validate_services_by_name(service_names)
         if ret:
             amulet.raise_status(amulet.FAIL, msg=ret)
 
-    def test_users(self):
+    def test_102_users(self):
         """Verify all existing roles."""
+        u.log.debug('Checking keystone users...')
         user1 = {'name': 'demoUser',
                  'enabled': True,
                  'tenantId': u.not_null,
@@ -187,19 +198,15 @@ class SwiftProxyBasicDeployment(OpenStackAmuletDeployment):
         if ret:
             amulet.raise_status(amulet.FAIL, msg=ret)
 
-    def test_service_catalog(self):
+    def test_104_keystone_service_catalog(self):
         """Verify that the service catalog endpoint data is valid."""
-        endpoint_vol = {'adminURL': u.valid_url,
+        u.log.debug('Checking keystone service catalog...')
-                        '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}
+                       'internalURL': u.valid_url,
-        if self._get_openstack_release() >= self.precise_folsom:
+                       'id': u.not_null}
-            endpoint_vol['id'] = u.not_null
+
-            endpoint_id['id'] = u.not_null
         expected = {'image': [endpoint_id], 'object-store': [endpoint_id],
                     'identity': [endpoint_id]}
         actual = self.keystone_demo.service_catalog.get_endpoints()
@@ -208,8 +215,9 @@ class SwiftProxyBasicDeployment(OpenStackAmuletDeployment):
         if ret:
             amulet.raise_status(amulet.FAIL, msg=ret)
 
-    def test_openstack_object_store_endpoint(self):
+    def test_106_swift_object_store_endpoint(self):
         """Verify the swift object-store endpoint data."""
+        u.log.debug('Checking keystone endpoint for swift object store...')
         endpoints = self.keystone.endpoints.list()
         admin_port = internal_port = public_port = '8080'
         expected = {'id': u.not_null,
@@ -225,8 +233,9 @@ class SwiftProxyBasicDeployment(OpenStackAmuletDeployment):
             message = 'object-store endpoint: {}'.format(ret)
             amulet.raise_status(amulet.FAIL, msg=message)
 
-    def test_swift_proxy_identity_service_relation(self):
+    def test_200_swift_proxy_identity_service_relation(self):
         """Verify the swift-proxy to keystone identity relation data."""
+        u.log.debug('Checking swift-proxy:keystone identity relation...')
         unit = self.swift_proxy_sentry
         relation = ['identity-service', 'keystone:identity-service']
         expected = {
@@ -244,8 +253,9 @@ class SwiftProxyBasicDeployment(OpenStackAmuletDeployment):
             message = u.relation_error('swift-proxy identity-service', ret)
             amulet.raise_status(amulet.FAIL, msg=message)
 
-    def test_keystone_identity_service_relation(self):
+    def test_202_keystone_identity_service_relation(self):
         """Verify the keystone to swift-proxy identity relation data."""
+        u.log.debug('Checking keystone:swift-proxy identity relation...')
         unit = self.keystone_sentry
         relation = ['identity-service', 'swift-proxy:identity-service']
         expected = {
@@ -268,9 +278,10 @@ class SwiftProxyBasicDeployment(OpenStackAmuletDeployment):
             message = u.relation_error('keystone identity-service', ret)
             amulet.raise_status(amulet.FAIL, msg=message)
 
-    def test_swift_storage_swift_storage_relation(self):
+    def test_204_swift_storage_swift_storage_relation(self):
         """Verify the swift-storage to swift-proxy swift-storage relation
            data."""
+        u.log.debug('Checking swift:swift-proxy swift-storage relation...')
         unit = self.swift_storage_sentry
         relation = ['swift-storage', 'swift-proxy:swift-storage']
         expected = {
@@ -287,9 +298,10 @@ class SwiftProxyBasicDeployment(OpenStackAmuletDeployment):
             message = u.relation_error('swift-storage swift-storage', ret)
             amulet.raise_status(amulet.FAIL, msg=message)
 
-    def test_swift_proxy_swift_storage_relation(self):
+    def test_206_swift_proxy_swift_storage_relation(self):
         """Verify the swift-proxy to swift-storage swift-storage relation
            data."""
+        u.log.debug('Checking swift-proxy:swift swift-storage relation...')
         unit = self.swift_proxy_sentry
         relation = ['swift-storage', 'swift-storage:swift-storage']
         expected = {
@@ -304,8 +316,9 @@ class SwiftProxyBasicDeployment(OpenStackAmuletDeployment):
             message = u.relation_error('swift-proxy swift-storage', ret)
             amulet.raise_status(amulet.FAIL, msg=message)
 
-    def test_glance_object_store_relation(self):
+    def test_208_glance_object_store_relation(self):
         """Verify the glance to swift-proxy object-store relation data."""
+        u.log.debug('Checking glance:swift-proxy object-store relation...')
         unit = self.glance_sentry
         relation = ['object-store', 'swift-proxy:object-store']
         expected = {'private-address': u.valid_ip}
@@ -315,8 +328,9 @@ class SwiftProxyBasicDeployment(OpenStackAmuletDeployment):
             message = u.relation_error('glance object-store', ret)
             amulet.raise_status(amulet.FAIL, msg=message)
 
-    def test_swift_proxy_object_store_relation(self):
+    def test_210_swift_proxy_object_store_relation(self):
         """Verify the swift-proxy to glance object-store relation data."""
+        u.log.debug('Checking swift-proxy:glance object-store relation...')
         unit = self.swift_proxy_sentry
         relation = ['object-store', 'glance:object-store']
         expected = {'private-address': u.valid_ip}
@@ -325,31 +339,14 @@ class SwiftProxyBasicDeployment(OpenStackAmuletDeployment):
             message = u.relation_error('swift-proxy object-store', ret)
             amulet.raise_status(amulet.FAIL, msg=message)
 
-    def test_z_restart_on_config_change(self):
+    def test_300_swift_config(self):
-        """Verify that the specified services are restarted when the config
+        """Verify the data in the swift-hash section of the swift config
-           is changed.
+           file."""
-
+        u.log.debug('Checking swift config...')
-           Note(coreycb): The method name with the _z_ is a little odd
+        unit = self.swift_storage_sentry
-           but it forces the test to run last.  It just makes things
-           easier because restarting services requires re-authorization.
-           """
-        svc = 'swift-proxy'
-        self.d.configure('swift-proxy', {'node-timeout': '90'})
-
-        if not u.service_restarted(self.swift_proxy_sentry, svc,
-                                   '/etc/swift/proxy-server.conf'):
-            self.d.configure('swift-proxy', {'node-timeout': '60'})
-            msg = "service {} didn't restart after config change".format(svc)
-            amulet.raise_status(amulet.FAIL, msg=msg)
-
-        self.d.configure('swift-proxy', {'node-timeout': '60'})
-
-    def test_swift_config(self):
-        """Verify the data in the swift config file."""
-        unit = self.swift_proxy_sentry
         conf = '/etc/swift/swift.conf'
-        swift_proxy_relation = unit.relation('swift-storage',
+        swift_proxy_relation = self.swift_proxy_sentry.relation(
-                                             'swift-storage:swift-storage')
+            'swift-storage', 'swift-storage:swift-storage')
         expected = {
             'swift_hash_path_suffix': swift_proxy_relation['swift_hash']
         }
@@ -359,11 +356,9 @@ class SwiftProxyBasicDeployment(OpenStackAmuletDeployment):
             message = "swift config error: {}".format(ret)
             amulet.raise_status(amulet.FAIL, msg=message)
 
-    def test_proxy_server_icehouse_config(self):
+    def test_302_proxy_server_config(self):
         """Verify the data in the proxy-server config file."""
-        if self._get_openstack_release() < self.precise_icehouse:
+        u.log.debug('Checking swift proxy-server config...')
-            return
-
         unit = self.swift_proxy_sentry
         conf = '/etc/swift/proxy-server.conf'
         keystone_relation = self.keystone_sentry.relation(
@@ -460,378 +455,23 @@ class SwiftProxyBasicDeployment(OpenStackAmuletDeployment):
                 message = "proxy-server config error: {}".format(ret)
                 amulet.raise_status(amulet.FAIL, msg=message)
 
-    def test_proxy_server_havana_config(self):
+    def test_400_swift_backed_image_create(self):
-        """Verify the data in the proxy-server config file."""
+        """Create an instance in glance, which is backed by swift, and validate
-        if self._get_openstack_release() != self.precise_havana:
+        that some of the metadata for the image match in glance and swift."""
-            return
+        u.log.debug('Checking swift objects and containers with a '
+                    'swift-backed glance image...')
 
-        unit = self.swift_proxy_sentry
+        # Create swift-backed glance image
-        conf = '/etc/swift/proxy-server.conf'
+        img_new = u.create_cirros_image(self.glance, "cirros-image-1")
-        keystone_relation = self.keystone_sentry.relation(
+        img_id = img_new.id
-            'identity-service', 'swift-proxy:identity-service')
+        img_md5 = img_new.checksum
-        swift_proxy_relation = unit.relation(
+        img_size = img_new.size
-            'identity-service', 'keystone:identity-service')
-        swift_proxy_ip = swift_proxy_relation['private-address']
-        auth_host = keystone_relation['auth_host']
-        auth_protocol = keystone_relation['auth_protocol']
-
-        expected = {
-            'DEFAULT': {
-                'bind_port': '8070',
-                'user': 'swift'
-            },
-            'pipeline:main': {
-                'pipeline': 'healthcheck cache swift3 authtoken '
-                            'keystoneauth container-quotas account-quotas '
-                            'proxy-server'
-            },
-            'app:proxy-server': {
-                'use': 'egg:swift#proxy',
-                'allow_account_management': 'true',
-                'account_autocreate': 'true',
-                'node_timeout': '60',
-                'recoverable_node_timeout': '30'
-            },
-            'filter:tempauth': {
-                'use': 'egg:swift#tempauth',
-                'user_system_root': 'testpass .admin https://{}:8080/v1/'
-                                    'AUTH_system'.format(swift_proxy_ip)
-            },
-            'filter:healthcheck': {'use': 'egg:swift#healthcheck'},
-            'filter:cache': {
-                'use': 'egg:swift#memcache',
-                'memcache_servers': '{}:11211'.format(swift_proxy_ip)
-            },
-            'filter:account-quotas': {'use': 'egg:swift#account_quotas'},
-            'filter:container-quotas': {'use': 'egg:swift#container_quotas'},
-            'filter:keystoneauth': {
-                'use': 'egg:swift#keystoneauth',
-                'operator_roles': 'Member,Admin'
-            },
-            'filter:authtoken': {
-                'paste.filter_factory': 'keystoneclient.middleware.'
-                                        'auth_token:filter_factory',
-                'auth_host': auth_host,
-                'auth_port': keystone_relation['auth_port'],
-                'auth_protocol': auth_protocol,
-                'auth_uri': '{}://{}:{}'.format(
-                    auth_protocol,
-                    auth_host,
-                    keystone_relation['service_port']),
-                'admin_tenant_name': keystone_relation['service_tenant'],
-                'admin_user': keystone_relation['service_username'],
-                'admin_password': keystone_relation['service_password'],
-                'delay_auth_decision': 'true',
-                'signing_dir': '/var/cache/swift',
-                'cache': 'swift.cache'
-            },
-            'filter:s3token': {
-                'paste.filter_factory': 'keystone.middleware.s3_token:'
-                                        'filter_factory',
-                'service_host': keystone_relation['service_host'],
-                'service_port': keystone_relation['service_port'],
-                'auth_port': keystone_relation['auth_port'],
-                'auth_host': keystone_relation['auth_host'],
-                'auth_protocol': keystone_relation['auth_protocol'],
-                'auth_token': keystone_relation['admin_token'],
-                'admin_token': keystone_relation['admin_token'],
-                'service_protocol': keystone_relation['service_protocol']
-            },
-            'filter:swift3': {'use': 'egg:swift3#swift3'}
-        }
-
-        for section, pairs in expected.iteritems():
-            ret = u.validate_config_data(unit, conf, section, pairs)
-            if ret:
-                message = "proxy-server config error: {}".format(ret)
-                amulet.raise_status(amulet.FAIL, msg=message)
-
-    def test_proxy_server_grizzly_config(self):
-        """Verify the data in the proxy-server config file."""
-        if self._get_openstack_release() != self.precise_grizzly:
-            return
-
-        unit = self.swift_proxy_sentry
-        conf = '/etc/swift/proxy-server.conf'
-        keystone_relation = self.keystone_sentry.relation(
-            'identity-service', 'swift-proxy:identity-service')
-        swift_proxy_relation = unit.relation(
-            'identity-service', 'keystone:identity-service')
-        swift_proxy_ip = swift_proxy_relation['private-address']
-        auth_host = keystone_relation['auth_host']
-        auth_protocol = keystone_relation['auth_protocol']
-
-        expected = {
-            'DEFAULT': {
-                'bind_port': '8070',
-                'user': 'swift'
-            },
-            'pipeline:main': {
-                'pipeline': 'healthcheck cache swift3 s3token authtoken '
-                            'keystone container-quotas account-quotas '
-                            'proxy-server'
-            },
-            'app:proxy-server': {
-                'use': 'egg:swift#proxy',
-                'allow_account_management': 'true',
-                'account_autocreate': 'true',
-                'node_timeout': '60',
-                'recoverable_node_timeout': '30'
-            },
-            'filter:tempauth': {
-                'use': 'egg:swift#tempauth',
-                'user_system_root': 'testpass .admin https://{}:8080/v1/'
-                                    'AUTH_system'.format(swift_proxy_ip)
-            },
-            'filter:healthcheck': {'use': 'egg:swift#healthcheck'},
-            'filter:cache': {
-                'use': 'egg:swift#memcache',
-                'memcache_servers': '{}:11211'.format(swift_proxy_ip)
-            },
-            'filter:account-quotas': {'use': 'egg:swift#account_quotas'},
-            'filter:container-quotas': {'use': 'egg:swift#container_quotas'},
-            'filter:keystone': {
-                'paste.filter_factory': 'swift.common.middleware.'
-                                        'keystoneauth:filter_factory',
-                'operator_roles': 'Member,Admin'
-            },
-            'filter:authtoken': {
-                'paste.filter_factory': 'keystone.middleware.auth_token:'
-                                        'filter_factory',
-                'auth_host': auth_host,
-                'auth_port': keystone_relation['auth_port'],
-                'auth_protocol': auth_protocol,
-                'auth_uri': '{}://{}:{}'.format(
-                    auth_protocol,
-                    auth_host,
-                    keystone_relation['service_port']),
-                'admin_tenant_name': keystone_relation['service_tenant'],
-                'admin_user': keystone_relation['service_username'],
-                'admin_password': keystone_relation['service_password'],
-                'delay_auth_decision': 'true',
-                'signing_dir': '/var/cache/swift'
-            },
-            'filter:s3token': {
-                'paste.filter_factory': 'keystone.middleware.s3_token:'
-                                        'filter_factory',
-                'service_host': keystone_relation['service_host'],
-                'service_port': keystone_relation['service_port'],
-                'auth_port': keystone_relation['auth_port'],
-                'auth_host': keystone_relation['auth_host'],
-                'auth_protocol': keystone_relation['auth_protocol'],
-                'auth_token': keystone_relation['admin_token'],
-                'admin_token': keystone_relation['admin_token'],
-                'service_protocol': keystone_relation['service_protocol']
-            },
-            'filter:swift3': {'use': 'egg:swift3#swift3'}
-        }
-
-        for section, pairs in expected.iteritems():
-            ret = u.validate_config_data(unit, conf, section, pairs)
-            if ret:
-                message = "proxy-server config error: {}".format(ret)
-                amulet.raise_status(amulet.FAIL, msg=message)
-
-    def test_proxy_server_folsom_config(self):
-        """Verify the data in the proxy-server config file."""
-        if self._get_openstack_release() != self.precise_folsom:
-            return
-
-        unit = self.swift_proxy_sentry
-        conf = '/etc/swift/proxy-server.conf'
-        keystone_relation = self.keystone_sentry.relation(
-            'identity-service', 'swift-proxy:identity-service')
-        swift_proxy_relation = unit.relation(
-            'identity-service', 'keystone:identity-service')
-        swift_proxy_ip = swift_proxy_relation['private-address']
-        auth_host = keystone_relation['auth_host']
-        auth_protocol = keystone_relation['auth_protocol']
-
-        expected = {
-            'DEFAULT': {
-                'bind_port': '8070',
-                'user': 'swift'
-            },
-            'pipeline:main': {
-                'pipeline': 'healthcheck cache swift3 s3token authtoken '
-                            'keystone proxy-server'
-            },
-            'app:proxy-server': {
-                'use': 'egg:swift#proxy',
-                'allow_account_management': 'true',
-                'account_autocreate': 'true',
-                'node_timeout': '60',
-                'recoverable_node_timeout': '30'
-            },
-            'filter:tempauth': {
-                'use': 'egg:swift#tempauth',
-                'user_system_root': 'testpass .admin https://{}:8080/v1/'
-                                    'AUTH_system'.format(swift_proxy_ip)
-            },
-            'filter:healthcheck': {'use': 'egg:swift#healthcheck'},
-            'filter:cache': {
-                'use': 'egg:swift#memcache',
-                'memcache_servers': '{}:11211'.format(swift_proxy_ip)
-            },
-            'filter:keystone': {
-                'paste.filter_factory': 'keystone.middleware.swift_auth:'
-                                        'filter_factory',
-                'operator_roles': 'Member,Admin'
-            },
-            'filter:authtoken': {
-                'paste.filter_factory': 'keystone.middleware.auth_token:'
-                                        'filter_factory',
-                'auth_host': auth_host,
-                'auth_port': keystone_relation['auth_port'],
-                'auth_protocol': auth_protocol,
-                'auth_uri': '{}://{}:{}'.format(
-                    auth_protocol,
-                    auth_host,
-                    keystone_relation['service_port']),
-                'admin_tenant_name': keystone_relation['service_tenant'],
-                'admin_user': keystone_relation['service_username'],
-                'admin_password': keystone_relation['service_password'],
-                'delay_auth_decision': '1'
-            },
-            'filter:s3token': {
-                'paste.filter_factory': 'keystone.middleware.s3_token:'
-                                        'filter_factory',
-                'service_host': keystone_relation['service_host'],
-                'service_port': keystone_relation['service_port'],
-                'auth_port': keystone_relation['auth_port'],
-                'auth_host': keystone_relation['auth_host'],
-                'auth_protocol': keystone_relation['auth_protocol'],
-                'auth_token': keystone_relation['admin_token'],
-                'admin_token': keystone_relation['admin_token'],
-                'service_protocol': keystone_relation['service_protocol']
-            },
-            'filter:swift3': {'use': 'egg:swift#swift3'}
-        }
-
-        for section, pairs in expected.iteritems():
-            ret = u.validate_config_data(unit, conf, section, pairs)
-            if ret:
-                message = "proxy-server config error: {}".format(ret)
-                amulet.raise_status(amulet.FAIL, msg=message)
-
-    def test_proxy_server_essex_config(self):
-        """Verify the data in the proxy-server config file."""
-        if self._get_openstack_release() != self.precise_essex:
-            return
-
-        unit = self.swift_proxy_sentry
-        conf = '/etc/swift/proxy-server.conf'
-        keystone_relation = self.keystone_sentry.relation(
-            'identity-service', 'swift-proxy:identity-service')
-        swift_proxy_relation = unit.relation(
-            'identity-service', 'keystone:identity-service')
-        swift_proxy_ip = swift_proxy_relation['private-address']
-        auth_host = keystone_relation['auth_host']
-        auth_protocol = keystone_relation['auth_protocol']
-
-        expected = {
-            'DEFAULT': {
-                'bind_port': '8070',
-                'user': 'swift'
-            },
-            'pipeline:main': {
-                'pipeline': 'healthcheck cache swift3 s3token authtoken '
-                            'keystone proxy-server'
-            },
-            'app:proxy-server': {
-                'use': 'egg:swift#proxy',
-                'allow_account_management': 'true',
-                'account_autocreate': 'true',
-                'node_timeout': '60',
-                'recoverable_node_timeout': '30'
-            },
-            'filter:tempauth': {
-                'use': 'egg:swift#tempauth',
-                'user_system_root': 'testpass .admin https://{}:8080/v1/'
-                                    'AUTH_system'.format(swift_proxy_ip)
-            },
-            'filter:healthcheck': {'use': 'egg:swift#healthcheck'},
-            'filter:cache': {
-                'use': 'egg:swift#memcache',
-                'memcache_servers': '{}:11211'.format(swift_proxy_ip)
-            },
-            'filter:keystone': {
-                'paste.filter_factory': 'keystone.middleware.swift_auth:'
-                                        'filter_factory',
-                'operator_roles': 'Member,Admin'
-            },
-            'filter:authtoken': {
-                'paste.filter_factory': 'keystone.middleware.auth_token:'
-                                        'filter_factory',
-                'auth_host': auth_host,
-                'auth_port': keystone_relation['auth_port'],
-                'auth_protocol': auth_protocol,
-                'auth_uri': '{}://{}:{}'.format(
-                    auth_protocol,
-                    auth_host,
-                    keystone_relation['service_port']),
-                'admin_tenant_name': keystone_relation['service_tenant'],
-                'admin_user': keystone_relation['service_username'],
-                'admin_password': keystone_relation['service_password'],
-                'delay_auth_decision': '1'
-            },
-            'filter:s3token': {
-                'paste.filter_factory': 'keystone.middleware.s3_token:'
-                                        'filter_factory',
-                'service_host': keystone_relation['service_host'],
-                'service_port': keystone_relation['service_port'],
-                'auth_port': keystone_relation['auth_port'],
-                'auth_host': keystone_relation['auth_host'],
-                'auth_protocol': keystone_relation['auth_protocol'],
-                'auth_token': keystone_relation['admin_token'],
-                'admin_token': keystone_relation['admin_token'],
-                'service_protocol': keystone_relation['service_protocol']
-            },
-            'filter:swift3': {'use': 'egg:swift#swift3'}
-        }
-
-        for section, pairs in expected.iteritems():
-            ret = u.validate_config_data(unit, conf, section, pairs)
-            if ret:
-                message = "proxy-server config error: {}".format(ret)
-                amulet.raise_status(amulet.FAIL, msg=message)
-
-    def test_image_create(self):
-        """Create an instance in glance, which is backed by swift, and
-        validate that some of the metadata for the image match in glance
-        and swift.
-        """
-        # NOTE(coreycb): Skipping failing test on folsom until resolved. On
-        #                folsom only, uploading an image to glance gets 400 Bad
-        #                Request - Error uploading image: (error): [Errno 111]
-        #                ECONNREFUSED (HTTP 400)
-        if self._get_openstack_release() == self.precise_folsom:
-            u.log.error("Skipping failing test until resolved")
-            return
-
-        # Create glance image
-        image = u.create_cirros_image(self.glance, "cirros-image")
-        if not image:
-            amulet.raise_status(amulet.FAIL, msg="Image create failed")
-
-        # Validate that cirros image exists in glance and get its checksum/size
-        images = list(self.glance.images.list())
-        if len(images) != 1:
-            msg = "Expected 1 glance image, found {}".format(len(images))
-            amulet.raise_status(amulet.FAIL, msg=msg)
-
-        if images[0].name != 'cirros-image':
-            message = "cirros image does not exist"
-            amulet.raise_status(amulet.FAIL, msg=message)
-
-        glance_image_md5 = image.checksum
-        glance_image_size = image.size
 
         # Validate that swift object's checksum/size match that from glance
         headers, containers = self.swift.get_account()
         if len(containers) != 1:
-            msg = ("Expected 1 swift container, found "
+            msg = "Expected 1 swift container, found {}".format(
-                   "{}".format(len(containers)))
+                len(containers))
             amulet.raise_status(amulet.FAIL, msg=msg)
 
         container_name = containers[0].get('name')
@@ -844,15 +484,48 @@ class SwiftProxyBasicDeployment(OpenStackAmuletDeployment):
         swift_object_size = objects[0].get('bytes')
         swift_object_md5 = objects[0].get('hash')
 
-        if glance_image_size != swift_object_size:
+        if img_size != swift_object_size:
-            msg = ("Glance image size {} != swift object size "
+            msg = "Glance image size {} != swift object size {}".format(
-                   "{}".format(glance_image_size, swift_object_size))
+                img_size, swift_object_size)
             amulet.raise_status(amulet.FAIL, msg=msg)
 
-        if glance_image_md5 != swift_object_md5:
+        if img_md5 != swift_object_md5:
-            msg = ("Glance image hash {} != swift object hash "
+            msg = "Glance image hash {} != swift object hash {}".format(
-                   "{}".format(glance_image_md5, swift_object_md5))
+                img_md5, swift_object_md5)
             amulet.raise_status(amulet.FAIL, msg=msg)
 
         # Cleanup
-        u.delete_image(self.glance, image)
+        u.delete_resource(self.glance.images, img_id, msg="glance image")
+        u.log.info('OK')
+
+    def test_900_restart_on_config_change(self):
+        """Verify that the specified services are restarted when the config
+           is changed."""
+        u.log.info('Checking that conf files and system services respond '
+                   'to a charm config change...')
+
+        sentry = self.swift_proxy_sentry
+        juju_service = 'swift-proxy'
+        services = {'swift-proxy': '/etc/swift/proxy-server.conf'}
+
+        # Expected default and alternate values
+        set_default = {'node-timeout': '60'}
+        set_alternate = {'node-timeout': '90'}
+
+        # Make config change, check for service restarts
+        u.log.debug('Making config change on {}...'.format(juju_service))
+        mtime = u.get_sentry_time(sentry)
+        self.d.configure(juju_service, set_alternate)
+
+        sleep_time = 40
+        for s, conf_file in services.iteritems():
+            u.log.debug("Checking that service restarted: {}".format(s))
+            if not u.validate_service_config_changed(sentry, mtime, s,
+                                                     conf_file,
+                                                     sleep_time=sleep_time):
+                self.d.configure(juju_service, set_default)
+                msg = "service {} didn't restart after config change".format(s)
+                amulet.raise_status(amulet.FAIL, msg=msg)
+            sleep_time = 0
+
+        self.d.configure(juju_service, set_default)