openide/python/helpers/test_generator.py

# encoding: utf-8
"""
Tests basic things that generator3 consists of.
NOTE: does not work in Jython 2.2 or IronPython 1.x, because pyparsing does not.
"""

import unittest
from generator3 import *

M = ModuleRedeclarator

import sys

IS_CLI = sys.platform == 'cli'
VERSION = sys.version_info[:2] # only (major, minor)

class TestRestoreFuncByDocComment(unittest.TestCase):
    """
    Tries to restore function signatures by doc strings.
    """

    def setUp(self):
        self.m = ModuleRedeclarator(None, None, '/dev/null')

    def testTrivial(self):
        result, ret_sig, note = self.m.parse_func_doc("blah f(a, b, c) ololo", "f", "f", None)
        self.assertEquals(result, "f(a, b, c)")
        self.assertEquals(note, M.SIG_DOC_NOTE)

    def testTrivialNested(self):
        result, ret_sig, note = self.m.parse_func_doc("blah f(a, (b, c), d) ololo", "f", "f", None)
        self.assertEquals(result, "f(a, (b, c), d)")
        self.assertEquals(note, M.SIG_DOC_NOTE)

    def testWithDefault(self):
        result, ret_sig, note = self.m.parse_func_doc("blah f(a, b, c=1) ololo", "f", "f", None)
        self.assertEquals(result, "f(a, b, c=1)")
        self.assertEquals(note, M.SIG_DOC_NOTE)

    def testNestedWithDefault(self):
        result, ret_sig, note = self.m.parse_func_doc("blah f(a, (b1, b2), c=1) ololo", "f", "f", None)
        self.assertEquals(result, "f(a, (b1, b2), c=1)")
        self.assertEquals(note, M.SIG_DOC_NOTE)

    def testAbstractDefault(self):
        # like new(S, ...)
        result, ret_sig, note = self.m.parse_func_doc('blah f(a, b=obscuredefault) ololo', "f", "f", None)
        self.assertEquals(result, "f(a, b=None)")
        self.assertEquals(note, M.SIG_DOC_NOTE)

    def testWithReserved(self):
        result, ret_sig, note = self.m.parse_func_doc("blah f(class, object, def) ololo", "f", "f", None)
        self.assertEquals(result, "f(p_class, p_object, p_def)")
        self.assertEquals(note, M.SIG_DOC_NOTE)

    def testWithReservedOpt(self):
        result, ret_sig, note = self.m.parse_func_doc("blah f(foo, bar[, def]) ololo", "f", "f", None)
        self.assertEquals(result, "f(foo, bar, p_def=None)")
        self.assertEquals(note, M.SIG_DOC_NOTE)

    def testPseudoNested(self):
        result, ret_sig, note = self.m.parse_func_doc("blah f(a, (b1, b2, ...)) ololo", "f", "f", None)
        self.assertEquals(result, "f(a, b_tuple)")
        self.assertEquals(note, M.SIG_DOC_NOTE)

    def testImportLike(self):
        # __import__
        result, ret_sig, note = self.m.parse_func_doc("blah f(name, globals={}, locals={}, fromlist=[], level=-1) ololo",
                                                      "f", "f", None)
        self.assertEquals(result, "f(name, globals={}, locals={}, fromlist=[], level=-1)")
        self.assertEquals(note, M.SIG_DOC_NOTE)

    def testOptionalBracket(self):
        # reduce
        result, ret_sig, note = self.m.parse_func_doc("blah f(function, sequence[, initial]) ololo", "f", "f", None)
        self.assertEquals(result, "f(function, sequence, initial=None)")
        self.assertEquals(note, M.SIG_DOC_NOTE)

    def testWithMore(self):
        result, ret_sig, note = self.m.parse_func_doc("blah f(foo [, bar1, bar2, ...]) ololo", "f", "f", None)
        self.assertEquals(result, "f(foo, *bar)")
        self.assertEquals(note, M.SIG_DOC_NOTE)

    def testNestedOptionals(self):
        result, ret_sig, note = self.m.parse_func_doc("blah f(foo [, bar1 [, bar2]]) ololo", "f", "f", None)
        self.assertEquals(result, "f(foo, bar1=None, bar2=None)")
        self.assertEquals(note, M.SIG_DOC_NOTE)

    def testInnerTuple(self):
        result, ret_sig, note = self.m.parse_func_doc("blah load_module(name, file, filename, (suffix, mode, type)) ololo"
            , "load_module", "load_module", None)
        self.assertEquals(result, "load_module(name, file, filename, (suffix, mode, type))")
        self.assertEquals(note, M.SIG_DOC_NOTE)

    def testIncorrectInnerTuple(self):
        result, ret_sig, note = self.m.parse_func_doc("blah f(a, (b=1, c=2)) ololo", "f", "f", None)
        self.assertEquals(result, "f(a, p_b)")
        self.assertEquals(note, M.SIG_DOC_NOTE)

    def testNestedOnly(self):
        result, ret_sig, note = self.m.parse_func_doc("blah f((foo, bar, baz)) ololo", "f", "f", None)
        self.assertEquals(result, "f((foo, bar, baz))")
        self.assertEquals(note, M.SIG_DOC_NOTE)

    def testTwoPseudoNested(self):
        result, ret_sig, note = self.m.parse_func_doc("blah f((a1, a2, ...), (b1, b2,..)) ololo", "f", "f", None)
        self.assertEquals(result, "f(a_tuple, b_tuple)")
        self.assertEquals(note, M.SIG_DOC_NOTE)

    def testTwoPseudoNestedWithLead(self):
        result, ret_sig, note = self.m.parse_func_doc("blah f(x, (a1, a2, ...), (b1, b2,..)) ololo", "f", "f", None)
        self.assertEquals(result, "f(x, a_tuple, b_tuple)")
        self.assertEquals(note, M.SIG_DOC_NOTE)

    def testPseudoNestedRange(self):
        result, ret_sig, note = self.m.parse_func_doc("blah f((a1, ..., an), b) ololo", "f", "f", None)
        self.assertEquals(result, "f(a_tuple, b)")
        self.assertEquals(note, M.SIG_DOC_NOTE)

    def testIncorrectList(self):
        result, ret_sig, note = self.m.parse_func_doc("blah f(x, y, 3, $) ololo", "f", "f", None)
        self.assertEquals(result, "f(x, y, *args, **kwargs)")
        self.assertEquals(note, M.SIG_DOC_UNRELIABLY)

    def testIncorrectStarredList(self):
        result, ret_sig, note = self.m.parse_func_doc("blah f(x, *y, 3, $) ololo", "f", "f", None)
        self.assertEquals(result, "f(x, *y, **kwargs)")
        self.assertEquals(note, M.SIG_DOC_UNRELIABLY)

    def testClashingNames(self):
        result, ret_sig, note = self.m.parse_func_doc("blah f(x, y, (x, y), z) ololo", "f", "f", None)
        self.assertEquals(result, "f(x, y, (x_1, y_1), z)")
        self.assertEquals(note, M.SIG_DOC_NOTE)

    def testQuotedParam(self):
        # like __delattr__
        result, ret_sig, note = self.m.parse_func_doc("blah getattr('name') ololo", "getattr", "getattr", None)
        self.assertEquals(result, "getattr(name)")
        self.assertEquals(note, M.SIG_DOC_NOTE)

    def testQuotedParam2(self):
        # like __delattr__, too
        result, ret_sig, note = self.m.parse_func_doc('blah getattr("name") ololo', "getattr", "getattr", None)
        self.assertEquals(result, "getattr(name)")
        self.assertEquals(note, M.SIG_DOC_NOTE)

    def testOptionalTripleDot(self):
        # like new(S, ...)
        result, ret_sig, note = self.m.parse_func_doc('blah f(foo, ...) ololo', "f", "f", None)
        self.assertEquals(result, "f(foo, *more)")
        self.assertEquals(note, M.SIG_DOC_NOTE)

    def testUnderscoredName(self):
        # like new(S, ...)
        result, ret_sig, note = self.m.parse_func_doc('blah f(foo_one, _bar_two) ololo', "f", "f", None)
        self.assertEquals(result, "f(foo_one, _bar_two)")
        self.assertEquals(note, M.SIG_DOC_NOTE)

    def testDashedName(self):
        # like new(S, ...)
        result, ret_sig, note = self.m.parse_func_doc('blah f(something-else, for-a-change) ololo', "f", "f", None)
        self.assertEquals(result, "f(something_else, for_a_change)")
        self.assertEquals(note, M.SIG_DOC_NOTE)

    def testSpacedDefault(self):
        # like new(S, ...)
        result, ret_sig, note = self.m.parse_func_doc('blah f(a, b = 1) ololo', "f", "f", None)
        self.assertEquals(result, "f(a, b=1)")
        self.assertEquals(note, M.SIG_DOC_NOTE)

    def testSpacedName(self):
        # like new(S, ...)
        result, ret_sig, note = self.m.parse_func_doc('blah femme(skirt or pants) ololo', "femme", "femme", None)
        self.assertEquals(result, "femme(skirt_or_pants)")
        self.assertEquals(note, M.SIG_DOC_NOTE)


