test: Extend the type checking of the ops-scenario tests

testing/tests/helpers.py

@@ -7,7 +7,7 @@
 import logging
 from collections.abc import Callable
 from pathlib import Path
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, cast
 
 import jsonpatch  # type: ignore
 from scenario.context import _DEFAULT_JUJU_VERSION, Context
@@ -75,5 +75,12 @@ def jsonpatch_delta(self: State, other: State) -> list[dict[str, Any]]:
         dict_self[attr] = [dataclasses.asdict(o) for o in dict_self[attr]]
     # The jsonpatch library is untyped.
     # See: https://github.com/stefankoegl/python-json-patch/issues/158
-    patch = jsonpatch.make_patch(dict_other, dict_self).patch  # type: ignore
-    return sorted(patch, key=lambda obj: obj['path'] + obj['op'])  # type: ignore
+    patch = cast('list[dict[str, Any]]', jsonpatch.make_patch(dict_other, dict_self).patch)  # type: ignore
+    return sort_patch(patch)
+
+
+def sort_patch(
+    patch: list[dict[str, Any]],
+    key: Callable[[dict[str, Any]], str] = lambda obj: obj['path'] + obj['op'],
+) -> list[dict[str, Any]]:
+    return sorted(patch, key=key)

testing/tests/test_e2e/test_actions.py

@@ -3,17 +3,20 @@
 
 from __future__ import annotations
 
+from typing import Any
+
 import pytest
 from scenario import Context
 from scenario.state import State, _Action, _next_action_id
 
 from ops._private.harness import ActionFailed
 from ops.charm import ActionEvent, CharmBase
 from ops.framework import Framework
+from ops.version import version as ops_version
 
 
 @pytest.fixture(scope='function')
-def mycharm():
+def mycharm() -> type[CharmBase]:
     class MyCharm(CharmBase):
         _evt_handler = None
 
@@ -22,16 +25,16 @@ def __init__(self, framework: Framework):
             for evt in self.on.events().values():
                 self.framework.observe(evt, self._on_event)
 
-        def _on_event(self, event):
+        def _on_event(self, event: ActionEvent):
             if handler := self._evt_handler:
                 handler(event)
 
     return MyCharm
 
 
 @pytest.mark.parametrize('baz_value', (True, False))
