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