public void Setup()
{
_userRepository = new Mock <IContactRepository>();
_dfeSignInService = new Mock <IDfeSignInService>();
_handler = new CreateAccountHandler(_userRepository.Object, _dfeSignInService.Object, new Mock <ILogger <CreateAccountHandler> >().Object);
}
public async void Handle_CreateAccount_NewUsername()
{
const int remainingDays = 5;
var command = new FORFarm.Application.Accounts.Commands.CreateAccount.CreateAccount
{
Username = "******",
Password = "******",
RemainingMembershipDays = remainingDays
};
var now = DateTime.UtcNow;
var moq = new Mock <IDateTime>();
moq.Setup(d => d.UtcNow).Returns(now);
var createAccountHandler = new CreateAccountHandler(NewContext, moq.Object, Mapper);
await createAccountHandler.Handle(command, CancellationToken.None);
var accountVm = await NewContext.Accounts.FirstOrDefaultAsync(a => a.Username == command.Username);
accountVm.Username.Should().Be(command.Username);
accountVm.Password.Should().Be(command.Password);
accountVm.MemberExpirationDate.Should().Be(now.AddDays(remainingDays));
}
public async Task Creates_Account()
{
// Arrange
var expectedAccount = new Account
{
AccountId = 1,
AccountType = AccountType.Credit,
DateCreated = _expectedDateTime,
UserId = 1,
};
_mockAccountService.Setup(s => s.AddAsync(It.IsAny <Guid>(), It.IsAny <Account>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(expectedAccount);
var handler = new CreateAccountHandler(_mockAccountService.Object, _mockDateTimeProviderObject);
// Act
var request = new CreateAccount(userId: expectedAccount.UserId, expectedAccount.AccountType);
var newAccount = await handler.Handle(request);
// Assert
Assert.NotNull(newAccount);
Assert.Equal(expectedAccount.AccountId, newAccount.AccountId);
Assert.Equal(expectedAccount.AccountType, newAccount.AccountType);
Assert.Equal(expectedAccount.DateCreated, newAccount.DateCreated);
Assert.Equal(expectedAccount.UserId, newAccount.UserId);
}
public void Setup()
{
_contactRepository = new Mock <IContactRepository>();
_contactRepository.Setup(r => r.CreateContact(EMAIL, GIVEN_NAME, FAMILY_NAME)).ReturnsAsync(new Contact {
Id = ContactId, GivenNames = GIVEN_NAME, FamilyName = FAMILY_NAME, Email = EMAIL
});
_dfeSignInService = new Mock <IDfeSignInService>();
_dfeSignInService.Setup(dfe => dfe.InviteUser(EMAIL, GIVEN_NAME, FAMILY_NAME, ContactId)).ReturnsAsync(new InviteUserResponse {
IsSuccess = true
});
_handler = new CreateAccountHandler(_contactRepository.Object, _dfeSignInService.Object, new Mock <ILogger <CreateAccountHandler> >().Object);
}
public async Task Null_Request_Throws()
{
// Arrange
var handler = new CreateAccountHandler(_mockAccountService.Object, _mockDateTimeProviderObject);
// Act
CreateAccount invalidRequest = null;
var exception = await Record.ExceptionAsync(() => handler.Handle(invalidRequest));
// Assert
_mockAccountService.Verify(s => s.AddAsync(It.IsAny <Guid>(), It.IsAny <Account>(), It.IsAny <CancellationToken>()), Times.Never);
Assert.NotNull(exception);
Assert.IsType <NullReferenceException>(exception);
}
public async Task IAccountService_Throws()
{
// Arrange
_mockAccountService.Setup(s => s.AddAsync(It.IsAny <Guid>(), It.IsAny <Account>(), It.IsAny <CancellationToken>()))
.ThrowsAsync(new Exception());
var handler = new CreateAccountHandler(_mockAccountService.Object, _mockDateTimeProviderObject);
// Act
var request = new CreateAccount(userId: 1, AccountType.Credit);
var exception = await Record.ExceptionAsync(() => handler.Handle(request));
// Assert
Assert.NotNull(exception);
Assert.IsType <Exception>(exception);
}
public async Task Succeed_With_Valid_Input(
CreateAccountCommand command,
Account account,
[Frozen] Mock <IAccountFactory> factory,
[Frozen] Mock <IWriteOnlyUnitOfWork> unitOfWork,
CreateAccountHandler sut)
{
factory.Setup(p => p.Build(It.IsAny <AccountHolder>())).Returns(account);
unitOfWork.Setup(p => p.Add(It.IsAny <Account>())).Returns(account);
unitOfWork.Setup(p => p.CommitAsync()).ReturnsAsync(1);
var result = await sut.Handle(command, new CancellationToken());
factory.Verify(p => p.Build(It.IsAny <AccountHolder>()), Times.Once);
unitOfWork.Verify(p => p.CommitAsync(), Times.Once());
unitOfWork.Verify(p => p.Add(account), Times.Once());
Assert.True(result.AccountId == account.Id);
}
private static void MessageStuff()
{
var config = new RabbitConsumerConfig()
{
ExchangeBindings = new List <ExchangeBinding>()
{
new ExchangeBinding
{
RoutingKey = "billing.account.create",
ExchangeName = "Billing"
},
new ExchangeBinding
{
RoutingKey = "billing.account.delete",
ExchangeName = "Billing"
},
new ExchangeBinding
{
RoutingKey = "policy.term.created",
ExchangeName = "Policy"
}
},
QueueName = "PrototypeQueue",
HostName = "10.0.0.190",
UserName = "******",
Password = "******",
Port = 5672
};
var account = new CreateAccount
{
AccountName = "Account Name",
Amount = 10.20m,
CorrelationId = "1234"
};
var deleteAccount = new AccountDelete()
{
CorrelationId = "1234",
AccountId = 2
};
var stringValue = JsonConvert.SerializeObject(deleteAccount);
var factory = new MessageFactory(MessageMap.GetMessageMap());
UnityContainer container = new UnityContainer();
container.RegisterType <IMessageHandler <CreateAccount>, CreateAccountHandler>();
var handler = new CreateAccountHandler();
var badHandler = new DeleteAccountHandler();
var dispatcher = new MessageDispatcher();
dispatcher.RegisterHandler(handler);
dispatcher.RegisterHandler(badHandler);
dispatcher.Register <CreateAccount>((i) =>
{
System.Console.WriteLine($"From Action account Name {i.AccountName}");
});
var consumer = new RabbitConsumer(config, factory, dispatcher);
string value = string.Empty;
while (value != "exit")
{
value = System.Console.ReadLine();
}
consumer.Dispose();
}
