Archives
/
sphinx-autoapi
mirror of https://github.com/readthedocs/sphinx-autoapi
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Converted tests to pytest style

Browse Source
pull/279/head
Ashley Whetter 3 years ago
parent 9372bdb9f1
commit 826bb2badd
11 changed files with 170 additions and 184 deletions
Show Stats Download Patch File Download Diff File

1
CHANGELOG.rst
Unescape Escape View File

@ -33,6 +33,7 @@ Trivial/Internal Changes
* New example implementation of ``autoapi-skip-member`` Sphinx event.
* Can run tests with tox 4.
* Updated packaging to use PEP-517.
* All unittest style tests have been converted to pytest style tests.
V1.7.0 (2021-01-31)

2
autoapi/documenters.py
Unescape Escape View File

@ -81,7 +81,7 @@ class AutoapiDocumenter(autodoc.Documenter):
return False, sorted(children)
class _AutoapiDocstringSignatureMixin(object): # pylint: disable=too-few-public-methods
class _AutoapiDocstringSignatureMixin: # pylint: disable=too-few-public-methods
def format_signature(self, **kwargs):
# Set "manual" attributes at the last possible moment.
# This is to let a manual entry or docstring searching happen first,

4
autoapi/mappers/base.py
Unescape Escape View File

@ -19,7 +19,7 @@ LOGGER = sphinx.util.logging.getLogger(__name__)
Path = namedtuple("Path", ["absolute", "relative"])
class PythonMapperBase(object):
class PythonMapperBase:
"""
Base object for JSON -> Python object mapping.
@ -166,7 +166,7 @@ class PythonMapperBase(object):
return self.type
class SphinxMapperBase(object):
class SphinxMapperBase:
"""Base class for mapping `PythonMapperBase` objects to Sphinx.

2
autoapi/mappers/python/parser.py
Unescape Escape View File

@ -7,7 +7,7 @@ import astroid.builder
from . import astroid_utils
class Parser(object):
class Parser:
def __init__(self):
self._name_stack = []
self._encoding = None

81
tests/python/test_parser.py
Unescape Escape View File

