# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.


import copy
import json
import mock
import unittest

import common

# Deal with the 'relations.hacluster.common' import in requires.py which
# is invalid in the unit tests as there is no 'relations'.
relations_mock = mock.MagicMock()
relations_mock.hacluster.common = common
modules = {
    'relations': relations_mock,
    'relations.hacluster': mock.MagicMock(),
    'relations.hacluster.common': common,
}
module_patcher = mock.patch.dict('sys.modules', modules)
module_patcher.start()

with mock.patch('charmhelpers.core.hookenv.metadata') as _meta:
    _meta.return_Value = 'ss'
    import requires

_hook_args = {}

TO_PATCH = [
    'data_changed',
]


def mock_hook(*args, **kwargs):

    def inner(f):
        # remember what we were passed.  Note that we can't actually determine
        # the class we're attached to, as the decorator only gets the function.
        _hook_args[f.__name__] = dict(args=args, kwargs=kwargs)
        return f
    return inner


class TestHAClusterRequires(unittest.TestCase):

    @classmethod
    def setUpClass(cls):
        cls._patched_hook = mock.patch('charms.reactive.when', mock_hook)
        cls._patched_hook_started = cls._patched_hook.start()
        # force requires to rerun the mock_hook decorator:
        # try except is Python2/Python3 compatibility as Python3 has moved
        # reload to importlib.
        try:
            reload(requires)
        except NameError:
            import importlib
            importlib.reload(requires)

    @classmethod
    def tearDownClass(cls):
        cls._patched_hook.stop()
        cls._patched_hook_started = None
        cls._patched_hook = None
        # and fix any breakage we did to the module
        try:
            reload(requires)
        except NameError:
            import importlib
            importlib.reload(requires)

    def patch(self, method):
        _m = mock.patch.object(self.obj, method)
        _mock = _m.start()
        self.addCleanup(_m.stop)
        return _mock

    def setUp(self):
        self.cr = requires.HAClusterRequires('some-relation', [])
        self._patches = {}
        self._patches_start = {}
        self.obj = requires
        for method in TO_PATCH:
            setattr(self, method, self.patch(method))

    def tearDown(self):
        self.cr = None
        for k, v in self._patches.items():
            v.stop()
            setattr(self, k, None)
        self._patches = None
        self._patches_start = None

    def patch_kr(self, attr, return_value=None):
        mocked = mock.patch.object(self.cr, attr)
        self._patches[attr] = mocked
        started = mocked.start()
        started.return_value = return_value
        self._patches_start[attr] = started
        setattr(self, attr, started)

    def test_joined(self):
        self.patch_kr('set_state')
        self.cr.joined()
        self.set_state.assert_called_once_with('{relation_name}.connected')

    def test_changed(self):
        self.patch_kr('is_clustered', True)
        self.patch_kr('set_state')
        self.cr.changed()
        self.set_state.assert_called_once_with('{relation_name}.available')

    def test_changed_not_clustered(self):
        self.patch_kr('is_clustered', False)
        self.patch_kr('remove_state')
        self.cr.changed()
        self.remove_state.assert_called_once_with('{relation_name}.available')

    def test_departed(self):
        self.patch_kr('remove_state')
        self.cr.departed()
        self.remove_state.assert_has_calls([
            mock.call('{relation_name}.available'),
            mock.call('{relation_name}.connected')])

    def test_is_clustered(self):
        self.patch_kr('get_remote_all')

        self.get_remote_all.return_value = [True]
        self.assertTrue(self.cr.is_clustered())

        self.get_remote_all.return_value = ['true']
        self.assertTrue(self.cr.is_clustered())

        self.get_remote_all.return_value = ['yes']
        self.assertTrue(self.cr.is_clustered())

        self.get_remote_all.return_value = None
        self.assertFalse(self.cr.is_clustered())

        self.get_remote_all.return_value = [False]
        self.assertFalse(self.cr.is_clustered())

        self.get_remote_all.return_value = ['false']
        self.assertFalse(self.cr.is_clustered())

        self.get_remote_all.return_value = ['flump']
        self.assertFalse(self.cr.is_clustered())

    def jsonify(self, options):
        json_encode_options = dict(
            sort_keys=True,
        )
        for k, v in options.items():
            if v:
                options[k] = json.dumps(v, **json_encode_options)

    def test_manage_resources(self):
        res = common.CRM()
        res.primitive('res_neutron_haproxy', 'lsb:haproxy',
                      op='monitor interval="5s"')
        res.init_services('haproxy')
        res.clone('cl_nova_haproxy', 'res_neutron_haproxy')
        expected = {
            'json_clones': {"cl_nova_haproxy": "res_neutron_haproxy"},
            'json_init_services': ["haproxy"],
            'json_resource_params': {
                "res_neutron_haproxy": '  op monitor interval="5s"'},
            'json_resources': {"res_neutron_haproxy": "lsb:haproxy"}}
        self.jsonify(expected)
        self.data_changed.return_value = True
        self.patch_kr('set_local')
        self.patch_kr('set_remote')
        self.cr.manage_resources(res)
        self.set_local.assert_called_once_with(**expected)
        self.set_remote.assert_called_once_with(**expected)

    def test_manage_resources_no_change(self):
        res = common.CRM()
        res.primitive('res_neutron_haproxy', 'lsb:haproxy',
                      op='monitor interval="5s"')
        res.init_services('haproxy')
        res.clone('cl_nova_haproxy', 'res_neutron_haproxy')
        self.data_changed.return_value = False
        self.patch_kr('set_local')
        self.patch_kr('set_remote')
        self.cr.manage_resources(res)
        self.assertFalse(self.set_local.called)
        self.assertFalse(self.set_remote.called)

    def test_bind_resources(self):
        self.patch_kr('get_local', 'resources')
        self.patch_kr('bind_on')
        self.patch_kr('manage_resources')
        self.cr.bind_resources()
        self.bind_on.assert_called_once_with(iface=None, mcastport=4440)
        self.manage_resources.assert_called_once_with('resources')

    def test_bind_resources_no_defaults(self):
        self.patch_kr('get_local', 'resources')
        self.patch_kr('bind_on')
        self.patch_kr('manage_resources')
        self.cr.bind_resources(iface='tr34', mcastport=111)
        self.bind_on.assert_called_once_with(iface='tr34', mcastport=111)
        self.manage_resources.assert_called_once_with('resources')

    def test_delete_resource(self):
        expected = {
            'resources': {},
            'resource_params': {},
            'delete_resources': ('doomed_res',),
            'groups': {},
            'ms': {},
            'orders': {},
            'colocations': {},
            'clones': {},
            'locations': {},
            'init_services': []}
        self.patch_kr('get_local', None)
        self.patch_kr('set_local')
        self.cr.delete_resource('doomed_res')
        self.set_local.assert_called_once_with(resources=expected)

    def test_delete_resource_multi(self):
        base = {
            'resources': {},
            'resource_params': {},
            'groups': {},
            'ms': {},
            'orders': {},
            'colocations': {},
            'clones': {},
            'locations': {},
            'init_services': []}
        res_with_res1 = copy.deepcopy(base)
        res_with_res1_res2 = copy.deepcopy(base)
        res_with_res1['delete_resources'] = ('doomed_res1',)
        res_with_res1_res2['delete_resources'] = ('doomed_res1', 'doomed_res2')
        get_local_results = [res_with_res1, base]
        self.patch_kr('get_local')
        self.get_local.side_effect = lambda x: get_local_results.pop()
        self.patch_kr('set_local')
        self.cr.delete_resource('doomed_res1')
        self.cr.delete_resource('doomed_res2')
        self.set_local.assert_has_calls([
            mock.call(resources=res_with_res1),
            mock.call(resources=res_with_res1_res2)])

    def test_add_vip(self):
        expected = {
            'resources': {
                'res_mysql_4b8ce37_vip': 'ocf:heartbeat:IPaddr2'},
            'delete_resources': [],
            'resource_params': {
                'res_mysql_4b8ce37_vip': (
                    '  params ip="10.110.5.43"  op monitor depth="0" '
                    'timeout="20s" interval="10s"')},
            'groups': {},
            'ms': {},
            'orders': {},
            'colocations': {},
            'clones': {},
            'locations': {},
            'init_services': []}

        self.patch_kr('get_local', None)
        self.patch_kr('set_local')
        self.cr.add_vip('mysql', '10.110.5.43')
        self.set_local.assert_called_once_with(resources=expected)

    def test_add_additional_vip(self):
        existing_resource = {
            'resources': {
                'res_mysql_4b8ce37_vip': 'ocf:heartbeat:IPaddr2'},
            'delete_resources': [],
            'resource_params': {
                'res_mysql_4b8ce37_vip': (
                    '  params ip="10.110.5.43"  op monitor depth="0" '
                    'timeout="20s" interval="10s"')},
            'groups': {},
            'ms': {},
            'orders': {},
            'colocations': {},
            'clones': {},
            'locations': {},
            'init_services': []}

        expected = {
            'resources': {
                'res_mysql_4b8ce37_vip': 'ocf:heartbeat:IPaddr2',
                'res_mysql_1993276_vip': 'ocf:heartbeat:IPaddr2'},
            'delete_resources': [],
            'resource_params': {
                'res_mysql_4b8ce37_vip': (
                    '  params ip="10.110.5.43"  op monitor depth="0" '
                    'timeout="20s" interval="10s"'),
                'res_mysql_1993276_vip': (
                    '  params ip="10.120.5.43"  op monitor depth="0" '
                    'timeout="20s" interval="10s"')},
            'groups': {
                'grp_mysql_vips': ('res_mysql_1993276_vip '
                                   'res_mysql_4b8ce37_vip')},
            'ms': {},
            'orders': {},
            'colocations': {},
            'clones': {},
            'locations': {},
            'init_services': []}

        self.patch_kr('get_local', existing_resource)
        self.patch_kr('set_local')
        self.cr.add_vip('mysql', '10.120.5.43')
        self.set_local.assert_called_once_with(resources=expected)

    def test_add_init_service(self):
        expected = {
            'resources': {
                'res_mysql_telnetd': 'lsb:telnetd'},
            'delete_resources': [],
            'resource_params': {
                'res_mysql_telnetd': '  op monitor interval="5s"'},
            'groups': {},
            'ms': {},
            'orders': {},
            'colocations': {},
            'clones': {'cl_res_mysql_telnetd': 'res_mysql_telnetd'},
            'locations': {},
            'init_services': ('telnetd',)}
        self.patch_kr('get_local', None)
        self.patch_kr('set_local')
        self.cr.add_init_service('mysql', 'telnetd')
        self.set_local.assert_called_once_with(resources=expected)

    def test_add_dnsha(self):
        expected = {
            'resources': {
                'res_keystone_public_hostname': 'ocf:maas:dns'},
            'delete_resources': [],
            'resource_params': {
                'res_keystone_public_hostname': (
                    '  params  fqdn="keystone.public" '
                    'ip_address="10.110.5.43"')},
            'groups': {},
            'ms': {},
            'orders': {},
            'colocations': {},
            'clones': {},
            'locations': {},
            'init_services': []}

        self.patch_kr('get_local', None)
        self.patch_kr('set_local')
        self.cr.add_dnsha(
            'keystone',
            '10.110.5.43',
            'keystone.public',
            'public')
        self.set_local.assert_called_once_with(resources=expected)

    def test_add_additional_dnsha(self):
        existing_resource = {
            'resources': {
                'res_keystone_public_hostname': 'ocf:maas:dns'},
            'delete_resources': [],
            'resource_params': {
                'res_keystone_public_hostname': (
                    '  params  fqdn="keystone.public" '
                    'ip_address="10.110.5.43"')},
            'groups': {},
            'ms': {},
            'orders': {},
            'colocations': {},
            'clones': {},
            'locations': {},
            'init_services': []}
        expected = {
            'resources': {
                'res_keystone_public_hostname': 'ocf:maas:dns',
                'res_keystone_admin_hostname': 'ocf:maas:dns'},
            'delete_resources': [],
            'resource_params': {
                'res_keystone_public_hostname': (
                    '  params  fqdn="keystone.public" '
                    'ip_address="10.110.5.43"'),
                'res_keystone_admin_hostname': (
                    '  params  fqdn="keystone.admin" '
                    'ip_address="10.120.5.43"')},
            'groups': {
                'grp_keystone_hostnames': ('res_keystone_admin_hostname '
                                           'res_keystone_public_hostname')},
            'ms': {},
            'orders': {},
            'colocations': {},
            'clones': {},
            'locations': {},
            'init_services': []}

        self.patch_kr('get_local', existing_resource)
        self.patch_kr('set_local')
        self.cr.add_dnsha(
            'keystone',
            '10.120.5.43',
            'keystone.admin',
            'admin')
        self.set_local.assert_called_once_with(resources=expected)

    @mock.patch.object(requires.hookenv, 'related_units')
    @mock.patch.object(requires.hookenv, 'relation_get')
    def test_get_remote_all(self, relation_get, related_units):
        unit_data = {
            'rid:1': {
                'app1/0': {
                    'key1': 'value1',
                    'key2': 'value2'},
                'app1/1': {
                    'key1': 'value1',
                    'key2': 'value3'}},
            'rid:2': {
                'app2/0': {
                    'key1': 'value1',
                    'key2': 'value3'}},
            'rid:3': {}}

        def get_unit_data(key, unit, relation_id):
            return unit_data[relation_id].get(unit, {}).get(key, {})
        conv1 = mock.MagicMock()
        conv1.relation_ids = ['rid:1', 'rid:2']
        conv2 = mock.MagicMock()
        conv2.relation_ids = ['rid:3']
        self.patch_kr('conversations', [conv1, conv2])
        related_units.side_effect = lambda x: unit_data[x].keys()
        relation_get.side_effect = get_unit_data
        # Check de-duplication:
        self.assertEqual(
            self.cr.get_remote_all('key1'),
            ['value1'])
        # Check multiple values:
        self.assertEqual(
            self.cr.get_remote_all('key2'),
            ['value2', 'value3'])
        # Check missing key
        self.assertEqual(
            self.cr.get_remote_all('key100'),
            [])
        # Check missing key with default
        self.assertEqual(
            self.cr.get_remote_all('key100', default='defaultvalue'),
            ['defaultvalue'])