~corey.bryant/charms/trusty/keystone/git-ods

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',

    'openstack_upgrade_available',

    'save_script_rc',

    'migrate_database',

    'ensure_initial_admin',

    'add_service_to_keystone',

    'synchronize_ca_if_changed',

    'update_nrpe_config',

    # 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')

    def test_install_hook(self, 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)

        self.assertTrue(self.apt_update.called)

        self.apt_install.assert_called_with(

            ['haproxy', 'unison', 'python-keystoneclient',

             'uuid', 'python-mysqldb', 'openssl', 'apache2',

             'pwgen', 'python-six', 'keystone', 'python-psycopg2'], fatal=True)

        self.git_install.assert_called_with(None)

    @patch.object(utils, 'git_install_requested')

    def test_install_hook_git(self, 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)

        self.assertTrue(self.apt_update.called)

        self.apt_install.assert_called_with(

            ['haproxy', 'unison', 'python-setuptools', 'python-keystoneclient',

             'uuid', 'python-mysqldb', 'libmysqlclient-dev', 'libssl-dev',

             'openssl', 'libffi-dev', 'apache2', 'python-pip', 'pwgen',

             'python-six', 'libxslt1-dev', 'python-psycopg2', 'libyaml-dev',

             'zlib1g-dev', 'python-dev', 'libxml2-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'}

        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.object(hooks, 'is_db_initialised')

    @patch.object(hooks, 'is_db_ready')

    @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, mock_is_db_ready,

                                mock_is_db_initialised):

        mock_is_db_initialised.return_value = True

        mock_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.object(hooks, 'is_db_ready')

    @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,

                                    mock_is_db_ready):

        mock_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, 'is_db_initialised')

    @patch.object(hooks, 'is_db_ready')

    @patch.object(hooks, 'CONFIGS')

    @patch.object(hooks, 'identity_changed')

    def test_postgresql_db_changed(self, identity_changed, configs,

                                   mock_is_db_ready, mock_is_db_initialised,

                                   mock_ensure_ssl_cert_master, mock_log):

        mock_is_db_initialised.return_value = True

        mock_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.object(hooks, 'ensure_pki_dir_permissions')

    @patch.object(hooks, 'ensure_ssl_dir')

    @patch.object(hooks, 'is_pki_enabled')

    @patch.object(hooks, 'is_ssl_cert_master')

    @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, 'ensure_permissions')

    @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,

                                              ensure_permissions,

                                              mock_peer_units,

                                              mock_is_db_ready,

                                              mock_is_db_initialised,

                                              mock_send_ssl_sync_request,

                                              mock_is_ssl_cert_master,

                                              mock_is_pki_enabled,

                                              mock_ensure_ssl_dir,

                                              mock_ensure_pki_dir_permissions,

                                              mock_ensure_ssl_cert_master,

                                              mock_log, git_requested):

        git_requested.return_value = False

        mock_is_pki_enabled.return_value = True

        mock_is_ssl_cert_master.return_value = True

        mock_is_db_initialised.return_value = True

        mock_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.object(hooks, 'update_all_identity_relation_units')

    @patch.object(hooks, 'ensure_pki_dir_permissions')

    @patch.object(hooks, 'ensure_ssl_dir')

    @patch.object(hooks, 'is_pki_enabled')

    @patch.object(hooks, 'peer_units')

    @patch.object(hooks, 'is_ssl_cert_master')

    @patch.object(hooks, 'ensure_permissions')

    @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,

                                                  ensure_permissions,

                                                  mock_is_ssl_cert_master,

                                                  mock_peer_units,

                                                  mock_is_pki_enabled,

                                                  mock_ensure_ssl_dir,

                                                  mock_ensure_pki_permissions,

                                                  mock_update_all_id_rel_units,

                                                  mock_ensure_ssl_cert_master,

                                                  mock_log, git_requested):

        git_requested.return_value = False

        mock_is_pki_enabled.return_value = True

        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.object(hooks, 'ensure_pki_dir_permissions')

    @patch.object(hooks, 'ensure_ssl_dir')

    @patch.object(hooks, 'is_pki_enabled')

    @patch.object(hooks, 'is_ssl_cert_master')

    @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, 'ensure_permissions')

    @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,

                                                   ensure_permissions,

                                                   mock_peer_units,

                                                   mock_is_db_ready,

                                                   mock_is_db_initialised,

                                                   mock_send_ssl_sync_request,

                                                   mock_is_ssl_cert_master,

                                                   mock_is_pki_enabled,

                                                   mock_ensure_ssl_dir,

                                                   mock_ensure_pki_permissions,

                                                   mock_ensure_ssl_cert_master,

                                                   mock_log, git_requested):

        git_requested.return_value = False

        mock_is_pki_enabled.return_value = True

        mock_is_ssl_cert_master.return_value = True

        mock_is_db_ready.return_value = True

        mock_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.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, '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, 'is_pki_enabled')

    @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, 'ensure_permissions')

    @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,

                                        ensure_permissions, mock_peer_units,

                                        mock_is_db_ready,

                                        mock_is_db_initialised,

                                        mock_send_ssl_sync_request,

                                        mock_is_pki_enabled,

                                        mock_ensure_ssl_dir,

                                        mock_ensure_ssl_cert_master,

                                        mock_log, config_val_changed,

                                        git_requested):

        git_requested.return_value = True

        mock_ensure_ssl_cert_master.return_value = False

        mock_is_pki_enabled.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.called)

    @patch.object(hooks, 'is_db_initialised')

    @patch.object(hooks, 'is_db_ready')

    @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, mock_is_db_ready,

                                     mock_is_db_initialised):

        mock_is_db_initialised.return_value = True

        mock_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, '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.config')