Fix unit test issues

Summary:
Fix couple of issues in parameterized tests
- Fix `endswith()` string, `thrift_mutable_types`
- Check `.__name__.endswith("thrift_mutable_types")` once in `setUp()`
- Move `hashability` test(s) to separate test class
- Fix few `import as`, `immutable_types` vs `mutable_types`

Reviewed By: ahilger

Differential Revision: D59618306

fbshipit-source-id: a537a8a0ba1c421a7deb2b6d09ae3c2303ec0faf

Author: yoney

thrift/lib/python/test/enums.py

@@ -67,6 +67,9 @@ def setUp(self) -> None:
         self.OptionalColorGroups: Type[OptionalColorGroups] = (
             self.test_types.OptionalColorGroups
         )
+        self.is_mutable_run: bool = self.test_types.__name__.endswith(
+            "thrift_mutable_types"
+        )
         # pyre-ignore[16]: has no attribute `serializer_module`
         self.serializer: types.ModuleType = self.serializer_module
 
@@ -115,8 +118,7 @@ def test_bad_enum_hash_same(self) -> None:
             self.serializer.Protocol.JSON,
         )
         # Mutable types do not support hashing
-        # pyre-ignore[16]: has no attribute `test_types`
-        if self.test_types.__name__.endswith("immutable_types"):
+        if not self.is_mutable_run:
             self.assertEqual(hash(x), hash(y))
         self.assertEqual(hash(x.type), hash(y.type))
         self.assertFalse(x.type is y.type)

thrift/lib/python/test/exceptions.py

@@ -146,6 +146,9 @@ def setUp(self) -> None:
         self.SimpleError: Type[SimpleErrorType] = self.test_types.SimpleError
         self.Color: Type[ColorType] = self.test_types.Color
         self.ValueOrError: Type[ValueOrErrorType] = self.test_types.ValueOrError
+        self.is_mutable_run: bool = self.test_types.__name__.endswith(
+            "thrift_mutable_types"
+        )
         # pyre-ignore[16]: has no attribute `serializer_module`
         self.serializer: types.ModuleType = self.serializer_module
 
@@ -269,8 +272,7 @@ def test_expr_deserialized(self) -> None:
         self.assertEqual(repr(z), "UnfriendlyError(errortext='WAT!', code=22)")
 
     def test_serialize_deserialize(self) -> None:
-        # pyre-ignore[16]: has no attribute `test_types`
-        if not self.test_types.__name__.endswith("immutable_types"):
+        if self.is_mutable_run:
             # `ValueOrError` is an union, MutableUnion implementation is not complete yet
             return
 

thrift/lib/python/test/lists.py

@@ -25,8 +25,8 @@
 import python_test.containers.thrift_mutable_types as mutable_containers_types
 import python_test.containers.thrift_types as immutable_containers_types
 
-import python_test.lists.thrift_mutable_types as immutable_lists_types
-import python_test.lists.thrift_types as mutable_lists_types
+import python_test.lists.thrift_mutable_types as mutable_lists_types
+import python_test.lists.thrift_types as immutable_lists_types
 
 from folly.iobuf import IOBuf
 
@@ -43,6 +43,12 @@
 from python_test.testing_utils import Untruthy
 
 
