public async Task UpdateGroup_ShouldThrow_WhenCyclicDependencyDetected()
{
// arrange
var cancellationToken = new CancellationToken();
var unitOfWorkFactory = new TransactionScopeUnitOfWorkFactory();
var dbContextFactory = new DefaultDbContextFactory();
var generator = new MasterDataDbGenerator(unitOfWorkFactory, dbContextFactory);
using (var _ = unitOfWorkFactory.Create())
{
// act & assert
await generator.InsertType(HierarchyType.Groups, cancellationToken);
var root = await generator.FindTree(ClassifierTree.DefaultCode, cancellationToken);
await generator.InsertGroups(root.Uid, 3, 3, null, null, cancellationToken);
await AssertClosureEqual("../../../Content/closure.3x3.txt", generator.PrintClosure(root.Code), cancellationToken);
// act & assert - cyclic dependency
var result = await generator.UpdateGroup(root.Code, "1.1", "1.1.1", cancellationToken, false);
Assert.IsNotNull(result);
Assert.IsFalse(result.Success);
Assert.IsNotNull(result.Errors);
Assert.AreEqual("parentUid", result.Errors[0].Key);
Assert.AreEqual("Cyclic dependency detected.", result.Errors[0].Messages[0]);
}
}
public async Task Handle_NormalValues_RegisterExternalUser()
{
// arrange
var cancellationToken = new CancellationToken();
var unitOfWorkFactory = new TransactionScopeUnitOfWorkFactory();
var dbContextFactory = new DefaultDbContextFactory();
var identityServiceFactory = new IdentityServiceFactory();
var classifierRepositoryFactoryBuilder = new ClassifierRepositoryFactoryBuilder(dbContextFactory)
{
UserTypeCode = ClassifierTypeCode.User
};
var classifierRepositoryFactory = classifierRepositoryFactoryBuilder.Build();
// todo: test EmailConfirmationService
var emailConfirmationServiceMock = new Mock <IEmailConfirmationService>();
var handler = new ExternalRegisterHandler(new NullLogger <ExternalRegisterHandler>(), classifierRepositoryFactory,
identityServiceFactory.UserManager, identityServiceFactory.SignInManager, emailConfirmationServiceMock.Object);
using (var _ = unitOfWorkFactory.Create())
{
// act
var command = new ExternalRegister
{
Email = "*****@*****.**"
};
var result = await handler.Handle(command, cancellationToken);
// assert
Assert.IsTrue(result.Success, string.Join(",", result.Message));
}
}
public async Task Run_DefaultConfig_ShouldBootstrapDatabase()
{
// arrange
var cancellationToken = new CancellationToken();
var loggerFactory = LoggerFactory.Create(
builder => builder.AddConsole(options => options.FormatterName = "systemd"));
var optionsMonitorMock = new Mock <IOptionsMonitor <MigrationOptions> >();
optionsMonitorMock.Setup(x => x.CurrentValue).Returns(() => new MigrationOptions
{
MigrationPath = "../../../../../database/migrations/"
});
var dbContextFactory = new DefaultDbContextFactory();
var resourceProvider = new EmbeddedResourceProvider();
var migrator = new DbMigrationRunner(
loggerFactory.CreateLogger <DbMigrationRunner>(),
optionsMonitorMock.Object,
dbContextFactory, resourceProvider);
// act
await migrator.Run(cancellationToken);
// assert
}
public async Task UpdateGroup_Should_RebuildClosureTable()
{
// arrange
var cancellationToken = new CancellationToken();
var unitOfWorkFactory = new TransactionScopeUnitOfWorkFactory();
var dbContextFactory = new DefaultDbContextFactory();
var generator = new MasterDataDbGenerator(unitOfWorkFactory, dbContextFactory);
using (var _ = unitOfWorkFactory.Create())
{
// act & assert
await generator.InsertType(HierarchyType.Groups, cancellationToken);
var root = await generator.FindTree(ClassifierTree.DefaultCode, cancellationToken);
await generator.InsertGroups(root.Uid, 3, 3, null, null, cancellationToken);
await AssertClosureEqual("../../../Content/closure.3x3.txt", generator.PrintClosure(root.Code), cancellationToken);
// act & assert - from null to not null parent
await generator.UpdateGroup(root.Code, "1", "2.1", cancellationToken);
await AssertClosureEqual("../../../Content/closure.3x3~1to2.1.txt", generator.PrintClosure(root.Code), cancellationToken);
// act & assert - from not null to null parent
await generator.UpdateGroup(root.Code, "2.2", null, cancellationToken);
await AssertClosureEqual("../../../Content/closure.3x3~1to2.1~2.2toRoot.txt", generator.PrintClosure(root.Code), cancellationToken);
// act & assert - from not null to not null parent
await generator.UpdateGroup(root.Code, "3.3", "1.3", cancellationToken);
await AssertClosureEqual("../../../Content/closure.3x3~1to2.1~2.2toRoot~3.3to1.3.txt", generator.PrintClosure(root.Code), cancellationToken);
}
}
public async Task GetClassifierTreeList_ReturnList()
{
// arrange
var cancellationToken = new CancellationToken();
var unitOfWorkFactory = new TransactionScopeUnitOfWorkFactory();
var dbContextFactory = new DefaultDbContextFactory();
var classifierTreeRepository = new DbClassifierTreeRepository(dbContextFactory);
var generator = new MasterDataDbGenerator(unitOfWorkFactory, dbContextFactory);
var handler = new GetClassifierTreeListHandler(classifierTreeRepository);
using (var _ = unitOfWorkFactory.Create())
{
// default tree will be insered for HierarchyType.Groups
await generator.InsertType(HierarchyType.Groups, cancellationToken);
// act
var result = await handler.Handle(new GetClassifierTreeList
{
TypeCode = generator.TypeCode
}, cancellationToken);
// assert
Assert.IsNotNull(result);
Assert.AreEqual(1, result.TotalCount);
}
}
public async Task Handle_NormalValues_RegisterUser()
{
// arrange
var cancellationToken = new CancellationToken();
var unitOfWorkFactory = new TransactionScopeUnitOfWorkFactory();
var dbContextFactory = new DefaultDbContextFactory();
var appOptionsAccessorMock = new Mock <IOptionsMonitor <AppOptions> >();
appOptionsAccessorMock.Setup(x => x.CurrentValue)
.Returns(() => new AppOptions {
AppUrl = "https://app.montr.net"
});
var appOptionsAccessor = appOptionsAccessorMock.Object;
var identityServiceFactory = new IdentityServiceFactory();
var classifierRepositoryFactoryBuilder = new ClassifierRepositoryFactoryBuilder(dbContextFactory)
{
UserTypeCode = ClassifierTypeCode.User
};
var classifierRepositoryFactory = classifierRepositoryFactoryBuilder.Build();
// todo: test EmailConfirmationService
/*
* var dbMessageTemplateRepository = new DbMessageTemplateRepository(dbContextFactory);
* var templateRenderer = new MustacheTemplateRenderer(dbMessageTemplateRepository);
* var emailConfirmationService = new EmailConfirmationService(userManager, appUrlBuilder, new Mock<IEmailSender>().Object, templateRenderer);
*/
var appUrlBuilder = new DefaultAppUrlBuilder(appOptionsAccessor);
var emailConfirmationServiceMock = new Mock <IEmailConfirmationService>();
var generator = new MasterDataDbGenerator(unitOfWorkFactory, dbContextFactory);
var handler = new RegisterHandler(new NullLogger <RegisterHandler>(), classifierRepositoryFactory,
identityServiceFactory.UserManager, identityServiceFactory.SignInManager, appUrlBuilder, emailConfirmationServiceMock.Object);
using (var _ = unitOfWorkFactory.Create())
{
await generator.EnsureClassifierTypeRegistered(Numerator.GetDefaultMetadata(), cancellationToken);
await generator.EnsureClassifierTypeRegistered(User.GetDefaultMetadata(), cancellationToken);
// act
var command = new Register
{
Email = "*****@*****.**",
Password = Guid.NewGuid().ToString()
};
var result = await handler.Handle(command, cancellationToken);
// assert
Assert.IsTrue(result.Success);
}
}
public async Task Handle_WithoutExistingLink_ShouldInsertNewLink()
{
// arrange
var cancellationToken = new CancellationToken();
var unitOfWorkFactory = new TransactionScopeUnitOfWorkFactory();
var dbContextFactory = new DefaultDbContextFactory();
var classifierTypeRepository = new DbClassifierTypeRepository(dbContextFactory);
var classifierTypeService = new DbClassifierTypeService(dbContextFactory, classifierTypeRepository);
var generator = new MasterDataDbGenerator(unitOfWorkFactory, dbContextFactory);
var handler = new InsertClassifierLinkHandler(unitOfWorkFactory, dbContextFactory, classifierTypeService);
using (var _ = unitOfWorkFactory.Create())
{
await generator.InsertType(HierarchyType.Groups, cancellationToken);
var root = await generator.FindTree(ClassifierTree.DefaultCode, cancellationToken);
var group1 = await generator.InsertGroup(root.Uid, "001", null, cancellationToken);
var root2 = await generator.InsertTree("root2", cancellationToken);
// ReSharper disable once PossibleInvalidOperationException
var group2 = await generator.InsertGroup(root2.Uid.Value, "002", null, cancellationToken);
var item1 = await generator.InsertItem("001", null, cancellationToken);
await generator.InsertLink(group1.Uid, item1.Uid, cancellationToken);
// assert - initially new items belongs to default group
var links = await generator.GetLinks(null, item1.Uid, cancellationToken);
Assert.AreEqual(1, links.TotalCount);
Assert.AreEqual(group1.Uid, links.Rows[0].Group.Uid);
Assert.AreEqual(item1.Uid, links.Rows[0].Item.Uid);
// act - link with new group in same hierarchy
var result = await handler.Handle(new InsertClassifierLink
{
UserUid = generator.UserUid,
TypeCode = generator.TypeCode,
// ReSharper disable once PossibleInvalidOperationException
GroupUid = group2.Uid.Value,
// ReSharper disable once PossibleInvalidOperationException
ItemUid = item1.Uid.Value
}, cancellationToken);
// assert - new link inserted
Assert.IsTrue(result.Success);
// assert - item linked to new group, link with default root still exists
links = await generator.GetLinks(null, item1.Uid, cancellationToken);
Assert.AreEqual(2, links.TotalCount);
var groups = links.Rows.Select(x => x.Group.Uid).ToList();
CollectionAssert.Contains(groups, group1.Uid);
CollectionAssert.Contains(groups, group2.Uid);
}
}
public async Task Handle_InSecondaryHierarchy_ShouldDeleteExistingLink()
{
// arrange
var cancellationToken = new CancellationToken();
var unitOfWorkFactory = new TransactionScopeUnitOfWorkFactory();
var dbContextFactory = new DefaultDbContextFactory();
var classifierTypeRepository = new DbClassifierTypeRepository(dbContextFactory);
var classifierTypeService = new DbClassifierTypeService(dbContextFactory, classifierTypeRepository);
var dbHelper = new MasterDataDbGenerator(unitOfWorkFactory, dbContextFactory);
var handler = new DeleteClassifierLinkHandler(unitOfWorkFactory, dbContextFactory, classifierTypeService);
using (var _ = unitOfWorkFactory.Create())
{
// arrange
await dbHelper.InsertType(HierarchyType.Groups, cancellationToken);
var root = await dbHelper.FindTree(ClassifierTree.DefaultCode, cancellationToken);
var root2 = await dbHelper.InsertTree("root2", cancellationToken);
// ReSharper disable once PossibleInvalidOperationException
var group2 = await dbHelper.InsertGroup(root2.Uid.Value, "002", null, cancellationToken);
var item1 = await dbHelper.InsertItem("001", null, cancellationToken);
await dbHelper.InsertLink(group2.Uid, item1.Uid, cancellationToken);
// assert - links to --default and-- secondary hierarchy exists
var links = await dbHelper.GetLinks(null, item1.Uid, cancellationToken);
Assert.AreEqual(1, links.TotalCount);
var groups = links.Rows.Select(x => x.Group.Uid).ToList();
// CollectionAssert.Contains(groups, root.Uid);
CollectionAssert.Contains(groups, group2.Uid);
// act
var result = await handler.Handle(new DeleteClassifierLink
{
UserUid = dbHelper.UserUid,
TypeCode = dbHelper.TypeCode,
// ReSharper disable once PossibleInvalidOperationException
GroupUid = group2.Uid.Value,
// ReSharper disable once PossibleInvalidOperationException
ItemUid = item1.Uid.Value
}, cancellationToken);
// assert - link deleted
Assert.IsTrue(result.Success);
// assert - NO link to default hierarchy exists
links = await dbHelper.GetLinks(null, item1.Uid, cancellationToken);
Assert.AreEqual(0, links.TotalCount);
// Assert.AreEqual(root.Uid, links.Rows[0].Group.Uid);
// Assert.AreEqual(item1.Uid, links.Rows[0].Item.Uid);
}
}
public async Task DeleteClassifier_NormalValues_DeleteItems()
{
// arrange
var cancellationToken = new CancellationToken();
var unitOfWorkFactory = new TransactionScopeUnitOfWorkFactory();
var dbContextFactory = new DefaultDbContextFactory();
var generator = new MasterDataDbGenerator(unitOfWorkFactory, dbContextFactory);
var classifierRepositoryFactory = CreateClassifierRepositoryFactory(dbContextFactory);
var handler = new DeleteClassifierHandler(unitOfWorkFactory, classifierRepositoryFactory);
using (var _ = unitOfWorkFactory.Create())
{
// arrange
await generator.InsertType(HierarchyType.None, cancellationToken);
var insertedIds = new List <Guid>();
for (var i = 0; i < 5; i++)
{
var insertItem = await generator.InsertItem("00" + i, null, cancellationToken);
// ReSharper disable once PossibleInvalidOperationException
insertedIds.Add(insertItem.Uid.Value);
}
var searchResult = await classifierRepositoryFactory.GetNamedOrDefaultService(generator.TypeCode)
.Search(new ClassifierSearchRequest {
TypeCode = generator.TypeCode
}, cancellationToken);
// assert
Assert.IsNotNull(searchResult);
Assert.AreEqual(insertedIds.Count, searchResult.Rows.Count);
// act
var command = new DeleteClassifier
{
UserUid = generator.UserUid,
TypeCode = generator.TypeCode,
Uids = insertedIds.ToArray()
};
var result = await handler.Handle(command, cancellationToken);
// assert
Assert.IsNotNull(result);
Assert.IsTrue(result.Success);
Assert.AreEqual(insertedIds.Count, result.AffectedRows);
searchResult = await classifierRepositoryFactory.GetNamedOrDefaultService(generator.TypeCode)
.Search(new ClassifierSearchRequest {
TypeCode = generator.TypeCode
}, cancellationToken);
// assert
Assert.IsNotNull(searchResult);
Assert.AreEqual(0, searchResult.Rows.Count);
}
}
public async Task Execute_Should_UpdateEntityStatus()
{
// arrange
var cancellationToken = CancellationToken.None;
var dbContextFactory = new DefaultDbContextFactory();
var unitOfWorkFactory = new TransactionScopeUnitOfWorkFactory();
var generator = new CoreDbGenerator(unitOfWorkFactory, dbContextFactory);
var handler = new UpdateEntityStatusHandler(unitOfWorkFactory, dbContextFactory);
using (var _ = unitOfWorkFactory.Create())
{
// arrange
var item1 = new EntityStatus {
Uid = Guid.NewGuid(), DisplayOrder = 1, Code = "drafted", Name = "Draft"
};
var item2 = new EntityStatus {
Uid = Guid.NewGuid(), DisplayOrder = 2, Code = "published", Name = "Published"
};
await generator.InsertEntityStatus(item1, cancellationToken);
await generator.InsertEntityStatus(item2, cancellationToken);
// act
var request = new UpdateEntityStatus
{
EntityTypeCode = generator.EntityTypeCode,
EntityUid = generator.EntityUid,
Item = new EntityStatus
{
Uid = item1.Uid,
Code = "draft",
Name = "The Draft",
DisplayOrder = 10
}
};
var result = await handler.Handle(request, cancellationToken);
// assert
Assert.IsNotNull(result);
Assert.AreEqual(1, result.AffectedRows);
var statuses = await generator.GetEntityStatuses(cancellationToken);
Assert.AreEqual(2, statuses.Rows.Count);
Assert.AreEqual(2, statuses.Rows[0].DisplayOrder);
Assert.AreEqual("published", statuses.Rows[0].Code);
Assert.AreEqual("Published", statuses.Rows[0].Name);
Assert.AreEqual(10, statuses.Rows[1].DisplayOrder);
Assert.AreEqual("draft", statuses.Rows[1].Code);
Assert.AreEqual("The Draft", statuses.Rows[1].Name);
}
}
public async Task ManageUserRoles_NormalValues_ReturnSuccess()
{
// arrange
var cancellationToken = new CancellationToken();
var unitOfWorkFactory = new TransactionScopeUnitOfWorkFactory();
var dbContextFactory = new DefaultDbContextFactory();
var identityServiceFactory = new IdentityServiceFactory();
var classifierRepositoryFactoryBuilder = new ClassifierRepositoryFactoryBuilder(dbContextFactory);
var classifierRepositoryFactory = classifierRepositoryFactoryBuilder.Build();
var roleRepository = classifierRepositoryFactory.GetNamedOrDefaultService(classifierRepositoryFactoryBuilder.RoleTypeCode);
var userRepository = classifierRepositoryFactory.GetNamedOrDefaultService(classifierRepositoryFactoryBuilder.UserTypeCode);
var generator = new MasterDataDbGenerator(unitOfWorkFactory, dbContextFactory);
var addHandler = new AddUserRolesHandler(new NullLogger <AddUserRolesHandler>(), unitOfWorkFactory, identityServiceFactory.UserManager);
var removeHandler = new RemoveUserRolesHandler(new NullLogger <RemoveUserRolesHandler>(), unitOfWorkFactory, identityServiceFactory.UserManager);
var roles = new[] { "test_role_1", "test_role_2", "test_role_3" };
using (var _ = unitOfWorkFactory.Create())
{
await generator.EnsureClassifierTypeRegistered(Role.GetDefaultMetadata(), cancellationToken);
await generator.EnsureClassifierTypeRegistered(User.GetDefaultMetadata(), cancellationToken);
// arrange
foreach (var name in roles)
{
var role = await roleRepository.Insert(new Role { Uid = Guid.NewGuid(), Name = name }, cancellationToken);
Assert.IsTrue(role.Success, string.Join(",", role.Errors.SelectMany(x => x.Messages)));
}
// var dbRoles = identityServiceFactory.RoleManager.Roles.ToList();
var user = await userRepository.Insert(new User { Uid = Guid.NewGuid(), UserName = "******" }, cancellationToken);
Assert.IsTrue(user.Success, string.Join(",", user.Errors.SelectMany(x => x.Messages)));
// ReSharper disable once PossibleInvalidOperationException
var userUid = user.Uid.Value;
// act - add roles
var addResult = await addHandler.Handle(new AddUserRoles { UserUid = userUid, Roles = roles }, cancellationToken);
Assert.IsTrue(addResult.Success, string.Join(",", user.Errors.SelectMany(x => x.Messages)));
// act - remove roles
var removeResult = await removeHandler.Handle(new RemoveUserRoles { UserUid = userUid, Roles = roles }, cancellationToken);
Assert.IsTrue(removeResult.Success, string.Join(",", user.Errors.SelectMany(x => x.Messages)));
}
}
public async Task Update_WithGetOptions_ShouldInsertAndUpdate()
{
// arrange
var cancellationToken = new CancellationToken();
var unitOfWorkFactory = new TransactionScopeUnitOfWorkFactory();
var dbContextFactory = new DefaultDbContextFactory();
var dateTimeProvider = new DefaultDateTimeProvider();
var mediatorMock = new Mock <IPublisher>();
var repository = new DbSettingsRepository(dbContextFactory, dateTimeProvider, mediatorMock.Object);
using (var _ = unitOfWorkFactory.Create())
{
// act (insert)
var options = repository.GetSettings <TestOptions>()
.Set(x => x.Number, 42)
.Set(x => x.Value, null)
.Set(x => x.State, AppState.Initialized);
var affected = await options.Update(cancellationToken);
// assert (insert)
Assert.AreEqual(3, affected);
var allSettings = await LoadSettings(dbContextFactory, cancellationToken);
var s1 = allSettings.SingleOrDefault(x => x.Id == "Montr.Core.Tests.Services.TestOptions:Number");
var s2 = allSettings.SingleOrDefault(x => x.Id == "Montr.Core.Tests.Services.TestOptions:Value");
var s3 = allSettings.SingleOrDefault(x => x.Id == "Montr.Core.Tests.Services.TestOptions:State");
Assert.IsNotNull(s1);
Assert.AreEqual("42", s1.Value);
Assert.IsNotNull(s2);
Assert.AreEqual(null, s2.Value);
Assert.IsNotNull(s3);
Assert.AreEqual("Initialized", s3.Value);
// act (update)
options = repository.GetSettings <TestOptions>()
.Set(x => x.State, AppState.None);
affected = await options.Update(cancellationToken);
// assert (update)
Assert.AreEqual(1, affected);
allSettings = await LoadSettings(dbContextFactory, cancellationToken);
s3 = allSettings.SingleOrDefault(x => x.Id == "Montr.Core.Tests.Services.TestOptions:State");
Assert.IsNotNull(s3);
Assert.AreEqual("None", s3.Value);
}
}
public async Task Handle_LastLinkInDefaultHierarchy_ShouldThrow()
{
// arrange
var cancellationToken = new CancellationToken();
var unitOfWorkFactory = new TransactionScopeUnitOfWorkFactory();
var dbContextFactory = new DefaultDbContextFactory();
var classifierTypeRepository = new DbClassifierTypeRepository(dbContextFactory);
var classifierTypeService = new DbClassifierTypeService(dbContextFactory, classifierTypeRepository);
var generator = new MasterDataDbGenerator(unitOfWorkFactory, dbContextFactory);
var handler = new DeleteClassifierLinkHandler(unitOfWorkFactory, dbContextFactory, classifierTypeService);
using (var _ = unitOfWorkFactory.Create())
{
// arrange
await generator.InsertType(HierarchyType.Groups, cancellationToken);
var root = await generator.FindTree(ClassifierTree.DefaultCode, cancellationToken);
var group1 = await generator.InsertGroup(root.Uid, "001", null, cancellationToken);
var item1 = await generator.InsertItem("001", null, cancellationToken);
await generator.InsertLink(group1.Uid, item1.Uid, cancellationToken);
// assert - links in default hierarchy exists
var links = await generator.GetLinks(null, item1.Uid, cancellationToken);
Assert.AreEqual(1, links.TotalCount);
Assert.AreEqual(group1.Uid, links.Rows[0].Group.Uid);
Assert.AreEqual(item1.Uid, links.Rows[0].Item.Uid);
// act
var result = await handler.Handle(new DeleteClassifierLink
{
UserUid = generator.UserUid,
TypeCode = generator.TypeCode,
// ReSharper disable once PossibleInvalidOperationException
GroupUid = group1.Uid.Value,
// ReSharper disable once PossibleInvalidOperationException
ItemUid = item1.Uid.Value
}, cancellationToken);
// assert - link not deleted
Assert.IsTrue(result.Success);
Assert.AreEqual(1, result.Errors.Count);
// assert - link to default hierarchy root exists
links = await generator.GetLinks(null, item1.Uid, cancellationToken);
Assert.AreEqual(1, links.TotalCount);
Assert.AreEqual(root.Uid, links.Rows[0].Group.Uid);
Assert.AreEqual(item1.Uid, links.Rows[0].Item.Uid);
}
}
/// <summary>
/// Initializes an instance of the <see cref="ServicesTestsCollectionFixture"/> class.
/// </summary>
public ServicesTestsCollectionFixture()
{
var dbContextFactory = new DefaultDbContextFactory();
IConfigurationRoot config = dbContextFactory.Configuration;
string connectionString = dbContextFactory.ConnectionString;
bool recreateDbOnStart = (bool?)config.GetValue(typeof(bool?), "RecreateDbOnStart") ?? false;
performDbSetup(dbContextFactory, recreateDbOnStart);
this.ConnectionString = connectionString;
}
public IConfigurationProvider Build(IConfigurationBuilder builder)
{
if (ReloadOnChange)
{
_reloadToken = new ConfigurationReloadToken();
}
// todo: resolve services
var dbContextFactory = new DefaultDbContextFactory();
return(new DbConfigurationProvider(this, dbContextFactory));
}
public async Task InsertClassifier_DuplicateCode_ReturnError()
{
// arrange
var cancellationToken = new CancellationToken();
var unitOfWorkFactory = new TransactionScopeUnitOfWorkFactory();
var dbContextFactory = new DefaultDbContextFactory();
var generator = new MasterDataDbGenerator(unitOfWorkFactory, dbContextFactory);
var classifierRepositoryFactory = CreateClassifierRepositoryFactory(dbContextFactory);
var handler = new InsertClassifierHandler(unitOfWorkFactory, classifierRepositoryFactory);
using (var _ = unitOfWorkFactory.Create())
{
// arrange - 1st item
await generator.InsertType(HierarchyType.None, cancellationToken);
var command = new InsertClassifier
{
UserUid = generator.UserUid,
Item = new Classifier
{
Type = generator.TypeCode,
Code = "001",
Name = "Test Classifier"
}
};
// act
var result = await handler.Handle(command, cancellationToken);
// assert
Assert.IsNotNull(result);
Assert.IsTrue(result.Success);
Assert.IsNotNull(result.Uid);
Assert.AreNotEqual(Guid.Empty, result.Uid);
// arrange - 2nd item
command.Item.Uid = Guid.NewGuid();
// act
result = await handler.Handle(command, cancellationToken);
// assert
Assert.IsNotNull(result);
Assert.IsFalse(result.Success);
Assert.IsNull(result.Uid);
Assert.AreEqual(1, result.Errors.Count);
Assert.AreEqual("code", result.Errors[0].Key);
// todo: use error codes?
Assert.AreEqual("Code «001» is already used in item \"Test Classifier\"", result.Errors[0].Messages[0]);
}
}
public async Task GetGroups_ForNotNullParent_ReturnItems()
{
// arrange
var cancellationToken = CancellationToken.None;
var unitOfWorkFactory = new TransactionScopeUnitOfWorkFactory();
var dbContextFactory = new DefaultDbContextFactory();
var classifierTypeRepository = new DbClassifierTypeRepository(dbContextFactory);
var classifierTreeRepository = new DbClassifierTreeRepository(dbContextFactory);
var classifierTypeService = new DbClassifierTypeService(dbContextFactory, classifierTypeRepository);
var classifierTreeService = new DefaultClassifierTreeService(classifierTreeRepository);
var generator = new MasterDataDbGenerator(unitOfWorkFactory, dbContextFactory);
var handler = new GetClassifierGroupListHandler(dbContextFactory, classifierTypeService, classifierTreeService);
using (var _ = unitOfWorkFactory.Create())
{
// arrange
await generator.InsertType(HierarchyType.Groups, cancellationToken);
var tree = await generator.FindTree(ClassifierTree.DefaultCode, cancellationToken);
var parentGroup = await generator.InsertGroup(tree.Uid, "001", null, cancellationToken);
await generator.InsertGroup(tree.Uid, "001.001", parentGroup.Uid, cancellationToken);
await generator.InsertGroup(tree.Uid, "001.002", parentGroup.Uid, cancellationToken);
await generator.InsertGroup(tree.Uid, "001.003", parentGroup.Uid, cancellationToken);
await generator.InsertGroup(tree.Uid, "001.004", parentGroup.Uid, cancellationToken);
await generator.InsertGroup(tree.Uid, "001.005", parentGroup.Uid, cancellationToken);
await generator.InsertGroup(tree.Uid, "001.006", parentGroup.Uid, cancellationToken);
await generator.InsertGroup(tree.Uid, "001.007", parentGroup.Uid, cancellationToken);
// act
var command = new GetClassifierGroupList
{
TypeCode = generator.TypeCode,
TreeUid = tree.Uid,
ParentUid = parentGroup.Uid,
};
var result = await handler.Handle(command, cancellationToken);
// assert
Assert.IsNotNull(result);
Assert.AreEqual(7, result.Rows.Count);
}
}
public async Task Execute_Should_DeleteEntityStatus()
{
// arrange
var cancellationToken = CancellationToken.None;
var dbContextFactory = new DefaultDbContextFactory();
var unitOfWorkFactory = new TransactionScopeUnitOfWorkFactory();
var generator = new CoreDbGenerator(unitOfWorkFactory, dbContextFactory);
var handler = new DeleteEntityStatusHandler(unitOfWorkFactory, dbContextFactory);
using (var _ = unitOfWorkFactory.Create())
{
// arrange
var uids = new List <Guid>();
for (var i = 0; i < 42; i++)
{
var insertResult = await generator.InsertEntityStatus(new EntityStatus
{
Uid = Guid.NewGuid(),
Code = "status_code_" + i,
Name = "Status Name " + i
}, cancellationToken);
// ReSharper disable once PossibleInvalidOperationException
uids.Add(insertResult.Uid.Value);
}
// act
var request = new DeleteEntityStatus
{
EntityTypeCode = generator.EntityTypeCode,
EntityUid = generator.EntityUid,
Uids = uids.Take(3).ToList()
};
var result = await handler.Handle(request, cancellationToken);
// assert
Assert.IsNotNull(result);
Assert.AreEqual(3, result.AffectedRows);
var statuses = await generator.GetEntityStatuses(cancellationToken);
Assert.AreEqual(39, statuses.Rows.Count);
foreach (var uid in request.Uids)
{
Assert.IsNull(statuses.Rows.FirstOrDefault(x => x.Uid == uid));
}
}
}
public async Task GenerateNumber_IndependentNumerator_ShouldGenerate()
{
// arrange
var cancellationToken = new CancellationToken();
var unitOfWorkFactory = new TransactionScopeUnitOfWorkFactory();
var dbContextFactory = new DefaultDbContextFactory();
var dateTimeProvider = new DefaultDateTimeProvider();
var generator = new MasterDataDbGenerator(unitOfWorkFactory, dbContextFactory);
var numeratorTagProvider = new TestNumberTagResolver {
EntityTypeCode = NumerableEntityTypeCode
};
var classifierRepositoryFactory = CreateClassifierRepositoryFactory(dbContextFactory);
var service = new DbNumberGenerator(dbContextFactory, classifierRepositoryFactory, dateTimeProvider, new INumberTagResolver[] { numeratorTagProvider });
using (var _ = unitOfWorkFactory.Create())
{
var request = new GenerateNumberRequest
{
EntityTypeCode = NumerableEntityTypeCode,
EntityTypeUid = Guid.NewGuid()
};
await generator.InsertNumerator(new Numerator
{
Pattern = "{Company}-{Number}",
KeyTags = new[] { "Company" }
}, request, cancellationToken);
// act
numeratorTagProvider.Values = new Dictionary <string, string> {
{ "Company", "MT" }
};
var number1 = await service.GenerateNumber(request, cancellationToken);
var number2 = await service.GenerateNumber(request, cancellationToken);
numeratorTagProvider.Values = new Dictionary <string, string> {
{ "Company", "GT" }
};
var number3 = await service.GenerateNumber(request, cancellationToken);
var number4 = await service.GenerateNumber(request, cancellationToken);
// assert
Assert.AreEqual("MT-00001", number1);
Assert.AreEqual("MT-00002", number2);
Assert.AreEqual("GT-00001", number3);
Assert.AreEqual("GT-00002", number4);
}
}
public static IServiceCollection AddDatabase(this IServiceCollection services, IConfigurationRoot config)
{
string connString = Globals.Configuration["db:ConnString"];
string dbType = Globals.Configuration["db:DbType"];
IDbContextFactory dbContextFactory = new DefaultDbContextFactory(dbType, connString);
services.AddSingleton <IDbContextFactory>(dbContextFactory);
services.AddScoped <IDbContext>(a =>
{
return(a.GetService <IDbContextFactory>().CreateContext());
});
return(services);
}
private static async Task DumpToDb(ParseResult result, string typeCode)
{
var unitOfWorkFactory = new TransactionScopeUnitOfWorkFactory();
var dbContextFactory = new DefaultDbContextFactory();
var classifierTypeRepository = new DbClassifierTypeRepository(dbContextFactory);
var classifierTypeService = new DbClassifierTypeService(dbContextFactory, classifierTypeRepository);
var handler = new ImportClassifierListHandler(unitOfWorkFactory, dbContextFactory, classifierTypeService);
await handler.Handle(new ImportClassifierList
{
CompanyUid = Guid.Parse("6465dd4c-8664-4433-ba6a-14effd40ebed"),
UserUid = Guid.NewGuid(),
TypeCode = typeCode,
Data = result
}, CancellationToken.None);
}
public async Task GetNumeratorEntityList_Should_ReturnList()
{
// arrange
var cancellationToken = CancellationToken.None;
var dbContextFactory = new DefaultDbContextFactory();
var unitOfWorkFactory = new TransactionScopeUnitOfWorkFactory();
var generator = new MasterDataDbGenerator(unitOfWorkFactory, dbContextFactory);
var entityTypeResolverMock = new Mock <IEntityNameResolver>();
entityTypeResolverMock.Setup(x => x.Resolve(It.IsAny <string>(), It.IsAny <Guid>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(() => "Numerator Entity Name");
var entityTypeResolverFactory = new Mock <INamedServiceFactory <IEntityNameResolver> >();
entityTypeResolverFactory.Setup(x => x.GetRequiredService(It.IsAny <string>()))
.Returns(() => entityTypeResolverMock.Object);
var repository = new DbNumeratorEntityRepository(dbContextFactory, entityTypeResolverFactory.Object);
var handler = new GetNumeratorEntityListHandler(repository);
using (var _ = unitOfWorkFactory.Create())
{
// arrange
var numerator = await generator.InsertNumerator(
new Numerator(),
new GenerateNumberRequest
{
EntityTypeCode = "NumeratorTypeCode",
EntityTypeUid = Guid.NewGuid()
}, cancellationToken);
// act
// ReSharper disable once PossibleInvalidOperationException
var command = new GetNumeratorEntityList {
NumeratorUid = numerator.Uid.Value
};
var result = await handler.Handle(command, cancellationToken);
// assert
Assert.IsNotNull(result);
Assert.IsNull(result.TotalCount);
Assert.IsTrue(result.Rows.Count > 0);
Assert.IsTrue(result.Rows.Count(x => x.EntityTypeCode == "NumeratorTypeCode") == 1);
}
}
public async Task GetInvitationList_ForNormalRequest_ReturnItems()
{
// arrange
var cancellationToken = CancellationToken.None;
var dbContextFactory = new DefaultDbContextFactory();
var classifierTypeRepository = new DbClassifierTypeRepository(dbContextFactory);
var classifierTypeService = new DbClassifierTypeService(dbContextFactory, classifierTypeRepository);
var fieldProviderRegistry = new DefaultFieldProviderRegistry();
fieldProviderRegistry.AddFieldType(typeof(TextField));
var dbFieldDataRepository = new DbFieldDataRepository(dbContextFactory, fieldProviderRegistry);
var metadataServiceMock = new Mock <IClassifierTypeMetadataService>();
metadataServiceMock
.Setup(x => x.GetMetadata(It.IsAny <ClassifierType>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(() => new FieldMetadata[]
{
new TextField {
Key = "test1", Active = true, System = false
},
new TextField {
Key = "test2", Active = true, System = false
},
new TextField {
Key = "test3", Active = true, System = false
}
});
var classifierRepository = new DbClassifierRepository <Classifier>(dbContextFactory,
classifierTypeService, null, metadataServiceMock.Object, dbFieldDataRepository, null);
var handler = new GetInvitationListHandler(dbContextFactory, classifierRepository);
// act
var command = new GetInvitationList
{
UserUid = Guid.NewGuid(),
};
var result = await handler.Handle(command, cancellationToken);
// assert
Assert.IsNotNull(result);
Assert.IsNotNull(result.Rows);
}
public async Task UpdateClassifier_NormalValues_UpdateItems()
{
// arrange
var cancellationToken = new CancellationToken();
var unitOfWorkFactory = new TransactionScopeUnitOfWorkFactory();
var dbContextFactory = new DefaultDbContextFactory();
var generator = new MasterDataDbGenerator(unitOfWorkFactory, dbContextFactory);
var classifierRepositoryFactory = CreateClassifierRepositoryFactory(dbContextFactory);
var handler = new UpdateClassifierHandler(unitOfWorkFactory, classifierRepositoryFactory);
using (var _ = unitOfWorkFactory.Create())
{
// arrange
await generator.InsertType(HierarchyType.None, cancellationToken);
var insertItem = await generator.InsertItem("001", null, cancellationToken);
// act
var command = new UpdateClassifier
{
UserUid = generator.UserUid,
Item = new Classifier
{
// ReSharper disable once PossibleInvalidOperationException
Uid = insertItem.Uid.Value,
Type = generator.TypeCode,
Code = "001",
Name = "Test Classifier",
Fields = new FieldData
{
{ "test1", "value1" },
{ "test2", "value2" },
{ "test3", "value3" }
}
}
};
var result = await handler.Handle(command, cancellationToken);
// assert
Assert.IsNotNull(result);
Assert.IsTrue(result.Success);
Assert.AreEqual(1, result.AffectedRows);
}
}
public async Task Register_NormalValues_RegisterClassifierType()
{
// arrange
var cancellationToken = new CancellationToken();
var unitOfWorkFactory = new TransactionScopeUnitOfWorkFactory();
var dbContextFactory = new DefaultDbContextFactory();
var classifierTypeRepository = new DbClassifierTypeRepository(dbContextFactory);
var classifierTypeService = new DbClassifierTypeService(dbContextFactory, classifierTypeRepository);
var dbFieldMetadataService = new DbFieldMetadataService(dbContextFactory, new DefaultDateTimeProvider(), new NewtonsoftJsonSerializer());
var handler = new DefaultClassifierTypeRegistrator(
new NullLogger <DefaultClassifierTypeRegistrator>(),
unitOfWorkFactory, classifierTypeService, dbFieldMetadataService);
using (var _ = unitOfWorkFactory.Create())
{
// act
var command = new RegisterClassifierType
{
Item = new ClassifierType
{
Code = "new_classifier_registration",
Name = "New Classifier Registration",
IsSystem = true
},
Fields = new List <FieldMetadata>
{
new TextField {
Key = "code", Name = "Code", Active = true, System = true
},
new TextField {
Key = "name", Name = "Name", Active = true, System = true
},
}
};
var result = await handler.Register(command.Item, command.Fields, cancellationToken);
// assert
Assert.IsNotNull(result);
Assert.AreNotEqual(Guid.Empty, result.Uid);
}
}
public async Task GetCompanyList_Should_ReturnCompanyList()
{
// arrange
var dbContextFactory = new DefaultDbContextFactory();
var dbCompanyRepository = new DbCompanyRepository(dbContextFactory);
var handler = new GetCompanyListHandler(dbCompanyRepository);
// act
var command = new GetCompanyList
{
UserUid = Guid.NewGuid()
};
var result = await handler.Handle(command, CancellationToken.None);
// assert
Assert.IsNotNull(result);
Assert.IsNotNull(result.Rows);
}
public async Task GenerateNumber_WithPeriodTags_ShouldGenerate()
{
// arrange
var cancellationToken = new CancellationToken();
var unitOfWorkFactory = new TransactionScopeUnitOfWorkFactory();
var dbContextFactory = new DefaultDbContextFactory();
var dateTimeProvider = new DefaultDateTimeProvider();
var generator = new MasterDataDbGenerator(unitOfWorkFactory, dbContextFactory);
var numeratorTagProvider = new TestNumberTagResolver {
EntityTypeCode = NumerableEntityTypeCode
};
var classifierRepositoryFactory = CreateClassifierRepositoryFactory(dbContextFactory);
var service = new DbNumberGenerator(dbContextFactory, classifierRepositoryFactory, dateTimeProvider, new INumberTagResolver[] { numeratorTagProvider });
using (var _ = unitOfWorkFactory.Create())
{
var request = new GenerateNumberRequest
{
EntityTypeCode = NumerableEntityTypeCode,
EntityTypeUid = Guid.NewGuid()
};
await generator.InsertNumerator(new Numerator
{
Periodicity = NumeratorPeriodicity.Year,
Pattern = "{Company}-{Number}-{Day}-{Month}-{Quarter}-{Year2}-{Year4}"
}, request, cancellationToken);
// act
numeratorTagProvider.Values = new Dictionary <string, string> {
{ "Company", "MT" }
};
numeratorTagProvider.Date = new DateTime(2003, 2, 5);
var number1 = await service.GenerateNumber(request, cancellationToken);
numeratorTagProvider.Date = new DateTime(1999, 10, 30);
var number2 = await service.GenerateNumber(request, cancellationToken);
// assert
Assert.AreEqual("MT-00001-05-02-1-03-2003", number1);
Assert.AreEqual("MT-00001-30-10-4-99-1999", number2);
}
}
public async Task Handle_NormalValues_ShouldDeleteTree()
{
// arrange
var cancellationToken = new CancellationToken();
var unitOfWorkFactory = new TransactionScopeUnitOfWorkFactory();
var dbContextFactory = new DefaultDbContextFactory();
var classifierTypeRepository = new DbClassifierTypeRepository(dbContextFactory);
var classifierTypeService = new DbClassifierTypeService(dbContextFactory, classifierTypeRepository);
var generator = new MasterDataDbGenerator(unitOfWorkFactory, dbContextFactory);
var handler = new DeleteClassifierTreeHandler(unitOfWorkFactory, dbContextFactory, classifierTypeService);
using (var _ = unitOfWorkFactory.Create())
{
// arrange
await generator.InsertType(HierarchyType.Groups, cancellationToken);
var tree2 = await generator.InsertTree("tree2", cancellationToken);
// assert - default and second trees exists
var trees = await generator.GetTrees(cancellationToken);
Assert.AreEqual(2, trees.TotalCount);
// act
var result = await handler.Handle(new DeleteClassifierTree
{
UserUid = generator.UserUid,
TypeCode = generator.TypeCode,
// ReSharper disable once PossibleInvalidOperationException
Uids = new [] { tree2.Uid.Value }
}, cancellationToken);
// assert - link deleted
Assert.IsTrue(result.Success);
Assert.AreEqual(1, result.AffectedRows);
// assert - default hierarchy exists
trees = await generator.GetTrees(cancellationToken);
Assert.AreEqual(1, trees.TotalCount);
Assert.AreEqual(ClassifierTree.DefaultCode, trees.Rows[0].Code);
}
}
public async Task Handle_ByUid_UpdateClassifierTree()
{
// arrange
var cancellationToken = new CancellationToken();
var unitOfWorkFactory = new TransactionScopeUnitOfWorkFactory();
var dbContextFactory = new DefaultDbContextFactory();
var classifierTypeRepository = new DbClassifierTypeRepository(dbContextFactory);
var classifierTypeService = new DbClassifierTypeService(dbContextFactory, classifierTypeRepository);
var generator = new MasterDataDbGenerator(unitOfWorkFactory, dbContextFactory);
var handler = new UpdateClassifierTreeHandler(unitOfWorkFactory, dbContextFactory, classifierTypeService);
using (var _ = unitOfWorkFactory.Create())
{
// arrange
await generator.InsertType(HierarchyType.Groups, cancellationToken);
var trees = await generator.GetTrees(cancellationToken);
// act
var result = await handler.Handle(new UpdateClassifierTree
{
UserUid = generator.UserUid,
TypeCode = generator.TypeCode,
Item = new ClassifierTree
{
Uid = trees.Rows[0].Uid,
Code = ClassifierTree.DefaultCode,
Name = "Test Classifier Tree"
}
}, cancellationToken);
// assert
Assert.IsNotNull(result);
Assert.IsTrue(result.Success);
Assert.AreEqual(1, result.AffectedRows);
trees = await generator.GetTrees(cancellationToken);
Assert.AreEqual(1, trees.TotalCount);
Assert.AreEqual("Test Classifier Tree", trees.Rows[0].Name);
}
}
public async Task GetEventList_ForNormalRequest_ReturnItems()
{
// arrange
var cancellationToken = CancellationToken.None;
var dbContextFactory = new DefaultDbContextFactory();
var handler = new GetEventListHandler(dbContextFactory);
// act
var command = new GetEventList
{
UserUid = Guid.NewGuid(),
};
var result = await handler.Handle(command, cancellationToken);
// assert
Assert.IsNotNull(result);
Assert.IsNotNull(result.Rows);
}
