public void performing_updates_has_information_about_failure_modules_operations_throws()
{
ModulesOperations.Setup(x => x.LoadModules(It.IsAny <IModuleDiscovery>()))
.Throws(new Exception("Can not discovery moduels"));
var moduleManifests = new List <ModuleManifest>
{
new ModuleManifest(),
};
// preapre stub module manifest
NomadUpdater.PrepareUpdate(moduleManifests);
ModulesRepository.Setup(x => x.GetModule(It.IsAny <string>()))
.Returns(new ModulePackage()
{
ModuleManifest = moduleManifests[0]
});
NomadUpdater.PerformUpdates(new CompositeModuleDiscovery());
// wait till end to get the information about failure
NomadUpdater.UpdateFinished.WaitOne();
Assert.AreEqual(UpdaterStatus.Invalid, NomadUpdater.Status);
}
public void preparing_updates_calls_proper_subsystems_publishes_msg_at_the_end()
{
// return the same - might stop working if some of the code is gonna be put to verify download };
var modulePacakge = new ModulePackage {
ModuleManifest = _moduleManifest
};
ModulesRepository.Setup(x => x.GetModule(It.Is <string>(y => y == _moduleName)))
.Returns(modulePacakge)
.Verifiable("This package should be downloaded");
EventAggregator.Setup(x => x.Publish(It.IsAny <NomadUpdatesReadyMessage>()))
.Callback <NomadUpdatesReadyMessage>(msg =>
{
Assert.IsFalse(msg.Error);
Assert.AreEqual(1, msg.ModuleManifests.Count);
Assert.AreSame(modulePacakge.ModuleManifest,
msg.ModuleManifests[0]);
})
.Returns(null)
.Verifiable("This message should be published upon exit");
NomadUpdater.PrepareUpdate(new List <ModuleManifest>()
{
_moduleManifest
});
EventAggregator.Verify();
ModulesRepository.Verify();
Assert.AreEqual(UpdaterStatus.Prepared, NomadUpdater.Status);
}
public void performing_updates_uses_packager_on_n_packages_exactly_n_times(int times)
{
int n = times;
IList <ModuleManifest> modulePackages = new List <ModuleManifest>();
for (int i = 0; i < n; i++)
{
modulePackages.Add(new ModuleManifest()
{
ModuleName = "Test" + i
});
}
// provide the proper packages per modules
ModulesRepository.Setup(x => x.GetModule(It.IsAny <string>()))
.Returns <string>(name => new ModulePackage()
{
ModuleManifest = modulePackages
.Where(x => x.ModuleName.Equals(name))
.Select(x => x).Single()
});
NomadUpdater.PrepareUpdate(modulePackages);
NomadUpdater.PerformUpdates(new CompositeModuleDiscovery());
NomadUpdater.UpdateFinished.WaitOne();
ModulePackager.Verify(x => x.PerformUpdates(PluginsDir, It.IsAny <ModulePackage>()),
Times.Exactly(n),
string.Format("One package should be invoked {0} times.", n));
}
public void publishes_avaliable_modules_message_when_everything_is_ok()
{
const string assembly = "test_assembly.dll";
var moduleInfo = new ModuleInfo(assembly);
var moduleManifest = new ModuleManifest
{
ModuleName = assembly,
ModuleVersion = new Version("0.0.0.0")
};
var updateManifest = new ModuleManifest
{
ModuleName = assembly,
ModuleVersion = new Version("0.0.0.1")
};
ModuleDiscovery.Setup(x => x.GetModules()).Returns(new List <ModuleInfo>
{
moduleInfo
});
// FIXME: this should use internal manifest factory
ModuleManifestFactory.Setup(x => x.GetManifest(It.Is <ModuleInfo>(y => y == moduleInfo)))
.Returns(moduleManifest);
EventAggregator.Setup(x => x.Publish(It.IsAny <NomadAvailableUpdatesMessage>()))
.Callback <NomadAvailableUpdatesMessage>(msg =>
{
Assert.AreEqual(1,
msg.AvailableUpdates.
Count);
Assert.AreEqual(updateManifest,
msg.AvailableUpdates.
First());
})
.Returns(null)
.Verifiable("Message was not published");
ModulesRepository
.Setup(x => x.GetAvailableModules())
.Returns(new AvailableModules
{
Manifests = new List <ModuleManifest> {
updateManifest
}
})
.Verifiable("Get Avaliable modules has not been called");
NomadUpdater.CheckUpdates();
ModulesRepository.Verify();
EventAggregator.Verify();
}
public void module_repository_throws_exception_while_preparing_updates_changed_to_message()
{
ModulesRepository.Setup(x => x.GetModule(It.IsAny <string>()))
.Throws(new Exception("Module Cannot be selected"));
EventAggregator.Setup(x => x.Publish(It.IsAny <NomadUpdatesReadyMessage>()))
.Callback <NomadUpdatesReadyMessage>(msg => Assert.IsTrue(msg.Error))
.Returns(null)
.Verifiable("The message should be published");
NomadUpdater.PrepareUpdate(new List <ModuleManifest>()
{
_moduleManifest
});
EventAggregator.Verify();
Assert.AreEqual(UpdaterStatus.Invalid, NomadUpdater.Status);
}
public void publishes_error_message_when_checking_for_updates_failed()
{
ModulesRepository.Setup(x => x.GetAvailableModules())
.Throws(new Exception("Can not have these modules"));
EventAggregator.Setup(x => x.Publish(It.IsAny <NomadAvailableUpdatesMessage>()))
.Callback <NomadAvailableUpdatesMessage>(
(msg) =>
{
Assert.IsTrue(msg.Error);
Assert.AreEqual(0, msg.AvailableUpdates.Count);
})
.Returns(null)
.Verifiable("Message was not published");
Assert.DoesNotThrow(() => NomadUpdater.CheckUpdates());
EventAggregator.Verify();
}
public void performing_updates_has_information_about_failure_packager_throws()
{
ModulePackager.Setup(
x => x.PerformUpdates(It.IsAny <String>(), It.IsAny <ModulePackage>()))
.Throws(new Exception("Can not pacakge this"));
var manifest = new ModuleManifest()
{
ModuleName = "AlaMaKota"
};
var moduleManifests = new List <ModuleManifest>
{
manifest,
};
ModulesRepository.Setup(x => x.GetModule(It.IsAny <string>()))
.Returns(new ModulePackage()
{
ModuleManifest = manifest
});
// preapre stub module manifest
NomadUpdater.PrepareUpdate(moduleManifests);
ModulesRepository.Setup(x => x.GetModule(It.IsAny <string>()))
.Returns(new ModulePackage()
{
ModuleManifest = moduleManifests[0]
});
NomadUpdater.PerformUpdates(new CompositeModuleDiscovery());
// wait till end to get the information about failure
NomadUpdater.UpdateFinished.WaitOne();
Assert.AreEqual(UpdaterStatus.Invalid, NomadUpdater.Status);
}
public void packages_gotten_from_repository_have_nulls()
{
EventAggregator.Setup(x => x.Publish(It.IsAny <NomadUpdatesReadyMessage>()))
.Callback <NomadUpdatesReadyMessage>(msg => Assert.IsTrue(msg.Error))
.Returns(null)
.Verifiable("The message should be published");
var modulePackages = new List <ModuleManifest>
{
new ModuleManifest()
{
ModuleName = "Test"
},
};
// provide wrong packages in repository
ModulesRepository.Setup(x => x.GetModule(It.IsAny <string>())).Returns(
new ModulePackage());
NomadUpdater.PrepareUpdate(modulePackages);
EventAggregator.Verify();
Assert.AreEqual(UpdaterStatus.Invalid, NomadUpdater.Status);
}
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);
}
