updated unittests to python3 and switched to pytest

Author: manfred-kaiser

tests/test_comparators.py

@@ -1,28 +1,15 @@
 # type: ignore
 
-import unittest
+import pytest
 
 import sifter.comparator
 from sifter.grammar.comparator import Comparator
 
 
-class MockComparator(Comparator):
+def test_mock_comparator() -> None:
+    class MockComparator(Comparator):
+        COMPARATOR_ID = 'i;vnd-mock'
 
-    COMPARATOR_ID = 'i;vnd-mock'
-
-
-class TestMatchTypes(unittest.TestCase):
-
-    def setUp(self) -> None:
-        MockComparator.register()
-
-    def test_unimplemented_match_type(self) -> None:
-        self.assertRaises(
-            RuntimeError,
-            sifter.comparator.get_match_fn,
-            'i;vnd-mock', 'IS',
-        )
-
-
-if __name__ == '__main__':
-    unittest.main()
+    MockComparator.register()
+    with pytest.raises(RuntimeError):
+        sifter.comparator.get_match_fn('i;vnd-mock', 'IS')

tests/test_evaluation.py

@@ -2,13 +2,19 @@
 
 import email
 import os.path
-import unittest
-import codecs
 
 import sifter.parser
 
 
-class TestEvaluateRules(unittest.TestCase):
+def eval_rules(filename_message, filename_rules):
+    with open(os.path.join(os.path.dirname(__file__), filename_message), encoding='utf-8') as msg_fh:
+        message = email.message_from_file(msg_fh)
+    with open(os.path.join(os.path.dirname(__file__), filename_rules), encoding='utf-8') as rule_fh:
+        rules = sifter.parser.parse_file(rule_fh)
+    return rules.evaluate(message)
+
+
+def test_evaulation():
 
     EVAL_RESULTS = (
         ("evaluation_1.msg", "evaluation_1.rules", [('redirect', 'acm@example.com')]),
@@ -20,24 +26,5 @@ class TestEvaluateRules(unittest.TestCase):
         ("evaluation_3.msg", "evaluation_3.rules", [('keep', None)]),
     )
 
-    def setUp(self) -> None:
-        self.messages = {}
-        self.rules = {}
-        for result in self.EVAL_RESULTS:
-            with codecs.open(os.path.join(os.path.dirname(__file__), result[0]),
-                             encoding='utf-8') as msg_fh:
-                self.messages.setdefault(result[0], email.message_from_file(msg_fh))
-            with codecs.open(os.path.join(os.path.dirname(__file__), result[1]),
-                             encoding='utf-8') as rule_fh:
-                self.rules.setdefault(result[1], sifter.parser.parse_file(rule_fh))
-
-    def test_msg_rule_cross_product(self) -> None:
-        for result in self.EVAL_RESULTS:
-            self.assertEqual(
-                self.rules[result[1]].evaluate(self.messages[result[0]]),
-                result[2]
-            )
-
-
-if __name__ == '__main__':
-    unittest.main()
+    for messagefile, rulefile, evaluated_rules in EVAL_RESULTS:
+        assert evaluated_rules == eval_rules(messagefile, rulefile)

tests/test_grammar.py

@@ -1,28 +1,19 @@
 # type: ignore
 
-import unittest
+import pytest
 
 import sifter.extension
 from sifter.grammar.state import EvaluationState
 
 
-class TestEvaluationState(unittest.TestCase):
+def test_grammar():
+    sifter.extension.register('ext1')
+    sifter.extension.register('ext2')
+    state = EvaluationState()
 
-    def setUp(self) -> None:
-        sifter.extension.register('ext1')
-        sifter.extension.register('ext2')
-        self.state = EvaluationState()
+    state.require_extension('ext1')
 
-    def test_require_extension(self) -> None:
-        self.state.require_extension('ext1')
-        self.assertTrue(self.state.check_required_extension('ext1', 'ext1'))
-        self.assertRaises(
-            RuntimeError,
-            self.state.check_required_extension,
-            'ext2',
-            'ext2',
-        )
+    assert state.check_required_extension('ext1', 'ext1') is True
 
-
-if __name__ == '__main__':
-    unittest.main()
+    with pytest.raises(RuntimeError):
+        state.check_required_extension('ext2', 'ext2')

tests/test_parser.py

@@ -1,23 +1,17 @@
 # type: ignore
 
 import os.path
-import unittest
-import codecs
 
 import sifter.parser
 
 
-class TestParseFile(unittest.TestCase):
+def test_parser():
+    in_filename = "parser_1.in"
+    golden_filename = "parser_1.out"
 
