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_NoUndefinedVariables_VaMultipleUndefinedVariablesProduceMultipleErrors(t *testing.T) {
testutil.ExpectFailsRule(t, graphql.NoUndefinedVariablesRule, `
query Foo($b: String) {
...FragAB
}
query Bar($a: String) {
...FragAB
}
fragment FragAB on Type {
field1(a: $a, b: $b)
...FragC
field3(a: $a, b: $b)
}
fragment FragC on Type {
field2(c: $c)
}
`, []gqlerrors.FormattedError{
testutil.RuleError(`Variable "$a" is not defined by operation "Foo".`, 9, 19, 2, 7),
testutil.RuleError(`Variable "$c" is not defined by operation "Foo".`, 14, 19, 2, 7),
testutil.RuleError(`Variable "$a" is not defined by operation "Foo".`, 11, 19, 2, 7),
testutil.RuleError(`Variable "$b" is not defined by operation "Bar".`, 9, 26, 5, 7),
testutil.RuleError(`Variable "$c" is not defined by operation "Bar".`, 14, 19, 5, 7),
testutil.RuleError(`Variable "$b" is not defined by operation "Bar".`, 11, 26, 5, 7),
})
}
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_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_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_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_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_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_PossibleFragmentSpreads_ObjectIntoNotContainingUnion(t *testing.T) {
testutil.ExpectFailsRule(t, graphql.PossibleFragmentSpreadsRule, `
fragment invalidObjectWithinUnion on CatOrDog { ...humanFragment }
fragment humanFragment on Human { pets { name } }
`, []gqlerrors.FormattedError{
testutil.RuleError(`Fragment "humanFragment" cannot be spread here as objects of `+
`type "CatOrDog" can never be of type "Human".`, 2, 55),
})
}
func TestValidate_PossibleFragmentSpreads_UnionIntoNotContainedObject(t *testing.T) {
testutil.ExpectFailsRule(t, graphql.PossibleFragmentSpreadsRule, `
fragment invalidUnionWithinObject on Human { ...catOrDogFragment }
fragment catOrDogFragment on CatOrDog { __typename }
`, []gqlerrors.FormattedError{
testutil.RuleError(`Fragment "catOrDogFragment" cannot be spread here as objects of `+
`type "Human" can never be of type "CatOrDog".`, 2, 52),
})
}
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_NoUnusedVariables_VariableNotUsed(t *testing.T) {
testutil.ExpectFailsRule(t, graphql.NoUnusedVariablesRule, `
query ($a: String, $b: String, $c: String) {
field(a: $a, b: $b)
}
`, []gqlerrors.FormattedError{
testutil.RuleError(`Variable "$c" is never used.`, 2, 38),
})
}
func TestValidate_ScalarLeafs_ObjectTypeMissingSelection(t *testing.T) {
testutil.ExpectFailsRule(t, graphql.ScalarLeafsRule, `
query directQueryOnObjectWithoutSubFields {
human
}
`, []gqlerrors.FormattedError{
testutil.RuleError(`Field "human" of type "Human" must have a sub selection.`, 3, 9),
})
}
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),
})
}
func TestValidate_NoUndefinedVariables_VariableNotDefined(t *testing.T) {
testutil.ExpectFailsRule(t, graphql.NoUndefinedVariablesRule, `
query Foo($a: String, $b: String, $c: String) {
field(a: $a, b: $b, c: $c, d: $d)
}
`, []gqlerrors.FormattedError{
testutil.RuleError(`Variable "$d" is not defined by operation "Foo".`, 3, 39, 2, 7),
})
}
func TestValidate_ScalarLeafs_ScalarSelectionNotAllowedWithDirectivesAndArgs(t *testing.T) {
testutil.ExpectFailsRule(t, graphql.ScalarLeafsRule, `
fragment scalarSelectionsNotAllowedWithDirectivesAndArgs on Dog {
doesKnowCommand(dogCommand: SIT) @include(if: true) { sinceWhen }
}
`, []gqlerrors.FormattedError{
testutil.RuleError(`Field "doesKnowCommand" of type "Boolean" must not have a sub selection.`, 3, 61),
})
}
func TestValidate_PossibleFragmentSpreads_ObjectIntoNotImplementingInterface(t *testing.T) {
testutil.ExpectFailsRule(t, graphql.PossibleFragmentSpreadsRule, `
fragment invalidObjectWithinInterface on Pet { ...humanFragment }
fragment humanFragment on Human { pets { name } }
`, []gqlerrors.FormattedError{
testutil.RuleError(`Fragment "humanFragment" cannot be spread here as objects of `+
`type "Pet" can never be of type "Human".`, 2, 54),
})
}
func TestValidate_ScalarLeafs_InterfaceTypeMissingSelection(t *testing.T) {
testutil.ExpectFailsRule(t, graphql.ScalarLeafsRule, `
{
human { pets }
}
`, []gqlerrors.FormattedError{
testutil.RuleError(`Field "pets" of type "[Pet]" must have a sub selection.`, 3, 17),
})
}
func TestValidate_PossibleFragmentSpreads_InterfaceIntoNonOverlappingUnion(t *testing.T) {
testutil.ExpectFailsRule(t, graphql.PossibleFragmentSpreadsRule, `
fragment invalidInterfaceWithinUnion on HumanOrAlien { ...petFragment }
fragment petFragment on Pet { name }
`, []gqlerrors.FormattedError{
testutil.RuleError(`Fragment "petFragment" cannot be spread here as objects of `+
`type "HumanOrAlien" can never be of type "Pet".`, 2, 62),
})
}
func TestValidate_ScalarLeafs_ScalarSelectionNotAllowedOnBoolean(t *testing.T) {
testutil.ExpectFailsRule(t, graphql.ScalarLeafsRule, `
fragment scalarSelectionsNotAllowedOnBoolean on Dog {
barks { sinceWhen }
}
`, []gqlerrors.FormattedError{
testutil.RuleError(`Field "barks" of type "Boolean" must not have a sub selection.`, 3, 15),
})
}
func TestValidate_ScalarLeafs_ScalarSelectionNotAllowedOnEnum(t *testing.T) {
testutil.ExpectFailsRule(t, graphql.ScalarLeafsRule, `
fragment scalarSelectionsNotAllowedOnEnum on Cat {
furColor { inHexdec }
}
`, []gqlerrors.FormattedError{
testutil.RuleError(`Field "furColor" of type "FurColor" must not have a sub selection.`, 3, 18),
})
}
func TestValidate_PossibleFragmentSpreads_UnionIntoNonOverlappingUnion(t *testing.T) {
testutil.ExpectFailsRule(t, graphql.PossibleFragmentSpreadsRule, `
fragment invalidUnionWithinUnion on CatOrDog { ...humanOrAlienFragment }
fragment humanOrAlienFragment on HumanOrAlien { __typename }
`, []gqlerrors.FormattedError{
testutil.RuleError(`Fragment "humanOrAlienFragment" cannot be spread here as objects of `+
`type "CatOrDog" can never be of type "HumanOrAlien".`, 2, 54),
})
}
func TestValidate_NoUndefinedVariables_VariableNotDefinedByUnnamedQuery(t *testing.T) {
testutil.ExpectFailsRule(t, graphql.NoUndefinedVariablesRule, `
{
field(a: $a)
}
`, []gqlerrors.FormattedError{
testutil.RuleError(`Variable "$a" is not defined.`, 3, 18, 2, 7),
})
}
func TestValidate_PossibleFragmentSpreads_InterfaceIntoNonImplementingObject(t *testing.T) {
testutil.ExpectFailsRule(t, graphql.PossibleFragmentSpreadsRule, `
fragment invalidInterfaceWithinObject on Cat { ...intelligentFragment }
fragment intelligentFragment on Intelligent { iq }
`, []gqlerrors.FormattedError{
testutil.RuleError(`Fragment "intelligentFragment" cannot be spread here as objects of `+
`type "Cat" can never be of type "Intelligent".`, 2, 54),
})
}
func TestValidate_ScalarLeafs_ScalarSelectionNotAllowedWithDirectives(t *testing.T) {
testutil.ExpectFailsRule(t, graphql.ScalarLeafsRule, `
fragment scalarSelectionsNotAllowedWithDirectives on Dog {
name @include(if: true) { isAlsoHumanName }
}
`, []gqlerrors.FormattedError{
testutil.RuleError(`Field "name" of type "String" must not have a sub selection.`, 3, 33),
})
}
func TestValidate_PossibleFragmentSpreads_DifferentObjectIntoObject(t *testing.T) {
testutil.ExpectFailsRule(t, graphql.PossibleFragmentSpreadsRule, `
fragment invalidObjectWithinObject on Cat { ...dogFragment }
fragment dogFragment on Dog { barkVolume }
`, []gqlerrors.FormattedError{
testutil.RuleError(`Fragment "dogFragment" cannot be spread here as objects of `+
`type "Cat" can never be of type "Dog".`, 2, 51),
})
}
func TestValidate_FragmentsOnCompositeTypes_EnumIsInvalidFragmentType(t *testing.T) {
testutil.ExpectFailsRule(t, graphql.FragmentsOnCompositeTypesRule, `
fragment scalarFragment on FurColor {
bad
}
`, []gqlerrors.FormattedError{
testutil.RuleError(`Fragment "scalarFragment" cannot condition on non composite type "FurColor".`, 2, 34),
})
}
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),
})
}