introspection_test.go

package graphql

import (
	"bytes"
	"context"
	_ "embed"
	"encoding/json"
	"errors"
	"fmt"
	"net/http"
	"testing"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"github.com/vektah/gqlparser/v2"
	"github.com/vektah/gqlparser/v2/ast"
	"github.com/vektah/gqlparser/v2/formatter"
)

func TestIntrospectAPI(t *testing.T) {
	schema, err := IntrospectAPI(&mockJSONQueryer{
		JSONResult: `{
			"__schema": {
				"queryType": {
					"name": "Query"
				},
				"directives": [
					{
						"name": "deprecated",
						"args": [
							{"name": "reason"}
						]
					}
				]
			}
		}`,
	})
	assert.NoError(t, err)
	assert.Equal(t, &ast.Schema{
		Types: map[string]*ast.Definition{},
		Directives: map[string]*ast.DirectiveDefinition{
			"deprecated": {
				Name: "deprecated",
				Arguments: ast.ArgumentDefinitionList{
					{
						Name: "reason",
						Type: &ast.Type{
							Position: &ast.Position{},
						},
					},
				},
				Locations: []ast.DirectiveLocation{},
				Position: &ast.Position{
					Src: &ast.Source{BuiltIn: true},
				},
			},
		},
		PossibleTypes: map[string][]*ast.Definition{},
		Implements:    map[string][]*ast.Definition{},
	}, schema)
}

func TestIntrospectAPI_union(t *testing.T) {
	schema, err := IntrospectAPI(&mockJSONQueryer{
		JSONResult: `{
			"__schema": {
				"queryType": {
					"name": "Query"
				},
				"types": [
					{
						"name": "Subtype1",
						"kind": "OBJECT"
					},
					{
						"name": "Subtype2",
						"kind": "OBJECT"
					},
					{
						"name": "TypeA",
						"kind": "UNION",
						"possibleTypes": [
							{ "name": "Subtype1" },
							{ "name": "Subtype2" }
						]
					}
				]
			}
		}`,
	})
	assert.NoError(t, err)
	var (
		expectTypeA = &ast.Definition{
			Name:   "TypeA",
			Kind:   "UNION",
			Types:  []string{"Subtype1", "Subtype2"},
			Fields: ast.FieldList{},
		}
		expectSubtype1 = &ast.Definition{
			Name:   "Subtype1",
			Kind:   "OBJECT",
			Fields: ast.FieldList{},
		}
		expectSubtype2 = &ast.Definition{
			Name:   "Subtype2",
			Kind:   "OBJECT",
			Fields: ast.FieldList{},
		}
	)
	assert.Equal(t, &ast.Schema{
		Directives: map[string]*ast.DirectiveDefinition{},
		Types: map[string]*ast.Definition{
			"TypeA":    expectTypeA,
			"Subtype1": expectSubtype1,
			"Subtype2": expectSubtype2,
		},
		PossibleTypes: map[string][]*ast.Definition{
			"TypeA": {
				expectSubtype1,
				expectSubtype2,
			},
			"Subtype1": {
				expectSubtype1,
			},
			"Subtype2": {
				expectSubtype2,
			},
		},
		Implements: map[string][]*ast.Definition{
			"Subtype1": {expectSubtype1, expectTypeA},
			"Subtype2": {expectSubtype2, expectTypeA},
			"TypeA":    {expectTypeA},
		},
	}, schema)
}

// mockJSONQueryer unmarshals the internal JSONResult into the receiver. Simulates the real queryer, just a bit.
type mockJSONQueryer struct {
	JSONResult string
}

func (q *mockJSONQueryer) Query(ctx context.Context, input *QueryInput, receiver interface{}) error {
	return json.Unmarshal([]byte(q.JSONResult), receiver)
}

func TestIntrospectQuery_savesQueryType(t *testing.T) {
	// introspect the api with a known response
	schema, err := IntrospectAPI(&MockSuccessQueryer{
		IntrospectionQueryResult{
			Schema: &IntrospectionQuerySchema{
				QueryType: IntrospectionQueryRootType{
					Name: "Query",
				},
				Types: []IntrospectionQueryFullType{
					{
						Kind: "OBJECT",
						Name: "Query",
						Fields: []IntrospectionQueryFullTypeField{
							{
								Name: "Hello",
								Type: IntrospectionTypeRef{
									Kind: "SCALAR",
								},
							},
						},
					},
				},
			},
		},
	})
	// if something went wrong
	if err != nil {
		t.Error(err.Error())
		return
	}

	// make sure we got a schema back
	if schema == nil {
		t.Error("Received nil schema")
		return
	}
	if schema.Query == nil {
		t.Error("Query was nil")
		return
	}

	// make sure the query type has the right name
	assert.Equal(t, "Query", schema.Query.Name)
}

