Distinguish globals/locals tests

Author: Zac-HD

hypothesis-python/src/hypothesis/strategies/_internal/core.py

@@ -1077,6 +1077,12 @@ def as_strategy(strat_or_callable, thing, final=True):
         # See https://github.com/python/cpython/pull/17214 for details.
         optional = getattr(thing, "__optional_keys__", ())
         anns = {k: from_type(v) for k, v in get_type_hints(thing).items()}
+        if (
+            (not anns)
+            and thing.__annotations__
+            and ".<locals>." in getattr(thing, "__qualname__", "")
+        ):
+            raise InvalidArgument("Failed to retrieve type annotations for local type")
         return fixed_dictionaries(  # type: ignore
             mapping={k: v for k, v in anns.items() if k not in optional},
             optional={k: v for k, v in anns.items() if k in optional},

hypothesis-python/tests/nocover/test_type_lookup_future_annotations.py

@@ -12,22 +12,37 @@
 
 from typing import TypedDict, Union
 
+import pytest
+
 from hypothesis import given, strategies as st
+from hypothesis.errors import InvalidArgument
 
+alias = Union[int, str]
 
-@given(st.data())
-def test_complex_forward_ref_in_typed_dict(data):
-    alias = Union[int, bool]
 
-    class A(TypedDict):
-        a: int
+class A(TypedDict):
+    a: int
 
-    class B(TypedDict):
-        a: A
-        b: alias
 
-    b_strategy = st.from_type(B)
-    d = data.draw(b_strategy)
+class B(TypedDict):
+    a: A
+    b: alias
+
+
+@given(st.from_type(B))
+def test_complex_forward_ref_in_typed_dict(d):
     assert isinstance(d["a"], dict)
     assert isinstance(d["a"]["a"], int)
-    assert isinstance(d["b"], (int, bool))
+    assert isinstance(d["b"], (int, str))
+
+
+def test_complex_forward_ref_in_typed_dict_local():
+    local_alias = Union[int, str]
+
+    class C(TypedDict):
+        a: A
+        b: local_alias
+
+    c_strategy = st.from_type(C)
+    with pytest.raises(InvalidArgument):
+        c_strategy.example()