import mock

import reactive.designate_handlers as handlers

import charms_openstack.test_utils as test_utils


class TestRegisteredHooks(test_utils.TestRegisteredHooks):

    def test_hooks(self):
        # test that the hooks actually registered the relation expressions that
        # are meaningful for this interface: this is to handle regressions.
        # The keys are the function names that the hook attaches to.
        all_interfaces = (
            'dns-config.available',
            'shared-db.available',
            'identity-service.available',
            'coordinator-memcached.available',
            'amqp.available')
        hook_set = {
            'when': {
                'setup_amqp_req': ('amqp.connected', ),
                'setup_database': ('shared-db.connected', ),
                'maybe_setup_endpoint': ('identity-service.connected', ),
                'configure_ssl': ('identity-service.available', ),
                'update_peers': ('cluster.available', ),
                'config_changed': ('config.changed', ),
                'cluster_connected': ('ha.connected', ),
                'create_servers_and_domains': (
                    all_interfaces + ('base-config.rendered', 'db.synched')),
                'configure_designate_full': (
                    all_interfaces + ('db.synched', )),
                'run_db_migration': (
                    all_interfaces + ('base-config.rendered', )),
                'configure_designate_basic': all_interfaces,
            },
            'when_not': {
                'setup_amqp_req': ('amqp.requested-access', ),
                'setup_database': ('shared-db.setup', ),
                'install_packages': ('installed', ),
                'run_db_migration': ('db.synched', ),
                'configure_designate_basic': ('base-config.rendered', ),
                'create_servers_and_domains': ('domains.created', ),
                'run_assess_status_on_every_hook': (
                    'dont-set-assess-status', ),
            },
            'when_any': {
                'set_dns_config_available': (
                    'dns-slaves-config-valid', 'dns-backend.available', ),
            },
            'when_none': {
                'clear_dns_config_available': (
                    'dns-slaves-config-valid', 'dns-backend.available', ),
            },
            'hook': {
                'check_dns_slaves': ('config-changed', ),
            },
        }
        # test that the hooks were registered via the
        # reactive.barbican_handlers
        self.registered_hooks_test_helper(handlers, hook_set, [])


class TestHandlers(test_utils.PatchHelper):

    def _patch_provide_charm_instance(self):
        the_charm = mock.MagicMock()
        self.patch_object(handlers, 'provide_charm_instance',
                          name='provide_charm_instance',
                          new=mock.MagicMock())
        self.provide_charm_instance().__enter__.return_value = the_charm
        self.provide_charm_instance().__exit__.return_value = None
        return the_charm

    def test_install_packages(self):
        the_charm = self._patch_provide_charm_instance()
        self.patch_object(handlers.reactive, 'set_state')
        self.patch_object(handlers.reactive, 'remove_state')
        handlers.install_packages()
        the_charm.install.assert_called_once_with()
        calls = [mock.call('amqp.requested-access'),
                 mock.call('shared-db.setup'),
                 mock.call('base-config.rendered'),
                 mock.call('db.synched')]
        self.remove_state.assert_has_calls(calls)

    def test_setup_amqp_req(self):
        self.patch_object(handlers.reactive, 'set_state')
        amqp = mock.MagicMock()
        handlers.setup_amqp_req(amqp)
        amqp.request_access.assert_called_once_with(
            username='designate', vhost='openstack')
        self.set_state.assert_called_once_with('amqp.requested-access')

    def test_database(self):
        database = mock.MagicMock()
        handlers.setup_database(database)
        calls = [
            mock.call(
                'designate',
                'designate',
                prefix='designate'),
            mock.call(
                'dpm',
                'dpm',
                prefix='dpm'),
        ]
        database.configure.has_calls(calls)

    def test_setup_endpoint(self):
        the_charm = self._patch_provide_charm_instance()
        the_charm.service_type = 's1'
        the_charm.region = 'r1'
        the_charm.public_url = 'p1'
        the_charm.internal_url = 'i1'
        the_charm.admin_url = 'a1'
        args = ['s1', 'r1', 'p1', 'i1', 'a1']
        self.patch_object(handlers, 'is_data_changed',
                          name='is_data_changed',
                          new=mock.MagicMock())
        self.is_data_changed().__enter__.return_value = True
        self.is_data_changed().__exit__.return_value = None
        keystone = mock.MagicMock()
        handlers.maybe_setup_endpoint(keystone)
        self.is_data_changed.called_once_with(mock.ANY, args)
        keystone.register_endpoints.assert_called_once_with(*args)

    def test_configure_designate_basic(self):
        the_charm = self._patch_provide_charm_instance()
        self.patch_object(handlers.reactive, 'set_state')
        self.patch_object(handlers.reactive.RelationBase, 'from_state',
                          return_value=None)
        handlers.configure_designate_basic('arg1', 'arg2')
        the_charm.render_base_config.assert_called_once_with(
            ('arg1', 'arg2', ))
        self.set_state.assert_called_once_with('base-config.rendered')

    def test_run_db_migration(self):
        the_charm = self._patch_provide_charm_instance()
        self.patch_object(handlers.reactive, 'set_state')
        the_charm.db_sync_done.return_value = False
        handlers.run_db_migration('arg1', 'arg2')
        the_charm.db_sync.assert_called_once_with()
        self.assertFalse(self.set_state.called)
        the_charm.db_sync.reset_mock()
        the_charm.db_sync_done.return_value = True
        handlers.run_db_migration('arg1', 'arg2')
        the_charm.db_sync.assert_called_once_with()
        self.set_state.assert_called_once_with('db.synched')

    def test_update_peers(self):
        the_charm = self._patch_provide_charm_instance()
        handlers.update_peers('cluster')
        the_charm.update_peers.assert_called_once_with('cluster')

    def test_configure_designate_full(self):
        the_charm = self._patch_provide_charm_instance()
        self.patch_object(handlers.reactive.RelationBase,
                          'from_state',
                          return_value=None)
        handlers.configure_designate_full('arg1', 'arg2')
        the_charm.configure_ssl.assert_called_once_with()
        the_charm.render_full_config.assert_called_once_with(
            ('arg1', 'arg2', ))
        the_charm.create_initial_servers_and_domains.assert_called_once_with()
        the_charm.render_with_interfaces.assert_called_once_with(
            ('arg1', 'arg2'), configs=mock.ANY)
        the_charm.render_rndc_keys.assert_called_once_with()
        the_charm.update_pools.assert_called_once_with()
        the_charm.upgrade_if_available.assert_called_once_with(
            ('arg1', 'arg2', ))

    def test_cluster_connected(self):
        the_charm = self._patch_provide_charm_instance()
        hacluster = mock.MagicMock()
        handlers.cluster_connected(hacluster)
        the_charm.configure_ha_resources.assert_called_once_with(hacluster)