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