private TypeInitializer InitializeTypes( IServiceProvider services, IDescriptorContext descriptorContext, IBindingLookup bindingLookup, IEnumerable <ITypeReference> types, Func <ISchema> schemaResolver) { var initializer = new TypeInitializer( services, descriptorContext, types, _resolverTypes, _contextData, _isOfType, IsQueryType); foreach (FieldMiddleware component in _globalComponents) { initializer.GlobalComponents.Add(component); } foreach (FieldReference reference in _resolvers.Keys) { initializer.Resolvers[reference] = new RegisteredResolver( typeof(object), _resolvers[reference]); } foreach (RegisteredResolver resolver in bindingLookup.Bindings .SelectMany(t => t.CreateResolvers())) { var reference = new FieldReference( resolver.Field.TypeName, resolver.Field.FieldName); initializer.Resolvers[reference] = resolver; } initializer.Initialize(schemaResolver); return(initializer); }
/// <summary> /// Constants /// </summary> internal Slot GetOrMakeConstant(object value) { Debug.Assert(!(value is CompilerConstant)); Slot ret; if (_constants.TryGetValue(value, out ret)) { return(ret); } Type type = value.GetType(); // Create a name like "c$3.141592$712" string name = value.ToString(); if (name.Length > 20) { name = name.Substring(0, 20); } name = "c$" + name + "$" + _constants.Count; FieldBuilder fb = _myType.DefineField(name, type, FieldAttributes.Static | FieldAttributes.InitOnly); ret = new StaticFieldSlot(fb); TypeInitializer.EmitConstantNoCache(value); _initGen.EmitFieldSet(fb); _constants[value] = ret; return(ret); }
private SchemaTypesDefinition CreateSchemaDefinition( TypeInitializer initializer) { var definition = new SchemaTypesDefinition(); definition.Types = initializer.Types.Values .Select(t => t.Type) .OfType <INamedType>() .Distinct() .ToArray(); definition.DirectiveTypes = initializer.Types.Values .Select(t => t.Type) .OfType <DirectiveType>() .Distinct() .ToArray(); RegisterOperationName(OperationType.Query, _options.QueryTypeName); RegisterOperationName(OperationType.Mutation, _options.MutationTypeName); RegisterOperationName(OperationType.Subscription, _options.SubscriptionTypeName); definition.QueryType = ResolveOperation( initializer, OperationType.Query); definition.MutationType = ResolveOperation( initializer, OperationType.Mutation); definition.SubscriptionType = ResolveOperation( initializer, OperationType.Subscription); return(definition); }
public void WriteToStreamAsyncReturnsODataRepresentation() { // Arrange ODataConventionModelBuilder modelBuilder = new ODataConventionModelBuilder(); modelBuilder.EntitySet <WorkItem>("WorkItems"); IEdmModel model = modelBuilder.GetEdmModel(); HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/WorkItems(10)"); HttpConfiguration configuration = new HttpConfiguration(); string routeName = "Route"; configuration.MapODataServiceRoute(routeName, null, model); request.SetConfiguration(configuration); IEdmEntitySet entitySet = model.EntityContainer.EntitySets().Single(); request.ODataProperties().Path = new ODataPath(new EntitySetSegment(entitySet), new KeySegment(new[] { new KeyValuePair <string, object>("ID", 10) }, entitySet.EntityType(), entitySet)); request.EnableODataDependencyInjectionSupport(routeName); ODataMediaTypeFormatter formatter = CreateFormatterWithJson(model, request, ODataPayloadKind.Resource); // Act ObjectContent <WorkItem> content = new ObjectContent <WorkItem>( (WorkItem)TypeInitializer.GetInstance(SupportedTypes.WorkItem), formatter); // Assert JsonAssert.Equal(Resources.WorkItemEntry, content.ReadAsStringAsync().Result); }
private void IEnumerableOfEntityTypeSerializesAsODataFeed(string expectedContent, bool json) { ODataMediaTypeFormatter formatter = CreateFormatter(); IEnumerable <Employee> collectionOfPerson = new Collection <Employee>() { (Employee)TypeInitializer.GetInstance(SupportedTypes.Employee, 0), (Employee)TypeInitializer.GetInstance(SupportedTypes.Employee, 1), }; ObjectContent <IEnumerable <Employee> > content = new ObjectContent <IEnumerable <Employee> >(collectionOfPerson, formatter, json ? ODataMediaTypes.ApplicationJsonODataMinimalMetadata : ODataMediaTypes.ApplicationAtomXmlTypeFeed); string actualContent = content.ReadAsStringAsync().Result; if (json) { JsonAssert.Equal(expectedContent, actualContent); } else { RegexReplacement replaceUpdateTime = new RegexReplacement( "<updated>*.*</updated>", "<updated>UpdatedTime</updated>"); Assert.Xml.Equal(expectedContent, actualContent, replaceUpdateTime); } }
public Schema Create() { IServiceProvider services = _services ?? new EmptyServiceProvider(); IBindingLookup bindingLookup = _bindingCompiler.Compile(DescriptorContext.Create(services)); var types = new List <ITypeReference>(_types); if (_documents.Count > 0) { types.AddRange(ParseDocuments(services, bindingLookup)); } var lazy = new LazySchema(); TypeInitializer initializer = InitializeTypes(services, bindingLookup, types, () => lazy.Schema); SchemaDefinition definition = CreateSchemaDefinition(initializer); if (definition.QueryType == null && _options.StrictValidation) { // TODO : Resources throw new SchemaException( SchemaErrorBuilder.New() .SetMessage("No QUERY TYPE") .Build()); } var schema = new Schema(definition); lazy.Schema = schema; return(schema); }
private static TypeInitializer CreateTypeInitializer( SchemaBuilder builder, IDescriptorContext context, IReadOnlyList <ITypeReference> typeReferences, TypeRegistry typeRegistry) { Dictionary <OperationType, ITypeReference> operations = builder._operations.ToDictionary( t => t.Key, t => t.Value(context.TypeInspector)); var initializer = new TypeInitializer( context, typeRegistry, typeReferences, builder._isOfType, type => GetOperationKind(type, context.TypeInspector, operations)); foreach (FieldMiddleware component in builder._globalComponents) { initializer.GlobalComponents.Add(component); } foreach (KeyValuePair <Type, (CreateRef, CreateRef)> binding in builder._clrTypes) { typeRegistry.TryRegister( (ExtendedTypeReference)binding.Value.Item1(context.TypeInspector), binding.Value.Item2.Invoke(context.TypeInspector)); } return(initializer); }
public void Initializer_SchemaOptions_Are_Null() { // arrange var initialTypes = new List <ITypeReference>(); initialTypes.Add(new ClrTypeReference( typeof(Foo), TypeContext.Output)); var serviceProvider = new EmptyServiceProvider(); var typeInitializer = new TypeInitializer( serviceProvider, DescriptorContext.Create(), initialTypes, new List <Type>(), new Dictionary <string, object>(), null, t => t is ObjectType <Foo>); // act Action action = () => typeInitializer.Initialize(() => null, null); // assert Assert.Throws <ArgumentNullException>(action); }
private SchemaTypesDefinition CreateSchemaDefinition( TypeInitializer typeInitializer, DiscoveredTypes discoveredTypes) { var definition = new SchemaTypesDefinition(); RegisterOperationName(OperationType.Query, _options.QueryTypeName); RegisterOperationName(OperationType.Mutation, _options.MutationTypeName); RegisterOperationName(OperationType.Subscription, _options.SubscriptionTypeName); definition.QueryType = ResolveOperation( typeInitializer, OperationType.Query); definition.MutationType = ResolveOperation( typeInitializer, OperationType.Mutation); definition.SubscriptionType = ResolveOperation( typeInitializer, OperationType.Subscription); IReadOnlyCollection <TypeSystemObjectBase> types = RemoveUnreachableTypes(discoveredTypes, definition); definition.Types = types .OfType <INamedType>() .Distinct() .ToArray(); definition.DirectiveTypes = types .OfType <DirectiveType>() .Distinct() .ToArray(); return(definition); }
public MongoDbSet(IMongoDatabase database, IDbsetContainer dbsetContainer, ITypeInitializer typeInitializer, ICustomServiceProvider serviceProvider) { this.Database = database; this.TypeInitializer = typeInitializer; this.CurrentTypeModel = TypeInitializer.GetTypeMetadata <TEntity>(); this.ServiceProvider = serviceProvider; this.DbsetContainer = dbsetContainer; this.SetRelationsMethod = this.GetType().GetMethod(nameof(this.SetRelations), BindingFlags.NonPublic | BindingFlags.Instance); }
public void EntityTypeSerializesAsODataEntry() { ODataMediaTypeFormatter formatter = CreateFormatter(); Employee employee = (Employee)TypeInitializer.GetInstance(SupportedTypes.Employee); ObjectContent <Employee> content = new ObjectContent <Employee>(employee, formatter); RegexReplacement replaceUpdateTime = new RegexReplacement("<updated>*.*</updated>", "<updated>UpdatedTime</updated>"); Assert.Xml.Equal(BaselineResource.TestEntityTypeBasic, content.ReadAsStringAsync().Result, regexReplacements: replaceUpdateTime); }
public Schema Create() { IServiceProvider services = _services ?? new EmptyServiceProvider(); DescriptorContext descriptorContext = DescriptorContext.Create(_options, services); IBindingLookup bindingLookup = _bindingCompiler.Compile(descriptorContext); var types = new List <ITypeReference>(_types); if (_documents.Count > 0) { types.AddRange(ParseDocuments(services, bindingLookup)); } if (_schema == null) { types.Add(new SchemaTypeReference(new Schema())); } else { types.Add(_schema); } var lazy = new LazySchema(); TypeInitializer initializer = InitializeTypes( services, descriptorContext, bindingLookup, types, () => lazy.Schema); SchemaTypesDefinition definition = CreateSchemaDefinition(initializer); if (definition.QueryType == null && _options.StrictValidation) { throw new SchemaException( SchemaErrorBuilder.New() .SetMessage(TypeResources.SchemaBuilder_NoQueryType) .Build()); } Schema schema = initializer.Types.Values .Select(t => t.Type) .OfType <Schema>() .First(); schema.CompleteSchema(definition); lazy.Schema = schema; return(schema); }
public void EntityTypeSerializesAsODataEntry() { // Arrange ODataMediaTypeFormatter formatter = CreateFormatter(); Employee employee = (Employee)TypeInitializer.GetInstance(SupportedTypes.Employee); ObjectContent <Employee> content = new ObjectContent <Employee>(employee, formatter, ODataMediaTypes.ApplicationJsonODataMinimalMetadata); // Act & Assert JsonAssert.Equal(Resources.EmployeeEntry, content.ReadAsStringAsync().Result); }
public Schema Create() { IServiceProvider services = _services ?? new EmptyServiceProvider(); var descriptorContext = DescriptorContext.Create( _options, services, CreateConventions(services), _contextData); foreach (Action <IDescriptorContext> action in _onBeforeCreate) { action(descriptorContext); } IBindingLookup bindingLookup = _bindingCompiler.Compile(descriptorContext); IReadOnlyCollection <ITypeReference> types = GetTypeReferences(services, bindingLookup); var lazy = new LazySchema(); TypeInitializer initializer = CreateTypeInitializer( services, descriptorContext, bindingLookup, types); DiscoveredTypes discoveredTypes = initializer.Initialize(() => lazy.Schema, _options); SchemaTypesDefinition definition = CreateSchemaDefinition(initializer, discoveredTypes); if (definition.QueryType == null && _options.StrictValidation) { throw new SchemaException( SchemaErrorBuilder.New() .SetMessage(TypeResources.SchemaBuilder_NoQueryType) .Build()); } Schema schema = discoveredTypes.Types .Select(t => t.Type) .OfType <Schema>() .First(); schema.CompleteSchema(definition); lazy.Schema = schema; TypeInspector.Default.Clear(); return(schema); }
public void CollectionOfObjectsSerializesAsOData() { Collection <object> collectionOfObjects = new Collection <object>(); collectionOfObjects.Add(1); collectionOfObjects.Add("Frank"); collectionOfObjects.Add(TypeInitializer.GetInstance(SupportedTypes.Person, 2)); collectionOfObjects.Add(TypeInitializer.GetInstance(SupportedTypes.Employee, 3)); ObjectContent <Collection <object> > content = new ObjectContent <Collection <object> >(collectionOfObjects, _formatter); Assert.Throws <ODataException>(() => content.ReadAsStringAsync().Result); }
private static TypeRegistry InitializeTypes( SchemaBuilder builder, IDescriptorContext context, IReadOnlyList <ITypeReference> types, LazySchema lazySchema) { var typeRegistry = new TypeRegistry(context.TypeInterceptor); TypeInitializer initializer = CreateTypeInitializer(builder, context, types, typeRegistry); initializer.Initialize(() => lazySchema.Schema, builder._options); return(typeRegistry); }
public void CollectionOfComplexTypeSerializesAsOData() { IEnumerable <Person> collectionOfPerson = new Collection <Person>() { (Person)TypeInitializer.GetInstance(SupportedTypes.Person, 0), (Person)TypeInitializer.GetInstance(SupportedTypes.Person, 1), (Person)TypeInitializer.GetInstance(SupportedTypes.Person, 2) }; ObjectContent <IEnumerable <Person> > content = new ObjectContent <IEnumerable <Person> >(collectionOfPerson, _formatter); Assert.Xml.Equal(BaselineResource.TestCollectionOfPerson, content.ReadAsStringAsync().Result); }
private static TypeInitializer CreateTypeInitializer( SchemaBuilder builder, IDescriptorContext context, IBindingLookup bindingLookup, IReadOnlyList <ITypeReference> typeReferences, TypeRegistry typeRegistry) { Dictionary <OperationType, ITypeReference> operations = builder._operations.ToDictionary(t => t.Key, t => t.Value(context.TypeInspector)); var interceptor = new AggregateTypeInitializationInterceptor( CreateInterceptors(builder, context.Services)); var initializer = new TypeInitializer( context, typeRegistry, typeReferences, builder._resolverTypes, interceptor, builder._isOfType, type => IsQueryType(context.TypeInspector, type, operations)); foreach (FieldMiddleware component in builder._globalComponents) { initializer.GlobalComponents.Add(component); } foreach (FieldReference reference in builder._resolvers.Keys) { initializer.Resolvers[reference] = new RegisteredResolver( typeof(object), builder._resolvers[reference]); } foreach (RegisteredResolver resolver in bindingLookup.Bindings.SelectMany(t => t.CreateResolvers())) { var reference = new FieldReference( resolver.Field.TypeName, resolver.Field.FieldName); initializer.Resolvers[reference] = resolver; } foreach (KeyValuePair <Type, (CreateRef, CreateRef)> binding in builder._clrTypes) { typeRegistry.TryRegister( (ExtendedTypeReference)binding.Value.Item1(context.TypeInspector), binding.Value.Item2.Invoke(context.TypeInspector)); } return(initializer); }
private void CollectionOfComplexTypeSerializesAsOData(string expectedContent, bool json) { IEnumerable <Person> collectionOfPerson = new Collection <Person>() { (Person)TypeInitializer.GetInstance(SupportedTypes.Person, 0), (Person)TypeInitializer.GetInstance(SupportedTypes.Person, 1), (Person)TypeInitializer.GetInstance(SupportedTypes.Person, 2) }; ObjectContent <IEnumerable <Person> > content = new ObjectContent <IEnumerable <Person> >(collectionOfPerson, _formatter, GetMediaType(json)); AssertEqual(json, expectedContent, content.ReadAsStringAsync().Result); }
public void IEnumerableOfEntityTypeSerializesAsODataFeed() { ODataMediaTypeFormatter formatter = CreateFormatter(); IEnumerable <Employee> collectionOfPerson = new Collection <Employee>() { (Employee)TypeInitializer.GetInstance(SupportedTypes.Employee, 0), (Employee)TypeInitializer.GetInstance(SupportedTypes.Employee, 1), }; ObjectContent <IEnumerable <Employee> > content = new ObjectContent <IEnumerable <Employee> >(collectionOfPerson, formatter); RegexReplacement replaceUpdateTime = new RegexReplacement("<updated>*.*</updated>", "<updated>UpdatedTime</updated>"); Assert.Xml.Equal(BaselineResource.TestFeedOfEmployee, content.ReadAsStringAsync().Result, regexReplacements: replaceUpdateTime); }
public void CollectionOfComplexTypeSerializesAsOData() { // Arrange IEnumerable <Person> collectionOfPerson = new Collection <Person>() { (Person)TypeInitializer.GetInstance(SupportedTypes.Person, 0), (Person)TypeInitializer.GetInstance(SupportedTypes.Person, 1), (Person)TypeInitializer.GetInstance(SupportedTypes.Person, 2) }; ObjectContent <IEnumerable <Person> > content = new ObjectContent <IEnumerable <Person> >(collectionOfPerson, _formatter, ODataMediaTypes.ApplicationJsonODataMinimalMetadata); // Act & Assert JsonAssert.Equal(Resources.CollectionOfPerson, content.ReadAsStringAsync().Result); }
private TypeInitializer CreateTypeInitializer( IServiceProvider services, IDescriptorContext descriptorContext, IBindingLookup bindingLookup, IEnumerable <ITypeReference> types) { var interceptor = new AggregateTypeInitializationInterceptor( CreateInterceptors(services)); var initializer = new TypeInitializer( services, descriptorContext, _contextData, types, _resolverTypes, interceptor, _isOfType, IsQueryType); foreach (FieldMiddleware component in _globalComponents) { initializer.GlobalComponents.Add(component); } foreach (FieldReference reference in _resolvers.Keys) { initializer.Resolvers[reference] = new RegisteredResolver( typeof(object), _resolvers[reference]); } foreach (RegisteredResolver resolver in bindingLookup.Bindings .SelectMany(t => t.CreateResolvers())) { var reference = new FieldReference( resolver.Field.TypeName, resolver.Field.FieldName); initializer.Resolvers[reference] = resolver; } foreach (KeyValuePair <IClrTypeReference, ITypeReference> binding in _clrTypes) { initializer.ClrTypes[binding.Key] = binding.Value; } return(initializer); }
public void Register_ClrType_InferSchemaTypes() { // arrange var initialTypes = new List <ITypeReference>(); initialTypes.Add(new ClrTypeReference( typeof(Foo), TypeContext.Output)); var serviceProvider = new EmptyServiceProvider(); var typeInitializer = new TypeInitializer( serviceProvider, DescriptorContext.Create(), initialTypes, new List <Type>(), new Dictionary <string, object>(), new AggregateTypeInitilizationInterceptor(), null, t => t is ObjectType <Foo>); // act typeInitializer.Initialize(() => null, new SchemaOptions()); // assert bool exists = typeInitializer.Types.TryGetValue( new ClrTypeReference( typeof(ObjectType <Foo>), TypeContext.Output), out RegisteredType type); Assert.True(exists); Assert.IsType <ObjectType <Foo> >(type.Type).Fields.ToDictionary( t => t.Name.ToString(), t => TypeVisualizer.Visualize(t.Type)) .MatchSnapshot(new SnapshotNameExtension("FooType")); exists = typeInitializer.Types.TryGetValue( new ClrTypeReference(typeof(ObjectType <Bar>), TypeContext.Output), out type); Assert.True(exists); Assert.IsType <ObjectType <Bar> >(type.Type).Fields.ToDictionary( t => t.Name.ToString(), t => TypeVisualizer.Visualize(t.Type)) .MatchSnapshot(new SnapshotNameExtension("BarType")); }
private static void WriteToStreamAsyncReturnsODataRepresentation(string expectedContent, bool json) { ODataConventionModelBuilder modelBuilder = new ODataConventionModelBuilder(); modelBuilder.EntitySet <WorkItem>("WorkItems"); IEdmModel model = modelBuilder.GetEdmModel(); HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/WorkItems(10)"); HttpConfiguration configuration = new HttpConfiguration(); string routeName = "Route"; configuration.Routes.MapODataRoute(routeName, null, model); request.SetConfiguration(configuration); request.SetEdmModel(model); IEdmEntitySet entitySet = model.EntityContainers().Single().EntitySets().Single(); request.SetODataPath(new ODataPath(new EntitySetPathSegment(entitySet), new KeyValuePathSegment("10"))); request.SetODataRouteName(routeName); ODataMediaTypeFormatter formatter; if (json) { formatter = CreateFormatterWithJson(model, request, ODataPayloadKind.Entry); } else { formatter = CreateFormatter(model, request, ODataPayloadKind.Entry); } ObjectContent <WorkItem> content = new ObjectContent <WorkItem>( (WorkItem)TypeInitializer.GetInstance(SupportedTypes.WorkItem), formatter); string actualContent = content.ReadAsStringAsync().Result; if (json) { JsonAssert.Equal(expectedContent, actualContent); } else { RegexReplacement replaceUpdateTime = new RegexReplacement( "<updated>*.*</updated>", "<updated>UpdatedTime</updated>"); Assert.Xml.Equal(expectedContent, actualContent, replaceUpdateTime); } }
public Schema Create() { IServiceProvider services = _services ?? new EmptyServiceProvider(); var descriptorContext = DescriptorContext.Create( _options, services, CreateConventions(services)); IBindingLookup bindingLookup = _bindingCompiler.Compile(descriptorContext); IReadOnlyCollection <ITypeReference> types = GetTypeReferences(services, bindingLookup); var lazy = new LazySchema(); TypeInitializer initializer = InitializeTypes( services, descriptorContext, bindingLookup, types, () => lazy.Schema); SchemaTypesDefinition definition = CreateSchemaDefinition(initializer); if (definition.QueryType == null && _options.StrictValidation) { throw new SchemaException( SchemaErrorBuilder.New() .SetMessage(TypeResources.SchemaBuilder_NoQueryType) .Build()); } Schema schema = initializer.Types.Values .Select(t => t.Type) .OfType <Schema>() .First(); schema.CompleteSchema(definition); lazy.Schema = schema; return(schema); }
public void IEnumerableOfEntityTypeSerializesAsODataFeed() { // Arrange ODataMediaTypeFormatter formatter = CreateFormatter(); IEnumerable <Employee> collectionOfPerson = new Collection <Employee>() { (Employee)TypeInitializer.GetInstance(SupportedTypes.Employee, 0), (Employee)TypeInitializer.GetInstance(SupportedTypes.Employee, 1), }; ObjectContent <IEnumerable <Employee> > content = new ObjectContent <IEnumerable <Employee> >(collectionOfPerson, formatter, ODataMediaTypes.ApplicationJsonODataMinimalMetadata); // Act & Assert JsonAssert.Equal(Resources.FeedOfEmployee, content.ReadAsStringAsync().Result); }
public async Task EntityTypeSerializesAsODataEntry() { // Arrange const string routeName = "OData"; IEdmEntitySet entitySet = _model.EntityContainer.FindEntitySet("employees"); ODataPath path = new ODataPath(new EntitySetSegment(entitySet)); var config = RoutingConfigurationFactory.CreateWithRootContainer(routeName, b => b.AddService(ServiceLifetime.Singleton, s => _model)); var request = RequestFactory.Create(HttpMethod.Get, "http://localhost/property", config, routeName, path); var payload = new ODataPayloadKind[] { ODataPayloadKind.Resource }; var formatter = FormatterTestHelper.GetFormatter(payload, request); Employee employee = (Employee)TypeInitializer.GetInstance(SupportedTypes.Employee); var content = FormatterTestHelper.GetContent(employee, formatter, ODataMediaTypes.ApplicationJsonODataMinimalMetadata); // Act & Assert JsonAssert.Equal(Resources.EmployeeEntry, await FormatterTestHelper.GetContentResult(content, request)); }
public Employee(int index, ReferenceDepthContext context) : base(index, context) { this.EmployeeId = index; this.WorkItem = new WorkItem() { EmployeeID = index, IsCompleted = false, NumberOfHours = ((index + 100) / 6), WorkItemID = index + 25 }; this.Manager = (Employee)TypeInitializer.InternalGetInstance(SupportedTypes.Employee, (index + 1) % (DataSource.MaxIndex + 1), context); this.DirectReports = new System.Collections.Generic.List <Employee>(); Employee directEmployee = (Employee)TypeInitializer.InternalGetInstance(SupportedTypes.Employee, (index + 2) % (DataSource.MaxIndex + 1), context); if (directEmployee != null) { this.DirectReports.Add(directEmployee); } }
public void Register_SchemaType_ClrTypeExists() { // arrange var initialTypes = new List <ITypeReference>(); initialTypes.Add(new ClrTypeReference( typeof(FooType), TypeContext.Output)); var serviceProvider = new EmptyServiceProvider(); var typeInitializer = new TypeInitializer( serviceProvider, initialTypes, new List <Type>(), new Dictionary <string, object>(), null, t => t is FooType); // act typeInitializer.Initialize(() => null); // assert bool exists = typeInitializer.Types.TryGetValue( new ClrTypeReference(typeof(FooType), TypeContext.Output), out RegisteredType type); Assert.True(exists); Assert.IsType <FooType>(type.Type).Fields.ToDictionary( t => t.Name.ToString(), t => TypeVisualizer.Visualize(t.Type)) .MatchSnapshot(new SnapshotNameExtension("FooType")); exists = typeInitializer.Types.TryGetValue( new ClrTypeReference(typeof(BarType), TypeContext.Output), out type); Assert.True(exists); Assert.IsType <BarType>(type.Type).Fields.ToDictionary( t => t.Name.ToString(), t => TypeVisualizer.Visualize(t.Type)) .MatchSnapshot(new SnapshotNameExtension("BarType")); }
private void EntityTypeSerializesAsODataEntry(string expectedContent, bool json) { ODataMediaTypeFormatter formatter = CreateFormatter(); Employee employee = (Employee)TypeInitializer.GetInstance(SupportedTypes.Employee); ObjectContent <Employee> content = new ObjectContent <Employee>(employee, formatter, json ? ODataMediaTypes.ApplicationJsonODataMinimalMetadata : ODataMediaTypes.ApplicationAtomXmlTypeEntry); string actualContent = content.ReadAsStringAsync().Result; if (json) { JsonAssert.Equal(expectedContent, actualContent); } else { RegexReplacement replaceUpdateTime = new RegexReplacement( "<updated>*.*</updated>", "<updated>UpdatedTime</updated>"); Assert.Xml.Equal(expectedContent, actualContent, replaceUpdateTime); } }