-    def test_files(self) -> None:
-        for in_filename, golden_filename in (("parser_1.in", "parser_1.out"),):
-            with codecs.open(os.path.join(os.path.dirname(__file__), in_filename), encoding='utf-8') as in_fh:
-                test_output = str(sifter.parser.parse_file(in_fh))
-            with codecs.open(os.path.join(os.path.dirname(__file__), golden_filename),
-                             encoding='utf-8') as golden_fh:
-                golden_output = golden_fh.read()
-            self.assertEqual(test_output, golden_output)
+    with open(os.path.join(os.path.dirname(__file__), in_filename), 'r', encoding='utf-8', newline='') as in_fh:
+        test_output = str(sifter.parser.parse_file(in_fh))
+    with open(os.path.join(os.path.dirname(__file__), golden_filename), 'r', encoding='utf-8', newline='') as golden_fh:
+        golden_output = golden_fh.read()
 
-
-if __name__ == '__main__':
-    unittest.main()
+    assert test_output == golden_output

tests/test_validators.py

@@ -1,6 +1,7 @@
 # type: ignore
 
-import unittest
+
+import pytest
 
 from sifter.grammar.tag import Tag as GrammarTag
 from sifter.grammar.rule import Rule, RuleSyntaxError
@@ -18,60 +19,39 @@ def __init__(self, arguments=None, tests=None):
         super(MockRule, self).__init__(arguments, tests)
 
 
-class TestValidationFn(unittest.TestCase):
-
-    def test_too_many_args(self) -> None:
-        mock_rule = MockRule([GrammarTag('IS'), 13, ])
-        self.assertRaises(
-            RuleSyntaxError,
-            mock_rule.validate_arguments,
-        )
-
-    def test_not_enough_args(self) -> None:
-        mock_rule = MockRule([13, ])
-        self.assertRaises(
-            RuleSyntaxError,
-            mock_rule.validate_arguments,
-            [
-                Number(),
-                StringList(),
-            ],
-        )
-
-
-class TestTagValidator(unittest.TestCase):
-
-    def test_allowed_tag(self) -> None:
-        mock_validator = TagValidator(['MOCK', 'IS', ])
-        self.assertEqual(
-            mock_validator.validate([GrammarTag('IS')], 0),
-            1
-        )
-
-    def test_allowed_single_tag(self) -> None:
-        # test the case for a non-list single tag name
-        mock_validator = TagValidator('IS')
-        self.assertEqual(
-            mock_validator.validate([GrammarTag('IS')], 0),
-            1
-        )
-
-    def test_not_allowed_tag(self) -> None:
-        mock_validator = TagValidator(['MOCK', 'FOO', ])
-        self.assertEqual(
-            mock_validator.validate([GrammarTag('IS')], 0),
-            0
-        )
-
-    def test_not_allowed_single_tag(self) -> None:
-        # test the case for a non-list single tag name. test when the tag is a
-        # substring of the allowed tag.
-        mock_validator = TagValidator('ISFOO')
-        self.assertEqual(
-            mock_validator.validate([GrammarTag('IS')], 0),
-            0
-        )
-
-
-if __name__ == '__main__':
-    unittest.main()
+def test_too_many_args() -> None:
+    mock_rule = MockRule([GrammarTag('IS'), 13, ])
+    with pytest.raises(RuleSyntaxError):
+        mock_rule.validate_arguments()
+
+
+def test_not_enough_args() -> None:
+    mock_rule = MockRule([13, ])
+    with pytest.raises(RuleSyntaxError):
+        mock_rule.validate_arguments([
+            Number(),
+            StringList(),
+        ])
+
+
+def test_allowed_tag() -> None:
+    mock_validator = TagValidator(['MOCK', 'IS', ])
+    assert mock_validator.validate([GrammarTag('IS')], 0) == 1
+
+
+def test_allowed_single_tag() -> None:
+    # test the case for a non-list single tag name
+    mock_validator = TagValidator('IS')
+    assert mock_validator.validate([GrammarTag('IS')], 0) == 1
+
+
+def test_not_allowed_tag() -> None:
+    mock_validator = TagValidator(['MOCK', 'FOO', ])
+    assert mock_validator.validate([GrammarTag('IS')], 0) == 0
+
+
+def test_not_allowed_single_tag() -> None:
+    # test the case for a non-list single tag name. test when the tag is a
+    # substring of the allowed tag.
+    mock_validator = TagValidator('ISFOO')
+    assert mock_validator.validate([GrammarTag('IS')], 0) == 0