sphinx-autoapi/tests/python/test_parser.py

# coding=utf8

"""Test Python parser"""

import sys
import unittest
from textwrap import dedent

import astroid
import pytest

from autoapi.mappers.python import Parser

if sys.version_info < (3, 0):
    from StringIO import StringIO
else:
    from io import StringIO


class PythonParserTests(unittest.TestCase):
    def parse(self, source):
        node = astroid.extract_node(source)
        return Parser().parse(node)

    def test_parses_basic_file(self):
        source = """
        def foo(bar):
            pass
        """
        data = self.parse(source)[0]
        self.assertEqual(data["name"], "foo")
        self.assertEqual(data["type"], "function")

    def test_parses_all(self):
        source = """
        __all__ = ['Foo', 5.0]
        """
        data = self.parse(source)[0]
        self.assertEqual(data["name"], "__all__")
        self.assertEqual(data["value"], ["Foo", 5.0])

    @pytest.mark.xfail(reason="Cannot parse list additions")
    def test_parses_all_with_list_addition(self):
        source = """
        __all__ = ['Foo'] + []
        """
        data = self.parse(source)[0]
        self.assertEqual(data["name"], "__all__")
        self.assertEqual(data["value"], ["Foo"])

    @pytest.mark.xfail(reason="Cannot parse list additions")
    def test_parses_all_with_name_addtion(self):
        source = """
        __all__ = ['Foo'] + bar.__all__
        """
        data = self.parse(source)[0]
        self.assertEqual(data["name"], "__all__")
        self.assertEqual(data["value"], ["Foo"])

    @pytest.mark.xfail(reason="Cannot parse list additions")
    def test_parses_all_with_multiple_name_addtions(self):
        source = """
        __all__ = foo + bar
        __all__ += boop
        __all__ += ['foo']
        """
        data = self.parse(source)
        self.assertEqual(data["name"], "__all__")
        self.assertEqual(data["value"], ["foo"])
        source = """
        __all__ = ['foo']
        __all__ = foo
        """
        data = self.parse(source)
        self.assertEqual(data["name"], "__all__")
        self.assertEqual(data["value"], [])

    def test_parses_all_multiline(self):
        source = """
        __all__ = [
            'foo',
            'bar',
        ]
        """
        data = self.parse(source)[0]
        self.assertEqual(data["value"], ["foo", "bar"])

    @pytest.mark.xfail(reason="Cannot parse list additions")
    def test_parses_all_generator(self):
        source = """
        __all__ = [x for x in dir(token) if x[0] != '_'] + ['foo', 'bar']
        """
        data = self.parse(source)[0]
        self.assertEqual(data["value"], ["foo", "bar"])

    def test_parses_name(self):
        source = "foo.bar"
        self.assertEqual(self.parse(source), {})

    def test_parses_list(self):
        name = "__all__"
        value = [1, 2, 3, 4]
        source = "{} = {}".format(name, value)
        data = self.parse(source)[0]
        self.assertEqual(data["name"], name)
        self.assertEqual(data["value"], value)

    def test_parses_nested_list(self):
        name = "__all__"
        value = [[1, 2], [3, 4]]
        source = "{} = {}".format(name, value)
        data = self.parse(source)[0]
        self.assertEqual(data["name"], name)
        self.assertEqual(data["value"], value)

    def test_arguments(self):
        """Argument parsing of source"""
        source = (
            "def foobar(self, bar, baz=42, foo=True,\n"
            "           *args, **kwargs):\n"
            '    "This is a docstring"\n'
            "    return True\n"
        )
        data = self.parse(source)[0]
        self.assertEqual(data["args"], "self, bar, baz=42, foo=True, *args, **kwargs")

    def test_advanced_arguments(self):
        """Advanced argument parsing"""
        source = (
            'def foobar(self, a, b, c=42, d="string", e=(1,2),\n'
            '           f={"a": True}, g=None, h=[1,2,3,4],\n'
            "           i=dict(a=True), j=False, *args, **kwargs):\n"
            '    "This is a docstring"\n'
            "    return True\n"
        )
        data = self.parse(source)[0]
        self.assertEqual(
            data["args"],
            ", ".join(
                [
                    "self",
                    "a",
                    "b",
                    "c=42",
                    "d='string'",
                    "e=(1, 2)",
                    "f={'a': True}",
                    "g=None",
                    "h=[1, 2, 3, 4]",
                    "i=dict(a=True)",
                    "j=False",
                    "*args",
                    "**kwargs",
                ]
            ),
        )

    def test_dict_key_assignment(self):
        """Ignore assignment to dictionary entries."""
        source = """
        MY_DICT = {}  #@
        if condition:
            MY_DICT['key'] = 'value'
        MY_DICT['key2'] = 'value2'
        """
        data = self.parse(source)[0]
        self.assertEqual(data["name"], "MY_DICT")

    def test_list_index_assignment(self):
        """Ignore assignment to indexes."""
        source = """
        COLOUR = [255, 128, 0]  #@
        if condition:
            COLOUR[1] = 255
        COLOUR[2] = 255
        """
        data = self.parse(source)[0]
        self.assertEqual(data["name"], "COLOUR")