public void CreateUnion() { // arrange DocumentNode document = Parser.Default.Parse( "union X = A | B"); UnionTypeDefinitionNode unionTypeDefinition = document .Definitions.OfType <UnionTypeDefinitionNode>().First(); var context = new SchemaContext(); var configuration = new SchemaConfiguration( context.RegisterServiceProvider, context.Types); configuration.RegisterType(new ObjectType(d => d.Name("A").Field("a").Type <StringType>())); configuration.RegisterType(new ObjectType(d => d.Name("B").Field("a").Type <StringType>())); // act var factory = new UnionTypeFactory(); UnionType unionType = factory.Create(unionTypeDefinition); configuration.RegisterType(unionType); var typeFinalizer = new TypeFinalizer(configuration); typeFinalizer.FinalizeTypes(context, null); // assert Assert.Equal("X", unionType.Name); Assert.Equal(2, unionType.Types.Count); Assert.Equal("A", unionType.Types.First().Key); Assert.Equal("B", unionType.Types.Last().Key); }
public void CreateEnum() { // arrange DocumentNode document = Parser.Default.Parse( "enum Abc { A B C }"); EnumTypeDefinitionNode typeDefinition = document .Definitions.OfType <EnumTypeDefinitionNode>().First(); var context = new SchemaContext(); var configuration = new SchemaConfiguration( context.RegisterServiceProvider, context.Types); // act var factory = new EnumTypeFactory(); EnumType enumType = factory.Create(typeDefinition); configuration.RegisterType(enumType); var typeFinalizer = new TypeFinalizer(configuration); typeFinalizer.FinalizeTypes(context, null); // assert Assert.Equal("Abc", enumType.Name); Assert.Collection(enumType.Values, t => Assert.Equal("A", t.Name), t => Assert.Equal("B", t.Name), t => Assert.Equal("C", t.Name)); }
private static IReadOnlySchemaOptions ExecuteSchemaConfiguration( SchemaContext context, Action <ISchemaConfiguration> configure, List <SchemaError> errors) { try { // configure resolvers, custom types and type mappings. SchemaConfiguration configuration = new SchemaConfiguration( context.ServiceManager.RegisterServiceProvider, context.Types); configure(configuration); TypeFinalizer typeFinalizer = new TypeFinalizer(configuration); typeFinalizer.FinalizeTypes(context); errors.AddRange(typeFinalizer.Errors); return(new ReadOnlySchemaOptions(configuration.Options)); } catch (Exception ex) { throw new SchemaException(new[] { new SchemaError(ex.Message, null, ex) }); } }
public void CreateIncludeDirective() { // arrange SchemaContext schemaContext = SchemaContextFactory.Create(); SchemaConfiguration schemaConfiguration = new SchemaConfiguration(sp => { }, schemaContext.Types); TypeFinalizer typeFinalizer = new TypeFinalizer(schemaConfiguration); typeFinalizer.FinalizeTypes(schemaContext, null); // assert Directive directive = schemaContext.Directives .GetDirectives().FirstOrDefault(t => t.Name == "include"); // assert Assert.NotNull(directive); Assert.IsType <IncludeDirective>(directive); Assert.Equal("include", 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)); }
private static IReadOnlySchemaOptions ExecuteSchemaConfiguration( SchemaContext context, Action <ISchemaConfiguration> configure, List <SchemaError> errors) { try { // configure resolvers, custom types and type mappings. var configuration = new SchemaConfiguration( context.RegisterServiceProvider, context.Types, context.Resolvers, context.Directives); configuration.RegisterCustomContext <IResolverCache>( ExecutionScope.Global, s => new ResolverCache()); configure(configuration); var options = new ReadOnlySchemaOptions(configuration.Options); var typeFinalizer = new TypeFinalizer(configuration); typeFinalizer.FinalizeTypes(context, options.QueryTypeName); errors.AddRange(typeFinalizer.Errors); return(options); } catch (Exception ex) { throw new SchemaException(new[] { new SchemaError(ex.Message, null, ex) }); } }
private DirectiveType CreateDirective <T>(T directiveType) where T : DirectiveType { var schemaContext = new SchemaContext(); schemaContext.Types.RegisterType(new StringType()); schemaContext.Directives.RegisterDirectiveType(directiveType); var schemaConfiguration = new SchemaConfiguration( sp => { }, schemaContext.Types, schemaContext.Directives); var typeFinalizer = new TypeFinalizer(schemaConfiguration); typeFinalizer.FinalizeTypes(schemaContext, null); return(schemaContext.Directives.GetDirectiveTypes().Single()); }
public void CreateCostDirective() { // arrange SchemaContext schemaContext = SchemaContextFactory.Create(); var schemaConfiguration = new SchemaConfiguration( sp => { }, schemaContext.Types, schemaContext.Resolvers, schemaContext.Directives); var typeFinalizer = new TypeFinalizer(schemaConfiguration); typeFinalizer.FinalizeTypes(schemaContext, null); // assert DirectiveType directive = schemaContext.Directives .GetDirectiveTypes() .FirstOrDefault(t => t.Name == "cost"); // assert Assert.NotNull(directive); Assert.IsType <CostDirectiveType>(directive); Assert.Equal("cost", directive.Name); Assert.Collection(directive.Arguments, t => { Assert.Equal("complexity", t.Name); Assert.IsType <IntType>( Assert.IsType <NonNullType>(t.Type).Type); }, t => { Assert.Equal("multipliers", t.Name); Assert.IsType <MultiplierPathType>( Assert.IsType <NonNullType>( Assert.IsType <ListType>(t.Type).ElementType).Type); }); Assert.Collection(directive.Locations, t => Assert.Equal(DirectiveLocation.FieldDefinition, t)); }