public void TestCommandHandle()
{
var accountName = "testName";
var accountServiceMock = new Mock <IAggregateService <AccountAggregate> >();
accountServiceMock.Setup(m => m.Load(It.IsAny <Guid>())).Returns((Guid guid) => new AccountAggregate());
var eventPublisherMock = new Mock <IEventPublisher>();
eventPublisherMock.Setup(m => m.Publish(It.IsAny <CreateAccountEvent>())).Callback((IEvent e) =>
{
Assert.IsType <CreateAccountEvent>(e);
CreateAccountEvent createAccountEvent = (CreateAccountEvent)e;
Assert.Equal(accountName, createAccountEvent.AccountName);
Assert.NotEqual(Guid.Empty, createAccountEvent.ItemGuid);
Assert.Equal(Guid.Empty, createAccountEvent.EventGuid);
});
var commandHandler = new CreateAccountCommandHandler(accountServiceMock.Object, eventPublisherMock.Object);
ICommand command = new CreateAccountCommand {
Name = accountName
};
commandHandler.Handle((CreateAccountCommand)command);
eventPublisherMock.VerifyAll();
}
public void Success()
{
var testFixture = new QueryTestFixture();
var mockFactory = new MockRepository(MockBehavior.Loose);
var mediator = mockFactory.Create <IMediator>();
mediator.Setup(s => s.Publish(It.IsAny <CreatedAccountDomainEvent>(), It.IsAny <CancellationToken>()))
.Returns(Task.Run(() => { }));
var ct = new CancellationToken();
var hashService = mockFactory.Create <IHashService>();
var cmd = new CreateAccountCommandHandler(mediator.Object, testFixture.Context, hashService.Object);
var cmdArgs = new CreateAccountCommand()
{
Alias = "alias",
Email = "*****@*****.**",
Password = "******"
};
Assert.DoesNotThrowAsync(async() => await cmd.Handle(cmdArgs, ct));
}
public void ExistWitTheSameEmail()
{
var testFixture = new QueryTestFixture();
var dbContext = testFixture.Context;
var mockFactory = new MockRepository(MockBehavior.Loose);
dbContext.Add(new Account()
{
Email = "*****@*****.**"
});
dbContext.SaveChanges();
var mediator = mockFactory.Create <IMediator>();
var ct = new CancellationToken();
var hashService = mockFactory.Create <IHashService>();
var cmd = new CreateAccountCommandHandler(mediator.Object, dbContext, hashService.Object);
var cmdArgs = new CreateAccountCommand()
{
Alias = "alias",
Email = "*****@*****.**",
Password = "******"
};
Assert.ThrowsAsync <UnableCreateAccountException>(async() => await cmd.Handle(cmdArgs, ct));
}
public async Task CreateAccountCommand_DoesNot_create_account_when_Income_threshold_is_not_met()
{
//Arrange
var userId = Guid.NewGuid();
var request = new CreateAccountRequest {
UserId = userId
};
var response = new CreateAccountResponse();
using (var db = MockDbContext())
{
db.Users.RemoveRange(db.Users);
db.SaveChanges();
db.Users.Add(new User {
Id = userId, Name = "Tester1", Email = "*****@*****.**", Salary = 2000, Expenses = 1500
});
db.SaveChanges();
var command = new CreateAccountCommand(request);
var handler = new CreateAccountCommandHandler(db);
//Act
response = await handler.Handle(command, CancellationToken.None);
}
//Assert
response.Status.Should().Contain("Income");
response.Id.Should().BeEmpty();
}
public async Task CreateAccountCommand_DoesNot_create_account_when_User_notfound()
{
//Arrange
var userId = Guid.NewGuid();
var request = new CreateAccountRequest {
UserId = userId
};
var response = new CreateAccountResponse();
using (var db = MockDbContext())
{
db.Users.RemoveRange(db.Users);
db.SaveChanges();
var command = new CreateAccountCommand(request);
var handler = new CreateAccountCommandHandler(db);
//Act
response = await handler.Handle(command, CancellationToken.None);
}
//Assert
response.Status.Should().Contain("not be created");
response.Id.Should().BeEmpty();
}
public async Task ThenTheAccountIsCreated()
{
var accountId = 123443;
var name = "Account Name";
await _handler.Handle(new CreateAccountCommand(accountId, name));
_accountRepository.Verify(x => x.CreateAccount(accountId, name));
}
public void When_create_account_command_is_triggered_with_an_empty_name_it_should_throw()
{
// Arrange
var eventStore = new InMemoryEventRepositoryBuilder().Build();
var handler = new CreateAccountCommandHandler(eventStore);
// Act
Action action = () => handler.Handle(new CreateAccountCommand(Guid.NewGuid(), ""));
// Assert
action.ShouldThrow<ArgumentException>();
}
public async Task ThenIfThereAreMoreThanOneEmprefPassedThenTheyAreAddedToTheAccount()
{
//Arrange
var createAccountCommand = new CreateAccountCommand {
PayeReference = "123/abc,456/123", AccessToken = "123rd", RefreshToken = "45YT", OrganisationStatus = "active"
};
//Act
await _handler.Handle(createAccountCommand);
//Assert
_accountRepository.Verify(x => x.CreateAccount(It.IsAny <long>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <DateTime?>(), "123/abc", "123rd", "45YT", "active", It.IsAny <string>(), It.IsAny <short>(), It.IsAny <short?>(), It.IsAny <string>()), Times.Once);
_accountRepository.Verify(x => x.AddPayeToAccount(It.Is <Paye>(c => c.AccountId.Equals(ExpectedAccountId) && c.EmpRef.Equals("456/123") && c.AccessToken.Equals("123rd") && c.RefreshToken.Equals("45YT"))), Times.Once);
}
public async Task ThenTheAccountDataIsRetrievedAndSaved()
{
var expectedAccount = new AccountDetailViewModelBuilder().Build();
var accountHref = $"/api/accounts/{expectedAccount.HashedAccountId}";
_accountGateway.Setup(x => x.GetAccount(accountHref)).ReturnsAsync(expectedAccount);
await _commandHandler.Handle(new CreateAccountCommand { AccountHref = accountHref });
_accountRepository.Verify(x => x.SaveAccount(expectedAccount), Times.Once);
_mediator.Verify(x => x.PublishAsync(It.Is <CreateLegalEntityCommand>(c => c.LegalEntityHref == expectedAccount.LegalEntities[0].Href)), Times.Once);
_mediator.Verify(x => x.PublishAsync(It.Is <CreatePayeSchemeCommand>(c => c.PayeSchemeHref == expectedAccount.PayeSchemes[0].Href)), Times.Once);
}
public void When_create_account_command_is_triggered_it_should_raise_the_appropriate_events()
{
// Arrange
var eventStore = new InMemoryEventRepositoryBuilder().Build();
var handler = new CreateAccountCommandHandler(eventStore);
// Act
handler.Handle(new CreateAccountCommand(Guid.NewGuid(), "Thomas"));
// Assert
eventStore.Events.Should().HaveCount(1);
eventStore.Events.OfType<AccountCreatedEvent>().Should().HaveCount(1);
}
public async Task CreateAccountCommandHandler_Handle_AccountAlreadyExistsFail()
{
var options = new DbContextOptionsBuilder <AccountsContext>()
.UseInMemoryDatabase(nameof(CreateAccountCommandHandler_Handle_AccountAlreadyExistsFail))
.Options;
var accountContext = new AccountsContext(options);
var accountRepository = new AccountRepository(accountContext);
var createAccountCommandHandler = new CreateAccountCommandHandler(accountRepository);
await createAccountCommandHandler
.Handle(new CreateAccountCommand("test", "password"), CancellationToken.None)
.ConfigureAwait(false);
await Assert.ThrowsAsync <InvalidOperationException>(async() =>
{
await createAccountCommandHandler
.Handle(new CreateAccountCommand("test", "password"), CancellationToken.None)
.ConfigureAwait(false);
});
}
public async void Handle_GivenValidCustomer_ShouldCreateAccount()
{
// Arrange
// Create Customer
var customerCreation = new CreateCustomerCommandHandler(_customerLogger, _mapper, _customerRepository);
var newCustomerCommandRequest = new CreateCustomerCommand {
Email = "*****@*****.**", MonthlyIncome = 20000, MonthlyExpense = 200
};
var customerCreationResult = await customerCreation.Handle(newCustomerCommandRequest, CancellationToken.None);
var newAccountCommandRequest = new CreateAccountCommand {
Email = customerCreationResult.Email, customerId = customerCreationResult.Id
};
// Act
var accountCreationSUT = new CreateAccountCommandHandler(_accountLogger, _mapper, _accountRepository, _customerRepository);
var accountCreationResult = await accountCreationSUT.Handle(newAccountCommandRequest, CancellationToken.None);
var customerFromDb = _customerDbContext.Customers.Find(customerCreationResult.Id);
var accountFromDb = _customerDbContext.Accounts.Find(accountCreationResult.AccountNo);
// Assert
Assert.NotNull(customerCreationResult);
Assert.IsType <Guid>(customerCreationResult.Id);
Assert.Equal(newCustomerCommandRequest.Email, customerCreationResult.Email);
Assert.Equal(newCustomerCommandRequest.MonthlyExpense, customerCreationResult.MonthlyExpense);
Assert.Equal(newCustomerCommandRequest.MonthlyIncome, customerCreationResult.MonthlyIncome);
Assert.NotNull(customerFromDb);
Assert.Equal(customerCreationResult.Id, customerFromDb.Id);
Assert.Equal(newCustomerCommandRequest.Email, customerFromDb.Email);
Assert.Equal(newCustomerCommandRequest.MonthlyExpense, customerFromDb.MonthlyExpense);
Assert.Equal(newCustomerCommandRequest.MonthlyIncome, customerFromDb.MonthlyIncome);
Assert.NotNull(accountCreationResult);
Assert.Equal(customerCreationResult.Id, accountCreationResult.customerId);
Assert.Equal(customerCreationResult.Email, accountCreationResult.Email);
Assert.True(accountFromDb.Active);
Assert.NotNull(accountFromDb);
Assert.Equal(accountCreationResult.customerId, accountFromDb.CustomerId);
Assert.Equal(accountCreationResult.Email, accountFromDb.Email);
}
public async Task CreateAccountCommandHandler_Handle_AccountCreated()
{
var options = new DbContextOptionsBuilder <AccountsContext>()
.UseInMemoryDatabase(nameof(CreateAccountCommandHandler_Handle_AccountCreated))
.Options;
var accountContext = new AccountsContext(options);
var accountRepository = new AccountRepository(accountContext);
var createAccountCommandHandler = new CreateAccountCommandHandler(accountRepository);
var accountId = await createAccountCommandHandler
.Handle(new CreateAccountCommand("test", "password"), CancellationToken.None)
.ConfigureAwait(false);
Assert.True(Guid.TryParse(accountId.ToString(), out var unused));
}
public async Task CreateAccountSuccessfuly()
{
// Arrange
handler = new CreateAccountCommandHandler(_Database);
accountModel = new CreateAccountCommand()
{
AccountId = "0000",
AccountName = "Cash",
Active = 0,
CatagoryId = 1,
OpeningBalance = 100,
CostCenterId = 1
};
// Act
var response = await handler.Handle(accountModel, CancellationToken.None);
// Assert
Assert.NotEqual(0, response);
}
public async Task CreateNewAccount()
{
var handler = new CreateAccountCommandHandler(DbContext);
var request = new CreateAccountCommand
{
Email = "*****@*****.**",
Password = "******",
PasswordConfirmation = "AUDd9d722h(H!U&(H!wbu13g"
};
var result = await handler.Handle(request, CancellationToken.None);
Assert.True(result is UserDto);
Assert.Equal("*****@*****.**", result.Email);
var createdEntry = await DbContext
.Set <User>()
.Where(u => u.Uid == result.Id)
.FirstAsync();
Assert.NotNull(createdEntry);
Assert.True(BCrypt.Net.BCrypt.Verify("AUDd9d722h(H!U&(H!wbu13g", createdEntry.EncryptedPassword));
}
public async void Handle_GivenCustomerNotExist_ShouldThrowNotFoundException()
{
// Arrange
// Create Customer
var notCustomerEmail = "*****@*****.**";
var newAccountCommandRequest = new CreateAccountCommand {
Email = notCustomerEmail, customerId = Guid.NewGuid()
};
// Act
var accountCreationSUT = new CreateAccountCommandHandler(_accountLogger, _mapper, _accountRepository, _customerRepository);
var accountCreationExceptionResult = await Assert.ThrowsAsync <NotFoundException>(async() => await accountCreationSUT.Handle(newAccountCommandRequest, CancellationToken.None));
var accountFromDb = _accountRepository.GetAccountByEmail(notCustomerEmail);
// Assert
Assert.Null(accountFromDb);
}
public async Task ThenTheIdHashingServiceIsCalledAfterTheAccountIsCreated()
{
//Arrange
var createAccountCommand = new CreateAccountCommand {
PayeReference = "123/abc,456/123", AccessToken = "123rd", RefreshToken = "45YT", ExternalUserId = _user.Ref.ToString()
};
//Act
await _handler.Handle(createAccountCommand);
//Assert
_hashingService.Verify(x => x.HashValue(ExpectedAccountId), Times.Once);
}
public async void Handle_GivenCustomerWithInSufficientBalance_ShouldThrowBadRequest()
{
// Arrange
// Create Customer
var customerCreation = new CreateCustomerCommandHandler(_customerLogger, _mapper, _customerRepository);
var newCustomerCommandRequest = new CreateCustomerCommand {
Email = "*****@*****.**", MonthlyIncome = 2000, MonthlyExpense = 1200
};
var customerCreationResult = await customerCreation.Handle(newCustomerCommandRequest, CancellationToken.None);
var newAccountCommandRequest = new CreateAccountCommand {
Email = customerCreationResult.Email, customerId = customerCreationResult.Id
};
// Act
var accountCreationSUT = new CreateAccountCommandHandler(_accountLogger, _mapper, _accountRepository, _customerRepository);
var accountCreationExceptionResult = await Assert.ThrowsAsync <BadRequestException>(async() => await accountCreationSUT.Handle(newAccountCommandRequest, CancellationToken.None));
var accountFromDb = _accountRepository.GetAccountByEmail(customerCreationResult.Email);
// Assert
Assert.Null(accountFromDb);
}
