func TestValidate_OverlappingFieldsCanBeMerged_ReportsEachConflictOnce(t *testing.T) { testutil.ExpectFailsRule(t, graphql.OverlappingFieldsCanBeMergedRule, ` { f1 { ...A ...B } f2 { ...B ...A } f3 { ...A ...B x: c } } fragment A on Type { x: a } fragment B on Type { x: b } `, []gqlerrors.FormattedError{ testutil.RuleError(`Fields "x" conflict because a and b are different fields.`, 18, 9, 21, 9), testutil.RuleError(`Fields "x" conflict because a and c are different fields.`, 18, 9, 14, 11), testutil.RuleError(`Fields "x" conflict because b and c are different fields.`, 21, 9, 14, 11), }) }
func TestValidate_NoUnusedFragments_ContainsUnknownFragmentsWithRefCycle(t *testing.T) { testutil.ExpectFailsRule(t, graphql.NoUnusedFragmentsRule, ` query Foo { human(id: 4) { ...HumanFields1 } } query Bar { human(id: 4) { ...HumanFields2 } } fragment HumanFields1 on Human { name ...HumanFields3 } fragment HumanFields2 on Human { name } fragment HumanFields3 on Human { name } fragment Unused1 on Human { name ...Unused2 } fragment Unused2 on Human { name ...Unused1 } `, []gqlerrors.FormattedError{ testutil.RuleError(`Fragment "Unused1" is never used.`, 22, 7), testutil.RuleError(`Fragment "Unused2" is never used.`, 26, 7), }) }
func TestValidate_NoCircularFragmentSpreads_NoSpreadingItselfDeeply(t *testing.T) { testutil.ExpectFailsRule(t, graphql.NoFragmentCyclesRule, ` fragment fragA on Dog { ...fragB } fragment fragB on Dog { ...fragC } fragment fragC on Dog { ...fragO } fragment fragX on Dog { ...fragY } fragment fragY on Dog { ...fragZ } fragment fragZ on Dog { ...fragO } fragment fragO on Dog { ...fragP } fragment fragP on Dog { ...fragA, ...fragX } `, []gqlerrors.FormattedError{ testutil.RuleError(`Cannot spread fragment "fragA" within itself via fragB, fragC, fragO, fragP.`, 2, 31, 3, 31, 4, 31, 8, 31, 9, 31), testutil.RuleError(`Cannot spread fragment "fragO" within itself via fragP, fragX, fragY, fragZ.`, 8, 31, 9, 41, 5, 31, 6, 31, 7, 31), }) }
func TestValidate_UniqueInputFieldNames_ManyDuplicateInputObjectFields(t *testing.T) { testutil.ExpectFailsRule(t, graphql.UniqueInputFieldNamesRule, ` { field(arg: { f1: "value", f1: "value", f1: "value" }) } `, []gqlerrors.FormattedError{ testutil.RuleError(`There can be only one input field named "f1".`, 3, 22, 3, 35), testutil.RuleError(`There can be only one input field named "f1".`, 3, 22, 3, 48), }) }
func TestValidate_NoUnusedVariables_MultipleVariablesNotUsed(t *testing.T) { testutil.ExpectFailsRule(t, graphql.NoUnusedVariablesRule, ` query Foo($a: String, $b: String, $c: String) { field(b: $b) } `, []gqlerrors.FormattedError{ testutil.RuleError(`Variable "$a" is never used in operation "Foo".`, 2, 17), testutil.RuleError(`Variable "$c" is never used in operation "Foo".`, 2, 41), }) }
func TestValidate_KnownArgumentNames_UnknownArgsAmongstKnownArgs(t *testing.T) { testutil.ExpectFailsRule(t, graphql.KnownArgumentNamesRule, ` fragment oneGoodArgOneInvalidArg on Dog { doesKnowCommand(whoknows: 1, dogCommand: SIT, unknown: true) } `, []gqlerrors.FormattedError{ testutil.RuleError(`Unknown argument "whoknows" on field "doesKnowCommand" of type "Dog".`, 3, 25), testutil.RuleError(`Unknown argument "unknown" on field "doesKnowCommand" of type "Dog".`, 3, 55), }) }
func TestValidate_UniqueArgumentNames_ManyDuplicateFieldArguments(t *testing.T) { testutil.ExpectFailsRule(t, graphql.UniqueArgumentNamesRule, ` { field(arg1: "value", arg1: "value", arg1: "value") } `, []gqlerrors.FormattedError{ testutil.RuleError(`There can be only one argument named "arg1".`, 3, 15, 3, 30), testutil.RuleError(`There can be only one argument named "arg1".`, 3, 15, 3, 45), }) }
func TestValidate_NoUndefinedVariables_MultipleVariablesNotDefined(t *testing.T) { testutil.ExpectFailsRule(t, graphql.NoUndefinedVariablesRule, ` query Foo($b: String) { field(a: $a, b: $b, c: $c) } `, []gqlerrors.FormattedError{ testutil.RuleError(`Variable "$a" is not defined by operation "Foo".`, 3, 18, 2, 7), testutil.RuleError(`Variable "$c" is not defined by operation "Foo".`, 3, 32, 2, 7), }) }
func TestValidate_VariablesAreInputTypes_1(t *testing.T) { testutil.ExpectFailsRule(t, graphql.VariablesAreInputTypesRule, ` query Foo($a: Dog, $b: [[CatOrDog!]]!, $c: Pet) { field(a: $a, b: $b, c: $c) } `, []gqlerrors.FormattedError{ testutil.RuleError(`Variable "$a" cannot be non-input type "Dog".`, 2, 21), testutil.RuleError(`Variable "$b" cannot be non-input type "[[CatOrDog!]]!".`, 2, 30), testutil.RuleError(`Variable "$c" cannot be non-input type "Pet".`, 2, 50), }) }
func TestValidate_KnownDirectives_WithMisplacedDirectives(t *testing.T) { testutil.ExpectFailsRule(t, graphql.KnownDirectivesRule, ` query Foo @include(if: true) { name @operationOnly ...Frag @operationOnly } `, []gqlerrors.FormattedError{ testutil.RuleError(`Directive "include" may not be used on QUERY.`, 2, 17), testutil.RuleError(`Directive "operationOnly" may not be used on FIELD.`, 3, 14), testutil.RuleError(`Directive "operationOnly" may not be used on FRAGMENT_SPREAD.`, 4, 17), }) }
func TestValidate_ProvidedNonNullArguments_DirectiveArguments_WithDirectiveWithMissingTypes(t *testing.T) { testutil.ExpectFailsRule(t, graphql.ProvidedNonNullArgumentsRule, ` { dog @include { name @skip } } `, []gqlerrors.FormattedError{ testutil.RuleError(`Directive "@include" argument "if" of type "Boolean!" is required but not provided.`, 3, 15), testutil.RuleError(`Directive "@skip" argument "if" of type "Boolean!" is required but not provided.`, 4, 18), }) }
func TestValidate_ProvidedNonNullArguments_InvalidNonNullableValue_MissingMultipleNonNullableArguments(t *testing.T) { testutil.ExpectFailsRule(t, graphql.ProvidedNonNullArgumentsRule, ` { complicatedArgs { multipleReqs } } `, []gqlerrors.FormattedError{ testutil.RuleError(`Field "multipleReqs" argument "req1" of type "Int!" is required but not provided.`, 4, 13), testutil.RuleError(`Field "multipleReqs" argument "req2" of type "Int!" is required but not provided.`, 4, 13), }) }
func TestValidate_UniqueVariableNames_DuplicateVariableNames(t *testing.T) { testutil.ExpectFailsRule(t, graphql.UniqueVariableNamesRule, ` query A($x: Int, $x: Int, $x: String) { __typename } query B($x: String, $x: Int) { __typename } query C($x: Int, $x: Int) { __typename } `, []gqlerrors.FormattedError{ testutil.RuleError(`There can only be one variable named "x".`, 2, 16, 2, 25), testutil.RuleError(`There can only be one variable named "x".`, 2, 16, 2, 34), testutil.RuleError(`There can only be one variable named "x".`, 3, 16, 3, 28), testutil.RuleError(`There can only be one variable named "x".`, 4, 16, 4, 25), }) }
func TestValidate_AnonymousOperationMustBeAlone_MultipleAnonOperations(t *testing.T) { testutil.ExpectFailsRule(t, graphql.LoneAnonymousOperationRule, ` { fieldA } { fieldB } `, []gqlerrors.FormattedError{ testutil.RuleError(`This anonymous operation must be the only defined operation.`, 2, 7), testutil.RuleError(`This anonymous operation must be the only defined operation.`, 5, 7), }) }
func TestValidate_NoCircularFragmentSpreads_NoSpreadingItselfDeeplyTwoPaths_AltTraverseOrder(t *testing.T) { testutil.ExpectFailsRule(t, graphql.NoFragmentCyclesRule, ` fragment fragA on Dog { ...fragC } fragment fragB on Dog { ...fragC } fragment fragC on Dog { ...fragA, ...fragB } `, []gqlerrors.FormattedError{ testutil.RuleError(`Cannot spread fragment "fragA" within itself via fragC.`, 2, 31, 4, 31), testutil.RuleError(`Cannot spread fragment "fragC" within itself via fragB.`, 4, 41, 3, 31), }) }
func TestValidate_FieldsOnCorrectType_ReportErrorsWhenTheTypeIsKnownAgain(t *testing.T) { testutil.ExpectFailsRule(t, graphql.FieldsOnCorrectTypeRule, ` fragment typeKnownAgain on Pet { unknown_pet_field { ... on Cat { unknown_cat_field } } } `, []gqlerrors.FormattedError{ testutil.RuleError(`Cannot query field "unknown_pet_field" on type "Pet".`, 3, 9), testutil.RuleError(`Cannot query field "unknown_cat_field" on type "Cat".`, 5, 13), }) }
func TestValidate_NoCircularFragmentSpreads_NoSpreadingItselfDirectly(t *testing.T) { testutil.ExpectFailsRule(t, graphql.NoFragmentCyclesRule, ` fragment fragA on Dog { ...fragA } `, []gqlerrors.FormattedError{ testutil.RuleError(`Cannot spread fragment "fragA" within itself.`, 2, 31), }) }
func TestValidate_NoCircularFragmentSpreads_SpreadingRecursivelyWithinFieldFails(t *testing.T) { testutil.ExpectFailsRule(t, graphql.NoFragmentCyclesRule, ` fragment fragA on Human { relatives { ...fragA } }, `, []gqlerrors.FormattedError{ testutil.RuleError(`Cannot spread fragment "fragA" within itself.`, 2, 45), }) }
func TestValidate_NoCircularFragmentSpreads_NoSpreadingItselfDeeplyAndImmediately(t *testing.T) { testutil.ExpectFailsRule(t, graphql.NoFragmentCyclesRule, ` fragment fragA on Dog { ...fragB } fragment fragB on Dog { ...fragB, ...fragC } fragment fragC on Dog { ...fragA, ...fragB } `, []gqlerrors.FormattedError{ testutil.RuleError(`Cannot spread fragment "fragB" within itself.`, 3, 31), testutil.RuleError(`Cannot spread fragment "fragA" within itself via fragB, fragC.`, 2, 31, 3, 41, 4, 31), testutil.RuleError(`Cannot spread fragment "fragB" within itself via fragC.`, 3, 41, 4, 41), }) }
func TestValidate_NoUndefinedVariables_VariablesInFragmentNotDefinedByMultipleOperations(t *testing.T) { testutil.ExpectFailsRule(t, graphql.NoUndefinedVariablesRule, ` query Foo($b: String) { ...FragAB } query Bar($a: String) { ...FragAB } fragment FragAB on Type { field(a: $a, b: $b) } `, []gqlerrors.FormattedError{ testutil.RuleError(`Variable "$a" is not defined by operation "Foo".`, 9, 18, 2, 7), testutil.RuleError(`Variable "$b" is not defined by operation "Bar".`, 9, 25, 5, 7), }) }
func TestValidate_OverlappingFieldsCanBeMerged_ReturnTypesMustBeUnambiguous_DisallowsDifferingDeepReturnTypesDespiteNoOverlap(t *testing.T) { testutil.ExpectFailsRuleWithSchema(t, &schema, graphql.OverlappingFieldsCanBeMergedRule, ` { someBox { ... on IntBox { box: stringBox { scalar } } ... on StringBox { box: intBox { scalar } } } } `, []gqlerrors.FormattedError{ testutil.RuleError( `Fields "box" conflict because subfields "scalar" conflict because they return conflicting types String and Int.`, 5, 15, 6, 17, 10, 15, 11, 17), }) }
func TestValidate_OverlappingFieldsCanBeMerged_ReturnTypesMustBeUnambiguous_ComparesDeepTypesIncludingList(t *testing.T) { testutil.ExpectFailsRuleWithSchema(t, &schema, graphql.OverlappingFieldsCanBeMergedRule, ` { connection { ...edgeID edges { node { id: name } } } } fragment edgeID on Connection { edges { node { id } } } `, []gqlerrors.FormattedError{ testutil.RuleError( `Fields "edges" conflict because subfields "node" conflict because subfields "id" conflict because `+ `id and name are different fields.`, 14, 11, 15, 13, 16, 15, 5, 13, 6, 15, 7, 17), }) }
func TestValidate_OverlappingFieldsCanBeMerged_VeryDeepConflict(t *testing.T) { testutil.ExpectFailsRule(t, graphql.OverlappingFieldsCanBeMergedRule, ` { field { deepField { x: a } }, field { deepField { x: b } } } `, []gqlerrors.FormattedError{ testutil.RuleError( `Fields "field" conflict because subfields "deepField" conflict because subfields "x" conflict because `+ `a and b are different fields.`, 3, 9, 4, 11, 5, 13, 8, 9, 9, 11, 10, 13), }) }
func TestValidate_OverlappingFieldsCanBeMerged_ReportsDeepConflictToNearestCommonAncestor(t *testing.T) { testutil.ExpectFailsRule(t, graphql.OverlappingFieldsCanBeMergedRule, ` { field { deepField { x: a } deepField { x: b } }, field { deepField { y } } } `, []gqlerrors.FormattedError{ testutil.RuleError( `Fields "deepField" conflict because subfields "x" conflict because `+ `a and b are different fields.`, 4, 11, 5, 13, 7, 11, 8, 13), }) }
func TestValidate_KnownTypeNames_UnknownTypeNamesAreInValid(t *testing.T) { testutil.ExpectFailsRule(t, graphql.KnownTypeNamesRule, ` query Foo($var: JumbledUpLetters) { user(id: 4) { name pets { ... on Badger { name }, ...PetFields } } } fragment PetFields on Peettt { name } `, []gqlerrors.FormattedError{ testutil.RuleError(`Unknown type "JumbledUpLetters".`, 2, 23), testutil.RuleError(`Unknown type "Badger".`, 5, 25), testutil.RuleError(`Unknown type "Peettt".`, 8, 29), }) }
func TestValidate_NoCircularFragmentSpreads_NoSpreadingItselfIndirectlyReportsOppositeOrder(t *testing.T) { testutil.ExpectFailsRule(t, graphql.NoFragmentCyclesRule, ` fragment fragB on Dog { ...fragA } fragment fragA on Dog { ...fragB } `, []gqlerrors.FormattedError{ testutil.RuleError(`Cannot spread fragment "fragB" within itself via fragA.`, 2, 31, 3, 31), }) }
func TestValidate_UniqueArgumentNames_DuplicateDirectiveArguments(t *testing.T) { testutil.ExpectFailsRule(t, graphql.UniqueArgumentNamesRule, ` { field @directive(arg1: "value", arg1: "value") } `, []gqlerrors.FormattedError{ testutil.RuleError(`There can be only one argument named "arg1".`, 3, 26, 3, 41), }) }
func TestValidate_FragmentsOnCompositeTypes_InputObjectIsInvalidFragmentType(t *testing.T) { testutil.ExpectFailsRule(t, graphql.FragmentsOnCompositeTypesRule, ` fragment inputFragment on ComplexInput { stringField } `, []gqlerrors.FormattedError{ testutil.RuleError(`Fragment "inputFragment" cannot condition on non composite type "ComplexInput".`, 2, 33), }) }
func TestValidate_KnownArgumentNames_InvalidArgName(t *testing.T) { testutil.ExpectFailsRule(t, graphql.KnownArgumentNamesRule, ` fragment invalidArgName on Dog { doesKnowCommand(unknown: true) } `, []gqlerrors.FormattedError{ testutil.RuleError(`Unknown argument "unknown" on field "doesKnowCommand" of type "Dog".`, 3, 25), }) }
func TestValidate_KnownArgumentNames_UndirectiveArgsAreInvalid(t *testing.T) { testutil.ExpectFailsRule(t, graphql.KnownArgumentNamesRule, ` { dog @skip(unless: true) } `, []gqlerrors.FormattedError{ testutil.RuleError(`Unknown argument "unless" on directive "@skip".`, 3, 19), }) }