public void GetInstance_ICollection_InterceptsThatCollection() { // Arrange var expectedInterceptedTypes = new[] { typeof(IEnumerable <ITimeProvider>), typeof(ICollection <ITimeProvider>) }; var container = new Container(); container.Options.EnableAutoVerification = false; var contexts = new List <InitializationContext>(); container.Options.RegisterResolveInterceptor((c, p) => { contexts.Add(c); var i = p(); return(i); }, c => true); container.Collection.Append <ITimeProvider, RealTimeProvider>(); // Act container.GetInstance <ICollection <ITimeProvider> >(); // Assert var actualInterceptedTypes = from context in contexts select context.Registration.ImplementationType; AssertThat.SequenceEquals(expectedInterceptedTypes, actualInterceptedTypes); }
public void GetAllInstances_AppendingInstancesOfOpenGenericImplementations_ResolvesTheExpectedCollection() { // Arrange Type[] expectedHandlerTypes = new[] { typeof(NewConstraintEventHandler <StructEvent>), typeof(StructConstraintEventHandler <StructEvent>), }; var container = ContainerFactory.New(); container.Collection.Register(typeof(IEventHandler <>), new[] { typeof(NewConstraintEventHandler <>) }); container.Collection .AppendInstance(typeof(IEventHandler <>), new StructConstraintEventHandler <StructEvent>()); // AuditableEventEventHandler<AuditableEvent> can be registered, and resolved, but should not // be resolved as part of IEnumerable<IEventHandler<StructEvent>>. container.Collection .AppendInstance(typeof(IEventHandler <>), new AuditableEventEventHandler <AuditableEvent>()); // Act var handlers = container.GetAllInstances(typeof(IEventHandler <StructEvent>)); Type[] actualHandlerTypes = handlers.Select(h => h.GetType()).ToArray(); // Assert AssertThat.SequenceEquals(expectedHandlerTypes, actualHandlerTypes); }
public void GetAllInstances_MultipleAppendedOpenGenericTypesMixedWithClosedGenericRegisterCollection_ResolvesTheExpectedCollection() { // Arrange Type[] expectedHandlerTypes = new[] { typeof(NewConstraintEventHandler <StructEvent>), typeof(AuditableEventEventHandler <StructEvent>), typeof(StructConstraintEventHandler <StructEvent>), }; var container = ContainerFactory.New(); container.Collection.Append(typeof(IEventHandler <>), typeof(NewConstraintEventHandler <>)); container.Collection.Register(typeof(IEventHandler <StructEvent>), new[] { typeof(AuditableEventEventHandler <StructEvent>) }); container.Collection.Append(typeof(IEventHandler <>), typeof(StructConstraintEventHandler <>)); // Act Type[] actualHandlerTypes = container.GetAllInstances(typeof(IEventHandler <StructEvent>)) .Select(h => h.GetType()).ToArray(); // Assert AssertThat.SequenceEquals(expectedHandlerTypes, actualHandlerTypes); }
private static void _(Type type, Type genericTypeDefinition, params Type[] expected) { Type[] actual = type.GetClosedTypesOf(genericTypeDefinition); AssertThat.SequenceEquals( expectedTypes: expected.OrderBy(HashCode), actualTypes: actual.OrderBy(HashCode)); }
public void Create_WhenReturnedCollectionIterated_ProducesTheExpectedInstances() { // Arrange var expectedTypes = new[] { typeof(NullLogger), typeof(ConsoleLogger) }; var container = new Container(); // Act var stream = container.Collection.Create <ILogger>(expectedTypes); // Assert AssertThat.SequenceEquals(expectedTypes, actualTypes: stream.Select(GetType)); }
public void Create_CollectionWithAbstraction_CallsBackIntoContainerUponIterationToGetTheDefaultRegistration() { // Arrange var container = new Container(); container.Register <ILogger, ConsoleLogger>(); // Act var stream = container.Collection.Create <ILogger>(typeof(ILogger)); // Assert AssertThat.SequenceEquals( expectedTypes: new[] { typeof(ConsoleLogger) }, actualTypes: stream.Select(GetType)); }
public void GetAllInstances_TwoUncontrolledVariantCollections2_ResolvesInstancesThroughBaseType() { // Arrange var container = ContainerFactory.New(); container.RegisterCollection <ITypeConverter <DerivedA> >(new[] { new DerivedAConverter() }); container.RegisterCollection <ITypeConverter <DerivedB> >(new[] { new DerivedBConverter() }); // Act var baseConverters = container.GetAllInstances <ITypeConverter <BaseClass> >(); var types = baseConverters.Select(b => b.GetType()).ToArray(); // Assert AssertThat.SequenceEquals(new[] { typeof(DerivedAConverter), typeof(DerivedBConverter) }, types); }
public void Create_CreatingMultipleCollectionsOfTheSameServiceType_ProducesTheExpectedInstancesForBothCollections() { // Arrange var expectedTypes1 = new[] { typeof(NullLogger), typeof(ConsoleLogger) }; var expectedTypes2 = new[] { typeof(Logger <int>), typeof(Logger <bool>) }; var container = new Container(); // Act var stream1 = container.Collection.Create <ILogger>(expectedTypes1); var stream2 = container.Collection.Create <ILogger>(expectedTypes2); // Assert AssertThat.SequenceEquals(expectedTypes1, actualTypes: stream1.Select(GetType)); AssertThat.SequenceEquals(expectedTypes2, actualTypes: stream2.Select(GetType)); }
private static void Assert_CalledTwiceForSameType_ResolvesExpectedSequence <T>( Action <Container> registration, params Type[] expectedTypes) where T : class { // Arrange var container = new Container(); // Act registration(container); var instances = container.GetAllInstances <T>(); var actualTypes = instances.Select(GetType).ToArray(); // Assert AssertThat.SequenceEquals(expectedTypes, actualTypes); }
public void GetAllInstances_AppendingInstancesOfClosedGenericImplementation_ResolvesTheExpectedCollection() { // Arrange Type[] expectedHandlerTypes = new[] { typeof(NewConstraintEventHandler <StructEvent>), typeof(AuditableEventEventHandler <StructEvent>), }; var container = ContainerFactory.New(); container.Collection.Register(typeof(IEventHandler <>), new[] { typeof(NewConstraintEventHandler <>) }); container.Collection .AppendInstance <IEventHandler <StructEvent> >(new AuditableEventEventHandler <StructEvent>()); // Act var handlers = container.GetAllInstances(typeof(IEventHandler <StructEvent>)); Type[] actualHandlerTypes = handlers.Select(h => h.GetType()).ToArray(); // Assert AssertThat.SequenceEquals(expectedHandlerTypes, actualHandlerTypes); }
public void GetAllInstances_RegistrationPrependedToExistingOpenGenericRegistration_ResolvesTheExtectedCollection() { // Arrange Type[] expectedHandlerTypes = new[] { typeof(StructEventHandler), typeof(NewConstraintEventHandler <StructEvent>), }; var container = ContainerFactory.New(); var registration = Lifestyle.Transient.CreateRegistration <StructEventHandler>(container); container.Collection.Append(typeof(IEventHandler <>), registration); container.Collection.Register(typeof(IEventHandler <>), new[] { typeof(NewConstraintEventHandler <>) }); // Act Type[] actualHandlerTypes = container.GetAllInstances(typeof(IEventHandler <StructEvent>)) .Select(h => h.GetType()).ToArray(); // Assert AssertThat.SequenceEquals(expectedHandlerTypes, actualHandlerTypes); }