init

tests/test_callbacks.py

@@ -0,0 +1,50 @@
+import unittest
+from unittest.mock import Mock
+
+import nio
+
+from my_project_name.callbacks import Callbacks
+from my_project_name.storage import Storage
+
+from tests.utils import make_awaitable, run_coroutine
+
+
+class CallbacksTestCase(unittest.TestCase):
+    def setUp(self) -> None:
+        # Create a Callbacks object and give it some Mock'd objects to use
+        self.fake_client = Mock(spec=nio.AsyncClient)
+        self.fake_client.user = "@fake_user:example.com"
+
+        self.fake_storage = Mock(spec=Storage)
+
+        # We don't spec config, as it doesn't currently have well defined attributes
+        self.fake_config = Mock()
+
+        self.callbacks = Callbacks(
+            self.fake_client, self.fake_storage, self.fake_config
+        )
+
+    def test_invite(self):
+        """Tests the callback for InviteMemberEvents"""
+        # Tests that the bot attempts to join a room after being invited to it
+
+        # Create a fake room and invite event to call the 'invite' callback with
+        fake_room = Mock(spec=nio.MatrixRoom)
+        fake_room_id = "!abcdefg:example.com"
+        fake_room.room_id = fake_room_id
+
+        fake_invite_event = Mock(spec=nio.InviteMemberEvent)
+        fake_invite_event.sender = "@some_other_fake_user:example.com"
+
+        # Pretend that attempting to join a room is always successful
+        self.fake_client.join.return_value = make_awaitable(None)
+
+        # Pretend that we received an invite event
+        run_coroutine(self.callbacks.invite(fake_room, fake_invite_event))
+
+        # Check that we attempted to join the room
+        self.fake_client.join.assert_called_once_with(fake_room_id)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_config.py

@@ -0,0 +1,81 @@
+import unittest
+from unittest.mock import Mock
+
+from my_project_name.config import Config
+from my_project_name.errors import ConfigError
+
+
+class ConfigTestCase(unittest.TestCase):
+    def test_get_cfg(self):
+        """Test that Config._get_cfg works correctly"""
+
+        # Here's our test dictionary. Pretend that this was parsed from a YAML config file.
+        test_config_dict = {"a_key": 5, "some_key": {"some_other_key": "some_value"}}
+
+        # We create a fake config using Mock. _get_cfg will attempt to pull from self.config_dict,
+        # so we use a Mock to quickly create a dummy class, and set the 'config_dict' attribute to
+        # our test dictionary.
+        fake_config = Mock()
+        fake_config.config_dict = test_config_dict
+
+        # Now let's make some calls to Config._get_cfg. We provide 'fake_cfg' as the first argument
+        # as a substitute for 'self'. _get_cfg will then be pulling values from fake_cfg.config_dict.
+
+        # Test that we can get the value of a top-level key
+        self.assertEqual(
+            Config._get_cfg(fake_config, ["a_key"]),
+            5,
+        )
+
+        # Test that we can get the value of a nested key
+        self.assertEqual(
+            Config._get_cfg(fake_config, ["some_key", "some_other_key"]),
+            "some_value",
+        )
+
+        # Test that the value provided by the default option is used when a key does not exist
+        self.assertEqual(
+            Config._get_cfg(
+                fake_config,
+                ["a_made_up_key", "this_does_not_exist"],
+                default="The default",
+            ),
+            "The default",
+        )
+
+        # Test that the value provided by the default option is *not* used when a key *does* exist
+        self.assertEqual(
+            Config._get_cfg(fake_config, ["a_key"], default="The default"),
+            5,
+        )
+
+        # Test that keys that do not exist raise a ConfigError when the required argument is True
+        with self.assertRaises(ConfigError):
+            Config._get_cfg(
+                fake_config, ["a_made_up_key", "this_does_not_exist"], required=True
+            )
+
+        # Test that a ConfigError is not returned when a non-existent key is provided and required is False
+        self.assertIsNone(
+            Config._get_cfg(
+                fake_config, ["a_made_up_key", "this_does_not_exist"], required=False
+            )
+        )
+
+        # Test that default is used for non-existent keys, even if required is True
+        # (Typically one shouldn't use a default with required=True anyways...)
+        self.assertEqual(
+            Config._get_cfg(
+                fake_config,
+                ["a_made_up_key", "this_does_not_exist"],
+                default="something",
+                required=True,
+            ),
+            "something",
+        )
+
+    # TODO: Test creating a test yaml file, passing the path to Config and _parse_config_values is called correctly
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/utils.py

@@ -0,0 +1,22 @@
+# Utility functions to make testing easier
+import asyncio
+from typing import Any, Awaitable
+
+
+def run_coroutine(result: Awaitable[Any]) -> Any:
+    """Wrapper for asyncio functions to allow them to be run from synchronous functions"""
+    loop = asyncio.get_event_loop()
+    result = loop.run_until_complete(result)
+    loop.close()
+    return result
+
+
+def make_awaitable(result: Any) -> Awaitable[Any]:
+    """
+    Makes an awaitable, suitable for mocking an `async` function.
+    This uses Futures as they can be awaited multiple times so can be returned
+    to multiple callers.
+    """
+    future = asyncio.Future()  # type: ignore
+    future.set_result(result)
+    return future