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 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 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 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()); }