refactor(tests): finish converting all tests to pytest

Author: joanise

g2p/tests/test_neural.py

@@ -1,17 +1,16 @@
 #!/usr/bin/env python
 
 import sys
-from unittest import SkipTest, TestCase
 
-from pytest import main
+from pytest import main, skip
 
 from g2p import make_g2p
 from g2p.log import LOGGER
 from g2p.mappings.utils import has_neural_support
 from g2p.tests.public.data import load_neural_test_data
 
 
-class NeuralLangTest(TestCase):
+class TestNeuralLang:
     """Basic Test for individual lookup tables.
 
     Test file is in g2p/tests/public/data/neural.psv.
@@ -21,10 +20,8 @@ class NeuralLangTest(TestCase):
     """
 
     def test_io(self):
-        if sys.version_info < (3, 9):
-            raise SkipTest("neural g2p requires python >= 3.9")
         if not has_neural_support():
-            raise SkipTest("neural not installed; skipping neural tests")
+            skip("neural not installed; skipping neural tests")
         langs_to_test = load_neural_test_data()
 
         # go through each language declared in the test case set up

g2p/tests/test_studio.py

@@ -16,11 +16,10 @@
 import time
 from datetime import datetime
 from random import sample
-from unittest import IsolatedAsyncioTestCase
 
 import socketio  # type: ignore
 from playwright.async_api import Error, async_playwright, expect  # type: ignore
-from pytest import fixture, main
+from pytest import fixture, main, mark
 
 from g2p.log import LOGGER
 from g2p.tests.public.data import load_public_test_data
@@ -30,9 +29,7 @@
 
 @fixture(autouse=True, scope="module")
 def run_studio():
-    """Launch the studio server automatically via this fuxture (pytest only)
-
-    When using unittest, launch run_studio.py in another window first."""
+    """Launch the studio server automatically via this fuxture"""
     import threading
 
     def start_studio():
@@ -56,13 +53,12 @@ def start_studio():
     yield
 
 
-class StudioTest(IsolatedAsyncioTestCase):
-    def __init__(self, *args):
-        super().__init__(*args)
-        # self.port = 5000
-        self.port = STUDIO_PORT
-        self.debug_convert = True
-        self.timeout_delay = 500
+@mark.asyncio
+class TestStudio:
+    # self.port = 5000
+    port = STUDIO_PORT
+    debug_convert = True
+    timeout_delay = 500
 
     async def test_socket_connection(self):
         client = socketio.AsyncClient()

g2p/tests/test_tokenize_and_map.py

@@ -1,19 +1,15 @@
 #!/usr/bin/env python
 
 import sys
-from unittest import TestCase
 
-from pytest import main
+from pytest import main, raises
 
 import g2p
 
 
-class TokenizeAndMapTest(TestCase):
+class TestTokenizeAndMap:
     """Test suite for chaining tokenization and transduction"""
 
-    def setUp(self):
-        pass
-
     def contextualize(self, word: str):
         return word + " " + word + " ," + word + ", " + word
 
@@ -162,37 +158,32 @@ def test_removed_tok_langs_in_v2(self) -> None:
         # monkey patch to make sure we always exercise the TypeError pathway
         saved_version = g2p._version.VERSION
         g2p._version.VERSION = "2.0"
-        with self.assertRaises(TypeError):
+        with raises(TypeError):
             _ = g2p.make_g2p("iku-sro", "eng-ipa", "path")  # type: ignore
         g2p._version.VERSION = saved_version
 
     def test_make_g2p_cache(self):
