public void CreateRepeatableDirectiveType()
{
// arrange
var source = "directive @foo(a:String) repeatable on QUERY";
// act
ISchema schema = SchemaBuilder.New()
.AddDocumentFromString(source)
.AddQueryType <DummyQuery>()
.Create();
// assert
DirectiveType type = schema.GetDirectiveType("foo");
Assert.Equal("foo", type.Name);
Assert.True(type.IsRepeatable);
Assert.Collection(type.Locations,
t => Assert.Equal(DirectiveLocation.Query, t));
Assert.Collection(type.Arguments,
t =>
{
Assert.Equal("a", t.Name);
Assert.IsType <StringType>(t.Type);
});
}
private void CompleteDirective(
ITypeInitializationContext context,
DirectiveDescription description,
HashSet <string> processed)
{
DirectiveReference reference =
DirectiveReference.FromDescription(description);
DirectiveType directiveType = context.GetDirectiveType(reference);
if (directiveType != null)
{
if (!processed.Add(directiveType.Name) &&
!directiveType.IsRepeatable)
{
context.ReportError(new SchemaError(
$"The specified directive `@{directiveType.Name}` " +
"is unique and cannot be added twice.",
context.Type as INamedType));
}
else if (directiveType.Locations.Contains(_location))
{
_directives.Add(Directive.FromDescription(
directiveType, description, _source));
}
else
{
context.ReportError(new SchemaError(
$"The specified directive `@{directiveType.Name}` " +
"is not allowed on the current location " +
$"`{_location}`.",
context.Type as INamedType));
}
}
}
public void DirectiveOrderIsSignificant()
{
// arrange
var someType = new ObjectType(t =>
t.Name("Foo")
.Field("abc")
.Type <StringType>()
.Resolve("abc")
.Directive(new DirectiveNode("foo"))
.Directive(new DirectiveNode("bar")));
var foo = new DirectiveType(d => d
.Name("foo")
.Location(DirectiveLocation.FieldDefinition));
var bar = new DirectiveType(d => d
.Name("bar")
.Location(DirectiveLocation.FieldDefinition));
// act
ISchema schema = CreateSchema(b =>
{
b.AddType(someType);
b.AddDirectiveType(foo);
b.AddDirectiveType(bar);
});
// assert
Assert.Collection(someType.Fields["abc"].Directives,
t => Assert.Equal("foo", t.Name),
t => Assert.Equal("bar", t.Name));
}
public void CreateSkipDirective()
{
// arrange
SchemaContext schemaContext = SchemaContextFactory.Create();
SchemaConfiguration schemaConfiguration =
new SchemaConfiguration(
sp => { },
schemaContext.Types,
schemaContext.Resolvers,
schemaContext.Directives);
TypeFinalizer typeFinalizer = new TypeFinalizer(schemaConfiguration);
typeFinalizer.FinalizeTypes(schemaContext, null);
// assert
DirectiveType directive = schemaContext.Directives
.GetDirectiveTypes().FirstOrDefault(t => t.Name == "skip");
// assert
Assert.NotNull(directive);
Assert.IsType <SkipDirective>(directive);
Assert.Equal("skip", directive.Name);
Assert.Collection(directive.Arguments,
t =>
{
Assert.Equal("if", t.Name);
Assert.IsType <NonNullType>(t.Type);
Assert.IsType <BooleanType>(((NonNullType)t.Type).Type);
});
Assert.Collection(directive.Locations,
t => Assert.Equal(DirectiveLocation.Field, t),
t => Assert.Equal(DirectiveLocation.FragmentSpread, t),
t => Assert.Equal(DirectiveLocation.InlineFragment, t));
}
internal static Directive FromDescription(
DirectiveType directiveType,
DirectiveDescription description,
object source)
{
if (directiveType == null)
{
throw new ArgumentNullException(nameof(directiveType));
}
if (description == null)
{
throw new ArgumentNullException(nameof(description));
}
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
if (description.CustomDirective is null)
{
return(new Directive(directiveType,
description.ParsedDirective,
source));
}
else
{
return(new Directive(directiveType,
description.CustomDirective,
source));
}
}
public void MapCustomDirectiveToDifferentType()
{
// arrange
ISchema schema = CreateSchema();
DirectiveType directiveType = schema.GetDirectiveType("Foo");
var fooDirective = new FooDirective
{
Bar = "123",
Child = new FooChild
{
Bar = "456"
}
};
// act
var directive = Directive.FromDescription(
directiveType,
new DirectiveDefinition(
fooDirective,
_typeInspector.GetTypeRef(fooDirective.GetType())),
new object());
FooChild mappedObject = directive.ToObject <FooChild>();
// assert
Assert.Equal("123", mappedObject.Bar);
}
public void EnsureSkipDirectiveIsAvailable()
{
// arrange
ISchema schema = CreateSchema(b => { });
// act
DirectiveType directive =
schema.DirectiveTypes.FirstOrDefault(
t => t.Name.Equals("skip"));
// assert
Assert.NotNull(directive);
Assert.IsType <SkipDirectiveType>(directive);
Assert.Equal("skip", directive.Name);
Assert.Collection(directive.Arguments,
t =>
{
Assert.Equal("if", t.Name);
Assert.IsType <NonNullType>(t.Type);
Assert.IsType <BooleanType>(((NonNullType)t.Type).Type);
});
Assert.Collection(directive.Locations,
t => Assert.Equal(DirectiveLocation.Field, t),
t => Assert.Equal(DirectiveLocation.FragmentSpread, t),
t => Assert.Equal(DirectiveLocation.InlineFragment, t));
}
public void GetArgumentFromCustomDirective()
{
// arrange
ISchema schema = CreateSchema();
DirectiveType directiveType = schema.GetDirectiveType("Foo");
var fooDirective = new FooDirective
{
Bar = "123",
Child = new FooChild
{
Bar = "456"
}
};
// act
var directive = Directive.FromDescription(
directiveType,
new DirectiveDefinition(
fooDirective,
_typeInspector.GetTypeRef(fooDirective.GetType())),
new object());
var barValue = directive.GetArgument <string>("bar");
// assert
Assert.Equal("123", barValue);
}
public void DirectiveIsRepeatable()
{
// arrange
var someType = new ObjectType(t =>
t.Name("Foo")
.Field("abc")
.Type <StringType>()
.Resolve("abc")
.Directive(new DirectiveNode("foo"))
.Directive(new DirectiveNode("foo")));
var foo = new DirectiveType(d => d
.Name("foo")
.Location(DirectiveLocation.FieldDefinition)
.Repeatable());
// act
CreateSchema(b =>
{
b.AddType(someType);
b.AddDirectiveType(foo);
});
// assert
Assert.Collection(someType.Fields["abc"].Directives,
t => Assert.Equal("foo", t.Name),
t => Assert.Equal("foo", t.Name));
}
public void DirectiveIsNotRepeatable()
{
// arrange
var someType = new ObjectType(t =>
t.Name("Foo")
.Field("abc")
.Type <StringType>()
.Resolve("abc")
.Directive(new DirectiveNode("foo"))
.Directive(new DirectiveNode("foo")));
var foo = new DirectiveType(d =>
d.Name("foo").Location(DirectiveLocation.FieldDefinition));
// act
Action action = () => CreateSchema(b =>
{
b.AddType(someType);
b.AddDirectiveType(foo);
});
// assert
Assert.Collection(Assert.Throws <SchemaException>(action).Errors,
t => Assert.Equal(
"The specified directive `@foo` " +
"is unique and cannot be added twice.",
t.Message));
}
public void InvalidLocation()
{
// arrange
var someType = new ObjectType(t => t
.Name("Foo")
.Field("abc")
.Type <StringType>()
.Resolve("abc")
.Directive(new DirectiveNode("foo")));
var foo = new DirectiveType(d => d
.Name("foo")
.Location(DirectiveLocation.Object));
// act
Action action = () => CreateSchema(b =>
{
b.AddType(someType);
b.AddDirectiveType(foo);
});
// assert
Assert.Collection(Assert.Throws <SchemaException>(action).Errors,
t => Assert.Equal(
"The specified directive `@foo` " +
"is not allowed on the current location " +
$"`{DirectiveLocation.FieldDefinition}`.",
t.Message));
}
public void UniqueDirective()
{
// arrange
var directiveType = new DirectiveType(
t => t.Name("foo")
.Location(DirectiveLocation.Object)
.Argument("a").Type <StringType>());
var objectType = new ObjectType(t =>
{
t.Name("Bar");
t.Directive("foo", new ArgumentNode("a", "1"));
t.Directive("foo", new ArgumentNode("a", "2"));
t.Field("foo").Resolver(() => "baz");
});
// act
Action a = () => Schema.Create(t =>
{
t.RegisterDirective(directiveType);
t.RegisterQueryType(objectType);
});
// assert
SchemaException exception = Assert.Throws <SchemaException>(a);
Assert.Collection(exception.Errors,
t =>
{
Assert.Equal(
"The specified directive `@foo` " +
"is unique and cannot be added twice.",
t.Message);
});
}
public static void MergeDirectives(
ICompletionContext context,
IList <DirectiveDefinition> extension,
IList <DirectiveDefinition> type)
{
var directives =
new List <(DirectiveType type, DirectiveDefinition def)>();
foreach (DirectiveDefinition directive in type)
{
DirectiveType directiveType =
context.GetDirectiveType(directive.Reference);
directives.Add((directiveType, directive));
}
foreach (DirectiveDefinition directive in extension)
{
MergeDirective(context, directives, directive);
}
type.Clear();
foreach (DirectiveDefinition directive in
directives.Select(t => t.def))
{
type.Add(directive);
}
}
public void DirectiveOrderIsSignificant()
{
// act
var someType = new ObjectType(t => t.Name("Foo"));
var directiveDescriptions = new List <DirectiveDescription>
{
new DirectiveDescription(new DirectiveNode("foo")),
new DirectiveDescription(new DirectiveNode("bar"))
};
var foo = new DirectiveType(d =>
d.Name("foo").Location(DirectiveLocation.Field));
var bar = new DirectiveType(d =>
d.Name("bar").Location(DirectiveLocation.Field));
var context = new Mock <ITypeInitializationContext>(
MockBehavior.Strict);
context.Setup(
t => t.GetDirectiveType(It.IsAny <DirectiveReference>()))
.Returns(new Func <DirectiveReference, DirectiveType>(
r =>
{
if (r.Name == "foo")
{
return(foo);
}
if (r.Name == "bar")
{
return(bar);
}
return(null);
}
));
// act
var collection = new DirectiveCollection(
someType, DirectiveLocation.Field,
directiveDescriptions);
((INeedsInitialization)collection)
.RegisterDependencies(context.Object);
((INeedsInitialization)collection)
.CompleteType(context.Object);
// assert
Assert.Collection(collection,
t => Assert.Equal("foo", t.Name),
t => Assert.Equal("bar", t.Name));
}
public void ConfigureTypedDirectiveWithResolver()
{
// arrange
// act
DirectiveType directiveType =
CreateDirective <CustomDirectiveType>();
// assert
Assert.True(directiveType.IsExecutable);
Assert.NotNull(directiveType.Middleware);
Assert.Equal(typeof(CustomDirective), directiveType.ClrType);
}
public void ConfigureTypedDirectiveWithResolver()
{
// arrange
// act
DirectiveType directiveType =
CreateDirective(new CustomDirectiveType());
// assert
Assert.True(directiveType.IsExecutable);
Assert.NotEmpty(directiveType.MiddlewareComponents);
Assert.Equal(typeof(CustomDirective), directiveType.ClrType);
}
internal Directive(
DirectiveType directiveType,
DirectiveNode parsedDirective,
object source)
{
Type = directiveType
?? throw new ArgumentNullException(nameof(directiveType));
_parsedDirective = parsedDirective
?? throw new ArgumentNullException(nameof(parsedDirective));
Source = source
?? throw new ArgumentNullException(nameof(source));
Name = directiveType.Name;
}
internal Directive(
DirectiveType directiveType,
object customDirective,
object source)
{
Type = directiveType
?? throw new ArgumentNullException(nameof(directiveType));
_customDirective = customDirective
?? throw new ArgumentNullException(nameof(customDirective));
Source = source
?? throw new ArgumentNullException(nameof(source));
Name = directiveType.Name;
}
public void ConfigureTypedDirectiveNoArguments()
{
// arrange
// act
DirectiveType directiveType =
CreateDirective(new Custom2DirectiveType());
// assert
Assert.True(directiveType.HasMiddleware);
Assert.NotEmpty(directiveType.MiddlewareComponents);
Assert.Equal(typeof(CustomDirective), directiveType.RuntimeType);
Assert.Empty(directiveType.Arguments);
}
public void ConfigureTypedDirectiveWithResolver()
{
// arrange
// act
DirectiveType directiveType =
CreateDirective(new CustomDirectiveType());
// assert
Assert.True(directiveType.HasMiddleware);
Assert.NotEmpty(directiveType.MiddlewareComponents);
Assert.Equal(typeof(CustomDirective), directiveType.RuntimeType);
Assert.Collection(directiveType.Arguments,
t => Assert.Equal("argument", t.Name.Value));
}
public void ConfigureTypedDirective_DefaultBinding_Explicit()
{
// arrange
// act
DirectiveType directiveType =
CreateDirective(new CustomDirectiveType(),
b => b.ModifyOptions(o =>
o.DefaultBindingBehavior = BindingBehavior.Explicit));
// assert
Assert.True(directiveType.IsExecutable);
Assert.NotEmpty(directiveType.MiddlewareComponents);
Assert.Equal(typeof(CustomDirective), directiveType.ClrType);
Assert.Empty(directiveType.Arguments);
}
private Directive(
DirectiveType directiveType,
DirectiveNode parsedDirective,
object?customDirective,
object source)
{
Type = directiveType
?? throw new ArgumentNullException(nameof(directiveType));
_parsedDirective = parsedDirective
?? throw new ArgumentNullException(nameof(parsedDirective));
_customDirective = customDirective;
Source = source
?? throw new ArgumentNullException(nameof(source));
Name = directiveType.Name;
}
public void ConfigureDirectiveWithResolver()
{
// arrange
DirectiveType directiveType = new DirectiveType(
t => t.Name("Foo")
.Location(DirectiveLocation.Field)
.Middleware(next => context => Task.CompletedTask));
// act
directiveType = CreateDirective(directiveType);
// assert
Assert.True(directiveType.IsExecutable);
Assert.NotNull(directiveType.Middleware);
Assert.Null(directiveType.ClrType);
}
public void ConfigureDirectiveWithResolver()
{
// arrange
var directiveType = new DirectiveType(t => t
.Name("Foo")
.Location(DirectiveLocation.Field)
.Use(next => context => default(ValueTask)));
// act
directiveType = CreateDirective(directiveType);
// assert
Assert.True(directiveType.HasMiddleware);
Assert.NotEmpty(directiveType.MiddlewareComponents);
Assert.Equal(typeof(object), directiveType.RuntimeType);
}
public void ConfigureDirectiveWithResolver()
{
// arrange
var directiveType = new DirectiveType(t => t
.Name("Foo")
.Location(DirectiveLocation.Field)
.Use(next => context => Task.CompletedTask));
// act
directiveType = CreateDirective(directiveType);
// assert
Assert.True(directiveType.IsExecutable);
Assert.NotEmpty(directiveType.MiddlewareComponents);
Assert.Equal(typeof(object), directiveType.ClrType);
}
private bool TryCompleteDirective(
ICompletionContext context,
DirectiveDefinition definition,
ISet <string> processed,
out Directive directive)
{
DirectiveType directiveType = context.GetDirectiveType(definition.Reference);
directive = null;
if (directiveType != null)
{
if (!processed.Add(directiveType.Name) && !directiveType.IsRepeatable)
{
context.ReportError(SchemaErrorBuilder.New()
.SetMessage(string.Format(
CultureInfo.InvariantCulture,
TypeResources.DirectiveCollection_DirectiveIsUnique,
directiveType.Name))
.SetCode(ErrorCodes.Schema.MissingType)
.SetTypeSystemObject(context.Type)
.AddSyntaxNode(definition.ParsedDirective)
.SetExtension("Source", _source)
.Build());
}
else if (directiveType.Locations.Contains(_location))
{
directive = Directive.FromDescription(directiveType, definition, _source);
}
else
{
context.ReportError(SchemaErrorBuilder.New()
.SetMessage(string.Format(
CultureInfo.InvariantCulture,
TypeResources.DirectiveCollection_LocationNotAllowed,
directiveType.Name,
_location))
.SetCode(ErrorCodes.Schema.MissingType)
.SetTypeSystemObject(context.Type)
.AddSyntaxNode(definition.ParsedDirective)
.SetExtension("Source", _source)
.Build());
}
}
return(directive != null);
}
public void ExecutableRepeatableDirectives()
{
// arrange
var directiveType = new DirectiveType(
t => t.Name("foo")
.Repeatable()
.Location(DirectiveLocation.Object)
.Location(DirectiveLocation.FieldDefinition)
.Use(next => context => Task.CompletedTask)
.Argument("a").Type <StringType>());
var objectType = new ObjectType(t =>
{
t.Name("Bar");
t.Directive("foo", new ArgumentNode("a", "1"));
t.Field("foo").Resolver(() => "baz")
.Directive("foo", new ArgumentNode("a", "2"));
});
// act
var schema = Schema.Create(t =>
{
t.RegisterDirective(directiveType);
t.RegisterQueryType(objectType);
});
// assert
IReadOnlyCollection <IDirective> collection =
schema.GetType <ObjectType>("Bar")
.Fields["foo"].ExecutableDirectives;
Assert.Collection(collection,
t =>
{
Assert.Equal("foo", t.Name);
Assert.Equal("1", t.GetArgument <string>("a"));
},
t =>
{
Assert.Equal("foo", t.Name);
Assert.Equal("2", t.GetArgument <string>("a"));
});
}
private void CompleteDirective(
ICompletionContext context,
DirectiveDefinition definition,
ISet <string> processed)
{
DirectiveType directiveType =
context.GetDirectiveType(definition.Reference);
if (directiveType != null)
{
if (!processed.Add(directiveType.Name) &&
!directiveType.IsRepeatable)
{
// TODO : resources
context.ReportError(SchemaErrorBuilder.New()
.SetMessage(
$"The specified directive `@{directiveType.Name}` " +
"is unique and cannot be added twice.")
.SetCode(TypeErrorCodes.MissingType)
.SetTypeSystemObject(context.Type)
.AddSyntaxNode(definition.ParsedDirective)
.Build());
}
else if (directiveType.Locations.Contains(_location))
{
_directives.Add(Directive.FromDescription(
directiveType, definition, _source));
}
else
{
// TODO : resources
context.ReportError(SchemaErrorBuilder.New()
.SetMessage(
$"The specified directive `@{directiveType.Name}` " +
"is not allowed on the current location " +
$"`{_location}`.")
.SetCode(TypeErrorCodes.MissingType)
.SetTypeSystemObject(context.Type)
.AddSyntaxNode(definition.ParsedDirective)
.Build());
}
}
}
public void ConvertCustomDirectiveToDirectiveNode()
{
// arrange
ISchema schema = CreateSchema();
DirectiveType directiveType = schema.GetDirectiveType("Foo");
var fooDirective = new FooDirective
{
Bar = "123",
Child = new FooChild
{
Bar = "456"
}
};
// act
var directive = Directive.FromDescription(
directiveType,
new DirectiveDefinition(
fooDirective,
_typeInspector.GetTypeRef(fooDirective.GetType())),
new object());
DirectiveNode directiveNode = directive.ToNode();
// assert
Assert.Equal(directiveType.Name, directiveNode.Name.Value);
Assert.Collection(directiveNode.Arguments,
t =>
{
Assert.Equal("bar", t.Name.Value);
Assert.Equal("123", ((StringValueNode)t.Value).Value);
},
t =>
{
Assert.Equal("child", t.Name.Value);
Assert.Collection(((ObjectValueNode)t.Value).Fields,
x =>
{
Assert.Equal("bar", x.Name.Value);
Assert.Equal("456",
((StringValueNode)x.Value).Value);
});
});
}
public void DirectiveNotRepeatable()
{
// act
var someType = new ObjectType(t => t.Name("Foo"));
var directiveDescriptions = new List <DirectiveDescription>
{
new DirectiveDescription(new DirectiveNode("foo")),
new DirectiveDescription(new DirectiveNode("foo"))
};
var foo = new DirectiveType(d =>
d.Name("foo").Location(DirectiveLocation.Field));
var errors = new List <SchemaError>();
var context = new Mock <ITypeInitializationContext>();
context.Setup(
t => t.GetDirectiveType(It.IsAny <DirectiveReference>()))
.Returns(new Func <DirectiveReference, DirectiveType>(
r => foo));
context.Setup(t => t.ReportError(It.IsAny <SchemaError>()))
.Callback(new Action <SchemaError>(errors.Add));
// act
var collection = new DirectiveCollection(
someType, DirectiveLocation.Field,
directiveDescriptions);
((INeedsInitialization)collection)
.RegisterDependencies(context.Object);
((INeedsInitialization)collection)
.CompleteType(context.Object);
// assert
Assert.Collection(errors,
t => Assert.Equal(
"The specified directive `@foo` " +
"is unique and cannot be added twice.",
t.Message));
}
