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