public void RegisterSingle_RegisteringANonConcreteType_ThrowsAnArgumentExceptionWithExpectedMessage()
{
// Arrange
string expectedMessage = typeof(IUserRepository).Name + " is not a concrete type.";
var container = ContainerFactory.New();
try
{
// Act
container.RegisterSingle <IUserRepository>();
Assert.Fail("The abstract type was not expected to be registered successfully.");
}
catch (ArgumentException ex)
{
AssertThat.IsInstanceOfType(typeof(ArgumentException), ex, "No subtype was expected.");
AssertThat.StringContains(expectedMessage, ex.Message);
}
}
public void ContainerGetInstance_ResolvingAnInstanceWithDependencies_OnlyCallsTheDelegateForThisRootInstance()
{
// Arrange
var resolvedInstances = new InstanceInitializationDataCollection();
var container = new Container();
container.Options.ResolveUnregisteredConcreteTypes = true;
container.Options.RegisterResolveInterceptor(resolvedInstances.Intercept, Always);
// Act
container.GetInstance <Dep1>();
object actualInstance = resolvedInstances.First().Instance;
// Assert
AssertThat.IsInstanceOfType(typeof(Dep1), actualInstance, resolvedInstances.ToString());
Assert.AreEqual(1, resolvedInstances.Count, resolvedInstances.ToString());
}
public void GetInstance_ServiceRegisteredUsingRegisterInstanceNonGeneric_CallsExpressionBuildingWithConstantExpression()
{
// Arrange
var expressionsBuilding = new List <Expression>();
var container = ContainerFactory.New();
container.RegisterInstance(typeof(IUserRepository), new SqlUserRepository());
container.ExpressionBuilding += (s, e) =>
{
expressionsBuilding.Add(e.Expression);
};
// Act
container.GetInstance <IUserRepository>();
// Assert
Assert.AreEqual(1, expressionsBuilding.Count);
AssertThat.IsInstanceOfType(typeof(ConstantExpression), expressionsBuilding.Single());
}
public void GetInstance_CalledTwiceForSingletonRegistrationWithTransientDecorator_CallsEventOnceForInstanceTwiceForDecorator()
{
// Arrange
var actualContexts = new List <InstanceInitializationData>();
var container = new Container();
container.Register <RealTimeProvider>();
container.RegisterInitializer(actualContexts.Add, TruePredicate);
container.RegisterSingle <ICommandHandler <RealCommand>, StubCommandHandler>();
container.RegisterDecorator(typeof(ICommandHandler <>), typeof(RealCommandHandlerDecorator));
// Act
var decorator1 = container.GetInstance <ICommandHandler <RealCommand> >() as RealCommandHandlerDecorator;
var decorator2 = container.GetInstance <ICommandHandler <RealCommand> >() as RealCommandHandlerDecorator;
// Assert
Assert.AreEqual(3, actualContexts.Count, "Three event args were expected.");
AssertThat.IsInstanceOfType(typeof(StubCommandHandler), actualContexts.First().Instance);
Assert.AreSame(decorator1.Decorated, actualContexts.First().Instance);
Assert.AreEqual(
expected: typeof(RealCommandHandlerDecorator),
actual: actualContexts.Second().Context.Registration.ImplementationType);
Assert.AreSame(decorator1, actualContexts.Second().Instance);
Assert.AreEqual(
expected: typeof(RealCommandHandlerDecorator),
actual: actualContexts.Last().Context.Registration.ImplementationType);
Assert.AreSame(decorator2, actualContexts.Last().Instance);
}
public void ExpressionBuilding_OnInstanceWithInitializer_GetsExpressionWhereInitializerIsNotAppliedYet()
{
// Arrange
Expression actualBuildingExpression = null;
var container = ContainerFactory.New();
container.Register <IUserRepository, SqlUserRepository>();
container.RegisterInitializer <SqlUserRepository>(repository => { });
container.ExpressionBuilding += (sender, e) =>
{
Assert.AreEqual(e.KnownImplementationType, typeof(SqlUserRepository), "Test setup fail.");
actualBuildingExpression = e.Expression;
};
// Act
container.GetInstance <IUserRepository>();
// Assert
AssertThat.IsInstanceOfType(typeof(NewExpression), actualBuildingExpression, "The initializer is expected to be applied AFTER the ExpressionBuilding event ran. " +
"This makes it much easier to alter the given expression.");
}
public void GetInstance_OnInstanceRegisteredAsSingleton_ExpressionBuiltGetsFiredWithConstantExpression()
{
// Arrange
var container = ContainerFactory.New();
container.RegisterSingle <IUserRepository, SqlUserRepository>();
Expression actualExpression = null;
container.ExpressionBuilt += (sender, e) =>
{
if (e.RegisteredServiceType == typeof(IUserRepository))
{
actualExpression = e.Expression;
}
};
// Act
container.GetInstance <IUserRepository>();
// Assert
Assert.IsNotNull(actualExpression);
AssertThat.IsInstanceOfType(typeof(ConstantExpression), actualExpression);
}
public void InjectingEnumerableOfMetadata_ForDecoratedInstances_Succeeds()
{
// Arrange
var container = ContainerFactory.New();
container.Collection.Append(typeof(IEventHandler<>), typeof(NotifyCustomer), Lifestyle.Singleton);
container.Collection.Append(typeof(IEventHandler<>), typeof(DetermineNewWarehouseInventory));
container.RegisterDecorator(typeof(IEventHandler<>), typeof(EventHandlerDecorator<>));
// Act
var service = container.GetInstance<EnumerableMetadata<IEventHandler<OrderShipped>>>();
container.Verify();
var metadatas = service.Metadatas;
var notifyDecorator = (EventHandlerDecorator<OrderShipped>)metadatas.First().GetInstance();
var determineDecorator = (EventHandlerDecorator<OrderShipped>)metadatas.Last().GetInstance();
// Assert
Assert.AreEqual(2, metadatas.Count());
AssertThat.IsInstanceOfType<NotifyCustomer>(notifyDecorator.Decoratee);
AssertThat.IsInstanceOfType<DetermineNewWarehouseInventory>(determineDecorator.Decoratee);
}