class TestRestoreMethodByDocComment(unittest.TestCase):
    """
    Restoring with a class name set
    """

    def setUp(self):
        self.m = ModuleRedeclarator(None, None, '/dev/null')

    def testPlainMethod(self):
        result, ret_sig, note = self.m.parse_func_doc("blah f(self, foo, bar) ololo", "f", "f", "SomeClass")
        self.assertEquals(result, "f(self, foo, bar)")
        self.assertEquals(note, M.SIG_DOC_NOTE)

    def testInsertSelf(self):
        result, ret_sig, note = self.m.parse_func_doc("blah f(foo, bar) ololo", "f", "f", "SomeClass")
        self.assertEquals(result, "f(self, foo, bar)")
        self.assertEquals(note, M.SIG_DOC_NOTE)


class TestAnnotatedParameters(unittest.TestCase):
    """
    f(foo: int) and friends; in doc comments, happen in 2.x world, too.
    """

    def setUp(self):
        self.m = ModuleRedeclarator(None, None, '/dev/null')

    def testMixed(self):
        result, ret_sig, note = self.m.parse_func_doc('blah f(i: int, foo) ololo', "f", "f", None)
        self.assertEquals(result, "f(i, foo)")
        self.assertEquals(note, M.SIG_DOC_NOTE)

    def testNested(self):
        result, ret_sig, note = self.m.parse_func_doc('blah f(i: int, (foo: bar, boo: Decimal)) ololo', "f", "f", None)
        self.assertEquals(result, "f(i, (foo, boo))")
        self.assertEquals(note, M.SIG_DOC_NOTE)

    def testSpaced(self):
        result, ret_sig, note = self.m.parse_func_doc('blah f(i: int, j :int, k : int) ololo', "f", "f", None)
        self.assertEquals(result, "f(i, j, k)")
        self.assertEquals(note, M.SIG_DOC_NOTE)


