public List <ModuleUserControl> GetMenuModules(int menuId, int parentId = 0)
{
var controls = new List <ModuleUserControl>();
using (var session = new DataSession())
{
var modulesRepo = new ModulesRepository(session.UnitOfWork);
var modules = modulesRepo.GetMenuModules(menuId);
int index = 0;
foreach (var module in modules)
{
int moduleParentId = 0;
int.TryParse(Convert.ToString(module.ParentId), out moduleParentId);
if (moduleParentId != parentId)
{
continue;
}
var control = GetControlFromModuleData(module);
control.ID = control.GetType().Name + "_index";
if (control != null)
{
controls.Add(control);
}
}
}
return(controls);
}
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));
}
protected void Page_PreRender(object sender, EventArgs e)
{
var modules = AttachedModules.GetModules <ISendMails>();
var modulesAny = false;
foreach (var moduleType in modules)
{
var moduleObject = (ISendMails)Activator.CreateInstance(moduleType, null);
if (ModulesRepository.IsActiveModule(moduleObject.ModuleStringId))
{
modulesAny = true;
}
}
if (!modulesAny)
{
lblMessage.Text = Resource.Admin_m_News_SendMailOff;
lblMessage.ForeColor = System.Drawing.Color.Red;
divMessage.Visible = true;
divSend.Visible = false;
}
else if (!IsPostBack)
{
divMessage.Visible = false;
divSend.Visible = true;
}
}
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);
}
protected void Page_Load(object sender, EventArgs e)
{
var ocModule = AttachedModules.GetModules <IOrderConfirmation>().FirstOrDefault();
IOrderConfirmation classInstance;
if (ocModule != null)
{
classInstance = (IOrderConfirmation)Activator.CreateInstance(ocModule, null);
if (!ModulesRepository.IsActiveModule(classInstance.ModuleStringId) || !classInstance.CheckAlive())
{
Response.Redirect("~/orderconfirmation.aspx");
return;
}
}
else
{
Response.Redirect("~/orderconfirmation.aspx");
return;
}
SetMeta(new MetaInfo(string.Format("{0} - {1}", classInstance.PageName, SettingsMain.ShopName)),
string.Empty);
liPageHead.Text = classInstance.PageName;
Control c =
(this).LoadControl(
UrlService.GetAbsoluteLink(string.Format("/Modules/{0}/{1}", classInstance.ModuleStringId,
classInstance.FileUserControlOrderConfirmation)));
if (c != null)
{
pnlContent.Controls.Add(c);
}
}
public LmPlatformRepositoriesContainer()
{
UsersRepository = new UsersRepository(_dataContext);
BugsRepository = new BugsRepository(_dataContext);
BugLogsRepository = new BugLogsRepository(_dataContext);
GroupsRepository = new GroupsRepository(_dataContext);
ProjectsRepository = new ProjectsRepository(_dataContext);
ProjectUsersRepository = new ProjectUsersRepository(_dataContext);
ProjectCommentsRepository = new ProjectCommentsRepository(_dataContext);
StudentsRepository = new StudentsRepository(_dataContext);
SubjectRepository = new SubjectRepository(_dataContext);
TestsRepository = new TestsRepository(_dataContext);
TestUnlocksRepository = new TestUnlockRepository(_dataContext);
QuestionsRepository = new QuestionsRepository(_dataContext);
UsersRepository = new UsersRepository(_dataContext);
ModulesRepository = new ModulesRepository(_dataContext);
LecturerRepository = new LecturerRepository(_dataContext);
MessageRepository = new MessageRepository(_dataContext);
MaterialsRepository = new MaterialsRepository(_dataContext);
FoldersRepository = new FoldersRepository(_dataContext);
SubGroupRepository = new SubGroupRepository(_dataContext);
AttachmentRepository = new AttachmentRepository(_dataContext);
LecturesRepository = new LecturesRepository(_dataContext);
LabsRepository = new LabsRepository(_dataContext);
ProjectUsersRepository = new ProjectUsersRepository(_dataContext);
PracticalRepository = new PracticalRepository(_dataContext);
ConceptRepository = new ConceptRepository(_dataContext);
WatchingTimeRepository = new WatchingTimeRepository(_dataContext);
TestQuestionPassResultsRepository = new TestQuestionPassResultsRepository(_dataContext);
//todo UNUSED ProjectMatrixRequirementsRepository = new ProjectMatrixRequirementsRepository(_dataContext);
}
private void SaveProductTabs(int productId)
{
foreach (var detailsTabsModule in AttachedModules.GetModules <IProductTabs>())
{
var classInstance = (IProductTabs)Activator.CreateInstance(detailsTabsModule, null);
if (ModulesRepository.IsActiveModule(classInstance.ModuleStringId) && classInstance.CheckAlive())
{
foreach (ListViewItem tabBody in lvTabBodies.Items)
{
var tabTitleId = 0;
var stringTabTitleId = ((HiddenField)tabBody.FindControl("hfTabTitleId")).Value;
var stringTabBody = ((TextBox)tabBody.FindControl("fckTabBody")).Text;
if (!int.TryParse(stringTabTitleId, out tabTitleId))
{
continue;
}
if (string.IsNullOrEmpty(stringTabBody))
{
classInstance.DeleteProductDetailsTab(productId, tabTitleId);
}
else if (!string.IsNullOrEmpty(stringTabTitleId))
{
classInstance.SaveProductDetailsTab(productId, tabTitleId, stringTabBody);
}
}
}
}
}
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 int AddModule(int menuId, ModuleType type, int parentId = 0)
{
int newId;
var module = new Domain.Modules()
{
MenuId = menuId,
ModuleType = (int)type,
Position = GetNextPosition(menuId, parentId),
CreatedAt = DateTime.Now,
CreatedById = Authentication.Instance.GetUserId()
};
if (parentId > 0)
{
module.ParentId = parentId;
}
using (var session = new DataSession())
{
var modulesRepo = new ModulesRepository(session.UnitOfWork);
newId = modulesRepo.Save(module);
}
return(newId);
}
protected void Page_Load(object sender, EventArgs e)
{
if (Request["module"].IsNullOrEmpty())
{
Response.Redirect(UrlService.GetAdminAbsoluteLink(""));
}
var module = AttachedModules.GetModules().FirstOrDefault(
item => ((IModule)Activator.CreateInstance(item, null)).ModuleStringId == Request["module"]);
if (module == null)
{
Response.Redirect(UrlService.GetAdminAbsoluteLink(""));
}
ckbActiveModule.Attributes.Add("data-modulestringid", Request["module"]);
ckbActiveModule.Checked = ModulesRepository.IsActiveModule(Request["module"]);
lblIsActive.Text = ckbActiveModule.Checked
? Resources.Resource.Admin_Module_Active
: Resources.Resource.Admin_Module_NotActive;
lblIsActive.ForeColor = ckbActiveModule.Checked
? System.Drawing.Color.Green
: System.Drawing.Color.Red;
var moduleObject = (IModule)Activator.CreateInstance(module, null);
lblHead.Text = moduleObject.ModuleName;
if (moduleObject.ModuleControls != null)
{
rptTabs.DataSource = moduleObject.ModuleControls;
rptTabs.DataBind();
int currentControlIndex = CurrentControlIndex;
if (currentControlIndex < 0 || currentControlIndex > (moduleObject.ModuleControls.Count - 1))
{
currentControlIndex = 0;
}
if (moduleObject.ModuleControls != null && moduleObject.ModuleControls.Any())
{
Control c =
(this).LoadControl(
UrlService.GetAbsoluteLink(string.Format("/Modules/{0}/{1}", moduleObject.ModuleStringId,
moduleObject.ModuleControls[currentControlIndex]
.File)));
if (c != null)
{
pnlBody.Controls.Add(c);
}
SetMeta(string.Format("{0} - {1} - {2}", SettingsMain.ShopName, moduleObject.ModuleName, moduleObject.ModuleControls[currentControlIndex].NameTab));
}
}
else
{
lblInfo.Text = Resources.Resource.Admin_Module_NotConfigure;
}
}
//private ConfigOptions _options;
public InitialiseWorkflowData(IHostingEnvironment env, TriggerRepository context,
ModulesRepository module, WFStateRepository wfstate, MessageTemplateRepository message)
{
_context = context;;
_env = env;
_module = module;
_wfstate = wfstate;
_message = message;
}
public UnitOfWork(ApiContext context)
{
_context = context;
Users = new UsersRepository(_context);
Assigments = new AssigmentsRepository(_context);
Modules = new ModulesRepository(_context);
ModuleContents = new ModuleContentsRepository(_context);
Videos = new VideosRepository(_context);
}
public RolesService(RolesRepository repo,
RolesModulesMappingsRepository mappingRepo,
ModulesRepository moduleRepo,
SystemViewsRepository viewsRepository)
{
rolesRepository = repo;
this.mappingRepo = mappingRepo;
this.moduleRepo = moduleRepo;
this.viewsRepository = viewsRepository;
}
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 static void SendNews(string txtTitle, string text)
{
foreach (var moduleType in AttachedModules.GetModules <ISendMails>())
{
var moduleObject = (ISendMails)Activator.CreateInstance(moduleType, null);
if (ModulesRepository.IsActiveModule(moduleObject.ModuleStringId))
{
moduleObject.SendMails(txtTitle, text, MailRecipientType.Subscriber);
}
}
}
public void Sanity()
{
ActiveRecordStarter.Initialize(typeof(Module).Assembly, ActiveRecordSectionHandler.Instance);
var factory = ActiveRecordMediator.GetSessionFactoryHolder().GetSessionFactory(typeof (ActiveRecordBase));
var repo = new ModulesRepository {SessionFactory = factory};
var session = factory.OpenSession();
NHibernate.Context.CurrentSessionContext.Bind(session);
repo.AllFor(2009, 1, Guid.NewGuid());
}
private int GetNextPosition(int menuId, int parentId)
{
int position = 100;
using (var session = new DataSession())
{
var modulesRepo = new ModulesRepository(session.UnitOfWork);
position = modulesRepo.GetNextPosition(menuId, parentId);
}
return(position);
}
private int GetMenuIdFromModuleId(int parentId)
{
int menuId = 0;
using (var session = new DataSession())
{
var modulesRepo = new ModulesRepository(session.UnitOfWork);
menuId = modulesRepo.GetMenuIdFromModuleId(parentId);
}
return(menuId);
}
public void DeleteModule(int menuId, int moduleId)
{
using (var session = new DataSession())
{
var modulesRepo = new ModulesRepository(session.UnitOfWork);
var module = modulesRepo.GetSingle(moduleId);
if (module.MenuId == menuId)
{
modulesRepo.Delete(module);
}
}
}
public async Task GetModulesTest()
{
// IModulesRepository moduleRepository = GetModulesRepository();
var mockRepo = new Mock <IModulesRepository>();
mockRepo.Setup(x => x.GetModules());
var companyObject = new ModulesRepository(new BusinessRulesDataEngineContext());
var retrnData = companyObject.GetModules();
//var mockedCtxVolunteer = new Mock<IModulesRepository>();
//mockedCtxVolunteer.Setup(m => m.GetModules());
//var result = await moduleRepository.GetModules();
Assert.True(Convert.ToInt32(retrnData) > 0, "The Data Populated Successfully !!");
}
public UnitOfWork(AladonContext context)
{
Context = context;
Users = new UsersRepository(context);
Roles = new RolesRepository(context);
UserRoles = new UserRolesRepository(context);
Permissions = new PermissionsRepository(context);
Modules = new ModulesRepository(context);
LocationTypes = new LocationTypesRepository(context);
AssetStructures = new AssetStructureRepository(context);
AssetPartInfors = new AssetPartInforRepository(context);
AssetTypes = new AssetTypeRepository(context);
Documents = new DocumentRepository(context);
Parts = new PartRepository(context);
AssetTags = new AssetTagRepository(context);
}
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);
}
protected void btnSend_Click(object sender, EventArgs e)
{
if (!IsValidData())
{
return;
}
var isSend = false;
var modules = AttachedModules.GetModules <ISendMails>().ToArray();
var recipientType = MailRecipientType.None;
if (ckbSubscribers.Checked)
{
recipientType |= MailRecipientType.Subscriber;
}
if (ckbOrderedCustomers.Checked)
{
recipientType |= MailRecipientType.OrderCustomer;
}
foreach (var moduleType in modules)
{
var moduleObject = (ISendMails)Activator.CreateInstance(moduleType, null);
if (ModulesRepository.IsActiveModule(moduleObject.ModuleStringId))
{
isSend |= moduleObject.SendMails(txtTitle.Text, fckMailContent.Text, recipientType);
}
}
if (isSend)
{
lblMessage.Text = Resource.Admin_m_News_MessageIsSend;
lblMessage.ForeColor = System.Drawing.Color.Blue;
}
else
{
lblMessage.Text = Resource.Admin_m_News_MessageIsSend;
lblMessage.ForeColor = System.Drawing.Color.Red;
}
divMessage.Visible = true;
divSend.Visible = false;
}
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();
}
protected void Page_PreRender(object sender, EventArgs e)
{
var brand = popUpBrand.SelectBrandId != 0 ? BrandService.GetBrandById(popUpBrand.SelectBrandId) : null;
lBrand.Text = brand != null ? brand.Name : Resource.Admin_Product_NotSelected;
ibRemoveBrand.Visible = popUpBrand.SelectBrandId != 0;
if (!AddingNewProduct)
{
aToClient.HRef = "../" + UrlService.GetLinkDB(ParamType.Product, ProductId);
aToClient.Visible = true;
}
else
{
aToClient.Visible = false;
}
if (ProductId != 0)
{
var listDetailsTabs = new List <ITab>();
foreach (var detailsTabsModule in AttachedModules.GetModules <IProductTabs>())
{
var classInstance = (IProductTabs)Activator.CreateInstance(detailsTabsModule, null);
if (ModulesRepository.IsActiveModule(classInstance.ModuleStringId) && classInstance.CheckAlive())
{
listDetailsTabs.AddRange(classInstance.GetProductTabsCollection(ProductId));
}
}
lvTabBodies.DataSource = listDetailsTabs;
lvTabTitles.DataSource = listDetailsTabs;
lvTabBodies.DataBind();
lvTabTitles.DataBind();
}
}
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 CanRegister()
{
ActiveRecordStarter.Initialize(typeof(Module).Assembly, ActiveRecordSectionHandler.Instance);
var factory = ActiveRecordMediator.GetSessionFactoryHolder().GetSessionFactory(typeof(ActiveRecordBase));
var repo = new ModulesRepository { SessionFactory = factory };
var session = factory.OpenSession();
NHibernate.Context.CurrentSessionContext.Bind(session);
var person = session.CreateQuery("from Person").SetMaxResults(1).UniqueResult<Person>();
Console.WriteLine(person.Id);
var moduleAvailability = session.CreateQuery("from ModuleAvailability ma").SetMaxResults(1).UniqueResult<ModuleAvailability>();
var reg = new ModuleRegistration(person, moduleAvailability);
repo.SaveRegistraion(reg);
session.Flush();
session.Clear();
Console.WriteLine(reg.ToString());
var r = session.CreateQuery("from ModuleRegistration r where r.Student = :student")
.SetEntity("student", person)
.UniqueResult<ModuleRegistration>();
Console.WriteLine(r.ToString());
}
protected void Page_Load(object sender, EventArgs e)
{
SetMeta(string.Format("{0} - {1}", SettingsMain.ShopName, Resource.Admin_NewsAdmin_Header));
if (!IsPostBack)
{
_paging = new SqlPaging
{
TableName = "[Settings].[News]",
ItemsPerPage = 20
};
_paging.AddFieldsRange(new List <Field>
{
new Field
{
Name = "NewsID as ID",
IsDistinct = true
},
new Field {
Name = "Title"
},
new Field {
Name = "ShowOnMainPage"
},
new Field {
Name = "NewsCategoryID"
},
new Field {
Name = "AddingDate", Sorting = SortDirection.Descending
}
});
grid.ChangeHeaderImageUrl("arrowAddingDate", "images/arrowdown.gif");
pageNumberer.CurrentPageIndex = 1;
_paging.CurrentPageIndex = 1;
ViewState["Paging"] = _paging;
}
else
{
_paging = (SqlPaging)(ViewState["Paging"]);
_paging.ItemsPerPage = SQLDataHelper.GetInt(ddRowsPerPage.SelectedValue);
if (_paging == null)
{
throw (new Exception("Paging lost"));
}
string strIds = Request.Form["SelectedIds"];
if (!string.IsNullOrEmpty(strIds))
{
strIds = strIds.Trim();
string[] arrids = strIds.Split(' ');
_selectionFilter = new InSetFieldFilter();
if (arrids.Contains("-1"))
{
_selectionFilter.IncludeValues = false;
_inverseSelection = true;
}
else
{
_selectionFilter.IncludeValues = true;
}
_selectionFilter.Values = arrids.Where(id => id != "-1").ToArray();
}
}
var modules = AttachedModules.GetModules <ISendMails>();
foreach (var moduleType in modules)
{
var moduleObject = (ISendMails)Activator.CreateInstance(moduleType, null);
if (ModulesRepository.IsActiveModule(moduleObject.ModuleStringId))
{
CanSendNews = true;
}
}
}
public ModulesService(ModulesRepository repository)
{
_repository = repository;
}
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);
}
public ModulesController([FromServices] DataContext dbContext)
{
_rep = new ModulesRepository(dbContext);
}