@ -4,7 +4,6 @@
from io import StringIO
import sys
import unittest
from textwrap import dedent
import astroid
@ -13,7 +12,7 @@ import pytest
from autoapi.mappers.python.parser import Parser
class PythonParserTests(unittest.TestCase):
class TestPythonParser:
def parse(self, source):
node = astroid.extract_node(source)
return Parser().parse(node)
@ -24,16 +23,16 @@ class PythonParserTests(unittest.TestCase):
pass
"""
data = self.parse(source)[0]
self.assertEqual(data["name"], "foo")
self.assertEqual(data["type"], "function")
assert data["name"] == "foo"
assert 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])
assert data["name"] == "__all__"
assert data["value"] == ["Foo", 5.0]
def test_parses_all_multiline(self):
source = """
@ -43,27 +42,27 @@ class PythonParserTests(unittest.TestCase):
]
"""
data = self.parse(source)[0]
self.assertEqual(data["value"], ["foo", "bar"])
assert data["value"] == ["foo", "bar"]
def test_parses_name(self):
source = "foo.bar"
self.assertEqual(self.parse(source), {})
assert 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)
assert data["name"] == name
assert 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)
assert data["name"] == name
assert data["value"] == value
def test_arguments(self):
"""Argument parsing of source"""
@ -74,17 +73,15 @@ class PythonParserTests(unittest.TestCase):
" return True\n"
)
data = self.parse(source)[0]
self.assertEqual(
data["args"],
[
(None, "self", None, None),
(None, "bar", None, None),
(None, "baz", None, "42"),
(None, "foo", None, "True"),
("*", "args", None, None),
("**", "kwargs", None, None),
],
)
expected = [
(None, "self", None, None),
(None, "bar", None, None),
(None, "baz", None, "42"),
(None, "foo", None, "True"),
("*", "args", None, None),
("**", "kwargs", None, None),
]
assert data["args"] == expected
def test_advanced_arguments(self):
"""Advanced argument parsing"""
@ -96,24 +93,22 @@ class PythonParserTests(unittest.TestCase):
" return True\n"
)
data = self.parse(source)[0]
self.assertEqual(
data["args"],
[
(None, "self", None, None),
(None, "a", None, None),
(None, "b", None, None),
(None, "c", None, "42"),
(None, "d", None, "'string'"),
(None, "e", None, "(1, 2)"),
(None, "f", None, "{'a': True}"),
(None, "g", None, "None"),
(None, "h", None, "[1, 2, 3, 4]"),
(None, "i", None, "dict(a=True)"),
(None, "j", None, "False"),
("*", "args", None, None),
("**", "kwargs", None, None),
],
)
expected = [
(None, "self", None, None),
(None, "a", None, None),
(None, "b", None, None),
(None, "c", None, "42"),
(None, "d", None, "'string'"),
(None, "e", None, "(1, 2)"),
(None, "f", None, "{'a': True}"),
(None, "g", None, "None"),
(None, "h", None, "[1, 2, 3, 4]"),
(None, "i", None, "dict(a=True)"),
(None, "j", None, "False"),
("*", "args", None, None),
("**", "kwargs", None, None),
]
assert data["args"] == expected
def test_dict_key_assignment(self):
"""Ignore assignment to dictionary entries."""
@ -124,7 +119,7 @@ class PythonParserTests(unittest.TestCase):
MY_DICT['key2'] = 'value2'
"""
data = self.parse(source)[0]
self.assertEqual(data["name"], "MY_DICT")
assert data["name"] == "MY_DICT"
def test_list_index_assignment(self):
"""Ignore assignment to indexes."""
@ -135,4 +130,4 @@ class PythonParserTests(unittest.TestCase):
COLOUR[2] = 255
"""
data = self.parse(source)[0]
self.assertEqual(data["name"], "COLOUR")
assert data["name"] == "COLOUR"

24
tests/python/test_pyintegration.py
Unescape Escape View File

@ -3,7 +3,7 @@ import os
import re
import shutil
import sys
from mock import patch, Mock, call
from unittest.mock import patch, Mock, call
import pytest
import sphinx
@ -48,7 +48,7 @@ def builder():
os.chdir(cwd)
class TestSimpleModule(object):
class TestSimpleModule:
@pytest.fixture(autouse=True, scope="class")
def built(self, builder):
builder("pyexample")
@ -117,7 +117,7 @@ class TestSimpleModule(object):
assert "Bases:" in example_file
class TestSimpleStubModule(object):
class TestSimpleStubModule:
@pytest.fixture(autouse=True, scope="class")
def built(self, builder):
builder("pyiexample")
@ -142,7 +142,7 @@ class TestSimpleStubModule(object):
assert "Set an attribute" in example_file
class TestSimpleStubModuleNotPreferred(object):
class TestSimpleStubModuleNotPreferred:
@pytest.fixture(autouse=True, scope="class")
def built(self, builder):
builder("pyiexample2")
@ -158,7 +158,7 @@ class TestSimpleStubModuleNotPreferred(object):
assert "Foo" in example_file
class TestPy3Module(object):
class TestPy3Module:
@pytest.fixture(autouse=True, scope="class")
def built(self, builder):
builder("py3example")
@ -260,7 +260,7 @@ def test_py3_hiding_undoc_overloaded_members(builder):
assert "undoc_overloaded_method" not in example_file
class TestAnnotationCommentsModule(object):
class TestAnnotationCommentsModule:
@pytest.fixture(autouse=True, scope="class")
def built(self, builder):
builder("pyannotationcommentsexample")
@ -296,7 +296,7 @@ class TestAnnotationCommentsModule(object):
@pytest.mark.skipif(
sys.version_info < (3, 8), reason="Positional only arguments need Python >=3.8"
)
class TestPositionalOnlyArgumentsModule(object):
class TestPositionalOnlyArgumentsModule:
@pytest.fixture(autouse=True, scope="class")
def built(self, builder):
builder("py38positionalparams")
@ -341,7 +341,7 @@ def test_napoleon_integration_loaded(builder):
assert "Args" not in example_file
class TestSimplePackage(object):
class TestSimplePackage:
@pytest.fixture(autouse=True, scope="class")
def built(self, builder):
builder("pypackageexample")
@ -514,7 +514,7 @@ def test_order_members(builder, value, order):
assert indexes == sorted(indexes)
class _CompareInstanceType(object):
class _CompareInstanceType:
def __init__(self, type_):
self.type = type_
@ -602,7 +602,7 @@ def test_skip_members_hook(builder):
assert mock_call in emit_firstresult_patch.mock_calls
class TestComplexPackage(object):
class TestComplexPackage:
@pytest.fixture(autouse=True, scope="class")
def built(self, builder):
builder("pypackagecomplex")
@ -705,7 +705,7 @@ class TestComplexPackage(object):
assert "unicode_str" in foo_file
class TestComplexPackageParallel(object):
class TestComplexPackageParallel:
@pytest.fixture(autouse=True, scope="class")
def built(self, builder):
builder("pypackagecomplex", parallel=2)
@ -756,7 +756,7 @@ def test_caching(builder):
assert mtimes[1] != mtimes[0]
class TestImplicitNamespacePackage(object):
class TestImplicitNamespacePackage:
@pytest.fixture(autouse=True, scope="class")
def built(self, builder):
builder("py3implicitnamespace")

2
tests/test_astroid_utils.py
Unescape Escape View File

@ -57,7 +57,7 @@ def imported_call_cases():
yield import_, basename, expected
class TestAstroidUtils(object):
class TestAstroidUtils:
@pytest.mark.parametrize(
("import_", "basename", "expected"), list(imported_basename_cases())
)

109
tests/test_domains.py
Unescape Escape View File

@ -1,65 +1,60 @@
"""Test .NET autoapi domain"""
import unittest
import mock
from mock import patch
from unittest import mock
from unittest.mock import patch
from autoapi.mappers import dotnet
class DotNetSphinxMapperTests(unittest.TestCase):
def setUp(self):
"""Test setup"""
class MockConfig:
def __getattr__(self, key):
attrs = {
"autoapi_dirs": ["/tmp/autoapi/tmp"],
"autoapi_root": "/tmp/autoapi/root",
}
return attrs.get(key, None)
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()
class MockApplication:
config = MockConfig()
def warn(self, *args, **kwargs):
pass
def warn(self, *args, **kwargs):
pass
self.application = _application()
class TestDotNetSphinxMapper:
def test_create_class(self):
"""Test .NET class instance creation helper"""
dom = dotnet.DotNetSphinxMapper(self.application)
dom = dotnet.DotNetSphinxMapper(MockApplication())
def _create_class(data):
return list(dom.create_class(data))[0]
cls = _create_class({"id": "Foo.Bar", "type": "Namespace"})
self.assertIsInstance(cls, dotnet.DotNetNamespace)
assert isinstance(cls, dotnet.DotNetNamespace)
cls = _create_class({"id": "Foo.Bar", "type": "Class"})
self.assertIsInstance(cls, dotnet.DotNetClass)
assert isinstance(cls, dotnet.DotNetClass)
cls = _create_class({"id": "Foo.Bar", "type": "Property"})
self.assertIsInstance(cls, dotnet.DotNetProperty)
assert isinstance(cls, dotnet.DotNetProperty)
cls = _create_class({"id": "Foo.Bar", "type": "Method"})
self.assertIsInstance(cls, dotnet.DotNetMethod)
assert isinstance(cls, dotnet.DotNetMethod)
cls = _create_class({"id": "Foo.Bar", "type": "Enum"})
self.assertIsInstance(cls, dotnet.DotNetEnum)
assert isinstance(cls, dotnet.DotNetEnum)
cls = _create_class({"id": "Foo.Bar", "type": "Constructor"})
self.assertIsInstance(cls, dotnet.DotNetConstructor)
assert isinstance(cls, dotnet.DotNetConstructor)
cls = _create_class({"id": "Foo.Bar", "type": "Struct"})
self.assertIsInstance(cls, dotnet.DotNetStruct)
assert isinstance(cls, dotnet.DotNetStruct)
cls = _create_class({"id": "Foo.Bar", "type": "Interface"})
self.assertIsInstance(cls, dotnet.DotNetInterface)
assert isinstance(cls, dotnet.DotNetInterface)
cls = _create_class({"id": "Foo.Bar", "type": "Delegate"})
self.assertIsInstance(cls, dotnet.DotNetDelegate)
assert isinstance(cls, dotnet.DotNetDelegate)
cls = _create_class({"id": "Foo.Bar", "type": "Field"})
self.assertIsInstance(cls, dotnet.DotNetField)
assert isinstance(cls, dotnet.DotNetField)
cls = _create_class({"id": "Foo.Bar", "type": "Event"})
self.assertIsInstance(cls, dotnet.DotNetEvent)
assert isinstance(cls, dotnet.DotNetEvent)
def test_create_class_with_children(self):
dom = dotnet.DotNetSphinxMapper(self.application)
dom = dotnet.DotNetSphinxMapper(MockApplication())
def _create_class(data):
return list(dom.create_class(data))[0]
@ -71,8 +66,8 @@ class DotNetSphinxMapperTests(unittest.TestCase):
"items": [{"id": "Foo.Bar.Baz", "type": "Method"}],
}
)
self.assertIsInstance(cls, dotnet.DotNetClass)
self.assertDictEqual(cls.item_map, {})
assert isinstance(cls, dotnet.DotNetClass)
assert cls.item_map == {}
@patch("subprocess.check_output", lambda foo: foo)
def test_get_objects(self):
@ -97,71 +92,71 @@ class DotNetSphinxMapperTests(unittest.TestCase):
with patch(
"autoapi.mappers.dotnet.DotNetSphinxMapper.read_file", _mock_read
):
dom = dotnet.DotNetSphinxMapper(self.application)
dom = dotnet.DotNetSphinxMapper(MockApplication())
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")
assert len(objs) == 2
assert objs["Foo.Bar"].id == "Foo.Bar"
assert objs["Foo.Bar"].name == "Foo.Bar"
assert objs["Foo.Bar2"].id == "Foo.Bar2"
assert objs["Foo.Bar2"].name == "Foo.Bar2"
class DotNetPythonMapperTests(unittest.TestCase):
class TestDotNetPythonMapper:
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`")
assert 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")
assert 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`")
assert 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`")
assert 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``")
assert 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``")
assert ret == "This is an example comment ``FOO``"
ret = dotnet.DotNetPythonMapper.transform_doc_comments(
'With surrounding characters s<see cref="FOO" />s'
)
self.assertEqual(ret, r"With surrounding characters s :any:`FOO`\s")
assert ret == r"With surrounding characters s :any:`FOO`\s"
ret = dotnet.DotNetPythonMapper.transform_doc_comments(
'With surrounding characters s<paramref name="FOO" />s'
)
self.assertEqual(ret, r"With surrounding characters s ``FOO``\s")
assert ret == r"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")
assert 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")
assert ret == "No space before :dn:meth:`Foo\\`1`\\or after"
def test_parsing_obj(self):
"""Parse out object, test for transforms, etc"""
@ -187,11 +182,9 @@ class DotNetPythonMapperTests(unittest.TestCase):
},
}
mapped = dotnet.DotNetPythonMapper(obj, app=mock.MagicMock(), jinja_env=None)
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``",
expected = {"name": "a", "type": "{TUser}", "desc": "Test :any:`TUser`"}
assert mapped.parameters[0] == expected
assert (
mapped.returns["description"]
== "Test references :any:`Bar` and paramrefs ``a``"
)

17
tests/test_integration.py
Unescape Escape View File

@ -3,10 +3,9 @@ import json
import os
import sys
import shutil
import unittest
from contextlib import contextmanager
from mock import patch
from unittest.mock import patch
import pytest
import sphinx
@ -34,15 +33,15 @@ def sphinx_build(test_dir, confoverrides=None):
os.chdir("../..")
class LanguageIntegrationTests(unittest.TestCase):
class LanguageIntegrationTests:
def _run_test(self, test_dir, test_file, test_string):
with sphinx_build(test_dir):
with io.open(test_file, encoding="utf8") as fin:
text = fin.read().strip()
self.assertIn(test_string, text)
assert test_string in text
class JavaScriptTests(LanguageIntegrationTests):
class TestJavaScript(LanguageIntegrationTests):
def _js_read(self, path):
return json.load(open("../fixtures/javascript.json"))
@ -59,7 +58,7 @@ class JavaScriptTests(LanguageIntegrationTests):
sphinx.version_info >= (3,),
reason="golangdomain extension does not support sphinx >=3",
)
class GoTests(LanguageIntegrationTests):
class TestGo(LanguageIntegrationTests):
def _go_read(self, path, **kwargs):
return json.load(open("../fixtures/go.json"))
@ -76,7 +75,7 @@ class GoTests(LanguageIntegrationTests):
sphinx.version_info >= (3,),
reason="dotnetdomain extension does not support sphinx >=3",
)
class DotNetTests(LanguageIntegrationTests):
class TestDotNet(LanguageIntegrationTests):
def _dotnet_read(self, path):
return json.load(open("../fixtures/dotnet.json"))
@ -100,7 +99,7 @@ class DotNetTests(LanguageIntegrationTests):
)
class IntegrationTests(LanguageIntegrationTests):
class TestIntegration(LanguageIntegrationTests):
def test_template_overrides(self):
self._run_test(
"templateexample",
@ -109,7 +108,7 @@ class IntegrationTests(LanguageIntegrationTests):
)
class TOCTreeTests(LanguageIntegrationTests):
class TestTOCTree(LanguageIntegrationTests):
def test_toctree_overrides(self):
self._run_test("toctreeexample", "_build/text/index.txt", "API Reference")

111
tests/test_objects.py
Unescape Escape View File

@ -2,10 +2,9 @@
"""Test .NET autoapi objects"""
import os
import unittest
from collections import namedtuple
import mock
from unittest import mock
import os
from jinja2 import Environment, FileSystemLoader
@ -14,84 +13,84 @@ from autoapi.mappers import python
from autoapi.settings import TEMPLATE_DIR
class DotNetObjectTests(unittest.TestCase):
class TestDotNetObject:
def test_type(self):
"""Test types of some of the objects"""
obj = dotnet.DotNetNamespace({"id": "Foo.Bar"}, jinja_env=None, app=None)
self.assertEqual(obj.type, "namespace")
self.assertEqual(obj.ref_type, "namespace")
self.assertEqual(obj.ref_directive, "ns")
assert obj.type == "namespace"
assert obj.ref_type == "namespace"
assert obj.ref_directive == "ns"
obj = dotnet.DotNetMethod({"id": "Foo.Bar"}, jinja_env=None, app=None)
self.assertEqual(obj.type, "method")
self.assertEqual(obj.ref_type, "method")
self.assertEqual(obj.ref_directive, "meth")
assert obj.type == "method"
assert obj.ref_type == "method"
assert obj.ref_directive == "meth"
obj = dotnet.DotNetProperty({"id": "Foo.Bar"}, jinja_env=None, app=None)
self.assertEqual(obj.type, "property")
self.assertEqual(obj.ref_type, "property")
self.assertEqual(obj.ref_directive, "prop")
assert obj.type == "property"
assert obj.ref_type == "property"
assert obj.ref_directive == "prop"
obj = dotnet.DotNetEnum({"id": "Foo.Bar"}, jinja_env=None, app=None)
self.assertEqual(obj.type, "enum")
self.assertEqual(obj.ref_type, "enumeration")
self.assertEqual(obj.ref_directive, "enum")
assert obj.type == "enum"
assert obj.ref_type == "enumeration"
assert obj.ref_directive == "enum"
obj = dotnet.DotNetStruct({"id": "Foo.Bar"}, jinja_env=None, app=None)
self.assertEqual(obj.type, "struct")
self.assertEqual(obj.ref_type, "structure")
self.assertEqual(obj.ref_directive, "struct")
assert obj.type == "struct"
assert obj.ref_type == "structure"
assert obj.ref_directive == "struct"
obj = dotnet.DotNetConstructor({"id": "Foo.Bar"}, jinja_env=None, app=None)
self.assertEqual(obj.type, "constructor")
self.assertEqual(obj.ref_type, "constructor")
self.assertEqual(obj.ref_directive, "ctor")
assert obj.type == "constructor"
assert obj.ref_type == "constructor"
assert obj.ref_directive == "ctor"
obj = dotnet.DotNetInterface({"id": "Foo.Bar"}, jinja_env=None, app=None)
self.assertEqual(obj.type, "interface")
self.assertEqual(obj.ref_type, "interface")
self.assertEqual(obj.ref_directive, "iface")
assert obj.type == "interface"
assert obj.ref_type == "interface"
assert obj.ref_directive == "iface"
obj = dotnet.DotNetDelegate({"id": "Foo.Bar"}, jinja_env=None, app=None)
self.assertEqual(obj.type, "delegate")
self.assertEqual(obj.ref_type, "delegate")
self.assertEqual(obj.ref_directive, "del")
assert obj.type == "delegate"
assert obj.ref_type == "delegate"
assert obj.ref_directive == "del"
obj = dotnet.DotNetClass({"id": "Foo.Bar"}, jinja_env=None, app=None)
self.assertEqual(obj.type, "class")
self.assertEqual(obj.ref_type, "class")
self.assertEqual(obj.ref_directive, "cls")
assert obj.type == "class"
assert obj.ref_type == "class"
assert obj.ref_directive == "cls"
obj = dotnet.DotNetField({"id": "Foo.Bar"}, jinja_env=None, app=None)
self.assertEqual(obj.type, "field")
self.assertEqual(obj.ref_type, "field")
self.assertEqual(obj.ref_directive, "field")
assert obj.type == "field"
assert obj.ref_type == "field"
assert obj.ref_directive == "field"
obj = dotnet.DotNetEvent({"id": "Foo.Bar"}, jinja_env=None, app=None)
self.assertEqual(obj.type, "event")
self.assertEqual(obj.ref_type, "event")
self.assertEqual(obj.ref_directive, "event")
assert obj.type == "event"
assert obj.ref_type == "event"
assert obj.ref_directive == "event"
def test_names(self):
"""Test names of objects"""
obj = dotnet.DotNetNamespace({"id": "Foo.Bar"}, jinja_env=None, app=None)
self.assertEqual(obj.name, "Foo.Bar")
self.assertEqual(obj.short_name, "Bar")
assert obj.name == "Foo.Bar"
assert obj.short_name == "Bar"
obj = dotnet.DotNetNamespace(
{"id": "Foo.Bar.Something`1"}, jinja_env=None, app=None
)
self.assertEqual(obj.name, "Foo.Bar.Something`1")
self.assertEqual(obj.short_name, "Something`1")
assert obj.name == "Foo.Bar.Something`1"
assert obj.short_name == "Something`1"
def test_namespace_namespace(self):
"""Namespace parent resolution"""
ns = dotnet.DotNetNamespace({"id": "Foo.Bar.Widgets"}, jinja_env=None, app=None)
self.assertEqual(ns.namespace, "Foo.Bar")
assert ns.namespace == "Foo.Bar"
ns = dotnet.DotNetNamespace({"id": "Foo.Bar"}, jinja_env=None, app=None)
self.assertEqual(ns.namespace, "Foo")
assert ns.namespace == "Foo"
ns = dotnet.DotNetNamespace({"id": "Foo"}, jinja_env=None, app=None)
self.assertIsNone(ns.namespace)
assert ns.namespace is None
def test_class_namespace(self):
"""Class parent resolution"""
@ -100,32 +99,32 @@ class DotNetObjectTests(unittest.TestCase):
jinja_env=None,
app=None,
)
self.assertEqual(cls.namespace, "Foo.Bar")
assert cls.namespace == "Foo.Bar"
cls = dotnet.DotNetClass(
dict(id="Foo.Bar", type="class"), jinja_env=None, app=None
)
self.assertEqual(cls.namespace, "Foo")
assert cls.namespace == "Foo"
cls = dotnet.DotNetClass(dict(id="Foo", type="class"), jinja_env=None, app=None)
self.assertIsNone(cls.namespace)
assert cls.namespace is None
def test_filename(self):
"""Object file name"""
cls = dotnet.DotNetClass({"id": "Foo.Bar.Widget"}, jinja_env=None, app=None)
self.assertEqual(cls.pathname, os.path.join("Foo", "Bar", "Widget"))
assert cls.pathname == os.path.join("Foo", "Bar", "Widget")
cls = dotnet.DotNetClass({"id": "Foo.Bar.Widget<T>"}, jinja_env=None, app=None)
self.assertEqual(cls.pathname, os.path.join("Foo", "Bar", "Widget-T"))
assert cls.pathname == os.path.join("Foo", "Bar", "Widget-T")
cls = dotnet.DotNetClass(
{"id": "Foo.Bar.Widget<T>(TFoo)"}, jinja_env=None, app=None
)
self.assertEqual(cls.pathname, os.path.join("Foo", "Bar", "Widget-T"))
assert cls.pathname == os.path.join("Foo", "Bar", "Widget-T")
cls = dotnet.DotNetClass(
{"id": "Foo.Foo-Bar.Widget<T>(TFoo)"}, jinja_env=None, app=None
)
self.assertEqual(cls.pathname, os.path.join("Foo", "FooBar", "Widget-T"))
assert cls.pathname == os.path.join("Foo", "FooBar", "Widget-T")
cls = dotnet.DotNetClass({"id": u"Foo.Bär"}, jinja_env=None, app=None)
self.assertEqual(cls.pathname, os.path.join("Foo", "Bar"))
assert cls.pathname == os.path.join("Foo", "Bar")
cls = dotnet.DotNetClass({"id": u"Ащщ.юИфк"}, jinja_env=None, app=None)
self.assertEqual(cls.pathname, os.path.join("Ashchshch", "iuIfk"))
assert cls.pathname == os.path.join("Ashchshch", "iuIfk")
def test_rendered_class_escaping(self):
"""Rendered class escaping"""
@ -135,12 +134,12 @@ class DotNetObjectTests(unittest.TestCase):
jinja_env=jinja_env,
app=mock.MagicMock(),
)
self.assertIn("* :dn:cls:`Foo.Baz\\`1`\n", cls.render())
assert "* :dn:cls:`Foo.Baz\\`1`\n" in cls.render()
def test_include_path(self):
"""Include path"""
cls = dotnet.DotNetClass({"id": "Foo.Bar.Widget"}, jinja_env=None, app=None)
self.assertEqual(cls.include_path, "/autoapi/Foo/Bar/Widget/index")
assert cls.include_path == "/autoapi/Foo/Bar/Widget/index"
cls = dotnet.DotNetClass({"id": "Foo.Bar.Widget"}, jinja_env=None, app=None)
cls.url_root = "/autofoo"
self.assertEqual(cls.include_path, "/autofoo/Foo/Bar/Widget/index")
assert cls.include_path == "/autofoo/Foo/Bar/Widget/index"

1
tox.ini
Unescape Escape View File

@ -21,7 +21,6 @@ extras =
go
deps =
pytest
mock
sphinx30: Sphinx<3.1
sphinx31: Sphinx<3.2
sphinx32: Sphinx<3.3

Write Preview
Loading…
Cancel
Save