public void ApplyForTier3_IfCallIsValid_Tier3StatusWillBeChangedToPreVerified()
{
UserValidationEssentials essentials = AccessControlUtility.RegisterAndLogin("user", "*****@*****.**", "123", _applicationContext);
TierController tierController = _applicationContext["TierController"] as TierController;
tierController.Request = new HttpRequestMessage(HttpMethod.Post, "");
tierController.Request.Headers.Add("Auth", essentials.ApiKey);
tierController.GetVerifyForTier1(new Tier1Param("User", DateTime.Now.AddDays(-10).ToShortDateString(), "656667"));
tierController.GetVerifyForTier2(new Tier2Param("asd", "", "", "punjab", "Isb", "123"));
var content = new MultipartFormDataContent();
content.Add(new StreamContent(new FileStream(@"C:\Logs\Logs.txt", FileMode.Open)));
tierController.Request.Content = content;
tierController.GetVerifyForTier3(new Tier3Param("asd", "123", "bill", "logs.txt"));
ManualResetEvent resetEvent = new ManualResetEvent(false);
resetEvent.WaitOne(15000);
IHttpActionResult httpActionResult = tierController.GetTierStatuses();
OkNegotiatedContentResult <UserTierStatusRepresentation[]> statuses = (OkNegotiatedContentResult <UserTierStatusRepresentation[]>)httpActionResult;
Assert.AreEqual(statuses.Content.Length, 5);
Assert.AreEqual(statuses.Content[0].Status, Status.Verified.ToString());
Assert.AreEqual(statuses.Content[1].Status, Status.Preverified.ToString());
Assert.AreEqual(statuses.Content[2].Status, Status.Preverified.ToString());
Assert.AreEqual(statuses.Content[3].Status, Status.Preverified.ToString());
httpActionResult = tierController.GetTier3Details();
OkNegotiatedContentResult <Tier3Details> detials = (OkNegotiatedContentResult <Tier3Details>)httpActionResult;
Assert.AreEqual(detials.Content.Nin, "123");
Assert.AreEqual(detials.Content.Ssn, "asd");
}
public void LoginSuccessfulTest_TestsifTheLoginisSuccessfulAfterProvidingValidCredentials_VerifiesThroughThereturnedResult()
{
ILoginApplicationService loginApplicationService = (ILoginApplicationService)_applicationContext["LoginApplicationService"];
Assert.IsNotNull(loginApplicationService);
IRegistrationApplicationService registrationService = (IRegistrationApplicationService)_applicationContext["RegistrationApplicationService"];
string username = "******";
string activationKey = registrationService.CreateAccount(new SignupUserCommand(
"*****@*****.**", username, "alice", "Wonderland", TimeZone.CurrentTimeZone, ""));
Assert.IsNotNull(activationKey);
IUserApplicationService userApplicationService = (IUserApplicationService)_applicationContext["UserApplicationService"];
bool accountActivated = userApplicationService.ActivateAccount(new ActivationCommand(activationKey, "Bob", "alice"));
Assert.IsTrue(accountActivated);
UserValidationEssentials userValidationEssentials = loginApplicationService.Login(new LoginCommand("Bob", "alice"));
Assert.IsNotNull(userValidationEssentials);
Assert.IsNotNull(userValidationEssentials.ApiKey);
Assert.IsNotNull(userValidationEssentials.SecretKey);
Assert.IsNotNull(userValidationEssentials.SessionLogoutTime);
}
public void LoginSuccessfulTest_ChecksIfTheSecurityKeysAreProperlyReturnedWhileLoggingIn_VerifiesTheReturnedKeysToConfirm()
{
IUserRepository userRepository = new MockUserRepository();
IIdentityAccessPersistenceRepository persistRepository = new MockPersistenceRepository(false);
ISecurityKeysApplicationService securityKeysApplicationService = new SecurityKeysApplicationService(new SecurityKeysGenerationService(),
persistRepository, null, null);
IPasswordEncryptionService passwordEncryptionService = new PasswordEncryptionService();
IMfaAuthorizationService mockMfaAuthorizationService = new MockMfaAuthorizationService();
ILoginApplicationService loginApplicationService = new LoginApplicationService(userRepository, passwordEncryptionService,
securityKeysApplicationService, new MockPersistenceRepository(false), mockMfaAuthorizationService);
string enteredPassword = "******";
User user = new User("*****@*****.**", "brucewayne", passwordEncryptionService.EncryptPassword(enteredPassword),
"Ninja County", TimeZone.CurrentTimeZone, "", "");
user.AutoLogout = new TimeSpan(0, 0, 0, 60);
user.IsActivationKeyUsed = new IsActivationKeyUsed(true);
// Add this user to the MockUserRepository
(userRepository as MockUserRepository).AddUser(user);
UserValidationEssentials userValidationEssentials = loginApplicationService.Login(
new LoginCommand("brucewayne", enteredPassword));
Assert.IsNotNull(userValidationEssentials);
Assert.IsNotNull(userValidationEssentials.ApiKey);
Assert.IsNotNull(userValidationEssentials.SecretKey);
Assert.AreEqual(userValidationEssentials.SessionLogoutTime, user.AutoLogout);
}
public void ChangePasswordSuccessTest_ChecksIfThePasswordIsChangedSuccessfully_VerifiesThroughTheReturnedValue()
{
IUserApplicationService userApplicationService = (IUserApplicationService)_applicationContext["UserApplicationService"];
IRegistrationApplicationService registrationApplicationService = (IRegistrationApplicationService)_applicationContext["RegistrationApplicationService"];
ILoginApplicationService loginApplicationService = (ILoginApplicationService)_applicationContext["LoginApplicationService"];
IUserRepository userRepository = (IUserRepository)_applicationContext["UserRepository"];
string username = "******";
string activatioNKey = registrationApplicationService.CreateAccount(new SignupUserCommand("*****@*****.**", "linkinpark", "burnitdown", "USA", TimeZone.CurrentTimeZone, ""));
ManualResetEvent manualResetEvent = new ManualResetEvent(false);
userApplicationService.ActivateAccount(new ActivationCommand(activatioNKey, username, "burnitdown"));
manualResetEvent.WaitOne(6000);
UserValidationEssentials validationEssentials = loginApplicationService.Login(new LoginCommand(username, "burnitdown"));
User userBeforePasswordChange = userRepository.GetUserByUserName("linkinpark");
string passwordBeforeChange = userBeforePasswordChange.Password;
ChangePasswordResponse changePasswordResponse = userApplicationService.ChangePassword(new ChangePasswordCommand(
validationEssentials.ApiKey, "burnitdown", "burnitdowntwice"));
Assert.IsTrue(changePasswordResponse.ChangeSuccessful);
User userAfterPasswordChange = userRepository.GetUserByUserName("linkinpark");
string passwordAfterChange = userAfterPasswordChange.Password;
// Verify the old and new password do not match
Assert.AreNotEqual(passwordBeforeChange, passwordAfterChange);
}
public void ActivateAccountFailThenSeccussfulTest_ChecksIfUserCannotLoginUntilAccountIsNotActivatedAndTriesToActivateAgainAndThenLogsIn_VerifiesByExpectingExceptionAndReturnedValue()
{
IUserApplicationService userApplicationService = (IUserApplicationService)_applicationContext["UserApplicationService"];
IRegistrationApplicationService registrationApplicationService =
(IRegistrationApplicationService)_applicationContext["RegistrationApplicationService"];
IUserRepository userRepository = (IUserRepository)_applicationContext["UserRepository"];
ILoginApplicationService loginApplicationService = (ILoginApplicationService)_applicationContext["LoginApplicationService"];
ISecurityKeysRepository securityKeysRepository = (ISecurityKeysRepository)_applicationContext["SecurityKeysPairRepository"];
string username = "******";
string email = "*****@*****.**";
string password = "******";
string activationKey = registrationApplicationService.CreateAccount(new SignupUserCommand(email, username, password, "USA", TimeZone.CurrentTimeZone, ""));
loginApplicationService.Login(new LoginCommand(username, password));
bool accountActivated = userApplicationService.ActivateAccount(new ActivationCommand(activationKey, username, password));
Assert.IsTrue(accountActivated);
User userByUserName = userRepository.GetUserByUserName(username);
Assert.IsNotNull(userByUserName);
Assert.IsTrue(userByUserName.IsActivationKeyUsed.Value);
UserValidationEssentials userValidationEssentials = loginApplicationService.Login(new LoginCommand(username, password));
Assert.IsNotNull(userValidationEssentials);
SecurityKeysPair securityKeysPair = securityKeysRepository.GetByApiKey(userValidationEssentials.ApiKey);
Assert.IsNotNull(securityKeysPair);
User receivedUser = userRepository.GetUserByUserName(username);
Assert.IsTrue(receivedUser.IsActivationKeyUsed.Value);
}
public void ChangePasswordFailDueToInvalidApiKeyTest_ChecksIfExceptionIsRaisedAfterWrongApiKeyIsGiven_VerifiesByExpectingException()
{
IUserApplicationService userApplicationService = (IUserApplicationService)_applicationContext["UserApplicationService"];
IRegistrationApplicationService registrationApplicationService =
(IRegistrationApplicationService)_applicationContext["RegistrationApplicationService"];
ILoginApplicationService loginApplicationService =
(ILoginApplicationService)_applicationContext["LoginApplicationService"];
IUserRepository userRepository = (IUserRepository)_applicationContext["UserRepository"];
string username = "******";
string activationKey = registrationApplicationService.CreateAccount(new SignupUserCommand("*****@*****.**", "linkinpark", "burnitdown", "USA", TimeZone.CurrentTimeZone, ""));
ManualResetEvent manualResetEvent = new ManualResetEvent(false);
userApplicationService.ActivateAccount(new ActivationCommand(activationKey, username, "burnitdown"));
manualResetEvent.WaitOne(6000);
UserValidationEssentials validationEssentials = loginApplicationService.Login(new LoginCommand(username, "burnitdown"));
User userBeforePasswordChange = userRepository.GetUserByUserName("linkinpark");
string passwordBeforeChange = userBeforePasswordChange.Password;
UserValidationEssentials validationEssentials2 = new UserValidationEssentials(new Tuple <ApiKey, SecretKey, DateTime>(
new ApiKey(validationEssentials.ApiKey + "1"), new SecretKey(validationEssentials.SecretKey), DateTime.Now), validationEssentials.SessionLogoutTime);
// Give the wrong API Key
userApplicationService.ChangePassword(new ChangePasswordCommand(validationEssentials.ApiKey + 1, "burnitdown", "burnitdowntwice"));
User userAfterPasswordChange = userRepository.GetUserByUserName("linkinpark");
string passwordAfterChange = userAfterPasswordChange.Password;
// Verify the old and new password do not match
Assert.AreEqual(passwordBeforeChange, passwordAfterChange);
}
public void ChangePasswordFailDueWrongOldPassword_ChecksIfExceptionIsRaisedAfterCheckingOldPassword_VerifiesByExpectingException()
{
IUserApplicationService userApplicationService = (IUserApplicationService)_applicationContext["UserApplicationService"];
IRegistrationApplicationService registrationApplicationService =
(IRegistrationApplicationService)_applicationContext["RegistrationApplicationService"];
ILoginApplicationService loginApplicationService =
(ILoginApplicationService)_applicationContext["LoginApplicationService"];
IIdentityAccessPersistenceRepository persistenceRepository =
(IIdentityAccessPersistenceRepository)_applicationContext["IdentityAccessPersistenceRepository"];
IUserRepository userRepository = (IUserRepository)_applicationContext["UserRepository"];
string username = "******";
string activationKey = registrationApplicationService.CreateAccount(new SignupUserCommand("*****@*****.**", "linkinpark", "burnitdown", "USA", TimeZone.CurrentTimeZone, ""));
ManualResetEvent manualResetEvent = new ManualResetEvent(false);
userApplicationService.ActivateAccount(new ActivationCommand(activationKey, username, "burnitdown"));
manualResetEvent.WaitOne(6000);
UserValidationEssentials validationEssentials = loginApplicationService.Login(new LoginCommand(username, "burnitdown"));
User userBeforePasswordChange = userRepository.GetUserByUserName("linkinpark");
string passwordBeforeChange = userBeforePasswordChange.Password;
User userByUserName = userRepository.GetUserByUserName(username);
// When the User's Logout time and ValidationEssentials Logout time won't match, test will fail
userByUserName.AutoLogout = new TimeSpan(0, 0, 0, 0, 1);
persistenceRepository.SaveUpdate(userByUserName);
// Give the wrong API Key
userApplicationService.ChangePassword(new ChangePasswordCommand(validationEssentials.ApiKey, "123", "burnitdowntwice"));
User userAfterPasswordChange = userRepository.GetUserByUserName("linkinpark");
string passwordAfterChange = userAfterPasswordChange.Password;
// Verify the old and new password do not match
// Assert.AreEqual(passwordBeforeChange, passwordAfterChange);
}
public void UpdateUsergeneratedSystemKey_IfNoPermissionIsAssigned_InvalidOperationExceptionWillBeThrown()
{
UserValidationEssentials essentials = AccessControlUtility.RegisterAndLogin("user", "*****@*****.**", "123", _applicationContext);
SecurityKeyPairController securityKeyPairController =
_applicationContext["SecurityKeyPairController"] as SecurityKeyPairController;
IPermissionRepository permissionRepository = _applicationContext["PermissionRespository"] as IPermissionRepository;
IList <Permission> permissions = permissionRepository.GetAllPermissions();
List <string> securityKeyPermissions = new List <string>();
for (int i = 0; i < permissions.Count; i++)
{
securityKeyPermissions.Add(permissions[i].PermissionId);
}
securityKeyPairController.Request = new HttpRequestMessage(HttpMethod.Post, "");
securityKeyPairController.Request.Headers.Add("Auth", essentials.ApiKey);
CreateUserGeneratedSecurityKeyPair command = new CreateUserGeneratedSecurityKeyPair(securityKeyPermissions, "", "", "", false, false, false, "#1");
IHttpActionResult httpActionResult = securityKeyPairController.CreateSecurityKey(command);
OkNegotiatedContentResult <SecurityKeyPair> result = (OkNegotiatedContentResult <SecurityKeyPair>)httpActionResult;
Assert.IsNotNullOrEmpty(result.Content.ApiKey);
Assert.IsNotNullOrEmpty(result.Content.SecretKey);
httpActionResult = securityKeyPairController.GetUserSecurityKeys();
OkNegotiatedContentResult <object> result1 = (OkNegotiatedContentResult <object>)httpActionResult;
List <object> objectPairs = result1.Content as List <object>;
Assert.IsNotNull(objectPairs);
List <SecurityKeyPairList> pairs = new List <SecurityKeyPairList>();
foreach (object objectPair in objectPairs)
{
pairs.Add(objectPair as SecurityKeyPairList);
}
Assert.AreEqual(pairs.Count, 1);
Assert.AreEqual(pairs[0].KeyDescription, "#1");
Assert.IsNull(pairs[0].ExpirationDate);
httpActionResult = securityKeyPairController.GetSecurityKeyDetail("#1");
OkNegotiatedContentResult <SecurityKeyRepresentation> securityKey = (OkNegotiatedContentResult <SecurityKeyRepresentation>)httpActionResult;
Assert.AreEqual(securityKey.Content.KeyDescritpion, "#1");
Assert.AreEqual(securityKey.Content.EnableEndDate, false);
Assert.AreEqual(securityKey.Content.EnableExpirationDate, false);
Assert.AreEqual(securityKey.Content.EnableStartDate, false);
List <SecurityKeyPermissionsRepresentation> permissionsRepresentations = new List <SecurityKeyPermissionsRepresentation>();
for (int i = 0; i < securityKeyPermissions.Count; i++)
{
permissionsRepresentations.Add(new SecurityKeyPermissionsRepresentation(false, new Permission(securityKeyPermissions[i], "")));
}
UpdateUserGeneratedSecurityKeyPair updateKeyPair =
new UpdateUserGeneratedSecurityKeyPair(securityKey.Content.ApiKey, "#2", true, false, false, "",
DateTime.Today.AddDays(-2).ToString(), permissionsRepresentations.ToArray(), "");
httpActionResult = securityKeyPairController.UpdateSecurityKey(updateKeyPair);
BadRequestErrorMessageResult errorMessage = (BadRequestErrorMessageResult)httpActionResult;
Assert.AreEqual(errorMessage.Message, "Please assign atleast one permission.");
}
public void ApplyForTier2_IfCallIsValid_Tier2StatusWillBeChangedToPreVerified()
{
UserValidationEssentials essentials = AccessControlUtility.RegisterAndLogin("user", "*****@*****.**", "123", _applicationContext);
TierController tierController = _applicationContext["TierController"] as TierController;
tierController.Request = new HttpRequestMessage(HttpMethod.Post, "");
tierController.Request.Headers.Add("Auth", essentials.ApiKey);
tierController.GetVerifyForTier1(new Tier1Param("User", DateTime.Now.AddDays(-10).ToShortDateString(), "656667"));
tierController.GetVerifyForTier2(new Tier2Param("asd", "", "", "punjab", "Isb", "123"));
IHttpActionResult httpActionResult = tierController.GetTierStatuses();
OkNegotiatedContentResult <UserTierStatusRepresentation[]> statuses = (OkNegotiatedContentResult <UserTierStatusRepresentation[]>)httpActionResult;
Assert.AreEqual(statuses.Content.Length, 5);
Assert.AreEqual(statuses.Content[0].Status, Status.Verified.ToString());
Assert.AreEqual(statuses.Content[1].Status, Status.Preverified.ToString());
Assert.AreEqual(statuses.Content[2].Status, Status.Preverified.ToString());
httpActionResult = tierController.GetTier2Details();
OkNegotiatedContentResult <Tier2Details> detials = (OkNegotiatedContentResult <Tier2Details>)httpActionResult;
Assert.AreEqual(detials.Content.Country, "Pakistan");
Assert.AreEqual(detials.Content.AddressLine1, "asd");
Assert.AreEqual(detials.Content.State, "punjab");
Assert.AreEqual(detials.Content.City, "Isb");
Assert.AreEqual(detials.Content.ZipCode, "123");
}
public void ChangeSettingsSuccessfultTest_ChecksIfTheSettingsForUserChangeSuccessfulyAndValuesInDatabaseChange_VerifiesByReturnedValueAndDatabaseQuerying()
{
IUserApplicationService userApplicationService = (IUserApplicationService)_applicationContext["UserApplicationService"];
IRegistrationApplicationService registrationApplicationService =
(IRegistrationApplicationService)_applicationContext["RegistrationApplicationService"];
IUserRepository userRepository = (IUserRepository)_applicationContext["UserRepository"];
IPasswordEncryptionService passwordEncryption =
(IPasswordEncryptionService)_applicationContext["PasswordEncryptionService"];
string username = "******";
string email = "*****@*****.**";
string password = "******";
string activationKey = registrationApplicationService.CreateAccount(new SignupUserCommand(email, username, password, "USA", TimeZone.CurrentTimeZone, ""));
User userByUserName = userRepository.GetUserByUserName(username);
Assert.IsNotNull(userByUserName);
Assert.AreEqual(email, userByUserName.Email);
Assert.IsTrue(passwordEncryption.VerifyPassword(password, userByUserName.Password));
Assert.AreEqual(Language.English, userByUserName.Language);
Assert.AreEqual(TimeZone.CurrentTimeZone.StandardName, userByUserName.TimeZone.StandardName);
Assert.AreEqual(new TimeSpan(0, 0, 10, 0), userByUserName.AutoLogout);
Assert.IsNull(userByUserName.ForgotPasswordCode);
Assert.IsNull(userByUserName.ForgotPasswordCodeExpiration);
Assert.AreEqual(0, userByUserName.ForgottenPasswordCodes.Length);
bool accountActivated = userApplicationService.ActivateAccount(new ActivationCommand(activationKey, username, password));
Assert.IsTrue(accountActivated);
ManualResetEvent manualResetEvent = new ManualResetEvent(false);
manualResetEvent.WaitOne(6000);
ILoginApplicationService loginApplicationService = (ILoginApplicationService)_applicationContext["LoginApplicationService"];
UserValidationEssentials userValidationEssentials = loginApplicationService.Login(new LoginCommand(username, password));
Assert.IsNotNull(userValidationEssentials);
Assert.IsNotNull(userValidationEssentials.ApiKey);
Assert.IsNotNull(userValidationEssentials.SecretKey);
Assert.IsNotNull(userValidationEssentials.SessionLogoutTime);
string newEmail = "*****@*****.**";
var resetPasswordReponse = userApplicationService.ChangeSettings(new ChangeSettingsCommand(
userValidationEssentials.ApiKey, newEmail, "", Language.Arabic, TimeZone.CurrentTimeZone, false, 67));
Assert.IsTrue(resetPasswordReponse.ChangeSuccessful);
userByUserName = userRepository.GetUserByUserName(username);
Assert.IsNotNull(userByUserName);
Assert.AreEqual(newEmail, userByUserName.Email);
Assert.IsTrue(passwordEncryption.VerifyPassword(password, userByUserName.Password));
Assert.AreEqual(Language.Arabic, userByUserName.Language);
Assert.AreEqual(TimeZone.CurrentTimeZone.StandardName, userByUserName.TimeZone.StandardName);
Assert.AreEqual(new TimeSpan(0, 0, 67, 0), userByUserName.AutoLogout);
Assert.IsNull(userByUserName.ForgotPasswordCode);
Assert.IsNull(userByUserName.ForgotPasswordCodeExpiration);
Assert.AreEqual(0, userByUserName.ForgottenPasswordCodes.Length);
}
public void LoginMfaAuthorizationTest_ChecksIfMfaAuthorizationIsDoneSuccessfully_VerifiesThroughReturnValue()
{
ILoginApplicationService loginApplicationService = (ILoginApplicationService)_applicationContext["LoginApplicationService"];
ILogoutApplicationService logoutApplicationService = (ILogoutApplicationService)_applicationContext["LogoutApplicationService"];
IMfaSubscriptionRepository mfaSubscriptionRepository = (IMfaSubscriptionRepository)_applicationContext["MfaSubscriptionRepository"];
IMfaCodeGenerationService mfaCodeGenerationService = (IMfaCodeGenerationService)ContextRegistry.GetContext()["MfaCodeGenerationService"];
Assert.IsNotNull(loginApplicationService);
IRegistrationApplicationService registrationService = (IRegistrationApplicationService)_applicationContext["RegistrationApplicationService"];
string username = "******";
string activationKey = registrationService.CreateAccount(new SignupUserCommand(
"*****@*****.**", username, "alice", "Wonderland", TimeZone.CurrentTimeZone, ""));
Assert.IsNotNull(activationKey);
IUserApplicationService userApplicationService = (IUserApplicationService)_applicationContext["UserApplicationService"];
bool accountActivated = userApplicationService.ActivateAccount(new ActivationCommand(activationKey, "Bob", "alice"));
Assert.IsTrue(accountActivated);
UserValidationEssentials userValidationEssentials = loginApplicationService.Login(new LoginCommand("Bob", "alice"));
Assert.IsNotNull(userValidationEssentials);
Assert.IsNotNull(userValidationEssentials.ApiKey);
Assert.IsNotNull(userValidationEssentials.SecretKey);
Assert.IsNotNull(userValidationEssentials.SessionLogoutTime);
IList <MfaSubscription> allSubscriptions = mfaSubscriptionRepository.GetAllSubscriptions();
List <Tuple <string, string, bool> > mfaSubscriptions = new List <Tuple <string, string, bool> >();
foreach (var subscription in allSubscriptions)
{
mfaSubscriptions.Add(new Tuple <string, string, bool>(subscription.MfaSubscriptionId, subscription.MfaSubscriptionName,
true));
}
SubmitMfaSettingsResponse submitMfaSettingsResponse = userApplicationService.SubmitMfaSettings(
new MfaSettingsCommand(false, null, userValidationEssentials.ApiKey, mfaSubscriptions));
Assert.IsTrue(submitMfaSettingsResponse.Successful);
logoutApplicationService.Logout(new LogoutCommand(userValidationEssentials.ApiKey));
UserValidationEssentials validationEssentials = loginApplicationService.Login(new LoginCommand("Bob", "alice", null));
Assert.IsFalse(validationEssentials.LoginSuccessful);
Assert.IsNull(validationEssentials.ApiKey);
// As we are using the stub implementation for MfaCodeGenerationService, the service returns only the same code every
// time. So we can use the code in this test case
validationEssentials = loginApplicationService.Login(new LoginCommand("Bob", "alice", mfaCodeGenerationService.GenerateCode()));
Assert.IsTrue(validationEssentials.LoginSuccessful);
Assert.IsNotNull(validationEssentials.ApiKey);
Assert.IsNotNull(validationEssentials.SecretKey);
}
public void VerifyTierLevelTest_TestsIfTheTierLevelIsVerifiedAsExpected_QueriesDatabaseToConfirm()
{
UserValidationEssentials essentials = AccessControlUtility.RegisterAndLogin("user", "*****@*****.**", "123", _applicationContext);
TierController tierController = _applicationContext["TierController"] as TierController;
Assert.IsNotNull(tierController);
tierController.Request = new HttpRequestMessage(HttpMethod.Post, "");
tierController.Request.Headers.Add("Auth", essentials.ApiKey);
tierController.GetVerifyForTier1(new Tier1Param("User", DateTime.Now.AddDays(-10).ToShortDateString(), "656667"));
// Tier 2 will not be considered for verification because Tier 1 is not yet verified
tierController.GetVerifyForTier2(new Tier2Param("asd", "", "", "punjab", "Isb", "123"));
IHttpActionResult httpActionResult = tierController.GetTierStatuses();
OkNegotiatedContentResult <UserTierStatusRepresentation[]> statuses = (OkNegotiatedContentResult <UserTierStatusRepresentation[]>)httpActionResult;
Assert.AreEqual(statuses.Content.Length, 5);
Assert.AreEqual(statuses.Content[0].Status, Status.Verified.ToString());
Assert.AreEqual(statuses.Content[1].Status, Status.Preverified.ToString());
Assert.AreEqual(statuses.Content[2].Status, Status.NonVerified.ToString());
IHttpActionResult verifyTierLevelResult = tierController.VerifyTierLevel(new VerifyTierLevelParams("Tier 1", essentials.ApiKey));
OkNegotiatedContentResult <VerifyTierLevelResponse> verificationResponse = (OkNegotiatedContentResult <VerifyTierLevelResponse>)verifyTierLevelResult;
Assert.IsTrue(verificationResponse.Content.VerificationSuccessful);
httpActionResult = tierController.GetTierStatuses();
statuses = (OkNegotiatedContentResult <UserTierStatusRepresentation[]>)httpActionResult;
Assert.AreEqual(statuses.Content.Length, 5);
Assert.AreEqual(statuses.Content[0].Status, Status.Verified.ToString());
Assert.AreEqual(statuses.Content[1].Status, Status.Verified.ToString());
Assert.AreEqual(statuses.Content[2].Status, Status.NonVerified.ToString());
// Tier 2 will now be verified as Tier 1 is already verified
tierController.GetVerifyForTier2(new Tier2Param("asd", "", "", "punjab", "Isb", "123"));
httpActionResult = tierController.GetTierStatuses();
statuses = (OkNegotiatedContentResult <UserTierStatusRepresentation[]>)httpActionResult;
Assert.AreEqual(statuses.Content.Length, 5);
Assert.AreEqual(statuses.Content[0].Status, Status.Verified.ToString());
Assert.AreEqual(statuses.Content[1].Status, Status.Verified.ToString());
Assert.AreEqual(statuses.Content[2].Status, Status.Preverified.ToString());
verifyTierLevelResult = tierController.VerifyTierLevel(new VerifyTierLevelParams("Tier 2", essentials.ApiKey));
verificationResponse = (OkNegotiatedContentResult <VerifyTierLevelResponse>)verifyTierLevelResult;
Assert.IsTrue(verificationResponse.Content.VerificationSuccessful);
httpActionResult = tierController.GetTierStatuses();
statuses = (OkNegotiatedContentResult <UserTierStatusRepresentation[]>)httpActionResult;
Assert.AreEqual(statuses.Content.Length, 5);
Assert.AreEqual(statuses.Content[0].Status, Status.Verified.ToString());
Assert.AreEqual(statuses.Content[1].Status, Status.Verified.ToString());
Assert.AreEqual(statuses.Content[2].Status, Status.Verified.ToString());
}
public void GetTier3Detials_IfTier3IsNotVerified_InvalidOperationExceptionShouldBeThrown()
{
UserValidationEssentials essentials = AccessControlUtility.RegisterAndLogin("user", "*****@*****.**", "123", _applicationContext);
TierController tierController = _applicationContext["TierController"] as TierController;
tierController.Request = new HttpRequestMessage(HttpMethod.Post, "");
tierController.Request.Headers.Add("Auth", essentials.ApiKey);
IHttpActionResult httpActionResult = tierController.GetTier3Details();
BadRequestErrorMessageResult result = httpActionResult as BadRequestErrorMessageResult;
Assert.AreEqual(result.Message, "Tier 3 details are not submitted yet.");
}
public void LogoutSuccessTest_TestsIfAUserGetsLogoutAsExpected_FailsIfDoesNot()
{
ILoginApplicationService loginApplicationService = (ILoginApplicationService)_applicationContext["LoginApplicationService"];
Assert.IsNotNull(loginApplicationService);
IRegistrationApplicationService registrationService = (IRegistrationApplicationService)_applicationContext["RegistrationApplicationService"];;
// Register
string username = "******";
string password = "******";
string activationKey = registrationService.CreateAccount(new SignupUserCommand(
"*****@*****.**", username, password, "Wonderland", TimeZone.CurrentTimeZone, ""));
Assert.IsNotNull(activationKey);
IUserApplicationService userApplicationService = (IUserApplicationService)_applicationContext["UserApplicationService"];
IUserRepository userRepository = (IUserRepository)_applicationContext["UserRepository"];
// Activate account
bool accountActivated = userApplicationService.ActivateAccount(new ActivationCommand(activationKey, username, password));
Assert.IsTrue(accountActivated);
User userByUserName = userRepository.GetUserByUserName(username);
Assert.IsNotNull(userByUserName);
Assert.IsTrue(userByUserName.IsActivationKeyUsed.Value);
// Login
UserValidationEssentials userValidationEssentials = loginApplicationService.Login(new LoginCommand(username, password));
Assert.IsNotNull(userValidationEssentials);
Assert.IsNotNull(userValidationEssentials.ApiKey);
Assert.IsNotNull(userValidationEssentials.SecretKey);
Assert.IsNotNull(userValidationEssentials.SessionLogoutTime);
// Logout
ILogoutApplicationService logoutApplicationService =
(ILogoutApplicationService)_applicationContext["LogoutApplicationService"];
Assert.IsNotNull(logoutApplicationService);
bool logout = logoutApplicationService.Logout(new LogoutCommand(userValidationEssentials.ApiKey));
Assert.IsTrue(logout);
ISecurityKeysRepository securityKeysRepository = (ISecurityKeysRepository)_applicationContext["SecurityKeysPairRepository"];
SecurityKeysPair securityKeysPair = securityKeysRepository.GetByApiKey(userValidationEssentials.ApiKey);
Assert.IsNull(securityKeysPair);
}
public void LoginSuccessfulAndCheckSecurityKeysPairTest_ChecksIfAfterUserLoginSecurityPairsValuesAreAsExpected_ChecksByGettingSecurityKeysFromRepo()
{
ILoginApplicationService loginApplicationService = (ILoginApplicationService)_applicationContext["LoginApplicationService"];
Assert.IsNotNull(loginApplicationService);
IRegistrationApplicationService registrationService = (IRegistrationApplicationService)_applicationContext["RegistrationApplicationService"];
IUserRepository userRepository = (IUserRepository)_applicationContext["UserRepository"];
ISecurityKeysRepository securityKeysRepository = (ISecurityKeysRepository)_applicationContext["SecurityKeysPairRepository"];
string username = "******";
string email = "*****@*****.**";
string password = "******";
string activationKey = registrationService.CreateAccount(new SignupUserCommand(
email, username, password, "Wonderland", TimeZone.CurrentTimeZone, ""));
Assert.IsNotNull(activationKey);
IUserApplicationService userApplicationService = (IUserApplicationService)_applicationContext["UserApplicationService"];
bool accountActivated = userApplicationService.ActivateAccount(new ActivationCommand(activationKey, "Bob", "alice"));
Assert.IsTrue(accountActivated);
UserValidationEssentials userValidationEssentials = loginApplicationService.Login(new LoginCommand(
username, password));
Assert.IsNotNull(userValidationEssentials);
Assert.IsNotNull(userValidationEssentials.ApiKey);
Assert.IsNotNull(userValidationEssentials.SecretKey);
Assert.IsNotNull(userValidationEssentials.SessionLogoutTime);
User user = userRepository.GetUserByUserName(username);
Assert.IsNotNull(user);
// Check that the user logged in this same minute and date, as we cannot check the seconds exactly
Assert.AreEqual(user.LastLogin.Date, DateTime.Today.Date);
Assert.AreEqual(user.LastLogin.Hour, DateTime.Now.Hour);
Assert.AreEqual(user.LastLogin.Minute, DateTime.Now.Minute);
Assert.AreEqual(userValidationEssentials.SessionLogoutTime, user.AutoLogout);
SecurityKeysPair securityKeysPair = securityKeysRepository.GetByApiKey(userValidationEssentials.ApiKey);
Assert.IsNotNull(securityKeysPair);
Assert.AreEqual(userValidationEssentials.SecretKey, securityKeysPair.SecretKey);
}
public void GetLastLogin_IfTheApiKeyIsValid_LastLoginWillBeReturned()
{
IUserApplicationService userApplicationService = (IUserApplicationService)_applicationContext["UserApplicationService"];
IRegistrationApplicationService registrationApplicationService = (IRegistrationApplicationService)_applicationContext["RegistrationApplicationService"];
ILoginApplicationService loginApplicationService = (ILoginApplicationService)_applicationContext["LoginApplicationService"];
IUserRepository userRepository = (IUserRepository)_applicationContext["UserRepository"];
string username = "******";
string activatioNKey = registrationApplicationService.CreateAccount(new SignupUserCommand("*****@*****.**", "linkinpark", "burnitdown", "USA", TimeZone.CurrentTimeZone, ""));
ManualResetEvent manualResetEvent = new ManualResetEvent(false);
userApplicationService.ActivateAccount(new ActivationCommand(activatioNKey, username, "burnitdown"));
manualResetEvent.WaitOne(6000);
UserValidationEssentials validationEssentials = loginApplicationService.Login(new LoginCommand(username, "burnitdown"));
DateTime LastLogin = userApplicationService.LastLogin(validationEssentials.ApiKey);
Assert.AreEqual(LastLogin.ToString(), validationEssentials.LastLogin.ToString());
}
public void LoginSuccessfulTest_TestsifTheLoginisSuccessfulAfterProvidingValidCredentials_VerifiesByGettingUserFromRepositoryAndCheckingCredentials()
{
ILoginApplicationService loginApplicationService = (ILoginApplicationService)_applicationContext["LoginApplicationService"];
Assert.IsNotNull(loginApplicationService);
IRegistrationApplicationService registrationService = (IRegistrationApplicationService)_applicationContext["RegistrationApplicationService"];
IUserRepository userRepository = (IUserRepository)_applicationContext["UserRepository"];
IPasswordEncryptionService passwordEncryptionService = (IPasswordEncryptionService)_applicationContext["PasswordEncryptionService"];
string username = "******";
string email = "*****@*****.**";
string password = "******";
string activationKey = registrationService.CreateAccount(new SignupUserCommand(
email, username, password, "Wonderland", TimeZone.CurrentTimeZone, ""));
Assert.IsNotNull(activationKey);
IUserApplicationService userApplicationService = (IUserApplicationService)_applicationContext["UserApplicationService"];
bool accountActivated = userApplicationService.ActivateAccount(new ActivationCommand(activationKey, "Bob", "alice"));
Assert.IsTrue(accountActivated);
UserValidationEssentials userValidationEssentials = loginApplicationService.Login(new LoginCommand("Bob", "alice"));
Assert.IsNotNull(userValidationEssentials);
Assert.IsNotNull(userValidationEssentials.ApiKey);
Assert.IsNotNull(userValidationEssentials.SecretKey);
Assert.IsNotNull(userValidationEssentials.SessionLogoutTime);
User user = userRepository.GetUserByUserName(username);
Assert.IsNotNull(user);
Assert.AreEqual(user.Email, email);
Assert.AreEqual(user.ActivationKey, activationKey);
Assert.AreEqual(userValidationEssentials.SessionLogoutTime, user.AutoLogout);
Assert.IsTrue(passwordEncryptionService.VerifyPassword(password, user.Password));
}
public void CreateUsergeneratedSystemKey_ProvideAllParameters_TheKeysShouldBeReturned()
{
UserValidationEssentials essentials = AccessControlUtility.RegisterAndLogin("user", "*****@*****.**", "123", _applicationContext);
SecurityKeyPairController securityKeyPairController =
_applicationContext["SecurityKeyPairController"] as SecurityKeyPairController;
IPermissionRepository permissionRepository = _applicationContext["PermissionRespository"] as IPermissionRepository;
IList <Permission> permissions = permissionRepository.GetAllPermissions();
List <string> securityKeyPermissions = new List <string>();
for (int i = 0; i < permissions.Count; i++)
{
securityKeyPermissions.Add(permissions[i].PermissionId);
}
securityKeyPairController.Request = new HttpRequestMessage(HttpMethod.Post, "");
securityKeyPairController.Request.Headers.Add("Auth", essentials.ApiKey);
CreateUserGeneratedSecurityKeyPair command = new CreateUserGeneratedSecurityKeyPair(securityKeyPermissions, "", "", "", false, false, false, "#1");
IHttpActionResult httpActionResult = securityKeyPairController.CreateSecurityKey(command);
OkNegotiatedContentResult <SecurityKeyPair> result = (OkNegotiatedContentResult <SecurityKeyPair>)httpActionResult;
Assert.IsNotNullOrEmpty(result.Content.ApiKey);
Assert.IsNotNullOrEmpty(result.Content.SecretKey);
CreateUserGeneratedSecurityKeyPair command2 = new CreateUserGeneratedSecurityKeyPair(securityKeyPermissions, "", "", "", false, false, false, "#2");
httpActionResult = securityKeyPairController.CreateSecurityKey(command2);
result = (OkNegotiatedContentResult <SecurityKeyPair>)httpActionResult;
Assert.IsNotNullOrEmpty(result.Content.ApiKey);
Assert.IsNotNullOrEmpty(result.Content.SecretKey);
httpActionResult = securityKeyPairController.GetUserSecurityKeys();
OkNegotiatedContentResult <object> result1 = (OkNegotiatedContentResult <object>)httpActionResult;
List <object> objectPairs = result1.Content as List <object>;
List <SecurityKeyPairList> pairs = new List <SecurityKeyPairList>();
foreach (object objectPair in objectPairs)
{
pairs.Add(objectPair as SecurityKeyPairList);
}
Assert.AreEqual(pairs.Count, 2);
Assert.AreEqual(pairs[1].KeyDescription, "#1");
Assert.IsNull(pairs[1].ExpirationDate);
httpActionResult = securityKeyPairController.GetSecurityKeyDetail("#1");
OkNegotiatedContentResult <SecurityKeyRepresentation> securityKey = (OkNegotiatedContentResult <SecurityKeyRepresentation>)httpActionResult;
Assert.AreEqual(securityKey.Content.KeyDescritpion, "#1");
Assert.AreEqual(securityKey.Content.EnableEndDate, false);
Assert.AreEqual(securityKey.Content.EnableExpirationDate, false);
Assert.AreEqual(securityKey.Content.EnableStartDate, false);
Assert.AreEqual(pairs[0].KeyDescription, "#2");
Assert.IsNull(pairs[0].ExpirationDate);
httpActionResult = securityKeyPairController.GetSecurityKeyDetail("#2");
securityKey = (OkNegotiatedContentResult <SecurityKeyRepresentation>)httpActionResult;
Assert.AreEqual(securityKey.Content.KeyDescritpion, "#2");
Assert.AreEqual(securityKey.Content.EnableEndDate, false);
Assert.AreEqual(securityKey.Content.EnableExpirationDate, false);
Assert.AreEqual(securityKey.Content.EnableStartDate, false);
}
public void UpdateUsergeneratedSystemKey_ProvideAllParameters_TheKeysDetailsShouldGetUpdated()
{
UserValidationEssentials essentials = AccessControlUtility.RegisterAndLogin("user", "*****@*****.**", "123", _applicationContext);
SecurityKeyPairController securityKeyPairController =
_applicationContext["SecurityKeyPairController"] as SecurityKeyPairController;
IPermissionRepository permissionRepository = _applicationContext["PermissionRespository"] as IPermissionRepository;
IList <Permission> permissions = permissionRepository.GetAllPermissions();
List <string> securityKeyPermissions = new List <string>();
for (int i = 0; i < permissions.Count; i++)
{
securityKeyPermissions.Add(permissions[i].PermissionId);
}
securityKeyPairController.Request = new HttpRequestMessage(HttpMethod.Post, "");
securityKeyPairController.Request.Headers.Add("Auth", essentials.ApiKey);
CreateUserGeneratedSecurityKeyPair command = new CreateUserGeneratedSecurityKeyPair(securityKeyPermissions, "", "", "", false, false, false, "#1");
IHttpActionResult httpActionResult = securityKeyPairController.CreateSecurityKey(command);
OkNegotiatedContentResult <SecurityKeyPair> result = (OkNegotiatedContentResult <SecurityKeyPair>)httpActionResult;
Assert.IsNotNullOrEmpty(result.Content.ApiKey);
Assert.IsNotNullOrEmpty(result.Content.SecretKey);
httpActionResult = securityKeyPairController.GetUserSecurityKeys();
OkNegotiatedContentResult <object> result1 = (OkNegotiatedContentResult <object>)httpActionResult;
List <object> objectPairs = result1.Content as List <object>;
Assert.IsNotNull(objectPairs);
List <SecurityKeyPairList> pairs = new List <SecurityKeyPairList>();
foreach (object objectPair in objectPairs)
{
pairs.Add(objectPair as SecurityKeyPairList);
}
Assert.AreEqual(pairs.Count, 1);
Assert.AreEqual(pairs[0].KeyDescription, "#1");
Assert.IsNull(pairs[0].ExpirationDate);
httpActionResult = securityKeyPairController.GetSecurityKeyDetail("#1");
OkNegotiatedContentResult <SecurityKeyRepresentation> securityKey = (OkNegotiatedContentResult <SecurityKeyRepresentation>)httpActionResult;
Assert.AreEqual(securityKey.Content.KeyDescritpion, "#1");
Assert.AreEqual(securityKey.Content.EnableEndDate, false);
Assert.AreEqual(securityKey.Content.EnableExpirationDate, false);
Assert.AreEqual(securityKey.Content.EnableStartDate, false);
List <SecurityKeyPermissionsRepresentation> permissionsRepresentations = new List <SecurityKeyPermissionsRepresentation>();
for (int i = 0; i < securityKeyPermissions.Count; i++)
{
if (securityKeyPermissions[i] == PermissionsConstant.Cancel_Order)
{
permissionsRepresentations.Add(new SecurityKeyPermissionsRepresentation(false, new Permission(securityKeyPermissions[i], "Cancel Order")));
}
else if (securityKeyPermissions[i] == PermissionsConstant.Query_Open_Orders)
{
permissionsRepresentations.Add(new SecurityKeyPermissionsRepresentation(false, new Permission(securityKeyPermissions[i], "Query Open Orders")));
}
else if (securityKeyPermissions[i] == PermissionsConstant.Place_Order)
{
permissionsRepresentations.Add(new SecurityKeyPermissionsRepresentation(false, new Permission(securityKeyPermissions[i], "Place Order")));
}
else if (securityKeyPermissions[i] == PermissionsConstant.Withdraw_Funds)
{
permissionsRepresentations.Add(new SecurityKeyPermissionsRepresentation(false, new Permission(securityKeyPermissions[i], "Withdraw Funds")));
}
else
{
permissionsRepresentations.Add(new SecurityKeyPermissionsRepresentation(true, new Permission(securityKeyPermissions[i], securityKeyPermissions[i])));
}
}
UpdateUserGeneratedSecurityKeyPair updateKeyPair =
new UpdateUserGeneratedSecurityKeyPair(securityKey.Content.ApiKey, "#2", true, false, false, "",
DateTime.Today.AddDays(-2).ToString(), permissionsRepresentations.ToArray(), "");
httpActionResult = securityKeyPairController.UpdateSecurityKey(updateKeyPair);
httpActionResult = securityKeyPairController.GetSecurityKeyDetail("#2");
securityKey = (OkNegotiatedContentResult <SecurityKeyRepresentation>)httpActionResult;
Assert.AreEqual(securityKey.Content.KeyDescritpion, "#2");
Assert.AreEqual(securityKey.Content.EnableEndDate, false);
Assert.AreEqual(securityKey.Content.EnableExpirationDate, false);
Assert.AreEqual(securityKey.Content.EnableStartDate, true);
ValidatePermissions(securityKey.Content.SecurityKeyPermissions);
}
