private IRepository CreateRepository(ISession session) { var unitOfWork = new DefaultUnitOfWork(session); var repository = new DefaultRepository(unitOfWork); return(repository); }
public void Should_Delete_Page_Content() { RunActionInTransaction(session => { // Create content var content = TestDataProvider.CreateNewHtmlContent(); var pageContent = TestDataProvider.CreateNewPageContent(content); session.SaveOrUpdate(pageContent); session.Flush(); session.Clear(); // Delete page content var request = new DeletePageContentCommandRequest { PageContentId = pageContent.Id, PageContentVersion = pageContent.Version, ContentVersion = content.Version }; var unitOfWork = new DefaultUnitOfWork(session); var command = new DeletePageContentCommand(); command.UnitOfWork = unitOfWork; command.Repository = new DefaultRepository(unitOfWork); var result = command.Execute(request); Assert.IsTrue(result); }); }
public void Should_Return_Widgets_List_Successfully() { RunActionInTransaction( session => { ServerControlWidget control1 = TestDataProvider.CreateNewServerControlWidget(); HtmlContentWidget control2 = TestDataProvider.CreateNewHtmlContentWidget(); control1.Id = Guid.NewGuid(); control1.Name = Guid.NewGuid().ToString().Replace("-", string.Empty); session.SaveOrUpdate(control1); session.SaveOrUpdate(control2); session.Flush(); var unitOfWork = new DefaultUnitOfWork(session); var repository = new DefaultRepository(unitOfWork); var categoryService = new Mock <ICategoryService>(); var cmsConfiguration = new Mock <ICmsConfiguration>().Object; var widgetService = new DefaultWidgetService(repository, unitOfWork, null, null, null, categoryService.Object, cmsConfiguration); var command = new GetSiteSettingsWidgetsCommand(widgetService); var response = command.Execute(new WidgetsFilter { SearchQuery = control1.Name.Substring(1, control1.Name.Length - 1) }); Assert.IsNotNull(response); Assert.IsNotNull(response.Items); Assert.GreaterOrEqual(response.Items.Count(), 1); var widget = response.Items.FirstOrDefault(w => control1.Id == w.Id); Assert.IsNotNull(widget); Assert.AreEqual(control1.Name, widget.WidgetName); }); }
public void Should_Save_Options_Successfully() { RunActionInTransaction(session => { var unitOfWork = new DefaultUnitOfWork(session); var repository = new DefaultRepository(unitOfWork); var cmsConfiguration = new Mock <ICmsConfiguration>(); var optionService = new DefaultOptionService(repository, new HttpRuntimeCacheService(), cmsConfiguration.Object); // Create layout with options var layout = TestDataProvider.CreateNewLayout(); layout.LayoutOptions = new List <LayoutOption>(); var option1 = TestDataProvider.CreateNewLayoutOption(layout); option1.Type = OptionType.Text; layout.LayoutOptions.Add(option1); var option2 = TestDataProvider.CreateNewLayoutOption(layout); option2.Type = OptionType.Text; layout.LayoutOptions.Add(option2); var option3 = TestDataProvider.CreateNewLayoutOption(layout); option3.Type = OptionType.Text; layout.LayoutOptions.Add(option3); session.SaveOrUpdate(layout); session.Flush(); session.Clear(); // Create fake options: // 1 should be kept // 2 should be updated // 3 should be inserted // option2 should be deleted var newOption1 = new LayoutOption { Key = option1.Key, Type = option1.Type, DefaultValue = option1.DefaultValue }; var newOption2 = new LayoutOption { Key = option2.Key, Type = option2.Type, DefaultValue = TestDataProvider.ProvideRandomString(100) }; var newOption3 = new LayoutOption { Key = TestDataProvider.ProvideRandomString(100), Type = OptionType.Text, DefaultValue = TestDataProvider.ProvideRandomString(100) }; var newOptions = new List <IOptionEntity> { newOption1, newOption2, newOption3 }; optionService.SetOptions <LayoutOption, Layout>(layout, newOptions); unitOfWork.Commit(); // Load all options var options = repository.AsQueryable <LayoutOption>(lo => lo.Layout == layout).ToList(); Assert.AreEqual(options.Count, 3); Assert.IsTrue(options.Any(o => o.Key == option1.Key && o.DefaultValue == option1.DefaultValue && o.Type == option1.Type)); Assert.IsTrue(options.Any(o => o.Key == option2.Key && o.DefaultValue == newOption2.DefaultValue && o.Type == option2.Type)); Assert.IsTrue(options.Any(o => o.Key == newOption3.Key && o.DefaultValue == newOption3.DefaultValue && o.Type == newOption3.Type)); }); }
public void Should_Create_UoW_With_SessionFactoryprovider_Successfully() { using (var unitOfWork = new DefaultUnitOfWork(Container.Resolve <ISessionFactoryProvider>())) { Assert.IsNotNull(unitOfWork.Session); } }
public void Should_ThrowValidationException_AboutNonDeletableOption() { RunActionInTransaction(session => { var unitOfWork = new DefaultUnitOfWork(session); var repository = new DefaultRepository(unitOfWork); var optionService = new DefaultOptionService(repository, new HttpRuntimeCacheService()); // Create layout with options var layout = TestDataProvider.CreateNewLayout(); layout.LayoutOptions = new List <LayoutOption>(); var option1 = TestDataProvider.CreateNewLayoutOption(layout); option1.Type = OptionType.Text; option1.IsDeletable = false; layout.LayoutOptions.Add(option1); session.SaveOrUpdate(layout); session.Flush(); session.Clear(); optionService.SetOptions <LayoutOption, Layout>(layout, new List <IOption>()); unitOfWork.Commit(); }); }
public void Should_Delete_Page_Content() { RunActionInTransaction(session => { // Create content var content = TestDataProvider.CreateNewHtmlContent(); var pageContent = TestDataProvider.CreateNewPageContent(content); session.SaveOrUpdate(pageContent); session.Flush(); session.Clear(); // Delete page content var request = new DeletePageContentCommandRequest { PageContentId = pageContent.Id, PageContentVersion = pageContent.Version, ContentVersion = content.Version }; var unitOfWork = new DefaultUnitOfWork(session); var repository = new DefaultRepository(unitOfWork); var securityService = new Mock <ISecurityService>().Object; var optionService = new Mock <IOptionService>().Object; var childContentService = new Mock <IChildContentService>().Object; var contentService = new DefaultContentService(securityService, repository, optionService, childContentService); var command = new DeletePageContentCommand(contentService); command.UnitOfWork = unitOfWork; command.Repository = repository; var result = command.Execute(request); Assert.IsTrue(result); }); }
public void Should_Delete_Media_With_Access_Rules() { RunActionInTransaction(session => { var uow = new DefaultUnitOfWork(session); var repository = new DefaultRepository(uow); var file = TestDataProvider.CreateNewMediaFileWithAccessRules(3); session.SaveOrUpdate(file); session.Flush(); session.Clear(); var command = new DeleteMediaCommand(); command.Repository = repository; command.UnitOfWork = uow; var result = command.Execute(new DeleteMediaCommandRequest { Id = file.Id, Version = file.Version }); Assert.IsTrue(result); session.Clear(); var deletedFile = session.Query <MediaFile>().FirstOrDefault(f => f.Id == file.Id && !f.IsDeleted); Assert.IsNull(deletedFile); }); }
public void Should_Delete_HtmlContentWidget_Successfully() { var htmlContentWidget = TestDataProvider.CreateNewHtmlContentWidget(); RunActionInTransaction(session => { session.SaveOrUpdate(htmlContentWidget); session.Flush(); session.Clear(); var uow = new DefaultUnitOfWork(session); var repository = new DefaultRepository(uow); var optionService = new Mock <IOptionService>().Object; var contentService = new Mock <IContentService>().Object; var widgetService = new DefaultWidgetService(repository, uow, optionService, contentService); DeleteWidgetCommand command = new DeleteWidgetCommand(widgetService); bool success = command.Execute(new DeleteWidgetRequest { WidgetId = htmlContentWidget.Id, Version = htmlContentWidget.Version }); Assert.IsTrue(success); }); }
public void Should_Create_Transaction_Successfuly() { using (var unitOfWork = new DefaultUnitOfWork(Container.Resolve <ISessionFactoryProvider>())) { Assert.IsFalse(unitOfWork.IsActiveTransaction); unitOfWork.BeginTransaction(); Assert.IsTrue(unitOfWork.IsActiveTransaction); } }
public void Should_Clone_Page_With_Tags_Options_Contents_AccessRules() { RunActionInTransaction(session => { const string url = "/test-link"; var uow = new DefaultUnitOfWork(session); var repository = new DefaultRepository(uow); var pageToClone = TestDataProvider.CreateNewPageWithTagsContentsOptionsAndAccessRules(session, 2, 2, 2, 2); session.SaveOrUpdate(pageToClone); session.Flush(); session.Clear(); var pageService = new Mock <IPageService>(); pageService.Setup(f => f.ValidatePageUrl(It.IsAny <string>(), It.IsAny <Guid?>())); pageService.Setup(f => f.CreatePagePermalink(It.IsAny <string>(), It.IsAny <string>())).Returns(url); var urlService = new Mock <IUrlService>(); urlService.Setup(f => f.FixUrl(It.IsAny <string>())).Returns(url); var rules = new List <IAccessRule>(); var rule1 = TestDataProvider.CreateNewAccessRule(); rules.Add(rule1); var rule2 = TestDataProvider.CreateNewAccessRule(); rules.Add(rule2); var command = new ClonePageCommand(); command.Repository = repository; command.UnitOfWork = uow; command.PageService = pageService.Object; command.UrlService = urlService.Object; command.AccessControlService = new Mock <IAccessControlService>().Object; command.Context = new Mock <ICommandContext>().Object; var result = command.Execute(new ClonePageViewModel { PageId = pageToClone.Id, PageTitle = "new cloned page", PageUrl = url, UserAccessList = pageToClone.AccessRules.Select(u => new UserAccessViewModel(u)).ToList() }); Assert.IsNotNull(result); session.Clear(); var actual = repository.AsQueryable <PageProperties>().Where(f => f.Id == result.PageId).ToList().FirstOrDefault(); Assert.IsNotNull(actual); Assert.AreEqual(2, actual.AccessRules.Count(), "AccessRules"); Assert.AreEqual(2, actual.PageTags.Count(), "Tags"); Assert.AreEqual(2, actual.PageContents.Count(), "Contents"); Assert.AreEqual(2, actual.Options.Count(), "Options"); }); }
public void Should_Return_Page_Content_Options_Successfully() { RunActionInTransaction(session => { var content = TestDataProvider.CreateNewContent(); var pageContent = TestDataProvider.CreateNewPageContent(content); FillContentWithOptions(content); FillPageContentWithOptions(content, pageContent); session.SaveOrUpdate(pageContent); session.Flush(); session.Clear(); // Create command var unitOfWork = new DefaultUnitOfWork(session); var command = new GetPageContentOptionsCommand(); var repository = new DefaultRepository(unitOfWork); command.UnitOfWork = unitOfWork; command.Repository = repository; command.CmsConfiguration = Container.Resolve <ICmsConfiguration>(); command.OptionService = new DefaultOptionService(repository, new HttpRuntimeCacheService(), command.CmsConfiguration); // Execute command var result = command.Execute(pageContent.Id); // Should return 4 options: 2 with assigned values, 1 without parent option and 1 unassigned Assert.IsNotNull(result); Assert.IsNotNull(result.OptionValues); Assert.AreEqual(result.OptionValues.Count, 5); Assert.IsNotNull(result.OptionValues.FirstOrDefault(o => o.OptionKey == content.ContentOptions[0].Key && o.OptionValue == pageContent.Options[0].Value && o.OptionDefaultValue == content.ContentOptions[0].DefaultValue && !o.UseDefaultValue && !o.CanEditOption)); Assert.IsNotNull(result.OptionValues.FirstOrDefault(o => o.OptionKey == content.ContentOptions[1].Key && o.OptionValue == pageContent.Options[1].Value && o.OptionDefaultValue == content.ContentOptions[1].DefaultValue && !o.UseDefaultValue && !o.CanEditOption)); Assert.IsNotNull(result.OptionValues.FirstOrDefault(o => o.OptionKey == content.ContentOptions[2].Key && o.OptionValue == content.ContentOptions[2].DefaultValue && o.OptionDefaultValue == content.ContentOptions[2].DefaultValue && o.UseDefaultValue && !o.CanEditOption)); Assert.IsNotNull(result.OptionValues.FirstOrDefault(o => o.OptionKey == pageContent.Options[2].Key && o.OptionValue == pageContent.Options[2].Value && o.OptionDefaultValue == null && o.CanEditOption)); Assert.IsNotNull(result.OptionValues.FirstOrDefault(o => o.OptionKey == pageContent.Options[3].Key && o.OptionValue == pageContent.Options[3].Value && o.OptionDefaultValue == null && o.CanEditOption)); }); }
public void Should_Throw_Exception_Creating_Multiple_Transactions() { Assert.Throws <DataException>(() => { using (var unitOfWork = new DefaultUnitOfWork(Container.Resolve <ISessionFactoryProvider>())) { unitOfWork.BeginTransaction(); unitOfWork.BeginTransaction(); } }); }
public void Sould_Delete_Page_Successfully() { RunActionInTransaction(session => { const string url = "/test-link/"; var uow = new DefaultUnitOfWork(session); var repository = new DefaultRepository(uow); var page = TestDataProvider.CreateNewPageWithTagsContentsOptionsAndAccessRules(session); session.SaveOrUpdate(page); session.Flush(); session.Clear(); var pageService = new Mock <IPageService>(); pageService.Setup(f => f.ValidatePageUrl(It.IsAny <string>(), It.IsAny <Guid?>())); pageService.Setup(f => f.CreatePagePermalink(It.IsAny <string>(), It.IsAny <string>())).Returns(url); var sitemapService = new Mock <ISitemapService>(); sitemapService .Setup(service => service.GetNodesByPage(It.IsAny <PageProperties>())) .Returns(() => new List <SitemapNode>()); var urlService = new Mock <IUrlService>(); urlService.Setup(f => f.FixUrl(It.IsAny <string>())).Returns((string a) => a); var securityService = new Mock <ICmsSecurityConfiguration>(); securityService.Setup(f => f.AccessControlEnabled).Returns(false); var configurationService = new Mock <ICmsConfiguration>(); configurationService.Setup(f => f.Security).Returns(securityService.Object); var command = new DeletePageCommand(null, sitemapService.Object, urlService.Object, configurationService.Object); command.Repository = repository; command.UnitOfWork = uow; var result = command.Execute(new DeletePageViewModel { PageId = page.Id, UpdateSitemap = false, RedirectUrl = null, SecurityWord = "DELETE", Version = page.Version }); Assert.IsTrue(result); session.Clear(); var actual = repository.AsQueryable <PageProperties>().FirstOrDefault(f => f.Id == page.Id && !f.IsDeleted); Assert.IsNull(actual); }); }
private CmsRoleProvider GetRoleProvider(ISession session, IRepository repository = null, IUnitOfWork unitOfWork = null) { if (repository == null || unitOfWork == null) { unitOfWork = new DefaultUnitOfWork(session); repository = new DefaultRepository(unitOfWork); } var roleService = new DefaultRoleService(repository); var roleProvider = new CmsRoleProvider(repository, unitOfWork, roleService); return(roleProvider); }
public void Disposes_transaction() { // Arrange var database = new Mock <IDbConnection>(); var transaction = new Mock <IDbTransaction>(); var sut = new DefaultUnitOfWork(database.Object, transaction.Object, PeregrineConfig.Postgres); // Act sut.Dispose(); // Assert transaction.Verify(t => t.Dispose()); }
public void Rollsback_transaction() { // Arrange var database = new Mock <IDatabase>(); var transaction = new Mock <IDbTransaction>(); var sut = new DefaultUnitOfWork(database.Object, transaction.Object); // Act sut.Dispose(); // Assert transaction.Verify(t => t.Rollback()); }
public void Should_Call_CreateRole_WithException_ExistingRole() { RunActionInTransaction(session => { // Create role var role = CreateFakeRoles(session, 1)[0]; var unitOfWork = new DefaultUnitOfWork(session); var repository = new DefaultRepository(unitOfWork); var roleProvider = GetRoleProvider(session, repository, unitOfWork); // Try create existing role roleProvider.CreateRole(role.Name); }); }
public void Disposes_of_database_and_transaction() { // Arrange var database = new Mock <IDatabase>(); var transaction = new Mock <IDbTransaction>(); var sut = new DefaultUnitOfWork(database.Object, transaction.Object); // Act sut.Dispose(); // Assert database.Verify(d => d.Dispose()); transaction.Verify(t => t.Dispose()); }
public void Disposes_transaction_but_not_database() { // Arrange var database = new Mock <IDbConnection>(); var transaction = new Mock <IDbTransaction>(); var sut = new DefaultUnitOfWork(database.Object, transaction.Object, PeregrineConfig.Postgres, true); // Act sut.Dispose(); // Assert database.Verify(d => d.Dispose(), Times.Never); transaction.Verify(t => t.Dispose()); }
protected virtual void Handle(ICommandMessage command, IMessageHandler <ICommandMessage> handler, ICommandCallback callback) { _logger.LogDebug($"Handling command [{command.CommandName}]"); try { var unitOfWork = DefaultUnitOfWork.StartAndGet(command); // no need to attach transaction - ambient var chain = new DefaultInterceptorChain(unitOfWork, _handlerInterceptors.Keys.GetEnumerator(), handler); var result = unitOfWork.ExecuteWithResult(chain.Proceed, RollbackConfiguration); callback.OnSuccess(command, result); // todo: double check R cast } catch (Exception e) { callback.OnFailure(command, e); } }
public void Does_not_dispose_twice() { // Arrange var database = new Mock <IDbConnection>(); var transaction = new Mock <IDbTransaction>(); var sut = new DefaultUnitOfWork(database.Object, transaction.Object, PeregrineConfig.Postgres); // Act sut.Dispose(); sut.Dispose(); // Assert database.Verify(d => d.Dispose(), Times.Once); transaction.Verify(t => t.Dispose(), Times.Once); }
public void Should_Call_CreateRole_Successfully() { RunActionInTransaction(session => { var unitOfWork = new DefaultUnitOfWork(session); var repository = new DefaultRepository(unitOfWork); var roleProvider = GetRoleProvider(session, repository, unitOfWork); var roleName = TestDataProvider.ProvideRandomString(MaxLength.Name); roleProvider.CreateRole(roleName); var roles = repository.AsQueryable <Role>(role => role.Name == roleName).ToList(); Assert.NotNull(roles); Assert.AreEqual(roles.Count, 1); Assert.AreEqual(roles[0].Name, roleName); }); }
public void Does_not_rollback_twice() { // Arrange var database = new Mock <IDatabase>(); var transaction = new Mock <IDbTransaction>(); var sut = new DefaultUnitOfWork(database.Object, transaction.Object); sut.Rollback(); // Act sut.Dispose(); // Assert transaction.Verify(t => t.Rollback(), Times.Once); database.Verify(d => d.Dispose()); transaction.Verify(t => t.Dispose()); }
public void Does_not_rollback_a_saved_unit_of_work() { // Arrange var database = new Mock <IDbConnection>(); var transaction = new Mock <IDbTransaction>(); var sut = new DefaultUnitOfWork(database.Object, transaction.Object, PeregrineConfig.Postgres); sut.SaveChanges(); // Act sut.Dispose(); // Assert transaction.Verify(t => t.Rollback(), Times.Never); database.Verify(d => d.Dispose()); transaction.Verify(t => t.Dispose()); }
public void Disposes_database_even_if_exception_occurs_during_disposing_transaction() { // Arrange var database = new Mock <IDbConnection>(); var transaction = new Mock <IDbTransaction>(); transaction.Setup(t => t.Dispose()).Throws <CustomException>(); var sut = new DefaultUnitOfWork(database.Object, transaction.Object, PeregrineConfig.Postgres); // Act Action act = () => sut.Dispose(); // Assert act.Should().Throw <CustomException>(); database.Verify(d => d.Dispose()); transaction.Verify(t => t.Dispose()); }
public void Should_Call_RemoveUsersFromRoles_Successfully() { RunActionInTransaction(session => { var fakeRoles = CreateFakeRoles(session, 3); var fakeUsers = CreateFakeUsers(session, fakeRoles, 3); var unitOfWork = new DefaultUnitOfWork(session); var repository = new DefaultRepository(unitOfWork); var roleProvider = GetRoleProvider(session, repository, unitOfWork); // Pass filtered user names and filtered roleNames var userNames = new[] { fakeUsers[0].UserName, fakeUsers[1].UserName }; var roleNames = new[] { fakeRoles[0].Name, fakeRoles[1].Name }; roleProvider.RemoveUsersFromRoles(userNames, roleNames); roleNames = fakeRoles.Select(role => role.Name).ToArray(); userNames = fakeUsers.Select(user => user.UserName).ToArray(); var userRoles = repository .AsQueryable <UserRole>(userRole => userNames.Contains(userRole.User.UserName) || roleNames.Contains(userRole.Role.Name)) .Select(userRole => new { UserName = userRole.User.UserName, RoleName = userRole.Role.Name }) .ToList(); Assert.NotNull(userRoles); // Should be left pairs: // 0 user -> 2 role // 1 user -> 2 role // 2 user -> 0 role // 2 user -> 1 role // 2 user -> 2 role Assert.AreEqual(userRoles.Count, 5); Assert.IsTrue(userRoles.Any(ur => ur.UserName == fakeUsers[0].UserName && ur.RoleName == fakeRoles[2].Name)); Assert.IsTrue(userRoles.Any(ur => ur.UserName == fakeUsers[1].UserName && ur.RoleName == fakeRoles[2].Name)); Assert.IsTrue(userRoles.Any(ur => ur.UserName == fakeUsers[2].UserName && ur.RoleName == fakeRoles[0].Name)); Assert.IsTrue(userRoles.Any(ur => ur.UserName == fakeUsers[2].UserName && ur.RoleName == fakeRoles[1].Name)); Assert.IsTrue(userRoles.Any(ur => ur.UserName == fakeUsers[2].UserName && ur.RoleName == fakeRoles[2].Name)); }); }
public void Should_Return_Empty_List() { RunActionInTransaction( session => { var unitOfWork = new DefaultUnitOfWork(session); var repository = new DefaultRepository(unitOfWork); var widgetService = new DefaultWidgetService(repository, unitOfWork, null, null, null); var command = new GetSiteSettingsWidgetsCommand(widgetService); var response = command.Execute(new WidgetsFilter { SearchQuery = Guid.NewGuid().ToString() }); Assert.IsNotNull(response); Assert.IsNotNull(response.Items); Assert.IsEmpty(response.Items); }); }
public void ShouldRetrieveMasterPageOptionsSuccessfully() { RunActionInTransaction(session => { var unitOfWork = new DefaultUnitOfWork(session); var repository = new DefaultRepository(unitOfWork); var pages = CreateNestedOptions(session, 1); var optionService = new DefaultOptionService(repository, new HttpRuntimeCacheService()); var optionValues = optionService.GetMergedMasterPagesOptionValues(pages[0].Id, null, pages[0].Layout.Id); Assert.AreEqual(optionValues.Count, 4); Assert.IsTrue(optionValues.Any(o => o.OptionKey == "l1" && o.OptionValue == "l1")); Assert.IsTrue(optionValues.Any(o => o.OptionKey == "l2" && o.OptionValue == "l2")); Assert.IsTrue(optionValues.Any(o => o.OptionKey == "l3" && o.OptionValue == "l3p1")); Assert.IsTrue(optionValues.Any(o => o.OptionKey == "p1" && o.OptionValue == "p1")); }); }
public void Disposes_database_and_transaction_even_if_exception_occurs_during_rollback() { // Arrange var database = new Mock <IDatabase>(); var transaction = new Mock <IDbTransaction>(); transaction.Setup(t => t.Rollback()) .Throws <CustomException>(); var sut = new DefaultUnitOfWork(database.Object, transaction.Object); // Act Action act = () => sut.Dispose(); // Assert act.ShouldThrow <CustomException>(); database.Verify(d => d.Dispose()); transaction.Verify(t => t.Dispose()); }