public void DirectFieldSelectionOnUnion()
{
// arrange
IDocumentValidatorContext context = ValidationUtils.CreateContext();
DocumentNode query = Utf8GraphQLParser.Parse(@"
query {
catOrDog {
... directFieldSelectionOnUnion
}
}
fragment directFieldSelectionOnUnion on CatOrDog {
name
barkVolume
}
");
context.Prepare(query);
// act
Rule.Validate(context, query);
// assert
Assert.Collection(context.Errors,
t => Assert.Equal(
"A union type cannot declare a field directly. " +
"Use inline fragments or fragments instead", t.Message));
context.Errors.First().MatchSnapshot();
}
public void InDirectFieldSelectionOnUnion()
{
// arrange
IDocumentValidatorContext context = ValidationUtils.CreateContext();
DocumentNode query = Utf8GraphQLParser.Parse(@"
query {
dog {
... inDirectFieldSelectionOnUnion
}
}
fragment inDirectFieldSelectionOnUnion on CatOrDog {
__typename
... on Pet {
name
}
... on Dog {
barkVolume
}
}
");
context.Prepare(query);
// act
Rule.Validate(context, query);
// assert
Assert.Empty(context.Errors);
}
public void DefinedOnImplementorsButNotInterfaceOnPet()
{
// arrange
IDocumentValidatorContext context = ValidationUtils.CreateContext();
DocumentNode query = Utf8GraphQLParser.Parse(@"
query {
dog {
... definedOnImplementorsButNotInterface
}
}
fragment definedOnImplementorsButNotInterface on Pet {
nickname
}
");
context.Prepare(query);
// act
Rule.Validate(context, query);
// assert
Assert.Collection(context.Errors,
t => Assert.Equal(
"The field `nickname` does not exist " +
"on the type `Pet`.", t.Message));
context.Errors.First().MatchSnapshot();
}
public void NotOnExistingTypeOnFragment()
{
// arrange
IDocumentValidatorContext context = ValidationUtils.CreateContext();
DocumentNode query = Utf8GraphQLParser.Parse(@"
{
dog {
...notOnExistingType
}
}
fragment notOnExistingType on NotInSchema {
name
}
");
context.Prepare(query);
// act
Rule.Validate(context, query);
// assert
Assert.Collection(context.Errors,
t =>
{
Assert.Equal(
"Unknown type `NotInSchema`.",
t.Message);
});
context.Errors.MatchSnapshot();
}
public static void ExpectValid(
ISchema schema,
Action <IValidationBuilder> configure,
string sourceText)
{
// arrange
var serviceCollection = new ServiceCollection();
IValidationBuilder builder = serviceCollection
.AddValidation()
.ConfigureValidation(c => c.Modifiers.Add(o => o.Rules.Clear()));
configure(builder);
IServiceProvider services = serviceCollection.BuildServiceProvider();
var rule = services.GetRequiredService <IValidationConfiguration>()
.GetRules("Default").First();
IDocumentValidatorContext context = ValidationUtils.CreateContext(schema);
DocumentNode query = Utf8GraphQLParser.Parse(sourceText);
context.Prepare(query);
// act
rule.Validate(context, query);
// assert
Assert.False(context.UnexpectedErrorsDetected);
Assert.Empty(context.Errors);
}
public void TwoOperationsThatShareVariableName()
{
// arrange
IDocumentValidatorContext context = ValidationUtils.CreateContext();
DocumentNode query = Utf8GraphQLParser.Parse(@"
query A($atOtherHomes: Boolean) {
...HouseTrainedFragment
}
query B($atOtherHomes: Boolean) {
...HouseTrainedFragment
}
fragment HouseTrainedFragment on Query {
dog {
isHousetrained(atOtherHomes: $atOtherHomes)
}
}
");
context.Prepare(query);
// act
Rule.Validate(context, query);
// assert
Assert.Empty(context.Errors);
}
public void QueriesWithValidVariableTypes()
{
// arrange
IDocumentValidatorContext context = ValidationUtils.CreateContext();
DocumentNode query = Utf8GraphQLParser.Parse(@"
query takesBoolean($atOtherHomes: Boolean) {
dog {
isHouseTrained(atOtherHomes: $atOtherHomes)
}
}
query takesComplexInput($complexInput: ComplexInput) {
findDog(complex: $complexInput) {
name
}
}
query TakesListOfBooleanBang($booleans: [Boolean!]) {
booleanList(booleanListArg: $booleans)
}
");
context.Prepare(query);
// act
Rule.Validate(context, query);
// assert
Assert.Empty(context.Errors);
}
public void VariableNotUsedWithinFragment()
{
// arrange
IDocumentValidatorContext context = ValidationUtils.CreateContext();
DocumentNode query = Utf8GraphQLParser.Parse(@"
query variableNotUsedWithinFragment($atOtherHomes: Boolean) {
dog {
...isHousetrainedWithoutVariableFragment
}
}
fragment isHousetrainedWithoutVariableFragment on Dog {
isHousetrained
}
");
context.Prepare(query);
// act
Rule.Validate(context, query);
// assert
Assert.Collection(context.Errors,
t => Assert.Equal(
"The following variables were not used: " +
"atOtherHomes.", t.Message));
}
public void VariableUsedInSecondLevelFragment()
{
// arrange
IDocumentValidatorContext context = ValidationUtils.CreateContext();
DocumentNode query = Utf8GraphQLParser.Parse(@"
query variableUsedInFragment($atOtherHomes: Boolean) {
dog {
...isHousetrainedFragment
}
}
fragment isHousetrainedFragment on Dog {
...isHousetrainedFragmentLevel2
}
fragment isHousetrainedFragmentLevel2 on Dog {
isHousetrained(atOtherHomes: $atOtherHomes)
}
");
context.Prepare(query);
// act
Rule.Validate(context, query);
// assert
Assert.False(context.Errors.Count > 0);
}
public void VarsMustBeDefinedInAllOperationsInWhichAFragmentIsUsedErr()
{
// arrange
IDocumentValidatorContext context = ValidationUtils.CreateContext();
DocumentNode query = Utf8GraphQLParser.Parse(@"
query variableIsNotDefinedUsedInNestedFragment {
dog {
...outerHousetrainedFragment
}
}
fragment outerHousetrainedFragment on Dog {
...isHousetrainedFragment
}
fragment isHousetrainedFragment on Dog {
isHousetrained(atOtherHomes: $atOtherHomes)
}");
context.Prepare(query);
// act
Rule.Validate(context, query);
// assert
Assert.True(context.Errors.Count > 0);
Assert.Collection(context.Errors,
t => Assert.Equal(
"The following variables were not declared: " +
"atOtherHomes.", t.Message));
}
public void QueryWithExtraVar()
{
// arrange
IDocumentValidatorContext context = ValidationUtils.CreateContext();
DocumentNode query = Utf8GraphQLParser.Parse(@"
query queryWithUsedVar($atOtherHomes: Boolean) {
dog {
...isHousetrainedFragment
}
}
query queryWithExtraVar($atOtherHomes: Boolean, $extra: Int) {
dog {
...isHousetrainedFragment
}
}
fragment isHousetrainedFragment on Dog {
isHousetrained(atOtherHomes: $atOtherHomes)
}
");
context.Prepare(query);
// act
Rule.Validate(context, query);
// assert
Assert.True(context.Errors.Count > 0);
Assert.Collection(context.Errors,
t => Assert.Equal(
"The following variables were not used: " +
"extra.", t.Message));
}
public void DuplicateFragments()
{
// arrange
IDocumentValidatorContext context = ValidationUtils.CreateContext();
DocumentNode query = Utf8GraphQLParser.Parse(@"
{
dog {
...fragmentOne
}
}
fragment fragmentOne on Dog {
name
}
fragment fragmentOne on Dog {
owner {
name
}
}
");
context.Prepare(query);
// act
Rule.Validate(context, query);
// assert
Assert.Collection(context.Errors,
t => Assert.Equal(
"There are multiple fragments with the name `fragmentOne`.",
t.Message));
context.Errors.First().MatchSnapshot();
}
public void QueryWithSideBySideFragSpreads()
{
// arrange
IDocumentValidatorContext context = ValidationUtils.CreateContext();
DocumentNode query = Utf8GraphQLParser.Parse(@"
{
dog {
...dogFragment
...dogFragment
...dogFragment
...dogFragment
...dogFragment
...dogFragment
...dogFragment
}
}
fragment dogFragment on Dog {
name
}
");
context.Prepare(query);
// act
Rule.Validate(context, query);
// assert
Assert.Empty(context.Errors);
}
public void FragOnScalar()
{
// arrange
IDocumentValidatorContext context = ValidationUtils.CreateContext();
DocumentNode query = Utf8GraphQLParser.Parse(@"
{
dog {
... fragOnScalar
}
}
fragment fragOnScalar on Int {
something
}
");
context.Prepare(query);
// act
Rule.Validate(context, query);
// assert
Assert.Collection(context.Errors,
t => Assert.Equal(t.Message,
"Fragments can only be declared on unions, interfaces, " +
"and objects."));
context.Errors.MatchSnapshot();
}
public void UniqueFragments()
{
// arrange
IDocumentValidatorContext context = ValidationUtils.CreateContext();
DocumentNode query = Utf8GraphQLParser.Parse(@"
{
dog {
...fragmentOne
...fragmentTwo
}
}
fragment fragmentOne on Dog {
name
}
fragment fragmentTwo on Dog {
owner {
name
}
}
");
context.Prepare(query);
// act
Rule.Validate(context, query);
// assert
Assert.Empty(context.Errors);
}
public void UsedNestedFragment()
{
// arrange
IDocumentValidatorContext context = ValidationUtils.CreateContext();
DocumentNode query = Utf8GraphQLParser.Parse(@"
fragment nameFragment on Dog {
name
... nestedNameFragment
}
fragment nestedNameFragment on Dog {
name
}
{
dog {
name
... nameFragment
}
}
");
context.Prepare(query);
// act
Rule.Validate(context, query);
// assert
Assert.Empty(context.Errors);
}
public void FragOnUnion()
{
// arrange
IDocumentValidatorContext context = ValidationUtils.CreateContext();
DocumentNode query = Utf8GraphQLParser.Parse(@"
{
dog {
... fragOnUnion
}
}
fragment fragOnUnion on CatOrDog {
... on Dog {
name
}
}
");
context.Prepare(query);
// act
Rule.Validate(context, query);
// assert
Assert.Empty(context.Errors);
}
public void VarsMustBeDefinedInAllOperationsInWhichAFragmentIsUsed()
{
// arrange
IDocumentValidatorContext context = ValidationUtils.CreateContext();
DocumentNode query = Utf8GraphQLParser.Parse(@"
query housetrainedQueryOne($atOtherHomes: Boolean) {
dog {
...isHousetrainedFragment
}
}
query housetrainedQueryTwo($atOtherHomes: Boolean) {
dog {
...isHousetrainedFragment
}
}
query housetrainedQueryThree {
dog {
isHousetrained(atOtherHomes: true)
}
}
fragment isHousetrainedFragment on Dog {
isHousetrained(atOtherHomes: $atOtherHomes)
}");
context.Prepare(query);
// act
Rule.Validate(context, query);
// assert
Assert.False(context.Errors.Count > 0);
}
public void UnusedFragment()
{
// arrange
IDocumentValidatorContext context = ValidationUtils.CreateContext();
DocumentNode query = Utf8GraphQLParser.Parse(@"
fragment nameFragment on Dog { # unused
name
}
{
dog {
name
}
}
");
context.Prepare(query);
// act
Rule.Validate(context, query);
// assert
Assert.Collection(context.Errors,
t => Assert.Equal(
"The specified fragment `nameFragment` " +
"is not used within the current document.", t.Message));
context.Errors.MatchSnapshot();
}
public void DefinedFragment()
{
// arrange
IDocumentValidatorContext context = ValidationUtils.CreateContext();
DocumentNode query = Utf8GraphQLParser.Parse(@"
{
dog {
...definedFragment
}
}
fragment definedFragment on Dog
{
barkVolume
}
");
context.Prepare(query);
// act
Rule.Validate(context, query);
// assert
Assert.Empty(context.Errors);
}
public void OperationWithTwoVariablesThatHaveTheSameName()
{
// arrange
IDocumentValidatorContext context = ValidationUtils.CreateContext();
DocumentNode query = Utf8GraphQLParser.Parse(@"
query houseTrainedQuery($atOtherHomes: Boolean, $atOtherHomes: Boolean) {
dog {
isHousetrained(atOtherHomes: $atOtherHomes)
}
}
");
context.Prepare(query);
// act
Rule.Validate(context, query);
// assert
Assert.Single(context.Errors);
Assert.Collection(context.Errors,
t => Assert.Equal(
"A document containing operations that " +
"define more than one variable with the same " +
"name is invalid for execution.", t.Message));
}
public void UndefinedFragment()
{
// arrange
IDocumentValidatorContext context = ValidationUtils.CreateContext();
DocumentNode query = Utf8GraphQLParser.Parse(@"
{
dog {
...undefinedFragment
}
}
");
context.Prepare(query);
// act
Rule.Validate(context, query);
// assert
Assert.Collection(context.Errors,
t => Assert.Equal(
"The specified fragment `undefinedFragment` " +
"does not exist.",
t.Message));
context.Errors.MatchSnapshot();
}
public void CorrectTypeOnInlineFragment2()
{
// arrange
IDocumentValidatorContext context = ValidationUtils.CreateContext();
DocumentNode query = Utf8GraphQLParser.Parse(@"
{
dog {
...inlineFragment2
}
}
fragment inlineFragment2 on Dog {
... @include(if: true) {
name
}
}
");
context.Prepare(query);
// act
Rule.Validate(context, query);
// assert
Assert.Empty(context.Errors);
}
public void FragmentDoesNotMatchType()
{
// arrange
IDocumentValidatorContext context = ValidationUtils.CreateContext();
DocumentNode query = Utf8GraphQLParser.Parse(@"
{
dog {
...fragmentDoesNotMatchType
}
}
fragment fragmentDoesNotMatchType on Human {
name
}
");
context.Prepare(query);
// act
Rule.Validate(context, query);
// assert
Assert.Collection(context.Errors,
t => Assert.Equal(t.Message,
"The parent type does not match the type condition on " +
"the fragment."));
context.Errors.MatchSnapshot();
}
public void VariableUsedInDirective()
{
// arrange
IDocumentValidatorContext context = ValidationUtils.CreateContext();
DocumentNode query_a = Utf8GraphQLParser.Parse(@"
query variableUsedInFragment($atOtherHomes: Boolean) {
dog {
...isHousetrainedFragment
}
}
fragment isHousetrainedFragment on Dog {
isHousetrained @skip(if: $atOtherHomes)
}
");
DocumentNode query_b = Utf8GraphQLParser.Parse(@"
query variableUsedInFragment($atOtherHomes: Boolean) {
dog {
...isHousetrainedFragment @skip(if: $atOtherHomes)
}
}
fragment isHousetrainedFragment on Dog {
isHousetrained
}
");
// act
context.Prepare(query_a);
Rule.Validate(context, query_a);
context.Prepare(query_b);
Rule.Validate(context, query_b);
// assert
Assert.Empty(context.Errors);
}
protected void ExpectValid(ISchema schema, string sourceText)
{
// arrange
IDocumentValidatorContext context = ValidationUtils.CreateContext(schema);
DocumentNode query = Utf8GraphQLParser.Parse(sourceText);
context.Prepare(query);
// act
Rule.Validate(context, query);
// assert
Assert.False(context.UnexpectedErrorsDetected);
Assert.Empty(context.Errors);
}
public static void ExpectErrors(
ISchema schema,
Action <IValidationBuilder> configure,
string sourceText,
IEnumerable <KeyValuePair <string, object> > contextData = null,
params Action <IError>[] elementInspectors)
{
// arrange
var serviceCollection = new ServiceCollection();
IValidationBuilder builder = serviceCollection
.AddValidation()
.ConfigureValidation(c => c.Modifiers.Add(o => o.Rules.Clear()));
configure(builder);
IServiceProvider services = serviceCollection.BuildServiceProvider();
var rule = services.GetRequiredService <IValidationConfiguration>()
.GetRules(Schema.DefaultName).First();
IDocumentValidatorContext context = ValidationUtils.CreateContext(schema);
DocumentNode query = Utf8GraphQLParser.Parse(sourceText);
context.Prepare(query);
if (contextData is not null)
{
foreach ((var key, object value) in contextData)
{
context.ContextData[key] = value;
}
}
// act
rule.Validate(context, query);
// assert
Assert.NotEmpty(context.Errors);
if (elementInspectors.Length > 0)
{
Assert.Collection(context.Errors, elementInspectors);
}
context.Errors.MatchSnapshot();
}
public void FragmentCycle2()
{
// arrange
IDocumentValidatorContext context = ValidationUtils.CreateContext();
DocumentNode query = Utf8GraphQLParser.Parse(@"
{
dog {
...nameFragment
}
}
fragment nameFragment on Dog {
name
...barkVolumeFragment
}
fragment barkVolumeFragment on Dog {
barkVolume
...barkVolumeFragment1
}
fragment barkVolumeFragment1 on Dog {
barkVolume
...barkVolumeFragment2
}
fragment barkVolumeFragment2 on Dog {
barkVolume
...nameFragment
}
");
context.Prepare(query);
// act
Rule.Validate(context, query);
// assert
Assert.Collection(context.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."));
context.Errors.MatchSnapshot();
}
public void VariableUsedInListInput()
{
// arrange
IDocumentValidatorContext context = ValidationUtils.CreateContext();
DocumentNode query = Utf8GraphQLParser.Parse(@"
query queryWithListInput($value: Bool)
{
booleanList(booleanListArg: [ $value ])
}");
context.Prepare(query);
// act
Rule.Validate(context, query);
// assert
Assert.False(context.Errors.Count > 0);
}
public void QueriesWithInvalidVariableTypes()
{
// arrange
IDocumentValidatorContext context = ValidationUtils.CreateContext();
DocumentNode query = Utf8GraphQLParser.Parse(@"
query takesCat($cat: Cat) {
# ...
}
query takesDogBang($dog: Dog!) {
# ...
}
query takesListOfPet($pets: [Pet]) {
# ...
}
query takesCatOrDog($catOrDog: CatOrDog) {
# ...
}
");
context.Prepare(query);
// act
Rule.Validate(context, query);
// assert
Assert.NotEmpty(context.Errors);
Assert.Collection(context.Errors,
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));
}