if not IS_CLI and VERSION < (3, 0):
    class TestInspect(unittest.TestCase):
        """
        See that inspect actually works if needed
        """

        def setUp(self):
            self.m = ModuleRedeclarator(None, None, '/dev/null')

        def testSimple(self):
            def target(a, b, c=1, *d, **e):
                return a, b, c, d, e

            result = restore_by_inspect(target)
            self.assertEquals(result, "(a, b, c=1, *d, **e)")

        def testNested(self):
            # NOTE: Py3k can't handle nested tuple args, thus we compile it conditionally
            code = (
                "def target(a, (b, c), d, e=1):\n"
                "    return a, b, c, d, e"
            )
            namespace = {}
            eval(compile(code, "__main__", "single"), namespace)
            target = namespace['target']

            result = restore_by_inspect(target)
            self.assertEquals(result, "(a, (b, c), d, e=1)")

class _DiffPrintingTestCase(unittest.TestCase):
    def assertEquals(self, etalon, specimen, msg=None):
        if type(etalon) == str and type(specimen) == str and etalon != specimen:
            print("%s" % "\n")
            # print side by side
            ei = iter(etalon.split("\n"))
            si = iter(specimen.split("\n"))
            if VERSION < (3, 0):
                si_next = si.next
            else:
                si_next = si.__next__
            for el in ei:
                try: sl = si_next()
                except StopIteration: break # I wish the exception would just work as break
                if el != sl:
                    print("!%s" % el)
                    print("?%s" % sl)
                else:
                    print(">%s" % sl)
                    # one of the iters might not end yet
            for el in ei:
                print("!%s" % el)
            for sl in si:
                print("?%s" % sl)
            raise self.failureException(msg)
        else:
            self.failUnlessEqual(etalon, specimen, msg)