func TestIntrospectQuery_savesMutationType(t *testing.T) {
	// introspect the api with a known response
	schema, err := IntrospectAPI(&MockSuccessQueryer{
		IntrospectionQueryResult{
			Schema: &IntrospectionQuerySchema{
				QueryType: IntrospectionQueryRootType{
					Name: "Query",
				},
				MutationType: &IntrospectionQueryRootType{
					Name: "Mutation",
				},
				Types: []IntrospectionQueryFullType{
					{
						Kind: "OBJECT",
						Name: "Mutation",
						Fields: []IntrospectionQueryFullTypeField{
							{
								Name: "Hello",
								Type: IntrospectionTypeRef{
									Kind: "SCALAR",
								},
							},
						},
					},
				},
			},
		},
	})
	// if something went wrong
	if err != nil {
		t.Error(err.Error())
		return
	}

	// make sure we got a schema back
	if schema == nil {
		t.Error("Received nil schema")
		return
	}
	if schema.Mutation == nil {
		t.Error("Mutation was nil")
		return
	}

	// make sure the query type has the right name
	assert.Equal(t, "Mutation", schema.Mutation.Name)
}

func TestIntrospectQuery_savesSubscriptionType(t *testing.T) {
	// introspect the api with a known response
	schema, err := IntrospectAPI(&MockSuccessQueryer{
		IntrospectionQueryResult{
			Schema: &IntrospectionQuerySchema{
				QueryType: IntrospectionQueryRootType{
					Name: "Query",
				},
				SubscriptionType: &IntrospectionQueryRootType{
					Name: "Subscription",
				},
				Types: []IntrospectionQueryFullType{
					{
						Kind: "OBJECT",
						Name: "Subscription",
						Fields: []IntrospectionQueryFullTypeField{
							{
								Name: "Hello",
								Type: IntrospectionTypeRef{
									Kind: "SCALAR",
								},
							},
						},
					},
				},
			},
		},
	})
	// if something went wrong
	if err != nil {
		t.Error(err.Error())
		return
	}

	// make sure we got a schema back
	if schema == nil {
		t.Error("Received nil schema")
		return
	}
	if schema.Subscription == nil {
		t.Error("Subscription was nil")
		return
	}

	// make sure the query type has the right name
	assert.Equal(t, "Subscription", schema.Subscription.Name)
}

func TestIntrospectQuery_multipleTypes(t *testing.T) {
	// introspect the api with a known response
	schema, err := IntrospectAPI(&MockSuccessQueryer{
		IntrospectionQueryResult{
			Schema: &IntrospectionQuerySchema{
				QueryType: IntrospectionQueryRootType{
					Name: "Query",
				},
				Types: []IntrospectionQueryFullType{
					{
						Kind: "OBJECT",
						Name: "Type1",
					},
					{
						Kind: "OBJECT",
						Name: "Type2",
					},
				},
			},
		},
	})
	// if something went wrong
	if err != nil {
		t.Error(err.Error())
		return
	}

	// make sure that the schema has both types
	if len(schema.Types) != 2 {
		t.Errorf("Encountered incorrect number of types: %v", len(schema.Types))
		return
	}

	// there should be Type1
	type1, ok := schema.Types["Type1"]
	if !ok {
		t.Errorf("Did not have a type 1")
		return
	}
	assert.Equal(t, "Type1", type1.Name)
	assert.Equal(t, ast.Object, type1.Kind)

	// there should be Type2
	type2, ok := schema.Types["Type2"]
	if !ok {
		t.Errorf("Did not have a type 2")
		return
	}
	assert.Equal(t, "Type2", type2.Name)
	assert.Equal(t, ast.Object, type2.Kind)
}

func TestIntrospectQuery_interfaces(t *testing.T) {
	// introspect the api with a known response
	schema, err := IntrospectAPI(&MockSuccessQueryer{
		IntrospectionQueryResult{
			Schema: &IntrospectionQuerySchema{
				QueryType: IntrospectionQueryRootType{
					Name: "Query",
				},
				Types: []IntrospectionQueryFullType{
					{
						Kind:        "INTERFACE",
						Name:        "IFace",
						Description: "Description",
						Fields: []IntrospectionQueryFullTypeField{
							{
								Name: "Hello",
								Type: IntrospectionTypeRef{
									Kind: "SCALAR",
								},
							},
						},
					},
					{
						Kind: "OBJECT",
						Name: "Type1",
						Interfaces: []IntrospectionTypeRef{
							{
								Kind: "INTERFACE",
								Name: "IFace",
							},
						},
					},
					{
						Kind: "OBJECT",
						Name: "Type2",
						Interfaces: []IntrospectionTypeRef{
							{
								Kind: "INTERFACE",
								Name: "IFace",
							},
						},
					},
				},
			},
		},
	})
	if err != nil {
		t.Error(err.Error())
		return
	}

	iface, ok := schema.Types["IFace"]
	if !ok {
		t.Error("Could not find union")
		return
	}

	// make sure the meta data was correct
	assert.Equal(t, "IFace", iface.Name)
	assert.Equal(t, "Description", iface.Description)

	// make sure there is only one field defined
	fields := iface.Fields
	if len(fields) != 1 {
		t.Errorf("Encountered incorrect number of fields on interface: %v", len(fields))
		return
	}
	assert.Equal(t, "Hello", fields[0].Name)

	// get the list of possible types that the implement the interface
	possibleTypes := schema.GetPossibleTypes(schema.Types["IFace"])
	if len(possibleTypes) != 2 {
		t.Errorf("Encountered incorrect number of fields that are possible for an interface: %v", len(possibleTypes))
		return
	}

	// make sure the first possible type matches expectations
	possibleType1 := possibleTypes[0]
	if possibleType1.Name != "Type1" && possibleType1.Name != "Type2" {
		t.Errorf("first possible type did not have the right name: %s", possibleType1.Name)
		return
	}

	// make sure the first possible type matches expectations
	possibleType2 := possibleTypes[0]
	if possibleType2.Name != "Type1" && possibleType2.Name != "Type2" {
		t.Errorf("first possible type did not have the right name: %s", possibleType2.Name)
		return
	}

	// make sure the 2 types implement the interface

	type1Implements := schema.GetImplements(schema.Types["Type1"])
	// type 1 implements 2 types
	if len(type1Implements) != 2 {
		t.Errorf("Type1 implements incorrect number of types: %v", len(type1Implements))
		return
	}
	// make sure it implements intself
	assert.Equal(t, "Type1", type1Implements[0].Name)

	type1Implementer := type1Implements[1]
	assert.Equal(t, "IFace", type1Implementer.Name)

	type2Implements := schema.GetImplements(schema.Types["Type2"])
	// type 1 implements only one type
	if len(type2Implements) != 2 {
		t.Errorf("Type2 implements incorrect number of types: %v", len(type2Implements))
		return
	}
	assert.Equal(t, "Type2", type2Implements[0].Name)
	type2Implementer := type2Implements[1]
	assert.Equal(t, "IFace", type2Implementer.Name)
}

