Move MyThing to example_things submodule

I've improved test coverage by adding explicit tests
of MyThing.

Author: rwb27

src/labthings_fastapi/example_things/__init__.py

@@ -67,10 +67,10 @@ def increment_counter(self):
         self.counter += 1
 
     @thing_action
-    def slowly_increase_counter(self):
+    def slowly_increase_counter(self, increments=60, delay=1):
         """Increment the counter slowly over a minute"""
-        for i in range(60):
-            time.sleep(1)
+        for i in range(increments):
+            time.sleep(delay)
             self.increment_counter()
 
     counter = PropertyDescriptor(
@@ -83,6 +83,16 @@ def slowly_increase_counter(self):
         description="A pointless string for demo purposes.",
     )
 
+    @thing_action
+    def action_without_arguments(self) -> None:
+        """An action that takes no arguments"""
+        pass
+
+    @thing_action
+    def action_with_only_kwargs(self, **kwargs) -> None:
+        """An action that takes **kwargs"""
+        pass
+
 
 class ThingWithBrokenAffordances(Thing):
     """A Thing that raises exceptions in actions/properites"""

tests/test_actions.py

@@ -2,97 +2,10 @@
 import pytest
 from labthings_fastapi.server import ThingServer
 from temp_client import poll_task, get_link
-import time
-from typing import Optional, Annotated
-from labthings_fastapi.thing import Thing
 from labthings_fastapi.decorators import thing_action
-from labthings_fastapi.descriptors import PropertyDescriptor
-from pydantic import Field
-
-
-class TestThing(Thing):
-    @thing_action
-    def anaction(
-        self,
-        repeats: Annotated[
-            int, Field(description="The number of times to try the action")
-        ],  # no default = required parameter
-        undocumented: int,
-        title: Annotated[
-            str, Field(description="the title of the invocation")
-        ] = "Untitled",
-        attempts: Annotated[
-            Optional[list[str]],
-            Field(
-                description="Names for each attempt - I suggest final, Final, FINAL."
-            ),
-        ] = None,
-    ) -> dict[str, str]:
-        """Quite a complicated action
-
-        This action has lots of parameters and is designed to confuse my schema
-        generator. I hope it doesn't!
-
-        I might even use some Markdown here:
-
-        * If this renders, it supports lists
-        * With at east two items.
-        """
-        # We should be able to call actions as normal Python functions
-        self.increment_counter()
-        return {"end_result": "finished!!"}
-
-    @thing_action
-    def make_a_dict(
-        self,
-        extra_key: Optional[str] = None,
-        extra_value: Optional[str] = None,
-    ) -> dict[str, str]:
-        """An action that returns a dict"""
-        out = {"key": "value"}
-        if extra_key is not None:
-            out[extra_key] = extra_value
-        return out
-
-    @thing_action
-    def increment_counter(self):
-        """Increment the counter property
-
-        This action doesn't do very much - all it does, in fact,
-        is increment the counter (which may be read using the
-        `counter` property).
-        """
-        self.counter += 1
-
-    @thing_action
-    def slowly_increase_counter(self):
-        """Increment the counter slowly over a minute"""
-        for i in range(60):
-            time.sleep(1)
-            self.increment_counter()
-
-    counter = PropertyDescriptor(
-        model=int, initial_value=0, readonly=True, description="A pointless counter"
-    )
-
-    foo = PropertyDescriptor(
-        model=str,
-        initial_value="Example",
-        description="A pointless string for demo purposes.",
-    )
-
-    @thing_action
-    def action_without_arguments(self) -> None:
-        """An action that takes no arguments"""
-        pass
-
-    @thing_action
-    def action_with_only_kwargs(self, **kwargs) -> None:
-        """An action that takes **kwargs"""
-        pass
-
-
-thing = TestThing()
+from labthings_fastapi.example_things import MyThing
+
+thing = MyThing()
 server = ThingServer()
 server.add_thing(thing, "/thing")
 

tests/test_example_thing.py

@@ -0,0 +1,60 @@
+from labthings_fastapi.example_things import (
+    MyThing,
+    ThingWithBrokenAffordances,
+    ThingThatCantInstantiate,
+    ThingThatCantStart,
+)
+import pytest
+
+
+class DummyBlockingPortal:
+    """A dummy blocking portal for testing
+    
+    This is a blocking portal that doesn't actually do anything.
+    In the future, we should improve LabThings so this is not required.
+    """
+    def start_task_soon(self, func, *args, **kwargs):
+        pass
+
+
+def test_mything():
+    thing = MyThing()
+    thing._labthings_blocking_portal = DummyBlockingPortal()
+    assert isinstance(thing, MyThing)
+    assert thing.counter == 0
+    ret = thing.anaction(3, 1, title="MyTitle", attempts=["a", "b", "c"])
+    assert ret == {"end_result": "finished!!"}
+    ret = thing.make_a_dict("key2", "value2")
+    assert ret == {"key": "value", "key2": "value2"}
+    before = thing.counter
+    thing.increment_counter()
+    assert thing.counter == before + 1
+    thing.slowly_increase_counter(3, 0)
+    assert thing.counter == before + 4
+    assert thing.foo == "Example"
+    thing.foo = "New Value"
+    assert thing.foo == "New Value"
+    thing.action_without_arguments()
+    thing.action_with_only_kwargs(foo="bar")
+
+
+def test_thing_with_broken_affordances():
+    thing = ThingWithBrokenAffordances()
+    assert isinstance(thing, ThingWithBrokenAffordances)
+    with pytest.raises(RuntimeError):
+        thing.broken_action()
+    with pytest.raises(RuntimeError):
+        thing.broken_property()
+
+
+def test_thing_that_cant_instantiate():
+    with pytest.raises(Exception):
+        ThingThatCantInstantiate()
+
+
+def test_thing_that_cant_start():
+    thing = ThingThatCantStart()
+    assert isinstance(thing, ThingThatCantStart)
+    with pytest.raises(Exception):
+        with thing:
+            pass

tests/test_websocket.py

@@ -1,6 +1,6 @@
 from fastapi.testclient import TestClient
 from labthings_fastapi.server import ThingServer
-from test_thing import MyThing
+from labthings_fastapi.example_things import MyThing
 
 my_thing = MyThing()
 server = ThingServer()