# Test admin commands

import functools

import unittest

from mercurial.i18n import _

from mercurial import error, ui as uimod

from mercurial import registrar

from mercurial.admin import verify

class TestAdminVerifyFindChecks(unittest.TestCase):

    def __init__(self, *args, **kwargs):

        super().__init__(*args, **kwargs)

        self.ui = uimod.ui.load()

        self.repo = b"fake-repo"

        def cleanup_table(self):

            self.table = {}

            self.alias_table = {}

            self.pyramid = {}

        self.addCleanup(cleanup_table, self)

    def setUp(self):

        self.table = {}

        self.alias_table = {}

        self.pyramid = {}

        check = registrar.verify_check(self.table, self.alias_table)

        # mock some fake check method for tests purpose

        @check(

            b"test.dummy",

            alias=b"dummy",

            options=[],

        )

        def check_dummy(ui, repo, **options):

            return options

        @check(

            b"test.fake",

            alias=b"fake",

            options=[

                (b'a', False, _(b'a boolean value (default: False)')),

                (b'b', True, _(b'a boolean value (default: True)')),

                (b'c', [], _(b'a list')),

            ],

        )

        def check_fake(ui, repo, **options):

            return options

        # alias in the middle of a hierarchy

        check(

            b"test.noop",

            alias=b"noop",

            options=[],

        )(verify.noop_func)

        @check(

            b"test.noop.deeper",

            alias=b"deeper",

            options=[

                (b'y', True, _(b'a boolean value (default: True)')),

                (b'z', [], _(b'a list')),

            ],

        )

        def check_noop_deeper(ui, repo, **options):

            return options

    # args wrapper utilities

    def find_checks(self, name):

        return verify.find_checks(

            name=name,

            table=self.table,

            alias_table=self.alias_table,

            full_pyramid=self.pyramid,

        )

    def pass_options(self, checks, options):

        return verify.pass_options(

            self.ui,

            checks,

            options,

            table=self.table,

            alias_table=self.alias_table,

            full_pyramid=self.pyramid,

        )

    def get_checks(self, names, options):

        return verify.get_checks(

            self.repo,

            self.ui,

            names=names,

            options=options,

            table=self.table,

            alias_table=self.alias_table,

            full_pyramid=self.pyramid,

        )

    # tests find_checks

    def test_find_checks_empty_name(self):

        with self.assertRaises(error.InputError):

            self.find_checks(name=b"")

    def test_find_checks_wrong_name(self):

        with self.assertRaises(error.InputError):

            self.find_checks(name=b"unknown")

    def test_find_checks_dummy(self):

        name = b"test.dummy"

        found = self.find_checks(name=name)

        self.assertEqual(len(found), 1)

        self.assertIn(name, found)

        meth = found[name]

        self.assertTrue(callable(meth))

        self.assertEqual(len(meth.options), 0)

    def test_find_checks_fake(self):

        name = b"test.fake"

        found = self.find_checks(name=name)

        self.assertEqual(len(found), 1)

        self.assertIn(name, found)

        meth = found[name]

        self.assertTrue(callable(meth))

        self.assertEqual(len(meth.options), 3)

    def test_find_checks_noop(self):

        name = b"test.noop.deeper"

        found = self.find_checks(name=name)

        self.assertEqual(len(found), 1)

        self.assertIn(name, found)

        meth = found[name]

        self.assertTrue(callable(meth))

        self.assertEqual(len(meth.options), 2)

    def test_find_checks_from_aliases(self):

        found = self.find_checks(name=b"dummy")

        self.assertEqual(len(found), 1)

        self.assertIn(b"test.dummy", found)

        found = self.find_checks(name=b"fake")

        self.assertEqual(len(found), 1)

        self.assertIn(b"test.fake", found)

        found = self.find_checks(name=b"deeper")

        self.assertEqual(len(found), 1)

        self.assertIn(b"test.noop.deeper", found)

    def test_find_checks_from_root(self):

        found = self.find_checks(name=b"test")

        self.assertEqual(len(found), 3)

        self.assertIn(b"test.dummy", found)

        self.assertIn(b"test.fake", found)

        self.assertIn(b"test.noop.deeper", found)

    def test_find_checks_from_intermediate(self):

        found = self.find_checks(name=b"test.noop")

        self.assertEqual(len(found), 1)

        self.assertIn(b"test.noop.deeper", found)

    def test_find_checks_from_parent_dot_name(self):

        found = self.find_checks(name=b"noop.deeper")

        self.assertEqual(len(found), 1)

        self.assertIn(b"test.noop.deeper", found)

    # tests pass_options

    def test_pass_options_no_checks_no_options(self):

        checks = {}

        options = []

        with self.assertRaises(error.Error):

            self.pass_options(checks=checks, options=options)

    def test_pass_options_fake_empty_options(self):

        checks = self.find_checks(name=b"test.fake")

        funcs = {

            n: functools.partial(f, self.ui, self.repo)

            for n, f in checks.items()

        }

        options = []

        # should end with default options

        expected_options = {"a": False, "b": True, "c": []}

        func = self.pass_options(checks=funcs, options=options)

        self.assertDictEqual(func[b"test.fake"].keywords, expected_options)

    def test_pass_options_fake_non_existing_options(self):

        checks = self.find_checks(name=b"test.fake")

        funcs = {

            n: functools.partial(f, self.ui, self.repo)

            for n, f in checks.items()

        }

        with self.assertRaises(error.InputError):

            options = [b"test.fake:boom=yes"]

            self.pass_options(checks=funcs, options=options)

    def test_pass_options_fake_unrelated_options(self):

        checks = self.find_checks(name=b"test.fake")

        funcs = {

            n: functools.partial(f, self.ui, self.repo)

            for n, f in checks.items()

        }

        options = [b"test.noop.deeper:y=yes"]

        with self.assertRaises(error.InputError):

            self.pass_options(checks=funcs, options=options)

    def test_pass_options_fake_set_option(self):

        checks = self.find_checks(name=b"test.fake")

        funcs = {

            n: functools.partial(f, self.ui, self.repo)

            for n, f in checks.items()

        }

        options = [b"test.fake:a=yes"]

        expected_options = {"a": True, "b": True, "c": []}

        func = self.pass_options(checks=funcs, options=options)

        self.assertDictEqual(func[b"test.fake"].keywords, expected_options)

    def test_pass_options_fake_set_option_with_alias(self):

        checks = self.find_checks(name=b"test.fake")

        funcs = {

            n: functools.partial(f, self.ui, self.repo)

            for n, f in checks.items()

        }

        options = [b"fake:a=yes"]

        expected_options = {"a": True, "b": True, "c": []}

        func = self.pass_options(checks=funcs, options=options)

        self.assertDictEqual(func[b"test.fake"].keywords, expected_options)

    def test_pass_options_fake_set_all_option(self):

        checks = self.find_checks(name=b"test.fake")

        funcs = {

            n: functools.partial(f, self.ui, self.repo)

            for n, f in checks.items()

        }

        options = [b"test.fake:a=yes", b"test.fake:b=no", b"test.fake:c=0,1,2"]

        expected_options = {"a": True, "b": False, "c": [b"0", b"1", b"2"]}

        func = self.pass_options(checks=funcs, options=options)

        self.assertDictEqual(func[b"test.fake"].keywords, expected_options)

    def test_pass_options_fake_set_all_option_plus_unexisting(self):

        checks = self.find_checks(name=b"test.fake")

        funcs = {

            n: functools.partial(f, self.ui, self.repo)

            for n, f in checks.items()

        }

        options = [

            b"test.fake:a=yes",

            b"test.fake:b=no",

            b"test.fake:c=0,1,2",

            b"test.fake:d=0",

        ]

        with self.assertRaises(error.InputError):

            self.pass_options(checks=funcs, options=options)

    def test_pass_options_fake_duplicate_option(self):

        checks = self.find_checks(name=b"test.fake")

        funcs = {

            n: functools.partial(f, self.ui, self.repo)

            for n, f in checks.items()

        }

        options = [

            b"test.fake:a=yes",

            b"test.fake:a=no",

        ]

        with self.assertRaises(error.InputError):

            self.pass_options(checks=funcs, options=options)

    def test_pass_options_fake_set_malformed_option(self):

        checks = self.find_checks(name=b"test.fake")

        funcs = {

            n: functools.partial(f, self.ui, self.repo)

            for n, f in checks.items()

        }

        options = [

            b"test.fake:ayes",

            b"test.fake:b==no",

            b"test.fake=",

            b"test.fake:",

            b"test.fa=ke:d=0",

            b"test.fa=ke:d=0",

        ]

        for opt in options:

            with self.assertRaises(error.InputError):

                self.pass_options(checks=funcs, options=[opt])

    def test_pass_options_types(self):

        checks = self.find_checks(name=b"test.fake")

        funcs = {

            n: functools.partial(f, self.ui, self.repo)

            for n, f in checks.items()

        }

        # boolean, yes/no

        options = [b"test.fake:a=yes", b"test.fake:b=no"]

        expected_options = {"a": True, "b": False, "c": []}

        func = self.pass_options(checks=funcs, options=options)

        self.assertDictEqual(func[b"test.fake"].keywords, expected_options)

        # boolean, 0/1

        options = [b"test.fake:a=1", b"test.fake:b=0"]

        expected_options = {"a": True, "b": False, "c": []}

        func = self.pass_options(checks=funcs, options=options)

        self.assertDictEqual(func[b"test.fake"].keywords, expected_options)

        # boolean, true/false

        options = [b"test.fake:a=true", b"test.fake:b=false"]

        expected_options = {"a": True, "b": False, "c": []}

        func = self.pass_options(checks=funcs, options=options)

        self.assertDictEqual(func[b"test.fake"].keywords, expected_options)

        # boolean, wrong type

        options = [b"test.fake:a=si"]

        with self.assertRaises(error.InputError):

            self.pass_options(checks=funcs, options=options)

        # lists

        options = [b"test.fake:c=0,1,2"]

        expected_options = {"a": False, "b": True, "c": [b"0", b"1", b"2"]}

        func = self.pass_options(checks=funcs, options=options)

        self.assertDictEqual(func[b"test.fake"].keywords, expected_options)

        options = [b"test.fake:c=x,y,z"]

        expected_options = {"a": False, "b": True, "c": [b"x", b"y", b"z"]}

        func = self.pass_options(checks=funcs, options=options)

        self.assertDictEqual(func[b"test.fake"].keywords, expected_options)

    # tests get_checks

    def test_get_checks_fake(self):

        funcs = self.get_checks(

            names=[b"test.fake"], options=[b"test.fake:a=yes"]

        )

        options = funcs.get(b"test.fake").keywords

        expected_options = {"a": True, "b": True, "c": []}

        self.assertDictEqual(options, expected_options)

    def test_get_checks_multiple_mixed_with_defaults(self):

        funcs = self.get_checks(

            names=[b"test.fake", b"test.noop.deeper", b"test.dummy"],

            options=[

                b"test.noop.deeper:y=no",

                b"test.noop.deeper:z=-1,0,1",

            ],

        )

        options = funcs.get(b"test.fake").keywords

        expected_options = {"a": False, "b": True, "c": []}

        self.assertDictEqual(options, expected_options)

        options = funcs.get(b"test.noop.deeper").keywords

        expected_options = {"y": False, "z": [b"-1", b"0", b"1"]}

        self.assertDictEqual(options, expected_options)

        options = funcs.get(b"test.dummy").keywords

        expected_options = {}

        self.assertDictEqual(options, expected_options)

    def test_broken_pyramid(self):

        """Check that we detect pyramids that can't resolve"""

        table = {}

        alias_table = {}

        pyramid = {}

        check = registrar.verify_check(table, alias_table)

        # Create two checks that clash

        @check(b"test.wrong.intermediate")

        def check_dummy(ui, repo, **options):

            return options

        @check(b"test.wrong.intermediate.thing")