public void DeclareUnion_MarkerInterfaceAndTypeSet()
{
// arrange
var errors = new List <SchemaError>();
var schemaContext = new SchemaContext();
schemaContext.Types.RegisterType(new FooType());
schemaContext.Types.RegisterType(new BarType());
// act
var fooType = new UnionType <IFooOrBar>(c => c.Type <BazType>());
// assert
schemaContext.Types.RegisterType(fooType);
INeedsInitialization init = fooType;
var initializationContext = new TypeInitializationContext(
schemaContext, a => errors.Add(a), fooType, false);
init.RegisterDependencies(initializationContext);
schemaContext.CompleteTypes();
Assert.Empty(errors);
Assert.Collection(fooType.Types.Values,
t => Assert.Equal("Baz", t.Name),
t => Assert.Equal("Foo", t.Name),
t => Assert.Equal("Bar", t.Name));
}
public void IntArgumentIsInferedAsNonNullType()
{
// arrange
var errors = new List <SchemaError>();
var schemaContext = new SchemaContext();
var intType = new IntType();
schemaContext.Types.RegisterType(intType);
// act
var fooType = new ObjectType <QueryWithIntArg>();
// assert
var initializationContext = new TypeInitializationContext(
schemaContext, a => errors.Add(a), fooType, false);
((INeedsInitialization)fooType)
.RegisterDependencies(initializationContext);
schemaContext.CompleteTypes();
Assert.Empty(errors);
IType argumentType = fooType.Fields["bar"]
.Arguments.First().Type;
Assert.NotNull(argumentType);
Assert.True(argumentType.IsNonNullType());
Assert.Equal(intType, argumentType.NamedType());
}
public void DeclareUnion_ByProvidingExplicitTypeSet()
{
// arrange
var errors = new List <SchemaError>();
var schemaContext = new SchemaContext();
// act
var fooType = new UnionType(d => d
.Type <FooType>()
.Type <BarType>());
// assert
schemaContext.Types.RegisterType(fooType);
INeedsInitialization init = fooType;
var initializationContext = new TypeInitializationContext(
schemaContext, a => errors.Add(a), fooType, false);
init.RegisterDependencies(initializationContext);
schemaContext.CompleteTypes();
Assert.Empty(errors);
Assert.Collection(fooType.Types.Values,
t => Assert.Equal("Foo", t.Name),
t => Assert.Equal("Bar", t.Name));
}
public void UnionType_AddDirectives_DirectiveClassInstance()
{
// arrange
var errors = new List <SchemaError>();
var schemaContext = new SchemaContext();
schemaContext.Directives.RegisterDirectiveType <FooDirectiveType>();
// act
var fooType = new UnionType(
d => d.Directive(new FooDirective())
.Type <FooType>()
.Type <BarType>());
// assert
schemaContext.Types.RegisterType(fooType);
INeedsInitialization init = fooType;
var initializationContext = new TypeInitializationContext(
schemaContext, a => errors.Add(a), fooType, false);
init.RegisterDependencies(initializationContext);
schemaContext.CompleteTypes();
Assert.Empty(errors);
Assert.NotEmpty(fooType.Directives["foo"]);
}
public void GenericInputObject_AddDirectives_NameArgs2()
{
// arrange
var errors = new List <SchemaError>();
var schemaContext = new SchemaContext();
schemaContext.Directives.RegisterDirectiveType <FooDirectiveType>();
// act
var fooType = new InputObjectType <SimpleInput>(
d => d.Directive(new NameString("foo"))
.Field(f => f.Id)
.Directive(new NameString("foo")));
// assert
schemaContext.Types.RegisterType(fooType);
INeedsInitialization init = fooType;
var initializationContext = new TypeInitializationContext(
schemaContext, a => errors.Add(a), fooType, false);
init.RegisterDependencies(initializationContext);
schemaContext.CompleteTypes();
Assert.Empty(errors);
Assert.NotEmpty(fooType.Directives["foo"]);
Assert.NotEmpty(fooType.Fields["id"].Directives["foo"]);
}
public void InterfaceType_AddDirectives_DirectiveType()
{
// arrange
var errors = new List <SchemaError>();
var schemaContext = new SchemaContext();
schemaContext.Directives.RegisterDirectiveType <FooDirectiveType>();
// act
var fooType = new InterfaceType(
d => d.Directive <FooDirective>()
.Field("id")
.Type <StringType>()
.Directive <FooDirective>());
// assert
schemaContext.Types.RegisterType(fooType);
INeedsInitialization init = fooType;
var initializationContext = new TypeInitializationContext(
schemaContext, a => errors.Add(a), fooType, false);
init.RegisterDependencies(initializationContext);
schemaContext.CompleteTypes();
Assert.Empty(errors);
Assert.NotEmpty(fooType.Directives["foo"]);
Assert.NotEmpty(fooType.Fields["id"].Directives["foo"]);
}
public void CheckFieldsAreCorrect()
{
// arrange
var errors = new List <SchemaError>();
var schemaContext = new SchemaContext();
// act
var type = new ConnectionType <StringType>();
// assert
INeedsInitialization init = type;
var initializationContext = new TypeInitializationContext(
schemaContext, a => errors.Add(a), type, false);
init.RegisterDependencies(initializationContext);
schemaContext.CompleteTypes();
Assert.Collection(type.Fields.Where(t => !t.IsIntrospectionField),
t =>
{
Assert.Equal("pageInfo", t.Name);
Assert.IsType <NonNullType>(t.Type);
Assert.IsType <PageInfoType>(((NonNullType)t.Type).Type);
},
t =>
{
Assert.Equal("edges", t.Name);
Assert.IsType <ListType>(t.Type);
Assert.IsType <NonNullType>(((ListType)t.Type).ElementType);
Assert.IsType <EdgeType <StringType> >(
((NonNullType)((ListType)t.Type).ElementType).Type);
});
}
public void CheckFieldsAreCorrect()
{
// arrange
var errors = new List <SchemaError>();
var schemaContext = new SchemaContext();
// act
var type = new PageInfoType();
// assert
INeedsInitialization init = type;
var initializationContext = new TypeInitializationContext(
schemaContext, a => errors.Add(a), type, false);
init.RegisterDependencies(initializationContext);
schemaContext.CompleteTypes();
Assert.Collection(type.Fields.Where(t => !t.IsIntrospectionField),
t =>
{
Assert.Equal("hasNextPage", t.Name);
Assert.Equal(
"Indicates whether more edges exist following " +
"the set defined by the clients arguments.",
t.Description);
Assert.IsType <NonNullType>(t.Type);
Assert.IsType <BooleanType>(((NonNullType)t.Type).Type);
},
t =>
{
Assert.Equal("hasPreviousPage", t.Name);
Assert.Equal(
"Indicates whether more edges exist prior " +
"the set defined by the clients arguments.",
t.Description);
Assert.IsType <NonNullType>(t.Type);
Assert.IsType <BooleanType>(((NonNullType)t.Type).Type);
},
t =>
{
Assert.Equal("startCursor", t.Name);
Assert.IsType <StringType>(t.Type);
},
t =>
{
Assert.Equal("endCursor", t.Name);
Assert.IsType <StringType>(t.Type);
});
}
public void CreateObjectType()
{
// arrange
var scalarType = new StringType();
var parser = new Parser();
DocumentNode document = parser.Parse(
"type Simple { a: String b: [String] }");
ObjectTypeDefinitionNode objectTypeDefinition = document
.Definitions.OfType <ObjectTypeDefinitionNode>().First();
var resolverBinding = new DelegateResolverBinding(
"Simple", "a",
(c, r) => "hello");
var serviceManager = new ServiceManager();
var schemaContext = new SchemaContext(serviceManager);
schemaContext.Types.RegisterType(scalarType);
schemaContext.Resolvers.RegisterResolver(resolverBinding);
// act
var factory = new ObjectTypeFactory();
ObjectType objectType = factory.Create(objectTypeDefinition);
schemaContext.Types.RegisterType(objectType);
var initializationContext = new TypeInitializationContext(
schemaContext, error => { }, objectType, false);
((INeedsInitialization)objectType)
.RegisterDependencies(initializationContext);
schemaContext.CompleteTypes();
// assert
Assert.Equal("Simple", objectType.Name);
Assert.Equal(3, objectType.Fields.Count);
Assert.True(objectType.Fields.ContainsField("a"));
Assert.True(objectType.Fields.ContainsField("b"));
Assert.False(objectType.Fields["a"].Type.IsNonNullType());
Assert.False(objectType.Fields["a"].Type.IsListType());
Assert.True(objectType.Fields["a"].Type.IsScalarType());
Assert.Equal("String", objectType.Fields["a"].Type.TypeName());
Assert.False(objectType.Fields["b"].Type.IsNonNullType());
Assert.True(objectType.Fields["b"].Type.IsListType());
Assert.False(objectType.Fields["b"].Type.IsScalarType());
Assert.Equal("String", objectType.Fields["b"].Type.TypeName());
Assert.Equal("hello", (objectType.Fields["a"]
.Resolver(null, CancellationToken.None)));
}
public void InferFieldsFromClrInterface()
{
// arrange
var errors = new List <SchemaError>();
var schemaContext = new SchemaContext();
schemaContext.Types.RegisterType(new BooleanType());
schemaContext.Types.RegisterType(new StringType());
schemaContext.Types.RegisterType(new IntType());
// act
var fooType = new InterfaceType <IFoo>();
schemaContext.Types.RegisterType(fooType);
INeedsInitialization init = fooType;
var initializationContext = new TypeInitializationContext(
schemaContext, a => errors.Add(a), fooType, false);
init.RegisterDependencies(initializationContext);
schemaContext.CompleteTypes();
// assert
Assert.Empty(errors);
Assert.Collection(
fooType.Fields.Where(t => !t.IsIntrospectionField),
t =>
{
Assert.Equal("bar", t.Name);
Assert.IsType <BooleanType>(
Assert.IsType <NonNullType>(t.Type).Type);
},
t =>
{
Assert.Equal("baz", t.Name);
Assert.IsType <StringType>(t.Type);
},
t =>
{
Assert.Equal("qux", t.Name);
Assert.IsType <IntType>(
Assert.IsType <NonNullType>(t.Type).Type);
Assert.Collection(t.Arguments,
a => Assert.Equal("a", a.Name));
});
}
public void IntializeImpicitFieldWithImplicitResolver()
{
// arrange
ServiceManager services = new ServiceManager();
List <SchemaError> errors = new List <SchemaError>();
SchemaContext context = new SchemaContext(services);
// act
ObjectType <Foo> fooType = new ObjectType <Foo>();
((INeedsInitialization)fooType).RegisterDependencies(
context, e => errors.Add(e));
context.CompleteTypes();
// assert
Assert.Empty(errors);
Assert.NotNull(fooType.Fields.Values.First().Resolver);
}
public void GenericObjectTypes()
{
// arrange
var errors = new List <SchemaError>();
var schemaContext = new SchemaContext();
// act
var genericType = new ObjectType <GenericFoo <string> >();
INeedsInitialization init = genericType;
var initializationContext = new TypeInitializationContext(
schemaContext, a => errors.Add(a), genericType, false);
init.RegisterDependencies(initializationContext);
schemaContext.CompleteTypes();
// assert
Assert.Equal("GenericFooOfString", genericType.Name);
}
public void IntializeImpicitFieldWithImplicitResolver()
{
// arrange
var errors = new List <SchemaError>();
var schemaContext = new SchemaContext();
// act
var fooType = new ObjectType <Foo>();
INeedsInitialization init = fooType;
var initializationContext = new TypeInitializationContext(
schemaContext, a => errors.Add(a), fooType, false);
init.RegisterDependencies(initializationContext);
schemaContext.CompleteTypes();
// assert
Assert.Empty(errors);
Assert.NotNull(fooType.Fields.First().Resolver);
}
public void EnsureObjectTypeKindIsCorret()
{
// arrange
ServiceManager services = new ServiceManager();
List <SchemaError> errors = new List <SchemaError>();
SchemaContext context = new SchemaContext(services);
ObjectType <Foo> someObject = new ObjectType <Foo>(
d => d.Field(f => f.Description).Name("a"));
((INeedsInitialization)someObject).RegisterDependencies(
context, e => errors.Add(e));
context.CompleteTypes();
// act
TypeKind kind = someObject.Kind;
// assert
Assert.Equal(TypeKind.Object, kind);
}
internal static TypeResult <T> CreateType <T>(
Func <ISchemaContext, T> factory)
where T : class, INamedType, INeedsInitialization
{
var errors = new List <SchemaError>();
var schemaContext = new SchemaContext();
var type = factory(schemaContext);
schemaContext.Types.RegisterType(type);
var initializationContext = new TypeInitializationContext(
schemaContext, a => errors.Add(a), type, false);
type.RegisterDependencies(initializationContext);
schemaContext.CompleteTypes();
return(new TypeResult <T>(type, errors));
}
public async Task FieldMiddlewareIsIntegrated()
{
// arrange
var resolverContext = new Mock <IMiddlewareContext>();
resolverContext.SetupAllProperties();
var errors = new List <SchemaError>();
var schemaContext = new SchemaContext();
var stringType = new StringType();
schemaContext.Types.RegisterType(stringType);
schemaContext.Resolvers.RegisterMiddleware(next => async context =>
{
await next(context);
if (context.Result is string s)
{
context.Result = s.ToUpperInvariant();
}
});
// act
var fooType = new ObjectType(c =>
c.Name("Foo").Field("bar").Resolver(() => "baz"));
// assert
schemaContext.Types.RegisterType(fooType);
var initializationContext = new TypeInitializationContext(
schemaContext, a => errors.Add(a), fooType, false);
((INeedsInitialization)fooType)
.RegisterDependencies(initializationContext);
schemaContext.CompleteTypes();
Assert.Empty(errors);
await fooType.Fields["bar"].Middleware(resolverContext.Object);
Assert.Equal("BAZ", resolverContext.Object.Result);
}
private void CompleteType(
INamedType namedType,
Action <SchemaContext> configure = null)
{
var schemaContext = new SchemaContext();
schemaContext.Types.RegisterType(new StringType());
schemaContext.Types.RegisterType(namedType);
if (configure != null)
{
configure(schemaContext);
}
var initializationContext = new TypeInitializationContext(
schemaContext, error => { }, namedType, false);
((INeedsInitialization)namedType)
.RegisterDependencies(initializationContext);
schemaContext.CompleteTypes();
}
public void Initialize_IgnoreProperty_PropertyIsNotInSchemaType()
{
// arrange
var errors = new List <SchemaError>();
var schemaContext = new SchemaContext();
// act
var fooType = new InputObjectType <SimpleInput>(
d => d.Field(f => f.Id).Ignore());
INeedsInitialization init = fooType;
// assert
var initializationContext = new TypeInitializationContext(
schemaContext, a => errors.Add(a), fooType, false);
init.RegisterDependencies(initializationContext);
schemaContext.CompleteTypes();
Assert.Empty(errors);
Assert.Collection(fooType.Fields,
t => Assert.Equal("name", t.Name));
}
public void IntializeExplicitFieldWithImplicitResolver()
{
// arrange
var errors = new List <SchemaError>();
var schemaContext = new SchemaContext();
// act
var nodeInterface = new NodeType();
// assert
INeedsInitialization init = nodeInterface;
var initializationContext = new TypeInitializationContext(
schemaContext, a => errors.Add(a), nodeInterface, false);
schemaContext.Types.RegisterType(nodeInterface);
init.RegisterDependencies(initializationContext);
schemaContext.CompleteTypes();
Assert.Empty(errors);
Assert.Equal(
"Node",
nodeInterface.Name);
Assert.Equal(
"The node interface is implemented by entities that have " +
"a gloabl unique identifier.",
nodeInterface.Description);
Assert.Collection(nodeInterface.Fields,
t =>
{
Assert.Equal("id", t.Name);
Assert.IsType <IdType>(
Assert.IsType <NonNullType>(t.Type).Type);
});
}
public void ExplicitInterfaceFieldDeclaration()
{
// arrange
var errors = new List <SchemaError>();
var schemaContext = new SchemaContext();
schemaContext.Types.RegisterType(new BooleanType());
schemaContext.Types.RegisterType(new StringType());
schemaContext.Types.RegisterType(new IntType());
// act
var fooType = new InterfaceType <IFoo>(t =>
t.BindFields(BindingBehavior.Explicit)
.Field(p => p.Bar));
schemaContext.Types.RegisterType(fooType);
INeedsInitialization init = fooType;
var initializationContext = new TypeInitializationContext(
schemaContext, a => errors.Add(a), fooType, false);
init.RegisterDependencies(initializationContext);
schemaContext.CompleteTypes();
// assert
Assert.Empty(errors);
Assert.Collection(
fooType.Fields.Where(t => !t.IsIntrospectionField),
t =>
{
Assert.Equal("bar", t.Name);
Assert.IsType <BooleanType>(
Assert.IsType <NonNullType>(t.Type).Type);
});
}
private static Schema CreateSchema(
IServiceProvider services,
SchemaContext context,
SchemaNames names,
Action <ISchemaConfiguration> configure,
bool strict)
{
List <SchemaError> errors = new List <SchemaError>();
// setup introspection fields
IntrospectionFields introspectionFields =
new IntrospectionFields(context, e => errors.Add(e));
SchemaNames internalNames = names;
try
{
// configure resolvers, custom types and type mappings.
SchemaConfiguration configuration = new SchemaConfiguration(services);
configure(configuration);
errors.AddRange(configuration.RegisterTypes(context));
configuration.RegisterResolvers(context);
errors.AddRange(context.CompleteTypes());
string queryTypeName = configuration.QueryTypeName ?? names.QueryTypeName;
string mutationTypeName = configuration.MutationTypeName ?? names.MutationTypeName;
string subscriptionTypeName = configuration.SubscriptionTypeName ?? names.SubscriptionTypeName;
internalNames = new SchemaNames(queryTypeName, mutationTypeName, subscriptionTypeName);
}
catch (ArgumentException ex)
{
// TODO : maybe we should throw a more specific
// argument exception that at least contains the config object.
throw new SchemaException(new[]
{
new SchemaError(ex.Message, null)
});
}
if (strict && errors.Any())
{
throw new SchemaException(errors);
}
internalNames = string.IsNullOrEmpty(names.QueryTypeName)
? new SchemaNames(null, null, null)
: names;
if (strict && !context.Types.TryGetType <ObjectType>(
internalNames.QueryTypeName, out ObjectType ot))
{
throw new SchemaException(new SchemaError(
"Schema is missing the mandatory `Query` type."));
}
return(new Schema(
services,
SchemaTypes.Create(
context.Types.GetTypes(),
context.Types.GetTypeBindings(),
internalNames),
introspectionFields));
}