Adjust TypeGuard tests to document limitations of notna/isna type narrowing

Author: gandhis1

tests/test_pandas.py

@@ -259,29 +259,56 @@ def test_isna() -> None:
     assert not check(assert_type(pd.isna(2.5), bool), bool)
     assert check(assert_type(pd.notna(2.5), bool), bool)
 
-    # Check type guard functionality
+    # Check TypeGuard type narrowing functionality
+    # TODO: Due to limitations in TypeGuard spec, the true annotations are not always viable
+    # and as a result the type narrowing does not always work as it intuitively should
+    # There is a proposal being floated for a StrictTypeGuard that will have more rigid narrowing semantics
+    # In the test cases below, a commented out assertion will be included to document the optimal test result
     nullable1 = random.choice(["value", None, pd.NA, pd.NaT])
     if pd.notna(nullable1):
         check(assert_type(nullable1, str), str)
+    if not pd.isna(nullable1):
+        # TODO: This is the true type (see comments above on the limitations of TypeGuard)
+        # check(assert_type(nullable1, str), str)
+        check(assert_type(nullable1, Union[str, NaTType, NAType, None]), str)
     if pd.isna(nullable1):
         assert_type(nullable1, Union[NaTType, NAType, None])
+    if not pd.notna(nullable1):
+        # TODO: This is the true type (see comments above on the limitations of TypeGuard)
+        # assert_type(nullable1, Union[NaTType, NAType, None])
+        assert_type(nullable1, Union[str, NaTType, NAType, None])
 
     nullable2 = random.choice([2, None])
     if pd.notna(nullable2):
         check(assert_type(nullable2, int), int)
+    if not pd.isna(nullable2):
+        # TODO: This is the true type (see comments above on the limitations of TypeGuard)
+        # check(assert_type(nullable2, int), int)
+        check(assert_type(nullable2, Union[int, None]), int)
     if pd.isna(nullable2):
-        # TODO: Due to limitations in TypeGuard spec, the true annotation is not viable at this time
-        # There is a proposal being floated for a StrictTypeGuard that will have more rigid narrowing semantics
-        # assert_type(nullable2, None)
-        assert_type(nullable2, Union[NaTType, NAType, None])
-
-    nullable3 = random.choice([2, None, pd.NA])
+        # TODO: This is the true type (see comments above on the limitations of TypeGuard)
+        # check(assert_type(nullable2, None), type(None))
+        check(assert_type(nullable2, Union[NaTType, NAType, None]), type(None))
+    if not pd.notna(nullable2):
+        # TODO: This is the true type (see comments above on the limitations of TypeGuard)
+        # check(assert_type(nullable2, None), type(None))
+        assert_type(nullable2, Union[int, NaTType, NAType, None])
+
+    nullable3 = random.choice([True, None, pd.NA])
     if pd.notna(nullable3):
-        check(assert_type(nullable3, int), int)
+        check(assert_type(nullable3, bool), bool)
+    if not pd.isna(nullable3):
+        # TODO: This is the true type (see comments above on the limitations of TypeGuard)
+        # check(assert_type(nullable3, bool), bool)
+        check(assert_type(nullable3, Union[bool, NAType, None]), bool)
     if pd.isna(nullable3):
-        # TODO: See comment above about the limitations of TypeGuard
+        # TODO: This is the true type (see comments above on the limitations of TypeGuard)
         # assert_type(nullable3, Union[NAType, None])
         assert_type(nullable3, Union[NaTType, NAType, None])
+    if not pd.notna(nullable3):
+        # TODO: This is the true type (see comments above on the limitations of TypeGuard)
+        # assert_type(nullable3, Union[NAType, None])
+        assert_type(nullable3, Union[bool, NaTType, NAType, None])
 
 
 # GH 55