class TestSpecialCases(unittest.TestCase):
    """
    Tests cases where predefined overrides kick in
    """

    def setUp(self):
        import sys

        if VERSION >= (3, 0):
            import builtins as the_builtins

            self.builtins_name = the_builtins.__name__
        else:
            import __builtin__ as the_builtins

            self.builtins_name = the_builtins.__name__
        self.m = ModuleRedeclarator(the_builtins, None, '/dev/null', doing_builtins=True)

    def _testBuiltinFuncName(self, func_name, expected):
        class_name = None
        self.assertTrue(self.m.is_predefined_builtin(self.builtins_name, class_name, func_name))
        result, note = restore_predefined_builtin(class_name, func_name)
        self.assertEquals(result, func_name + expected)
        self.assertEquals(note, "known special case of " + func_name)

    def testZip(self):
        self._testBuiltinFuncName("zip", "(seq1, seq2, *more_seqs)")

    def testRange(self):
        self._testBuiltinFuncName("range", "(start=None, stop=None, step=None)")

    def testFilter(self):
        self._testBuiltinFuncName("filter", "(function_or_none, sequence)")

        # we caould want to test a calss without __dict__, but it takes a C extension to really create one,

class TestDataOutput(_DiffPrintingTestCase):
    """
    Tests for sanity of output of data members
    """

    def setUp(self):
        self.m = ModuleRedeclarator(self, None, 4) # Pass anything with __dict__ as module

    def checkFmtValue(self, data, expected):
        buf = Buf(self.m)
        self.m.fmt_value(buf.out, data, 0)
        result = "".join(buf.data).strip()
        self.assertEquals(expected, result)

    def testRecursiveDict(self):
        data = {'a': 1}
        data['b'] = data
        expected = "\n".join((
            "{",
            "    'a': 1,",
            "    'b': '<value is a self-reference, replaced by this string>',",
            "}"
        ))
        self.checkFmtValue(data, expected)

    def testRecursiveList(self):
        data = [1]
        data.append(data)
        data.append(2)
        data.append([10, data, 20])
        expected = "\n".join((
            "[",
            "    1,",
            "    '<value is a self-reference, replaced by this string>',",
            "    2,",
            "    [",
            "        10,",
            "        '<value is a self-reference, replaced by this string>',",
            "        20,",
            "    ],",
            "]"
        ))
        self.checkFmtValue(data, expected)

if not IS_CLI:
    class TestReturnTypes(unittest.TestCase):
        """
        Tests for sanity of output of data members
        """

        def setUp(self):
            self.m = ModuleRedeclarator(None, None, 4)

        def checkRestoreFunction(self, doc, expected):
            spec, ret_literal, note = self.m.parse_func_doc(doc, "foo", "foo", None)
            self.assertEqual(expected, ret_literal, "%r != %r; spec=%r, note=%r" % (expected, ret_literal, spec, note))
            pass

        def testSimpleArrowInt(self):
            doc = "This is foo(bar) -> int"
            self.checkRestoreFunction(doc, "0")

        def testSimpleArrowList(self):
            doc = "This is foo(bar) -> list"
            self.checkRestoreFunction(doc, "[]")

        def testArrowListOf(self):
            doc = "This is foo(bar) -> list of int"
            self.checkRestoreFunction(doc, "[]")

        #    def testArrowTupleOf(self):
        #      doc = "This is foo(bar) -> (a, b,..)"
        #      self.checkRestoreFunction(doc, "()")

        def testSimplePrefixInt(self):
            doc = "This is int foo(bar)"
            self.checkRestoreFunction(doc, "0")

        def testSimplePrefixObject(self):
            doc = "Makes an instance: object foo(bar)"
            self.checkRestoreFunction(doc, "object()")

        if VERSION < (3, 0):
            # TODO: we only support it in 2.x; must update when we do it in 3.x, too
            def testSimpleArrowFile(self):
                doc = "Opens a file: foo(bar) -> file"
                self.checkRestoreFunction(doc, "file('/dev/null')")

        def testUnrelatedPrefix(self):
            doc = """
        Consumes a list of int
        foo(bar)
      """
            self.checkRestoreFunction(doc, None)


###
if __name__ == '__main__':
    unittest.main()