Tests

import unittest

import argon


def returns(return_value):
    return lambda args: return_value


class TestArgon(unittest.TestCase):

    def test_command_ok(self):
        app = argon.App()
        with app.command("a") as a:
            a.handler(returns("a"))
        self.assertEqual(app.run(["a"]), "a")

    def test_command_no_handler(self):
        def no_handler():
            app = argon.App()
            with app.command("a") as a:
                pass  # no handler
        self.assertRaises(argon.CommandError, no_handler)

    def test_command_two_handlers(self):
        def two_handlers():
            app = argon.App()
            with app.command("a") as a:
                a.handler(returns("a"))
                a.handler(returns("a"))
        self.assertRaises(argon.CommandError, two_handlers)

    def test_sub_simple_ok(self):
        app = argon.App()
        with app.sub("a") as a:
            with a.command("a") as aa:
                aa.handler(returns("aa"))
            with a.command("b") as ab:
                ab.handler(returns("ab"))
        with app.command("c") as a:
            a.handler(returns("c"))
        self.assertEqual(app.run(["a", "a"]), "aa")
        self.assertEqual(app.run(["a", "b"]), "ab")
        self.assertEqual(app.run(["c"]), "c")

    def test_nesting(self):
        app = argon.App()
        with app.sub("a") as a:
            with a.sub("a") as aa:
                with aa.command("a") as aaa:
                    aaa.handler(returns("aaa"))
                with aa.command("b") as aab:
                    aab.handler(returns("aab"))
                with aa.sub("c") as aac:
                    with aac.command("a") as aaca:
                        aaca.handler(returns("aaca"))
                    with aac.command("b") as aacb:
                        aacb.handler(returns("aacb"))
            with a.sub("b") as ab:
                with ab.command("a") as aba:
                    aba.handler(returns("aba"))
                with ab.command("b") as abb:
                    abb.handler(returns("abb"))
                with ab.sub("c") as abc:
                    with abc.command("a") as abca:
                        abca.handler(returns("abca"))
                    with abc.command("b") as abcb:
                        abcb.handler(returns("abcb"))

        for comb in ["aaa", "aab", "aaca", "aacb",
                     "aba", "abb", "abca", "abcb"]:
            self.assertEqual(app.run(list(comb)), comb)

    def test_name_collisions(self):
        def same_sub_sub_name():
            app = argon.App()
            with app.sub("a") as a:
                with a.command("aa") as aa:
                    aa.handler(returns("aa"))
            with app.sub("a") as a:
                with a.command("aa") as aa:
                    aa.handler(returns("aa"))
        self.assertRaises(argon.SubError, same_sub_sub_name)

        def same_sub_command_name():
            app = argon.App()
            with app.sub("a") as a:
                with a.command("aa") as aa:
                    aa.handler(returns("aa"))
            with app.command("a") as a:
                a.handler(returns("a"))
        self.assertRaises(argon.SubError, same_sub_command_name)

        def same_command_command_name():
            app = argon.App()
            with app.command("a") as a:
                a.handler(returns("a"))
            with app.command("a") as a:
                a.handler(returns("a"))
        self.assertRaises(argon.SubError, same_command_command_name)

    def test_args(self):
        def xy(args):
            return (args.x, args.y)

        app = argon.App()
        with app.sub("a") as a:
            a.arg("-x", dest="x", nargs="?", default=False)
            with a.command("a") as aa:
                aa.arg("-y", dest="y", default=False, action="store_true")
                aa.handler(xy)

        self.assertEqual(app.run("a a".split()), (False, False))
        self.assertEqual(app.run("a -x a a".split()), ("a", False))
        self.assertEqual(app.run("a a -y".split()), (False, True))
        self.assertEqual(app.run("a -x foo a -y".split()), ("foo", True))

    def test_parse(self):
        handler = lambda args: args
        app = argon.App()
        with app.command("a") as a:
            a.handler(handler)
        func, args = app.parse(["a"])
        self.assertIs(func, handler)

    def test_parse_known(self):
        handler = lambda args: args
        app = argon.App()
        with app.command("a") as a:
            a.handler(handler)
        func, args, unknowns = app.parse_known(["a", "b"])
        self.assertIs(func, handler)
        self.assertEqual(unknowns, ["b"])

    def test_run_known(self):
        return_unknowns = lambda args, unknowns: unknowns
        app = argon.App()
        with app.command("a") as a:
            a.handler(return_unknowns)
        self.assertEqual(app.run_known(["a", "b"]), ["b"])

if __name__ == "__main__":
    unittest.main()