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 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 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);
}
}
public async Task Handle_WithExistingLink_ShouldDeleteExistingLinkAndInsertNewLink()
{
// 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 group2 = await generator.InsertGroup(root.Uid, "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 is inserted
Assert.IsTrue(result.Success);
// assert - item linked to new group, link with root not exists
links = await generator.GetLinks(null, item1.Uid, cancellationToken);
Assert.AreEqual(1, links.TotalCount);
Assert.AreEqual(group2.Uid, links.Rows[0].Group.Uid);
Assert.AreEqual(item1.Uid, links.Rows[0].Item.Uid);
}
}
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 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 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 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 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 GetItems_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.Items, cancellationToken);
var parentItem = await generator.InsertItem("001", null, cancellationToken);
for (var i = 0; i < 3; i++)
{
await generator.InsertItem($"{i:D4}", parentItem.Uid, cancellationToken);
}
// act
var command = new GetClassifierGroupList
{
TypeCode = generator.TypeCode,
ParentUid = parentItem.Uid
};
var result = await handler.Handle(command, cancellationToken);
// assert
Assert.IsNotNull(result);
Assert.AreEqual(3, result.Rows.Count);
}
}
public async Task Handle_NormalValues_InsertClassifierTree()
{
// 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 InsertClassifierTreeHandler(unitOfWorkFactory, dbContextFactory, classifierTypeService);
using (var _ = unitOfWorkFactory.Create())
{
// arrange
await generator.InsertType(HierarchyType.Groups, cancellationToken);
// act
var result = await handler.Handle(new InsertClassifierTree
{
UserUid = generator.UserUid,
TypeCode = generator.TypeCode,
Item = new ClassifierTree
{
Code = "001",
Name = "Test Classifier Tree"
}
}, cancellationToken);
// assert
Assert.IsNotNull(result);
Assert.IsTrue(result.Success);
Assert.IsNotNull(result.Uid);
Assert.AreNotEqual(Guid.Empty, result.Uid);
var trees = await generator.GetTrees(cancellationToken);
Assert.AreEqual(2, trees.TotalCount); // one for default tree and second for inserted in test
}
}
public async Task GetItems_ForBigGroups_ReturnNoMoreThan1000Items()
{
// 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);
// todo: generate a lot of groups
// act
var command = new GetClassifierGroupList
{
TypeCode = generator.TypeCode,
TreeUid = tree.Uid
};
var result = await handler.Handle(command, cancellationToken);
// assert
Assert.IsNotNull(result);
Assert.IsTrue(result.Rows.Count <= 1000);
}
}
public async Task ManageRole_NormalValues_ManageItems()
{
// arrange
var cancellationToken = new CancellationToken();
var unitOfWorkFactory = new TransactionScopeUnitOfWorkFactory();
var dbContextFactory = new DefaultDbContextFactory();
var generator = new MasterDataDbGenerator(unitOfWorkFactory, dbContextFactory);
var classifierRepositoryFactoryBuilder = new ClassifierRepositoryFactoryBuilder(dbContextFactory);
var classifierRepositoryFactory = classifierRepositoryFactoryBuilder.Build();
var insertHandler = new InsertClassifierHandler(unitOfWorkFactory, classifierRepositoryFactory);
var updateHandler = new UpdateClassifierHandler(unitOfWorkFactory, classifierRepositoryFactory);
var deleteHandler = new DeleteClassifierHandler(unitOfWorkFactory, classifierRepositoryFactory);
using (var _ = unitOfWorkFactory.Create())
{
// arrange
generator.TypeCode = classifierRepositoryFactoryBuilder.RoleTypeCode;
await generator.InsertType(HierarchyType.None, cancellationToken);
// act - insert
var insertedIds = new List <Guid>();
for (var i = 0; i < 3; i++)
{
var insertResult = await insertHandler.Handle(new InsertClassifier
{
UserUid = generator.UserUid,
Item = new Role
{
Type = generator.TypeCode,
Code = "00" + i,
Name = "00" + i + " - Test Role"
}
}, cancellationToken);
Assert.IsNotNull(insertResult);
Assert.IsTrue(insertResult.Success, string.Join(",", insertResult.Errors.SelectMany(x => x.Messages)));
// ReSharper disable once PossibleInvalidOperationException
insertedIds.Add(insertResult.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 - update
foreach (var item in searchResult.Rows.Cast <Role>())
{
item.Name = item.Name.Replace("Test", "Updated");
var updateCommand = new UpdateClassifier
{
UserUid = generator.UserUid,
Item = item
};
var updateResult = await updateHandler.Handle(updateCommand, cancellationToken);
Assert.IsNotNull(updateResult);
Assert.IsTrue(updateResult.Success, string.Join(",", updateResult.Errors.SelectMany(x => x.Messages)));
}
searchResult = await classifierRepositoryFactory.GetNamedOrDefaultService(generator.TypeCode)
.Search(new ClassifierSearchRequest {
TypeCode = generator.TypeCode
}, cancellationToken);
// assert
Assert.IsNotNull(searchResult);
Assert.AreEqual(insertedIds.Count, searchResult.Rows.Count);
Assert.AreEqual(0, searchResult.Rows.Count(x => x.Name.Contains("Test")));
Assert.AreEqual(insertedIds.Count, searchResult.Rows.Count(x => x.Name.Contains("Updated")));
// act - delete
var command = new DeleteClassifier
{
UserUid = generator.UserUid,
TypeCode = generator.TypeCode,
Uids = insertedIds.ToArray()
};
var deleteResult = await deleteHandler.Handle(command, cancellationToken);
// assert
Assert.IsNotNull(deleteResult);
Assert.IsTrue(deleteResult.Success, string.Join(",", deleteResult.Errors?.SelectMany(x => x.Messages) ?? Array.Empty <string>()));
Assert.AreEqual(insertedIds.Count, deleteResult.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 ExportClassifierList_Should_ReturnStream()
{
// 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 fieldProviderRegistry = new DefaultFieldProviderRegistry();
fieldProviderRegistry.AddFieldType(typeof(TextField));
fieldProviderRegistry.AddFieldType(typeof(TextAreaField));
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 generator = new MasterDataDbGenerator(unitOfWorkFactory, dbContextFactory);
var classifierRepository = new DbClassifierRepository <Classifier>(
dbContextFactory, classifierTypeService, null, metadataServiceMock.Object, dbFieldDataRepository, null);
var classifierRepositoryFactoryMock = new Mock <INamedServiceFactory <IClassifierRepository> >();
classifierRepositoryFactoryMock
.Setup(x => x.GetNamedOrDefaultService(generator.TypeCode))
.Returns(() => classifierRepository);
var handler = new ExportClassifierListHandler(classifierRepositoryFactoryMock.Object);
using (var _ = unitOfWorkFactory.Create())
{
// arrange
await generator.InsertType(HierarchyType.None, cancellationToken);
for (var i = 0; i < 100; i++)
{
await generator.InsertItem($"{i:D4}", null, cancellationToken);
}
// act
var command = new ExportClassifierList
{
TypeCode = generator.TypeCode
};
var result = await handler.Handle(command, cancellationToken);
// assert
Assert.IsNotNull(result);
Assert.IsNotNull(result.Stream);
Assert.IsNotNull(result.FileName);
Assert.IsNotNull(result.ContentType);
// temp
using (var fs = new FileStream(result.FileName, FileMode.OpenOrCreate))
{
await result.Stream.CopyToAsync(fs, cancellationToken);
}
}
}
public async Task Handle_NormalValues_InsertInvitation()
{
// 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 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 generator = new MasterDataDbGenerator(unitOfWorkFactory, dbContextFactory);
var classifierRepositoryFactoryMock = new Mock <INamedServiceFactory <IClassifierRepository> >();
classifierRepositoryFactoryMock
.Setup(x => x.GetNamedOrDefaultService(It.IsAny <string>()))
.Returns(() => classifierRepository);
var handler = new InsertInvitationHandler(unitOfWorkFactory, dbContextFactory, classifierRepositoryFactoryMock.Object);
using (var _ = unitOfWorkFactory.Create())
{
// act
var command = new InsertInvitation
{
UserUid = generator.UserUid,
CompanyUid = generator.CompanyUid,
EventUid = Guid.Parse("436c290c-37b2-11e9-88fe-00ff279ba9e1"),
Items = new []
{
new Invitation {
CounterpartyUid = Guid.Parse("1bef28d6-2255-416c-a706-008e0c179508")
}
}
};
var result = await handler.Handle(command, cancellationToken);
// assert
Assert.IsNotNull(result);
Assert.IsTrue(result.Success);
Assert.AreEqual(1, result.AffectedRows);
}
}
public async Task CreateCompany_Should_CreateCompany()
{
// arrange
var cancellationToken = new CancellationToken();
var unitOfWorkFactory = new TransactionScopeUnitOfWorkFactory();
var dbContextFactory = new DefaultDbContextFactory();
var dateTimeProvider = new DefaultDateTimeProvider();
var mediatorMock = new Mock <IPublisher>();
var fieldProviderRegistry = new DefaultFieldProviderRegistry();
fieldProviderRegistry.AddFieldType(typeof(TextField));
// var dbFieldMetadataRepository = new DbFieldMetadataRepository(dbContextFactory, fieldProviderRegistry, new NewtonsoftJsonSerializer());
var dbFieldDataRepository = new DbFieldDataRepository(dbContextFactory, fieldProviderRegistry);
var classifierRepositoryFactory = CreateClassifierRepositoryFactory(dbContextFactory);
var dbNumberGenerator = new DbNumberGenerator(dbContextFactory, classifierRepositoryFactory, dateTimeProvider, Array.Empty <INumberTagResolver>());
var dbDocumentService = new DbDocumentService(dbContextFactory, dbNumberGenerator, mediatorMock.Object);
var jsonSerializer = new DefaultJsonSerializer();
var auditLogService = new DbAuditLogService(dbContextFactory, jsonSerializer);
var classifierRegistrator = new DefaultClassifierRegistrator(NullLogger <DefaultClassifierRegistrator> .Instance, classifierRepositoryFactory);
var metadataRepositoryMock = new Mock <IRepository <FieldMetadata> >();
metadataRepositoryMock
.Setup(x => x.Search(It.IsAny <MetadataSearchRequest>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(() => new SearchResult <FieldMetadata>
{
Rows = 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 backgroundJobManagerMock = new Mock <IBackgroundJobManager>();
var generator = new MasterDataDbGenerator(unitOfWorkFactory, dbContextFactory);
var handler = new CreateCompanyHandler(unitOfWorkFactory,
dbContextFactory, dateTimeProvider, metadataRepositoryMock.Object,
dbFieldDataRepository, classifierRepositoryFactory, dbDocumentService, auditLogService, backgroundJobManagerMock.Object);
using (var _ = unitOfWorkFactory.Create())
{
await generator.EnsureClassifierTypeRegistered(Numerator.GetDefaultMetadata(), cancellationToken);
await generator.EnsureClassifierTypeRegistered(DocumentType.GetDefaultMetadata(), cancellationToken);
foreach (var classifier in RegisterClassifiersStartupTask.GetClassifiers())
{
await classifierRegistrator.Register(classifier, cancellationToken);
}
// act
var company = new Company
{
ConfigCode = "company",
Name = "Montr Inc.",
Fields = new FieldData
{
{ "test1", "value1" },
{ "test2", "value2" },
{ "test3", "value3" }
}
};
var command = new CreateCompany
{
UserUid = Guid.NewGuid(),
Item = company
};
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);
// assert registration request inserted
DbDocument dbDocument;
using (var db = dbContextFactory.Create())
{
dbDocument = await db.GetTable <DbDocument>()
.Where(x => x.CompanyUid == result.Uid)
.SingleAsync(cancellationToken);
}
Assert.IsNotNull(dbDocument);
// assert registration request field data inserted
IList <DbFieldData> fieldData;
using (var db = dbContextFactory.Create())
{
fieldData = await db.GetTable <DbFieldData>()
.Where(x => x.EntityTypeCode == Document.TypeCode && x.EntityUid == dbDocument.Uid)
.ToListAsync(cancellationToken);
}
Assert.AreEqual(company.Fields.Count, fieldData.Count);
Assert.AreEqual(company.Fields["test1"], fieldData.Single(x => x.Key == "test1").Value);
Assert.AreEqual(company.Fields["test2"], fieldData.Single(x => x.Key == "test2").Value);
Assert.AreEqual(company.Fields["test3"], fieldData.Single(x => x.Key == "test3").Value);
}
}
public async Task ManageNumerator_NormalValues_ManageItems()
{
// arrange
var cancellationToken = new CancellationToken();
var unitOfWorkFactory = new TransactionScopeUnitOfWorkFactory();
var dbContextFactory = new DefaultDbContextFactory();
var generator = new MasterDataDbGenerator(unitOfWorkFactory, dbContextFactory);
var classifierRepositoryFactory = CreateClassifierRepositoryFactory(dbContextFactory);
var insertHandler = new InsertClassifierHandler(unitOfWorkFactory, classifierRepositoryFactory);
var updateHandler = new UpdateClassifierHandler(unitOfWorkFactory, classifierRepositoryFactory);
var deleteHandler = new DeleteClassifierHandler(unitOfWorkFactory, classifierRepositoryFactory);
using (var _ = unitOfWorkFactory.Create())
{
// arrange
generator.TypeCode = NumeratorTypeCode;
await generator.InsertType(HierarchyType.None, cancellationToken);
// act - insert
var insertedIds = new List <Guid>();
for (var i = 0; i < 5; i++)
{
var insertResult = await insertHandler.Handle(new InsertClassifier
{
UserUid = generator.UserUid,
Item = new Numerator
{
Type = generator.TypeCode,
Code = "00" + i,
Name = "00" + i + " - Test Numerator",
EntityTypeCode = "DocumentType",
Pattern = "{Number}"
}
}, cancellationToken);
Assert.IsNotNull(insertResult);
Assert.AreEqual(true, insertResult.Success);
// ReSharper disable once PossibleInvalidOperationException
insertedIds.Add(insertResult.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 - update
foreach (var classifier in searchResult.Rows.Cast <Numerator>())
{
classifier.Name = classifier.Name.Replace("Test", "Updated");
classifier.Pattern = "No. " + classifier.Pattern;
var updateCommand = new UpdateClassifier
{
UserUid = generator.UserUid,
Item = classifier
};
var updateResult = await updateHandler.Handle(updateCommand, cancellationToken);
Assert.IsNotNull(updateResult);
Assert.AreEqual(true, updateResult.Success);
}
searchResult = await classifierRepositoryFactory.GetNamedOrDefaultService(generator.TypeCode)
.Search(new ClassifierSearchRequest {
TypeCode = generator.TypeCode
}, cancellationToken);
// assert
Assert.IsNotNull(searchResult);
Assert.AreEqual(insertedIds.Count, searchResult.Rows.Count);
Assert.AreEqual(0, searchResult.Rows.Count(x => x.Name.Contains("Test")));
Assert.AreEqual(insertedIds.Count, searchResult.Rows.Count(x => x.Name.Contains("Updated")));
Assert.AreEqual(insertedIds.Count, searchResult.Rows.Cast <Numerator>().Count(x => x.Pattern.Contains("No.")));
// act - delete
var command = new DeleteClassifier
{
UserUid = generator.UserUid,
TypeCode = generator.TypeCode,
Uids = insertedIds.ToArray()
};
var result = await deleteHandler.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 GetClassifierLinkList_Should_ReturnList()
{
// 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 GetClassifierLinkListHandler(dbContextFactory, classifierTypeService);
using (var _ = unitOfWorkFactory.Create())
{
await generator.InsertType(HierarchyType.Groups, cancellationToken);
var tree = await generator.FindTree(ClassifierTree.DefaultCode, cancellationToken);
var group1 = await generator.InsertGroup(tree.Uid, "001", null, cancellationToken);
var item1 = await generator.InsertItem("001", null, cancellationToken);
var item2 = await generator.InsertItem("002", null, cancellationToken);
await generator.InsertLink(group1.Uid, item1.Uid, cancellationToken);
await generator.InsertLink(group1.Uid, item2.Uid, cancellationToken);
// act - search by group code
var result = await handler.Handle(new GetClassifierLinkList
{
TypeCode = generator.TypeCode,
GroupUid = group1.Uid
}, cancellationToken);
// assert
Assert.IsNotNull(result);
Assert.AreEqual(2, result.TotalCount);
Assert.AreEqual(tree.Uid, result.Rows[0].Tree.Uid);
Assert.AreEqual(group1.Uid, result.Rows[0].Group.Uid);
Assert.AreEqual(tree.Uid, result.Rows[1].Tree.Uid);
Assert.AreEqual(group1.Uid, result.Rows[1].Group.Uid);
var items = result.Rows.Select(x => x.Item.Uid).ToList();
CollectionAssert.Contains(items, item1.Uid);
CollectionAssert.Contains(items, item2.Uid);
// act - search by item code
result = await handler.Handle(new GetClassifierLinkList
{
TypeCode = generator.TypeCode,
ItemUid = item1.Uid
}, cancellationToken);
// assert
Assert.IsNotNull(result);
Assert.AreEqual(1, result.TotalCount);
Assert.AreEqual(tree.Uid, result.Rows[0].Tree.Uid);
Assert.AreEqual(group1.Uid, result.Rows[0].Group.Uid);
Assert.AreEqual(item1.Uid, result.Rows[0].Item.Uid);
// act - search by both group and item codes
result = await handler.Handle(new GetClassifierLinkList
{
TypeCode = generator.TypeCode,
GroupUid = group1.Uid,
ItemUid = item2.Uid
}, cancellationToken);
// assert
Assert.IsNotNull(result);
Assert.AreEqual(1, result.TotalCount);
Assert.AreEqual(tree.Uid, result.Rows[0].Tree.Uid);
Assert.AreEqual(group1.Uid, result.Rows[0].Group.Uid);
Assert.AreEqual(item2.Uid, result.Rows[0].Item.Uid);
}
}
public async Task InsertClassifier_NormalValues_InsertItems()
{
// 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
await generator.InsertType(HierarchyType.None, cancellationToken);
// act
var command = new InsertClassifier
{
UserUid = generator.UserUid,
Item = new Classifier
{
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.IsNotNull(result.Uid);
Assert.AreNotEqual(Guid.Empty, result.Uid);
var classifierResult = await classifierRepositoryFactory.GetNamedOrDefaultService(generator.TypeCode)
.Search(new ClassifierSearchRequest {
TypeCode = generator.TypeCode, Uid = result.Uid, IncludeFields = true
}, cancellationToken);
Assert.AreEqual(1, classifierResult.Rows.Count);
var inserted = classifierResult.Rows[0];
// todo: figure out why insert.Fields is null
Assert.AreEqual(command.Item.Code, inserted.Code);
Assert.AreEqual(command.Item.Name, inserted.Name);
// assert field data inserted
IList <DbFieldData> fieldData;
using (var db = dbContextFactory.Create())
{
fieldData = await db.GetTable <DbFieldData>()
.Where(x => x.EntityTypeCode == Classifier.TypeCode && x.EntityUid == result.Uid)
.ToListAsync(cancellationToken);
}
Assert.AreEqual(command.Item.Fields.Count, fieldData.Count);
Assert.AreEqual(command.Item.Fields["test1"], fieldData.Single(x => x.Key == "test1").Value);
Assert.AreEqual(command.Item.Fields["test2"], fieldData.Single(x => x.Key == "test2").Value);
Assert.AreEqual(command.Item.Fields["test3"], fieldData.Single(x => x.Key == "test3").Value);
}
}
public async Task GetGroups_WithFocusUid_ReturnChildrenOfEachParentGroups()
{
// 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);
// 2 roots without parent
for (var i = 0; i < 2; i++)
{
await generator.InsertGroup(tree.Uid, $"1-{i:D4}", null, cancellationToken);
}
// 1 root with 4 deep children
Guid?parentUid = null;
for (var i = 0; i <= 5; i++)
{
var childGroup = await generator.InsertGroup(tree.Uid, $"2-{i:D4}", parentUid, cancellationToken);
parentUid = childGroup.Uid;
}
// 3 roots without parent
for (var i = 0; i < 3; i++)
{
await generator.InsertGroup(tree.Uid, $"3-{i:D4}", null, cancellationToken);
}
var focusUid = parentUid;
// act & assert - focus in root scope
var command = new GetClassifierGroupList
{
TypeCode = generator.TypeCode,
TreeUid = tree.Uid,
ParentUid = null,
FocusUid = focusUid
// PageSize = 100 // todo: common limit for all levels is not ok
};
var result = await handler.Handle(command, cancellationToken);
// todo: pretty print and compare by focus.txt
Assert.IsNotNull(result);
Assert.AreEqual(6, result.Rows.Count);
Assert.IsNull(result.Rows[0].Children);
Assert.IsNull(result.Rows[1].Children);
Assert.IsNull(result.Rows[3].Children);
Assert.IsNull(result.Rows[4].Children);
Assert.IsNull(result.Rows[5].Children);
Assert.IsNotNull(result.Rows[2].Children);
Assert.AreEqual(result.Rows[2].Children.Count, 1); // 0 lvl
Assert.AreEqual(result.Rows[2].Children[0].Children.Count, 1); // 1 lvl
Assert.AreEqual(result.Rows[2].Children[0].Children[0].Children.Count, 1); // 2 lvl
Assert.AreEqual(result.Rows[2].Children[0].Children[0].Children[0].Children.Count, 1); // 3 lvl
Assert.AreEqual(result.Rows[2].Children[0].Children[0].Children[0].Children[0].Children.Count, 1); // 4 lvl
Assert.IsNull(result.Rows[2].Children[0].Children[0].Children[0].Children[0].Children[0].Children);
// act & assert - focus in scope of selected parent
// todo: what is the difference with previous asserts - ParentUid should be set?
command = new GetClassifierGroupList
{
TypeCode = generator.TypeCode,
TreeUid = tree.Uid,
FocusUid = focusUid
};
result = await handler.Handle(command, cancellationToken);
// todo: pretty print and compare by focus.txt
Assert.IsNotNull(result);
Assert.AreEqual(6, result.Rows.Count);
Assert.IsNull(result.Rows[0].Children);
Assert.IsNull(result.Rows[1].Children);
Assert.IsNull(result.Rows[3].Children);
Assert.IsNull(result.Rows[4].Children);
Assert.IsNull(result.Rows[5].Children);
Assert.IsNotNull(result.Rows[2].Children);
Assert.AreEqual(result.Rows[2].Children.Count, 1); // 0 lvl
Assert.AreEqual(result.Rows[2].Children[0].Children.Count, 1); // 1 lvl
Assert.AreEqual(result.Rows[2].Children[0].Children[0].Children.Count, 1); // 2 lvl
Assert.AreEqual(result.Rows[2].Children[0].Children[0].Children[0].Children.Count, 1); // 3 lvl
Assert.AreEqual(result.Rows[2].Children[0].Children[0].Children[0].Children[0].Children.Count, 1); // 4 lvl
Assert.IsNull(result.Rows[2].Children[0].Children[0].Children[0].Children[0].Children[0].Children);
}
}
public async Task GetClassifierList_Should_ReturnList()
{
// arrange
var cancellationToken = CancellationToken.None;
var dbContextFactory = new DefaultDbContextFactory();
var unitOfWorkFactory = new TransactionScopeUnitOfWorkFactory();
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 classifierRepositoryFactoryMock = new Mock <INamedServiceFactory <IClassifierRepository> >();
classifierRepositoryFactoryMock.Setup(x => x.GetNamedOrDefaultService(It.IsAny <string>())).Returns(classifierRepository);
var handler = new GetClassifierListHandler(classifierRepositoryFactoryMock.Object);
var generator = new MasterDataDbGenerator(unitOfWorkFactory, dbContextFactory);
using (var _ = unitOfWorkFactory.Create())
{
// arrange
await generator.InsertType(HierarchyType.None, cancellationToken);
for (var i = 0; i < 42; i++)
{
await generator.InsertItem($"{i:D4}", null, cancellationToken);
}
// act
var command = new GetClassifierList
{
TypeCode = generator.TypeCode
};
var result = await handler.Handle(command, cancellationToken);
// assert
Assert.IsNotNull(result);
Assert.AreEqual(10, result.Rows.Count);
Assert.AreEqual(42, result.TotalCount);
}
}