-        self.assertIs(
-            g2p.make_g2p("fra", "fra-ipa", tokenize=False),
-            g2p.make_g2p("fra", "fra-ipa", tokenize=False),
+        assert g2p.make_g2p("fra", "fra-ipa", tokenize=False) is g2p.make_g2p(
+            "fra", "fra-ipa", tokenize=False
         )
-
-        self.assertIsNot(
-            g2p.make_g2p("fra", "fra-ipa", tokenize=True),
-            g2p.make_g2p("fra", "fra-ipa", tokenize=False),
+        assert g2p.make_g2p("fra", "fra-ipa", tokenize=True) is not g2p.make_g2p(
+            "fra", "fra-ipa", tokenize=False
         )
         my_tokenizer = g2p.make_tokenizer("oji")
-        self.assertIs(
-            g2p.make_g2p("oji", "eng-ipa", custom_tokenizer=my_tokenizer),
-            g2p.make_g2p("oji", "eng-ipa", custom_tokenizer=my_tokenizer),
-        )
-        self.assertIs(
-            g2p.make_g2p("oji", "eng-ipa", custom_tokenizer=my_tokenizer),
-            g2p.make_g2p("oji", "eng-ipa", custom_tokenizer=g2p.make_tokenizer("oji")),
-        )
-        self.assertIsNot(
-            g2p.make_g2p("oji", "eng-ipa", custom_tokenizer=my_tokenizer),
-            g2p.make_g2p("oji", "eng-ipa", custom_tokenizer=g2p.make_tokenizer("ikt")),
-        )
-        self.assertIsNot(
-            g2p.make_g2p("oji", "eng-ipa", custom_tokenizer=my_tokenizer),
-            g2p.make_g2p("oji", "eng-ipa", tokenize=True),
+        assert g2p.make_g2p(
+            "oji", "eng-ipa", custom_tokenizer=my_tokenizer
+        ) is g2p.make_g2p("oji", "eng-ipa", custom_tokenizer=my_tokenizer)
+        assert g2p.make_g2p(
+            "oji", "eng-ipa", custom_tokenizer=my_tokenizer
+        ) is g2p.make_g2p("oji", "eng-ipa", custom_tokenizer=g2p.make_tokenizer("oji"))
+        assert g2p.make_g2p(
+            "oji", "eng-ipa", custom_tokenizer=my_tokenizer
+        ) is not g2p.make_g2p(
+            "oji", "eng-ipa", custom_tokenizer=g2p.make_tokenizer("ikt")
         )
+        assert g2p.make_g2p(
+            "oji", "eng-ipa", custom_tokenizer=my_tokenizer
+        ) is not g2p.make_g2p("oji", "eng-ipa", tokenize=True)
 
 
 if __name__ == "__main__":

g2p/tests/test_tokenizer.py

@@ -1,15 +1,14 @@
 #!/usr/bin/env python
 
 import sys
-from unittest import TestCase
 
-from pytest import main
+from pytest import main, raises
 
 import g2p.mappings.tokenizer as tok
 from g2p.log import LOGGER
 
 
-class TokenizerTest(TestCase):
+class TestTokenizer:
     """Test suite for tokenizing text in a language-specific way"""
 
     def test_tokenize_fra(self):
@@ -19,19 +18,19 @@ def test_tokenize_fra(self):
         assert len(tokens) == 8
         assert tokens[0].is_word
         assert tokens[0].text == "ceci"
-        self.assertFalse(tokens[1].is_word)
+        assert not tokens[1].is_word
         assert tokens[1].text == " "
         assert tokens[2].is_word
         assert tokens[2].text == "était"
-        self.assertFalse(tokens[3].is_word)
+        assert not tokens[3].is_word
         assert tokens[3].text == " '"
         assert tokens[4].is_word
         assert tokens[4].text == "un"
-        self.assertFalse(tokens[5].is_word)
+        assert not tokens[5].is_word
         assert tokens[5].text == "' "
         assert tokens[6].is_word
         assert tokens[6].text == "test"
-        self.assertFalse(tokens[7].is_word)
+        assert not tokens[7].is_word
         assert tokens[7].text == "."
 
     def test_tokenize_eng(self):
@@ -41,10 +40,10 @@ def test_tokenize_eng(self):
         assert len(tokens) == 8
         assert tokens[0].is_word
         assert tokens[0].text == "This"
-        self.assertFalse(tokens[1].is_word)
+        assert not tokens[1].is_word
         assert tokens[1].text == " "
 
-    def test_lexicon_tokenizer(self):
+    def test_lexicon_tokenizer(self, subtests):
         tokenizer = tok.make_tokenizer("eng")
         tests = [
             ("It's", ["It's"]),
@@ -58,7 +57,7 @@ def test_lexicon_tokenizer(self):
             ("all-in: nonsense", ["all", "-", "in", ": ", "nonsense"]),  # all-in is not
         ]
         for input_text, expected_tokens in tests:
-            with self.subTest(input_text=input_text):
+            with subtests.test(input_text=input_text):
                 tokens = tokenizer.tokenize_text(input_text)
                 assert [x.text for x in tokens] == expected_tokens
 
@@ -100,10 +99,10 @@ def test_tokenize_tce_equiv(self):
         assert len(tok.make_tokenizer("tce").tokenize_text(input)) == 7
 
     def test_tokenizer_identity_tce(self):
-        self.assertNotEqual(tok.make_tokenizer("eng"), tok.make_tokenizer("fra"))
-        self.assertNotEqual(tok.make_tokenizer("eng"), tok.make_tokenizer("tce"))
+        assert tok.make_tokenizer("eng") != tok.make_tokenizer("fra")
+        assert tok.make_tokenizer("eng") != tok.make_tokenizer("tce")
         assert tok.make_tokenizer("tce") == tok.make_tokenizer("tce")
-        self.assertNotEqual(tok.make_tokenizer("tce"), tok.make_tokenizer())
+        assert tok.make_tokenizer("tce") != tok.make_tokenizer()
         assert tok.make_tokenizer("foo") == tok.make_tokenizer()
 
     def test_tokenize_kwk(self):
@@ -123,25 +122,25 @@ def test_three_hop_tokenizer(self):
 
     def test_tokenize_not_ipa_explicit(self):
         tokenizer = tok.make_tokenizer("fn-unicode-font", "fn-unicode")
-        self.assertNotEqual(tokenizer, tok.make_tokenizer())
+        assert tokenizer != tok.make_tokenizer()
 
     def test_tokenize_not_ipa_implicit(self):
         tokenizer = tok.make_tokenizer("fn-unicode-font")
-        self.assertNotEqual(tokenizer, tok.make_tokenizer())
+        assert tokenizer != tok.make_tokenizer()
 
     def test_tokenize_lang_does_not_exist(self):
         assert tok.make_tokenizer("not_a_language") == tok.make_tokenizer()
         assert tok.make_tokenizer("fra" == "not_a_language"), tok.make_tokenizer()
 
     def test_make_tokenizer_error(self):
-        with self.assertRaises(ValueError):
+        with raises(ValueError):
             _ = tok.make_tokenizer("fra", "eng-arpabet", ["fra-ipa", "eng-ipa"])
 
-    def test_deprecated_warning(self):
-        with self.assertLogs(LOGGER, level="WARNING") as cm:
+    def test_deprecated_warning(self, caplog):
+        with caplog.at_level("WARNING", logger=LOGGER.name):
             tok._deprecated_warning_printed = False
             assert tok.get_tokenizer("fra") == tok.make_tokenizer("fra")
-        assert "deprecated" in "".join(cm.output)
+        assert "deprecated" in caplog.text
 
     def test_gwi_multichar_grapheme_makeg2p(self):
         from g2p import make_g2p

g2p/tests/test_transducer.py

@@ -2,9 +2,9 @@
 
 import os
 import sys
-from unittest import TestCase, mock
+from unittest import mock
 
-from pytest import main
+from pytest import main, raises
 
 from g2p import make_g2p
 from g2p.exceptions import MalformedMapping, NeuralDependencyError
@@ -16,11 +16,11 @@
 # mypy: disable-error-code="attr-defined"
 
 
-class TransducerTest(TestCase):
+class TestTransducer:
     """Basic Transducer Test"""
 
     @classmethod
-    def setUpClass(cls):
+    def setup_class(cls):
         cls.test_mapping_moh = Mapping.find_mapping(
             in_lang="moh-equiv", out_lang="moh-ipa"
         )
@@ -93,9 +93,9 @@ def setUpClass(cls):
     def test_no_neural_dependencies(self):
         """This tests what happens if a user tries to create a neural g2p without installing the dependencies. Other neural tests (for when deps are installed are in test_neural.py module.)"""
         with mock.patch("g2p.mappings.utils.has_neural_support", return_value=False):
-            with self.assertRaises(NeuralDependencyError):
+            with raises(NeuralDependencyError):
                 make_g2p("foo", "bar", neural=True)
-            with self.assertRaises(NeuralDependencyError):
+            with raises(NeuralDependencyError):
                 make_g2p("str", "str-ipa", neural=True)
 
     def test_properties(self):
@@ -131,11 +131,11 @@ def test_graph_properties(self):
         tg.debugger = [["spam", "spam", "spam", "spam"]]
         assert 1 == len(tg.debugger)
         assert 4 == len(tg.debugger[0])
-        with self.assertRaises(ValueError):
+        with raises(ValueError):
             tg.input_nodes = ("foo", "bar", "baz")
-        with self.assertRaises(ValueError):
+        with raises(ValueError):
             tg.output_nodes = ("foo", "bar", "baz")
-        with self.assertRaises(ValueError):
+        with raises(ValueError):
             tg.tiers = ["spam", "spam", "eggs", "spam"]
         tg = self.test_trans("abab")
         tg += tg
@@ -160,15 +160,15 @@ def test_composite_graph_properties(self):
         assert [(0 == "b"), (1, "b"), (2, "b"), (3, "b")], ctg.input_nodes
         ctg.output_string = "baba"
         assert [(0 == "b"), (1, "a"), (2, "b"), (3, "a")], ctg.output_nodes
-        with self.assertRaises(ValueError):
+        with raises(ValueError):
             ctg.debugger = [["spam", "spam", "spam", "spam"]]
-        with self.assertRaises(ValueError):
+        with raises(ValueError):
             ctg.edges = [(0, 1), (1, 0), (2, 3), (3, 2)]
-        with self.assertRaises(ValueError):
+        with raises(ValueError):
             ctg.input_nodes = ("foo", "bar", "baz")
-        with self.assertRaises(ValueError):
+        with raises(ValueError):
             ctg.output_nodes = ("foo", "bar", "baz")
-        with self.assertRaises(ValueError):
+        with raises(ValueError):
             ctg.tiers = ["spam", "spam", "eggs", "spam"]
         ctg = self.test_trans_composite("aba")
         ctg += ctg
@@ -244,7 +244,7 @@ def test_case_preservation(self):
         # I guess it's arguable what should happen here, but I'll just change case if any of the characters are differently cased
         assert transducer("Tlaba").output_string == "\u2144aba"
         # case equivalencies that are not the same length cause indexing errors in the current implementation
-        with self.assertRaises(MalformedMapping):
+        with raises(MalformedMapping):
             Mapping(
                 rules=[
                     {"in": "'a", "out": "b"},
@@ -257,7 +257,7 @@ def test_case_preservation(self):
                 case_equivalencies={"λ": "\u2144\u2144\u2144"},
             )
 
-        with self.assertRaises(MalformedMapping):
+        with raises(MalformedMapping):
             _ = Mapping(
                 rules=[{"in": "a", "out": "b"}],
                 case_sensitive=True,