-def test_action_event(mycharm, baz_value):
-    ctx = Context(
+def test_action_event(mycharm: type[CharmBase], baz_value: bool):
+    ctx: Context[CharmBase] = Context(
         mycharm,
         meta={'name': 'foo'},
         actions={'foo': {'params': {'bar': {'type': 'number'}, 'baz': {'type': 'boolean'}}}},
@@ -47,11 +50,11 @@ def test_action_event(mycharm, baz_value):
 
 def test_action_no_results():
     class MyCharm(CharmBase):
-        def __init__(self, framework):
+        def __init__(self, framework: Framework):
             super().__init__(framework)
             framework.observe(self.on.act_action, self._on_act_action)
 
-        def _on_act_action(self, _):
+        def _on_act_action(self, _: ActionEvent):
             pass
 
     ctx = Context(MyCharm, meta={'name': 'foo'}, actions={'act': {}})
@@ -61,27 +64,27 @@ def _on_act_action(self, _):
 
 
 @pytest.mark.parametrize('res_value', ('one', 1, [2], ['bar'], (1,), {1, 2}))
-def test_action_event_results_invalid(mycharm, res_value):
+def test_action_event_results_invalid(mycharm: type[CharmBase], res_value: object):
     def handle_evt(charm: CharmBase, evt: ActionEvent):
         with pytest.raises((TypeError, AttributeError)):
-            evt.set_results(res_value)
+            evt.set_results(res_value)  # type: ignore
 
-    mycharm._evt_handler = handle_evt
+    mycharm._evt_handler = handle_evt  # type: ignore
 
     ctx = Context(mycharm, meta={'name': 'foo'}, actions={'foo': {}})
     ctx.run(ctx.on.action('foo'), State())
 
 
 @pytest.mark.parametrize('res_value', ({'a': {'b': {'c'}}}, {'d': 'e'}))
-def test_action_event_results_valid(mycharm, res_value):
-    def handle_evt(_: CharmBase, evt):
+def test_action_event_results_valid(mycharm: type[CharmBase], res_value: dict[str, Any]):
+    def handle_evt(_: CharmBase, evt: ActionEvent):
         if not isinstance(evt, ActionEvent):
             return
         evt.set_results(res_value)
         evt.log('foo')
         evt.log('bar')
 
-    mycharm._evt_handler = handle_evt
+    mycharm._evt_handler = handle_evt  # type: ignore
 
     ctx = Context(mycharm, meta={'name': 'foo'}, actions={'foo': {}})
 
@@ -91,7 +94,7 @@ def handle_evt(_: CharmBase, evt):
 
 
 @pytest.mark.parametrize('res_value', ({'a': {'b': {'c'}}}, {'d': 'e'}))
-def test_action_event_outputs(mycharm, res_value):
+def test_action_event_outputs(mycharm: type[CharmBase], res_value: dict[str, Any]):
     def handle_evt(_: CharmBase, evt: ActionEvent):
         if not isinstance(evt, ActionEvent):
             return
@@ -101,7 +104,7 @@ def handle_evt(_: CharmBase, evt: ActionEvent):
         evt.log('log2')
         evt.fail('failed becozz')
 
-    mycharm._evt_handler = handle_evt
+    mycharm._evt_handler = handle_evt  # type: ignore
 
     ctx = Context(mycharm, meta={'name': 'foo'}, actions={'foo': {}})
     with pytest.raises(ActionFailed) as exc_info:
@@ -111,27 +114,27 @@ def handle_evt(_: CharmBase, evt: ActionEvent):
     assert ctx.action_logs == ['log1', 'log2']
 
 
-def test_action_event_fail(mycharm):
+def test_action_event_fail(mycharm: type[CharmBase]):
     def handle_evt(_: CharmBase, evt: ActionEvent):
         if not isinstance(evt, ActionEvent):
             return
         evt.fail('action failed!')
 
-    mycharm._evt_handler = handle_evt
+    mycharm._evt_handler = handle_evt  # type: ignore
 
     ctx = Context(mycharm, meta={'name': 'foo'}, actions={'foo': {}})
     with pytest.raises(ActionFailed) as exc_info:
         ctx.run(ctx.on.action('foo'), State())
     assert exc_info.value.message == 'action failed!'
 
 
-def test_action_event_fail_context_manager(mycharm):
+def test_action_event_fail_context_manager(mycharm: type[CharmBase]):
     def handle_evt(_: CharmBase, evt: ActionEvent):
         if not isinstance(evt, ActionEvent):
             return
         evt.fail('action failed!')
 
-    mycharm._evt_handler = handle_evt
+    mycharm._evt_handler = handle_evt  # type: ignore
 
     ctx = Context(mycharm, meta={'name': 'foo'}, actions={'foo': {}})
     with pytest.raises(ActionFailed) as exc_info:
@@ -142,11 +145,11 @@ def handle_evt(_: CharmBase, evt: ActionEvent):
 
 def test_action_continues_after_fail():
     class MyCharm(CharmBase):
-        def __init__(self, framework):
+        def __init__(self, framework: Framework):
             super().__init__(framework)
             framework.observe(self.on.foo_action, self._on_foo_action)
 
-        def _on_foo_action(self, event):
+        def _on_foo_action(self, event: ActionEvent):
             event.log('starting')
             event.set_results({'initial': 'result'})
             event.fail('oh no!')
@@ -160,44 +163,55 @@ def _on_foo_action(self, event):
     assert ctx.action_results == {'initial': 'result', 'final': 'result'}
 
 
-def test_action_event_has_id(mycharm):
+def _ops_less_than(wanted_major: int, wanted_minor: int) -> bool:
+    major, minor = (int(v) for v in ops_version.split('.')[:2])
+    if major < wanted_major:
+        return True
+    if major == wanted_major and minor < wanted_minor:
+        return True
+    return False
+
+
+@pytest.mark.skipif(_ops_less_than(2, 11), reason="ops 2.10 and earlier don't have ActionEvent.id")
+def test_action_event_has_id(mycharm: type[CharmBase]):
     def handle_evt(_: CharmBase, evt: ActionEvent):
         if not isinstance(evt, ActionEvent):
             return
         assert isinstance(evt.id, str) and evt.id != ''
 
-    mycharm._evt_handler = handle_evt
+    mycharm._evt_handler = handle_evt  # type: ignore
 
     ctx = Context(mycharm, meta={'name': 'foo'}, actions={'foo': {}})
     ctx.run(ctx.on.action('foo'), State())
 
 
-def test_action_event_has_override_id(mycharm):
+@pytest.mark.skipif(_ops_less_than(2, 11), reason="ops 2.10 and earlier don't have ActionEvent.id")
+def test_action_event_has_override_id(mycharm: type[CharmBase]):
     uuid = '0ddba11-cafe-ba1d-5a1e-dec0debad'
 
     def handle_evt(charm: CharmBase, evt: ActionEvent):
         if not isinstance(evt, ActionEvent):
             return
         assert evt.id == uuid
 
-    mycharm._evt_handler = handle_evt
+    mycharm._evt_handler = handle_evt  # type: ignore
 
     ctx = Context(mycharm, meta={'name': 'foo'}, actions={'foo': {}})
     ctx.run(ctx.on.action('foo', id=uuid), State())
 
 
 def test_two_actions_same_context():
     class MyCharm(CharmBase):
-        def __init__(self, framework):
+        def __init__(self, framework: Framework):
             super().__init__(framework)
             framework.observe(self.on.foo_action, self._on_foo_action)
             framework.observe(self.on.bar_action, self._on_bar_action)
 
-        def _on_foo_action(self, event):
+        def _on_foo_action(self, event: ActionEvent):
             event.log('foo')
             event.set_results({'foo': 'result'})
 
-        def _on_bar_action(self, event):
+        def _on_bar_action(self, event: ActionEvent):
             event.log('bar')
             event.set_results({'bar': 'result'})
 
@@ -213,7 +227,7 @@ def _on_bar_action(self, event):
 
 def test_positional_arguments():
     with pytest.raises(TypeError):
-        _Action('foo', {})
+        _Action('foo', {})  # type: ignore
 
 
 def test_default_arguments():

testing/tests/test_e2e/test_cloud_spec.py

@@ -15,7 +15,7 @@ def __init__(self, framework: ops.Framework):
         for evt in self.on.events().values():
             self.framework.observe(evt, self._on_event)
 
-    def _on_event(self, event):
+    def _on_event(self, event: ops.EventBase):
         pass
 
 

testing/tests/test_e2e/test_config.py

@@ -3,31 +3,32 @@
 
 from __future__ import annotations
 
+from typing import Any
+
 import pytest
 from scenario.state import State
 
-from ops.charm import CharmBase
-from ops.framework import Framework
+import ops
 
 from ..helpers import trigger
 
 
 @pytest.fixture(scope='function')
-def mycharm():
-    class MyCharm(CharmBase):
-        def __init__(self, framework: Framework):
+def mycharm() -> type[ops.CharmBase]:
+    class MyCharm(ops.CharmBase):
+        def __init__(self, framework: ops.Framework):
             super().__init__(framework)
             for evt in self.on.events().values():
                 self.framework.observe(evt, self._on_event)
 
-        def _on_event(self, event):
+        def _on_event(self, event: ops.EventBase):
             pass
 
     return MyCharm
 
 
-def test_config_get(mycharm):
-    def check_cfg(charm: CharmBase):
+def test_config_get(mycharm: type[ops.CharmBase]):
+    def check_cfg(charm: ops.CharmBase):
         assert charm.config['foo'] == 'bar'
         assert charm.config['baz'] == 1
 
@@ -43,8 +44,8 @@ def check_cfg(charm: CharmBase):
     )
 
 
-def test_config_get_default_from_meta(mycharm):
-    def check_cfg(charm: CharmBase):
+def test_config_get_default_from_meta(mycharm: type[ops.CharmBase]):
+    def check_cfg(charm: ops.CharmBase):
         assert charm.config['foo'] == 'bar'
         assert charm.config['baz'] == 2
         assert charm.config['qux'] is False
@@ -75,18 +76,18 @@ def check_cfg(charm: CharmBase):
         {'baz': 4, 'foo': 'bar', 'qux': True},
     ),
 )
-def test_config_in_not_mutated(mycharm, cfg_in):
-    class MyCharm(CharmBase):
-        def __init__(self, framework: Framework):
+def test_config_in_not_mutated(mycharm: type[ops.CharmBase], cfg_in: dict[str, Any]):
+    class MyCharm(ops.CharmBase):
+        def __init__(self, framework: ops.Framework):
             super().__init__(framework)
             for evt in self.on.events().values():
                 self.framework.observe(evt, self._on_event)
 
-        def _on_event(self, event):
+        def _on_event(self, event: ops.EventBase):
             # access the config to trigger a config-get
-            foo_cfg = self.config['foo']  # noqa: F841
-            baz_cfg = self.config['baz']  # noqa: F841
-            qux_cfg = self.config['qux']  # noqa: F841
+            _foo_cfg = self.config['foo']
+            _baz_cfg = self.config['baz']
+            _qux_cfg = self.config['qux']
 
     state_out = trigger(
         State(