Merge pull request #82 from LanceMaverick/tests

Made automated tests for some helper functions

skybeard/utils.py

@@ -13,8 +13,11 @@ def is_module(path):
         return True
     elif os.path.exists(os.path.join(path, "__init__.py")):
         return True
-    else:
-        return False
+    try:
+        if any(os.path.splitext(x)[1] == ".py" for x in os.listdir(path)):
+            return True
+    except FileNotFoundError:
+        pass
 
 
 def get_literal_path(path_or_autoloader):

tests/test_decorators.py

@@ -0,0 +1,39 @@
+import asyncio
+import unittest
+import types
+import functools
+from skybeard import decorators
+
+
+class TestSkybeardDecorators(unittest.TestCase):
+    def setUp(self):
+        self.loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(None)
+
+    def test_onerror_with_args_return_None(self):
+        @decorators.onerror("<i>foo</i>", parse_mode="HTML")
+        async def foo(beard, *args, **kwargs):
+            return beard, args, kwargs
+
+        foo_coro = foo(None)
+
+        self.assertIsInstance(foo, types.FunctionType)
+        self.assertIsInstance(foo_coro, types.CoroutineType)
+
+        self.loop.run_until_complete(foo_coro)
+
+    def test_debugonly_return_None(self):
+        @decorators.debugonly("<i>foo</i>", parse_mode="HTML")
+        async def foo(beard, *args, **kwargs):
+            return beard, args, kwargs
+
+        foo_coro = foo(None)
+
+        self.assertIsInstance(foo, types.FunctionType)
+        self.assertIsInstance(foo_coro, types.CoroutineType)
+
+        self.loop.run_until_complete(foo_coro)
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_predicates.py

@@ -0,0 +1,63 @@
+import asyncio
+import unittest
+
+import telepot
+import telepot.aio
+
+from skybeard import predicates
+from skybeard.beards import BeardChatHandler
+
+# TODO make TestBeard to test with real Telegram messages
+
+
+class TestBeard(BeardChatHandler):
+    pass
+
+
+class TestChatHandler():
+    def __init__(self, username, *args, **kwargs):
+        self._username = username
+
+    async def get_username(self):
+        return self._username
+
+
+class TestSkybeardPredicates(unittest.TestCase):
+    def setUp(self):
+        self.loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(None)
+
+    def test_regex_predicate_return_None(self):
+        f = predicates.regex_predicate("^foo.*")
+        msg = {"text": "foobar"}
+        self.assertTrue(f(None, msg))
+        msg = {"text": "bar"}
+        self.assertFalse(f(None, msg))
+
+    def test_command_predicate_return_None(self):
+        async def coro():
+            f = predicates.command_predicate("foobar")
+            c = TestChatHandler("foobot")
+            msg = {"text": "/foobar"}
+            self.assertTrue(await f(c, msg))
+            msg = {"text": "/foobar@foobot"}
+            self.assertTrue(await f(c, msg))
+        self.loop.run_until_complete(coro())
+
+    def test_Filters_text_return_None(self):
+        msg = {"text": "foobar"}
+        self.assertTrue(predicates.Filters.text(None, msg))
+
+    def test_Filters_location_return_None(self):
+        # TODO check the form of location messages
+        msg = {"location": [234, -1234]}
+        self.assertTrue(predicates.Filters.location(None, msg))
+
+    def test_Filters_document_return_None(self):
+        # TODO check the form of document messages
+        msg = {"document": b"asdfoinapofjapodifj"}
+        self.assertTrue(predicates.Filters.document(None, msg))
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_utils.py

@@ -0,0 +1,47 @@
+import unittest
+from skybeard import utils
+
+
+class TestSkybeardUtils(unittest.TestCase):
+    def test_is_module_return_None(self):
+        self.assertTrue(utils.is_module("skybeard"))
+        self.assertFalse(utils.is_module("foobarnotamodule"))
+
+    def test_embolden_return_string(self):
+        self.assertTrue(utils.embolden("foo") == "<b>foo</b>")
+
+    def test_italisize_return_string(self):
+        self.assertTrue(utils.italisize("foo") == "<i>foo</i>")
+
+    def test_get_args_take_msg_return_None(self):
+        msg = {"text": "/foobar foo bar"}
+        args = utils.get_args(msg)
+        expected_args = ("foo", "bar")
+        self.assertTrue(all((x == y for x, y in zip(args, expected_args))))
+
+    def test_get_args_take_text_return_None(self):
+        text = "/foobar foo bar"
+        args = utils.get_args(text)
+        expected_args = ("foo", "bar")
+        self.assertTrue(all((x == y for x, y in zip(args, expected_args))))
+
+    def test_get_args_with_shlex_take_msg_return_None(self):
+        msg = {"text": "/foobar 'foo bar' baz"}
+        args = utils.get_args(msg)
+        expected_args = ("foo bar", "baz")
+        self.assertTrue(all((x == y for x, y in zip(args, expected_args))))
+
+    def test_get_args_with_shlex_take_text_return_None(self):
+        text =  "/foobar 'foo bar' baz"
+        args = utils.get_args(text)
+        expected_args = ("foo bar", "baz")
+        self.assertTrue(all((x == y for x, y in zip(args, expected_args))))
+
+    def test_partition_text_return_None(self):
+        text = "a"*3000+"\n"+"b"*3000
+        partitioned_text = [x for x in utils.partition_text(text)]
+        self.assertTrue(len(partitioned_text) == 2)
+
+
+if __name__ == '__main__':
+    unittest.main()