diff options
Diffstat (limited to '')
| -rw-r--r-- | tests/test_domain_js.py | 222 |
1 files changed, 222 insertions, 0 deletions
diff --git a/tests/test_domain_js.py b/tests/test_domain_js.py new file mode 100644 index 0000000..465fef3 --- /dev/null +++ b/tests/test_domain_js.py @@ -0,0 +1,222 @@ +"""Tests the JavaScript Domain""" + +from unittest.mock import Mock + +import pytest +from docutils import nodes + +from sphinx import addnodes +from sphinx.addnodes import (desc, desc_annotation, desc_content, desc_name, desc_parameter, + desc_parameterlist, desc_sig_keyword, desc_sig_name, + desc_sig_space, desc_signature) +from sphinx.domains.javascript import JavaScriptDomain +from sphinx.testing import restructuredtext +from sphinx.testing.util import assert_node + + +@pytest.mark.sphinx('dummy', testroot='domain-js') +def test_domain_js_xrefs(app, status, warning): + """Domain objects have correct prefixes when looking up xrefs""" + app.builder.build_all() + + def assert_refnode(node, mod_name, prefix, target, reftype=None, + domain='js'): + attributes = { + 'refdomain': domain, + 'reftarget': target, + } + if reftype is not None: + attributes['reftype'] = reftype + if mod_name is not False: + attributes['js:module'] = mod_name + if prefix is not False: + attributes['js:object'] = prefix + assert_node(node, **attributes) + + doctree = app.env.get_doctree('roles') + refnodes = list(doctree.findall(addnodes.pending_xref)) + assert_refnode(refnodes[0], None, None, 'TopLevel', 'class') + assert_refnode(refnodes[1], None, None, 'top_level', 'func') + assert_refnode(refnodes[2], None, 'NestedParentA', 'child_1', 'func') + assert_refnode(refnodes[3], None, 'NestedParentA', 'NestedChildA.subchild_2', 'func') + assert_refnode(refnodes[4], None, 'NestedParentA', 'child_2', 'func') + assert_refnode(refnodes[5], False, 'NestedParentA', 'any_child', domain='') + assert_refnode(refnodes[6], None, 'NestedParentA', 'NestedChildA', 'class') + assert_refnode(refnodes[7], None, 'NestedParentA.NestedChildA', 'subchild_2', 'func') + assert_refnode(refnodes[8], None, 'NestedParentA.NestedChildA', + 'NestedParentA.child_1', 'func') + assert_refnode(refnodes[9], None, 'NestedParentA', 'NestedChildA.subchild_1', 'func') + assert_refnode(refnodes[10], None, 'NestedParentB', 'child_1', 'func') + assert_refnode(refnodes[11], None, 'NestedParentB', 'NestedParentB', 'class') + assert_refnode(refnodes[12], None, None, 'NestedParentA.NestedChildA', 'class') + assert len(refnodes) == 13 + + doctree = app.env.get_doctree('module') + refnodes = list(doctree.findall(addnodes.pending_xref)) + assert_refnode(refnodes[0], 'module_a.submodule', None, 'ModTopLevel', + 'class') + assert_refnode(refnodes[1], 'module_a.submodule', 'ModTopLevel', + 'mod_child_1', 'meth') + assert_refnode(refnodes[2], 'module_a.submodule', 'ModTopLevel', + 'ModTopLevel.mod_child_1', 'meth') + assert_refnode(refnodes[3], 'module_a.submodule', 'ModTopLevel', + 'mod_child_2', 'meth') + assert_refnode(refnodes[4], 'module_a.submodule', 'ModTopLevel', + 'module_a.submodule.ModTopLevel.mod_child_1', 'meth') + assert_refnode(refnodes[5], 'module_b.submodule', None, 'ModTopLevel', + 'class') + assert_refnode(refnodes[6], 'module_b.submodule', 'ModTopLevel', + 'module_a.submodule', 'mod') + assert len(refnodes) == 7 + + +@pytest.mark.sphinx('dummy', testroot='domain-js') +def test_domain_js_objects(app, status, warning): + app.builder.build_all() + + modules = app.env.domains['js'].data['modules'] + objects = app.env.domains['js'].data['objects'] + + assert 'module_a.submodule' in modules + assert 'module_a.submodule' in objects + assert 'module_b.submodule' in modules + assert 'module_b.submodule' in objects + + assert objects['module_a.submodule.ModTopLevel'][2] == 'class' + assert objects['module_a.submodule.ModTopLevel.mod_child_1'][2] == 'method' + assert objects['module_a.submodule.ModTopLevel.mod_child_2'][2] == 'method' + assert objects['module_b.submodule.ModTopLevel'][2] == 'class' + + assert objects['TopLevel'][2] == 'class' + assert objects['top_level'][2] == 'function' + assert objects['NestedParentA'][2] == 'class' + assert objects['NestedParentA.child_1'][2] == 'function' + assert objects['NestedParentA.any_child'][2] == 'function' + assert objects['NestedParentA.NestedChildA'][2] == 'class' + assert objects['NestedParentA.NestedChildA.subchild_1'][2] == 'function' + assert objects['NestedParentA.NestedChildA.subchild_2'][2] == 'function' + assert objects['NestedParentA.child_2'][2] == 'function' + assert objects['NestedParentB'][2] == 'class' + assert objects['NestedParentB.child_1'][2] == 'function' + + +@pytest.mark.sphinx('dummy', testroot='domain-js') +def test_domain_js_find_obj(app, status, warning): + + def find_obj(mod_name, prefix, obj_name, obj_type, searchmode=0): + return app.env.domains['js'].find_obj( + app.env, mod_name, prefix, obj_name, obj_type, searchmode) + + app.builder.build_all() + + assert (find_obj(None, None, 'NONEXISTANT', 'class') == (None, None)) + assert (find_obj(None, None, 'NestedParentA', 'class') == + ('NestedParentA', ('roles', 'NestedParentA', 'class'))) + assert (find_obj(None, None, 'NestedParentA.NestedChildA', 'class') == + ('NestedParentA.NestedChildA', + ('roles', 'NestedParentA.NestedChildA', 'class'))) + assert (find_obj(None, 'NestedParentA', 'NestedChildA', 'class') == + ('NestedParentA.NestedChildA', + ('roles', 'NestedParentA.NestedChildA', 'class'))) + assert (find_obj(None, None, 'NestedParentA.NestedChildA.subchild_1', 'func') == + ('NestedParentA.NestedChildA.subchild_1', + ('roles', 'NestedParentA.NestedChildA.subchild_1', 'function'))) + assert (find_obj(None, 'NestedParentA', 'NestedChildA.subchild_1', 'func') == + ('NestedParentA.NestedChildA.subchild_1', + ('roles', 'NestedParentA.NestedChildA.subchild_1', 'function'))) + assert (find_obj(None, 'NestedParentA.NestedChildA', 'subchild_1', 'func') == + ('NestedParentA.NestedChildA.subchild_1', + ('roles', 'NestedParentA.NestedChildA.subchild_1', 'function'))) + assert (find_obj('module_a.submodule', 'ModTopLevel', 'mod_child_2', 'meth') == + ('module_a.submodule.ModTopLevel.mod_child_2', + ('module', 'module_a.submodule.ModTopLevel.mod_child_2', 'method'))) + assert (find_obj('module_b.submodule', 'ModTopLevel', 'module_a.submodule', 'mod') == + ('module_a.submodule', + ('module', 'module-module_a.submodule', 'module'))) + + +def test_get_full_qualified_name(): + env = Mock(domaindata={}) + domain = JavaScriptDomain(env) + + # non-js references + node = nodes.reference() + assert domain.get_full_qualified_name(node) is None + + # simple reference + node = nodes.reference(reftarget='func') + assert domain.get_full_qualified_name(node) == 'func' + + # with js:module context + kwargs = {'js:module': 'module1'} + node = nodes.reference(reftarget='func', **kwargs) + assert domain.get_full_qualified_name(node) == 'module1.func' + + # with js:object context + kwargs = {'js:object': 'Class'} + node = nodes.reference(reftarget='func', **kwargs) + assert domain.get_full_qualified_name(node) == 'Class.func' + + # with both js:module and js:object context + kwargs = {'js:module': 'module1', 'js:object': 'Class'} + node = nodes.reference(reftarget='func', **kwargs) + assert domain.get_full_qualified_name(node) == 'module1.Class.func' + + +def test_js_module(app): + text = ".. js:module:: sphinx" + doctree = restructuredtext.parse(app, text) + assert_node(doctree, (nodes.target, + addnodes.index)) + assert_node(doctree[0], nodes.target, ids=["module-sphinx"]) + assert_node(doctree[1], addnodes.index, + entries=[("single", "sphinx (module)", "module-sphinx", "", None)]) + + +def test_js_function(app): + text = ".. js:function:: sum(a, b)" + doctree = restructuredtext.parse(app, text) + assert_node(doctree, (addnodes.index, + [desc, ([desc_signature, ([desc_name, ([desc_sig_name, "sum"])], + desc_parameterlist)], + [desc_content, ()])])) + assert_node(doctree[1][0][1], [desc_parameterlist, ([desc_parameter, ([desc_sig_name, "a"])], + [desc_parameter, ([desc_sig_name, "b"])])]) + assert_node(doctree[0], addnodes.index, + entries=[("single", "sum() (built-in function)", "sum", "", None)]) + assert_node(doctree[1], addnodes.desc, domain="js", objtype="function", noindex=False) + + +def test_js_class(app): + text = ".. js:class:: Application" + doctree = restructuredtext.parse(app, text) + assert_node(doctree, (addnodes.index, + [desc, ([desc_signature, ([desc_annotation, ([desc_sig_keyword, 'class'], + desc_sig_space)], + [desc_name, ([desc_sig_name, "Application"])], + [desc_parameterlist, ()])], + [desc_content, ()])])) + assert_node(doctree[0], addnodes.index, + entries=[("single", "Application() (class)", "Application", "", None)]) + assert_node(doctree[1], addnodes.desc, domain="js", objtype="class", noindex=False) + + +def test_js_data(app): + text = ".. js:data:: name" + doctree = restructuredtext.parse(app, text) + assert_node(doctree, (addnodes.index, + [desc, ([desc_signature, ([desc_name, ([desc_sig_name, "name"])])], + [desc_content, ()])])) + assert_node(doctree[0], addnodes.index, + entries=[("single", "name (global variable or constant)", "name", "", None)]) + assert_node(doctree[1], addnodes.desc, domain="js", objtype="data", noindex=False) + + +def test_noindexentry(app): + text = (".. js:function:: f()\n" + ".. js:function:: g()\n" + " :noindexentry:\n") + doctree = restructuredtext.parse(app, text) + assert_node(doctree, (addnodes.index, desc, addnodes.index, desc)) + assert_node(doctree[0], addnodes.index, entries=[('single', 'f() (built-in function)', 'f', '', None)]) + assert_node(doctree[2], addnodes.index, entries=[]) |