+class ImmutableListTests(unittest.TestCase):
+    def test_hashability(self) -> None:
+        hash(easy().val_list)
+        hash(I32List(range(10)))
+
+
 # ct = containers type, lt = lists type
 @parameterized_class(
     ("containers_types", "lists_types"),
@@ -64,6 +70,9 @@ def setUp(self) -> None:
         self.Foo: Type[Foo] = self.containers_types.Foo
         self.Lists: Type[Lists] = self.containers_types.Lists
         self.Color: Type[Color] = self.containers_types.Color
+        self.is_mutable_run: bool = self.containers_types.__name__.endswith(
+            "thrift_mutable_types"
+        )
 
     def test_negative_indexes(self) -> None:
         length = len(self.int_list)
@@ -117,13 +126,6 @@ def test_create_untruthy_list(self) -> None:
         self.assertEqual(I32List(Untruthy(5)), list(range(5)))
         self.assertEqual(Lists(i32List=Untruthy(5)).i32List, list(range(5)))
 
-    def test_hashability(self) -> None:
-        # Mutable types do not support hashing
-        # pyre-ignore[16]: has no attribute `lists_types`
-        if not self.lists_types.__name__.endswith("thrift_mutable_types"):
-            hash(self.easy().val_list)
-            hash(self.I32List(range(10)))
-
     def test_no_dict(self) -> None:
         with self.assertRaises(AttributeError):
             I32List().__dict__
@@ -252,8 +254,7 @@ def test_struct_with_list_fields(self) -> None:
         # test reaccess the list element not recreating the struct
         # DO_BEFORE(alperyoney,20240701): Figure out whether mutable containers
         # should cache the instance.
-        # pyre-ignore[16]: has no attribute `containers_types`
-        if not self.containers_types.__name__.endswith("thrift_mutable_types"):
+        if not self.is_mutable_run:
             self.assertIs(s.structList[0], s.structList[0])
             self.assertIs(s.structList[1], s.structList[1])
 
@@ -262,8 +263,7 @@ def test_count_enum(self) -> None:
         self.assertEqual(clist.colorList.count(self.Color.red), 2)
         self.assertEqual(clist.colorList.count(self.Color.blue), 1)
         self.assertEqual(clist.colorList.count(self.Color.green), 0)
-        # pyre-ignore[16]: has no attribute `containers_types`
-        if self.containers_types.__name__.endswith("thrift_mutable_types"):
+        if self.is_mutable_run:
             self.assertEqual(clist.colorList.count(0), 0)
             self.assertEqual(clist.colorList.count(1), 0)
             self.assertEqual(clist.colorList.count(2), 0)

thrift/lib/python/test/maps.py

@@ -26,8 +26,8 @@
 import python_test.containers.thrift_mutable_types as mutable_containers_types
 import python_test.containers.thrift_types as immutable_containers_types
 
-import python_test.maps.thrift_mutable_types as immutable_maps_types
-import python_test.maps.thrift_types as mutable_maps_types
+import python_test.maps.thrift_mutable_types as mutable_maps_types
+import python_test.maps.thrift_types as immutable_maps_types
 
 from folly.iobuf import IOBuf
 
@@ -53,6 +53,15 @@ class MyStringEnum(str, Enum):
     test = "test"
 
 
+class ImmutableMapTests(unittest.TestCase):
+    def test_hashability(self) -> None:
+        hash(immutable_maps_types.StrI32ListMap())
+        x = immutable_maps_types.StrStrIntListMapMap(
+            {"foo": immutable_maps_types.StrI32ListMap()}
+        )
+        hash(x["foo"])
+
+
 @parameterized_class(
     ("containers_types", "maps_types"),
     [
@@ -84,6 +93,9 @@ def setUp(self) -> None:
         self.Foo: Type[FooType] = self.containers_types.Foo
         self.Maps: Type[MapsType] = self.containers_types.Maps
         self.Color: Type[ColorType] = self.containers_types.Color
+        self.is_mutable_run: bool = self.containers_types.__name__.endswith(
+            "thrift_mutable_types"
+        )
 
     def test_recursive_const_map(self) -> None:
         self.assertEqual(self.LocationMap[1][1], 1)
@@ -163,14 +175,6 @@ def test_mixed_construction(self) -> None:
             self.StrStrIntListMapMap(px)
         self.assertNotIn("bar", cx)
 
-    def test_hashability(self) -> None:
-        # Mutable types do not support hashing
-        # pyre-ignore[16]: has no attribute `lists_types`
-        if self.maps_types.__name__.endswith("immutable_types"):
-            hash(self.StrI32ListMap())
-            x = self.StrStrIntListMapMap({"foo": self.StrI32ListMap()})
-            hash(x["foo"])
-
     def test_equality(self) -> None:
         x = self.StrIntMap({"foo": 5, "bar": 4})
         y = self.StrIntMap({"foo": 4, "bar": 5})
@@ -198,9 +202,6 @@ def test_struct_in_map(self) -> None:
         self.assertNotEqual(a, c)
 
     def test_struct_with_map_fields(self) -> None:
-        # pyre-ignore[16]: has no attribute `lists_types`
-        is_immutable = self.maps_types.__name__.endswith("immutable_types")
-
         s = self.Maps(
             boolMap={True: True, False: False},
             byteMap={1: 1, 2: 2, 3: 3},
@@ -212,12 +213,12 @@ def test_struct_with_map_fields(self) -> None:
             binaryMap={b"foo": b"foo", b"bar": b"bar"},
             iobufMap={IOBuf(b"foo"): IOBuf(b"foo"), IOBuf(b"bar"): IOBuf(b"bar")},
             structMap=(
-                {
+                {}
+                if self.is_mutable_run
+                else {
                     self.Foo(value=1): self.Foo(value=1),
                     self.Foo(value=2): self.Foo(value=2),
                 }
-                if is_immutable
-                else {}
             ),
         )
         self.assertEqual(s.boolMap, {True: True, False: False})
@@ -231,7 +232,7 @@ def test_struct_with_map_fields(self) -> None:
         self.assertEqual(
             s.iobufMap, {IOBuf(b"foo"): IOBuf(b"foo"), IOBuf(b"bar"): IOBuf(b"bar")}
         )
-        if is_immutable:
+        if not self.is_mutable_run:
             self.assertEqual(
                 s.structMap,
                 {

thrift/lib/python/test/refs.py

@@ -43,6 +43,9 @@ def setUp(self) -> None:
         """
         # pyre-ignore[16]: has no attribute `sets_types`
         self.ComplexRef: Type[ComplexRefType] = self.test_types.ComplexRef
+        self.is_mutable_run: bool = self.test_types.__name__.endswith(
+            "thrift_mutable_types"
+        )
 
     def test_create_default(self) -> None:
         x = self.ComplexRef()
@@ -71,17 +74,16 @@ def test_list(self) -> None:
         self.assertEqual(x.list_recursive_ref, (bar, baz))
 
     def test_set(self) -> None:
-        # pyre-ignore[16]: has no attribute `test_types`
-        is_immutable = self.test_types.__name__.endswith("immutable_types")
-
         bar, baz = self.ComplexRef(name="bar"), self.ComplexRef(name="baz")
         x = self.ComplexRef(
             name="foo",
             set_basetype_ref={1, 2, 3},
-            set_recursive_ref={bar, baz} if is_immutable else set(),
+            set_recursive_ref=set() if self.is_mutable_run else {bar, baz},
         )
         self.assertEqual(x.set_basetype_ref, {1, 2, 3})
-        self.assertEqual(x.set_recursive_ref, {bar, baz} if is_immutable else set())
+        self.assertEqual(
+            x.set_recursive_ref, set() if self.is_mutable_run else {bar, baz}
+        )
 
     def test_map(self) -> None:
         bar, baz = self.ComplexRef(name="bar"), self.ComplexRef(name="baz")
@@ -99,14 +101,14 @@ def test_shared_ref(self) -> None:
         self.assertEqual(x.list_shared_ref, (bar, baz))
 
     def test_const_shared_ref(self) -> None:
-        # pyre-ignore[16]: has no attribute `test_types`
-        is_immutable = self.test_types.__name__.endswith("immutable_types")
-
         bar, baz = self.ComplexRef(name="bar"), self.ComplexRef(name="baz")
         x = self.ComplexRef(
-            name="foo", set_const_shared_ref={bar, baz} if is_immutable else set()
+            name="foo",
+            set_const_shared_ref=set() if self.is_mutable_run else {bar, baz},
+        )
+        self.assertEqual(
+            x.set_const_shared_ref, set() if self.is_mutable_run else {bar, baz}
         )
-        self.assertEqual(x.set_const_shared_ref, {bar, baz} if is_immutable else set())
 
     def test_recursive(self) -> None:
         bar = self.ComplexRef(name="bar")

thrift/lib/python/test/sets.py

@@ -25,8 +25,8 @@
 import python_test.containers.thrift_mutable_types as mutable_containers_types
 import python_test.containers.thrift_types as immutable_containers_types
 
-import python_test.sets.thrift_mutable_types as immutable_sets_types
-import python_test.sets.thrift_types as mutable_sets_types
+import python_test.sets.thrift_mutable_types as mutable_sets_types
+import python_test.sets.thrift_types as immutable_sets_types
 
 from folly.iobuf import IOBuf
 
@@ -61,6 +61,9 @@ def setUp(self) -> None:
         self.Foo: Type[Foo] = self.containers_types.Foo
         self.Sets: Type[Sets] = self.containers_types.Sets
         self.Color: Type[Color] = self.containers_types.Color
+        self.is_mutable_run: bool = self.containers_types.__name__.endswith(
+            "thrift_mutable_types"
+        )
 
     def test_and(self) -> None:
         x = self.SetI32({1, 3, 4, 5})
@@ -184,9 +187,6 @@ def test_create_untruthy_set(self) -> None:
         self.assertEqual(Sets(i32Set=Untruthy(5)).i32Set, set(range(5)))
 
     def test_struct_with_set_fields(self) -> None:
-        # pyre-ignore[16]: has no attribute `lists_types`
-        is_immutable = self.sets_types.__name__.endswith("immutable_types")
-
         s = self.Sets(
             boolSet={True, False},
             byteSet={1, 2, 3},
@@ -198,7 +198,7 @@ def test_struct_with_set_fields(self) -> None:
             binarySet={b"foo", b"bar"},
             iobufSet={IOBuf(b"foo"), IOBuf(b"bar")},
             structSet=(
-                {self.Foo(value=1), self.Foo(value=2)} if is_immutable else set()
+                set() if self.is_mutable_run else {self.Foo(value=1), self.Foo(value=2)}
             ),
         )
         self.assertEqual(s.boolSet, {True, False})
@@ -210,7 +210,7 @@ def test_struct_with_set_fields(self) -> None:
         self.assertEqual(s.stringSet, {"foo", "bar"})
         self.assertEqual(s.binarySet, {b"foo", b"bar"})
         self.assertEqual(s.iobufSet, {IOBuf(b"foo"), IOBuf(b"bar")})
-        if is_immutable:
+        if not self.is_mutable_run:
             self.assertEqual(s.structSet, {Foo(value=1), Foo(value=2)})
             # test reaccess the set element won't have to recreating the struct
             structs1 = list(s.structSet)