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