public async Task TestMultiThreadContainerControlledLifetimeInstanceAlwaysSame()
{
// Arrange
var container = new FsContainer();
container
.For <ILogger>()
.Use <Logger>(new ContainerControlledLifetimeManager());
// Act
var instances = await Task.WhenAll(
Task.Run(() => {
Task.Delay(10);
return(container.Resolve <ILogger>());
}),
Task.Run(() => {
Task.Delay(10);
return(container.Resolve <ILogger>());
})
);
var logger = instances[0];
var logger1 = instances[1];
// Assert
Assert.IsNotNull(logger);
Assert.IsNotNull(logger1);
Assert.AreSame(logger, logger1);
}
public async Task TestMultiThreadContainerUseExistingObjectFromLifetimeManagerWithFactoryMethodAsync()
{
// Arrange
var container = new FsContainer();
container
.For <IRepository>()
.Use(ctx => new Repository("sql_connection_string"), new ContainerControlledLifetimeManager());
// Act
var instances = await Task.WhenAll(
Task.Run(() => {
Task.Delay(10);
return(container.Resolve <IRepository>());
}),
Task.Run(() => {
Task.Delay(10);
return(container.Resolve <IRepository>());
})
);
var first = instances[0];
var second = instances[1];
// Arrange
Assert.AreEqual(first.ConnectionString, "sql_connection_string");
Assert.AreEqual(second.ConnectionString, "sql_connection_string");
Assert.AreSame(first, second);
}
protected override void InternalClonemembers(FileSystemItem src)
{
base.InternalClonemembers(src);
FsContainer s = (FsContainer)src;
_itemsById = new Dictionary <Int64, FileSystemItem>();
_itemsByName = new Dictionary <String, FileSystemItem>();
foreach (KeyValuePair <Int64, FileSystemItem> kv in s._itemsById)
{
FileSystemItem srcItem = kv.Value;
if (srcItem is FsLink)
{
FsLink lnk = (FsLink)srcItem;
FsLink lnkNew = (FsLink)srcItem.Clone();
AddItem(lnkNew, false);
if (FileSystemItem.BelongsTo(src.Owner._currentMovingRoot, lnk.ItemTo, true))
{
src.Owner._linksToFlip.Add(lnkNew);
}
}
else
{
AddItem(srcItem.Clone(), false);
}
}
}
public PerResolveLifetimeManagerTest()
{
container = new FsContainer();
container
.For <IMapper>()
.Use <Mapper>(new PerResolveLifetimeManager());
}
public PerHttpRequestLifetimeManagerTest()
{
container = new FsContainer();
container
.For <IMapper>()
.Use <Mapper>(new PerHttpRequestLifetimeManager());
}
public HierarchicalLifetimeManagerTest()
{
parent = new FsContainer();
child1 = parent.CreateChildContainer();
child2 = parent.CreateChildContainer();
parent.For<ILogger>().Use<Logger>(new HierarchicalLifetimeManager());
parent.For<DisposableObject>()
.Use<DisposableObject>(new HierarchicalLifetimeManager());
}
public TransientLifetimeManagerTest()
{
container = new FsContainer();
container.For <ILogger>()
.Use <Logger>(new TransientLifetimeManager());
container.For <DisposableObject>()
.Use <DisposableObject>(new TransientLifetimeManager());
}
public void TestNotAssignableBaseClassTypesThrowNotAssignableException()
{
// Act
var container = new FsContainer();
container.For <DbLogger>().Use <Logger>();
// Arrange
}
public void TestNotAssignableInterfaceTypesThrowNotAssignableException()
{
// Act
var container = new FsContainer();
container.For <ILogger>().Use <Validator>();
// Arrange
}
public void TestMissingImplementationBindingResolve()
{
// Act
var container = new FsContainer();
// Arrange
var validator = container.Resolve <IValidator>();
// Assert
}
public void TestMissingParameterlessConstructorResolve()
{
// Act
var container = new FsContainer();
container.For <Credential>().Use <Credential>();
// Arrange
var instance = container.Resolve <Credential>();
// Assert
}
public void TestForUseByServiceResolve()
{
// Act
var container = new FsContainer();
container.For<IValidator>().Use<Validator>();
// Arrange
var validator = container.Resolve<IValidator>();
// Assert
Assert.AreNotEqual(validator, null);
}
public void TestContainerCouldCreateChild()
{
// Act
var container = new FsContainer();
// Arrange
var child = container.CreateChildContainer();
// Assert
Assert.IsNotNull(child);
Assert.IsInstanceOfType(child, typeof(FsContainer));
Assert.AreSame(child.Parent, container);
}
public void TestBaseClassInheritanceAreAssignableTypes()
{
// Act
var container = new FsContainer();
container.For<Logger>().Use<DbLogger>();
// Arrange
var logger = container.Resolve<Logger>();
// Assert
Assert.IsNotNull(logger);
Assert.IsInstanceOfType(logger, typeof(DbLogger));
}
public void TestContainerCouldCreateChild()
{
// Act
var container = new FsContainer();
// Arrange
var child = container.CreateChildContainer();
// Assert
Assert.IsNotNull(child);
Assert.IsInstanceOfType(child, typeof(FsContainer));
Assert.AreSame(child.Parent, container);
}
public void TestForUseByServiceResolve()
{
// Act
var container = new FsContainer();
container.For <IValidator>().Use <Validator>();
// Arrange
var validator = container.Resolve <IValidator>();
// Assert
Assert.AreNotEqual(validator, null);
}
public void RegisteredServicesResolvedWithCustomBindingResolver()
{
// Arrange
var container = new FsContainer
{
BindingResolver = new CustomBindingBindingResolver()
};
container.For <IValidator>().Use <Validator>();
// Act
container.Resolve <IValidator>();
}
public void TestRecursiveSingleArgumentResolve()
{
// Act
var container = new FsContainer();
container.For <ICustomerService>().Use <CustomerService>();
container.For <IValidator>().Use <Validator>();
// Arrange
var instance = container.Resolve <ICustomerService>();
// Assert
Assert.AreNotEqual(instance, null);
}
public void TestInterfaceInheritanceAreAssignableTypes()
{
// Act
var container = new FsContainer();
container.For <ILogger>().Use <DbLogger>();
// Arrange
var logger = container.Resolve <ILogger>();
// Assert
Assert.IsNotNull(logger);
Assert.IsInstanceOfType(logger, typeof(DbLogger));
}
public void TestContainerUseFactoryMethodToCreateTheObject()
{
// Arrange
var container = new FsContainer();
container
.For <IRepository>()
.Use(ctx => new Repository("sql_connection_string"));
// Act
var repository = container.Resolve <IRepository>();
// Arrange
Assert.AreEqual(repository.ConnectionString, "sql_connection_string");
}
public void TestContainerControlledLifetimeInstanceAlwaysSame()
{
// Act
var container = new FsContainer();
container.For<ILogger>().Use<Logger>(new ContainerControlledLifetimeManager());
// Arrange
var logger = container.Resolve<ILogger>();
var logger1 = container.Resolve<ILogger>();
// Assert
Assert.IsNotNull(logger);
Assert.IsNotNull(logger1);
Assert.AreSame(logger, logger1);
}
//((FileSysEmulator.FsContainer)item.Parent).RemoveItem( item );
private void RemoveItem(FileSystemItem item)
{
if (item is FsRoot)
{
throw new ApplicationException("Cant' remove file system root.");
}
if (item is FsDrive)
{
throw new ApplicationException("Cant' remove file system drive.");
}
FsContainer cont = (FsContainer)item.Parent;
cont.RemoveItem(item);
}
public void TestTransientLifetimeInstanceAlwaysDifferent()
{
// Act
var container = new FsContainer();
container.For<ILogger>().Use<Logger>(new TransientLifetimeManager());
// Arrange
var logger = container.Resolve<ILogger>();
var logger1 = container.Resolve<ILogger>();
// Assert
Assert.IsNotNull(logger);
Assert.IsNotNull(logger1);
Assert.AreNotSame(logger, logger1);
}
protected internal void CopyItem(FileSystemItem item, FsContainer parent)
{
if (item.Parent != this)
{
throw new ApplicationException(String.Format("Illegal call to CopyItem: '{0}' is owned by another container.", item.GetFullPath()));
}
if (parent._itemsById.ContainsKey(item.ID) || parent._itemsByName.ContainsKey(item.SearchedName))
{
throw new ApplicationException(String.Format("Can't copy '{0}' to '{1}': there is an duplicated item.", item.GetFullPath(), parent.GetFullPath()));
}
item = item.Clone();
parent.AddItem(item, false);
}
public void TestContainerChildrenAreNotTheSame()
{
// Act
var container = new FsContainer();
// Arrange
var child = container.CreateChildContainer();
var child1 = container.CreateChildContainer();
// Assert
Assert.IsNotNull(child);
Assert.IsNotNull(child1);
Assert.IsInstanceOfType(child, typeof(FsContainer));
Assert.IsInstanceOfType(child1, typeof(FsContainer));
Assert.AreNotSame(child, child1);
}
public void TestContainerControlledLifetimeInstanceAlwaysSame()
{
var container = new FsContainer();
container.For <ILogger>()
.Use <Logger>(new ContainerControlledLifetimeManager());
// Arrange
var logger = container.Resolve <ILogger>();
var logger1 = container.Resolve <ILogger>();
// Assert
Assert.IsNotNull(logger);
Assert.IsNotNull(logger1);
Assert.AreSame(logger, logger1);
}
public void TestContainerChildrenAreNotTheSame()
{
// Act
var container = new FsContainer();
// Arrange
var child = container.CreateChildContainer();
var child1 = container.CreateChildContainer();
// Assert
Assert.IsNotNull(child);
Assert.IsNotNull(child1);
Assert.IsInstanceOfType(child, typeof(FsContainer));
Assert.IsInstanceOfType(child1, typeof(FsContainer));
Assert.AreNotSame(child, child1);
}
public void TestRecursiveMultipleArgumentsResolve()
{
// Act
var container = new FsContainer();
container.For <ICustomerService>().Use <CustomerService>();
container.For <IContractService>().Use <ContractService>();
container.For <IDocumentService>().Use <DocumentService>();
container.For <IValidator>().Use <Validator>();
container.For <IContractRepository>().Use <ContractRepository>();
// Arrange
var instance = container.Resolve <ContractController>();
// Assert
Assert.AreNotEqual(instance, null);
}
public void TestContainerUseExistingObjectFromLifetimeManagerWithFactoryMethod()
{
// Arrange
var container = new FsContainer();
container
.For <IRepository>()
.Use(ctx => new Repository("sql_connection_string"), new ContainerControlledLifetimeManager());
// Act
var first = container.Resolve <IRepository>();
var second = container.Resolve <IRepository>();
// Arrange
Assert.AreEqual(first.ConnectionString, "sql_connection_string");
Assert.AreEqual(second.ConnectionString, "sql_connection_string");
Assert.AreSame(first, second);
}
public void TestContainerUseTransientLifetimeManagerAsDefaultWithFactoryMethod()
{
// Arrange
var container = new FsContainer();
container
.For <IRepository>()
.Use(ctx => new Repository("sql_connection_string"));
// Act
var first = container.Resolve <IRepository>();
var second = container.Resolve <IRepository>();
// Arrange
Assert.AreEqual(first.ConnectionString, "sql_connection_string");
Assert.AreEqual(second.ConnectionString, "sql_connection_string");
Assert.AreNotSame(first, second);
}
public void TestNonExistingParametersDoesNotAffectToInstanceCreatingResolve()
{
// Act
const string message = "Hello, world.";
var container = new FsContainer();
container.For <IRule>().Use <Rule>()
.WithConstructorArgument("message", message)
.WithConstructorArgument("messageException", message);
// Arrange
var instance = container.Resolve <IRule>();
// Assert
Assert.IsNotNull(instance, null);
Assert.AreSame(instance.GetMessage(), message);
}
public void TestWithSingleConstructorArgumentResolve()
{
// Act
const string argument = "Hello, world.";
var container = new FsContainer();
container.For <IRule>().Use <Rule>()
.WithConstructorArgument("message", argument);
// Arrange
var instance = container.Resolve <IRule>();
// Assert
Assert.IsNotNull(instance, null);
Assert.AreEqual(instance.GetMessage(), argument);
Assert.AreEqual(instance.GetNumber(), 0);
}
protected internal void MoveItem(FileSystemItem item, FsContainer parent)
{
if (item.Parent != this)
{
throw new ApplicationException(String.Format("Illegal call to MoveItem: '{0}' is owned by another container.", item.GetFullPath()));
}
if (parent._itemsById.ContainsKey(item.ID) || parent._itemsByName.ContainsKey(item.SearchedName))
{
throw new ApplicationException(String.Format("Can't move '{0}' to '{1}': there is an duplicated item.", item.GetFullPath(), parent.GetFullPath()));
}
_itemsById.Remove(item.ID);
_itemsByName.Remove(item.SearchedName);
Owner.UnregisterItem(item);
item.Parent = null;
parent.AddItem(item, false);
}
public void TestMultipleResolvedInstanceDisposeOnlyOnce()
{
// Arrange
var container = new FsContainer();
container
.For <DisposableObject>()
.Use <DisposableObject>(new ContainerControlledLifetimeManager());
// Act
var o1 = container.Resolve <DisposableObject>();
var o2 = container.Resolve <DisposableObject>();
// Assert
container.Dispose();
Assert.IsTrue(o1.WasDisposed);
Assert.IsTrue(o2.WasDisposed);
Assert.AreEqual(o1.DisposeCount, 1);
Assert.AreEqual(o2.DisposeCount, 1);
}
public async Task TestMultiThreadParentAndChildResolvesSameContainerControlledInstances()
{
// Arrange
var container = new FsContainer();
container
.For <ILogger>()
.Use <Logger>(new ContainerControlledLifetimeManager());
var child1 = container.CreateChildContainer();
var child2 = container.CreateChildContainer();
// Arrange
var instances = await Task.WhenAll(
Task.Run(() => {
Task.Delay(10);
return(container.Resolve <ILogger>());
}),
Task.Run(() => {
Task.Delay(10);
return(child1.Resolve <ILogger>());
}),
Task.Run(() => {
Task.Delay(10);
return(child2.Resolve <ILogger>());
})
);
var logger = instances[0];
var logger1 = instances[1];
var logger2 = instances[2];
// Assert
Assert.IsNotNull(logger);
Assert.IsNotNull(logger1);
Assert.IsNotNull(logger2);
Assert.AreSame(logger, logger1);
Assert.AreSame(logger, logger2);
Assert.AreSame(logger1, logger2);
}
public void TestParentAndChildResolvesSameContainerControlledInstances()
{
// Arrange
var container = new FsContainer();
container
.For <ILogger>()
.Use <Logger>(new ContainerControlledLifetimeManager());
var child1 = container.CreateChildContainer();
var child2 = container.CreateChildContainer();
// Arrange
var logger = container.Resolve <ILogger>();
var logger1 = child1.Resolve <ILogger>();
var logger2 = child2.Resolve <ILogger>();
// Assert
Assert.IsNotNull(logger);
Assert.IsNotNull(logger1);
Assert.IsNotNull(logger2);
Assert.AreSame(logger, logger1);
Assert.AreSame(logger, logger2);
Assert.AreSame(logger1, logger2);
}
public void TestNextWithArgumentOverridePreviousResolve()
{
// Act
const string msgFirst = "Hello, world.";
const string msgLast = "Good night, world.";
const int numFirst = 42;
const int numLast = 7;
var container = new FsContainer();
container.For <IRule>().Use <Rule>()
.WithConstructorArgument("message", msgFirst)
.WithConstructorArgument("message", msgLast)
.WithConstructorArgument("number", numFirst)
.WithConstructorArgument("number", numLast);
// Arrange
var instance = container.Resolve <IRule>();
// Assert
Assert.IsNotNull(instance, null);
Assert.AreEqual(instance.GetMessage(), msgLast);
Assert.AreEqual(instance.GetNumber(), numLast);
}
public void TestMissingParameterlessConstructorResolve()
{
// Act
var container = new FsContainer();
// Arrange
var instance = container.Resolve<Rule>();
// Assert
}
public void TestNonExistingParametersDoesNotAffectToInstanceCreatingResolve()
{
// Act
const string message = "Hello, world.";
var container = new FsContainer();
container.For<IRule>().Use<Rule>()
.WithConstructorArgument("message", message)
.WithConstructorArgument("messageException", message);
// Arrange
var instance = container.Resolve<IRule>();
// Assert
Assert.IsNotNull(instance, null);
Assert.AreSame(instance.GetMessage(), message);
}
public void TestNotAssignableBaseClassTypesThrowNotAssignableException()
{
// Act
var container = new FsContainer();
container.For<DbLogger>().Use<Logger>();
// Arrange
}
public void TestNotAssignableInterfaceTypesThrowNotAssignableException()
{
// Act
var container = new FsContainer();
container.For<ILogger>().Use<Validator>();
// Arrange
}
public void TestRecursiveMultipleArgumentsResolve()
{
// Act
var container = new FsContainer();
container.For<ICustomerService>().Use<CustomerService>();
container.For<IContractService>().Use<ContractService>();
container.For<IDocumentService>().Use<DocumentService>();
container.For<IValidator>().Use<Validator>();
container.For<IContractRepository>().Use<ContractRepository>();
// Arrange
var instance = container.Resolve<ContractController>();
// Assert
Assert.AreNotEqual(instance, null);
}
public void TestRecursiveSingleArgumentResolve()
{
// Act
var container = new FsContainer();
container.For<ICustomerService>().Use<CustomerService>();
container.For<IValidator>().Use<Validator>();
// Arrange
var instance = container.Resolve<ICustomerService>();
// Assert
Assert.AreNotEqual(instance, null);
}
public void TestWithSingleConstructorArgumentResolve()
{
// Act
const string argument = "Hello, world.";
var container = new FsContainer();
container.For<IRule>().Use<Rule>()
.WithConstructorArgument("message", argument);
// Arrange
var instance = container.Resolve<IRule>();
// Assert
Assert.IsNotNull(instance, null);
Assert.AreEqual(instance.GetMessage(), argument);
Assert.AreEqual(instance.GetNumber(), 0);
}
public void TestMissingImplementationBindingResolve()
{
// Act
var container = new FsContainer();
// Arrange
var validator = container.Resolve<IValidator>();
// Assert
}
public void TestNextWithArgumentOverridePreviousResolve()
{
// Act
const string msgFirst = "Hello, world.";
const string msgLast = "Good night, world.";
const int numFirst = 42;
const int numLast = 7;
var container = new FsContainer();
container.For<IRule>().Use<Rule>()
.WithConstructorArgument("message", msgFirst)
.WithConstructorArgument("message", msgLast)
.WithConstructorArgument("number", numFirst)
.WithConstructorArgument("number", numLast);
// Arrange
var instance = container.Resolve<IRule>();
// Assert
Assert.IsNotNull(instance, null);
Assert.AreEqual(instance.GetMessage(), msgLast);
Assert.AreEqual(instance.GetNumber(), numLast);
}
