def test_cyclic_import():
from .type_a import TypeA
from .type_b import TypeB
@strawberry.type
class Query:
a: TypeA
b: TypeB
assert (
print_type(Query(None, None))
== textwrap.dedent(
"""
type Query {
a: TypeA!
b: TypeB!
}
"""
).strip()
)
assert (
print_type(TypeA())
== textwrap.dedent(
"""
type TypeA {
typeB: TypeB!
}
"""
).strip()
)
assert (
print_type(TypeB())
== textwrap.dedent(
"""
type TypeB {
typeA: TypeA!
}
"""
).strip()
)
def test_optional():
@strawberry.type
class MyType:
s: Optional[str]
expected_type = """
type MyType {
s: String
}
"""
assert print_type(MyType("a")) == textwrap.dedent(expected_type).strip()
def test_recursive_type():
@strawberry.type
class MyType:
s: "MyType"
expected_type = """
type MyType {
s: MyType!
}
"""
assert print_type(MyType("a")) == textwrap.dedent(expected_type).strip()
def test_interface():
@strawberry.interface
class Node:
id: strawberry.ID
expected_type = """
interface Node {
id: ID!
}
"""
assert print_type(Node("a")) == textwrap.dedent(expected_type).strip()
def test_print_requires():
@strawberry.federation.type(keys=["upc"])
class Product:
name: str = strawberry.federation.field(requires="email")
expected_representation = """
type Product @key(fields: "upc") {
name: String! @requires(fields: "email")
}
"""
assert print_type(Product) == textwrap.dedent(
expected_representation).strip()
def test_subscription_type():
@strawberry.type
class MySub:
@strawberry.subscription
async def x(self, info) -> typing.AsyncGenerator[str, None]:
yield "Hi"
expected_type = """
type MySub {
x: String!
}
"""
assert print_type(MySub()) == textwrap.dedent(expected_type).strip()
def test_optional_default():
@strawberry.input
class MyInput:
s: Optional[str]
i: int = 0
expected_type = """
input MyInput {
s: String
i: Int! = 0
}
"""
assert print_type(MyInput("a",
1)) == textwrap.dedent(expected_type).strip()
def test_print_external():
@strawberry.federation.type(keys=["upc"])
class Product:
upc: str = strawberry.federation.field(external=True)
name: str = strawberry.federation.field(external=True)
expected_representation = """
type Product @key(fields: "upc") {
upc: String! @external
name: String! @external
}
"""
assert print_type(Product) == textwrap.dedent(
expected_representation).strip()
def test_print_provides():
@strawberry.federation.type(keys=["upc"])
class Product:
upc: str
name: typing.Optional[str]
@strawberry.federation.type(keys=["id"])
class Review:
product: Product = strawberry.federation.field(provides="name")
expected_representation = """
type Review @key(fields: "id") {
product: Product! @provides(fields: "name")
}
"""
assert print_type(Review) == textwrap.dedent(
expected_representation).strip()
def test_implementing_interface():
@strawberry.interface
class Node:
id: strawberry.ID
@strawberry.type
class Post(Node):
title: str
expected_type = """
type Post implements Node {
id: ID!
title: String!
}
"""
assert print_type(Post("a",
"abc")) == textwrap.dedent(expected_type).strip()
def test_print_extend():
@strawberry.federation.type(extend=True)
class Product:
upc: str
name: typing.Optional[str]
price: typing.Optional[int]
weight: typing.Optional[int]
expected_representation = """
extend type Product {
upc: String!
name: String
price: Int
weight: Int
}
"""
assert print_type(Product) == textwrap.dedent(
expected_representation).strip()
def test_print_type_with_key():
@strawberry.federation.type(keys=["upc"])
class Product:
upc: str
name: typing.Optional[str]
price: typing.Optional[int]
weight: typing.Optional[int]
expected_representation = """
type Product @key(fields: "upc") {
upc: String!
name: String
price: Int
weight: Int
}
"""
assert print_type(Product) == textwrap.dedent(
expected_representation).strip()
def test_simple_required_types():
@strawberry.type
class MyType:
s: str
i: int
b: bool
f: float
id: strawberry.ID
expected_type = """
type MyType {
s: String!
i: Int!
b: Boolean!
f: Float!
id: ID!
}
"""
assert (print_type(MyType(
"a", 1, True, 3.2, "123")) == textwrap.dedent(expected_type).strip())