func TestIntrospectQuery_unions(t *testing.T) {
	// introspect the api with a known response
	schema, err := IntrospectAPI(&MockSuccessQueryer{
		IntrospectionQueryResult{
			Schema: &IntrospectionQuerySchema{
				QueryType: IntrospectionQueryRootType{
					Name: "Query",
				},
				Types: []IntrospectionQueryFullType{
					{
						Kind:        "UNION",
						Name:        "Maybe",
						Description: "Description",
						PossibleTypes: []IntrospectionTypeRef{
							{
								Kind: "OBJECT",
								Name: "Type1",
							},
							// ensure the type does not reference itself,
							// however someone creates a situation where this actually happens (╯°□°)╯︵ ┻━┻
							{
								Kind: "UNION",
								Name: "Maybe",
							},
							{
								Kind: "OBJECT",
								Name: "Type2",
							},
						},
					},
					{
						Kind: "OBJECT",
						Name: "Type1",
					},
					{
						Kind: "OBJECT",
						Name: "Type2",
					},
				},
			},
		},
	})
	if err != nil {
		t.Error(err.Error())
		return
	}

	union, ok := schema.Types["Maybe"]
	if !ok {
		t.Error("Could not find union")
		return
	}

	const expectedTypes = 2

	// make sure the union matches expectations
	assert.Equal(t, "Maybe", union.Name)
	assert.Equal(t, ast.Union, union.Kind)
	assert.Equal(t, "Description", union.Description)
	assert.Lenf(t, union.Types, expectedTypes, "union.Types should have %d elements", expectedTypes)

	// make sure that the possible types for the Union match expectations
	possibleTypes := schema.GetPossibleTypes(schema.Types["Maybe"])
	if len(possibleTypes) != expectedTypes {
		t.Errorf("Encountered the right number of possible types: %v", len(possibleTypes))
		return
	}

	// make sure the first possible type matches expectations
	possibleType1 := possibleTypes[0]
	if possibleType1.Name != "Type1" && possibleType1.Name != "Type2" {
		t.Errorf("first possible type did not have the right name: %s", possibleType1.Name)
		return
	}

	// make sure the first possible type matches expectations
	possibleType2 := possibleTypes[0]
	if possibleType2.Name != "Type1" && possibleType2.Name != "Type2" {
		t.Errorf("first possible type did not have the right name: %s", possibleType2.Name)
		return
	}

	// make sure the 2 types implement the union

	type1Implements := schema.GetImplements(schema.Types["Type1"])
	// type 1 implements only one type
	if len(type1Implements) != 2 {
		t.Errorf("Type1 implements incorrect number of types: %v", len(type1Implements))
		return
	}
	type1Implementer := type1Implements[0]
	assert.Equal(t, "Maybe", type1Implementer.Name)

	type2Implements := schema.GetImplements(schema.Types["Type2"])
	// type 1 implements only one type
	if len(type2Implements) != 2 {
		t.Errorf("Type2 implements incorrect number of types: %v", len(type2Implements))
		return
	}
	type2Implementer := type2Implements[0]
	assert.Equal(t, "Maybe", type2Implementer.Name)
}

func TestIntrospectQueryUnmarshalType_scalarFields(t *testing.T) {
	// introspect the api with a known response
	schema, err := IntrospectAPI(&MockSuccessQueryer{
		IntrospectionQueryResult{
			Schema: &IntrospectionQuerySchema{
				QueryType: IntrospectionQueryRootType{
					Name: "Query",
				},
				Types: []IntrospectionQueryFullType{
					{
						Kind:        "SCALAR",
						Name:        "Name",
						Description: "Description",
					},
				},
			},
		},
	})
	if err != nil {
		t.Error(err.Error())
		return
	}

	// create a scalar type with known characteristics
	scalar, ok := schema.Types["Name"]
	if !ok {
		t.Error("Could not find a reference to Name scalar")
		return
	}

	// make sure the scalar has the right meta data
	assert.Equal(t, ast.Scalar, scalar.Kind)
	assert.Equal(t, "Name", scalar.Name)
	assert.Equal(t, "Description", scalar.Description)
}

