package graphql.schema.idl

import graphql.schema.GraphQLEnumType

import graphql.schema.GraphQLFieldDefinition

import graphql.schema.GraphQLFieldsContainer

import graphql.schema.GraphQLInputObjectType

import graphql.schema.GraphQLInterfaceType

import graphql.schema.GraphQLList

import graphql.schema.GraphQLNonNull

import graphql.schema.GraphQLObjectType

import graphql.schema.GraphQLSchema

import graphql.schema.GraphQLType

import graphql.schema.GraphQLUnionType

import graphql.schema.idl.errors.NotAnInputTypeError

import graphql.schema.idl.errors.NotAnOutputTypeError

import graphql.schema.visibility.GraphqlFieldVisibility

import spock.lang.Specification

import java.util.function.UnaryOperator

import static graphql.Scalars.GraphQLBoolean

import static graphql.Scalars.GraphQLInt

import static graphql.Scalars.GraphQLString

import static graphql.TestUtil.schema

class SchemaGeneratorTest extends Specification {

GraphQLType unwrap1Layer(GraphQLType type) {

if (type instanceof GraphQLNonNull) {

type = (type as GraphQLNonNull).wrappedType

} else if (type instanceof GraphQLList) {

type = (type as GraphQLList).wrappedType

}

type

}

GraphQLType unwrap(GraphQLType type) {

while (true) {

if (type instanceof GraphQLNonNull) {

type = (type as GraphQLNonNull).wrappedType

} else if (type instanceof GraphQLList) {

type = (type as GraphQLList).wrappedType

} else {

break

}

}

type

}

void commonSchemaAsserts(GraphQLSchema schema) {

assert schema.getQueryType().name == "Query"

assert schema.getMutationType().name == "Mutation"

// type Query {

// posts: [Post]

// author(id: Int!): Author

// }

def postField = schema.getQueryType().getFieldDefinition("posts")

assert postField.type instanceof GraphQLList

assert unwrap(postField.type).name == "Post"

def authorField = schema.getQueryType().getFieldDefinition("author")

assert authorField.type.name == "Author"

assert authorField.description == " author query must receive an id as argument"

assert authorField.arguments.get(0).name == "id"

assert authorField.arguments.get(0).type instanceof GraphQLNonNull

assert unwrap(authorField.arguments.get(0).type).name == "Int"

//type Post {

// id: Int!

// title: String

// votes: Int

// author: Author!

//}

GraphQLObjectType postType = schema.getType("Post") as GraphQLObjectType

assert postType.name == "Post"

assert postType.getDefinition().getName() == "Post"

//

// make sure that wrapped non null fields stay that way. we had a bug where decorated types lost their decoration

assert postType.getFieldDefinition("author").type instanceof GraphQLNonNull

assert (postType.getFieldDefinition("author").type as GraphQLNonNull).wrappedType.name == "Author"

assert postType.getFieldDefinition("author").getDefinition().getName() == "author"

//type Author {

// # the ! means that every author object _must_ have an id

// id: Int!

// firstName: String

// lastName: String

// # the list of Posts by this author

// posts: [Post]!

//}

GraphQLObjectType authorType = schema.getType("Author") as GraphQLObjectType

assert authorType.name == "Author"

//

// make sure that wrapped list fields stay that way. we had a bug where decorated types lost their decoration

assert authorType.getFieldDefinition("posts").type instanceof GraphQLNonNull

def wrappedList = (authorType.getFieldDefinition("posts").type as GraphQLNonNull).wrappedType

assert wrappedList instanceof GraphQLList

assert (wrappedList as GraphQLList).wrappedType.name == "Post"

//

// input PostUpVote {

// postId: ID

// votes : Int

// }

// type Mutation {

// upvotePost (

// upvoteArgs : PostUpVote!

// ) : Post

// }

def upvotePostField = schema.getMutationType().getFieldDefinition("upvotePost")

def upvotePostFieldArg = upvotePostField.arguments.get(0)

assert upvotePostFieldArg.name == "upvoteArgs"

assert upvotePostFieldArg.type instanceof GraphQLNonNull

assert unwrap(upvotePostFieldArg.type).name == "PostUpVote"

def inputObjectType = unwrap(upvotePostFieldArg.type) as GraphQLInputObjectType

assert inputObjectType.getDefinition().getName() == "PostUpVote"

assert inputObjectType.getField("postId").type.name == "ID"

assert inputObjectType.getField("votes").type.name == "Int"

assert inputObjectType.getField("votes").getDefinition().name == "votes"

def queryType = schema.getQueryType()

assert queryType.description == " the schema allows the following query\n to be made"

}

def "test simple schema generate"() {

def schemaSpec = """

def schema = schema(schemaSpec)

expect:

commonSchemaAsserts(schema)

}

def "schema can come from multiple sources and be bound together"() {

def schemaSpec1 = """

def schemaSpec2 = """

def schemaSpec3 = """

def typeRegistry1 = new SchemaParser().parse(schemaSpec1)

def typeRegistry2 = new SchemaParser().parse(schemaSpec2)

def typeRegistry3 = new SchemaParser().parse(schemaSpec3)

typeRegistry1.merge(typeRegistry2).merge(typeRegistry3)

def schema = new SchemaGenerator().makeExecutableSchema(typeRegistry1, RuntimeWiring.newRuntimeWiring().build())

expect:

commonSchemaAsserts(schema)

}

def "union type: union member used two times "() {

def spec = """

def schema = schema(spec)

expect:

def foobar = schema.getQueryType().getFieldDefinition("foobar")

foobar.type instanceof GraphQLUnionType

def types = ((GraphQLUnionType) foobar.type).getTypes()

types.size() == 2

types[0] instanceof GraphQLObjectType

types[1] instanceof GraphQLObjectType

types[0].name == "Foo"

types[1].name == "Bar"

}

def "union type: union members only used once"() {

def spec = """

def schema = schema(spec)

expect:

def foobar = schema.getQueryType().getFieldDefinition("foobar")

foobar.type instanceof GraphQLUnionType

def types = ((GraphQLUnionType) foobar.type).getTypes()

types.size() == 2

types[0] instanceof GraphQLObjectType

types[1] instanceof GraphQLObjectType

types[0].name == "Foo"

types[1].name == "Bar"

}

def "union type: union declared before members"() {

def spec = """

def schema = schema(spec)

expect:

def foobar = schema.getQueryType().getFieldDefinition("foobar")

foobar.type instanceof GraphQLUnionType

def types = ((GraphQLUnionType) foobar.type).getTypes()

types.size() == 2

types[0] instanceof GraphQLObjectType

types[1] instanceof GraphQLObjectType

types[0].name == "Foo"

types[1].name == "Bar"

}

def "union type: recursive definition via union type: Foo -> FooOrBar -> Foo "() {

def spec = """

def schema = schema(spec)

expect:

def foobar = schema.getQueryType().getFieldDefinition("foobar")

foobar.type instanceof GraphQLUnionType

def unionType = foobar.type as GraphQLUnionType

unionType.getName() == "FooOrBar"

unionType.getDefinition().getName() == "FooOrBar"

def types = unionType.getTypes()

types.size() == 2

types[0] instanceof GraphQLObjectType

types[1] instanceof GraphQLObjectType

types[0].name == "Foo"

types[1].name == "Bar"

}

def "enum types are handled"() {

def spec = """

def schema = schema(spec)

expect:

def rgbField = schema.getQueryType().getFieldDefinition("rgb")

rgbField.type instanceof GraphQLEnumType

def enumType = rgbField.type as GraphQLEnumType

enumType.getName() == "RGB"

enumType.getDefinition().getName() == "RGB"

enumType.values.get(0).getValue() == "RED"

enumType.values.get(1).getValue() == "GREEN"

enumType.values.get(2).getValue() == "BLUE"

}

def "interface types are handled"() {

def spec = """

def schema = schema(spec)

expect:

def interfaceType = schema.queryType.interfaces[0] as GraphQLInterfaceType

interfaceType.name == "Foo"

interfaceType.getDefinition().getName() == "Foo"

schema.queryType.fieldDefinitions[0].name == "is_foo"

schema.queryType.fieldDefinitions[0].type.name == "Boolean"

schema.queryType.fieldDefinitions[1].name == "is_bar"

schema.queryType.fieldDefinitions[1].type.name == "Boolean"

}

def "type extensions can be specified multiple times #406"() {

def spec = """

def schema = schema(spec)

expect:

GraphQLObjectType type = schema.getType("BaseType") as GraphQLObjectType

type.fieldDefinitions.size() == 6

type.fieldDefinitions[0].name == "baseField"

type.fieldDefinitions[0].type.name == "String"

type.fieldDefinitions[1].name == "extraField1"

type.fieldDefinitions[1].type.name == "String"

type.fieldDefinitions[2].name == "extraField2"

type.fieldDefinitions[2].type.name == "Int"

type.fieldDefinitions[3].name == "extraField3"

type.fieldDefinitions[3].type.name == "ID"

type.fieldDefinitions[4].name == "extraField4"

type.fieldDefinitions[4].type.name == "Boolean"

type.fieldDefinitions[5].name == "extraField5"

type.fieldDefinitions[5].type instanceof GraphQLNonNull

def interfaces = type.getInterfaces()

interfaces.size() == 3

interfaces[0].name == "Interface1"

interfaces[1].name == "Interface2"

interfaces[2].name == "Interface3"

}

def "read me type example makes sense"() {

def spec = """

def schema = schema(spec)

expect:

GraphQLObjectType type = schema.getQueryType()

type.name == "Human"

type.fieldDefinitions[0].name == "id"

type.fieldDefinitions[1].name == "name"

type.fieldDefinitions[2].name == "friends"

type.fieldDefinitions[3].name == "appearsIn"

type.fieldDefinitions[4].name == "homePlanet"

type.interfaces.size() == 1

type.interfaces[0].name == "Character"

}

def "Type used as inputType should throw appropriate error #425"() {

when:

def spec = """

schema(spec)

then:

def err = thrown(NotAnInputTypeError.class)

err.message == "expected InputType, but found CharacterInput type [@11:13]"

}

def "InputType used as type should throw appropriate error #425"() {

when:

def spec = """

schema(spec)

then:

def err = thrown(NotAnOutputTypeError.class)

err.message == "expected OutputType, but found CharacterInput type [@11:13]"

}

def "schema with subscription"() {

given:

def spec = """

when:

def schema = schema(spec)

then:

schema.getSubscriptionType().name == "Subscription"

}

def "comments are used as descriptions"() {

given:

def spec = """

when:

def schema = schema(spec)

then:

schema.getQueryType().description == "description 1\n description 2"

schema.getQueryType().getFieldDefinition("foo").description == " description 3"

((GraphQLUnionType) schema.getType("Union")).description == " description 4"

((GraphQLInterfaceType) schema.getType("Interface")).description == " description 5"

((GraphQLInterfaceType) schema.getType("Interface")).getFieldDefinition("foo").description == " interface field"

((GraphQLInputObjectType) schema.getType("Input")).description == " description 6 "

((GraphQLInputObjectType) schema.getType("Input")).getFieldDefinition("foo").description == " input field"

((GraphQLEnumType) schema.getType("Enum")).description == " description 7"

((GraphQLEnumType) schema.getType("Enum")).getValue("FOO").description == " enum value"

}

def "comments are separated from descriptions with empty lines"() {

given:

def spec = """

when:

def schema = schema(spec)

then:

schema.getQueryType().description == " description 1\n description 2"

schema.getQueryType().getFieldDefinition("foo").description == " description 3\n description 4"

}

enum ExampleEnum {

A,

B,

C

}

def "static enum values provider"() {

given:

def spec = """

def enumValuesProvider = new NaturalEnumValuesProvider<ExampleEnum>(ExampleEnum.class)

when:

def wiring = RuntimeWiring.newRuntimeWiring()

.type("Enum", { TypeRuntimeWiring.Builder it -> it.enumValues(enumValuesProvider) } as UnaryOperator)

.build()

def schema = schema(spec, wiring)

GraphQLEnumType enumType = schema.getType("Enum") as GraphQLEnumType

then:

enumType.getValue("A").value == ExampleEnum.A

enumType.getValue("B").value == ExampleEnum.B

enumType.getValue("C").value == ExampleEnum.C

}

def "enum with no values provider: value is the name"() {

given:

def spec = """

when:

def schema = schema(spec)

GraphQLEnumType enumType = schema.getType("Enum") as GraphQLEnumType

then:

enumType.getValue("A").value == "A"

enumType.getValue("B").value == "B"

enumType.getValue("C").value == "C"

}

def "deprecated directive is supported"() {

given:

def spec = """

when:

def wiring = RuntimeWiring.newRuntimeWiring()

.build()

def schema = schema(spec, wiring)

GraphQLEnumType enumType = schema.getType("Enum") as GraphQLEnumType

GraphQLObjectType queryType = schema.getType("Query") as GraphQLObjectType

then:

enumType.getValue("foo").getDeprecationReason() == "foo reason"

enumType.getValue("bar").getDeprecationReason() == "No longer supported" // default according to spec

!enumType.getValue("baz").isDeprecated()

queryType.getFieldDefinition("foo").getDeprecationReason() == "foo reason"

queryType.getFieldDefinition("bar").getDeprecationReason() == "No longer supported" // default according to spec

!queryType.getFieldDefinition("baz").isDeprecated()

}

def "schema is optional if there is a type called Query"() {

def spec = """

def schema = schema(spec)

expect:

schema != null

schema.getQueryType() != null

schema.getMutationType() == null

schema.getSubscriptionType() == null

schema.getQueryType().getFieldDefinition("field").getType() == GraphQLString

}

def "schema is optional if there is a type called Query while Mutation and Subscription will be found"() {

def spec = """

def schema = schema(spec)

expect:

schema != null

schema.getQueryType() != null

schema.getMutationType() != null

schema.getSubscriptionType() != null

schema.getQueryType().getFieldDefinition("field").getType() == GraphQLString

schema.getMutationType().getFieldDefinition("field").getType() == GraphQLInt

schema.getSubscriptionType().getFieldDefinition("field").getType() == GraphQLBoolean

}

def "builds additional types not referenced from schema top level"() {

def spec = """

def schema = schema(spec)

expect:

schema.getType("ReferencedA") instanceof GraphQLObjectType

schema.getType("ReferencedB") instanceof GraphQLObjectType

schema.getType("UnReferencedA") instanceof GraphQLObjectType

schema.getType("UnReferencedB") instanceof GraphQLInputObjectType

schema.getType("UnReferencedC") instanceof GraphQLInterfaceType

schema.getType("UnReferencedD") instanceof GraphQLUnionType

}

def "scalar default value is parsed"() {

def spec = """

def schema = schema(spec)

schema.getType("Query") instanceof GraphQLObjectType

GraphQLObjectType query = schema.getType("Query") as GraphQLObjectType

Object arg1 = query.getFieldDefinition("field").getArgument("arg1").defaultValue

Object arg2 = query.getFieldDefinition("field").getArgument("arg2").defaultValue

expect:

arg1 instanceof Integer

arg2 instanceof List

(arg2 as List).get(0) instanceof Integer

}

def "input object default value is parsed"() {

def spec = """