Switch from unittest to pytest

.github/workflows/ci.yml

@@ -31,8 +31,8 @@ jobs:
         with:
           python-version: ${{ matrix.python-version }}
       - run: uv sync --dev --all-packages
-      - run: uv run python -m unittest discover -s fluent.syntax
-      - run: uv run python -m unittest discover -s fluent.runtime
+      - run: uv run pytest fluent.syntax
+      - run: uv run pytest fluent.runtime
 
   # Test fluent.runtime's compatibility with a range of fluent.syntax versions.
   compatibility:
@@ -52,4 +52,4 @@ jobs:
       - run: uv venv
       - run: uv pip install ${{ matrix.fluent-syntax }}
       - run: uv pip install ./fluent.runtime
-      - run: uv run python -m unittest discover -s fluent.runtime
+      - run: uv run pytest fluent.runtime

fluent.runtime/tests/format/test_arguments.py

@@ -1,74 +1,61 @@
-import unittest
+import pytest
 
 from fluent.runtime import FluentBundle, FluentResource
 
 from ..utils import dedent_ftl
 
 
-class TestNumbersInValues(unittest.TestCase):
-    def setUp(self):
-        self.bundle = FluentBundle(["en-US"], use_isolating=False)
-        self.bundle.add_resource(
+class TestNumbersInValues:
+    @pytest.fixture
+    def bundle(self):
+        bundle = FluentBundle(["en-US"], use_isolating=False)
+        bundle.add_resource(
             FluentResource(
                 dedent_ftl(
                     """
-            foo = Foo { $num }
-            bar = { foo }
-            baz =
-                .attr = Baz Attribute { $num }
-            qux = { "a" ->
-               *[a]     Baz Variant A { $num }
-             }
-        """
+                    foo = Foo { $num }
+                    bar = { foo }
+                    baz =
+                        .attr = Baz Attribute { $num }
+                    qux = { "a" ->
+                       *[a]     Baz Variant A { $num }
+                     }
+                    """
                 )
             )
         )
+        return bundle
 
-    def test_can_be_used_in_the_message_value(self):
-        val, errs = self.bundle.format_pattern(
-            self.bundle.get_message("foo").value, {"num": 3}
-        )
-        self.assertEqual(val, "Foo 3")
-        self.assertEqual(len(errs), 0)
-
-    def test_can_be_used_in_the_message_value_which_is_referenced(self):
-        val, errs = self.bundle.format_pattern(
-            self.bundle.get_message("bar").value, {"num": 3}
-        )
-        self.assertEqual(val, "Foo 3")
-        self.assertEqual(len(errs), 0)
+    def test_can_be_used_in_the_message_value(self, bundle):
+        val, errs = bundle.format_pattern(bundle.get_message("foo").value, {"num": 3})
+        assert val == "Foo 3"
+        assert len(errs) == 0
 
-    def test_can_be_used_in_an_attribute(self):
-        val, errs = self.bundle.format_pattern(
-            self.bundle.get_message("baz").attributes["attr"], {"num": 3}
-        )
-        self.assertEqual(val, "Baz Attribute 3")
-        self.assertEqual(len(errs), 0)
+    def test_can_be_used_in_the_message_value_which_is_referenced(self, bundle):
+        val, errs = bundle.format_pattern(bundle.get_message("bar").value, {"num": 3})
+        assert val == "Foo 3"
+        assert len(errs) == 0
 
-    def test_can_be_used_in_a_variant(self):
-        val, errs = self.bundle.format_pattern(
-            self.bundle.get_message("qux").value, {"num": 3}
+    def test_can_be_used_in_an_attribute(self, bundle):
+        val, errs = bundle.format_pattern(
+            bundle.get_message("baz").attributes["attr"], {"num": 3}
         )
-        self.assertEqual(val, "Baz Variant A 3")
-        self.assertEqual(len(errs), 0)
+        assert val == "Baz Attribute 3"
+        assert len(errs) == 0
 
+    def test_can_be_used_in_a_variant(self, bundle):
+        val, errs = bundle.format_pattern(bundle.get_message("qux").value, {"num": 3})
+        assert val == "Baz Variant A 3"
+        assert len(errs) == 0
 
-class TestStrings(unittest.TestCase):
-    def setUp(self):
-        self.bundle = FluentBundle(["en-US"], use_isolating=False)
-        self.bundle.add_resource(
-            FluentResource(
-                dedent_ftl(
-                    """
-            foo = { $arg }
-        """
-                )
-            )
-        )
 
+class TestStrings:
     def test_can_be_a_string(self):
-        val, errs = self.bundle.format_pattern(
-            self.bundle.get_message("foo").value, {"arg": "Argument"}
+        bundle = FluentBundle(["en-US"], use_isolating=False)
+        bundle.add_resource(FluentResource("foo = { $arg }"))
+
+        val, errs = bundle.format_pattern(
+            bundle.get_message("foo").value, {"arg": "Argument"}
         )
-        self.assertEqual(val, "Argument")
-        self.assertEqual(len(errs), 0)
+        assert val == "Argument"
+        assert len(errs) == 0