func TestIntrospectQueryUnmarshalType_objects(t *testing.T) {
	// introspect the api with a known response
	schema, err := IntrospectAPI(&MockSuccessQueryer{
		IntrospectionQueryResult{
			Schema: &IntrospectionQuerySchema{
				QueryType: IntrospectionQueryRootType{
					Name: "Query",
				},
				Types: []IntrospectionQueryFullType{
					{
						Kind:        "OBJECT",
						Name:        "Query",
						Description: "Description",
						Fields: []IntrospectionQueryFullTypeField{
							{
								Name:        "hello",
								Description: "field-description",
								Args: []IntrospectionInputValue{
									{
										Name:        "arg1",
										Description: "arg1-description",
										Type: IntrospectionTypeRef{
											Name: "String",
										},
									},
								},
								Type: IntrospectionTypeRef{
									Name: "Foo",
								},
							},
						},
					},
				},
			},
		},
	})
	if err != nil {
		t.Error(err.Error())
		return
	}

	// create a scalar type with known characteristics
	object, ok := schema.Types["Query"]
	if !ok {
		t.Error("Could not find a reference to Query object")
		return
	}

	// make sure the object has the right meta data
	assert.Equal(t, ast.Object, object.Kind)
	assert.Equal(t, "Query", object.Name)
	assert.Equal(t, "Description", object.Description)

	// we should have added a single field
	if len(object.Fields) != 1 {
		t.Errorf("Encountered incorrect number of fields: %v", len(object.Fields))
		return
	}
	field := object.Fields[0]

	// make sure it had the right metadata
	assert.Equal(t, "hello", field.Name)
	assert.Equal(t, "field-description", field.Description)
	assert.Equal(t, "Foo", field.Type.Name())

	// it should have one arg
	if len(field.Arguments) != 1 {
		t.Errorf("Encountered incorrect number of arguments: %v", len(field.Arguments))
		return
	}
	argument := field.Arguments[0]

	// make sure it has the right metadata
	assert.Equal(t, "arg1", argument.Name)
	assert.Equal(t, "arg1-description", argument.Description)
	assert.Equal(t, "String", argument.Type.Name())
}

func TestIntrospectQueryUnmarshalType_directives(t *testing.T) { // introspect the api with a known response
	schema, err := IntrospectAPI(&MockSuccessQueryer{
		IntrospectionQueryResult{
			Schema: &IntrospectionQuerySchema{
				QueryType: IntrospectionQueryRootType{
					Name: "Query",
				},
				Types: []IntrospectionQueryFullType{
					{
						Kind:        "OBJECT",
						Name:        "Query",
						Description: "Description",
						Fields: []IntrospectionQueryFullTypeField{
							{
								Name:        "hello",
								Description: "field-description",
								Args: []IntrospectionInputValue{
									{
										Name:        "arg1",
										Description: "arg1-description",
										Type: IntrospectionTypeRef{
											Name: "String",
										},
									},
								},
								Type: IntrospectionTypeRef{
									Name: "Foo",
								},
							},
						},
					},
				},
				Directives: []IntrospectionQueryDirective{
					{
						Name:        "internal",
						Description: "internal-description",
						Locations:   []string{"QUERY", "MUTATION"},
						Args: []IntrospectionInputValue{
							{
								Name:        "hello",
								Description: "hello-description",
								Type: IntrospectionTypeRef{
									Name: "String",
								},
							},
						},
					},
				},
			},
		},
	})
	if err != nil {
		t.Error(err.Error())
		return
	}

	// make sure we have the one definition
	if len(schema.Directives) != 1 {
		t.Errorf("Encountered incorrect number of directives: %v", len(schema.Types))
		return
	}

	directive, ok := schema.Directives["internal"]
	if !ok {
		t.Error("Could not find directive 'internal'")
		return
	}

	// make sure that the directive meta data is right
	assert.Equal(t, "internal", directive.Name)
	assert.Equal(t, "internal-description", directive.Description)
	assert.Equal(t, []ast.DirectiveLocation{ast.LocationQuery, ast.LocationMutation}, directive.Locations)

	// make sure we got the args right
	if len(directive.Arguments) != 1 {
		t.Errorf("Encountered incorrect number of arguments: %v", len(directive.Arguments))
		return
	}

	// make sure we got the argumen type right
	assert.Equal(t, "String", directive.Arguments[0].Type.Name())
}

