# This file is part of Checkbox.
#
# Copyright 2013, 2014 Canonical Ltd.
# Written by:
#   Zygmunt Krynicki <zygmunt.krynicki@canonical.com>
#
# Checkbox is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 3,
# as published by the Free Software Foundation.

#
# Checkbox is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Checkbox.  If not, see <http://www.gnu.org/licenses/>.

"""
plainbox.impl.secure.test_config
================================

Test definitions for plainbox.impl.secure.config module
"""
from io import StringIO
from unittest import TestCase
import configparser

from plainbox.impl.secure.config import ChoiceValidator
from plainbox.impl.secure.config import ConfigMetaData
from plainbox.impl.secure.config import KindValidator
from plainbox.impl.secure.config import NotEmptyValidator
from plainbox.impl.secure.config import NotUnsetValidator
from plainbox.impl.secure.config import OneOrTheOtherValidator
from plainbox.impl.secure.config import PatternValidator
from plainbox.impl.secure.config import ParametricSection
from plainbox.impl.secure.config import PlainBoxConfigParser, Config
from plainbox.impl.secure.config import ValidationError
from plainbox.impl.secure.config import Variable, Section, Unset
from plainbox.impl.secure.config import understands_Unset
from plainbox.vendor import mock


class UnsetTests(TestCase):

    def test_str(self):
        self.assertEqual(str(Unset), "unset")

    def test_repr(self):
        self.assertEqual(repr(Unset), "Unset")

    def test_bool(self):
        self.assertEqual(bool(Unset), False)


class understands_Unset_Tests(TestCase):

    def test_func(self):
        @understands_Unset
        def func():
            pass

        self.assertTrue(hasattr(func, 'understands_Unset'))
        self.assertTrue(getattr(func, 'understands_Unset'))

    def test_cls(self):
        @understands_Unset
        class cls:
            pass

        self.assertTrue(hasattr(cls, 'understands_Unset'))
        self.assertTrue(getattr(cls, 'understands_Unset'))


class VariableTests(TestCase):

    def test_name(self):
        v1 = Variable()
        self.assertIsNone(v1.name)
        v2 = Variable('var')
        self.assertEqual(v2.name, 'var')
        v3 = Variable(name='var')
        self.assertEqual(v3.name, 'var')

    def test_section(self):
        v1 = Variable()
        self.assertEqual(v1.section, 'DEFAULT')
        v2 = Variable(section='foo')
        self.assertEqual(v2.section, 'foo')

    def test_kind(self):
        v1 = Variable(kind=bool)
        self.assertIs(v1.kind, bool)
        v2 = Variable(kind=int)
        self.assertIs(v2.kind, int)
        v3 = Variable(kind=float)
        self.assertIs(v3.kind, float)
        v4 = Variable(kind=str)
        self.assertIs(v4.kind, str)
        v5 = Variable()
        self.assertIs(v5.kind, str)
        v6 = Variable(kind=list)
        self.assertIs(v6.kind, list)
        with self.assertRaises(ValueError):
            Variable(kind=dict)

    def test_validator_list__default(self):
        """
        verify that each Variable has a validator_list and that by default,
        that list contains a KindValidator as the first element
        """
        self.assertEqual(Variable().validator_list, [KindValidator])

    def test_validator_list__explicit(self):
        """
        verify that each Variable has a validator_list and that, if
        customized, the list contains the custom validators, preceded by
        the implicit KindValidator object
        """
        def DummyValidator(variable, new_value):
            """ Dummy validator for the test below"""
            pass
        var = Variable(validator_list=[DummyValidator])
        self.assertEqual(var.validator_list, [KindValidator, DummyValidator])

    def test_validator_list__with_NotUnsetValidator(self):
        """
        verify that each Variable has a validator_list and that, if
        customized, and if using NotUnsetValidator it will take precedence
        over all other validators, including the implicit KindValidator
        """
        var = Variable(validator_list=[NotUnsetValidator()])
        self.assertEqual(
            var.validator_list, [NotUnsetValidator(), KindValidator])


