Пример #1
0
def test_reference_resolver_can_be_set_using_setter(schema):
    def resolve_result_type(*_):  # pylint: disable=unused-variable
        return "Wine"

    interface = FederatedInterfaceType("Product")
    interface.set_type_resolver(resolve_result_type)
    interface.reference_resolver(lambda *_: {"name": "Malbec"})
    interface.bind_to_schema(schema)

    obj = FederatedObjectType("Wine")
    obj.bind_to_schema(schema)

    result = graphql_sync(
        schema,
        """
            query GetEntities($representations: [_Any!]!) {
                _entities(representations: $representations) {
                    ... on Wine {
                        name
                    }
                }
            }
        """,
        variable_values={"representations": [{"__typename": "Wine", "upc": 1}]},
    )

    assert result.errors is None
    assert result.data["_entities"] == [{"name": "Malbec"}]
Пример #2
0
def test_federated_schema_not_mark_type_with_no_keys():
    type_defs = """
        type Query

        type Product {
            upc: String!
            name: String
            price: Int
        }
    """

    product = FederatedObjectType("Product")
    schema = make_federated_schema(type_defs, product)

    assert sic(print_object(schema.get_type("Product"))) == sic(
        """
            type Product {
                upc: String!
                name: String
                price: Int
            }
        """
    )

    assert schema.get_type("_Entity") is None
Пример #3
0
def test_federated_schema_mark_type_with_key_split_type_defs():
    query_type_defs = """
        type Query
    """

    product_type_defs = """
        type Product @key(fields: "upc") {
            upc: String!
            name: String
            price: Int
        }
    """

    product = FederatedObjectType("Product")
    schema = make_federated_schema(
        [query_type_defs, product_type_defs],
        product,
    )

    assert sic(print_object(schema.get_type("Product"))) == sic("""
            type Product {
                upc: String!
                name: String
                price: Int
            }
        """)

    assert sic(print_union(schema.get_type("_Entity"))) == sic("""
            union _Entity = Product
        """)
Пример #4
0
def test_federated_schema_mark_type_with_multiple_keys():
    type_defs = """
        type Query

        type Product @key(fields: "upc sku") {
            upc: String!
            sku: String!
            name: String
            price: Int
        }
    """

    product = FederatedObjectType("Product")
    schema = make_federated_schema(type_defs, product)

    assert sic(print_object(schema.get_type("Product"))) == sic("""
        type Product {
            upc: String!
            sku: String!
            name: String
            price: Int
        }
    """)

    assert sic(print_union(schema.get_type("_Entity"))) == sic("""
            union _Entity = Product
        """)
Пример #5
0
def test_reference_resolver_can_be_set_using_setter(schema):
    obj = FederatedObjectType("Product")
    obj.reference_resolver(lambda *_: {"name": "Malbec"})
    obj.bind_to_schema(schema)

    result = graphql_sync(
        schema,
        """
            query GetEntities($representations: [_Any!]!) {
                _entities(representations: $representations) {
                    ... on Product {
                        name
                    }
                }
            }
        """,
        variable_values={
            "representations": [{
                "__typename": "Product",
                "upc": 1
            }]
        },
    )

    assert result.errors is None
    assert result.data["_entities"] == [{"name": "Malbec"}]
Пример #6
0
def test_federated_schema_execute_reference_resolver_that_returns_none():
    type_defs = """
        type Query {
            rootField: String
        }

        type Product @key(fields: "upc") {
            upc: Int
            name: String
        }
    """

    product = FederatedObjectType("Product")

    @product.reference_resolver()
    def product_reference_resolver(_obj, _info, reference):
        assert reference["upc"] == 1
        # return None

    schema = make_federated_schema(type_defs, product)

    result = graphql_sync(
        schema,
        """
            query GetEntities($representations: [_Any!]!) {
                _entities(representations: $representations) {
                    ... on Product {
                        __typename
                        name
                    }
                }
            }
        """,
        variable_values={
            "representations": [
                {
                    "__typename": "Product",
                    "upc": 1,
                },
            ],
        },
    )

    assert result.errors is None
    assert result.data["_entities"][0] is None