func TestIntrospectQueryUnmarshalType_enums(t *testing.T) {
	// introspect the api with a known response
	schema, err := IntrospectAPI(&MockSuccessQueryer{
		IntrospectionQueryResult{
			Schema: &IntrospectionQuerySchema{
				QueryType: IntrospectionQueryRootType{
					Name: "Query",
				},
				Types: []IntrospectionQueryFullType{
					{
						Kind:        "ENUM",
						Name:        "Word",
						Description: "enum-description",
						EnumValues: []IntrospectionQueryEnumDefinition{
							{
								Name:        "hello",
								Description: "hello-description",
							},
							{
								Name:        "goodbye",
								Description: "goodbye-description",
							},
						},
					},
				},
			},
		},
	})
	if err != nil {
		t.Error(err.Error())
		return
	}

	// make sure we have the one definitino
	if len(schema.Types) != 1 {
		t.Errorf("Encountered incorrect number of types: %v", len(schema.Types))
		return
	}

	enum, ok := schema.Types["Word"]
	if !ok {
		t.Error("Coud not find definition for Word enum")
		return
	}

	// make sure the values matched expectations
	assert.Equal(t, "Word", enum.Name)
	assert.Equal(t, ast.Enum, enum.Kind)
	assert.Equal(t, "enum-description", enum.Description)
	assert.Equal(t, enum.EnumValues, ast.EnumValueList{
		&ast.EnumValueDefinition{
			Name:        "hello",
			Description: "hello-description",
		},
		&ast.EnumValueDefinition{
			Name:        "goodbye",
			Description: "goodbye-description",
		},
	})
}

func TestIntrospectQuery_deprecatedFields(t *testing.T) {
	t.Skip("Not yet implemented")
}

func TestIntrospectQuery_deprecatedEnums(t *testing.T) {
	t.Skip("Not yet Implemented")
}

func TestIntrospectQueryUnmarshalType_inputObjects(t *testing.T) {
	// introspect the api with a known response
	schema, err := IntrospectAPI(&MockSuccessQueryer{
		IntrospectionQueryResult{
			Schema: &IntrospectionQuerySchema{
				QueryType: IntrospectionQueryRootType{
					Name: "Query",
				},
				Types: []IntrospectionQueryFullType{
					{
						Kind:        "INPUT_OBJECT",
						Name:        "InputObjectType",
						Description: "Description",
						InputFields: []IntrospectionInputValue{
							{
								Name:        "hello",
								Description: "hello-description",
								Type: IntrospectionTypeRef{
									Name: "String",
								},
							},
						},
					},
				},
			},
		},
	})
	if err != nil {
		t.Error(err.Error())
		return
	}

	// create a scalar type with known characteristics
	object, ok := schema.Types["InputObjectType"]
	if !ok {
		t.Error("Could not find a reference to Query object")
		return
	}

	// make sure the object meta data is right
	assert.Equal(t, "InputObjectType", object.Name)
	assert.Equal(t, "Description", object.Description)
	assert.Equal(t, ast.InputObject, object.Kind)

	// we should have added a single field
	if len(object.Fields) != 1 {
		t.Errorf("Encountered incorrect number of fields: %v", len(object.Fields))
		return
	}
	field := object.Fields[0]

	// make sure it had the right metadata
	assert.Equal(t, "hello", field.Name)
	assert.Equal(t, "hello-description", field.Description)
	assert.Equal(t, "String", field.Type.Name())
}

func TestIntrospectUnmarshalDirectiveLocation(t *testing.T) {
	// make sure each directive location is extractable
	for key, value := range directiveLocationMap {
		// make sure we can convert a list of strings to the list of location
		result, err := introspectionUnmarshalDirectiveLocation([]string{key, key})
		if err != nil {
			t.Error(err.Error())
			return
		}

		assert.Equal(t, []ast.DirectiveLocation{value, value}, result)
	}
}

func TestIntrospectUnmarshalTypeDef(t *testing.T) {
	// the table
	table := []struct {
		Message    string
		Expected   *ast.Type
		RemoteType *IntrospectionTypeRef
	}{
		// named types
		{
			"User",
			ast.NamedType("User", &ast.Position{}),
			&IntrospectionTypeRef{
				Kind: "OBJECT",
				Name: "User",
			},
		},
		// non-null named types
		{
			"User!",
			ast.NonNullNamedType("User", &ast.Position{}),
			&IntrospectionTypeRef{
				Kind: "NON_NULL",
				OfType: &IntrospectionTypeRef{
					Kind: "OBJECT",
					Name: "User",
				},
			},
		},
		// lists of named types
		{
			"[User]",
			ast.ListType(ast.NamedType("User", &ast.Position{}), &ast.Position{}),
			&IntrospectionTypeRef{
				Kind: "LIST",
				OfType: &IntrospectionTypeRef{
					Kind: "OBJECT",
					Name: "User",
				},
			},
		},
		// non-null list of named types
		{
			"[User]!",
			ast.NonNullListType(ast.NamedType("User", &ast.Position{}), &ast.Position{}),
			&IntrospectionTypeRef{
				Kind: "NON_NULL",
				OfType: &IntrospectionTypeRef{
					Kind: "LIST",
					OfType: &IntrospectionTypeRef{
						Kind: "OBJECT",
						Name: "User",
					},
				},
			},
		},
		// a non-null list of non-null types
		{
			"[User!]!",
			ast.NonNullListType(ast.NonNullNamedType("User", &ast.Position{}), &ast.Position{}),
			&IntrospectionTypeRef{
				Kind: "NON_NULL",
				OfType: &IntrospectionTypeRef{
					Kind: "LIST",
					OfType: &IntrospectionTypeRef{
						Kind: "NON_NULL",
						OfType: &IntrospectionTypeRef{
							Kind: "OBJECT",
							Name: "User",
						},
					},
				},
			},
		},
		// lists of lists of named types
		{
			"[[User]]",
			ast.ListType(ast.ListType(ast.NamedType("User", &ast.Position{}), &ast.Position{}), &ast.Position{}),
			&IntrospectionTypeRef{
				Kind: "LIST",
				OfType: &IntrospectionTypeRef{
					Kind: "LIST",
					OfType: &IntrospectionTypeRef{
						Kind: "OBJECT",
						Name: "User",
					},
				},
			},
		},
	}

	for _, row := range table {
		t.Run(row.Message, func(t *testing.T) {
			assert.Equal(t, row.Expected, introspectionUnmarshalTypeRef(row.RemoteType), fmt.Sprintf("Desired type: %s", row.Message))
		})
	}
}