class SectionTests(TestCase):

    def test_name(self):
        s1 = Section()
        self.assertIsNone(s1.name)
        s2 = Section('sec')
        self.assertEqual(s2.name, 'sec')
        s3 = Variable(name='sec')
        self.assertEqual(s3.name, 'sec')


class ConfigTests(TestCase):

    def test_Meta_present(self):
        class TestConfig(Config):
            pass
        self.assertTrue(hasattr(TestConfig, 'Meta'))

    def test_Meta_base_cls(self):
        class TestConfig(Config):
            pass
        self.assertTrue(issubclass(TestConfig.Meta, ConfigMetaData))

        class HelperMeta:
            pass

        class TestConfigWMeta(Config):
            Meta = HelperMeta
        self.assertTrue(issubclass(TestConfigWMeta.Meta, ConfigMetaData))
        self.assertTrue(issubclass(TestConfigWMeta.Meta, HelperMeta))

    def test_Meta_variable_list(self):
        class TestConfig(Config):
            v1 = Variable()
            v2 = Variable()
        self.assertEqual(
            TestConfig.Meta.variable_list,
            [TestConfig.v1, TestConfig.v2])

    def test_variable_smoke(self):
        class TestConfig(Config):
            v = Variable()
        conf = TestConfig()
        self.assertIs(conf.v, Unset)
        conf.v = "value"
        self.assertEqual(conf.v, "value")
        del conf.v
        self.assertIs(conf.v, Unset)

    def _get_featureful_config(self):
        # define a featureful config class
        class TestConfig(Config):
            v1 = Variable()
            v2 = Variable(section="v23_section")
            v3 = Variable(section="v23_section")
            v_unset = Variable()
            v_bool = Variable(section="type_section", kind=bool)
            v_int = Variable(section="type_section", kind=int)
            v_float = Variable(section="type_section", kind=float)
            v_list = Variable(section="type_section", kind=list)
            v_str = Variable(section="type_section", kind=str)
            s = Section()
            ps = ParametricSection()
        conf = TestConfig()
        # assign value to each variable, except v3_unset
        conf.v1 = "v1 value"
        conf.v2 = "v2 value"
        conf.v3 = "v3 value"
        conf.v_bool = True
        conf.v_int = -7
        conf.v_float = 1.5
        conf.v_str = "hi"
        conf.v_list = ['foo', 'bar']
        # assign value to the section
        conf.s = {"a": 1, "b": 2}
        conf.ps = {"foo": {"c": 3, "d": 4}}
        return conf

    def test_get_parser_obj(self):
        """
        verify that Config.get_parser_obj() properly writes all the data to the
        ConfigParser object.
        """
        conf = self._get_featureful_config()
        parser = conf.get_parser_obj()
        # verify that section and section-less variables work
        self.assertEqual(parser.get("DEFAULT", "v1"), "v1 value")
        self.assertEqual(parser.get("v23_section", "v2"), "v2 value")
        self.assertEqual(parser.get("v23_section", "v3"), "v3 value")
        # verify that unset variable is not getting set to anything
        with self.assertRaises(configparser.Error):
            parser.get("DEFAULT", "v_unset")
        # verify that various types got converted correctly and still resolve
        # to correct typed values
        self.assertEqual(parser.get("type_section", "v_bool"), "True")
        self.assertEqual(parser.getboolean("type_section", "v_bool"), True)
        self.assertEqual(parser.get("type_section", "v_int"), "-7")
        self.assertEqual(parser.getint("type_section", "v_int"), -7)
        self.assertEqual(parser.get("type_section", "v_float"), "1.5")
        self.assertEqual(parser.getfloat("type_section", "v_float"), 1.5)
        self.assertEqual(parser.get("type_section", "v_str"), "hi")
        # verify that section work okay
        self.assertEqual(parser.get("s", "a"), "1")
        self.assertEqual(parser.get("s", "b"), "2")
        # verify that parametric section works okay
        self.assertEqual(parser.get("ps:foo", "c"), "3")
        self.assertEqual(parser.get("ps:foo", "d"), "4")

    def test_write(self):
        """
        verify that Config.write() works
        """
        conf = self._get_featureful_config()
        with StringIO() as stream:
            conf.write(stream)
            self.assertEqual(stream.getvalue(), (
                "[DEFAULT]\n"
                "v1 = v1 value\n"
                "\n"
                "[v23_section]\n"
                "v2 = v2 value\n"
                "v3 = v3 value\n"
                "\n"
                "[type_section]\n"
                "v_bool = True\n"
                "v_float = 1.5\n"
                "v_int = -7\n"
                "v_list = foo, bar\n"
                "v_str = hi\n"
                "\n"
                "[s]\n"
                "a = 1\n"
                "b = 2\n"
                "\n"
                "[ps:foo]\n"
                "c = 3\n"
                "d = 4\n"
                "\n"))

    def test_section_smoke(self):
        class TestConfig(Config):
            s = Section()
        conf = TestConfig()
        self.assertIs(conf.s, Unset)
        with self.assertRaises(TypeError):
            conf.s['key'] = "key-value"
        conf.s = {}
        self.assertEqual(conf.s, {})
        conf.s['key'] = "key-value"
        self.assertEqual(conf.s['key'], "key-value")
        del conf.s
        self.assertIs(conf.s, Unset)

    def test_read_string(self):
        class TestConfig(Config):
            v = Variable()
        conf = TestConfig()
        conf.read_string(
            "[DEFAULT]\n"
            "v = 1")
        self.assertEqual(conf.v, "1")
        self.assertEqual(len(conf.problem_list), 0)

    def test_read_list_with_spaces(self):
        class TestConfig(Config):
            l = Variable(kind=list)
        conf = TestConfig()
        conf.read_string('[DEFAULT]\nl = foo bar')
        self.assertEqual(conf.l, ['foo', 'bar'])
        self.assertEqual(len(conf.problem_list), 0)

    def test_read_list_with_commas(self):
        class TestConfig(Config):
            l = Variable(kind=list)
        conf = TestConfig()
        conf.read_string('[DEFAULT]\nl = foo,bar')
        self.assertEqual(conf.l, ['foo', 'bar'])
        self.assertEqual(len(conf.problem_list), 0)

    def test_read_list_quoted_strings(self):
        class TestConfig(Config):
            l = Variable(kind=list)
        conf = TestConfig()
        conf.read_string('[DEFAULT]\nl = foo "bar baz"')
        self.assertEqual(conf.l, ['foo', 'bar baz'])
        self.assertEqual(len(conf.problem_list), 0)

    def test_read_string_calls_validate_whole(self):
        """
        verify that Config.read_string() calls validate_whole()"
        """
        conf = Config()
        with mock.patch.object(conf, 'validate_whole') as mocked_validate:
            conf.read_string('')
        mocked_validate.assert_called_once_with()

    def test_read_calls_validate_whole(self):
        """
        verify that Config.read() calls validate_whole()"
        """
        conf = Config()
        with mock.patch.object(conf, 'validate_whole') as mocked_validate:
            conf.read([])
        mocked_validate.assert_called_once_with()

    def test_read__handles_errors_from_validate_whole(self):
        """
        verify that Config.read() collects errors from validate_whole()".
        """
        class TestConfig(Config):
            v = Variable()

            def validate_whole(self):
                raise ValidationError(TestConfig.v, self.v, "v is evil")
        conf = TestConfig()
        conf.read([])
        self.assertEqual(len(conf.problem_list), 1)
        self.assertEqual(conf.problem_list[0].variable, TestConfig.v)
        self.assertEqual(conf.problem_list[0].new_value, Unset)
        self.assertEqual(conf.problem_list[0].message, "v is evil")

    def test_read_string__does_not_ignore_nonmentioned_variables(self):
        class TestConfig(Config):
            v = Variable(validator_list=[NotUnsetValidator()])
        conf = TestConfig()
        conf.read_string("")
        # Because Unset is the default, sadly
        self.assertEqual(conf.v, Unset)
        # But there was a problem noticed
        self.assertEqual(len(conf.problem_list), 1)
        self.assertEqual(conf.problem_list[0].variable, TestConfig.v)
        self.assertEqual(conf.problem_list[0].new_value, Unset)
        self.assertEqual(conf.problem_list[0].message,
                         "must be set to something")

    def test_read_string__handles_errors_from_validate_whole(self):
        """
        verify that Config.read_strig() collects errors from validate_whole()".
        """
        class TestConfig(Config):
            v = Variable()

            def validate_whole(self):
                raise ValidationError(TestConfig.v, self.v, "v is evil")
        conf = TestConfig()
        conf.read_string("")
        self.assertEqual(len(conf.problem_list), 1)
        self.assertEqual(conf.problem_list[0].variable, TestConfig.v)
        self.assertEqual(conf.problem_list[0].new_value, Unset)
        self.assertEqual(conf.problem_list[0].message, "v is evil")


