public async Task Post_ReturnsAnHttp400BadRequestResponseWhenThereIsAnIssueRegistering()
{
var registerNewUserResult = new RegisterNewUserResult
{
Result = IdentityResult.Failed("some error")
};
_autoMocker.Get <IUserRegisterer>().Expect(mock => mock.RegisterUser(Arg <NewUser> .Is.Anything)).Return(Task.FromResult(registerNewUserResult));
var newUserMessage = new NewUserMessage
{
EmailAddress = "*****@*****.**",
UserName = "******",
Password = "******"
};
var actualResponse = await _autoMocker.ClassUnderTest.RegisterNewUser(newUserMessage);
Assert.That(actualResponse.Content, Is.TypeOf(typeof(ObjectContent <HttpError>)));
var content = actualResponse.Content as ObjectContent <HttpError>;
var httpError = content.Value as HttpError;
Assert.That(actualResponse.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
Assert.That(httpError.Message, Is.EqualTo(registerNewUserResult.Result.Errors.First()));
}
public static async Task CreateMessage(IMessagePublisher publisher)
{
var message = new NewUserMessage()
{
Id = Guid.NewGuid(),
Email = "*****@*****.**"
};
await publisher.PublishAsync(message);
}
private void OnOpponentArrived(NewUserMessage opponentInfo)
{
this.Scene.QueueAction(() =>
{
var opponent = new RemoteCharacter(client, opponentInfo.NewUserId);
opponent.ResizeTo(0, 0);
opponent.Tags.Add("enemy");
this.Scene.Add(opponent);
opponents.Add(opponent);
});
}
public async Task Post_ReturnsANewlyRegisteredUserMessage()
{
var newUserMessage = new NewUserMessage
{
UniqueDeviceId = "some unique device id"
};
var expectedNewlyRegisteredUserMessage = new NewlyRegisteredUserMessage
{
UserId = "user id",
PlayerId = 2,
PlayerName = "player name",
GamingGroupId = 3,
GamingGroupName = "gaming group name"
};
var registerNewUserResult = new RegisterNewUserResult
{
Result = IdentityResult.Success,
NewlyRegisteredUser = new NewlyRegisteredUser
{
UserId = "user id",
PlayerId = 2,
PlayerName = "player name",
GamingGroupId = 3,
GamingGroupName = "gaming group name"
}
};
_autoMocker.Get <IUserRegisterer>().Expect(mock => mock.RegisterUser(Arg <NewUser> .Is.Anything)).Return(Task.FromResult(registerNewUserResult));
string authenticationTokenString = "some auth token string";
DateTime authTokenExpiration = new DateTime();
var expectedAuthToken = new AuthToken(authenticationTokenString, authTokenExpiration);
_autoMocker.Get <IAuthTokenGenerator>().Expect(mock => mock.GenerateAuthToken(
expectedNewlyRegisteredUserMessage.UserId,
newUserMessage.UniqueDeviceId)).Return(expectedAuthToken);
var actualResponse = await _autoMocker.ClassUnderTest.RegisterNewUser(newUserMessage);
Assert.That(actualResponse.Content, Is.TypeOf(typeof(ObjectContent <NewlyRegisteredUserMessage>)));
var content = actualResponse.Content as ObjectContent <NewlyRegisteredUserMessage>;
var actualNewlyRegisteredUserMessage = content.Value as NewlyRegisteredUserMessage;
Assert.That(actualNewlyRegisteredUserMessage.UserId, Is.EqualTo(expectedNewlyRegisteredUserMessage.UserId));
Assert.That(actualNewlyRegisteredUserMessage.PlayerId, Is.EqualTo(expectedNewlyRegisteredUserMessage.PlayerId));
Assert.That(actualNewlyRegisteredUserMessage.PlayerName, Is.EqualTo(expectedNewlyRegisteredUserMessage.PlayerName));
Assert.That(actualNewlyRegisteredUserMessage.GamingGroupId, Is.EqualTo(expectedNewlyRegisteredUserMessage.GamingGroupId));
Assert.That(actualNewlyRegisteredUserMessage.GamingGroupName, Is.EqualTo(expectedNewlyRegisteredUserMessage.GamingGroupName));
Assert.That(actualNewlyRegisteredUserMessage.AuthenticationToken, Is.EqualTo(expectedAuthToken.AuthenticationTokenString));
Assert.That(actualNewlyRegisteredUserMessage.AuthenticationTokenExpirationDateTime, Is.EqualTo(expectedAuthToken.AuthenticationTokenExpirationDateTime));
}
public async Task Run([TimerTrigger("00:00:10", UseMonitor = true)] TimerInfo myTimer, ILogger log)
{
if (myTimer.IsPastDue)
{
log.LogInformation("Timer is running late!");
}
log.LogInformation($"C# Timer trigger function executed at: {DateTime.Now}");
var message = new NewUserMessage()
{
Id = Guid.NewGuid(),
Email = "timertest@simplemessagebus"
};
await _publisher.PublishAsync(message);
}
public virtual async Task <HttpResponseMessage> RegisterNewUser(NewUserMessage newUserMessage)
{
NewUser newUser = Mapper.Map <NewUserMessage, NewUser>(newUserMessage);
RegisterNewUserResult registerNewUserResult = await this.userRegisterer.RegisterUser(newUser);
if (registerNewUserResult.Result.Succeeded)
{
string authToken = authTokenGenerator.GenerateAuthToken(registerNewUserResult.NewlyRegisteredUser.UserId);
NewlyRegisteredUserMessage newlyRegisteredUserMessage = Mapper.Map <NewlyRegisteredUser, NewlyRegisteredUserMessage>(registerNewUserResult.NewlyRegisteredUser);
newlyRegisteredUserMessage.AuthenticationToken = authToken;
return(Request.CreateResponse(HttpStatusCode.OK, newlyRegisteredUserMessage));
}
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, registerNewUserResult.Result.Errors.First()));
}
public async Task AddUser(NewUserMessage message)
{
var salt = GenerateSalt();
var hash = HashPassword(message.Password, salt);
var user = new User
{
Id = message.Id,
Email = message.Email,
Username = message.Username,
Hash = hash,
Salt = salt,
Role = UserRole.User
};
_authenticationContext.Add(user);
await _authenticationContext.SaveChangesAsync();
}
public virtual async Task <HttpResponseMessage> RegisterNewUser(NewUserMessage newUserMessage)
{
var newUser = Mapper.Map <NewUserMessage, NewUser>(newUserMessage);
var registerNewUserResult = await _userRegisterer.RegisterUser(newUser);
if (registerNewUserResult.Result.Succeeded)
{
var authToken = _authTokenGenerator.GenerateAuthToken(registerNewUserResult.NewlyRegisteredUser.UserId, newUserMessage.UniqueDeviceId);
var newlyRegisteredUserMessage = Mapper.Map <NewlyRegisteredUser, NewlyRegisteredUserMessage>(registerNewUserResult.NewlyRegisteredUser);
newlyRegisteredUserMessage.AuthenticationToken = authToken.AuthenticationTokenString;
newlyRegisteredUserMessage.AuthenticationTokenExpirationDateTime =
authToken.AuthenticationTokenExpirationDateTime;
return(Request.CreateResponse(HttpStatusCode.OK, newlyRegisteredUserMessage));
}
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, registerNewUserResult.Result.Errors.First()));
}
public async Task Post_RegistersTheGivenUser()
{
_autoMocker.Get <IUserRegisterer>().Expect(mock => mock.RegisterUser(Arg <NewUser> .Is.Anything)).Return(Task.FromResult(new RegisterNewUserResult {
Result = IdentityResult.Failed("some failure")
}));
var newUserMessage = new NewUserMessage
{
EmailAddress = "*****@*****.**",
UserName = "******",
Password = "******"
};
await _autoMocker.ClassUnderTest.RegisterNewUser(newUserMessage);
_autoMocker.Get <IUserRegisterer>().AssertWasCalled(mock => mock.RegisterUser(
Arg <NewUser> .Matches(user => user.EmailAddress == newUserMessage.EmailAddress &&
user.UserName == newUserMessage.UserName &&
user.Password == newUserMessage.Password)));
}
public void HandleMessage(NewUserMessage msg, object extra)
{
Client client = (Client)extra;
Console.WriteLine("HandleNewUserMessage");
NewUserResultMessage m;
LoginMessage login;
login.UserName = msg.UserName;
login.Password = msg.Password;
if (DataLayer.CreateNewLogin(msg.UserName, msg.Password))
{
InitiateLogin(msg.UserName, client);
}
else
{
m.success = false;
GalaxyServer.AddToSendQueue(client, m);
}
}
protected virtual void OnNewUserMessage(NewUserMessageEventArgs e)
{
NewUserMessage?.Invoke(this, e);
}
/// <summary>
///
/// </summary>
/// <param name="newUserMessage"></param>
/// <returns></returns>
internal async Task <bool> SendNewUserEmailAsync(NewUserMessage newUserMessage)
{
//TODO: Send email here.
Console.WriteLine("The message has been processed.");
return(await Task.FromResult(true));
}