Пример #7
0
def test_federated_schema_type_with_multiple_keys():
    type_defs = """
        type Query
        type Product @key(fields: "upc") @key(fields: "sku") {
            upc: String!
            sku: String!
            price: String
        }
    """
    product = FederatedObjectType("Product")
    schema = make_federated_schema(type_defs)

    assert sic(print_object(schema.get_type("Product"))) == sic("""
            type Product {
                upc: String!
                sku: String!
                price: String
            }
        """)
Пример #8
0
async def test_federated_schema_execute_async_reference_resolver():
    type_defs = """
        type Query {
            rootField: String
        }

        type Product @key(fields: "upc") {
            upc: Int
            name: String
        }

        type User @key(fields: "id") {
            firstName: String
        }
    """

    product = FederatedObjectType("Product")

    @product.reference_resolver()
    async def product_reference_resolver(_obj, _info, reference):
        assert reference["upc"] == 1
        return {"name": "Apollo Gateway"}

    user = FederatedObjectType("User")

    @user.reference_resolver()
    async def user_reference_resolver(_obj, _info, reference):
        assert reference["id"] == 1
        return Mock(firstName="James")

    schema = make_federated_schema(type_defs, [product, user])

    result = await graphql(
        schema,
        """
            query GetEntities($representations: [_Any!]!) {
                _entities(representations: $representations) {
                    ... on Product {
                        __typename
                        name
                    }
                    ... on User {
                        __typename
                        firstName
                    }
                }
            }
        """,
        variable_values={
            "representations": [
                {
                    "__typename": "Product",
                    "upc": 1,
                },
                {
                    "__typename": "User",
                    "id": 1,
                },
            ],
        },
    )

    assert result.errors is None
    assert result.data["_entities"][0]["__typename"] == "Product"
    assert result.data["_entities"][0]["name"] == "Apollo Gateway"
    assert result.data["_entities"][1]["__typename"] == "User"
    assert result.data["_entities"][1]["firstName"] == "James"
Пример #9
0
from ariadne.contrib.federation import FederatedObjectType
from doctors.models import Doctor

doctor_federated_object = FederatedObjectType("Doctor")


@doctor_federated_object.reference_resolver
def get_doctor_by_uid(_, _info, representation):
    return Doctor.objects.get(uid=representation.get("uid"))


@doctor_federated_object.field("uid")
def resolve_id(obj, *_):
    return obj.uid


@doctor_federated_object.field("indexingId")
def resolve_indexing_id(obj, *_):
    return obj.indexing_id


@doctor_federated_object.field("first_name")
def resolve_first_name(obj, *_):
    return obj.first_name


@doctor_federated_object.field("last_name")
def resolve_last_name(obj, *_):
    return obj.last_name

Пример #10
0
import logging

from ariadne.contrib.federation import FederatedObjectType
from diagnosis.models import Diagnosis

patient_federated_type = FederatedObjectType("Patient")


class Patient:
    def __init__(self, uid):
        self.uid = uid


@patient_federated_type.reference_resolver
def get_patient_by_uid(_, _info, representation):
    try:
        uid = representation.get("uid")
        return Patient(uid)
    except Exception as error:
        logging.error(error)
        return None


@patient_federated_type.field("uid")
def resolve_uid(obj, *_):
    try:
        if isinstance(obj, dict):
            return obj.get("uid")
        if isinstance(obj, Patient):
            return obj.uid
    except Exception as error:
Пример #11
0
    PermitEmailType,
    RefundEmailType,
    send_permit_email,
    send_refund_email,
)
from .services.traficom import Traficom
from .talpa.order import TalpaOrderManager

logger = logging.getLogger("db")

helsinki_profile_query = load_schema_from_path(
    BASE_DIR / "parking_permits" / "schema" / "helsinki_profile.graphql")