func TestIntrospectWithContext(t *testing.T) {
	table := []struct {
		Message string
		Context context.Context
	}{
		{
			Message: "nil context should return context.Background",
			Context: nil,
		},
		{
			Message: "non nil context should return same object",
			Context: context.TODO(),
		},
	}
	for _, row := range table {
		t.Run(row.Message, func(t *testing.T) {
			opt := IntrospectWithContext(row.Context)
			if row.Context == nil {
				assert.Equal(t, context.Background(), opt.Context())
			} else {
				assert.Equal(t, row.Context, opt.Context())
			}
		})
	}
}

func TestIntrospectWithHTTPClient(t *testing.T) {
	table := []struct {
		Message string
		Client  *http.Client
	}{
		{
			Message: "nil client",
			Client:  nil,
		},
		{
			Message: "non nil client",
			Client:  &http.Client{},
		},
	}
	for _, row := range table {
		t.Run(row.Message, func(t *testing.T) {
			queryer := NewSingleRequestQueryer("foo")
			opt := IntrospectWithHTTPClient(row.Client)
			queryer = opt.Apply(queryer).(*SingleRequestQueryer)
			assert.Equal(t, row.Client, queryer.queryer.Client)
		})
	}
}

func TestIntrospectWithMiddlewares(t *testing.T) {
	table := []struct {
		Message string
		Wares   []NetworkMiddleware
	}{
		{
			Message: "no midddlewares",
			Wares:   nil,
		},
		{
			Message: "2 middlewares",
			Wares: []NetworkMiddleware{
				func(r *http.Request) error { return nil },
				func(r *http.Request) error { return nil },
			},
		},
	}
	for _, row := range table {
		t.Run(row.Message, func(t *testing.T) {
			queryer := NewSingleRequestQueryer("foo")
			opt := IntrospectWithMiddlewares(row.Wares...)
			queryer = opt.Apply(queryer).(*SingleRequestQueryer)
			assert.Len(t, queryer.queryer.Middlewares, len(row.Wares))
		})
	}
}

func Test_mergeIntrospectOptions(t *testing.T) {
	t.Parallel()
	client1 := &http.Client{}
	client2 := &http.Client{}
	wares1 := []NetworkMiddleware{
		func(r *http.Request) error { return errors.New("1.1") },
		func(r *http.Request) error { return errors.New("1.2") },
	}
	wares2 := []NetworkMiddleware{
		func(r *http.Request) error { return errors.New("2.1") },
		func(r *http.Request) error { return errors.New("2.2") },
	}
	table := []struct {
		Message  string
		Options  []*IntrospectOptions
		Expected IntrospectOptions
	}{
		{
			Message:  "nil options",
			Options:  nil,
			Expected: IntrospectOptions{},
		},
		{
			Message: "zero value",
			Options: []*IntrospectOptions{
				// Zero values. Was previously supported, so don't break back compatibility.
				{},
				{},
			},
			Expected: IntrospectOptions{},
		},
		{
			Message: "full case",
			Options: []*IntrospectOptions{
				IntrospectWithContext(context.TODO()),
				IntrospectWithHTTPClient(client1),
				IntrospectWithMiddlewares(wares1...),
			},
			Expected: IntrospectOptions{
				client: client1,
				wares:  wares1,
				ctx:    context.TODO(),
			},
		},
		{
			Message: "use the latest given context",
			Options: []*IntrospectOptions{
				IntrospectWithContext(context.Background()),
				IntrospectWithContext(context.TODO()),
			},
			Expected: IntrospectOptions{
				ctx: context.TODO(),
			},
		},
		{
			Message: "use the latest given client",
			Options: []*IntrospectOptions{
				IntrospectWithHTTPClient(client1),
				IntrospectWithHTTPClient(client2),
			},
			Expected: IntrospectOptions{
				client: client2,
			},
		},
		{
			Message: "all middlewares",
			Options: []*IntrospectOptions{
				IntrospectWithMiddlewares(wares1...),
				IntrospectWithMiddlewares(wares2...),
			},
			Expected: IntrospectOptions{
				wares: append(wares1, wares2...),
			},
		},
	}
	for _, row := range table {
		row := row // enable parallel sub-tests
		t.Run(row.Message, func(t *testing.T) {
			t.Parallel()
			opt := mergeIntrospectOptions(row.Options...)
			assert.Equal(t, row.Expected.client, opt.client)
			assert.Equal(t, row.Expected.ctx, opt.ctx)
			require.Len(t, opt.wares, len(row.Expected.wares))
			for i, ware := range row.Expected.wares {
				assert.Equal(t, ware(nil), opt.wares[i](nil))
			}
		})
	}
}