class ConfigMetaDataTests(TestCase):

    def test_filename_list(self):
        self.assertEqual(ConfigMetaData.filename_list, [])

    def test_variable_list(self):
        self.assertEqual(ConfigMetaData.variable_list, [])

    def test_section_list(self):
        self.assertEqual(ConfigMetaData.section_list, [])

    def test_parametric_section_list(self):
        self.assertEqual(ConfigMetaData.parametric_section_list, [])


class PlainBoxConfigParserTest(TestCase):

    def test_parser(self):
        conf_file = StringIO("[testsection]\nlower = low\nUPPER = up")
        config = PlainBoxConfigParser()
        config.read_file(conf_file)

        self.assertEqual(['testsection'], config.sections())
        all_keys = list(config['testsection'].keys())
        self.assertTrue('lower' in all_keys)
        self.assertTrue('UPPER' in all_keys)
        self.assertFalse('upper' in all_keys)

    def test_parametric_sections_parsing(self):
        class TestConfig(Config):
            ps = ParametricSection()
        conf_str = "[ps:foo]\nval = baz\n[ps:bar]\nvar = biz"
        config = TestConfig()
        config.read_string(conf_str)
        self.assertEqual(
            config.ps,
            {'foo': {'val': 'baz'}, 'bar': {'var': 'biz'}})


