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