query = QueryType()
mutation = MutationType()
address_node = FederatedObjectType("AddressNode")
profile_node = FederatedObjectType("ProfileNode")

schema_bindables = [
    query, mutation, address_node, snake_case_fallback_resolvers
]

ACTIVE_PERMIT_STATUSES = [
    ParkingPermitStatus.DRAFT,
    ParkingPermitStatus.VALID,
]


@query.field("getPermits")
@is_authenticated
@convert_kwargs_to_snake_case
from ariadne.contrib.federation import FederatedObjectType

from diagnosis.models import Diagnosis

diagnosis_federated_object = FederatedObjectType("Diagnosis")
patient_federated_object = FederatedObjectType("Patient")
doctor_federated_object = FederatedObjectType("Doctor")


@diagnosis_federated_object.resolve_reference
def get_diagnosis_by_uid(representation):
    return Diagnosis.objects.get(id=representation.get("id"))


@diagnosis_federated_object.field("uid")
def resolve_id(obj, *_):
    return obj.uid


@diagnosis_federated_object.field("indexingId")
def resolve_indexing_id(obj, *_):
    return obj.indexing_id


@diagnosis_federated_object.field("diagnosis")
def resolve_diagnosis(obj, *_):
    return obj.diagnosis


@diagnosis_federated_object.field("consulting_doctor")
def resolve_consulting_doctor(obj, *_):
Пример #13
0
    product: Product @provides(fields: "upc")
  }

  type User @key(fields: "email") @extends {
    email: String! @external
    reviews: [Review]
  }

  type Product @key(fields: "upc") @extends {
    upc: String! @external
    reviews: [Review]
  }