// mockJSONErrorQueryer unmarshals the internal JSONResult into the receiver.
// Like mockJSONQueryer but can return failures for X attempts.
type mockJSONErrorQueryer struct {
	FailuresRemaining int
	FailureErr        error
	JSONResult        string
}

func (q *mockJSONErrorQueryer) Query(ctx context.Context, input *QueryInput, receiver interface{}) error {
	if q.FailuresRemaining > 0 {
		q.FailuresRemaining--
		err := q.FailureErr
		if err == nil {
			err = errors.New("some error")
		}
		return err
	}
	return json.Unmarshal([]byte(q.JSONResult), receiver)
}

func TestIntrospectAPI_retry(t *testing.T) {
	t.Parallel()
	makeQueryer := func() *mockJSONErrorQueryer {
		return &mockJSONErrorQueryer{
			FailureErr: errors.New("foo"),
			JSONResult: `{
			"__schema": {
				"queryType": {
					"name": "Query"
				},
				"directives": [
					{
						"name": "deprecated",
						"args": [
							{"name": "reason"}
						]
					}
				]
			}
		}`,
		}
	}

	t.Run("no retrier", func(t *testing.T) {
		t.Parallel()
		queryer := makeQueryer()
		queryer.FailuresRemaining = 1
		_, err := IntrospectAPI(queryer)
		assert.Zero(t, queryer.FailuresRemaining)
		require.EqualError(t, err, "query failed: foo")
		assert.ErrorIs(t, err, queryer.FailureErr)
	})

	t.Run("retry more than once", func(t *testing.T) {
		t.Parallel()
		queryer := makeQueryer()
		queryer.FailuresRemaining = 10
		schema, err := IntrospectAPI(queryer, IntrospectWithRetrier(NewCountRetrier(10)))
		assert.Zero(t, queryer.FailuresRemaining)
		assert.NoError(t, err)

		assert.Equal(t, &ast.Schema{
			Types: map[string]*ast.Definition{},
			Directives: map[string]*ast.DirectiveDefinition{
				"deprecated": {
					Name: "deprecated",
					Arguments: ast.ArgumentDefinitionList{
						{
							Name: "reason",
							Type: &ast.Type{
								Position: &ast.Position{},
							},
						},
					},
					Locations: []ast.DirectiveLocation{},
					Position: &ast.Position{
						Src: &ast.Source{BuiltIn: true},
					},
				},
			},
			PossibleTypes: map[string][]*ast.Definition{},
			Implements:    map[string][]*ast.Definition{},
		}, schema)
	})
}

// Tests fix for https://github.com/nautilus/graphql/issues/35
func TestIntrospectAPI_valid_interface_implementation(t *testing.T) {
	t.Parallel()
	schema, err := IntrospectAPI(&mockJSONQueryer{
		JSONResult: `{
			"__schema": {
				"queryType": {
					"name": "Query"
				},
				"types": [
					{
						"description": null,
						"enumValues": [],
						"fields": [
							{
								"args": [
									{
										"defaultValue": null,
										"description": null,
										"name": "id",
										"type": {
											"kind": "NON_NULL",
											"name": null,
											"ofType": {
												"kind": "SCALAR",
												"name": "ID",
												"ofType": null
											}
										}
									}
								],
								"deprecationReason": null,
								"description": "Find a Node for the given ID. Use fragments to select additional fields.",
								"isDeprecated": false,
								"name": "node",
								"type": {
									"kind": "INTERFACE",
									"name": "Node",
									"ofType": null
								}
							}
						],
						"inputFields": [],
						"interfaces": [],
						"kind": "OBJECT",
						"name": "Query",
						"possibleTypes": []
					},
					{
						"description": "A resource.",
						"enumValues": [],
						"fields": [
							{
								"args": [],
								"deprecationReason": null,
								"description": "The ID of this resource.",
								"isDeprecated": false,
								"name": "id",
								"type": {
									"kind": "NON_NULL",
									"name": null,
									"ofType": {
										"kind": "SCALAR",
										"name": "ID",
										"ofType": null
									}
								}
							}
						],
						"inputFields": [],
						"interfaces": [
							{
								"kind": "INTERFACE",
								"name": "Node",
								"ofType": null
							}
						],
						"kind": "OBJECT",
						"name": "Resource",
						"possibleTypes": []
					},
					{
						"description": "Fetches an object given its ID.",
						"enumValues": [],
						"fields": [
							{
								"args": [],
								"deprecationReason": null,
								"description": "The globally unique object ID.",
								"isDeprecated": false,
								"name": "id",
								"type": {
									"kind": "NON_NULL",
									"name": null,
									"ofType": {
										"kind": "SCALAR",
										"name": "ID",
										"ofType": null
									}
								}
							}
						],
						"inputFields": [],
						"interfaces": [],
						"kind": "INTERFACE",
						"name": "Node",
						"possibleTypes": [
							{
								"kind": "INTERFACE",
								"name": "Node",
								"ofType": null
							},
							{
								"kind": "OBJECT",
								"name": "Resource",
								"ofType": null
							}
						]
					}
				]
			}
		}`,
	})
	assert.NoError(t, err)

	var schemaBuffer bytes.Buffer
	formatter.NewFormatter(&schemaBuffer).FormatSchema(schema)
	_, err = gqlparser.LoadSchema(&ast.Source{Name: "input.graphql", Input: schemaBuffer.String()})
	assert.Nil(t, err, "Type should implement an interface without formatting/re-parsing failures.")
}

