def test_basic_optional():
annotation = StrawberryAnnotation(Optional[str])
resolved = annotation.resolve()
assert isinstance(resolved, StrawberryOptional)
assert resolved.of_type is str
assert resolved == StrawberryOptional(of_type=str)
assert resolved == Optional[str]
def test_optional_of_string():
annotation = StrawberryAnnotation(Optional["bool"])
resolved = annotation.resolve()
assert isinstance(resolved, StrawberryOptional)
assert resolved.of_type is bool
assert resolved == StrawberryOptional(of_type=bool)
assert resolved == Optional[bool]
def __or__(self, other: Union[StrawberryType, type]) -> StrawberryType:
if other is None:
# Return the correct notation when using `StrawberryUnion | None`.
return StrawberryOptional(of_type=self)
# Raise an error in any other case.
# There is Work in progress to deal with more merging cases, see:
# https://github.com/strawberry-graphql/strawberry/pull/1455
raise InvalidUnionType(other)
def test_optional_list():
annotation = StrawberryAnnotation(Optional[List[bool]])
resolved = annotation.resolve()
assert isinstance(resolved, StrawberryOptional)
assert resolved.of_type == List[bool]
assert resolved == StrawberryOptional(of_type=List[bool])
assert resolved == Optional[List[bool]]
def test_optional_union_containing_a_real_union_and_unset():
annotation = StrawberryAnnotation(Union[str, int, None, _Unset])
resolved = annotation.resolve()
assert isinstance(resolved, StrawberryOptional)
assert resolved.of_type == Union[str, int]
assert resolved == StrawberryOptional(of_type=Union[str, int])
assert resolved == Optional[Union[str, int]]
def test_optional_with_unset_as_union():
annotation = StrawberryAnnotation(Union[_Unset, None, str])
resolved = annotation.resolve()
assert isinstance(resolved, StrawberryOptional)
assert resolved.of_type is str
assert resolved == StrawberryOptional(of_type=str)
assert resolved == Optional[str]
def test_string_of_optional():
namespace = {**locals(), **globals()}
annotation = StrawberryAnnotation("Optional[int]", namespace=namespace)
resolved = annotation.resolve()
assert isinstance(resolved, StrawberryOptional)
assert resolved.of_type is int
assert resolved == StrawberryOptional(of_type=int)
assert resolved == Optional[int]
def test_optional_optional():
"""Optional[Optional[...]] is squashed by Python to just Optional[...]"""
annotation = StrawberryAnnotation(Optional[Optional[bool]])
resolved = annotation.resolve()
assert isinstance(resolved, StrawberryOptional)
assert resolved.of_type is bool
assert resolved == StrawberryOptional(of_type=bool)
assert resolved == Optional[Optional[bool]]
assert resolved == Optional[bool]
def test_optional_union():
@strawberry.type
class CoolType:
foo: float
@strawberry.type
class UncoolType:
bar: bool
annotation = StrawberryAnnotation(Optional[Union[CoolType, UncoolType]])
resolved = annotation.resolve()
assert isinstance(resolved, StrawberryOptional)
assert resolved.of_type == Union[CoolType, UncoolType]
assert resolved == StrawberryOptional(of_type=Union[CoolType, UncoolType])
assert resolved == Optional[Union[CoolType, UncoolType]]
def create_optional(self, evaled_type: Any) -> StrawberryOptional:
types = evaled_type.__args__
non_optional_types = tuple(
filter(lambda x: x is not type(None), types) # noqa: E721
)
# Note that passing a single type to `Union` is equivalent to not using `Union`
# at all. This allows us to not di any checks for how many types have been
# passed as we can safely use `Union` for both optional types
# (e.g. `Optional[str]`) and optional unions (e.g.
# `Optional[Union[TypeA, TypeB]]`)
child_type = Union[non_optional_types] # type: ignore
of_type = StrawberryAnnotation(
annotation=child_type,
namespace=self.namespace,
).resolve()
return StrawberryOptional(of_type)
@strawberry.type
class TypeA:
name: str
@strawberry.type
class TypeB:
age: int
@pytest.mark.parametrize(
"types,expected_name",
[
([StrawberryList(str)], "StrListExample"),
([StrawberryList(StrawberryList(str))], "StrListListExample"),
([StrawberryOptional(StrawberryList(str))], "StrListOptionalExample"),
([StrawberryList(StrawberryOptional(str))], "StrOptionalListExample"),
([StrawberryList(Enum)], "EnumListExample"),
([StrawberryUnion("Union",
(TypeA, TypeB))], "UnionExample"), # type: ignore
([TypeA], "TypeAExample"),
([CustomInt], "CustomIntExample"),
([TypeA, TypeB], "TypeATypeBExample"),
([TypeA, LazyType["TypeB", "test_names"]
], "TypeATypeBExample"), # type: ignore
],
)
def test_name_generation(types, expected_name):
config = StrawberryConfig()
@strawberry.type