Test things

Author: tpoliaw

src/blueapi/cli/cli.py

@@ -39,6 +39,7 @@
 from blueapi.service.model import DeviceResponse, PlanResponse, SourceInfo, TaskRequest
 from blueapi.worker import ProgressEvent, WorkerEvent
 
+from . import stubgen
 from .scratch import setup_scratch
 from .updates import CliEventRenderer
 
@@ -167,7 +168,6 @@ def generate_stubs(obj: dict, target: Path):
 
     config: ApplicationConfig = obj["config"]
     bc = BlueapiClient.from_config(config)
-    from . import stubgen
 
     stubgen.generate_stubs(Path(target), list(bc.plans), list(bc.devices))
 

src/blueapi/client/cache.py

@@ -22,10 +22,7 @@ class PlanCache:
     """
 
     def __init__(self, runner: PlanRunner, plans: list[PlanModel]):
-        self._cache = {
-            model.name: Plan(name=model.name, model=model, runner=runner)
-            for model in plans
-        }
+        self._cache = {model.name: Plan(model=model, runner=runner) for model in plans}
         for name, plan in self._cache.items():
             if name.startswith("_"):
                 continue
@@ -56,12 +53,12 @@ class Plan:
 
         blueapi generate-stubs /tmp/blueapi-stubs
         uv add --editable /tmp/blueapi-stubs
+
     """
 
     model: PlanModel
 
-    def __init__(self, name, model: PlanModel, runner: PlanRunner):
-        self.name = name
+    def __init__(self, model: PlanModel, runner: PlanRunner):
         self.model = model
         self._runner = runner
         self.__doc__ = model.description
@@ -72,6 +69,10 @@ def __call__(self, *args, **kwargs) -> WorkerEvent:
         """
         return self._runner(self.name, self._build_args(*args, **kwargs))
 
+    @property
+    def name(self) -> str:
+        return self.model.name
+
     @property
     def help_text(self) -> str:
         return self.model.description or f"Plan {self!r}"

src/blueapi/stubs/templates/cache_template.pyi.jinja

@@ -30,16 +30,18 @@ class PlanCache:
         {{ item.docs | docstring | indent(8) }}
         """
         ...
-{% endfor -%}
+{%- endfor %}
 ### End
 
 
 class Plan:
     model: PlanModel
-    name: str
-    def __init__(self, name, model: PlanModel, runner: PlanRunner) -> None: ...
+    def __init__(self, model: PlanModel, runner: PlanRunner) -> None: ...
     def __call__(self, *args, **kwargs):  # -> None:
         ...
+
+    @property
+    def name(self) -> str: ...
     @property
     def help_text(self) -> str: ...
     @property

tests/unit_tests/cli/test_stubgen.py

@@ -1,8 +1,18 @@
+from io import StringIO
+from textwrap import dedent
 from types import FunctionType
+from unittest.mock import Mock
 
 import pytest
 
-from blueapi.cli.stubgen import _docstring, _type_string
+from blueapi.cli.stubgen import (
+    _docstring,
+    _type_string,
+    generate_stubs,
+    render_stub_file,
+)
+from blueapi.client.cache import DeviceRef, Plan
+from blueapi.service.model import DeviceModel, PlanModel
 
 
 def single_line():
@@ -76,3 +86,129 @@ def test_docstring_filter(input: FunctionType, expected: str):
 )
 def test_type_string(typ: dict, expected: str):
     assert _type_string(typ) == expected