// Tests fix for https://github.com/nautilus/graphql/issues/37
func TestIntrospectAPI_spread_fragment_on_interface(t *testing.T) {
	t.Parallel()
	schema, err := IntrospectAPI(&mockJSONQueryer{
		JSONResult: `{
			"__schema": {
				"queryType": {
					"name": "Query"
				},
				"types": [
					{
						"description": null,
						"enumValues": [],
						"fields": [
							{
								"args": [
									{
										"defaultValue": null,
										"description": null,
										"name": "id",
										"type": {
											"kind": "NON_NULL",
											"name": null,
											"ofType": {
												"kind": "SCALAR",
												"name": "ID",
												"ofType": null
											}
										}
									}
								],
								"deprecationReason": null,
								"description": "Find a Node for the given ID. Use fragments to select additional fields.",
								"isDeprecated": false,
								"name": "node",
								"type": {
									"kind": "INTERFACE",
									"name": "Node",
									"ofType": null
								}
							}
						],
						"inputFields": [],
						"interfaces": [],
						"kind": "OBJECT",
						"name": "Query",
						"possibleTypes": []
					},
					{
						"description": "A resource.",
						"enumValues": [],
						"fields": [
							{
								"args": [],
								"deprecationReason": null,
								"description": "The ID of this resource.",
								"isDeprecated": false,
								"name": "id",
								"type": {
									"kind": "NON_NULL",
									"name": null,
									"ofType": {
										"kind": "SCALAR",
										"name": "ID",
										"ofType": null
									}
								}
							}
						],
						"inputFields": [],
						"interfaces": [
							{
								"kind": "INTERFACE",
								"name": "Node",
								"ofType": null
							}
						],
						"kind": "OBJECT",
						"name": "Resource",
						"possibleTypes": []
					},
					{
						"description": "Fetches an object given its ID.",
						"enumValues": [],
						"fields": [
							{
								"args": [],
								"deprecationReason": null,
								"description": "The globally unique object ID.",
								"isDeprecated": false,
								"name": "id",
								"type": {
									"kind": "NON_NULL",
									"name": null,
									"ofType": {
										"kind": "SCALAR",
										"name": "ID",
										"ofType": null
									}
								}
							}
						],
						"inputFields": [],
						"interfaces": [],
						"kind": "INTERFACE",
						"name": "Node",
						"possibleTypes": [
							{
								"kind": "INTERFACE",
								"name": "Node",
								"ofType": null
							},
							{
								"kind": "OBJECT",
								"name": "Resource",
								"ofType": null
							}
						]
					}
				]
			}
		}`,
	})
	assert.NoError(t, err)

	typeNames := func(defs []*ast.Definition) []string {
		var names []string
		for _, def := range defs {
			names = append(names, def.Name)
		}
		return names
	}
	assert.Equal(t, []string{"Resource"}, typeNames(schema.GetPossibleTypes(schema.Types["Node"])))
	assert.Equal(t, []string{"Resource"}, typeNames(schema.GetPossibleTypes(schema.Types["Resource"])))

	_, err = gqlparser.LoadQuery(schema, `
query {
    node(id: "resource") {
        ... on Resource {
            id
        }
    }
}
`)
	assert.Nil(t, err, "Spreading object fragment on matching interface should be allowed")
}

//go:embed testdata/introspect_default_values.json
var introspectionDefaultValuesJSON string

// TestIntrospectDirectivesDefaultValue verifies fix for https://github.com/nautilus/graphql/issues/40
func TestIntrospectDirectivesDefaultValue(t *testing.T) {
	t.Parallel()

	schema, err := IntrospectAPI(&mockJSONQueryer{
		JSONResult: introspectionDefaultValuesJSON,
	})
	require.NoError(t, err)

	var schemaBuffer bytes.Buffer
	formatter.NewFormatter(&schemaBuffer).FormatSchema(schema)

	expectedSchema, err := gqlparser.LoadSchema(&ast.Source{Input: `
directive @hello(
  foo: String! = "foo"
  bar: Int = 1
  baz: Boolean = true
  biff: Float = 1.23
  boo: [String] = ["boo"]
  bah: HelloInput = {humbug: "humbug"}
  blah: HelloEnum = HELLO_1
) on FIELD_DEFINITION

input HelloInput {
  humbug: String
}

enum HelloEnum {
  HELLO_1
  HELLO_2
  HELLO_3
}
	`})
	require.NoError(t, err)
	var expectedBuffer bytes.Buffer
	formatter.NewFormatter(&expectedBuffer).FormatSchema(expectedSchema)
	assert.Equal(t, expectedBuffer.String(), schemaBuffer.String())
}