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());
}
