public void loading_module_fails_during_loading_assembly_phase_throws_an_exception_callback()
{
const string dir1 = @"Modules\Dependent5\ModuleA\";
const string dir2 = @"Modules\Dependent5\ModuleB\";
// dependant module generation
ModuleCompiler.SetUpModuleWithManifest(dir1,
@"..\Source\Nomad.Tests\FunctionalTests\Data\ErrorLoad\DependencyModule1.cs");
// second dependent module generation
ModuleCompiler.SetUpModuleWithManifest(dir2,
@"..\Source\Nomad.Tests\FunctionalTests\Data\ErrorLoad\ModuleWithDependency.cs",
dir1 + "DependencyModule1.dll");
// overwriting the dll file, causing BadImageFormatException
File.Create(dir1 + "DependencyModule1.dll");
// define discovery sequence
var discovery = new CompositeModuleDiscovery(new IModuleDiscovery[]
{
new DirectoryModuleDiscovery(
dir2, SearchOption.TopDirectoryOnly),
new DirectoryModuleDiscovery(
dir1, SearchOption.TopDirectoryOnly),
});
// perform test and assert
Assert.Throws <NomadCouldNotLoadModuleException>(
() => LoadModulesFromDiscovery(discovery));
}
public void selective_manual_update_with_updater_wokring_on_threads()
{
// create the updater module for manual testing
string updaterDir = NomadConfigurationSettings.ModuleDirectoryPath;
ModuleCompiler.SetUpModuleWithManifest(updaterDir,
@"..\Source\Nomad.Tests\FunctionalTests\Data\Updater\UpdaterModuleManual.cs");
// set up two simple modules
IModuleDiscovery basicDiscovery = SetUpTwoSimpleModulesGetTheirDiscovery();
// override kernel configuration
NomadConfigurationSettings.UpdaterType = UpdaterType.Manual;
SetUpKernel();
// skip verification about loaded modules, just load them
Kernel.LoadModules(new CompositeModuleDiscovery(basicDiscovery, new DirectoryModuleDiscovery(updaterDir, SearchOption.TopDirectoryOnly)));
// get updater reference, for synchronization
var updater = Kernel.ServiceLocator.Resolve <IUpdater>();
// initialize the updating through updater module using event aggregator and publish
Kernel.EventAggregator.Publish(new BeginUpdateMessage());
// no need to verify the messages - just final verification of loaded modules wait for finish
updater.UpdateFinished.WaitOne();
var loadedModules = Kernel.ServiceLocator.Resolve <ILoadedModulesService>().GetLoadedModules();
Assert.AreEqual(3, loadedModules.Count); // updater + simples ;)
AssertVersion("1.0.0.0", loadedModules, "SimplestModulePossible1");
AssertVersion("2.0.0.0", loadedModules, "SimplestModulePossible2");
}
public void loading_one_module_dependent_on_others_callback()
{
const string dir = @"Modules\Dependent1\ModuleA\";
const string dir2 = @"Modules\Dependent1\ModuleB\";
const string dir3 = @"Modules\Dependent1\ModuleC\";
// dependant module generation
ModuleCompiler.SetUpModuleWithManifest(dir,
@"..\Source\Nomad.Tests\FunctionalTests\Data\Dependencies\DependencyModule1.cs");
// second dependent module generation
ModuleCompiler.SetUpModuleWithManifest(dir3,
@"..\Source\Nomad.Tests\FunctionalTests\Data\Dependencies\DependencyModule2.cs");
// depending module generation
ModuleCompiler.SetUpModuleWithManifest(dir2,
@"..\Source\Nomad.Tests\FunctionalTests\Data\Dependencies\ModuleWithDependency.cs",
dir + "DependencyModule1.dll", dir3 + "DependencyModule2.dll");
// define discovery sequence
var discovery = new CompositeModuleDiscovery(new IModuleDiscovery[]
{
new DirectoryModuleDiscovery(
dir2, SearchOption.TopDirectoryOnly),
new DirectoryModuleDiscovery(
dir, SearchOption.TopDirectoryOnly),
new DirectoryModuleDiscovery(
dir3, SearchOption.TopDirectoryOnly),
});
// perform test and assert
LoadModulesFromDiscovery(discovery);
AssertModulesLoadedAreEqualTo("DependencyModule1", "DependencyModule2",
"ModuleWithDependency");
}
public void loaded_modules_appear_on_list_in_kernel_and_modules_domain()
{
ModuleCompiler.SetUpModuleWithManifest(dir,
@"..\Source\Nomad.Tests\FunctionalTests\Data\Services\SimplestModulePossible1.cs");
ModuleCompiler.SetUpModuleWithManifest(dir2,
@"..\Source\Nomad.Tests\FunctionalTests\Data\Services\SimplestModulePossible2.cs");
ModuleCompiler.SetUpModuleWithManifest(dir3,
@"..\Source\Nomad.Tests\FunctionalTests\Data\Services\LoadedModulesServiceTestingModule.cs");
// perform kernel test and assert
LoadModulesFromDiscovery(new DirectoryModuleDiscovery(@"Modules\Services\", SearchOption.AllDirectories));
var loadedModulesService = Kernel.ServiceLocator.Resolve <ILoadedModulesService>();
Assert.AreEqual(3, loadedModulesService.GetLoadedModules().Count);
//verify from VerificationModule in modules domain
int loaded;
using (StreamReader verificationFile =
File.OpenText(
@"Modules\Services\VerificationModule\ILoadedModulesServiceVerificationFile"))
{
Int32.TryParse(verificationFile.ReadLine(),
out loaded);
}
Assert.AreEqual(3, loaded);
}
/// <summary>
/// Set up the Two Modules A,B into with provided version. Based on <see cref="ModuleCompiler.DefaultSimpleModuleSource"/>
/// </summary>
/// <param name="directory"></param>
/// <param name="versionString"></param>
/// <returns></returns>
private IModuleDiscovery SetUpModulesWithVersion(string directory,
string versionString)
{
string moduleA = directory + @"\ModuleA";
string moduleB = directory + @"\ModuleB";
ManifestBuilderConfiguration builderConfiguration = ManifestBuilderConfiguration.Default;
builderConfiguration.VersionProvider = GetVersionProviderForVersion(versionString);
ModuleCompiler.SetUpModuleWithManifest(moduleA, ModuleCompiler.DefaultSimpleModuleSource,
builderConfiguration);
ModuleCompiler.SetUpModuleWithManifest(moduleB, ModuleCompiler.DefaultSimpleModuleSourceAlternative,
builderConfiguration);
return(new CompositeModuleDiscovery(new DirectoryModuleDiscovery(moduleA, SearchOption.TopDirectoryOnly),
new DirectoryModuleDiscovery(moduleB, SearchOption.TopDirectoryOnly)));
}
loading_module_with_dependency_with_no_dependency_present_results_in_exception_callback()
{
const string dir = @"Modules\Dependent3\ModuleA\";
const string dir2 = @"Modules\Dependent3\ModuleB\";
const string dir3 = @"Modules\Dependent3\ModuleC\";
// dependant module generation
ModuleCompiler.SetUpModuleWithManifest(dir,
@"..\Source\Nomad.Tests\FunctionalTests\Data\ChainDependencies\DependencyModule1.cs");
// second dependent module generation
ModuleCompiler.SetUpModuleWithManifest(dir3,
@"..\Source\Nomad.Tests\FunctionalTests\Data\ChainDependencies\DependencyModule2.cs",
dir + "DependencyModule1.dll");
// third dependent module generation
ModuleCompiler.SetUpModuleWithManifest(dir2,
@"..\Source\Nomad.Tests\FunctionalTests\Data\ChainDependencies\ModuleWithDependency.cs",
dir3 + "DependencyModule2.dll");
// remove dependency
Directory.Delete(dir3, true);
// define discovery sequence
var discovery = new CompositeModuleDiscovery(new IModuleDiscovery[]
{
new DirectoryModuleDiscovery(
dir2, SearchOption.TopDirectoryOnly),
new DirectoryModuleDiscovery(
dir, SearchOption.TopDirectoryOnly),
});
// perform test and assert
Assert.Throws <NomadCouldNotLoadModuleException>(
() => LoadModulesFromDiscovery(discovery));
}
public void basic_usage_scenerio_with_newer_versions_avaliable_automatic_update()
{
// create the updater module
string updaterDir = NomadConfigurationSettings.ModuleDirectoryPath;
ModuleCompiler.SetUpModuleWithManifest(updaterDir,
@"..\Source\Nomad.Tests\FunctionalTests\Data\Updater\UpdaterModule.cs");
// set up two simple modules
IModuleDiscovery v0Discovery = SetUpTwoSimpleModulesGetTheirDiscovery();
// override kernel configuration and initialize kernel
NomadConfigurationSettings.UpdaterType = UpdaterType.Automatic;
SetUpKernel();
// test against loading
var discovery = new CompositeModuleDiscovery(new DirectoryModuleDiscovery(updaterDir, SearchOption.TopDirectoryOnly),
v0Discovery);
Kernel.LoadModules(discovery);
// verify the versions of the loaded modules are proper
IList <ModuleInfo> loadedModules =
Kernel.ServiceLocator.Resolve <ILoadedModulesService>().GetLoadedModules();
Assert.AreEqual(3, loadedModules.Count);
AssertVersion("1.0.0.0", loadedModules, "SimplestModulePossible1");
AssertVersion("1.0.0.0", loadedModules, "SimplestModulePossible2");
// check if all stages of update were done
bool avaliableUpdates = false;
bool readyUpdates = false;
Kernel.EventAggregator.Subscribe <NomadAvailableUpdatesMessage>(
message =>
{
if (message.Error == false)
{
avaliableUpdates = true;
}
});
Kernel.EventAggregator.Subscribe <NomadUpdatesReadyMessage>(message =>
{
if (message.Error ==
false)
{
readyUpdates =
true;
}
});
var updater = Kernel.ServiceLocator.Resolve <IUpdater>();
// initialize the updating through updater module using event aggregator and publish
Kernel.EventAggregator.Publish(new BeginUpdateMessage());
// verify stages
Assert.IsTrue(avaliableUpdates, "Available updates message was not published.");
Assert.IsTrue(readyUpdates, "Updates ready message was not published.");
// verify the outcome of the updater after finishing (this wait is for test purposes)
updater.UpdateFinished.WaitOne();
Assert.AreEqual(UpdaterStatus.Idle, Kernel.ServiceLocator.Resolve <IUpdater>().Status, "Problem with the state of the updater");
// verify the versions of the newest modules are loaded
loadedModules = Kernel.ServiceLocator.Resolve <ILoadedModulesService>().GetLoadedModules();
Assert.AreEqual(3, loadedModules.Count);
AssertVersion("2.0.0.0", loadedModules, "SimplestModulePossible1");
AssertVersion("2.0.0.0", loadedModules, "SimplestModulePossible2");
}
public void basic_update_scenario_when_installing_new_module()
{
// create the updater module
string updaterDir = NomadConfigurationSettings.ModuleDirectoryPath;
ModuleCompiler.SetUpModuleWithManifest(updaterDir,
@"..\Source\Nomad.Tests\FunctionalTests\Data\Updater\UpdaterModule.cs");
// set up two simple modules -- to be loaded into kernel
string modulaADir = Path.Combine(NomadConfigurationSettings.ModuleDirectoryPath, "moduleA");
string modulaBDir = Path.Combine(NomadConfigurationSettings.ModuleDirectoryPath, "moduleB");
ModuleCompiler.SetUpModuleWithManifest(modulaADir, ModuleCompiler.DefaultSimpleModuleSource);
ModuleCompiler.SetUpModuleWithManifest(modulaBDir, ModuleCompiler.DefaultSimpleModuleSourceAlternative);
var twoSimpleModules = new CompositeModuleDiscovery(
new DirectoryModuleDiscovery(modulaADir, SearchOption.TopDirectoryOnly),
new DirectoryModuleDiscovery(modulaBDir, SearchOption.TopDirectoryOnly)
);
// set up third simple module -- completely independent to be placed in remote repository
string moduleCDir = Path.Combine(NomadConfigurationSettings.ModuleDirectoryPath, "moduleC");
ModuleCompiler.SetUpModuleWithManifest(moduleCDir, ModuleCompiler.DefaultSimpleModuleSourceLastAlternative);
// put the third one in repository
var listOfModuleInRepositoryInfos = twoSimpleModules.GetModules();
var listOfModuleInRepository = new List <ModuleManifest>(twoSimpleModules.GetModules().Select(x => x.Manifest));
SetUpModulesRepository(listOfModuleInRepository, listOfModuleInRepositoryInfos);
// initialize kernel
NomadConfigurationSettings.UpdaterType = UpdaterType.Automatic;
SetUpKernel();
// set up the subscribers for stages of update
bool updatesChecked = false;
bool updatesReady = false;
Kernel.EventAggregator.Subscribe <NomadAvailableUpdatesMessage>((m) =>
{
Assert.IsFalse(m.Error, "There should no error in checking");
updatesChecked = true;
});
Kernel.EventAggregator.Subscribe <NomadUpdatesReadyMessage>((m) =>
{
Assert.IsFalse(m.Error, "There should no error in preparing");
updatesReady = true;
});
// load those two modules into kernel
var discovery = new CompositeModuleDiscovery(twoSimpleModules,
new DirectoryModuleDiscovery(updaterDir, SearchOption.TopDirectoryOnly));
Kernel.LoadModules(discovery);
// invoke automatic update process
var updater = Kernel.ServiceLocator.Resolve <IUpdater>();
Kernel.EventAggregator.Publish(new BeginUpdateMessage());
// check stages of update
Assert.IsTrue(updatesChecked, "Updates checked message has never been invoked");
Assert.IsTrue(updatesReady, "Updates ready message has never been invoked ");
// wait for updater to finish and being in a good state
Assert.NotNull(updater.UpdateFinished, "Update finshed object is null, meaning that no one has started perform update");
updater.UpdateFinished.WaitOne();
Assert.AreEqual(UpdaterStatus.Idle, Kernel.ServiceLocator.Resolve <IUpdater>().Status, "Problem with the state of the updater after reload");
// assert that there are 4 modules installed and running - 3 simples and one updater
var loadedModules = Kernel.ServiceLocator.Resolve <ILoadedModulesService>().GetLoadedModules();
Assert.AreEqual(4, loadedModules.Count);
}
public void failing_update_beacause_of_the_missing_dependencies()
{
// create the updater module
string updaterDir = NomadConfigurationSettings.ModuleDirectoryPath;
ModuleCompiler.SetUpModuleWithManifest(updaterDir,
@"..\Source\Nomad.Tests\FunctionalTests\Data\Updater\UpdaterModule.cs");
// version for modules A, B and C
const string versionString = "1.0.0.0";
// create modules A with version v0 (this version and dependencies are only in manifest - not in assembly)
var moduelADir = Path.Combine(NomadConfigurationSettings.ModuleDirectoryPath, @"ModuleADir");
var moduleAConfiguration = ManifestBuilderConfiguration.Default;
moduleAConfiguration.VersionProvider = GetVersionProviderForVersion(versionString);
moduleAConfiguration.ModulesDependenciesProvider = GetModuleDependenciesOnSingleModule("SimplestModulePossible2", versionString);
ModuleCompiler.SetUpModuleWithManifest(moduelADir, ModuleCompiler.DefaultSimpleModuleSource, moduleAConfiguration);
// create module B with the same setting as A (with version v0)
var moduelBDir = Path.Combine(NomadConfigurationSettings.ModuleDirectoryPath, @"ModuleBDir");
moduleAConfiguration = ManifestBuilderConfiguration.Default;
moduleAConfiguration.VersionProvider = GetVersionProviderForVersion(versionString);
moduleAConfiguration.ModulesDependenciesProvider = GetModuleDependenciesOnSingleModule("SimplestModulePossible3", versionString);
ModuleCompiler.SetUpModuleWithManifest(moduelBDir, ModuleCompiler.DefaultSimpleModuleSourceAlternative, moduleAConfiguration);
// create module C with no dependency on any other module with version v0
var moduleCDir = Path.Combine(NomadConfigurationSettings.ModuleDirectoryPath, @"ModuleCDir");
moduleAConfiguration = ManifestBuilderConfiguration.Default;
moduleAConfiguration.VersionProvider = GetVersionProviderForVersion(versionString);
ModuleCompiler.SetUpModuleWithManifest(moduleCDir, ModuleCompiler.DefaultSimpleModuleSourceLastAlternative, moduleAConfiguration);
// create module B in version v1 which depends on module C in version v1
var moduleBVersionUpperDir = Path.Combine(NomadConfigurationSettings.ModuleDirectoryPath, @"ModuleBUpperDir");
moduleAConfiguration = ManifestBuilderConfiguration.Default;
moduleAConfiguration.VersionProvider = GetVersionProviderForVersion("2.0.0.0");
moduleAConfiguration.ModulesDependenciesProvider = GetModuleDependenciesOnSingleModule("SimplestModulePossible3", "2.0.0.0");
ModuleCompiler.SetUpModuleWithManifest(moduleBVersionUpperDir, ModuleCompiler.DefaultSimpleModuleSourceAlternative, moduleAConfiguration);
// put module B into repository
var bRepoModuleInfo = new DirectoryModuleDiscovery(moduleBVersionUpperDir, SearchOption.TopDirectoryOnly)
.GetModules()
.Select(x => x)
.Single();
ModulesRepository.Setup(x => x.GetAvailableModules())
.Returns(new AvailableModules(new List <ModuleManifest>()
{
bRepoModuleInfo.Manifest
}));
ModulesRepository
.Setup(x => x.GetModule(It.IsAny <string>()))
.Returns(new ModulePackage()
{
ModuleManifest = bRepoModuleInfo.Manifest,
ModuleZip = GetZippedData(new List <ModuleInfo>()
{
bRepoModuleInfo
}, bRepoModuleInfo.Manifest.ModuleName)
});
// configure kernel
NomadConfigurationSettings.UpdaterType = UpdaterType.Automatic;
SetUpKernel();
// load modules A,B,C in version v0 into Nomad
var discovery = new CompositeModuleDiscovery(new DirectoryModuleDiscovery(moduelADir, SearchOption.TopDirectoryOnly),
new DirectoryModuleDiscovery(moduelBDir, SearchOption.TopDirectoryOnly),
new DirectoryModuleDiscovery(moduleCDir, SearchOption.TopDirectoryOnly),
new DirectoryModuleDiscovery(updaterDir, SearchOption.TopDirectoryOnly));
Kernel.LoadModules(discovery);
// register for updates available message
var hasBeenInvoked = false;
Kernel.EventAggregator.Subscribe <NomadUpdatesReadyMessage>(message =>
{
hasBeenInvoked = true;
Assert.IsTrue(message.Error, "The error should be reported");
// list of non valid modules is accurate
Assert.AreEqual("SimplestModulePossible2", message.ModuleManifests[0].ModuleName);
});
// initialize check updates (automatic mode)
Kernel.EventAggregator.Publish(new BeginUpdateMessage());
// verify that update can not be done
Assert.IsTrue(hasBeenInvoked, "The updates ready message was not invoked");
Assert.AreEqual(UpdaterStatus.Invalid, Kernel.ServiceLocator.Resolve <IUpdater>().Status);
}