public void Register_SchemaType_ClrTypeExists_NoSystemTypes() { // arrange var context = DescriptorContext.Create(); var typeRegistry = new TypeRegistry(); var typeLookup = new TypeLookup(context.TypeInspector, typeRegistry); var typeDiscoverer = new TypeDiscoverer( context, typeRegistry, typeLookup, new HashSet <ITypeReference> { _typeInspector.GetTypeRef(typeof(FooType), TypeContext.Output) }, new AggregateTypeInterceptor(), false); // act IReadOnlyList <ISchemaError> errors = typeDiscoverer.DiscoverTypes(); // assert Assert.Empty(errors); new { registered = typeRegistry.Types .Select(t => new { type = t.Type.GetType().GetTypeName(), runtimeType = t.Type is IHasRuntimeType hr ? hr.RuntimeType.GetTypeName() : null, references = t.References.Select(t => t.ToString()).ToList() }).ToList(),
public void Upgrade_Type_From_GenericType() { // arrange var initialTypes = new HashSet <ITypeReference>(); initialTypes.Add(new ClrTypeReference( typeof(ObjectType <Foo>), TypeContext.Output)); initialTypes.Add(new ClrTypeReference( typeof(FooType), TypeContext.Output)); var serviceProvider = new EmptyServiceProvider(); var clrTypeReferences = new Dictionary <IClrTypeReference, ITypeReference>(); var typeDiscoverer = new TypeDiscoverer( initialTypes, clrTypeReferences, DescriptorContext.Create(), new Dictionary <string, object>(), new AggregateTypeInitializationInterceptor(), serviceProvider); // act DiscoveredTypes result = typeDiscoverer.DiscoverTypes(); // assert Assert.Empty(result.Errors); result.Types .Select(t => t.Type) .OfType <IHasClrType>() .ToDictionary( t => t.GetType().GetTypeName(), t => t.ClrType.GetTypeName()) .MatchSnapshot(new SnapshotNameExtension("registered")); clrTypeReferences.ToDictionary( t => t.Key.ToString(), t => t.Value.ToString()) .MatchSnapshot(new SnapshotNameExtension("clr")); }
public void Register_ClrType_InferSchemaTypes() { // arrange var initialTypes = new HashSet <ITypeReference>(); initialTypes.Add(TypeReference.Create( typeof(Foo), TypeContext.Output)); var serviceProvider = new EmptyServiceProvider(); var clrTypeReferences = new Dictionary <ClrTypeReference, ITypeReference>(); var typeDiscoverer = new TypeDiscoverer( initialTypes, clrTypeReferences, DescriptorContext.Create(), new AggregateTypeInitializationInterceptor(), serviceProvider); // act DiscoveredTypes result = typeDiscoverer.DiscoverTypes(); // assert Assert.Empty(result.Errors); new { registered = result.Types .Select(t => t.Type) .OfType <IHasRuntimeType>() .ToDictionary( t => t.GetType().GetTypeName(), t => t.RuntimeType.GetTypeName()), clr = clrTypeReferences.ToDictionary( t => t.Key.ToString(), t => t.Value.ToString()) }.MatchSnapshot(); }
public void Initialize( Func <ISchema> schemaResolver, IReadOnlySchemaOptions options) { if (schemaResolver is null) { throw new ArgumentNullException(nameof(schemaResolver)); } if (options is null) { throw new ArgumentNullException(nameof(options)); } // first we are going to find and initialize all types that belong to our schema. var typeRegistrar = new TypeDiscoverer( _context, _typeRegistry, _typeLookup, _initialTypes, _interceptor); if (typeRegistrar.DiscoverTypes() is { Count : > 0 } errors) { throw new SchemaException(errors); } // next lets tell the type interceptors what types we have initialized. if (_interceptor.TriggerAggregations) { _interceptor.OnTypesInitialized( _typeRegistry.Types.Select(t => t.DiscoveryContext).ToList()); } // before we can start completing type names we need to register the field resolvers. RegisterResolvers(); // now that we have the resolvers sorted and know what types our schema will roughly // consist of we are going to have a look if we can infer interface usage // from .NET classes that implement .NET interfaces. RegisterImplicitInterfaceDependencies(); // with all types (implicit and explicit) known we complete the type names. CompleteNames(schemaResolver); // with the type names all known we can now build pairs to bring together types and // their type extensions. MergeTypeExtensions(); // external resolvers are resolvers that are defined on the schema and are associated // with the types after they have received a name and the extensions are removed. RegisterExternalResolvers(); // with all resolvers in place we compile the once inferred from a C# member. CompileResolvers(); // last we complete the types. Completing types means that we will assign all // the fields resolving all missing parts and then making the types immutable. CompleteTypes(); // if we do not have any errors we will validate the types for spec violations. if (_errors.Count == 0) { _errors.AddRange(SchemaValidator.Validate( _typeRegistry.Types.Select(t => t.Type), options)); } if (_errors.Count > 0) { throw new SchemaException(_errors); } }