class KindValidatorTests(TestCase):

    class _Config(Config):
        var_bool = Variable(kind=bool)
        var_int = Variable(kind=int)
        var_float = Variable(kind=float)
        var_str = Variable(kind=str)

    def test_error_msg(self):
        """
        verify that KindValidator() has correct error message for each type
        """
        bad_value = object()
        self.assertEqual(
            KindValidator(self._Config.var_bool, bad_value),
            "expected a boolean")
        self.assertEqual(
            KindValidator(self._Config.var_int, bad_value),
            "expected an integer")
        self.assertEqual(
            KindValidator(self._Config.var_float, bad_value),
            "expected a floating point number")
        self.assertEqual(
            KindValidator(self._Config.var_str, bad_value),
            "expected a string")


class PatternValidatorTests(TestCase):

    class _Config(Config):
        var = Variable()

    def test_smoke(self):
        """
        verify that PatternValidator works as intended
        """
        validator = PatternValidator("foo.+")
        self.assertEqual(validator(self._Config.var, "foobar"), None)
        self.assertEqual(
            validator(self._Config.var, "foo"),
            "does not match pattern: 'foo.+'")

    def test_comparison_works(self):
        self.assertTrue(PatternValidator('foo') == PatternValidator('foo'))
        self.assertTrue(PatternValidator('foo') != PatternValidator('bar'))
        self.assertTrue(PatternValidator('foo') != object())


class ChoiceValidatorTests(TestCase):

    class _Config(Config):
        var = Variable()

    def test_smoke(self):
        """
        verify that ChoiceValidator works as intended
        """
        validator = ChoiceValidator(["foo", "bar"])
        self.assertEqual(validator(self._Config.var, "foo"), None)
        self.assertEqual(
            validator(self._Config.var, "omg"),
            "var must be one of foo, bar. Got 'omg'")

    def test_comparison_works(self):
        self.assertTrue(ChoiceValidator(["a"]) == ChoiceValidator(["a"]))
        self.assertTrue(ChoiceValidator(["a"]) != ChoiceValidator(["b"]))
        self.assertTrue(ChoiceValidator(["a"]) != object())


