public void ThrowsIfAssemblyRelativeNotUnderRootSolutionProfile()
{
WorkItem container = new TestableRootWorkItem();
ModuleLoaderService service = new ModuleLoaderService(null);
service.Load(container, new ModuleInfo(@"..\..\module.dll"));
}
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");
}
}
}
private void HyperlinkExecutedEventHandler(object sender, HyperlinkExecutedEventArgs e)
{
if (e.Hyperlink.Data.ContainsKey("DialogId")) //Support for links with only moduleid
{
var node = (from n in GetMenu().SelectNodes("descendant::item").Cast <XmlNode>()
where n.Attributes["operation"].Value == e.Hyperlink.Data["DialogId"]
select n).LastOrDefault();
if (node != null)
{
ShellMenuItem temp = new ShellMenuItem();
temp.Operation = node.Attributes["operation"].Value;
AuthorizationService.CheckAuthorization(Id, new IAuthOperation[] { temp });
if (temp.IsAuthorized)
{
if (!string.IsNullOrEmpty(node.Attributes["assemblyFile"].Value))
{
ModuleInfo info = new ModuleInfo(node.Attributes["assemblyFile"].Value);
ModuleLoaderService.Load(WorkItem, info);
}
EventTopic itemTopic = WorkItem.RootWorkItem.EventTopics.Get(node.Attributes["parameters"].Value);
MenuEventArgs args = new MenuEventArgs("", HyperlinkHelper.BuildQueryString(e.Hyperlink.Data), true, null);
itemTopic.Fire(this, args, WorkItem, PublicationScope.Global);
}
else
{
ShellInteractionService.ShowMessageBox(StringResources.Authorization_NotAuhtorized, StringResources.Authorization_Message, null, MessageBoxButton.Ok, MessageBoxImage.Warning);
}
}
}
}
public void InitializationExceptionsAreWrapped()
{
WorkItem mockContainer = new TestableRootWorkItem();
ModuleLoaderService loader = new ModuleLoaderService(null);
loader.Load(mockContainer,
new ModuleInfo(generatedAssemblies["ModuleThrowingException"].CodeBase.Replace(@"file:///", "")));
}
public void CanLoadDependentModulesWithoutInitialization()
{
WorkItem container = new TestableRootWorkItem();
ModuleLoaderService service = new ModuleLoaderService(null);
service.Load(container,
new ModuleInfo(generatedAssemblies["ModuleDependency2"].CodeBase.Replace(@"file:///", "")),
new ModuleInfo(generatedAssemblies["ModuleDependency1"].CodeBase.Replace(@"file:///", "")));
}
public void FailWhenDependingOnMissingModule()
{
ModuleInfo module = new ModuleInfo(GenerateDynamicModule("ModuleK", null, "ModuleL"));
WorkItem mockContainer = new TestableRootWorkItem();
ModuleLoaderService loader = new ModuleLoaderService(null);
loader.Load(mockContainer, module);
}
public void LoadModuleReferencingMissingAssembly()
{
WorkItem mockContainer = new TestableRootWorkItem();
ModuleLoaderService loader = new ModuleLoaderService(null);
ModuleInfo info = new ModuleInfo();
info.SetAssemblyFile(generatedAssemblies["ModuleReferencingAssembly"].CodeBase.Replace(@"file:///", ""));
loader.Load(mockContainer, info);
}
public void ModuleAddingDuplicatedServices()
{
Assembly moduleService = generatedAssemblies["ModuleExposingDuplicatedServices"];
ModuleInfo module = new ModuleInfo(moduleService.CodeBase.Replace(@"file:///", ""));
WorkItem container = new TestableRootWorkItem();
ModuleLoaderService service = new ModuleLoaderService(null);
service.Load(container, module);
}
public void FindModuleInitializerReturnsNullIfnotExists()
{
CompositionContainer mockContainer = new TestableRootCompositionContainer();
ModuleLoaderService loader = new ModuleLoaderService();
loader.Load(mockContainer,
new ModuleInfo("TestModuleName", generatedAssemblies["TestModule"].FullName, "~/TestModule"));
IModuleInitializer initializer = loader.FindInitializer("InexistantName");
Assert.IsNull(initializer);
}
public void LoadModuleWithServices()
{
Assembly compiledAssembly = generatedAssemblies["ModuleExposingServices"];
WorkItem container = new TestableRootWorkItem();
ModuleLoaderService service = new ModuleLoaderService(null);
ModuleInfo info = new ModuleInfo(compiledAssembly.CodeBase.Replace(@"file:///", ""));
service.Load(container, info);
Assert.IsNotNull(container.Services.Get(compiledAssembly.GetType("ModuleExposingServices.SimpleService")));
Assert.IsNotNull(container.Services.Get(compiledAssembly.GetType("ModuleExposingServices.ITestService")));
}
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 FindModuleInitializerReturnsCorrectInstance()
{
CompositionContainer mockContainer = new TestableRootCompositionContainer();
ModuleLoaderService loader = new ModuleLoaderService();
loader.Load(mockContainer,
new ModuleInfo("TestModuleName", generatedAssemblies["TestModule"].FullName, "~/TestModule"));
IModuleInitializer initializer = loader.FindInitializer("TestModuleName");
Assert.IsNotNull(initializer);
Assert.AreEqual("TestModule.TestModuleInitializer", initializer.GetType().FullName);
}
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 CanLoadModuleAssemblyWhichOnlyExposesServices()
{
Assembly asm = generatedAssemblies["ModuleExposingOnlyServices"];
WorkItem container = new TestableRootWorkItem();
ModuleLoaderService service = new ModuleLoaderService(null);
service.Load(container, new ModuleInfo(asm.CodeBase.Replace(@"file:///", "")));
Type typeSimpleService = asm.GetType("ModuleExposingOnlyServices.SimpleService");
Type typeITestService = asm.GetType("ModuleExposingOnlyServices.ITestService");
Assert.IsNotNull(container.Services.Get(typeSimpleService), "The SimpleService service was not loaded.");
Assert.IsNotNull(container.Services.Get(typeITestService), "The ITestService service was not loaded.");
}
public void LoadProfileWithAcyclicModuleDependencies()
{
List <string> assemblies = new List <string>();
// Create several modules with this dependency graph (X->Y meaning Y depends on X)
// a->b, b->c, b->d, c->e, d->e, f
assemblies.Add(GenerateDynamicModule("ModuleA", "ModuleA"));
assemblies.Add(GenerateDynamicModule("ModuleB", "ModuleB", "ModuleA"));
assemblies.Add(GenerateDynamicModule("ModuleC", "ModuleC", "ModuleB"));
assemblies.Add(GenerateDynamicModule("ModuleD", "ModuleD", "ModuleB"));
assemblies.Add(GenerateDynamicModule("ModuleE", "ModuleE", "ModuleC", "ModuleD"));
assemblies.Add(GenerateDynamicModule("ModuleF", "ModuleF"));
ModuleInfo[] Modules = new ModuleInfo[assemblies.Count];
for (int i = 0; i < assemblies.Count; i++)
{
Modules[i] = new ModuleInfo(assemblies[i]);
}
TextWriter consoleOut = Console.Out;
StringBuilder sb = new StringBuilder();
Console.SetOut(new StringWriter(sb));
WorkItem mockContainer = new TestableRootWorkItem();
ModuleLoaderService loader = new ModuleLoaderService(null);
loader.Load(mockContainer, Modules);
List <string> trace =
new List <string>(sb.ToString().Split(new string[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries));
Assert.AreEqual(12, trace.Count);
Assert.IsTrue(trace.IndexOf("ModuleE.AddServices") > trace.IndexOf("ModuleC.AddServices"),
"ModuleC must precede ModuleE");
Assert.IsTrue(trace.IndexOf("ModuleE.AddServices") > trace.IndexOf("ModuleD.AddServices"),
"ModuleD must precede ModuleE");
Assert.IsTrue(trace.IndexOf("ModuleD.AddServices") > trace.IndexOf("ModuleB.AddServices"),
"ModuleB must precede ModuleD");
Assert.IsTrue(trace.IndexOf("ModuleC.AddServices") > trace.IndexOf("ModuleB.AddServices"),
"ModuleB must precede ModuleC");
Assert.IsTrue(trace.IndexOf("ModuleB.AddServices") > trace.IndexOf("ModuleA.AddServices"),
"ModuleA must precede ModuleB");
Assert.IsTrue(trace.Contains("ModuleF.AddServices"), "ModuleF must be loaded");
Console.SetOut(consoleOut);
}
public void CanBeNotifiedOfAddedModules()
{
WorkItem wi = new TestableRootWorkItem();
IModuleLoaderService svc = new ModuleLoaderService(null);
LoadedModuleInfo lmi = null;
Assembly assm = generatedAssemblies["ModuleDependency1"];
svc.ModuleLoaded += delegate(object sender, DataEventArgs <LoadedModuleInfo> e)
{
lmi = e.Data;
};
svc.Load(wi, assm);
Assert.IsNotNull(lmi);
Assert.AreSame(assm, lmi.Assembly);
}
public void ServicesCanBeAddedOnDemand()
{
Assembly asm = generatedAssemblies["ModuleExposingServices"];
ModuleInfo module = new ModuleInfo(asm.CodeBase.Replace(@"file:///", ""));
WorkItem container = new TestableRootWorkItem();
ModuleLoaderService service = new ModuleLoaderService(null);
service.Load(container, module);
Type typeOnDemand = asm.GetType("ModuleExposingServices.OnDemandService");
FieldInfo fldInfo = typeOnDemand.GetField("ServiceCreated");
Assert.IsFalse((bool)fldInfo.GetValue(null), "The service was created.");
container.Services.Get(typeOnDemand);
Assert.IsTrue((bool)fldInfo.GetValue(null), "The service was not created.");
}
public void CanGetModuleMetaDataFromAssembly()
{
Assembly asm = generatedAssemblies["ModuleExposingOnlyServices"];
ModuleLoaderService service = new ModuleLoaderService(null);
WorkItem wi = new TestableRootWorkItem();
bool wasAdded = false;
wi.Services.Added += delegate(object sender, DataEventArgs <object> e)
{
if (e.Data.GetType().Name == "TestService")
{
wasAdded = true;
}
};
service.Load(wi, asm);
Assert.IsTrue(wasAdded);
}
public void CanEnumerateLoadedModules()
{
Assembly compiledAssembly1 = generatedAssemblies["ModuleDependency1"];
Assembly compiledAssembly2 = generatedAssemblies["ModuleDependency2"];
WorkItem wi = new TestableRootWorkItem();
ModuleLoaderService service = new ModuleLoaderService(null);
service.Load(wi, compiledAssembly1);
service.Load(wi, compiledAssembly2);
Assert.AreEqual(2, service.LoadedModules.Count);
Assert.AreSame(compiledAssembly1, service.LoadedModules[0].Assembly);
Assert.AreEqual("module1", service.LoadedModules[0].Name);
Assert.AreEqual(0, service.LoadedModules[0].Dependencies.Count);
Assert.AreSame(compiledAssembly2, service.LoadedModules[1].Assembly);
Assert.AreEqual("module2", service.LoadedModules[1].Name);
Assert.AreEqual(1, service.LoadedModules[1].Dependencies.Count);
Assert.AreEqual("module1", service.LoadedModules[1].Dependencies[0]);
}
public void FailWhenLoadingModulesWithCyclicDependencies()
{
List <string> assemblies = new List <string>();
// Create several modules with this dependency graph (X->Y meaning Y depends on X)
// 1->2, 2->3, 3->4, 4->5, 4->2
assemblies.Add(GenerateDynamicModule("Module1", "Module1"));
assemblies.Add(GenerateDynamicModule("Module2", "Module2", "Module1", "Module4"));
assemblies.Add(GenerateDynamicModule("Module3", "Module3", "Module2"));
assemblies.Add(GenerateDynamicModule("Module4", "Module4", "Module3"));
assemblies.Add(GenerateDynamicModule("Module5", "Module5", "Module4"));
ModuleInfo[] modules = new ModuleInfo[assemblies.Count];
for (int i = 0; i < assemblies.Count; i++)
{
modules[i] = new ModuleInfo(assemblies[i]);
}
WorkItem mockContainer = new TestableRootWorkItem();
ModuleLoaderService loader = new ModuleLoaderService(null);
loader.Load(mockContainer, modules);
}
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 void CanLoadAnonymousModulesWithDepedencies()
{
List <string> assemblies = new List <string>();
// Create several modules with this dependency graph (X->Y meaning Y depends on X)
// a->b, b->c, b->d, c->e, d->e, f
assemblies.Add(GenerateDynamicModule("ModuleX", "ModuleX"));
assemblies.Add(GenerateDynamicModule("ModuleY", null, "ModuleX"));
assemblies.Add(GenerateDynamicModule("ModuleP", "ModuleP"));
assemblies.Add(GenerateDynamicModule("ModuleQ", null, "ModuleP"));
ModuleInfo[] modules = new ModuleInfo[assemblies.Count];
for (int i = 0; i < assemblies.Count; i++)
{
modules[i] = new ModuleInfo(assemblies[i]);
}
TextWriter consoleOut = Console.Out;
StringBuilder sb = new StringBuilder();
Console.SetOut(new StringWriter(sb));
WorkItem mockContainer = new TestableRootWorkItem();
ModuleLoaderService loader = new ModuleLoaderService(null);
loader.Load(mockContainer, modules);
List <string> trace =
new List <string>(sb.ToString().Split(new string[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries));
Assert.AreEqual(8, trace.Count);
Assert.IsTrue(trace.IndexOf("ModuleX.AddServices") < trace.IndexOf("ModuleY.AddServices"),
"ModuleX must precede ModuleY");
Assert.IsTrue(trace.IndexOf("ModuleP.AddServices") < trace.IndexOf("ModuleQ.AddServices"),
"ModuleP must precede ModuleQ");
Console.SetOut(consoleOut);
}
public void LoadSampleModule()
{
WorkItem container = new TestableRootWorkItem();
IModuleLoaderService loader = new ModuleLoaderService(null);
container.Services.Add(typeof(IModuleLoaderService), loader);
int containerCount = GetItemCount(container);
ModuleInfo info = new ModuleInfo();
info.SetAssemblyFile(GenerateDynamicModule("SampleModule", "SampleModule"));
TextWriter consoleOut = Console.Out;
StringBuilder sb = new StringBuilder();
Console.SetOut(new StringWriter(sb));
loader.Load(container, info);
Assert.AreEqual(1, GetItemCount(container) - containerCount);
bool foundUs = false;
foreach (KeyValuePair <string, object> pair in container.Items)
{
if (pair.Value.GetType().FullName == "TestModules.SampleModuleClass")
{
foundUs = true;
break;
}
}
Assert.IsTrue(foundUs);
Console.SetOut(consoleOut);
}
public void NullCompositionContainerThrows()
{
ModuleLoaderService loader = new ModuleLoaderService();
loader.Load(null, new MockModuleInfo());
}
public void NullWorkItemThrows()
{
ModuleLoaderService loader = new ModuleLoaderService(null);
loader.Load(null, new MockModuleInfo());
}