private void Handle(CreateAccountMessage message)
{
var accountData = message.Account;
var account = new Account
{
Id = accountData.Id,
Login = accountData.Login,
PasswordHash = accountData.PasswordHash,
Nickname = accountData.Nickname,
UserGroupId = accountData.UserGroupId,
AvailableBreeds = accountData.AvailableBreeds,
Ticket = accountData.Ticket,
SecretQuestion = accountData.SecretQuestion,
SecretAnswer = accountData.SecretAnswer,
Lang = accountData.Lang,
Email = accountData.Email
};
if (AccountManager.CreateAccount(account))
{
Client.ReplyRequest(new CommonOKMessage(), message);
}
else
{
Client.SendError(string.Format("Login {0} already exists", accountData.Login), message);
}
}
public async Task Invalid_Data_Throws(CreateAccountMessage invalidMessage)
{
// Act
await _publisher.Publish(invalidMessage);
_messageProccessedEvent.WaitOne(_waitTimeInMiliseconds);
// Assert
using var context = _host.Resolve <AccountManagerDbContext>();
Assert.Empty(context.Accounts);
}
private void OnCreateAccount(CreateAccountMessage message)
{
CreateAccount(message.ForPlayerId, message.InitialBalance, message.Nickname, message.IsNPC)
.Then(newAccount =>
{
_messageRouter.SendResponse(new CreateAccountResponseMessage
{
Account = newAccount
});
});
}
public FakeClient AddAndConnectClient()
{
var client = new FakeClient(m_idProvider.Pop());
m_clients.Add(client);
if (!m_fakeAccountsId.Contains(client.Id))
{
var account = new AccountData()
{
Login = AccountName + client.Id,
PasswordHash = AccountPassword.GetMD5(),
Nickname = AccountName + client.Id,
UserGroupId = FakeUserGroup,
AvailableBreeds = BreedManager.AvailableBreeds,
SecretQuestion = "fakeclient",
SecretAnswer = "fakeclient",
Lang = "fr",
};
var msg = new CreateAccountMessage();
msg.Account = account;
IPCAccessor.Instance.SendRequest(msg, x =>
{
m_fakeAccountsId.Add(client.Id);
client.Connect(IP, Port);
client.Disconnected += OnClientDisconnected;
}, x =>
{
client.Disconnect();
m_clients.Remove(client);
});
}
else
{
client.Connect(IP, Port);
client.Disconnected += OnClientDisconnected;
}
return(client);
}
public async Task Creates_Account()
{
// Arrange
var correlationId = Guid.NewGuid();
var userId = 1;
var accountType = AccountType.Credit;
var message = new CreateAccountMessage(correlationId, userId, accountType);
// Act
await _publisher.Publish(message);
_messageProccessedEvent.WaitOne(_waitTimeInMiliseconds);
// Assert
using var context = _host.Resolve <AccountManagerDbContext>();
const int minimumValidAccountId = 1;
var account = context.Accounts.SingleOrDefault();
Assert.NotNull(account);
Assert.True(account.AccountId >= minimumValidAccountId);
Assert.Equal(userId, account.UserId);
Assert.Equal((int)accountType, (int)account.AccountType);
}
public async Task CreatesAccount()
{
// Arrange
var correlationId = Guid.NewGuid();
var userId = 1;
var accountType = AccountType.Credit;
var expectedCommand = new CreateAccount(correlationId, userId, AccountManager.Domain.Models.AccountType.Credit);
_mockMapper.Setup(x => x.Map <CreateAccount>(It.IsAny <CreateAccountMessage>()))
.Returns(expectedCommand);
_mockMediator.Setup(x => x.Send(It.Is <CreateAccount>(r => r == expectedCommand), It.IsAny <CancellationToken>()))
.Verifiable();
var handler = new CreateAccountMessageHandler(_mockMediator.Object, _mockMapper.Object, _mockLoggerObject);
// Act
var message = new CreateAccountMessage(correlationId, userId, accountType);
await handler.Handle(message);
// Assert
_mockMediator.Verify();
}
private void displayRegisterPage(CreateAccountMessage message) => RegisterPageVisibility = true;