class NotUnsetValidatorTests(TestCase):
    """
    Tests for the NotUnsetValidator class
    """

    class _Config(Config):
        var = Variable()

    def test_understands_Unset(self):
        """
        verify that Unset can be handled at all
        """
        self.assertTrue(getattr(NotUnsetValidator, "understands_Unset"))

    def test_rejects_unset_values(self):
        """
        verify that Unset variables are rejected
        """
        validator = NotUnsetValidator()
        self.assertEqual(
            validator(self._Config.var, Unset), "must be set to something")

    def test_accepts_other_values(self):
        """
        verify that other values are accepted
        """
        validator = NotUnsetValidator()
        self.assertIsNone(validator(self._Config.var, None))
        self.assertIsNone(validator(self._Config.var, "string"))
        self.assertIsNone(validator(self._Config.var, 15))

    def test_supports_custom_message(self):
        """
        verify that custom message is used
        """
        validator = NotUnsetValidator("value required!")
        self.assertEqual(
            validator(self._Config.var, Unset), "value required!")

    def test_comparison_works(self):
        """
        verify that comparison works as expected
        """
        self.assertTrue(NotUnsetValidator() == NotUnsetValidator())
        self.assertTrue(NotUnsetValidator("?") == NotUnsetValidator("?"))
        self.assertTrue(NotUnsetValidator() != NotUnsetValidator("?"))
        self.assertTrue(NotUnsetValidator() != object())


class NotEmptyValidatorTests(TestCase):

    class _Config(Config):
        var = Variable()

    def test_rejects_empty_values(self):
        validator = NotEmptyValidator()
        self.assertEqual(validator(self._Config.var, ""), "cannot be empty")

    def test_supports_custom_message(self):
        validator = NotEmptyValidator("name required!")
        self.assertEqual(validator(self._Config.var, ""), "name required!")

    def test_isnt_broken(self):
        validator = NotEmptyValidator()
        self.assertEqual(validator(self._Config.var, "some value"), None)

    def test_comparison_works(self):
        self.assertTrue(NotEmptyValidator() == NotEmptyValidator())
        self.assertTrue(NotEmptyValidator("?") == NotEmptyValidator("?"))
        self.assertTrue(NotEmptyValidator() != NotEmptyValidator("?"))
        self.assertTrue(NotEmptyValidator() != object())


class OneOrTheOtherValidatorTests(TestCase):

    class _Config(Config):
        var = Variable("The Name", kind=list)

    def test_pass_validation(self):
        validator = OneOrTheOtherValidator({'foo'}, {'bar'})
        value = ['foo']
        self.assertIsNone(validator(self._Config.var, value))
        value = ['bar']
        self.assertIsNone(validator(self._Config.var, value))

    def test_fail_validation(self):
        validator = OneOrTheOtherValidator({'foo'}, {'bar'})
        value = ['foo', 'bar']
        self.assertEquals(
            validator(self._Config.var, value),
            "The Name can only use values from {'foo'} or from {'bar'}")

    def test_pass_empty(self):
        validator = OneOrTheOtherValidator({'foo'}, {'bar'})
        value = []
        self.assertIsNone(validator(self._Config.var, value))

    def test_comparison_works(self):
        self.assertEqual(
            OneOrTheOtherValidator({'foo'}, {'bar'}),
            OneOrTheOtherValidator({'foo'}, {'bar'})
        )
        self.assertEqual(
            OneOrTheOtherValidator({1, 2}, {3, 4}),
            OneOrTheOtherValidator({2, 1}, {4, 3})
        )
        self.assertNotEqual(
            OneOrTheOtherValidator({1}, {2}),
            OneOrTheOtherValidator({1}, {'foo'})
        )
        self.assertNotEqual(OneOrTheOtherValidator({1}, {2}), object())