+
+
+def test_render_empty():
+    output = StringIO()
+
+    render_stub_file(output, [], [])
+    plan_text, device_text = _extract_rendered(output)
+
+    assert plan_text == ""
+    assert device_text == ""
+
+
+FOO = PlanModel(name="empty", description="Doc string for empty", schema={})
+
+BAR = PlanModel(
+    name="two_args",
+    description="Doc string for two_args",
+    schema={
+        "properties": {
+            "one": {"type": "integer"},
+            "two": {"type": "string"},
+        },
+        "required": ["one"],
+    },
+)
+
+
+def test_render_empty_plan_function():
+    output = StringIO()
+    plans = [Plan(model=FOO, runner=Mock())]
+    render_stub_file(output, plans, [])
+    plan_text, device_text = _extract_rendered(output)
+
+    assert device_text == ""
+
+    assert (
+        plan_text
+        == """\
+    def empty(self,
+    ) -> WorkerEvent:
+        \"""
+        Doc string for empty
+        \"""
+        ...\n"""
+    )
+
+
+def test_render_multiple_plan_functions():
+    output = StringIO()
+    runner = Mock()
+    plans = [Plan(FOO, runner), Plan(BAR, runner)]
+    render_stub_file(output, plans, [])
+    plan_text, device_text = _extract_rendered(output)
+    assert device_text == ""
+
+    assert (
+        plan_text
+        == """\
+    def empty(self,
+    ) -> WorkerEvent:
+        \"""
+        Doc string for empty
+        \"""
+        ...
+    def two_args(self,
+            one: int,
+            two: str | None = None,
+    ) -> WorkerEvent:
+        \"""
+        Doc string for two_args
+        \"""
+        ...\n"""
+    )
+
+
+def test_device_fields():
+    output = StringIO()
+    cache = Mock()
+    devices = [
+        DeviceRef("one", cache, DeviceModel(name="one", protocols=[])),
+        DeviceRef("two", cache, DeviceModel(name="two", protocols=[])),
+    ]
+    render_stub_file(output, [], devices)
+
+    plan_text, device_text = _extract_rendered(output)
+    assert plan_text == ""
+    assert device_text == "    one: DeviceRef\n    two: DeviceRef\n"
+
+
+def test_package_creation(tmp_path):
+    generate_stubs(tmp_path / "blueapi-stubs", [], [])
+    with open(tmp_path / "blueapi-stubs" / "pyproject.toml") as pyproj:
+        assert pyproj.read().startswith(
+            dedent("""
+            [project]
+            name = "blueapi-stubs"
+            version = "0.1.0"
+            """)
+        )
+    with open(
+        tmp_path / "blueapi-stubs" / "src" / "blueapi-stubs" / "py.typed"
+    ) as typed:
+        assert typed.read() == "partial\n"
+
+    assert (
+        tmp_path / "blueapi-stubs" / "src" / "blueapi-stubs" / "client" / "cache.pyi"
+    ).exists()
+
+
+def _extract_rendered(src: StringIO) -> tuple[str, str]:
+    src.seek(0)
+    _read_until_line(src, "### Generated plans")
+    plan_text = _read_until_line(src, "### End")
+    _read_until_line(src, "### Generated devices")
+    device_text = _read_until_line(src, "### End")
+    return plan_text, device_text
+
+
+def _read_until_line(src: StringIO, match: str) -> str:
+    text = ""
+    for line in src:
+        if line.startswith(match):
+            break
+        text += line
+
+    return text

tests/unit_tests/client/test_client.py

@@ -689,13 +689,12 @@ def test_device_ignores_underscores():
 
 
 def test_plan_help_text():
-    plan = Plan("foo", PlanModel(name="foo", description="help for foo"), Mock())
+    plan = Plan(PlanModel(name="foo", description="help for foo"), Mock())
     assert plan.help_text == "help for foo"
 
 
 def test_plan_fallback_help_text():
     plan = Plan(
-        "foo",
         PlanModel(
             name="foo",
             schema={"properties": {"one": {}, "two": {}}, "required": ["one"]},
@@ -707,7 +706,6 @@ def test_plan_fallback_help_text():
 
 def test_plan_properties():
     plan = Plan(
-        "foo",
         PlanModel(
             name="foo",
             schema={"properties": {"one": {}, "two": {}}, "required": ["one"]},
@@ -721,7 +719,7 @@ def test_plan_properties():
 
 def test_plan_empty_fallback_help_text():
     plan = Plan(
-        "foo", PlanModel(name="foo", schema={"properties": {}, "required": []}), Mock()
+        PlanModel(name="foo", schema={"properties": {}, "required": []}), Mock()
     )
     assert plan.help_text == "Plan foo()"
 
@@ -741,7 +739,7 @@ def test_plan_empty_fallback_help_text():
 )
 def test_plan_param_mapping(args, kwargs, params):
     runner = Mock()
-    plan = Plan(FULL_PLAN.name, FULL_PLAN, runner)
+    plan = Plan(FULL_PLAN, runner)
 
     plan(*args, **kwargs)
     runner.assert_called_once_with("foobar", params)
@@ -765,7 +763,6 @@ def test_plan_param_mapping(args, kwargs, params):
 def test_plan_invalid_param_mapping(args, kwargs, msg):
     runner = Mock(spec=Callable)
     plan = Plan(
-        FULL_PLAN.name,
         FULL_PLAN,
         runner,
     )

tests/unit_tests/test_cli.py

@@ -1329,3 +1329,17 @@ def test_config_schema(
             stream.write.assert_called()
     else:
         assert json.loads(result.output) == expected
+    pass
+
+
+@patch("blueapi.client.client.BlueapiClient.from_config")
+@patch("blueapi.cli.cli.stubgen")
+def test_genstubs(
+    stubgen,
+    client,
+    runner: CliRunner,
+):
+    runner.invoke(main, ["generate-stubs", "/path/to/stub_dir"])
+    stubgen.generate_stubs.assert_called_once_with(
+        Path("/path/to/stub_dir"), list(client().plans), list(client().devices)
+    )