"""

query = QueryType()
review = FederatedObjectType("Review")
user = FederatedObjectType("User")
product = FederatedObjectType("Product")


@review.reference_resolver
def resolve_reviews_reference(_, _info, representation):
    return get_review_by_id(representation["id"])


@review.field("author")
def resolve_review_author(review, *_):
    return {"__typename": "User", "email": review["user"]["email"]}


@review.field("product")
Пример #14
0
from ariadne.asgi import GraphQL
from ariadne import (load_schema_from_path,
                     make_executable_schema, MutationType, QueryType)
from ariadne.contrib.federation import (
    FederatedObjectType, make_federated_schema)
from . import resolvers

# load schema file
type_defs = load_schema_from_path("riderequests/schema.graphql")

mutation = MutationType()
query = QueryType()
riderequest = FederatedObjectType("RideRequest")

mutation.set_field("requestRide", resolvers.resolve_request_ride)
query.set_field("allRideRequests", resolvers.resolve_all_ride_request)
query.set_field("request", resolvers.resolve_ride_request)
riderequest.set_field("passenger", resolvers.resolve_riderequest_passenger)
riderequest.set_field("ride", resolvers.resolve_riderequest_ride)

# bind schema(queries and mutation) to the respective resolvers
schema = make_federated_schema(type_defs, [riderequest, query, mutation])
application = GraphQL(schema, debug=True)
Пример #15
0
from ariadne.contrib.federation import FederatedObjectType, make_federated_schema

query_type = QueryType()


class User:
    id = "45AOE5U6AU452E5A8"
    userId = "UHOH45"
    email = "*****@*****.**"
    firstName = "Brent"
    lastName = "Weeks"


@query_type.field('me')
def resolve_me(*_):
    return User()


user_type = FederatedObjectType('User')


@user_type.reference_resolver
def resolve_reference(_, _info, representation):
    return User()


type_defs = load_schema_from_path('schema.graphql')
schema = make_federated_schema(type_defs, query_type, user_type)

app = GraphQL(schema, debug=True)
Пример #16
0
from ariadne.contrib.federation import FederatedObjectType
from diagnosis.models import Diagnosis

diagnosis_federated_object = FederatedObjectType("Diagnosis")


@diagnosis_federated_object.reference_resolver
def get_diagnosis_by_uid(_, _info, representation):
    return Diagnosis.objects.get(uid=representation.get("uid"))


@diagnosis_federated_object.field("uid")
def resolve_id(obj, *_):
    return obj.uid


@diagnosis_federated_object.field("indexingId")
def resolve_indexing_id(obj, *_):
    return obj.indexing_id


@diagnosis_federated_object.field("diagnosis")
def resolve_diagnosis(obj, *_):
    return obj.diagnosis


@diagnosis_federated_object.field("consulting_doctor")
def resolve_consulting_doctor(obj, *_):
    return {"uid": obj.consulting_doctor}

Пример #17
0
from ariadne.contrib.federation import FederatedObjectType
from patient.models import Patient

patient_federated_object = FederatedObjectType("Patient")


@patient_federated_object.reference_resolver
def get_patient_by_uid(_, _info, representation):
    return Patient.objects.get(uid=representation.get("uid"))


@patient_federated_object.field("uid")
def resolve_id(obj, *_):
    return obj.uid


@patient_federated_object.field("indexingId")
def resolve_indexing_id(obj, *_):
    return obj.indexing_id


@patient_federated_object.field("first_name")
def resolve_first_name(obj, *_):
    return obj.first_name


@patient_federated_object.field("last_name")
def resolve_last_name(obj, *_):
    return obj.last_name

Пример #18
0
from ariadne.contrib.federation import FederatedObjectType

from user.models.user import User

user = FederatedObjectType("User")


@user.reference_resolver
def resolve_user_reference(_, _info, representation):
    print(representation)
    return User()
Пример #19
0
import logging

from ariadne.contrib.federation import FederatedObjectType
from diagnosis.models import Diagnosis

doctor_federated_type = FederatedObjectType("Doctor")


class Doctor:
    def __init__(self, uid):
        self.uid = uid


@doctor_federated_type.reference_resolver
def get_doctor_by_uid(_, _info, representation):
    try:
        uid = representation.get("uid")
        return Doctor(uid)
    except Exception as error:
        logging.error(error)
        return None


@doctor_federated_type.field("uid")
def resolve_uid(obj, *_):
    try:
        if isinstance(obj, dict):
            return obj.get("uid")
        if isinstance(obj, Doctor):
            return obj.uid
    except Exception as error:
Пример #20
0
from ariadne import QueryType
from ariadne.asgi import GraphQL
from ariadne.contrib.federation import FederatedObjectType, make_federated_schema

type_defs = """
  type Query {
    me: Book
  }

  type Book @key(fields: "title") {
    id: ID!
    title: String
    author: String!
  }
"""

query = QueryType()
user = FederatedObjectType("Book")

# @user.reference_resolver
# def resolve_user_reference(_, _info, representation):
#     return get_user_by_email(representation.get("email"))

schema = make_federated_schema(type_defs, [query, user])
application = GraphQL(schema)
Пример #21
0
def test_bind_federated_object_type_to_undefined_type_raises_error(schema):
    obj = FederatedObjectType("Test")
    with pytest.raises(ValueError):
        obj.bind_to_schema(schema)
Пример #22
0
def test_bind_federated_object_type_to_invalid_type_raises_error(schema):
    obj = FederatedObjectType("Date")
    with pytest.raises(ValueError):
        obj.bind_to_schema(schema)
Пример #23
0
from ariadne.contrib.federation import FederatedObjectType

from product.models.product import Product

product = FederatedObjectType("Product")


@product.reference_resolver
def resolve_product_reference(*_, representation):
    print(representation)
    return Product(upc="id", name="product", price=10, weight=12)
Пример #24
0
from random import choice
from string import ascii_letters

from ariadne.contrib.federation import FederatedObjectType

from review.models.review import Review

review = FederatedObjectType("Review")


@review.reference_resolver
def resolve_reviews_reference(_, _info, representation):
    print(representation)
    return Review(id=representation["id"], body=choice(ascii_letters))