909 lines
40 KiB
Python
909 lines
40 KiB
Python
from mock import call, patch, MagicMock
|
|
import os
|
|
import json
|
|
import uuid
|
|
import yaml
|
|
|
|
from test_utils import CharmTestCase
|
|
|
|
os.environ['JUJU_UNIT_NAME'] = 'keystone'
|
|
with patch('charmhelpers.core.hookenv.config') as config:
|
|
config.return_value = 'keystone'
|
|
import keystone_utils as utils
|
|
|
|
_reg = utils.register_configs
|
|
_map = utils.restart_map
|
|
|
|
utils.register_configs = MagicMock()
|
|
utils.restart_map = MagicMock()
|
|
|
|
import keystone_hooks as hooks
|
|
from charmhelpers.contrib import unison
|
|
|
|
utils.register_configs = _reg
|
|
utils.restart_map = _map
|
|
|
|
TO_PATCH = [
|
|
# charmhelpers.core.hookenv
|
|
'Hooks',
|
|
'config',
|
|
'is_relation_made',
|
|
'log',
|
|
'local_unit',
|
|
'filter_installed_packages',
|
|
'relation_ids',
|
|
'relation_set',
|
|
'relation_get',
|
|
'related_units',
|
|
'unit_get',
|
|
'peer_echo',
|
|
# charmhelpers.core.host
|
|
'apt_install',
|
|
'apt_update',
|
|
'restart_on_change',
|
|
# charmhelpers.contrib.openstack.utils
|
|
'configure_installation_source',
|
|
# charmhelpers.contrib.openstack.ip
|
|
'resolve_address',
|
|
# charmhelpers.contrib.hahelpers.cluster_utils
|
|
'is_elected_leader',
|
|
'get_hacluster_config',
|
|
# keystone_utils
|
|
'restart_map',
|
|
'register_configs',
|
|
'do_openstack_upgrade_reexec',
|
|
'openstack_upgrade_available',
|
|
'save_script_rc',
|
|
'migrate_database',
|
|
'ensure_initial_admin',
|
|
'add_service_to_keystone',
|
|
'synchronize_ca_if_changed',
|
|
'update_nrpe_config',
|
|
'ensure_ssl_dirs',
|
|
'is_db_initialised',
|
|
'is_db_ready',
|
|
# other
|
|
'check_call',
|
|
'execd_preinstall',
|
|
'mkdir',
|
|
'os',
|
|
# ip
|
|
'get_iface_for_address',
|
|
'get_netmask_for_address',
|
|
'get_address_in_network',
|
|
'git_install',
|
|
]
|
|
|
|
|
|
class KeystoneRelationTests(CharmTestCase):
|
|
|
|
def setUp(self):
|
|
super(KeystoneRelationTests, self).setUp(hooks, TO_PATCH)
|
|
self.config.side_effect = self.test_config.get
|
|
self.ssh_user = 'juju_keystone'
|
|
|
|
@patch.object(utils, 'git_install_requested')
|
|
@patch.object(unison, 'ensure_user')
|
|
def test_install_hook(self, ensure_user, git_requested):
|
|
git_requested.return_value = False
|
|
repo = 'cloud:precise-grizzly'
|
|
self.test_config.set('openstack-origin', repo)
|
|
hooks.install()
|
|
self.assertTrue(self.execd_preinstall.called)
|
|
self.configure_installation_source.assert_called_with(repo)
|
|
ensure_user.assert_called_with(user=self.ssh_user, group='keystone')
|
|
self.assertTrue(self.apt_update.called)
|
|
self.apt_install.assert_called_with(
|
|
['apache2', 'haproxy', 'keystone', 'openssl', 'pwgen',
|
|
'python-keystoneclient', 'python-mysqldb', 'python-psycopg2',
|
|
'python-six', 'unison', 'uuid'], fatal=True)
|
|
self.git_install.assert_called_with(None)
|
|
|
|
@patch.object(utils, 'git_install_requested')
|
|
@patch.object(unison, 'ensure_user')
|
|
def test_install_hook_git(self, ensure_user, git_requested):
|
|
git_requested.return_value = True
|
|
repo = 'cloud:trusty-juno'
|
|
openstack_origin_git = {
|
|
'repositories': [
|
|
{'name': 'requirements',
|
|
'repository': 'git://git.openstack.org/openstack/requirements', # noqa
|
|
'branch': 'stable/juno'},
|
|
{'name': 'keystone',
|
|
'repository': 'git://git.openstack.org/openstack/keystone',
|
|
'branch': 'stable/juno'}
|
|
],
|
|
'directory': '/mnt/openstack-git',
|
|
}
|
|
projects_yaml = yaml.dump(openstack_origin_git)
|
|
self.test_config.set('openstack-origin', repo)
|
|
self.test_config.set('openstack-origin-git', projects_yaml)
|
|
hooks.install()
|
|
self.assertTrue(self.execd_preinstall.called)
|
|
self.configure_installation_source.assert_called_with(repo)
|
|
ensure_user.assert_called_with(user=self.ssh_user, group='keystone')
|
|
self.assertTrue(self.apt_update.called)
|
|
self.apt_install.assert_called_with(
|
|
['apache2', 'haproxy', 'libffi-dev', 'libmysqlclient-dev',
|
|
'libssl-dev', 'libxml2-dev', 'libxslt1-dev', 'libyaml-dev',
|
|
'openssl', 'pwgen', 'python-dev', 'python-keystoneclient',
|
|
'python-mysqldb', 'python-pip', 'python-psycopg2',
|
|
'python-setuptools', 'python-six', 'unison', 'uuid',
|
|
'zlib1g-dev'], fatal=True)
|
|
self.git_install.assert_called_with(projects_yaml)
|
|
|
|
mod_ch_openstack_utils = 'charmhelpers.contrib.openstack.utils'
|
|
|
|
@patch.object(hooks, 'config')
|
|
@patch('%s.config' % (mod_ch_openstack_utils))
|
|
@patch('%s.relation_set' % (mod_ch_openstack_utils))
|
|
@patch('%s.relation_ids' % (mod_ch_openstack_utils))
|
|
@patch('%s.get_ipv6_addr' % (mod_ch_openstack_utils))
|
|
@patch('%s.sync_db_with_multi_ipv6_addresses' % (mod_ch_openstack_utils))
|
|
def test_db_joined(self, mock_sync_db_with_multi, mock_get_ipv6_addr,
|
|
mock_relation_ids, mock_relation_set, mock_config,
|
|
mock_hooks_config):
|
|
|
|
cfg_dict = {'prefer-ipv6': False,
|
|
'database': 'keystone',
|
|
'database-user': 'keystone',
|
|
'vip': None}
|
|
|
|
class mock_cls_config():
|
|
def __call__(self, key):
|
|
return cfg_dict[key]
|
|
|
|
cfg = mock_cls_config()
|
|
mock_hooks_config.side_effect = cfg
|
|
mock_config.side_effect = cfg
|
|
|
|
self.is_relation_made.return_value = False
|
|
self.unit_get.return_value = 'keystone.foohost.com'
|
|
hooks.db_joined()
|
|
self.relation_set.assert_called_with(database='keystone',
|
|
username='keystone',
|
|
hostname='keystone.foohost.com')
|
|
self.unit_get.assert_called_with('private-address')
|
|
|
|
cfg_dict['prefer-ipv6'] = True
|
|
mock_hooks_config.side_effect = mock_cls_config()
|
|
mock_relation_ids.return_value = ['shared-db']
|
|
mock_get_ipv6_addr.return_value = ['keystone.foohost.com']
|
|
self.is_relation_made.return_value = False
|
|
hooks.db_joined()
|
|
|
|
hosts = json.dumps(['keystone.foohost.com'])
|
|
mock_relation_set.assert_called_with(relation_id='shared-db',
|
|
database='keystone',
|
|
username='keystone',
|
|
hostname=hosts)
|
|
|
|
def test_postgresql_db_joined(self):
|
|
self.unit_get.return_value = 'keystone.foohost.com'
|
|
self.is_relation_made.return_value = False
|
|
hooks.pgsql_db_joined()
|
|
self.relation_set.assert_called_with(database='keystone'),
|
|
|
|
def test_db_joined_with_postgresql(self):
|
|
self.is_relation_made.return_value = True
|
|
|
|
with self.assertRaises(Exception) as context:
|
|
hooks.db_joined()
|
|
self.assertEqual(
|
|
context.exception.message,
|
|
'Attempting to associate a mysql database when there '
|
|
'is already associated a postgresql one')
|
|
|
|
def test_postgresql_joined_with_db(self):
|
|
self.is_relation_made.return_value = True
|
|
|
|
with self.assertRaises(Exception) as context:
|
|
hooks.pgsql_db_joined()
|
|
self.assertEqual(
|
|
context.exception.message,
|
|
'Attempting to associate a postgresql database when there '
|
|
'is already associated a mysql one')
|
|
|
|
@patch('keystone_utils.log')
|
|
@patch('keystone_utils.ensure_ssl_cert_master')
|
|
@patch.object(hooks, 'CONFIGS')
|
|
def test_db_changed_missing_relation_data(self, configs,
|
|
mock_ensure_ssl_cert_master,
|
|
mock_log):
|
|
mock_ensure_ssl_cert_master.return_value = False
|
|
configs.complete_contexts = MagicMock()
|
|
configs.complete_contexts.return_value = []
|
|
hooks.db_changed()
|
|
self.log.assert_called_with(
|
|
'shared-db relation incomplete. Peer not ready?'
|
|
)
|
|
|
|
@patch('keystone_utils.log')
|
|
@patch('keystone_utils.ensure_ssl_cert_master')
|
|
@patch.object(hooks, 'CONFIGS')
|
|
def test_postgresql_db_changed_missing_relation_data(self, configs,
|
|
mock_ensure_leader,
|
|
mock_log):
|
|
mock_ensure_leader.return_value = False
|
|
configs.complete_contexts = MagicMock()
|
|
configs.complete_contexts.return_value = []
|
|
hooks.pgsql_db_changed()
|
|
self.log.assert_called_with(
|
|
'pgsql-db relation incomplete. Peer not ready?'
|
|
)
|
|
|
|
def _shared_db_test(self, configs, unit_name):
|
|
self.relation_get.return_value = 'keystone/0 keystone/3'
|
|
self.local_unit.return_value = unit_name
|
|
configs.complete_contexts = MagicMock()
|
|
configs.complete_contexts.return_value = ['shared-db']
|
|
configs.write = MagicMock()
|
|
hooks.db_changed()
|
|
|
|
def _postgresql_db_test(self, configs):
|
|
configs.complete_contexts = MagicMock()
|
|
configs.complete_contexts.return_value = ['pgsql-db']
|
|
configs.write = MagicMock()
|
|
hooks.pgsql_db_changed()
|
|
|
|
@patch('keystone_utils.log')
|
|
@patch('keystone_utils.ensure_ssl_cert_master')
|
|
@patch.object(hooks, 'CONFIGS')
|
|
@patch.object(hooks, 'identity_changed')
|
|
def test_db_changed_allowed(self, identity_changed, configs,
|
|
mock_ensure_ssl_cert_master,
|
|
mock_log):
|
|
self.is_db_initialised.return_value = True
|
|
self.is_db_ready.return_value = True
|
|
mock_ensure_ssl_cert_master.return_value = False
|
|
self.relation_ids.return_value = ['identity-service:0']
|
|
self.related_units.return_value = ['unit/0']
|
|
|
|
self._shared_db_test(configs, 'keystone/3')
|
|
self.assertEquals([call('/etc/keystone/keystone.conf')],
|
|
configs.write.call_args_list)
|
|
self.migrate_database.assert_called_with()
|
|
self.assertTrue(self.ensure_initial_admin.called)
|
|
identity_changed.assert_called_with(
|
|
relation_id='identity-service:0',
|
|
remote_unit='unit/0')
|
|
|
|
@patch('keystone_utils.log')
|
|
@patch('keystone_utils.ensure_ssl_cert_master')
|
|
@patch.object(hooks, 'CONFIGS')
|
|
@patch.object(hooks, 'identity_changed')
|
|
def test_db_changed_not_allowed(self, identity_changed, configs,
|
|
mock_ensure_ssl_cert_master, mock_log):
|
|
self.is_db_ready.return_value = False
|
|
mock_ensure_ssl_cert_master.return_value = False
|
|
self.relation_ids.return_value = ['identity-service:0']
|
|
self.related_units.return_value = ['unit/0']
|
|
|
|
self._shared_db_test(configs, 'keystone/2')
|
|
self.assertEquals([call('/etc/keystone/keystone.conf')],
|
|
configs.write.call_args_list)
|
|
self.assertFalse(self.migrate_database.called)
|
|
self.assertFalse(self.ensure_initial_admin.called)
|
|
self.assertFalse(identity_changed.called)
|
|
|
|
@patch('keystone_utils.log')
|
|
@patch('keystone_utils.ensure_ssl_cert_master')
|
|
@patch.object(hooks, 'CONFIGS')
|
|
@patch.object(hooks, 'identity_changed')
|
|
def test_postgresql_db_changed(self, identity_changed, configs,
|
|
mock_ensure_ssl_cert_master, mock_log):
|
|
self.is_db_initialised.return_value = True
|
|
self.is_db_ready.return_value = True
|
|
mock_ensure_ssl_cert_master.return_value = False
|
|
self.relation_ids.return_value = ['identity-service:0']
|
|
self.related_units.return_value = ['unit/0']
|
|
|
|
self._postgresql_db_test(configs)
|
|
self.assertEquals([call('/etc/keystone/keystone.conf')],
|
|
configs.write.call_args_list)
|
|
self.migrate_database.assert_called_with()
|
|
self.assertTrue(self.ensure_initial_admin.called)
|
|
identity_changed.assert_called_with(
|
|
relation_id='identity-service:0',
|
|
remote_unit='unit/0')
|
|
|
|
@patch.object(hooks, 'git_install_requested')
|
|
@patch('keystone_utils.log')
|
|
@patch('keystone_utils.ensure_ssl_cert_master')
|
|
@patch('keystone_utils.ensure_ssl_dirs')
|
|
@patch.object(hooks, 'ensure_permissions')
|
|
@patch.object(hooks, 'ensure_pki_cert_paths')
|
|
@patch.object(hooks, 'ensure_pki_dir_permissions')
|
|
@patch.object(hooks, 'ensure_ssl_dir')
|
|
@patch.object(hooks, 'is_ssl_cert_master')
|
|
@patch.object(hooks, 'send_ssl_sync_request')
|
|
@patch.object(hooks, 'peer_units')
|
|
@patch.object(hooks, 'admin_relation_changed')
|
|
@patch.object(hooks, 'cluster_joined')
|
|
@patch.object(unison, 'ensure_user')
|
|
@patch.object(unison, 'get_homedir')
|
|
@patch.object(hooks, 'CONFIGS')
|
|
@patch.object(hooks, 'identity_changed')
|
|
@patch.object(hooks, 'configure_https')
|
|
def test_config_changed_no_upgrade_leader(self, configure_https,
|
|
identity_changed,
|
|
configs, get_homedir,
|
|
ensure_user,
|
|
cluster_joined,
|
|
admin_relation_changed,
|
|
mock_peer_units,
|
|
mock_send_ssl_sync_request,
|
|
mock_is_ssl_cert_master,
|
|
mock_ensure_ssl_dir,
|
|
mock_ensure_pki_cert_paths,
|
|
mock_ensure_permissions,
|
|
mock_ensure_pki_dir_permissions,
|
|
mock_ensure_ssl_dirs,
|
|
mock_ensure_ssl_cert_master,
|
|
mock_log, git_requested):
|
|
git_requested.return_value = False
|
|
mock_is_ssl_cert_master.return_value = True
|
|
self.is_db_initialised.return_value = True
|
|
self.is_db_ready.return_value = True
|
|
self.openstack_upgrade_available.return_value = False
|
|
self.is_elected_leader.return_value = True
|
|
# avoid having to mock syncer
|
|
mock_ensure_ssl_cert_master.return_value = False
|
|
mock_peer_units.return_value = []
|
|
self.relation_ids.return_value = ['identity-service:0']
|
|
self.related_units.return_value = ['unit/0']
|
|
|
|
hooks.config_changed()
|
|
ensure_user.assert_called_with(user=self.ssh_user, group='keystone')
|
|
get_homedir.assert_called_with(self.ssh_user)
|
|
|
|
self.save_script_rc.assert_called_with()
|
|
configure_https.assert_called_with()
|
|
self.assertTrue(configs.write_all.called)
|
|
|
|
self.assertTrue(self.ensure_initial_admin.called)
|
|
self.log.assert_called_with(
|
|
'Firing identity_changed hook for all related services.')
|
|
identity_changed.assert_called_with(
|
|
relation_id='identity-service:0',
|
|
remote_unit='unit/0')
|
|
admin_relation_changed.assert_called_with('identity-service:0')
|
|
|
|
@patch.object(hooks, 'git_install_requested')
|
|
@patch('keystone_utils.log')
|
|
@patch('keystone_utils.ensure_ssl_cert_master')
|
|
@patch('keystone_utils.ensure_ssl_dirs')
|
|
@patch.object(hooks, 'update_all_identity_relation_units')
|
|
@patch.object(hooks, 'ensure_permissions')
|
|
@patch.object(hooks, 'ensure_pki_cert_paths')
|
|
@patch.object(hooks, 'ensure_pki_dir_permissions')
|
|
@patch.object(hooks, 'ensure_ssl_dir')
|
|
@patch.object(hooks, 'peer_units')
|
|
@patch.object(hooks, 'is_ssl_cert_master')
|
|
@patch.object(hooks, 'cluster_joined')
|
|
@patch.object(unison, 'ensure_user')
|
|
@patch.object(unison, 'get_homedir')
|
|
@patch.object(hooks, 'CONFIGS')
|
|
@patch.object(hooks, 'identity_changed')
|
|
@patch.object(hooks, 'configure_https')
|
|
def test_config_changed_no_upgrade_not_leader(self, configure_https,
|
|
identity_changed,
|
|
configs, get_homedir,
|
|
ensure_user, cluster_joined,
|
|
mock_is_ssl_cert_master,
|
|
mock_peer_units,
|
|
mock_ensure_ssl_dir,
|
|
mock_ensure_permissions,
|
|
mock_ensure_pki_cert_paths,
|
|
mock_ensure_pki_permissions,
|
|
mock_update_all_id_rel_units,
|
|
ensure_ssl_dirs,
|
|
mock_ensure_ssl_cert_master,
|
|
mock_log, git_requested):
|
|
git_requested.return_value = False
|
|
mock_is_ssl_cert_master.return_value = True
|
|
mock_peer_units.return_value = []
|
|
self.openstack_upgrade_available.return_value = False
|
|
self.is_elected_leader.return_value = False
|
|
mock_ensure_ssl_cert_master.return_value = False
|
|
|
|
hooks.config_changed()
|
|
ensure_user.assert_called_with(user=self.ssh_user, group='keystone')
|
|
get_homedir.assert_called_with(self.ssh_user)
|
|
|
|
self.save_script_rc.assert_called_with()
|
|
configure_https.assert_called_with()
|
|
self.assertTrue(configs.write_all.called)
|
|
|
|
self.assertFalse(self.migrate_database.called)
|
|
self.assertFalse(self.ensure_initial_admin.called)
|
|
self.assertFalse(identity_changed.called)
|
|
|
|
@patch.object(hooks, 'git_install_requested')
|
|
@patch('keystone_utils.log')
|
|
@patch('keystone_utils.ensure_ssl_cert_master')
|
|
@patch('keystone_utils.ensure_ssl_dirs')
|
|
@patch.object(hooks, 'ensure_permissions')
|
|
@patch.object(hooks, 'ensure_pki_cert_paths')
|
|
@patch.object(hooks, 'ensure_pki_dir_permissions')
|
|
@patch.object(hooks, 'ensure_ssl_dir')
|
|
@patch.object(hooks, 'is_ssl_cert_master')
|
|
@patch.object(hooks, 'send_ssl_sync_request')
|
|
@patch.object(hooks, 'peer_units')
|
|
@patch.object(hooks, 'admin_relation_changed')
|
|
@patch.object(hooks, 'cluster_joined')
|
|
@patch.object(unison, 'ensure_user')
|
|
@patch.object(unison, 'get_homedir')
|
|
@patch.object(hooks, 'CONFIGS')
|
|
@patch.object(hooks, 'identity_changed')
|
|
@patch.object(hooks, 'configure_https')
|
|
def test_config_changed_with_openstack_upgrade(self, configure_https,
|
|
identity_changed,
|
|
configs, get_homedir,
|
|
ensure_user, cluster_joined,
|
|
admin_relation_changed,
|
|
mock_peer_units,
|
|
mock_send_ssl_sync_request,
|
|
mock_is_ssl_cert_master,
|
|
mock_ensure_ssl_dir,
|
|
mock_ensure_permissions,
|
|
mock_ensure_pki_cert_paths,
|
|
mock_ensure_pki_permissions,
|
|
mock_ensure_ssl_dirs,
|
|
mock_ensure_ssl_cert_master,
|
|
mock_log, git_requested):
|
|
git_requested.return_value = False
|
|
mock_is_ssl_cert_master.return_value = True
|
|
self.is_db_ready.return_value = True
|
|
self.is_db_initialised.return_value = True
|
|
self.openstack_upgrade_available.return_value = True
|
|
self.is_elected_leader.return_value = True
|
|
# avoid having to mock syncer
|
|
mock_ensure_ssl_cert_master.return_value = False
|
|
mock_peer_units.return_value = []
|
|
self.relation_ids.return_value = ['identity-service:0']
|
|
self.related_units.return_value = ['unit/0']
|
|
|
|
hooks.config_changed()
|
|
ensure_user.assert_called_with(user=self.ssh_user, group='keystone')
|
|
get_homedir.assert_called_with(self.ssh_user)
|
|
|
|
self.assertTrue(self.do_openstack_upgrade_reexec.called)
|
|
|
|
self.save_script_rc.assert_called_with()
|
|
configure_https.assert_called_with()
|
|
self.assertTrue(configs.write_all.called)
|
|
|
|
self.assertTrue(self.ensure_initial_admin.called)
|
|
self.log.assert_called_with(
|
|
'Firing identity_changed hook for all related services.')
|
|
identity_changed.assert_called_with(
|
|
relation_id='identity-service:0',
|
|
remote_unit='unit/0')
|
|
admin_relation_changed.assert_called_with('identity-service:0')
|
|
|
|
@patch.object(hooks, 'initialise_pki')
|
|
@patch.object(hooks, 'git_install_requested')
|
|
@patch.object(hooks, 'config_value_changed')
|
|
@patch('keystone_utils.log')
|
|
@patch('keystone_utils.ensure_ssl_cert_master')
|
|
@patch.object(hooks, 'ensure_ssl_dir')
|
|
@patch.object(hooks, 'send_ssl_sync_request')
|
|
@patch.object(hooks, 'is_db_initialised')
|
|
@patch.object(hooks, 'is_db_ready')
|
|
@patch.object(hooks, 'peer_units')
|
|
@patch.object(hooks, 'admin_relation_changed')
|
|
@patch.object(hooks, 'cluster_joined')
|
|
@patch.object(unison, 'ensure_user')
|
|
@patch.object(unison, 'get_homedir')
|
|
@patch.object(hooks, 'CONFIGS')
|
|
@patch.object(hooks, 'identity_changed')
|
|
@patch.object(hooks, 'configure_https')
|
|
def test_config_changed_git_updated(self, configure_https,
|
|
identity_changed,
|
|
configs, get_homedir, ensure_user,
|
|
cluster_joined, admin_relation_changed,
|
|
mock_peer_units,
|
|
mock_is_db_ready,
|
|
mock_is_db_initialised,
|
|
mock_send_ssl_sync_request,
|
|
mock_ensure_ssl_dir,
|
|
mock_ensure_ssl_cert_master,
|
|
mock_log, config_val_changed,
|
|
git_requested,
|
|
mock_initialise_pki):
|
|
git_requested.return_value = True
|
|
mock_ensure_ssl_cert_master.return_value = False
|
|
self.openstack_upgrade_available.return_value = False
|
|
self.is_elected_leader.return_value = True
|
|
mock_peer_units.return_value = []
|
|
self.relation_ids.return_value = ['identity-service:0']
|
|
self.related_units.return_value = ['unit/0']
|
|
|
|
repo = 'cloud:trusty-juno'
|
|
openstack_origin_git = {
|
|
'repositories': [
|
|
{'name': 'requirements',
|
|
'repository': 'git://git.openstack.org/openstack/requirements', # noqa
|
|
'branch': 'stable/juno'},
|
|
{'name': 'keystone',
|
|
'repository': 'git://git.openstack.org/openstack/keystone',
|
|
'branch': 'stable/juno'}
|
|
],
|
|
'directory': '/mnt/openstack-git',
|
|
}
|
|
projects_yaml = yaml.dump(openstack_origin_git)
|
|
self.test_config.set('openstack-origin', repo)
|
|
self.test_config.set('openstack-origin-git', projects_yaml)
|
|
hooks.config_changed()
|
|
self.git_install.assert_called_with(projects_yaml)
|
|
self.assertFalse(self.openstack_upgrade_available.called)
|
|
self.assertFalse(self.do_openstack_upgrade_reexec.called)
|
|
|
|
@patch.object(hooks, 'initialise_pki')
|
|
@patch.object(hooks, 'git_install_requested')
|
|
@patch.object(hooks, 'config_value_changed')
|
|
@patch.object(hooks, 'ensure_ssl_dir')
|
|
@patch.object(hooks, 'configure_https')
|
|
@patch.object(hooks, 'is_ssl_cert_master')
|
|
@patch.object(hooks, 'peer_units')
|
|
@patch.object(unison, 'get_homedir')
|
|
@patch.object(unison, 'ensure_user')
|
|
@patch('keystone_utils.ensure_ssl_cert_master')
|
|
def test_config_changed_with_openstack_upgrade_action(self,
|
|
ensure_ssl_cert,
|
|
ensure_user,
|
|
get_home,
|
|
peer_units, is_ssl,
|
|
config_https,
|
|
ensure_ssl_dir,
|
|
config_value_changed,
|
|
git_requested,
|
|
mock_initialise_pki):
|
|
ensure_ssl_cert.return_value = False
|
|
peer_units.return_value = []
|
|
|
|
git_requested.return_value = False
|
|
self.openstack_upgrade_available.return_value = True
|
|
self.test_config.set('action-managed-upgrade', True)
|
|
|
|
hooks.config_changed()
|
|
|
|
self.assertFalse(self.do_openstack_upgrade_reexec.called)
|
|
|
|
@patch('keystone_utils.log')
|
|
@patch('keystone_utils.ensure_ssl_cert_master')
|
|
@patch.object(hooks, 'hashlib')
|
|
@patch.object(hooks, 'send_notifications')
|
|
def test_identity_changed_leader(self, mock_send_notifications,
|
|
mock_hashlib, mock_ensure_ssl_cert_master,
|
|
mock_log):
|
|
self.is_db_initialised.return_value = True
|
|
self.is_db_ready.return_value = True
|
|
mock_ensure_ssl_cert_master.return_value = False
|
|
hooks.identity_changed(
|
|
relation_id='identity-service:0',
|
|
remote_unit='unit/0')
|
|
self.add_service_to_keystone.assert_called_with(
|
|
'identity-service:0',
|
|
'unit/0')
|
|
|
|
@patch.object(hooks, 'local_unit')
|
|
@patch('keystone_utils.log')
|
|
@patch('keystone_utils.ensure_ssl_cert_master')
|
|
def test_identity_changed_no_leader(self, mock_ensure_ssl_cert_master,
|
|
mock_log, mock_local_unit):
|
|
mock_ensure_ssl_cert_master.return_value = False
|
|
mock_local_unit.return_value = 'unit/0'
|
|
self.is_elected_leader.return_value = False
|
|
hooks.identity_changed(
|
|
relation_id='identity-service:0',
|
|
remote_unit='unit/0')
|
|
self.assertFalse(self.add_service_to_keystone.called)
|
|
self.log.assert_called_with(
|
|
'Deferring identity_changed() to service leader.')
|
|
|
|
@patch.object(hooks, 'local_unit')
|
|
@patch.object(hooks, 'peer_units')
|
|
@patch.object(unison, 'ssh_authorized_peers')
|
|
def test_cluster_joined(self, ssh_authorized_peers, mock_peer_units,
|
|
mock_local_unit):
|
|
mock_local_unit.return_value = 'unit/0'
|
|
mock_peer_units.return_value = ['unit/0']
|
|
hooks.cluster_joined()
|
|
ssh_authorized_peers.assert_called_with(
|
|
user=self.ssh_user, group='juju_keystone',
|
|
peer_interface='cluster', ensure_local_user=True)
|
|
|
|
@patch.object(hooks, 'initialise_pki')
|
|
@patch.object(hooks, 'update_all_identity_relation_units')
|
|
@patch.object(hooks, 'get_ssl_sync_request_units')
|
|
@patch.object(hooks, 'is_ssl_cert_master')
|
|
@patch.object(hooks, 'peer_units')
|
|
@patch('keystone_utils.relation_ids')
|
|
@patch('keystone_utils.config')
|
|
@patch('keystone_utils.log')
|
|
@patch('keystone_utils.ensure_ssl_cert_master')
|
|
@patch('keystone_utils.synchronize_ca')
|
|
@patch.object(hooks, 'check_peer_actions')
|
|
@patch.object(unison, 'ssh_authorized_peers')
|
|
@patch.object(hooks, 'CONFIGS')
|
|
def test_cluster_changed(self, configs, ssh_authorized_peers,
|
|
check_peer_actions, mock_synchronize_ca,
|
|
mock_ensure_ssl_cert_master,
|
|
mock_log, mock_config, mock_relation_ids,
|
|
mock_peer_units,
|
|
mock_is_ssl_cert_master,
|
|
mock_get_ssl_sync_request_units,
|
|
mock_update_all_identity_relation_units,
|
|
mock_initialise_pki):
|
|
|
|
relation_settings = {'foo_passwd': '123',
|
|
'identity-service:16_foo': 'bar'}
|
|
|
|
mock_is_ssl_cert_master.return_value = False
|
|
mock_peer_units.return_value = ['unit/0']
|
|
mock_ensure_ssl_cert_master.return_value = False
|
|
mock_relation_ids.return_value = []
|
|
self.is_elected_leader.return_value = False
|
|
|
|
def fake_rel_get(attribute=None, *args, **kwargs):
|
|
if not attribute:
|
|
return relation_settings
|
|
|
|
return relation_settings.get(attribute)
|
|
|
|
self.relation_get.side_effect = fake_rel_get
|
|
|
|
mock_config.return_value = None
|
|
|
|
hooks.cluster_changed()
|
|
whitelist = ['_passwd', 'identity-service:', 'ssl-cert-master',
|
|
'db-initialised', 'ssl-cert-available-updates']
|
|
self.peer_echo.assert_called_with(force=True, includes=whitelist)
|
|
ssh_authorized_peers.assert_called_with(
|
|
user=self.ssh_user, group='juju_keystone',
|
|
peer_interface='cluster', ensure_local_user=True)
|
|
self.assertFalse(mock_synchronize_ca.called)
|
|
self.assertTrue(configs.write_all.called)
|
|
|
|
def test_ha_joined(self):
|
|
self.get_hacluster_config.return_value = {
|
|
'vip': '10.10.10.10',
|
|
'ha-bindiface': 'em0',
|
|
'ha-mcastport': '8080'
|
|
}
|
|
self.get_iface_for_address.return_value = 'em1'
|
|
self.get_netmask_for_address.return_value = '255.255.255.0'
|
|
hooks.ha_joined()
|
|
args = {
|
|
'relation_id': None,
|
|
'corosync_bindiface': 'em0',
|
|
'corosync_mcastport': '8080',
|
|
'init_services': {'res_ks_haproxy': 'haproxy'},
|
|
'resources': {'res_ks_em1_vip': 'ocf:heartbeat:IPaddr2',
|
|
'res_ks_haproxy': 'lsb:haproxy'},
|
|
'resource_params': {
|
|
'res_ks_em1_vip': 'params ip="10.10.10.10"'
|
|
' cidr_netmask="255.255.255.0" nic="em1"',
|
|
'res_ks_haproxy': 'op monitor interval="5s"'},
|
|
'clones': {'cl_ks_haproxy': 'res_ks_haproxy'}
|
|
}
|
|
self.relation_set.assert_called_with(**args)
|
|
|
|
def test_ha_joined_duplicate_vip_key(self):
|
|
self.get_hacluster_config.return_value = {
|
|
'vip': '10.10.10.10 10.10.10.11',
|
|
'ha-bindiface': 'em0',
|
|
'ha-mcastport': '8080'
|
|
}
|
|
self.get_iface_for_address.return_value = 'em1'
|
|
self.get_netmask_for_address.return_value = '255.255.255.0'
|
|
hooks.ha_joined()
|
|
args = {
|
|
'relation_id': None,
|
|
'corosync_bindiface': 'em0',
|
|
'corosync_mcastport': '8080',
|
|
'init_services': {'res_ks_haproxy': 'haproxy'},
|
|
'resources': {'res_ks_em1_vip': 'ocf:heartbeat:IPaddr2',
|
|
'res_ks_haproxy': 'lsb:haproxy'},
|
|
'resource_params': {
|
|
'res_ks_em1_vip': 'params ip="10.10.10.10"'
|
|
' cidr_netmask="255.255.255.0" nic="em1"',
|
|
'res_ks_haproxy': 'op monitor interval="5s"'},
|
|
'clones': {'cl_ks_haproxy': 'res_ks_haproxy'}
|
|
}
|
|
self.relation_set.assert_called_with(**args)
|
|
|
|
def test_ha_joined_no_bound_ip(self):
|
|
self.get_hacluster_config.return_value = {
|
|
'vip': '10.10.10.10',
|
|
'ha-bindiface': 'em0',
|
|
'ha-mcastport': '8080'
|
|
}
|
|
self.test_config.set('vip_iface', 'eth120')
|
|
self.test_config.set('vip_cidr', '21')
|
|
self.get_iface_for_address.return_value = None
|
|
self.get_netmask_for_address.return_value = None
|
|
hooks.ha_joined()
|
|
args = {
|
|
'relation_id': None,
|
|
'corosync_bindiface': 'em0',
|
|
'corosync_mcastport': '8080',
|
|
'init_services': {'res_ks_haproxy': 'haproxy'},
|
|
'resources': {'res_ks_eth120_vip': 'ocf:heartbeat:IPaddr2',
|
|
'res_ks_haproxy': 'lsb:haproxy'},
|
|
'resource_params': {
|
|
'res_ks_eth120_vip': 'params ip="10.10.10.10"'
|
|
' cidr_netmask="21" nic="eth120"',
|
|
'res_ks_haproxy': 'op monitor interval="5s"'},
|
|
'clones': {'cl_ks_haproxy': 'res_ks_haproxy'}
|
|
}
|
|
self.relation_set.assert_called_with(**args)
|
|
|
|
def test_ha_joined_with_ipv6(self):
|
|
self.test_config.set('prefer-ipv6', True)
|
|
self.get_hacluster_config.return_value = {
|
|
'vip': '2001:db8:1::1',
|
|
'ha-bindiface': 'em0',
|
|
'ha-mcastport': '8080'
|
|
}
|
|
self.get_iface_for_address.return_value = 'em1'
|
|
self.get_netmask_for_address.return_value = '64'
|
|
hooks.ha_joined()
|
|
args = {
|
|
'relation_id': None,
|
|
'corosync_bindiface': 'em0',
|
|
'corosync_mcastport': '8080',
|
|
'init_services': {'res_ks_haproxy': 'haproxy'},
|
|
'resources': {'res_ks_em1_vip': 'ocf:heartbeat:IPv6addr',
|
|
'res_ks_haproxy': 'lsb:haproxy'},
|
|
'resource_params': {
|
|
'res_ks_em1_vip': 'params ipv6addr="2001:db8:1::1"'
|
|
' cidr_netmask="64" nic="em1"',
|
|
'res_ks_haproxy': 'op monitor interval="5s"'},
|
|
'clones': {'cl_ks_haproxy': 'res_ks_haproxy'}
|
|
}
|
|
self.relation_set.assert_called_with(**args)
|
|
|
|
@patch('keystone_utils.log')
|
|
@patch('keystone_utils.ensure_ssl_cert_master')
|
|
@patch('keystone_utils.synchronize_ca')
|
|
@patch.object(hooks, 'CONFIGS')
|
|
def test_ha_relation_changed_not_clustered_not_leader(self, configs,
|
|
mock_synchronize_ca,
|
|
mock_is_master,
|
|
mock_log):
|
|
mock_is_master.return_value = False
|
|
self.relation_get.return_value = False
|
|
self.is_elected_leader.return_value = False
|
|
|
|
hooks.ha_changed()
|
|
self.assertTrue(configs.write_all.called)
|
|
self.assertFalse(mock_synchronize_ca.called)
|
|
|
|
@patch('keystone_utils.log')
|
|
@patch('keystone_utils.ensure_ssl_cert_master')
|
|
@patch.object(hooks, 'identity_changed')
|
|
@patch.object(hooks, 'CONFIGS')
|
|
def test_ha_relation_changed_clustered_leader(self, configs,
|
|
identity_changed,
|
|
mock_ensure_ssl_cert_master,
|
|
mock_log):
|
|
self.is_db_initialised.return_value = True
|
|
self.is_db_ready.return_value = True
|
|
mock_ensure_ssl_cert_master.return_value = False
|
|
self.relation_get.return_value = True
|
|
self.is_elected_leader.return_value = True
|
|
self.relation_ids.return_value = ['identity-service:0']
|
|
self.related_units.return_value = ['unit/0']
|
|
|
|
hooks.ha_changed()
|
|
self.assertTrue(configs.write_all.called)
|
|
self.log.assert_called_with(
|
|
'Firing identity_changed hook for all related services.')
|
|
identity_changed.assert_called_with(
|
|
relation_id='identity-service:0',
|
|
remote_unit='unit/0')
|
|
|
|
@patch('keystone_utils.log')
|
|
@patch('keystone_utils.ensure_ssl_cert_master')
|
|
@patch.object(hooks, 'CONFIGS')
|
|
def test_configure_https_enable(self, configs, mock_ensure_ssl_cert_master,
|
|
mock_log):
|
|
mock_ensure_ssl_cert_master.return_value = False
|
|
configs.complete_contexts = MagicMock()
|
|
configs.complete_contexts.return_value = ['https']
|
|
configs.write = MagicMock()
|
|
|
|
hooks.configure_https()
|
|
self.assertTrue(configs.write_all.called)
|
|
cmd = ['a2ensite', 'openstack_https_frontend']
|
|
self.check_call.assert_called_with(cmd)
|
|
|
|
@patch('keystone_utils.log')
|
|
@patch('keystone_utils.ensure_ssl_cert_master')
|
|
@patch.object(hooks, 'CONFIGS')
|
|
def test_configure_https_disable(self, configs,
|
|
mock_ensure_ssl_cert_master,
|
|
mock_log):
|
|
mock_ensure_ssl_cert_master.return_value = False
|
|
configs.complete_contexts = MagicMock()
|
|
configs.complete_contexts.return_value = ['']
|
|
configs.write = MagicMock()
|
|
|
|
hooks.configure_https()
|
|
self.assertTrue(configs.write_all.called)
|
|
cmd = ['a2dissite', 'openstack_https_frontend']
|
|
self.check_call.assert_called_with(cmd)
|
|
|
|
@patch.object(utils, 'git_install_requested')
|
|
@patch.object(hooks, 'is_db_ready')
|
|
@patch.object(hooks, 'is_db_initialised')
|
|
@patch('keystone_utils.log')
|
|
@patch('keystone_utils.relation_ids')
|
|
@patch('keystone_utils.is_elected_leader')
|
|
@patch('keystone_utils.ensure_ssl_cert_master')
|
|
@patch('keystone_utils.update_hash_from_path')
|
|
@patch('keystone_utils.synchronize_ca')
|
|
@patch.object(unison, 'ssh_authorized_peers')
|
|
def test_upgrade_charm_leader(self, ssh_authorized_peers,
|
|
mock_synchronize_ca,
|
|
mock_update_hash_from_path,
|
|
mock_ensure_ssl_cert_master,
|
|
mock_is_elected_leader,
|
|
mock_relation_ids,
|
|
mock_log,
|
|
mock_is_db_initialised,
|
|
mock_is_db_ready,
|
|
git_requested):
|
|
mock_is_db_initialised.return_value = True
|
|
mock_is_db_ready.return_value = True
|
|
mock_is_elected_leader.return_value = False
|
|
mock_relation_ids.return_value = []
|
|
mock_ensure_ssl_cert_master.return_value = True
|
|
# Ensure always returns diff
|
|
mock_update_hash_from_path.side_effect = \
|
|
lambda hash, *args, **kwargs: hash.update(str(uuid.uuid4()))
|
|
|
|
self.is_elected_leader.return_value = True
|
|
self.filter_installed_packages.return_value = []
|
|
git_requested.return_value = False
|
|
hooks.upgrade_charm()
|
|
self.assertTrue(self.apt_install.called)
|
|
ssh_authorized_peers.assert_called_with(
|
|
user=self.ssh_user, group='juju_keystone',
|
|
peer_interface='cluster', ensure_local_user=True)
|
|
self.assertTrue(mock_synchronize_ca.called)
|
|
self.log.assert_called_with(
|
|
'Firing identity_changed hook for all related services.')
|
|
self.assertTrue(self.ensure_initial_admin.called)
|
|
|
|
@patch.object(utils, 'git_install_requested')
|
|
@patch('keystone_utils.log')
|
|
@patch('keystone_utils.relation_ids')
|
|
@patch('keystone_utils.ensure_ssl_cert_master')
|
|
@patch('keystone_utils.update_hash_from_path')
|
|
@patch.object(unison, 'ssh_authorized_peers')
|
|
def test_upgrade_charm_not_leader(self, ssh_authorized_peers,
|
|
mock_update_hash_from_path,
|
|
mock_ensure_ssl_cert_master,
|
|
mock_relation_ids,
|
|
mock_log, git_requested):
|
|
mock_relation_ids.return_value = []
|
|
mock_ensure_ssl_cert_master.return_value = False
|
|
# Ensure always returns diff
|
|
mock_update_hash_from_path.side_effect = \
|
|
lambda hash, *args, **kwargs: hash.update(str(uuid.uuid4()))
|
|
|
|
self.is_elected_leader.return_value = False
|
|
self.filter_installed_packages.return_value = []
|
|
git_requested.return_value = False
|
|
hooks.upgrade_charm()
|
|
self.assertTrue(self.apt_install.called)
|
|
ssh_authorized_peers.assert_called_with(
|
|
user=self.ssh_user, group='juju_keystone',
|
|
peer_interface='cluster', ensure_local_user=True)
|
|
self.assertFalse(self.log.called)
|
|
self.assertFalse(self.ensure_initial_admin.called)
|