public void ScalarSelectionsNotAllowedOnInt()
{
// arrange
DocumentNode query = Parser.Default.Parse(@"
{
dog {
barkVolume {
sinceWhen
}
}
}
");
Schema schema = ValidationUtils.CreateSchema();
var queryValidator = new QueryValidator(schema);
// act
QueryValidationResult result = queryValidator.Validate(query);
// assert
Assert.True(result.HasErrors);
Assert.Collection(result.Errors,
t => Assert.Equal(t.Message,
"`barkVolume` is a scalar field. Selections on scalars " +
"or enums are never allowed, because they are the leaf " +
"nodes of any GraphQL query."));
}
public void UnusedFragment()
{
// arrange
DocumentNode query = Parser.Default.Parse(@"
fragment nameFragment on Dog { # unused
name
}
{
dog {
name
}
}
");
Schema schema = ValidationUtils.CreateSchema();
var queryValidator = new QueryValidator(schema);
// act
QueryValidationResult result = queryValidator.Validate(query);
// assert
Assert.True(result.HasErrors);
Assert.Collection(result.Errors,
t => Assert.Equal(
"The specified fragment `nameFragment` " +
"is not used within the current document.", t.Message));
}
public void DuplicateFragments()
{
// arrange
DocumentNode query = Parser.Default.Parse(@"
{
dog {
...fragmentOne
}
}
fragment fragmentOne on Dog {
name
}
fragment fragmentOne on Dog {
owner {
name
}
}
");
Schema schema = ValidationUtils.CreateSchema();
var queryValidator = new QueryValidator(schema);
// act
QueryValidationResult result = queryValidator.Validate(query);
// assert
Assert.True(result.HasErrors);
Assert.Collection(result.Errors,
t => Assert.Equal(
"There are multiple fragments with the name `fragmentOne`.",
t.Message));
}
public void InvalidFieldArgName()
{
// arrange
DocumentNode query = Parser.Default.Parse(@"
fragment invalidArgName on Dog {
doesKnowCommand(command: CLEAN_UP_HOUSE)
}
");
Schema schema = ValidationUtils.CreateSchema();
var queryValidator = new QueryValidator(schema);
// act
QueryValidationResult result = queryValidator.Validate(query);
// assert
Assert.True(result.HasErrors);
Assert.Collection(result.Errors,
t => Assert.Equal(
"The argument `dogCommand` is required and does not " +
"allow null values.",
t.Message),
t => Assert.Equal(
"The argument `command` does not exist.", t.Message),
t => Assert.Equal(
"The specified fragment `invalidArgName` " +
"is not used within the current document.",
t.Message));
}
public void ConflictingBecauseAlias()
{
// arrange
DocumentNode query = Parser.Default.Parse(@"
fragment conflictingBecauseAlias on Dog {
name: nickname
name
}
");
Schema schema = ValidationUtils.CreateSchema();
var queryValidator = new QueryValidator(schema);
// act
QueryValidationResult result = queryValidator.Validate(query);
// assert
Assert.True(result.HasErrors);
Assert.Collection(result.Errors,
t => Assert.Equal(
"The query has non-mergable fields.",
t.Message),
t => Assert.Equal(
"The specified fragment `conflictingBecauseAlias` " +
"is not used within the current document.",
t.Message));
}
public void MissingRequiredArgNonNullBooleanArg()
{
// arrange
DocumentNode query = Parser.Default.Parse(@"
fragment missingRequiredArg on Arguments {
nonNullBooleanArgField(nonNullBooleanArg: null)
}
");
Schema schema = ValidationUtils.CreateSchema();
var queryValidator = new QueryValidator(schema);
// act
QueryValidationResult result = queryValidator.Validate(query);
// assert
Assert.True(result.HasErrors);
Assert.Collection(result.Errors,
t => Assert.Equal(
$"The argument `nonNullBooleanArg` is required " +
"and does not allow null values.", t.Message),
t => Assert.Equal(
"The specified fragment `missingRequiredArg` " +
"is not used within the current document.",
t.Message));
}
public void InlineFragOnScalar()
{
// arrange
DocumentNode query = Parser.Default.Parse(@"
{
dog {
... inlineFragOnScalar
}
}
fragment inlineFragOnScalar on Dog {
... on Boolean {
somethingElse
}
}
");
Schema schema = ValidationUtils.CreateSchema();
var queryValidator = new QueryValidator(schema);
// act
QueryValidationResult result = queryValidator.Validate(query);
// assert
Assert.True(result.HasErrors);
Assert.Collection(result.Errors,
t => Assert.Equal(t.Message,
"Fragments can only be declared on unions, interfaces, " +
"and objects."));
}
public void RequiredFieldIsNull()
{
// arrange
DocumentNode query = Parser.Default.Parse(@"
{
findDog2(complex: { name: null })
{
name
}
}
");
Schema schema = ValidationUtils.CreateSchema();
var queryValidator = new QueryValidator(schema);
// act
QueryValidationResult result = queryValidator.Validate(query);
// assert
Assert.True(result.HasErrors);
Assert.Collection(result.Errors,
t => Assert.Equal(
"`name` is a required field and cannot be null.",
t.Message));
}
public void UndefinedFragment()
{
// arrange
DocumentNode query = Parser.Default.Parse(@"
{
dog {
...undefinedFragment
}
}
");
Schema schema = ValidationUtils.CreateSchema();
var queryValidator = new QueryValidator(schema);
// act
QueryValidationResult result = queryValidator.Validate(query);
// assert
Assert.True(result.HasErrors);
Assert.Collection(result.Errors,
t => Assert.Equal(
"The specified fragment `undefinedFragment` " +
"does not exist.",
t.Message));
}
public void VariableNotUsedWithinFragment()
{
// arrange
DocumentNode query = Parser.Default.Parse(@"
query variableNotUsedWithinFragment($atOtherHomes: Boolean) {
dog {
...isHousetrainedWithoutVariableFragment
}
}
fragment isHousetrainedWithoutVariableFragment on Dog {
barkVolume
}
");
Schema schema = ValidationUtils.CreateSchema();
var queryValidator = new QueryValidator(schema);
// act
QueryValidationResult result = queryValidator.Validate(query);
// assert
Assert.True(result.HasErrors);
Assert.Collection(result.Errors,
t => Assert.Equal(
"The following variables were not used: " +
"atOtherHomes.", t.Message));
}
public void SkipDirectiveIsInTheWrongPlace()
{
// arrange
DocumentNode query = Parser.Default.Parse(@"
query @skip(if: $foo) {
field
}
");
Schema schema = ValidationUtils.CreateSchema();
var queryValidator = new QueryValidator(schema);
// act
QueryValidationResult result = queryValidator.Validate(query);
// assert
Assert.True(result.HasErrors);
Assert.Collection(result.Errors,
t => Assert.Equal(
"The field `field` does not exist " +
"on the type `Query`.", t.Message),
t => Assert.Equal(
"The specified directive is not valid the " +
"current location.", t.Message));
}
public void DisallowedSecondRootField()
{
// arrange
DocumentNode query = Parser.Default.Parse(@"
subscription sub {
newMessage {
body
sender
}
disallowedSecondRootField
}
");
Schema schema = ValidationUtils.CreateSchema();
var queryValidator = new QueryValidator(schema);
// act
QueryValidationResult result = queryValidator.Validate(query);
// assert
Assert.True(result.HasErrors);
Assert.Collection(result.Errors,
t => Assert.Equal(
$"Subscription operation `sub` must " +
"have exactly one root field.", t.Message),
t => Assert.Equal(
"The field `disallowedSecondRootField` does not exist " +
"on the type `Subscription`.", t.Message));
}
public void FieldIsNotDefinedOnTypeInFragment()
{
// arrange
DocumentNode query = Parser.Default.Parse(@"
fragment fieldNotDefined on Dog {
meowVolume
}
fragment aliasedLyingFieldTargetNotDefined on Dog {
barkVolume: kawVolume
}
");
Schema schema = ValidationUtils.CreateSchema();
var queryValidator = new QueryValidator(schema);
// act
QueryValidationResult result = queryValidator.Validate(query);
// assert
Assert.True(result.HasErrors);
Assert.Collection(result.Errors,
t => Assert.Equal(
"The field `meowVolume` does not exist " +
"on the type `Dog`.", t.Message),
t => Assert.Equal(
"The field `kawVolume` does not exist " +
"on the type `Dog`.", t.Message));
}
public void FragmentDoesNotMatchType()
{
// arrange
DocumentNode query = Parser.Default.Parse(@"
{
dog {
...fragmentDoesNotMatchType
}
}
fragment fragmentDoesNotMatchType on Human {
name
}
");
Schema schema = ValidationUtils.CreateSchema();
var queryValidator = new QueryValidator(schema);
// act
QueryValidationResult result = queryValidator.Validate(query);
// assert
Assert.True(result.HasErrors);
Assert.Collection(result.Errors,
t => Assert.Equal(t.Message,
"The parent type does not match the type condition on " +
"the fragment `fragmentDoesNotMatchType`."));
}
public void StringIntoInt()
{
// arrange
DocumentNode query = Parser.Default.Parse(@"
{
arguments {
...stringIntoInt
}
}
fragment stringIntoInt on Arguments {
intArgField(intArg: ""123"")
}
");
Schema schema = ValidationUtils.CreateSchema();
var queryValidator = new QueryValidator(schema);
// act
QueryValidationResult result = queryValidator.Validate(query);
// assert
Assert.True(result.HasErrors);
Assert.Collection(result.Errors,
t => Assert.Equal(
"The specified value type of argument `intArg` " +
"does not match the argument type.",
t.Message));
}
public void TwoQueryOperationsWithTheSameName()
{
// arrange
DocumentNode query = Parser.Default.Parse(@"
query getName {
dog {
name
}
}
query getName {
dog {
owner {
name
}
}
}
");
Schema schema = ValidationUtils.CreateSchema();
var queryValidator = new QueryValidator(schema);
// act
QueryValidationResult result = queryValidator.Validate(query);
// assert
Assert.True(result.HasErrors);
Assert.Collection(result.Errors,
t => Assert.Equal(
$"The operation name `getName` is not unique.",
t.Message));
}
public void NameFieldIsAmbiguous()
{
// arrange
DocumentNode query = Parser.Default.Parse(@"
{
findDog(complex: { name: ""A"", name: ""B"" })
{
name
}
}
");
Schema schema = ValidationUtils.CreateSchema();
var queryValidator = new QueryValidator(schema);
// act
QueryValidationResult result = queryValidator.Validate(query);
// assert
Assert.True(result.HasErrors);
Assert.Collection(result.Errors,
t => Assert.Equal(
"Field `name` is ambiguous.",
t.Message));
}
public void UnsupportedDirective()
{
// arrange
DocumentNode query = Parser.Default.Parse(@"
{
dog {
name @foo(bar: true)
}
}
");
Schema schema = ValidationUtils.CreateSchema();
var queryValidator = new QueryValidator(schema);
// act
QueryValidationResult result = queryValidator.Validate(query);
// assert
Assert.True(result.HasErrors);
Assert.Collection(result.Errors,
t => Assert.Equal(
"The specified directive `foo` " +
"is not supported by the current schema.",
t.Message));
}
public void DuplicateArgument()
{
// arrange
DocumentNode query = Parser.Default.Parse(@"
fragment goodNonNullArg on Arguments {
nonNullBooleanArgField(nonNullBooleanArg: true, nonNullBooleanArg: true)
}
");
Schema schema = ValidationUtils.CreateSchema();
var queryValidator = new QueryValidator(schema);
// act
QueryValidationResult result = queryValidator.Validate(query);
// assert
Assert.True(result.HasErrors);
Assert.Collection(result.Errors,
t => Assert.Equal(
$"Arguments are not unique.", t.Message),
t => Assert.Equal(
"The specified fragment `goodNonNullArg` " +
"is not used within the current document.",
t.Message));
}
public void InvalidInputObjectFieldsExist()
{
// arrange
DocumentNode query = Parser.Default.Parse(@"
{
findDog(complex: { favoriteCookieFlavor: ""Bacon"" })
{
name
}
}
");
Schema schema = ValidationUtils.CreateSchema();
var queryValidator = new QueryValidator(schema);
// act
QueryValidationResult result = queryValidator.Validate(query);
// assert
Assert.True(result.HasErrors);
Assert.Collection(result.Errors,
t => Assert.Equal(
"The specified input object field " +
"`favoriteCookieFlavor` does not exist.",
t.Message));
}
public void NotExistingTypeOnInlineFragment()
{
// arrange
DocumentNode query = Parser.Default.Parse(@"
{
dog {
...inlineNotExistingType
}
}
fragment inlineNotExistingType on Dog {
... on NotInSchema {
name
}
}
");
Schema schema = ValidationUtils.CreateSchema();
var queryValidator = new QueryValidator(schema);
// act
QueryValidationResult result = queryValidator.Validate(query);
// assert
Assert.True(result.HasErrors);
Assert.Collection(result.Errors,
t => Assert.Equal(t.Message,
"The specified inline fragment " +
"does not exist in the current schema."));
}
public void QueryWithTypeSystemDefinitions()
{
// arrange
DocumentNode query = Parser.Default.Parse(@"
query getDogName {
dog {
name
color
}
}
extend type Dog {
color: String
}
");
Schema schema = ValidationUtils.CreateSchema();
var queryValidator = new QueryValidator(schema);
// act
QueryValidationResult result = queryValidator.Validate(query);
// assert
Assert.True(result.HasErrors);
Assert.Collection(result.Errors,
t => Assert.Equal(
"A document containing TypeSystemDefinition " +
"is invalid for execution.", t.Message),
t => Assert.Equal(
"The field `color` does not exist " +
"on the type `Dog`.", t.Message));
}
public void OperationWithTwoVariablesThatHaveTheSameName()
{
// arrange
DocumentNode query = Parser.Default.Parse(@"
query houseTrainedQuery($atOtherHomes: Boolean, $atOtherHomes: Boolean) {
dog {
isHousetrained(atOtherHomes: $atOtherHomes)
}
}
");
Schema schema = ValidationUtils.CreateSchema();
var queryValidator = new QueryValidator(schema);
// act
QueryValidationResult result = queryValidator.Validate(query);
// assert
Assert.True(result.HasErrors);
Assert.Collection(result.Errors,
t => Assert.Equal(
"A document containing operations that " +
"define more than one variable with the same " +
"name is invalid for execution.", t.Message),
t => Assert.Equal(
"The field `isHousetrained` does not exist " +
"on the type `Dog`.", t.Message));
}
public void QueriesWithInvalidVariableTypes()
{
// arrange
DocumentNode query = Parser.Default.Parse(@"
query takesCat($cat: Cat) {
# ...
}
query takesDogBang($dog: Dog!) {
# ...
}
query takesListOfPet($pets: [Pet]) {
# ...
}
query takesCatOrDog($catOrDog: CatOrDog) {
# ...
}
");
Schema schema = ValidationUtils.CreateSchema();
var queryValidator = new QueryValidator(schema);
// act
QueryValidationResult result = queryValidator.Validate(query);
// assert
Assert.True(result.HasErrors);
Assert.Collection(result.Errors,
t => Assert.Equal(
"The following variables were not used: cat.",
t.Message),
t => Assert.Equal(
"The following variables were not used: dog.",
t.Message),
t => Assert.Equal(
"The following variables were not used: pets.",
t.Message),
t => Assert.Equal(
"The following variables were not used: catOrDog.",
t.Message),
t => Assert.Equal(
"The type of variable `cat` is not an input type.",
t.Message),
t => Assert.Equal(
"The type of variable `dog` is not an input type.",
t.Message),
t => Assert.Equal(
"The type of variable `pets` is not an input type.",
t.Message),
t => Assert.Equal(
"The type of variable `catOrDog` is not an input type.",
t.Message));
}
public void QueryIsNull()
{
// arrange
Schema schema = ValidationUtils.CreateSchema();
var queryValidator = new QueryValidator(schema);
// act
// act
Action a = () => queryValidator.Validate(null);
// assert
Assert.Throws <ArgumentNullException>(a);
}
public void QueryWithOneAnonymousAndOneNamedOperation()
{
// arrange
DocumentNode query = Parser.Default.Parse(@"
{
dog {
name
}
}
query getName {
dog {
owner {
name
}
}
}
");
Schema schema = ValidationUtils.CreateSchema();
var queryValidator = new QueryValidator(schema);
// act
QueryValidationResult result = queryValidator.Validate(query);
// assert
Assert.True(result.HasErrors);
Assert.Collection(result.Errors,
t =>
{
Assert.Equal(
"GraphQL allows a short‐hand form for defining query " +
"operations when only that one operation exists in the " +
"document.", t.Message);
});
}
public void FragmentCycle1()
{
// arrange
DocumentNode query = Parser.Default.Parse(@"
{
dog {
...nameFragment
}
}
fragment nameFragment on Dog {
name
...barkVolumeFragment
}
fragment barkVolumeFragment on Dog {
barkVolume
...nameFragment
}
");
Schema schema = ValidationUtils.CreateSchema();
var queryValidator = new QueryValidator(schema);
// act
QueryValidationResult result = queryValidator.Validate(query);
// assert
Assert.True(result.HasErrors);
Assert.Collection(result.Errors,
t => Assert.Equal(t.Message,
"The graph of fragment spreads must not form any " +
"cycles including spreading itself. Otherwise an " +
"operation could infinitely spread or infinitely " +
"execute on cycles in the underlying data."));
}
