Add tests for config_handler, json_type_handlers

Author: dwhswenson

paths_cli/tests/compiling/_gendocs/test_config_handler.py

@@ -0,0 +1,40 @@
+import pytest
+from unittest import mock
+
+from paths_cli.compiling._gendocs.config_handler import *
+
+GOOD_DATA = {'engine': {'header': "Engines", 'description': "desc"}}
+
+MODULE_LOC = "paths_cli.compiling._gendocs.config_handler."
+
+
+def test_load_config():
+    # load_config should create the correct DocCategoryInfo objects
+    mock_open = mock.mock_open(read_data="unused")
+    mock_loader = mock.Mock(return_value=mock.Mock(return_value=GOOD_DATA))
+    with mock.patch(MODULE_LOC + "open", mock_open) as m_open, \
+            mock.patch(MODULE_LOC + "select_loader", mock_loader) as m_load:
+        config = load_config("foo.yml")
+    assert 'engine' in config
+    data = config['engine']
+    assert isinstance(data, DocCategoryInfo)
+    assert data.header == "Engines"
+    assert data.description == "desc"
+
+
+def test_load_config_file_error():
+    # if the filename is bad, we should get a FileNotFoundError
+    with pytest.raises(FileNotFoundError):
+        load_config("foo.yml")
+
+
+def test_load_config_data_error():
+    # if the data can't be mapped to a DocCategoryInfo class, we should get
+    # a TypeError
+    BAD_DATA = {'engine': {'foo': 'bar'}}
+    mock_open = mock.mock_open(read_data="unused")
+    mock_loader = mock.Mock(return_value=mock.Mock(return_value=BAD_DATA))
+    with mock.patch(MODULE_LOC + "open", mock_open) as m_open, \
+            mock.patch(MODULE_LOC + "select_loader", mock_loader) as m_load:
+        with pytest.raises(TypeError, match='unexpected keyword'):
+            load_config("foo.yml")

paths_cli/tests/compiling/_gendocs/test_json_type_handlers.py

@@ -0,0 +1,50 @@
+import pytest
+
+from paths_cli.compiling._gendocs.json_type_handlers import *
+
+
+@pytest.mark.parametrize('json_type', ['object', 'foo'])
+def test_handle_object(json_type):
+    # object should convert to dict; anything else should be is-identical
+    if json_type == "foo":
+        json_type = {'foo': 'bar'}  # make the `is` test meaningful
+    result = handle_object(json_type)
+    if json_type == 'object':
+        assert result == 'dict'
+    else:
+        assert result is json_type
+
+
+def test_handle_listof():
+    json_type = {'type': "array", "items": "float"}
+    assert handle_listof(json_type) == "list of float"
+
+
+def test_category_handler():
+    json_type = {"$ref": "#/definitions/engine_type"}
+    handler = CategoryHandler('engine')
+    assert handler(json_type) == ":ref:`engine <compiling--engine>`"
+
+
+def test_eval_handler():
+    json_type = {"$ref": "#/definitions/EvalInt"}
+    handler = EvalHandler("EvalInt", link_to="EvalInt")
+    assert handler(json_type) == ":ref:`EvalInt <EvalInt>`"
+
+
+@pytest.mark.parametrize('json_type', ['string', 'float', 'list-float',
+                                       'engine', 'list-engine'])
+def test_json_type_to_string(json_type):
+    # integration tests for json_type_to_string
+    inputs, expected = {
+        'string': ("string", "string"),
+        'float': ("float", "float"),
+        'list-float': ({'type': 'array', 'items': 'float'},
+                       "list of float"),
+        'engine': ({"$ref": "#/definitions/engine_type"},
+                   ":ref:`engine <compiling--engine>`"),
+        'list-engine': ({"type": "array",
+                         "items": {"$ref": "#/definitions/engine_type"}},
+                        "list of :ref:`engine <compiling--engine>`"),
+    }[json_type]
+    assert json_type_to_string(inputs) == expected