Push coverage to 100%

Author: ghickman

pyproject.toml

@@ -55,7 +55,7 @@ dev = [
 show_contexts = true
 
 [tool.coverage.report]
-# fail_under = 100
+fail_under = 100
 show_missing = true
 skip_covered = true
 
@@ -64,6 +64,7 @@ branch = true
 relative_files = true
 dynamic_context = "test_function"
 omit = [
+  "src/classify/__main__.py",
   "src/classify/contrib/*",
   "tests/dummy_class.py",
 ]

src/classify/exceptions.py

@@ -0,0 +1,2 @@
+class NotAClassError(Exception):
+    pass

src/classify/library.py

@@ -1,13 +1,14 @@
 import builtins
 import collections
 import inspect
-import os
 import pydoc
 import sys
 from collections.abc import Generator
 
 from attrs import Factory, frozen
 
+from .exceptions import NotAClassError
+
 
 @frozen
 class Attribute:
@@ -64,12 +65,7 @@ def get_members(obj):
     ]
 
 
-def classify(obj: object, name=None) -> Class:
-    if not inspect.isclass(obj):
-        prefix = name if name else "Input"
-        msg = f"{prefix} doesn't look like a class, please specify the path to a class"
-        raise TypeError(msg)
-
+def classify(obj: object) -> Class:
     # flatten the MRO of the given class and flip the order so it's the first
     # non-object class first
     mro = [cls for cls in reversed(inspect.getmro(obj)) if cls is not builtins.object]
@@ -139,10 +135,12 @@ def build_methods(methods) -> Generator[Method, None, None]:
 
 def build(thing) -> Class:
     """Build a dictionary mapping of a class."""
-    if "django" in thing:
-        os.environ["DJANGO_SETTINGS_MODULE"] = "classify.contrib.django.settings"
-
     sys.path.insert(0, "")
 
-    obj, name = pydoc.resolve(thing)  # ty: ignore[not-iterable]
-    return classify(obj, name)
+    obj, _ = pydoc.resolve(thing)  # ty: ignore[not-iterable]
+    # TODO: what is name here??
+
+    if not inspect.isclass(obj):
+        raise NotAClassError
+
+    return classify(obj)

src/classify/main.py

@@ -7,6 +7,7 @@
 from rich.syntax import DEFAULT_THEME
 
 from . import renderers
+from .exceptions import NotAClassError
 from .library import build
 from .renderers import Renderer
 
@@ -38,25 +39,29 @@
 def run(
     klass, console_theme, django_settings, renderer: Renderer, output_path, port, serve
 ) -> None:
-    if django_settings:
-        os.environ["DJANGO_SETTINGS_MODULE"] = django_settings
+    os.environ["DJANGO_SETTINGS_MODULE"] = django_settings
 
     try:
         structure = build(klass)
     except (ImportError, pydoc.ErrorDuringImport):
-        sys.stderr.write(f"Could not import: {sys.argv[1]}\n")
+        sys.stderr.write(f"Could not import: {klass}\n")
+        sys.exit(1)
+    except NotAClassError:
+        sys.stderr.write(
+            f"{klass} doesn't look like a class, please specify the path to a class\n"
+        )
         sys.exit(1)
 
     match renderer:
         case Renderer.CONSOLE:
             renderers.to_console(structure, console_theme)
         case Renderer.HTML:
             renderers.to_html(structure, output_path, serve, port)
-        case Renderer.PAGER:
+        case Renderer.PAGER:  # pragma: no branch
+            # unclear why coverage thinks run() doesn't return, so marking as
+            # no branch for now
             renderers.to_pager(structure, console_theme)
 
-    sys.exit(0)
-
 
-if __name__ == "__main__":
+if __name__ == "__main__":  # pragma: no cover
     run()

src/classify/renderers/string.py

@@ -31,13 +31,9 @@ def methods(methods):
                 content += "\n"
         return content
 
-    def parents(parents):
-        return ", ".join([p.__name__ for p in parents])
-
     content = declaration(structure.name, structure.parents)
     content += "\n"
-    if docstring:
-        content += docstring(structure.docstring)
+    content += docstring(structure.docstring) if docstring else ""
     content += attributes(structure.attributes)
     content += "\n"
     content += methods(structure.methods)

tests/dummy_class.py

@@ -7,6 +7,10 @@ def three(self):
 
 
 class DummyClass(DummyParent):
+    """The main testing class"""
+
+    some_attribute = 7
+
     def __init__(self):
         super().__init__()
 

tests/test_library.py

@@ -9,7 +9,7 @@
     ("cls", "expected"),
     [
         (DummyParent, ["__dict__", "__weakref__", "one", "three"]),
-        (DummyClass, ["__init__", "one", "two"]),
+        (DummyClass, ["__init__", "one", "some_attribute", "two"]),
     ],
     ids=["parent", "child"],
 )

tests/test_main.py

@@ -0,0 +1,86 @@
+from pathlib import Path
+
+import pytest
+from click.testing import CliRunner
+
+from classify.main import run
+
+
+@pytest.mark.parametrize(
+    "invocation",
+    [
+        ["tests.dummy_class.DummyClass"],
+        ["tests.dummy_class.DummyClass", "--renderer", "console"],
+    ],
+    ids=["default-renderer", "console-renderer"],
+)
+def test_run(invocation):
+    runner = CliRunner()
+
+    result = runner.invoke(run, invocation)
+
+    assert result.exit_code == 0
+    assert "DummyClass" in result.output
+
+
+def test_run_with_html_renderer():
+    runner = CliRunner()
+
+    result = runner.invoke(
+        run,
+        ["tests.dummy_class.DummyClass", "--renderer", "html"],
+    )
+
+    assert result.exit_code == 0
+    assert result.output.startswith("Wrote:")
+
+
+def test_run_with_html_renderer_and_output_set():
+    runner = CliRunner()
+
+    result = runner.invoke(
+        run,
+        [
+            "tests.dummy_class.DummyClass",
+            "--renderer",
+            "html",
+            "--output",
+            "output",
+        ],
+    )
+
+    assert result.exit_code == 0
+    assert result.output == "Wrote: output/classify.html\n"
+
+    output = Path("output/classify.html").read_text()
+    assert "DummyClass" in output
+
+
+def test_run_with_pager_renderer():
+    runner = CliRunner()
+
+    result = runner.invoke(run, ["tests.dummy_class.DummyClass", "--renderer", "pager"])
+
+    assert result.exit_code == 0
+    assert "DummyClass" in result.output
+
+
+def test_run_with_unknown_path():
+    runner = CliRunner()
+
+    result = runner.invoke(run, ["unknown"])
+
+    assert result.exit_code == 1
+    assert result.output == "Could not import: unknown\n"
+
+
+def test_run_without_a_class():
+    runner = CliRunner()
+
+    result = runner.invoke(run, ["tests.dummy_class"])
+
+    assert result.exit_code == 1
+    assert (
+        result.output
+        == "tests.dummy_class doesn't look like a class, please specify the path to a class\n"
+    )