public void Should_return_NoUserForEmail_error_when_unknown_email_is_supplied()
{
// Given
var email = MakeFake.Email;
var fakeUserService = MakeFake.UserService(new User()
{
Email = email
});
var userTestBrowser = MakeTestErrorBrowser <UserModule>(fakeUserService: fakeUserService);
// When
var result = userTestBrowser.Post("/user/forgot-password/request", with =>
{
with.HttpRequest();
with.FormValue("username", "<valid-username>");
with.FormValue("email", "*****@*****.**");
});
// Then
result.StatusCode.ShouldBe(HttpStatusCode.NotFound);
var payload = result.Body.DeserializeJson <Dictionary <string, object> >();
payload.ContainsItems("ErrorCode", "ErrorMessage").ShouldBe(true);
payload["ErrorCode"].ShouldBe((int)ErrorCode.NoUserForEmail);
}
public void Should_return_NoUserForCredentials_error_when_unknown_user_credentials_are_supplied()
{
// Given
var username = MakeFake.Username;
var password = MakeFake.Password;
User userToLoad = null;
var fakeUserService = MakeFake.UserService(userToLoad);
var userTestBrowser = MakeTestErrorBrowser <UserModule>(fakeUserService: fakeUserService);
// When
var result = userTestBrowser.Post("/user/validate", with =>
{
with.HttpRequest();
with.FormValue("username", username);
with.FormValue("password", password);
});
// Then
result.StatusCode.ShouldBe(HttpStatusCode.NotFound);
var payload = result.Body.DeserializeJson <Dictionary <string, object> >();
payload.ContainsItems("ErrorCode", "ErrorMessage").ShouldBe(true);
payload["ErrorCode"].ShouldBe((int)ErrorCode.NoUserForCredentials);
}
public void Should_return_user_details_when_user_is_retrieved_with_valid_thumbkey()
{
// Given
var thumbkey = MakeFake.Guid;
var username = MakeFake.Username;
var userToLoad = new User {
UserName = username
};
var fakeUserCacheService = MakeFake.UserCacheService(userToLoad);
var userTestBrowser = MakeTestErrorBrowser <UserModule>(fakeUserCacheService: fakeUserCacheService);
// When
var result = userTestBrowser.Post("/user/get", with =>
{
with.HttpRequest();
with.FormValue("thumbkey", thumbkey);
});
// Then
result.StatusCode.ShouldBe(HttpStatusCode.OK);
var payload = result.Body.DeserializeJson <Dictionary <string, object> >();
payload.ContainsItems("User").ShouldBe(true);
var user = payload["User"];
((Dictionary <string, object>)user)["UserName"].ShouldBe(username);
}
public void Should_return_NoUserForThumbkey_error_when_valid_but_unknown_thumbkey_is_supplied()
{
// Given
var unknownThumbkey = MakeFake.Guid;
var fakeUserCacheService = MakeFake.UserCacheService();
A.CallTo(() => fakeUserCacheService.Validate(A <string> .Ignored)).Returns(false);
var userTestBrowser = MakeTestErrorBrowser <UserModule>(fakeUserCacheService: fakeUserCacheService);
// When
var result = userTestBrowser.Post("/user/validate/thumbkey", with =>
{
with.HttpRequest();
with.FormValue("thumbkey", unknownThumbkey);
});
// Then
result.StatusCode.ShouldBe(HttpStatusCode.NotFound);
var payload = result.Body.DeserializeJson <Dictionary <string, object> >();
payload.ContainsItems("ErrorCode", "ErrorMessage").ShouldBe(true);
payload["ErrorCode"].ShouldBe((int)ErrorCode.NoUserForThumbkey);
}
public void Should_return_new_password_when_valid_credentials_are_supplied()
{
// Given
var passwordLength = PasswordService.PasswordCharactersCount;
var token = MakeFake.Guid;
var fakeUserService = MakeFake.UserService(new User());
A.CallTo(() => fakeUserService.ForgotPasswordReset(A <User> .Ignored)).Returns(new string('*', passwordLength));
var fakePasswordService = MakeFake.PasswordService();
A.CallTo(() => fakePasswordService.IsForgotPasswordTokenValid(A <User> .Ignored, A <string> .Ignored)).Returns(true);
var userTestBrowser = MakeTestBrowser <UserModule>(fakeUserService: fakeUserService, fakePasswordService: fakePasswordService);
// When
var result = userTestBrowser.Post("/user/forgot-password/reset", with =>
{
with.HttpRequest();
with.FormValue("username", "<valid-username>");
with.FormValue("token", token);
});
// Then
result.StatusCode.ShouldBe(HttpStatusCode.OK);
var payload = result.Body.DeserializeJson <Dictionary <string, object> >();
payload.ContainsItems("Password").ShouldBe(true);
payload["Password"].ToString().Length.ShouldBe(passwordLength);
}
public void Should_return_existing_applicationid_when_existing_application_is_registered()
{
// Given
var singleUseToken = MakeFake.Guid;
var existingApplicationId = MakeFake.Guid;
var fakeApplicationService = MakeFake.ApplicationService();
A.CallTo(() => fakeApplicationService.AuthoriseSingleUseToken(A <string> .Ignored)).Returns(true);
A.CallTo(() => fakeApplicationService.Transfer(A <string> .Ignored, A <string> .Ignored)).Returns(new Application {
Id = existingApplicationId
});
var applicationTestBrowser = MakeTestBrowser <ApplicationModule>(fakeApplicationService: fakeApplicationService);
// When
var result = applicationTestBrowser.Post("/application/transfer", with =>
{
with.HttpRequest();
with.FormValue("singleUseToken", singleUseToken);
with.FormValue("name", "Existing Application");
with.FormValue("id", existingApplicationId);
});
// Then
result.StatusCode.ShouldBe(HttpStatusCode.OK);
var payload = result.Body.DeserializeJson <Dictionary <string, object> >();
payload.ContainsItems("ApplicationId").ShouldBe(true);
payload["ApplicationId"].ShouldBe(existingApplicationId);
}
public void Should_return_password_when_user_is_created()
{
// Given
var passwordLength = int.Parse(ConfigurationManager.AppSettings["ThumbsUp.PasswordCharacters.Count"]);
User userToLoad = null;
var fakeUserService = MakeFake.UserService(userToLoad);
A.CallTo(() => fakeUserService.CreateUser(A <string> .Ignored, A <string> .Ignored)).Returns(new string('*', passwordLength));
var userTestBrowser = MakeTestBrowser <UserModule>(fakeUserService: fakeUserService);
// When
var result = userTestBrowser.Post("/user/create", with =>
{
with.HttpRequest();
with.FormValue("username", "<username>");
with.FormValue("email", "*****@*****.**");
});
// Then
result.StatusCode.ShouldBe(HttpStatusCode.OK);
var payload = result.Body.DeserializeJson <Dictionary <string, object> >();
payload.ContainsItems("Password").ShouldBe(true);
payload["Password"].ToString().Length.ShouldBe(passwordLength);
}
public void Should_return_InvalidForgotPasswordToken_error_when_unknown_token_supplied()
{
// Given
var token = MakeFake.Guid;
var username = MakeFake.Username;
var userToLoad = new User();
var fakeUserService = MakeFake.UserService(userToLoad);
var fakePasswordService = MakeFake.PasswordService();
A.CallTo(() => fakePasswordService.IsForgotPasswordTokenValid(A <User> .Ignored, A <string> .Ignored)).Returns(false);
var userTestBrowser = MakeTestErrorBrowser <UserModule>(fakeUserService: fakeUserService, fakePasswordService: fakePasswordService);
// When
var result = userTestBrowser.Post("/user/forgot-password/reset", with =>
{
with.HttpRequest();
with.FormValue("username", username);
with.FormValue("token", token);
});
// Then
result.StatusCode.ShouldBe(HttpStatusCode.BadRequest);
var payload = result.Body.DeserializeJson <Dictionary <string, object> >();
payload.ContainsItems("ErrorCode", "ErrorMessage").ShouldBe(true);
payload["ErrorCode"].ShouldBe((int)ErrorCode.InvalidForgotPasswordToken);
}
public void Should_return_NoUserForCredentials_error_when_unknown_password_is_supplied()
{
// Given
var fakeUserService = MakeFake.UserService(new User());
var fakePasswordService = MakeFake.PasswordService();
A.CallTo(() => fakePasswordService.IsPasswordValid(A <User> .Ignored, A <string> .Ignored)).Returns(false);
var userTestBrowser = MakeTestErrorBrowser <UserModule>(fakeUserService: fakeUserService, fakePasswordService: fakePasswordService);
// When
var result = userTestBrowser.Post("/user/reset/password", with =>
{
with.HttpRequest();
with.FormValue("username", "<valid-username>");
with.FormValue("password", "<unknown-password>");
});
// Then
result.StatusCode.ShouldBe(HttpStatusCode.NotFound);
var payload = result.Body.DeserializeJson <Dictionary <string, object> >();
payload.ContainsItems("ErrorCode", "ErrorMessage").ShouldBe(true);
payload["ErrorCode"].ShouldBe((int)ErrorCode.NoUserForCredentials);
}
public void Should_return_new_password_when_valid_credentials_are_supplied()
{
// Given
var fakeToken = MakeFake.Guid;
var email = MakeFake.Email;
var fakeUserService = MakeFake.UserService(new User()
{
Email = email
});
A.CallTo(() => fakeUserService.ForgotPasswordRequest(A <User> .Ignored)).Returns(fakeToken);
var userTestBrowser = MakeTestBrowser <UserModule>(fakeUserService: fakeUserService);
// When
var result = userTestBrowser.Post("/user/forgot-password/request", with =>
{
with.HttpRequest();
with.FormValue("username", "<username>");
with.FormValue("email", email);
});
// Then
result.StatusCode.ShouldBe(HttpStatusCode.OK);
var payload = result.Body.DeserializeJson <Dictionary <string, object> >();
payload.ContainsItems("Token").ShouldBe(true);
payload["Token"].ShouldBe(fakeToken);
}
public void Should_return_thumbkey_when_valid_user_credentials_are_supplied()
{
// Given
var username = MakeFake.Username;
var password = MakeFake.Password;
var thumbKey = MakeFake.Guid;
User userToLoad = new User();
var fakeUserService = MakeFake.UserService(userToLoad);
var fakePasswordService = MakeFake.PasswordService();
A.CallTo(() => fakePasswordService.IsPasswordValid(A <User> .Ignored, A <string> .Ignored)).Returns(true);
var fakeUserCacheService = A.Fake <IUserCacheService>();
A.CallTo(() => fakeUserCacheService.Add(A <User> .Ignored)).Returns(thumbKey);
var userTestBrowser = MakeTestBrowser <UserModule>(fakeUserService: fakeUserService, fakePasswordService: fakePasswordService, fakeUserCacheService: fakeUserCacheService);
// When
var result = userTestBrowser.Post("/user/validate", with =>
{
with.HttpRequest();
with.FormValue("username", username);
with.FormValue("password", password);
});
// Then
result.StatusCode.ShouldBe(HttpStatusCode.OK);
var payload = result.Body.DeserializeJson <Dictionary <string, object> >();
payload.ContainsItems("ThumbKey").ShouldBe(true);
payload["ThumbKey"].ShouldBe(thumbKey);
}
public void Should_return_InvalidParameters_error_when_endpoint_is_hit_with_invalid_params()
{
//Given
var formValues = new Dictionary <string, string>()
{
{ "username", MakeFake.Username }, { "email", MakeFake.InvalidEmail }
};
User userToLoad = null;
var fakeUserService = MakeFake.UserService(userToLoad);
var userTestBrowser = MakeTestErrorBrowser <UserModule>(fakeUserService: fakeUserService);
TestInvalidParams <UserModule>("/user/create", formValues, browser: userTestBrowser);
}
public void Should_return_false_when_applicationid_is_unknown()
{
// Given
var applicationId = MakeFake.Guid;
Application instanceToLoad = null;
var fakeRavenSessionProvider = MakeFake.RavenSessionProvider <Application>(instanceToLoad);
var applicationService = new ApplicationService(fakeRavenSessionProvider);
// When
var isRegistered = applicationService.IsRegistered(applicationId);
// Then
isRegistered.ShouldBe(false);
}
public void Should_return_password_when_valid_username_and_password_are_supplied()
{
// Given
var username = MakeFake.Username;
var email = MakeFake.Email;
var fakePasswordService = MakeFake.PasswordService();
var userService = new UserService(A.Dummy <IRavenSessionProvider>(), fakePasswordService);
// When
var password = userService.CreateUser(username, email);
// Then
password.ShouldNotBe(null);
password.Length.ShouldBe(PasswordService.PasswordCharactersCount);
}
public void Should_return_valid_password_when_valid_user_and_email_are_supplied()
{
// Given
var user = new User();
var fakePasswordService = MakeFake.PasswordService();
var userService = new UserService(A.Dummy <IRavenSessionProvider>(), fakePasswordService);
// When
var password = userService.ForgotPasswordReset(user);
// Then
password.ShouldNotBe(null);
password.Length.ShouldBe(PasswordService.PasswordCharactersCount);
}
public void Should_return_password_when_valid_user_and_password_are_supplied()
{
// Given
var user = new User();
var fakePasswordService = MakeFake.PasswordService();
A.CallTo(() => fakePasswordService.IsPasswordValid(A <User> .Ignored, A <string> .Ignored)).Returns(true);
var userService = new UserService(A.Dummy <IRavenSessionProvider>(), fakePasswordService);
// When
var password = userService.ResetPassword(user);
// Then
password.ShouldNotBe(null);
password.Length.ShouldBe(PasswordService.PasswordCharactersCount);
}
public void Should_return_OK_when_unused_username_is_supplied()
{
// Given
User userToLoad = null;
var fakeUserService = MakeFake.UserService(userToLoad);
var userTestBrowser = MakeTestBrowser <UserModule>(fakeUserService: fakeUserService);
// When
var result = userTestBrowser.Post("/user/validate/name", with =>
{
with.HttpRequest();
with.FormValue("username", "<valid-username>");
});
// Then
result.StatusCode.ShouldBe(HttpStatusCode.OK);
}
public void Should_return_new_Application_when_new_application_is_registered()
{
// Given
var applicationName = MakeFake.Name;
var instanceToLoad = new Application()
{
Name = applicationName
};
var fakeRavenSessionProvider = MakeFake.RavenSessionProvider <Application>(instanceToLoad);
var applicationService = new ApplicationService(fakeRavenSessionProvider);
// When
var application = applicationService.Register(applicationName);
// Then
application.Name.ShouldBe(applicationName);
application.Id.IsGuid().ShouldBe(true);
}
public void Should_return_application_when_known_applicationid_is_supplied()
{
// Given
var applicationId = MakeFake.Guid;
var applicationName = MakeFake.Name;
var instanceToLoad = new Application()
{
Id = applicationId, Name = applicationName
};
var fakeRavenSessionProvider = MakeFake.RavenSessionProvider <Application>(instanceToLoad);
var applicationService = new ApplicationService(fakeRavenSessionProvider);
// When
var application = applicationService.Get(applicationId);
// Then
application.Name.ShouldBe(applicationName);
application.Id.ShouldBe(applicationId);
}
public void Should_return_new_Application_when_application_is_registered_with_existing_applicationid()
{
// Given
var applicationName = MakeFake.Name;
var applicationId = MakeFake.Guid;
var instanceToLoad = new Application()
{
Id = applicationId, Name = applicationName
};
var fakeRavenSessionProvider = MakeFake.RavenSessionProvider <Application>(instanceToLoad);
var applicationService = new ApplicationService(fakeRavenSessionProvider);
// When
var application = applicationService.Transfer(applicationName, applicationId);
// Then
application.Name.ShouldBe(applicationName);
application.Id.ShouldBe(applicationId);
}
public void Should_return_OK_when_valid_thumbkey_is_supplied()
{
// Given
var validThumbkey = MakeFake.Guid;
var fakeUserCacheService = MakeFake.UserCacheService();
A.CallTo(() => fakeUserCacheService.Validate(A <string> .Ignored)).Returns(true);
var userTestBrowser = MakeTestBrowser <UserModule>(fakeUserCacheService: fakeUserCacheService);
// When
var result = userTestBrowser.Post("/user/validate/thumbkey", with =>
{
with.HttpRequest();
with.FormValue("thumbkey", validThumbkey);
});
// Then
result.StatusCode.ShouldBe(HttpStatusCode.OK);
}
public void Should_return_UserNameTaken_error_when_existing_username_is_supplied()
{
// Given
User userToLoad = new User();
var fakeUserService = MakeFake.UserService(userToLoad);
var userTestBrowser = MakeTestErrorBrowser <UserModule>(fakeUserService: fakeUserService);
// When
var result = userTestBrowser.Post("/user/validate/name", with =>
{
with.HttpRequest();
with.FormValue("username", "<existing-username>");
});
// Then
result.StatusCode.ShouldBe(HttpStatusCode.BadRequest);
var payload = result.Body.DeserializeJson <Dictionary <string, object> >();
payload.ContainsItems("ErrorCode", "ErrorMessage").ShouldBe(true);
payload["ErrorCode"].ShouldBe((int)ErrorCode.UserNameTaken);
}
public void Should_return_NoUserForThumbkey_error_when_user_is_retrieved_with_valid_but_unknown_thumbkey()
{
// Given
var unknownThumbkey = MakeFake.Guid;
User userToLoad = null;
var fakeUserCacheService = MakeFake.UserCacheService(userToLoad);
var userTestBrowser = MakeTestErrorBrowser <UserModule>(fakeUserCacheService: fakeUserCacheService);
// When
var result = userTestBrowser.Post("/user/get", with =>
{
with.HttpRequest();
with.FormValue("thumbkey", unknownThumbkey);
});
// Then
result.StatusCode.ShouldBe(HttpStatusCode.NotFound);
var payload = result.Body.DeserializeJson <Dictionary <string, object> >();
payload.ContainsItems("ErrorCode", "ErrorMessage").ShouldBe(true);
payload["ErrorCode"].ShouldBe((int)ErrorCode.NoUserForThumbkey);
}
