public void CanRegisterTypeMappingOnRootContainer()
{
TestableRootCompositionContainer root = new TestableRootCompositionContainer();
root.RegisterTypeMapping<IFoo, Foo>();
Type mappedType = root.GetMappedType<IFoo>();
Assert.AreEqual(typeof (Foo), mappedType);
}
public void CanRegisterMultipleTypeMappings()
{
TestableRootCompositionContainer root = new TestableRootCompositionContainer();
root.RegisterTypeMapping<IFoo, Foo>();
root.RegisterTypeMapping<IBar, Bar>();
Assert.AreEqual(typeof (Bar), root.GetMappedType<IBar>());
Assert.AreEqual(typeof (Foo), root.GetMappedType<IFoo>());
}
public void RegisteredModuleServiceInstanceGetsAddedToModuleServicesCollection()
{
CompositionContainer rootContainer = new TestableRootCompositionContainer();
CompositionContainer childContainer = rootContainer.Containers.AddNew<CompositionContainer>();
ServiceInfo info = new ServiceInfo(typeof (IMockService), typeof (MockService), ServiceScope.Module);
ServiceLoaderService serviceLoader = new ServiceLoaderService();
serviceLoader.Load(childContainer, info);
Assert.IsTrue(childContainer.Services.Contains(typeof (IMockService)));
Assert.AreEqual(typeof (MockService), childContainer.Services.Get<IMockService>(true).GetType());
}
public void PolicyShouldRequestTypeMappingFromContainer()
{
TestableRootCompositionContainer container = new TestableRootCompositionContainer();
container.RegisterTypeMapping<IFoo, Foo>();
ContainerAwareTypeMappingPolicy policy = new ContainerAwareTypeMappingPolicy();
string requestId = "My mapped object";
DependencyResolutionLocatorKey requestKey =
new DependencyResolutionLocatorKey(typeof (IFoo), requestId);
DependencyResolutionLocatorKey result = policy.Map(container.Locator, requestKey);
Assert.AreEqual(typeof (Foo), result.Type);
Assert.AreEqual(requestId, result.ID);
}
public void PolicyCallsUpToParentContainerToGetMapping()
{
TestableRootCompositionContainer container = new TestableRootCompositionContainer();
container.RegisterTypeMapping<IFoo, Foo>();
CompositionContainer child = container.Containers.AddNew<CompositionContainer>();
ContainerAwareTypeMappingPolicy policy = new ContainerAwareTypeMappingPolicy();
string requestId = "My mapped object";
DependencyResolutionLocatorKey requestKey =
new DependencyResolutionLocatorKey(typeof (IFoo), requestId);
DependencyResolutionLocatorKey result = policy.Map(child.Locator, requestKey);
Assert.AreEqual(typeof (Foo), result.Type);
Assert.AreEqual(requestId, result.ID);
}
public void StrategyShouldDoTypeMapping()
{
TestableRootCompositionContainer root = new TestableRootCompositionContainer();
root.RegisterTypeMapping<IFoo, Foo>();
ContainerAwareTypeMappingStrategy strategy = new ContainerAwareTypeMappingStrategy();
MockBuilderContext builderContext =
new MockBuilderContext(strategy, new ReturnRequestedTypeStrategy());
builderContext.Policies.SetDefault<IContainerAwareTypeMappingPolicy>(
new ContainerAwareTypeMappingPolicy());
builderContext.Locator = root.Locator;
object result = strategy.BuildUp(builderContext, typeof (IFoo), null, "Test object");
DependencyResolutionLocatorKey key = result as DependencyResolutionLocatorKey;
Assert.IsNotNull(key);
Assert.AreEqual(typeof (Foo), key.Type);
}
public void GetContainerReturnsContainerOfModuleInSubFolder()
{
TestableRootCompositionContainer rootContainer = new TestableRootCompositionContainer();
CompositionContainer module1Container = rootContainer.Containers.AddNew<CompositionContainer>("Module1");
rootContainer.Containers.AddNew<CompositionContainer>("Shell");
MockEnumeratorService enumerator = rootContainer.Services.AddNew<MockEnumeratorService, IModuleEnumerator>();
enumerator.ModuleInfos = new ModuleInfo[]
{
new ModuleInfo("Shell", "Shell.Assembly", "~/"),
new ModuleInfo("Module1", "Module1.Assembly", "~/Module1")
};
ModuleContainerLocatorService service = rootContainer.Services.AddNew<ModuleContainerLocatorService>();
CompositionContainer result = service.GetContainer("~/Module1/Page.aspx");
Assert.AreSame(module1Container, result);
}
public void TestServicesAreTornDownWhenContainerIsDisposed()
{
TestableRootCompositionContainer container = new TestableRootCompositionContainer();
MockService svc = container.Services.AddNew<MockService>();
container.Dispose();
Assert.IsTrue(svc.OnTearingDownCalled);
}
public void RootContainerParentIsNull()
{
TestableRootCompositionContainer container = new TestableRootCompositionContainer();
Assert.IsNull(container.Parent);
}
public void TerminatingCompositionContainerCausesItToBeRemovedFromParent()
{
TestableRootCompositionContainer parent = new TestableRootCompositionContainer();
CompositionContainer child = parent.Containers.AddNew<CompositionContainer>();
Assert.AreEqual(1, parent.Containers.Count);
child.Dispose();
Assert.AreEqual(0, parent.Containers.Count);
}
public void RequestingTypeMappingOnChildReadsFromParent()
{
TestableRootCompositionContainer parent = new TestableRootCompositionContainer();
CompositionContainer child = parent.Containers.AddNew<CompositionContainer>();
parent.RegisterTypeMapping<IFoo, Foo>();
Assert.AreEqual(typeof (Foo), child.GetMappedType<IFoo>());
}
public void RootContainerCanAccessToRootContainer()
{
TestableRootCompositionContainer root = new TestableRootCompositionContainer();
Assert.AreEqual(root, root.RootContainer);
}
public void CreateInstancenotInjectNonRequiredNotPresentServiceDependency()
{
PolicyList policies = new PolicyList();
MockBuilderContext ctx = BuildContext(policies);
TestableRootCompositionContainer compositionContainer = new TestableRootCompositionContainer();
ctx.Locator.Add(new DependencyResolutionLocatorKey(typeof (CompositionContainer), null), compositionContainer);
MockDependencyDependingObjectNotRequired mockInstance =
(MockDependencyDependingObjectNotRequired)
ctx.HeadOfChain.BuildUp(ctx, typeof (MockDependencyDependingObjectNotRequired), null, null);
Assert.IsNotNull(mockInstance);
Assert.IsNull(mockInstance.DependentObject);
}
public void RequestingTypeMappingForUnmappedTypeReturnsRequestedType()
{
TestableRootCompositionContainer root = new TestableRootCompositionContainer();
Type mappedType = root.GetMappedType<Foo>();
Assert.AreEqual(typeof (Foo), mappedType);
}
public void GetContainerReturnsShellContainerEvenIfThereIsAFoundationalModule()
{
TestableRootCompositionContainer rootContainer = new TestableRootCompositionContainer();
rootContainer.Containers.AddNew<CompositionContainer>("Module1");
CompositionContainer shellContainer = rootContainer.Containers.AddNew<CompositionContainer>("Shell");
MockEnumeratorService enumerator = rootContainer.Services.AddNew<MockEnumeratorService, IModuleEnumerator>();
enumerator.ModuleInfos = new ModuleInfo[]
{
new ModuleInfo("Shell", "Shell.Assembly", "~/"),
new ModuleInfo("FoundationalModule", "FoundationalModule.Assembly", null),
new ModuleInfo("Module1", "Module1.Assembly", "~/Module1")
};
ModuleContainerLocatorService service = rootContainer.Services.AddNew<ModuleContainerLocatorService>();
CompositionContainer result = service.GetContainer("~/Page.aspx");
Assert.AreSame(shellContainer, result);
}
public void LoadCallsLoadOnModuleInitializer()
{
CompositionContainer mockContainer = new TestableRootCompositionContainer();
ModuleLoaderService loader = new ModuleLoaderService();
loader.Load(mockContainer,
new ModuleInfo("TestModule", generatedAssemblies["TestModule"].FullName, "~/TestModule"));
bool loadCalled =
(bool)
generatedAssemblies["TestModule"].GetType("TestModule.TestModuleInitializer").GetField("LoadCalled").GetValue(null);
Assert.IsTrue(loadCalled);
}
public void LoadCreatesNewContainerForModule()
{
CompositionContainer mockContainer = new TestableRootCompositionContainer();
ModuleLoaderService loader = new ModuleLoaderService();
loader.Load(mockContainer,
new ModuleInfo("TestModuleName", generatedAssemblies["TestModule"].FullName, "~/TestModule"));
CompositionContainer moduleContainer = mockContainer.Containers["TestModuleName"];
Assert.IsNotNull(moduleContainer);
}
public void GetContainerReturnsRootContainerIfNoModules()
{
TestableRootCompositionContainer rootContainer = new TestableRootCompositionContainer();
rootContainer.Services.AddNew<MockEnumeratorService, IModuleEnumerator>();
ModuleContainerLocatorService service = rootContainer.Services.AddNew<ModuleContainerLocatorService>();
CompositionContainer result = service.GetContainer("~/SubFolder/Page.aspx");
CompositionContainer result2 = service.GetContainer("~/Page.aspx");
Assert.AreSame(rootContainer, result);
Assert.AreSame(result, result2);
}
public void LoadRegistersServicesUsingIServiceLoaderService()
{
CompositionContainer mockContainer = new TestableRootCompositionContainer();
MockServiceLoaderService serviceLoaderService = new MockServiceLoaderService();
mockContainer.Services.Add<IServiceLoaderService>(serviceLoaderService);
ModuleLoaderService loader = new ModuleLoaderService();
DependantModuleInfo moduleInfo =
new DependantModuleInfo("TestModule", generatedAssemblies["TestModule"].FullName, "~/TestModule");
moduleInfo.Services =
new ServiceInfo[1] {new ServiceInfo(typeof (IMockService), typeof (MockService), ServiceScope.Global)};
loader.Load(mockContainer, moduleInfo);
Assert.IsNotNull(serviceLoaderService.UsedServices);
Assert.AreEqual(1, serviceLoaderService.UsedServices.Length);
Assert.AreEqual(typeof (IMockService), serviceLoaderService.UsedServices[0].RegisterAs);
Assert.IsNotNull(serviceLoaderService.UsedCompositionContainer);
Assert.AreEqual(mockContainer.Containers["TestModule"], serviceLoaderService.UsedCompositionContainer);
}
public MockWebClientApplication()
{
_rootContainer = new TestableRootCompositionContainer();
}
public void CreateInstancenotInjectsRegisteredInterfaceService()
{
PolicyList policies = new PolicyList();
MockBuilderContext ctx = BuildContext(policies);
TestableRootCompositionContainer compositionContainer = new TestableRootCompositionContainer();
ctx.Locator.Add(new DependencyResolutionLocatorKey(typeof (CompositionContainer), null), compositionContainer);
MockDependentObject mockDependency =
compositionContainer.Services.AddNew<MockDependentObject, IMockDependentObject>();
MockDependencyDependingInterface mockInstance =
(MockDependencyDependingInterface)
ctx.HeadOfChain.BuildUp(ctx, typeof (MockDependencyDependingInterface), null, null);
Assert.IsNotNull(mockInstance);
Assert.IsNotNull(mockInstance.DependentObject);
Assert.AreSame(mockDependency, mockInstance.DependentObject);
}
public void TypeMappingsMustBeTypeCompatible()
{
TestableRootCompositionContainer root = new TestableRootCompositionContainer();
root.RegisterTypeMapping(typeof (IBar), typeof (Foo));
}
public void DisposingContainerCausesContainedObjectsToBeTornDown()
{
TestableRootCompositionContainer cc = new TestableRootCompositionContainer();
MockTearDownStrategy strategy = new MockTearDownStrategy();
cc.Builder.Strategies.Add(strategy, WCSFBuilderStage.PreCreation);
cc.Dispose();
Assert.IsTrue(strategy.TearDownCalled);
}
public void ChildContainerAreDisposedWithParent()
{
TestableRootCompositionContainer parent = new TestableRootCompositionContainer();
CompositionContainer child = parent.Containers.AddNew<CompositionContainer>();
MockService svc = child.Services.AddNew<MockService>();
parent.Dispose();
Assert.IsTrue(svc.OnTearingDownCalled);
}
public void NestedContainerIntegrationTest()
{
CompositionContainer parentContainer = new TestableRootCompositionContainer();
CompositionContainer childContainer = parentContainer.Containers.AddNew<CompositionContainer>();
MockA a = new MockA();
MockA b = new MockA();
parentContainer.Services.Add(typeof (MockA), a);
childContainer.Services.Add(typeof (MockA), b);
Assert.AreSame(a, parentContainer.Services.Get<MockA>());
Assert.AreSame(b, childContainer.Services.Get<MockA>());
MockB c = new MockB();
parentContainer.Services.Add(typeof (MockB), c);
// Throws ArgumentException
childContainer.Services.AddOnDemand(typeof (MockB));
}
public void CanRegisterTypeMappingViaTypeObjects()
{
TestableRootCompositionContainer root = new TestableRootCompositionContainer();
root.RegisterTypeMapping(typeof (IFoo), typeof (Foo));
Type mappedType = root.GetMappedType(typeof (IFoo));
Assert.AreEqual(typeof (Foo), mappedType);
}
public void ChildContainerCanAccessToRootContainer()
{
TestableRootCompositionContainer root = new TestableRootCompositionContainer();
CompositionContainer child = root.Containers.AddNew<CompositionContainer>();
CompositionContainer innerChild = child.Containers.AddNew<CompositionContainer>();
Assert.AreEqual(root, innerChild.RootContainer);
}
public void GetContainerReturnsRootContainerIfNoModulesFoundWithGivenVirtualPath()
{
TestableRootCompositionContainer rootContainer = new TestableRootCompositionContainer();
rootContainer.Containers.AddNew<CompositionContainer>("Module1");
MockEnumeratorService enumerator = rootContainer.Services.AddNew<MockEnumeratorService, IModuleEnumerator>();
enumerator.ModuleInfos = new ModuleInfo[] {new ModuleInfo("Module1", "Module1.Assembly", "~/Module1")};
ModuleContainerLocatorService service = rootContainer.Services.AddNew<ModuleContainerLocatorService>();
CompositionContainer result = service.GetContainer("~/Page.aspx");
Assert.AreSame(rootContainer, result);
}
public void ChildContainerHasParent()
{
TestableRootCompositionContainer parent = new TestableRootCompositionContainer();
CompositionContainer child = parent.Containers.AddNew<CompositionContainer>();
Assert.AreSame(parent, child.Parent);
}
public void ChildContainersCanOverrideParentTypeMapping()
{
TestableRootCompositionContainer parent = new TestableRootCompositionContainer();
CompositionContainer child = parent.Containers.AddNew<CompositionContainer>();
parent.RegisterTypeMapping<IFoo, Foo>();
child.RegisterTypeMapping<IFoo, Foo2>();
Assert.AreEqual(typeof (Foo), parent.GetMappedType<IFoo>());
Assert.AreEqual(typeof (Foo2), child.GetMappedType<IFoo>());
}
public void InitializationExceptionsAreWrapped()
{
CompositionContainer mockContainer = new TestableRootCompositionContainer();
ModuleLoaderService loader = new ModuleLoaderService();
try
{
loader.Load(mockContainer,
new ModuleInfo("ModuleThrowingException", generatedAssemblies["ModuleThrowingException"].FullName,
"~/ModuleThrowingException"));
Assert.Fail("ModuleLoadException was not thrown");
}
catch (Exception ex)
{
if (!(ex is ModuleLoadException))
Assert.Fail("Exception is not of type ModuleLoadException");
if (!(((ModuleLoadException) ex).InnerException is NotImplementedException))
Assert.Fail("The actual inner exception was not wrapped correctly");
}
}
