sphinx-autoapi/tests/test_domains.py

"""Test .NET autoapi domain"""

import unittest

from mock import patch

from autoapi.mappers import dotnet


class DotNetSphinxMapperTests(unittest.TestCase):
    def setUp(self):
        """Test setup"""

        class _config(object):
            def __getattr__(self, key):
                attrs = {
                    "autoapi_dirs": ["/tmp/autoapi/tmp"],
                    "autoapi_root": "/tmp/autoapi/root",
                }
                return attrs.get(key, None)

        class _application(object):
            config = _config()

            def warn(self, *args, **kwargs):
                pass

        self.application = _application()

    def test_create_class(self):
        """Test .NET class instance creation helper"""
        dom = dotnet.DotNetSphinxMapper(self.application)

        def _create_class(data):
            return list(dom.create_class(data))[0]

        cls = _create_class({"id": "Foo.Bar", "type": "Namespace"})
        self.assertIsInstance(cls, dotnet.DotNetNamespace)
        cls = _create_class({"id": "Foo.Bar", "type": "Class"})
        self.assertIsInstance(cls, dotnet.DotNetClass)
        cls = _create_class({"id": "Foo.Bar", "type": "Property"})
        self.assertIsInstance(cls, dotnet.DotNetProperty)
        cls = _create_class({"id": "Foo.Bar", "type": "Method"})
        self.assertIsInstance(cls, dotnet.DotNetMethod)
        cls = _create_class({"id": "Foo.Bar", "type": "Enum"})
        self.assertIsInstance(cls, dotnet.DotNetEnum)
        cls = _create_class({"id": "Foo.Bar", "type": "Constructor"})
        self.assertIsInstance(cls, dotnet.DotNetConstructor)
        cls = _create_class({"id": "Foo.Bar", "type": "Struct"})
        self.assertIsInstance(cls, dotnet.DotNetStruct)
        cls = _create_class({"id": "Foo.Bar", "type": "Interface"})
        self.assertIsInstance(cls, dotnet.DotNetInterface)
        cls = _create_class({"id": "Foo.Bar", "type": "Delegate"})
        self.assertIsInstance(cls, dotnet.DotNetDelegate)
        cls = _create_class({"id": "Foo.Bar", "type": "Field"})
        self.assertIsInstance(cls, dotnet.DotNetField)
        cls = _create_class({"id": "Foo.Bar", "type": "Event"})
        self.assertIsInstance(cls, dotnet.DotNetEvent)

    def test_create_class_with_children(self):
        dom = dotnet.DotNetSphinxMapper(self.application)

        def _create_class(data):
            return list(dom.create_class(data))[0]

        cls = _create_class(
            {
                "id": "Foo.Bar",
                "type": "Class",
                "items": [{"id": "Foo.Bar.Baz", "type": "Method"}],
            }
        )
        self.assertIsInstance(cls, dotnet.DotNetClass)
        self.assertDictEqual(cls.item_map, {})

    @patch("subprocess.check_output", lambda foo: foo)
    def test_get_objects(self):
        """Test basic get objects"""
        objs = []

        def _mock_find(self, patterns, **kwargs):
            return {"items": ["foo", "bar"]}

        def _mock_read(self, path):
            return {
                "items": [
                    {"id": "Foo.Bar", "name": "Foo", "type": "property"},
                    {"id": "Foo.Bar2", "name": "Bar", "type": "property"},
                ],
                "id": "Foo.Bar",
                "type": "Class",
                "summary": path,
            }

        with patch("autoapi.mappers.dotnet.DotNetSphinxMapper.find_files", _mock_find):
            with patch(
                "autoapi.mappers.dotnet.DotNetSphinxMapper.read_file", _mock_read
            ):
                dom = dotnet.DotNetSphinxMapper(self.application)
                dom.load("", "", "", raise_error=False)
                dom.map()
                objs = dom.objects
                self.assertEqual(len(objs), 2)
                self.assertEqual(objs["Foo.Bar"].id, "Foo.Bar")
                self.assertEqual(objs["Foo.Bar"].name, "Foo.Bar")
                self.assertEqual(objs["Foo.Bar2"].id, "Foo.Bar2")
                self.assertEqual(objs["Foo.Bar2"].name, "Foo.Bar2")


class DotNetPythonMapperTests(unittest.TestCase):
    def test_xml_parse(self):
        """XML doc comment parsing"""
        ret = dotnet.DotNetPythonMapper.transform_doc_comments(
            'This is an example comment <see cref="FOO" />'
        )
        self.assertEqual(ret, "This is an example comment :any:`FOO`")

        ret = dotnet.DotNetPythonMapper.transform_doc_comments(
            'This is an example comment <see cref="!:FOO" />'
        )
        self.assertEqual(ret, "This is an example comment FOO")

        ret = dotnet.DotNetPythonMapper.transform_doc_comments(
            'This is an example comment <see cref="N:FOO">inner foo</see>'
        )
        self.assertEqual(ret, "This is an example comment :dn:ns:`FOO`")

        ret = dotnet.DotNetPythonMapper.transform_doc_comments(
            'Test <see cref="P:FOO" /> and <see cref="E:BAR">Blah</see>'
        )
        self.assertEqual(ret, "Test :dn:prop:`FOO` and :dn:event:`BAR`")

        ret = dotnet.DotNetPythonMapper.transform_doc_comments(
            'This is an example comment <paramref name="FOO" />'
        )
        self.assertEqual(ret, "This is an example comment ``FOO``")

        ret = dotnet.DotNetPythonMapper.transform_doc_comments(
            'This is an example comment <typeparamref name="FOO" />'
        )
        self.assertEqual(ret, "This is an example comment ``FOO``")

        ret = dotnet.DotNetPythonMapper.transform_doc_comments(
            'With surrounding characters s<see cref="FOO" />s'
        )
        self.assertEqual(ret, "With surrounding characters s :any:`FOO`\s")

        ret = dotnet.DotNetPythonMapper.transform_doc_comments(
            'With surrounding characters s<paramref name="FOO" />s'
        )
        self.assertEqual(ret, "With surrounding characters s ``FOO``\s")

    def test_xml_transform_escape(self):
        """XML transform escaping"""
        ret = dotnet.DotNetPythonMapper.transform_doc_comments(
            'Foo <see cref="Foo`1" /> Bar'
        )
        self.assertEqual(ret, "Foo :any:`Foo\\`1` Bar")

        ret = dotnet.DotNetPythonMapper.transform_doc_comments(
            'No space before<see cref="M:Foo`1" />or after'
        )
        self.assertEqual(ret, "No space before :dn:meth:`Foo\\`1`\\or after")

    def test_parsing_obj(self):
        """Parse out object, test for transforms, etc"""
        obj = {
            "uid": "Foo`1",
            "name": "Foo<TUser>",
            "summary": 'Test parsing <see cref="Bar" />',
            "syntax": {
                "parameters": [
                    {
                        "id": "a",
                        "type": "{TUser}",
                        "description": 'Test <see cref="TUser" />',
                    }
                ],
                "return": {
                    "type": "Bar",
                    "description": (
                        'Test references <see cref="Bar" /> '
                        'and paramrefs <paramref name="a" />'
                    ),
                },
            },
        }
        mapped = dotnet.DotNetPythonMapper(obj)
        self.assertEqual(
            mapped.parameters[0],
            {"name": "a", "type": "{TUser}", "desc": "Test :any:`TUser`"},
        )
        self.assertEqual(
            mapped.returns["description"],
            "Test references :any:`Bar` and paramrefs ``a``",
        )