public void CanRetrieveWithCorrectRef() { var retriever = new FileModuleTypeLoader(); var moduleInfo = new ModuleInfo() { Ref = "file://somefile" }; Assert.IsTrue(retriever.CanLoadModuleType(moduleInfo)); }
public void CannotRetrieveWithIncorrectRef() { var retriever = new FileModuleTypeLoader(); var moduleInfo = new ModuleInfo() { Ref = "NotForLocalRetrieval" }; Assert.IsFalse(retriever.CanLoadModuleType(moduleInfo)); }
public void ShouldLoadDownloadedAssemblies() { // NOTE: This test method uses a resource that is built in a pre-build event when building the project. The resource is a // dynamically generated XAP file that is built with the Mocks/Modules/createXap.bat batch file. // If this test is failing unexpectedly, it may be that the batch file is not working correctly in the current environment. var mockFileDownloader = new MockFileDownloader(); const string moduleTypeName = "Microsoft.Practices.Composite.Tests.Mocks.Modules.RemoteModule, RemoteModuleA, Version=0.0.0.0"; var remoteModuleUri = "http://MyModule.xap"; var moduleInfo = new ModuleInfo() { Ref = remoteModuleUri }; XapModuleTypeLoader typeLoader = new TestableXapModuleTypeLoader(mockFileDownloader); ManualResetEvent callbackEvent = new ManualResetEvent(false); typeLoader.BeginLoadModuleType( moduleInfo, delegate { callbackEvent.Set(); }); Assert.IsNull(Type.GetType(moduleTypeName)); Stream xapStream = Assembly.GetExecutingAssembly().GetManifestResourceStream("Microsoft.Practices.Composite.Tests.Mocks.Modules.RemoteModules.xap"); mockFileDownloader.InvokeOpenReadCompleted(new DownloadCompletedEventArgs(xapStream, null, false, mockFileDownloader.DownloadAsyncArgumentUserToken)); Assert.IsTrue(callbackEvent.WaitOne(500)); Assert.IsNotNull(Type.GetType(moduleTypeName)); }
/// <summary> /// Registers a module with the <see cref="StaticModuleEnumerator" />. /// </summary> /// <param name="moduleType">The module type. This class should implement <see cref="IModule"/>.</param> /// <param name="dependsOn">The names of the modules that this module depends on, if any.</param> /// <returns>The same instance of <see cref="StaticModuleEnumerator"/>.</returns> /// <remarks>The module name will be the Name of the type specified in <paramref name="moduleType"/>.</remarks> public StaticModuleEnumerator AddModule(Type moduleType, params string[] dependsOn) { ModuleInfo moduleInfo = new ModuleInfo(moduleType.Assembly.FullName , moduleType.FullName , moduleType.Name , dependsOn); _modules.Add(moduleInfo); return this; }
public void CanCreateCatalogFromList() { var moduleInfo = new ModuleInfo("MockModule", "type"); List<ModuleInfo> moduleInfos = new List<ModuleInfo> { moduleInfo }; var moduleCatalog = new ModuleCatalog(moduleInfos); Assert.AreEqual(1, moduleCatalog.Modules.Count()); Assert.AreEqual(moduleInfo, moduleCatalog.Modules.ElementAt(0)); }
public void BeginLoadModuleType(ModuleInfo moduleInfo, ModuleTypeLoadedCallback callback) { Thread retrieverThread = new Thread(() => { Thread.Sleep(SleepTimeOut); callback(moduleInfo, CallbackArgumentError); callbackEvent.Set(); }); retrieverThread.Start(); }
public void ShouldForwardValuesToModuleInfo() { ModuleInfoGroup group = new ModuleInfoGroup(); group.Ref = "MyCustomGroupRef"; ModuleInfo moduleInfo = new ModuleInfo(); Assert.IsNull(moduleInfo.Ref); group.Add(moduleInfo); Assert.AreEqual(group.Ref, moduleInfo.Ref); }
public void ShouldCallDownloadAsync() { var mockFileDownloader = new MockFileDownloader(); var remoteModuleUri = "http://MyModule.xap"; var moduleInfo = new ModuleInfo() { Ref = remoteModuleUri }; XapModuleTypeLoader typeLoader = new TestableXapModuleTypeLoader(mockFileDownloader); typeLoader.BeginLoadModuleType(moduleInfo, delegate { }); Assert.IsTrue(mockFileDownloader.DownloadAsyncCalled); Assert.AreEqual(remoteModuleUri, mockFileDownloader.downloadAsyncArgumentUri.OriginalString); }
public void InitializationExceptionsAreWrapped() { Assembly asm = CompilerHelper.CompileFileAndLoadAssembly("Microsoft.Practices.Composite.Tests.Mocks.Modules.MockModuleThrowingException.cs", @".\MocksModulesThwrowing\MockModuleThrowingException.dll"); ModuleLoader loader = new ModuleLoader(new MockContainerAdapter(), new MockLogger()); ModuleInfo info = new ModuleInfo(asm.CodeBase.Replace(@"file:///", ""), "Microsoft.Practices.Composite.Tests.Mocks.Modules.MockModuleThrowingException", "MockModuleThrowingException"); loader.Initialize(new[] { info }); }
public void BeginLoadModuleType(ModuleInfo moduleInfo, ModuleTypeLoadedCallback callback) { Exception error = null; try { this.assemblyResolver.LoadAssemblyFrom(moduleInfo.Ref); } catch (Exception ex) { error = ex; } callback(moduleInfo, error); }
protected override IModuleCatalog GetModuleCatalog() { string query = App.Current.Host.Source.Query; var level1 = new ModuleInfo(ModuleNames.level1, string.Format("{0}.Level1Module, {0}, Version=1.0.0.0", ModuleNames.level1)) { InitializationMode = InitializationMode.OnDemand, Ref = ModuleNames.level1 + ".xap" }; var level2 = new ModuleInfo(ModuleNames.level2, string.Format("{0}.Level2Module, {0}, Version=1.0.0.0",ModuleNames.level2)) { InitializationMode = InitializationMode.OnDemand, Ref = ModuleNames.level2 + ".xap" }; var level3 = new ModuleInfo(ModuleNames.level3, string.Format("{0}.Level3Module, {0}, Version=1.0.0.0", ModuleNames.level3)) { InitializationMode = InitializationMode.OnDemand, Ref = ModuleNames.level3 + ".xap" }; var level4 = new ModuleInfo(ModuleNames.level4, string.Format("{0}.Level4Module, {0}, Version=1.0.0.0", ModuleNames.level4)) { InitializationMode = InitializationMode.OnDemand, Ref = ModuleNames.level4 + ".xap" }; ModuleCatalog cat = new ModuleCatalog(); cat.AddModule(level1); cat.AddModule(level2); cat.AddModule(level3); cat.AddModule(level4); return cat; }
/// <summary> /// Adds a new module that is statically referenced to the specified module info group. /// </summary> /// <param name="moduleInfoGroup">The group where to add the module info in.</param> /// <param name="moduleName">The name for the module.</param> /// <param name="moduleType">The type for the module. This type should be a descendant of <see cref="IModule"/>.</param> /// <param name="dependsOn">The names for the modules that this module depends on.</param> /// <returns>Returns the instance of the passed in module info group, to provide a fluid interface.</returns> public static ModuleInfoGroup AddModule( this ModuleInfoGroup moduleInfoGroup, string moduleName, Type moduleType, params string[] dependsOn) { if (moduleType == null) { throw new ArgumentNullException("moduleType"); } ModuleInfo moduleInfo = new ModuleInfo(moduleName, moduleType.AssemblyQualifiedName); moduleInfo.DependsOn.AddRange(dependsOn); moduleInfoGroup.Add(moduleInfo); return moduleInfoGroup; }
public void Initialize(ModuleInfo moduleInfo) { IModule moduleInstance = null; try { moduleInstance = this.CreateModule(moduleInfo.ModuleType); moduleInstance.Initialize(); } catch (Exception ex) { this.HandleModuleInitializationError( moduleInfo, moduleInstance != null ? moduleInstance.GetType().Assembly.FullName : null, ex); } }
public void ShouldReturnErrorIfDownloadFails() { var mockFileDownloader = new MockFileDownloader(); var remoteModuleUri = "http://MyModule.xap"; var moduleInfo = new ModuleInfo() { Ref = remoteModuleUri }; XapModuleTypeLoader typeLoader = new TestableXapModuleTypeLoader(mockFileDownloader); ManualResetEvent callbackEvent = new ManualResetEvent(false); Exception error = null; typeLoader.BeginLoadModuleType( moduleInfo, delegate(ModuleInfo callbackModuleInfo, Exception moduleError) { error = moduleError; callbackEvent.Set(); }); mockFileDownloader.InvokeOpenReadCompleted(new DownloadCompletedEventArgs(null, new InvalidOperationException("Mock Ex"), false, mockFileDownloader.DownloadAsyncArgumentUserToken)); Assert.IsTrue(callbackEvent.WaitOne(500)); Assert.IsNotNull(error); Assert.IsInstanceOfType(error, typeof(InvalidOperationException)); }
public void Initialize(ModuleInfo[] moduleInfos) { List<ModuleInfo> modules = GetModulesLoadOrder(moduleInfos); IEnumerable<ModuleInfo> newModules = LoadAssembliesAndTypes(modules); foreach (ModuleInfo moduleInfo in newModules) { Type type = initializedModules[moduleInfo.ModuleType]; try { IModule module = CreateModule(type); module.Initialize(); } catch (Exception e) { HandleModuleLoadError(moduleInfo, type.Assembly.FullName, e); } } }
/// <summary> /// Handles any exception ocurred in the module Initialization process, /// logs the error using the <seealso cref="ILoggerFacade"/> and throws a <seealso cref="ModuleInitializeException"/>. /// This method can be overriden to provide a different behavior. /// </summary> /// <param name="moduleInfo">The module metadata where the error happenened.</param> /// <param name="assemblyName">The assembly name.</param> /// <param name="exception">The exception thrown that is the cause of the current error.</param> /// <exception cref="ModuleInitializeException"></exception> public virtual void HandleModuleInitializationError(ModuleInfo moduleInfo, string assemblyName, Exception exception) { Exception moduleException; if (exception is ModuleInitializeException) { moduleException = exception; } else { if (!string.IsNullOrEmpty(assemblyName)) { moduleException = new ModuleInitializeException(moduleInfo.ModuleName, assemblyName, exception.Message, exception); } else { moduleException = new ModuleInitializeException(moduleInfo.ModuleName, exception.Message, exception); } } this.loggerFacade.Log(moduleException.ToString(), Category.Exception, Priority.High); throw moduleException; }
public void ShouldResolveModuleAndInitializeSingleModule() { IContainerFacade containerFacade = new MockContainerAdapter(); var service = new ModuleLoader(containerFacade, new MockLogger()); FirstTestModule.wasInitializedOnce = false; var info = new ModuleInfo(typeof(FirstTestModule).Assembly.Location, typeof(FirstTestModule).FullName, "FirstTestModule"); service.Initialize(new[] { info }); Assert.IsTrue(FirstTestModule.wasInitializedOnce); }
public void FailWhenDependingOnMissingModule() { string assembly = CompilerHelper.GenerateDynamicModule("ModuleK", null, "ModuleL"); ModuleInfo module = new ModuleInfo(assembly, "ModuleK.TestsModules.ModuleKClass", "ModuleK", "ModuleL"); ModuleLoader loader = new ModuleLoader(new MockContainerAdapter(), new MockLogger()); loader.Initialize(new[] { module }); }
public override void HandleModuleLoadError(ModuleInfo moduleInfo, string assemblyName, Exception exception) { HandleModuleLoadErrorCalled = true; }
public void InexistentAssemblyFileThrows() { IContainerFacade containerFacade = new MockContainerAdapter(); var service = new TestableModuleInitializerService(containerFacade, new MockLogger()); var moduleInfo = new ModuleInfo(typeof(FirstTestModule).Assembly.Location + "NotValid.dll", typeof(FirstTestModule).FullName, "InexistantModule"); bool exceptionThrown = false; try { service.Initialize(new[] { moduleInfo }); } catch (Exception ex) { Assert.AreEqual(typeof(ModuleLoadException), ex.GetType()); StringAssert.Contains(ex.Message, "NotValid.dll"); StringAssert.Contains(ex.Message, "not found"); exceptionThrown = true; } Assert.IsTrue(exceptionThrown, "No exception thrown."); }
public void DuplicateModuleNameThrows() { IContainerFacade containerFacade = new MockContainerAdapter(); var service = new TestableModuleInitializerService(containerFacade, new MockLogger()); var firstModuleInfo = new ModuleInfo(typeof(FirstTestModule).Assembly.Location, typeof(FirstTestModule).FullName, "SameName"); var secondModuleInfo = new ModuleInfo(typeof(SecondTestModule).Assembly.Location, typeof(SecondTestModule).FullName, "SameName"); bool exceptionThrown = false; try { service.Initialize(new[] { firstModuleInfo, secondModuleInfo }); } catch (Exception ex) { Assert.AreEqual(typeof(ModuleLoadException), ex.GetType()); StringAssert.Contains(ex.Message, "SameName"); StringAssert.Contains(ex.Message, "duplicate"); exceptionThrown = true; } Assert.IsTrue(exceptionThrown, "No exception thrown."); }
public void ShouldNotLoadAssemblyThatHasAlreadyBeenLoaded() { IContainerFacade containerFacade = new MockContainerAdapter(); var service = new TestableModuleInitializerService(containerFacade, new MockLogger()); var firstModuleInfo = new ModuleInfo(typeof(FirstTestModule).Assembly.Location, typeof(FirstTestModule).FullName, "FirstTestModule"); var secondModuleInfo = new ModuleInfo(typeof(SecondTestModule).Assembly.Location, typeof(SecondTestModule).FullName, "SecondTestModule"); Assert.AreEqual(0, service.LoadedAssemblies.Count); service.Initialize(new[] { firstModuleInfo, secondModuleInfo }); Assert.AreEqual(1, service.LoadedAssemblies.Count); }
private static ModuleInfo CreateModuleInfo(string name, InitializationMode initializationMode, params string[] dependsOn) { ModuleInfo moduleInfo = new ModuleInfo(name, name); moduleInfo.InitializationMode = initializationMode; moduleInfo.DependsOn.AddRange(dependsOn); return moduleInfo; }
void IModuleInitializer.Initialize(ModuleInfo moduleInfo) { this.Initialize(moduleInfo); }
IEnumerable<ModuleInfo> IModuleCatalog.GetDependentModules(ModuleInfo moduleInfo) { if (GetDependentModules == null) return new List<ModuleInfo>(); return GetDependentModules(moduleInfo); }
private static ModuleInfo CreateModuleInfo(Type type, InitializationMode initializationMode, params string[] dependsOn) { ModuleInfo moduleInfo = new ModuleInfo(type.Name, type.AssemblyQualifiedName); moduleInfo.InitializationMode = initializationMode; moduleInfo.DependsOn.AddRange(dependsOn); return moduleInfo; }
public void ShouldNotInitializeIfAlreadyLoaded() { ModuleLoadTracker.ModuleLoadStack.Clear(); IContainerFacade containerFacade = new MockContainerAdapter(); var service = new ModuleLoader(containerFacade, new MockLogger()); FirstTestModule.wasInitializedOnce = false; SecondTestModule.wasInitializedOnce = false; var firstModuleInfo = new ModuleInfo(typeof(FirstTestModule).Assembly.Location, typeof(FirstTestModule).FullName, "FirstTestModule"); service.Initialize(new[] { firstModuleInfo }); Assert.AreEqual(1, ModuleLoadTracker.ModuleLoadStack.Count, "ModuleLoadStack should only contain 1 module"); service.Initialize(new[] { firstModuleInfo }); Assert.AreEqual(1, ModuleLoadTracker.ModuleLoadStack.Count, "ModuleLoadStack should not have module that has already been loaded"); }
public void Initialize(ModuleInfo moduleInfo) { LoadCalled = true; this.LoadedModules.Add(moduleInfo); }
public void ShouldLogModuleInitializationError() { IContainerFacade containerFacade = new MockContainerAdapter(); var logger = new MockLogger(); var service = new ModuleLoader(containerFacade, logger); ExceptionThrowingModule.wasInitializedOnce = false; var exceptionModule = new ModuleInfo(typeof(ExceptionThrowingModule).Assembly.Location, typeof(ExceptionThrowingModule).FullName, "ExceptionThrowingModule"); try { service.Initialize(new[] { exceptionModule }); } catch (ModuleLoadException) { } Assert.IsNotNull(logger.LastMessage); StringAssert.Contains(logger.LastMessage, "ExceptionThrowingModule"); }
public void Initialize(ModuleInfo moduleInfo) { LoadBody(moduleInfo); }
/// <summary> /// Evaluates the <see cref="ModuleInfo.Ref"/> property to see if the current typeloader will be able to retrieve the <paramref name="moduleInfo"/>. /// Returns true if the <see cref="ModuleInfo.Ref"/> property starts with "file://", because this indicates that the file /// is a local file. /// </summary> /// <param name="moduleInfo">Module that should have it's type loaded.</param> /// <returns> /// <see langword="true"/> if the current typeloader is able to retrieve the module, otherwise <see langword="false"/>. /// </returns> public bool CanLoadModuleType(ModuleInfo moduleInfo) { return(moduleInfo.Ref != null && moduleInfo.Ref.StartsWith("file://", StringComparison.Ordinal)); }