public async Task Setup()
{
context = await TestDatabase.GetDatabaseContext();
MockUsersRepository = new MockUsersRepository(context);
sut = new UserManagementService(
MockUsersRepository.UsersRepositorySuccessfulRequest.Object);
sutFailure = new UserManagementService(
MockUsersRepository.UsersRepositoryFailedRequest.Object);
userName = "******";
password = "******";
email = "*****@*****.**";
}
public async Task Setup()
{
context = await TestDatabase.GetDatabaseContext();
mockGamesRepository = new MockGamesRepository(context);
mockAppsRepository = new MockAppsRepository(context);
mockUsersRepository = new MockUsersRepository(context);
mockDifficultiesRepositorySuccessful = new MockDifficultiesRepository(context);
mockDifficultiesRepositoryFailed = new MockDifficultiesRepository(context);
mockSolutionsRepository = new MockSolutionsRepository(context);
sut = new GamesService(
mockGamesRepository.GamesRepositorySuccessfulRequest.Object,
mockAppsRepository.AppsRepositorySuccessfulRequest.Object,
mockUsersRepository.UsersRepositorySuccessfulRequest.Object,
mockDifficultiesRepositorySuccessful.DifficultiesRepositorySuccessfulRequest.Object,
mockSolutionsRepository.SolutionsRepositorySuccessfulRequest.Object);
sutFailure = new GamesService(
mockGamesRepository.GamesRepositoryFailedRequest.Object,
mockAppsRepository.AppsRepositorySuccessfulRequest.Object,
mockUsersRepository.UsersRepositorySuccessfulRequest.Object,
mockDifficultiesRepositorySuccessful.DifficultiesRepositorySuccessfulRequest.Object,
mockSolutionsRepository.SolutionsRepositorySuccessfulRequest.Object);
sutAnonFailure = new GamesService(
mockGamesRepository.GamesRepositorySuccessfulRequest.Object,
mockAppsRepository.AppsRepositorySuccessfulRequest.Object,
mockUsersRepository.UsersRepositorySuccessfulRequest.Object,
mockDifficultiesRepositoryFailed.DifficultiesRepositoryFailedRequest.Object,
mockSolutionsRepository.SolutionsRepositorySuccessfulRequest.Object);
sutUpdateFailure = new GamesService(
mockGamesRepository.GamesRepositoryUpdateFailedRequest.Object,
mockAppsRepository.AppsRepositorySuccessfulRequest.Object,
mockUsersRepository.UsersRepositorySuccessfulRequest.Object,
mockDifficultiesRepositorySuccessful.DifficultiesRepositorySuccessfulRequest.Object,
mockSolutionsRepository.SolutionsRepositorySuccessfulRequest.Object);
getGamesRequest = TestObjects.GetGamesRequest();
}
public async Task Setup()
{
context = await TestDatabase.GetDatabaseContext();
MockAppsRepository = new MockAppsRepository(context);
MockUsersRepository = new MockUsersRepository(context);
MockAppAdminsRepository = new MockAppAdminsRepository(context);
MockRolesRepository = new MockRolesRepository(context);
sut = new AppsService(
MockAppsRepository.AppsRepositorySuccessfulRequest.Object,
MockUsersRepository.UsersRepositorySuccessfulRequest.Object,
MockAppAdminsRepository.AppAdminsRepositorySuccessfulRequest.Object,
MockRolesRepository.RolesRepositorySuccessfulRequest.Object);
sutAppRepoFailure = new AppsService(
MockAppsRepository.AppsRepositoryFailedRequest.Object,
MockUsersRepository.UsersRepositorySuccessfulRequest.Object,
MockAppAdminsRepository.AppAdminsRepositoryFailedRequest.Object,
MockRolesRepository.RolesRepositoryFailedRequest.Object);
sutUserRepoFailure = new AppsService(
MockAppsRepository.AppsRepositorySuccessfulRequest.Object,
MockUsersRepository.UsersRepositoryFailedRequest.Object,
MockAppAdminsRepository.AppAdminsRepositoryFailedRequest.Object,
MockRolesRepository.RolesRepositorySuccessfulRequest.Object);
sutPromoteUser = new AppsService(
MockAppsRepository.AppsRepositorySuccessfulRequest.Object,
MockUsersRepository.UsersRepositoryInitiatePasswordSuccessful.Object,
MockAppAdminsRepository.AppAdminsRepositoryPromoteUser.Object,
MockRolesRepository.RolesRepositorySuccessfulRequest.Object);;
dateCreated = DateTime.UtcNow;
license = TestObjects.GetLicense();
baseRequest = TestObjects.GetBaseRequest();
paginator = TestObjects.GetPaginator();
userId = 1;
appId = 1;
}
public async Task Setup()
{
userName = "******";
password = "******";
context = await TestDatabase.GetDatabaseContext();
MockUsersRepository = new MockUsersRepository(context);
MockRolesRepository = new MockRolesRepository(context);
MockAppsRepository = new MockAppsRepository(context);
MockAppAdminsRepository = new MockAppAdminsRepository(context);
MockUserManagementService = new MockUserManagementService();
tokenManagement = new TokenManagement()
{
Secret = "3c1ad157-be37-40d2-9cc8-e7527a56aa7b",
Issuer = "testProject",
Audience = "testEnvironment"
};
IOptions <TokenManagement> options = Options.Create <TokenManagement>(tokenManagement);
sutValid = new AuthenticateService(
MockUsersRepository.UsersRepositorySuccessfulRequest.Object,
MockRolesRepository.RolesRepositorySuccessfulRequest.Object,
MockAppsRepository.AppsRepositorySuccessfulRequest.Object,
MockAppAdminsRepository.AppAdminsRepositorySuccessfulRequest.Object,
MockUserManagementService.UserManagementServiceSuccssfulRequest.Object,
options);
sutInvalid = new AuthenticateService(
MockUsersRepository.UsersRepositoryFailedRequest.Object,
MockRolesRepository.RolesRepositoryFailedRequest.Object,
MockAppsRepository.AppsRepositoryFailedRequest.Object,
MockAppAdminsRepository.AppAdminsRepositoryFailedRequest.Object,
MockUserManagementService.UserManagementServiceFailedRequest.Object,
options);
}
public MockUsersService(DatabaseContext context)
{
MockUsersRepository = new MockUsersRepository(context);
MockAppsRepository = new MockAppsRepository(context);
MockPasswordResetsRepository = new MockPasswordResetsRepository(context);
MockEmailConfirmationsRepository = new MockEmailConfirmationsRepository(context);
UsersServiceSuccessfulRequest = new Mock <IUsersService>();
UsersServiceFailedRequest = new Mock <IUsersService>();
UsersServiceSuccessfulRequest.Setup(userService =>
userService.CreateUser(It.IsAny <RegisterRequest>(), It.IsAny <string>(), It.IsAny <string>()))
.Returns(Task.FromResult(new UserResult()
{
Success = MockUsersRepository
.UsersRepositorySuccessfulRequest
.Object
.Add(It.IsAny <User>())
.Result
.Success,
Message = UsersMessages.UserCreatedMessage,
User = (User)MockUsersRepository
.UsersRepositorySuccessfulRequest
.Object
.Add(It.IsAny <User>())
.Result
.Object
} as IUserResult));
UsersServiceSuccessfulRequest.Setup(userService =>
userService.GetUser(
It.IsAny <int>(),
It.IsAny <string>(),
It.IsAny <bool>()))
.Returns(Task.FromResult(new UserResult()
{
Success = MockUsersRepository
.UsersRepositorySuccessfulRequest
.Object
.GetById(It.IsAny <int>(), It.IsAny <bool>())
.Result
.Success,
Message = UsersMessages.UserFoundMessage,
User = (User)MockUsersRepository
.UsersRepositorySuccessfulRequest
.Object
.GetById(It.IsAny <int>(), It.IsAny <bool>())
.Result
.Object
} as IUserResult));
UsersServiceSuccessfulRequest.Setup(userService =>
userService.GetUsers(
It.IsAny <int>(),
It.IsAny <string>(),
It.IsAny <Paginator>(),
It.IsAny <bool>()))
.Returns(Task.FromResult(new UsersResult()
{
Success = MockUsersRepository
.UsersRepositorySuccessfulRequest
.Object
.GetAll(It.IsAny <bool>())
.Result
.Success,
Message = UsersMessages.UsersFoundMessage,
Users = MockUsersRepository
.UsersRepositorySuccessfulRequest
.Object
.GetAll(It.IsAny <bool>())
.Result
.Objects
.ConvertAll(u => (IUser)u)
} as IUsersResult));
UsersServiceSuccessfulRequest.Setup(userService =>
userService.UpdateUser(
It.IsAny <int>(),
It.IsAny <UpdateUserRequest>(),
It.IsAny <string>(),
It.IsAny <string>()))
.Returns(Task.FromResult(new UserResult()
{
Success = MockUsersRepository
.UsersRepositorySuccessfulRequest
.Object
.Update(It.IsAny <User>())
.Result
.Success,
Message = UsersMessages.UserUpdatedMessage,
User = (User)MockUsersRepository
.UsersRepositorySuccessfulRequest
.Object
.Update(It.IsAny <User>())
.Result
.Object
} as IUserResult));
UsersServiceSuccessfulRequest.Setup(userService =>
userService.RequestPasswordReset(
It.IsAny <RequestPasswordResetRequest>(),
It.IsAny <string>(),
It.IsAny <string>()))
.Returns(Task.FromResult(new BaseResult()
{
Success = true,
Message = UsersMessages.ProcessedPasswordResetRequestMessage
} as IBaseResult));
UsersServiceSuccessfulRequest.Setup(userService =>
userService.ResendPasswordReset(
It.IsAny <int>(),
It.IsAny <int>(),
It.IsAny <string>(),
It.IsAny <string>()))
.Returns(Task.FromResult(new BaseResult()
{
Success = true,
Message = UsersMessages.PasswordResetEmailResentMessage
} as IBaseResult));
UsersServiceSuccessfulRequest.Setup(userService =>
userService.UpdatePassword(It.IsAny <UpdatePasswordRequest>()))
.Returns(Task.FromResult(new BaseResult()
{
Success = MockUsersRepository
.UsersRepositorySuccessfulRequest
.Object
.Update(It.IsAny <User>())
.Result
.Success,
Message = UsersMessages.PasswordResetMessage
} as IBaseResult));
UsersServiceSuccessfulRequest.Setup(userService =>
userService.DeleteUser(It.IsAny <int>()))
.Returns(Task.FromResult(new BaseResult()
{
Success = MockUsersRepository
.UsersRepositorySuccessfulRequest
.Object
.Delete(It.IsAny <User>())
.Result
.Success,
Message = UsersMessages.UserDeletedMessage
} as IBaseResult));
UsersServiceSuccessfulRequest.Setup(userService =>
userService.AddUserRoles(
It.IsAny <int>(),
It.IsAny <List <int> >(),
It.IsAny <string>()))
.Returns(Task.FromResult(new RolesResult()
{
Success = MockUsersRepository
.UsersRepositorySuccessfulRequest
.Object
.AddRoles(It.IsAny <int>(), It.IsAny <List <int> >())
.Result
.Success,
Message = UsersMessages.RolesAddedMessage,
Roles = new List <IRole>()
} as IRolesResult));
UsersServiceSuccessfulRequest.Setup(userService =>
userService.RemoveUserRoles(
It.IsAny <int>(),
It.IsAny <List <int> >(),
It.IsAny <string>()))
.Returns(Task.FromResult(new BaseResult()
{
Success = MockUsersRepository
.UsersRepositorySuccessfulRequest
.Object
.RemoveRoles(It.IsAny <int>(), It.IsAny <List <int> >())
.Result
.Success,
Message = UsersMessages.RolesRemovedMessage
} as IBaseResult));
UsersServiceSuccessfulRequest.Setup(userService =>
userService.ActivateUser(It.IsAny <int>()))
.Returns(Task.FromResult(new BaseResult()
{
Success = MockUsersRepository
.UsersRepositorySuccessfulRequest
.Object
.ActivateUser(It.IsAny <int>())
.Result,
Message = UsersMessages.UserActivatedMessage
} as IBaseResult));
UsersServiceSuccessfulRequest.Setup(userService =>
userService.DeactivateUser(It.IsAny <int>()))
.Returns(Task.FromResult(new BaseResult()
{
Success = MockUsersRepository
.UsersRepositorySuccessfulRequest
.Object
.DeactivateUser(It.IsAny <int>())
.Result,
Message = UsersMessages.UserDeactivatedMessage
} as IBaseResult));
UsersServiceSuccessfulRequest.Setup(usersService =>
usersService.ConfirmEmail(
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>()))
.Returns(Task.FromResult(new ConfirmEmailResult()
{
Success = MockUsersRepository
.UsersRepositorySuccessfulRequest
.Object
.ConfirmEmail(It.IsAny <IEmailConfirmation>())
.Result
.Success,
Message = UsersMessages.EmailConfirmedMessage
} as IConfirmEmailResult));
UsersServiceSuccessfulRequest.Setup(usersService =>
usersService.InitiatePasswordReset(It.IsAny <string>()))
.Returns(Task.FromResult(new InitiatePasswordResetResult()
{
Success = MockPasswordResetsRepository
.PasswordResetsRepositorySuccessfulRequest
.Object
.Create(It.IsAny <PasswordReset>())
.Result
.Success,
Message = UsersMessages.UserFoundMessage,
Token = Guid.NewGuid().ToString(),
ConfirmationEmailSuccessfullySent = true,
App = (App)MockAppsRepository
.AppsRepositorySuccessfulRequest
.Object
.GetById(It.IsAny <int>())
.Result
.Object,
User = (User)MockUsersRepository
.UsersRepositorySuccessfulRequest
.Object
.GetById(It.IsAny <int>())
.Result
.Object
} as IInitiatePasswordResetResult));
UsersServiceSuccessfulRequest.Setup(usersService =>
usersService.ResendEmailConfirmation(
It.IsAny <int>(),
It.IsAny <int>(),
It.IsAny <string>(),
It.IsAny <string>()))
.Returns(Task.FromResult(new UserResult()
{
Success = MockEmailConfirmationsRepository
.EmailConfirmationsRepositorySuccessfulRequest
.Object
.HasOutstandingEmailConfirmation(It.IsAny <int>(), It.IsAny <int>())
.Result,
Message = UsersMessages.EmailConfirmationEmailResentMessage,
ConfirmationEmailSuccessfullySent = true
} as IUserResult));
UsersServiceSuccessfulRequest.Setup(usersService =>
usersService.CancelEmailConfirmationRequest(
It.IsAny <int>(),
It.IsAny <int>()))
.Returns(Task.FromResult(new UserResult()
{
Success = MockEmailConfirmationsRepository
.EmailConfirmationsRepositorySuccessfulRequest
.Object
.Delete(It.IsAny <EmailConfirmation>())
.Result
.Success,
Message = UsersMessages.EmailConfirmationRequestCancelledMessage,
User = (User)MockUsersRepository
.UsersRepositorySuccessfulRequest
.Object
.GetById(It.IsAny <int>())
.Result
.Object
} as IUserResult));
UsersServiceSuccessfulRequest.Setup(usersService =>
usersService.CancelPasswordResetRequest(
It.IsAny <int>(),
It.IsAny <int>()))
.Returns(Task.FromResult(new UserResult()
{
Success = MockPasswordResetsRepository
.PasswordResetsRepositorySuccessfulRequest
.Object
.Delete(It.IsAny <PasswordReset>())
.Result
.Success,
Message = UsersMessages.PasswordResetRequestCancelledMessage,
User = (User)MockUsersRepository
.UsersRepositorySuccessfulRequest
.Object
.GetById(It.IsAny <int>())
.Result
.Object
} as IUserResult));
UsersServiceSuccessfulRequest.Setup(usersService =>
usersService.CancelAllEmailRequests(
It.IsAny <int>(),
It.IsAny <int>()))
.Returns(Task.FromResult(new UserResult()
{
Success = true,
Message = string.Format("{0} and {1}",
UsersMessages.EmailConfirmationRequestCancelledMessage,
UsersMessages.PasswordResetRequestCancelledMessage),
User = (User)MockUsersRepository
.UsersRepositorySuccessfulRequest
.Object
.GetById(It.IsAny <int>())
.Result
.Object
} as IUserResult));
UsersServiceFailedRequest.Setup(userService =>
userService.CreateUser(It.IsAny <RegisterRequest>(), It.IsAny <string>(), It.IsAny <string>()))
.Returns(Task.FromResult(new UserResult()
{
Success = MockUsersRepository
.UsersRepositoryFailedRequest
.Object
.Add(It.IsAny <User>())
.Result
.Success,
Message = UsersMessages.UserNotCreatedMessage,
User = (User)MockUsersRepository
.UsersRepositoryFailedRequest
.Object
.Add(It.IsAny <User>())
.Result
.Object
} as IUserResult));
UsersServiceFailedRequest.Setup(userService =>
userService.GetUser(
It.IsAny <int>(),
It.IsAny <string>(),
It.IsAny <bool>()))
.Returns(Task.FromResult(new UserResult()
{
Success = MockUsersRepository
.UsersRepositoryFailedRequest
.Object
.GetById(It.IsAny <int>(), It.IsAny <bool>())
.Result
.Success,
Message = UsersMessages.UserNotFoundMessage,
User = (User)MockUsersRepository
.UsersRepositoryFailedRequest
.Object
.GetById(It.IsAny <int>(), It.IsAny <bool>())
.Result
.Object,
} as IUserResult));
UsersServiceFailedRequest.Setup(userService =>
userService.GetUsers(
It.IsAny <int>(),
It.IsAny <string>(),
It.IsAny <Paginator>(),
It.IsAny <bool>()))
.Returns(Task.FromResult(new UsersResult()
{
Success = MockUsersRepository
.UsersRepositoryFailedRequest
.Object
.GetAll(It.IsAny <bool>())
.Result
.Success,
Message = UsersMessages.UsersNotFoundMessage,
Users = null
} as IUsersResult));
UsersServiceFailedRequest.Setup(userService =>
userService.UpdateUser(
It.IsAny <int>(),
It.IsAny <UpdateUserRequest>(),
It.IsAny <string>(),
It.IsAny <string>()))
.Returns(Task.FromResult(new UserResult()
{
Success = MockUsersRepository
.UsersRepositoryFailedRequest
.Object
.Update(It.IsAny <User>())
.Result
.Success,
Message = UsersMessages.UserNotUpdatedMessage,
User = (User)MockUsersRepository
.UsersRepositoryFailedRequest
.Object
.Update(It.IsAny <User>())
.Result
.Object
} as IUserResult));
UsersServiceFailedRequest.Setup(userService =>
userService.RequestPasswordReset(
It.IsAny <RequestPasswordResetRequest>(),
It.IsAny <string>(),
It.IsAny <string>()))
.Returns(Task.FromResult(new BaseResult()
{
Success = false,
Message = UsersMessages.UnableToProcessPasswordResetRequesMessage
} as IBaseResult));
UsersServiceFailedRequest.Setup(userService =>
userService.ResendPasswordReset(
It.IsAny <int>(),
It.IsAny <int>(),
It.IsAny <string>(),
It.IsAny <string>()))
.Returns(Task.FromResult(new BaseResult()
{
Success = false,
Message = UsersMessages.UserNotFoundMessage
} as IBaseResult));
UsersServiceFailedRequest.Setup(userService =>
userService.UpdatePassword(It.IsAny <UpdatePasswordRequest>()))
.Returns(Task.FromResult(new BaseResult()
{
Success = MockUsersRepository
.UsersRepositoryFailedRequest
.Object
.Update(It.IsAny <User>())
.Result
.Success,
Message = UsersMessages.PasswordNotResetMessage
} as IBaseResult));
UsersServiceFailedRequest.Setup(userService =>
userService.DeleteUser(It.IsAny <int>()))
.Returns(Task.FromResult(new BaseResult()
{
Success = MockUsersRepository
.UsersRepositoryFailedRequest
.Object
.Delete(It.IsAny <User>())
.Result
.Success,
Message = UsersMessages.UserNotDeletedMessage
} as IBaseResult));
UsersServiceFailedRequest.Setup(userService =>
userService.AddUserRoles(
It.IsAny <int>(),
It.IsAny <List <int> >(),
It.IsAny <string>()))
.Returns(Task.FromResult(new RolesResult()
{
Success = MockUsersRepository
.UsersRepositoryFailedRequest
.Object
.AddRoles(It.IsAny <int>(), It.IsAny <List <int> >())
.Result
.Success,
Message = UsersMessages.RolesNotAddedMessage,
Roles = new List <IRole>()
} as IRolesResult));
UsersServiceFailedRequest.Setup(userService =>
userService.RemoveUserRoles(
It.IsAny <int>(),
It.IsAny <List <int> >(),
It.IsAny <string>()))
.Returns(Task.FromResult(new BaseResult()
{
Success = MockUsersRepository
.UsersRepositoryFailedRequest
.Object
.RemoveRoles(It.IsAny <int>(), It.IsAny <List <int> >())
.Result
.Success,
Message = UsersMessages.RolesNotRemovedMessage
} as IBaseResult));
UsersServiceFailedRequest.Setup(userService =>
userService.ActivateUser(It.IsAny <int>()))
.Returns(Task.FromResult(new BaseResult()
{
Success = MockUsersRepository
.UsersRepositoryFailedRequest
.Object
.ActivateUser(It.IsAny <int>())
.Result,
Message = UsersMessages.UserNotActivatedMessage
} as IBaseResult));
UsersServiceFailedRequest.Setup(userService =>
userService.DeactivateUser(It.IsAny <int>()))
.Returns(Task.FromResult(new BaseResult()
{
Success = MockUsersRepository
.UsersRepositoryFailedRequest
.Object
.DeactivateUser(It.IsAny <int>())
.Result,
Message = UsersMessages.UserNotDeactivatedMessage
} as IBaseResult));
UsersServiceFailedRequest.Setup(usersService =>
usersService.ConfirmEmail(
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>()))
.Returns(Task.FromResult(new ConfirmEmailResult()
{
Success = MockUsersRepository
.UsersRepositoryFailedRequest
.Object
.ConfirmEmail(It.IsAny <IEmailConfirmation>())
.Result
.Success,
Message = UsersMessages.EmailNotConfirmedMessage
} as IConfirmEmailResult));
UsersServiceFailedRequest.Setup(usersService =>
usersService.InitiatePasswordReset(It.IsAny <string>()))
.Returns(Task.FromResult(new InitiatePasswordResetResult()
{
Success = MockPasswordResetsRepository
.PasswordResetsRepositoryFailedRequest
.Object
.Create(It.IsAny <PasswordReset>())
.Result
.Success,
Message = UsersMessages.UserNotFoundMessage,
Token = null,
ConfirmationEmailSuccessfullySent = null,
App = new App(),
User = new User()
} as IInitiatePasswordResetResult));
UsersServiceFailedRequest.Setup(usersService =>
usersService.ResendEmailConfirmation(
It.IsAny <int>(),
It.IsAny <int>(),
It.IsAny <string>(),
It.IsAny <string>()))
.Returns(Task.FromResult(new UserResult()
{
Success = MockEmailConfirmationsRepository
.EmailConfirmationsRepositoryFailedRequest
.Object
.HasOutstandingEmailConfirmation(It.IsAny <int>(), It.IsAny <int>())
.Result,
Message = UsersMessages.EmailConfirmationEmailNotResentMessage,
ConfirmationEmailSuccessfullySent = false
} as IUserResult));
UsersServiceFailedRequest.Setup(usersService =>
usersService.CancelEmailConfirmationRequest(
It.IsAny <int>(),
It.IsAny <int>()))
.Returns(Task.FromResult(new UserResult()
{
Success = MockEmailConfirmationsRepository
.EmailConfirmationsRepositoryFailedRequest
.Object
.Delete(It.IsAny <EmailConfirmation>())
.Result
.Success,
Message = UsersMessages.EmailConfirmationRequestNotCancelledMessage,
User = (User)MockUsersRepository
.UsersRepositorySuccessfulRequest
.Object
.GetById(It.IsAny <int>())
.Result
.Object
} as IUserResult));
UsersServiceFailedRequest.Setup(usersService =>
usersService.CancelPasswordResetRequest(
It.IsAny <int>(),
It.IsAny <int>()))
.Returns(Task.FromResult(new UserResult()
{
Success = MockPasswordResetsRepository
.PasswordResetsRepositoryFailedRequest
.Object
.Delete(It.IsAny <PasswordReset>())
.Result
.Success,
Message = UsersMessages.PasswordResetRequestNotCancelledMessage,
User = (User)MockUsersRepository
.UsersRepositorySuccessfulRequest
.Object
.GetById(It.IsAny <int>())
.Result
.Object
} as IUserResult));
UsersServiceFailedRequest.Setup(usersService =>
usersService.CancelAllEmailRequests(
It.IsAny <int>(),
It.IsAny <int>()))
.Returns(Task.FromResult(new UserResult()
{
Success = false,
Message = UsersMessages.EmailRequestsNotFoundMessage,
User = (User)MockUsersRepository
.UsersRepositorySuccessfulRequest
.Object
.GetById(It.IsAny <int>())
.Result
.Object
} as IUserResult));
}
public async Task Setup()
{
context = await TestDatabase.GetDatabaseContext();
MockEmailService = new MockEmailService();
MockUsersRepository = new MockUsersRepository(context);
MockAppsRepository = new MockAppsRepository(context);
MockRolesRepository = new MockRolesRepository(context);
MockAppAdminsRepository = new MockAppAdminsRepository(context);
MockEmailConfirmationsRepository = new MockEmailConfirmationsRepository(context);
MockPasswordResetRepository = new MockPasswordResetsRepository(context);
sut = new UsersService(
MockUsersRepository.UsersRepositorySuccessfulRequest.Object,
MockAppsRepository.AppsRepositorySuccessfulRequest.Object,
MockRolesRepository.RolesRepositorySuccessfulRequest.Object,
MockAppAdminsRepository.AppAdminsRepositorySuccessfulRequest.Object,
MockEmailConfirmationsRepository.EmailConfirmationsRepositorySuccessfulRequest.Object,
MockPasswordResetRepository.PasswordResetsRepositorySuccessfulRequest.Object,
MockEmailService.EmailServiceSuccessfulRequest.Object);
sutFailure = new UsersService(
MockUsersRepository.UsersRepositoryFailedRequest.Object,
MockAppsRepository.AppsRepositorySuccessfulRequest.Object,
MockRolesRepository.RolesRepositorySuccessfulRequest.Object,
MockAppAdminsRepository.AppAdminsRepositoryFailedRequest.Object,
MockEmailConfirmationsRepository.EmailConfirmationsRepositoryFailedRequest.Object,
MockPasswordResetRepository.PasswordResetsRepositorySuccessfulRequest.Object,
MockEmailService.EmailServiceSuccessfulRequest.Object);
sutEmailFailure = new UsersService(
MockUsersRepository.UsersRepositoryEmailFailedRequest.Object,
MockAppsRepository.AppsRepositorySuccessfulRequest.Object,
MockRolesRepository.RolesRepositorySuccessfulRequest.Object,
MockAppAdminsRepository.AppAdminsRepositoryFailedRequest.Object,
MockEmailConfirmationsRepository.EmailConfirmationsRepositoryFailedRequest.Object,
MockPasswordResetRepository.PasswordResetsRepositorySuccessfulRequest.Object,
MockEmailService.EmailServiceSuccessfulRequest.Object);
sutResetPassword = new UsersService(
MockUsersRepository.UsersRepositoryInitiatePasswordSuccessful.Object,
MockAppsRepository.AppsRepositoryInitiatePasswordSuccessfulRequest.Object,
MockRolesRepository.RolesRepositorySuccessfulRequest.Object,
MockAppAdminsRepository.AppAdminsRepositorySuccessfulRequest.Object,
MockEmailConfirmationsRepository.EmailConfirmationsRepositorySuccessfulRequest.Object,
MockPasswordResetRepository.PasswordResetsRepositorySuccessfulRequest.Object,
MockEmailService.EmailServiceSuccessfulRequest.Object);
sutResendEmailConfirmation = new UsersService(
MockUsersRepository.UsersRepositoryResendEmailConfirmationSuccessful.Object,
MockAppsRepository.AppsRepositorySuccessfulRequest.Object,
MockRolesRepository.RolesRepositorySuccessfulRequest.Object,
MockAppAdminsRepository.AppAdminsRepositorySuccessfulRequest.Object,
MockEmailConfirmationsRepository.EmailConfirmationsRepositorySuccessfulRequest.Object,
MockPasswordResetRepository.PasswordResetsRepositorySuccessfulRequest.Object,
MockEmailService.EmailServiceSuccessfulRequest.Object);
sutRequestPasswordReset = new UsersService(
MockUsersRepository.UsersRepositorySuccessfulRequest.Object,
MockAppsRepository.AppsRepositorySuccessfulRequest.Object,
MockRolesRepository.RolesRepositorySuccessfulRequest.Object,
MockAppAdminsRepository.AppAdminsRepositorySuccessfulRequest.Object,
MockEmailConfirmationsRepository.EmailConfirmationsRepositorySuccessfulRequest.Object,
MockPasswordResetRepository.PasswordResetsRepositorySuccessfullCreateRequest.Object,
MockEmailService.EmailServiceSuccessfulRequest.Object);
baseRequest = TestObjects.GetBaseRequest();
}
public MockSolutionsService(DatabaseContext context)
{
MockSolutionsRepository = new MockSolutionsRepository(context);
MockUsersRepository = new MockUsersRepository(context);
SolutionsServiceSuccessfulRequest = new Mock <ISolutionsService>();
SolutionsServiceFailedRequest = new Mock <ISolutionsService>();
SolutionsServiceSolveFailedRequest = new Mock <ISolutionsService>();
SolutionsServiceSuccessfulRequest.Setup(solutionsService =>
solutionsService.GetSolution(It.IsAny <int>(), It.IsAny <bool>()))
.Returns(Task.FromResult(new SolutionResult()
{
Success = MockSolutionsRepository
.SolutionsRepositorySuccessfulRequest
.Object
.GetById(It.IsAny <int>(), It.IsAny <bool>())
.Result
.Success,
Message = SolutionsMessages.SolutionFoundMessage,
Solution = (SudokuSolution)MockSolutionsRepository
.SolutionsRepositorySuccessfulRequest
.Object
.GetById(It.IsAny <int>(), It.IsAny <bool>())
.Result
.Object
} as ISolutionResult));
SolutionsServiceSuccessfulRequest.Setup(solutionsService =>
solutionsService.GetSolutions(It.IsAny <BaseRequest>(), It.IsAny <bool>()))
.Returns(Task.FromResult(new SolutionsResult()
{
Success = MockSolutionsRepository
.SolutionsRepositorySuccessfulRequest
.Object
.GetAll(It.IsAny <bool>())
.Result
.Success,
Message = SolutionsMessages.SolutionsFoundMessage,
Solutions = MockSolutionsRepository
.SolutionsRepositorySuccessfulRequest
.Object
.GetAll(It.IsAny <bool>())
.Result
.Objects
.ConvertAll(s => (ISudokuSolution)s)
} as ISolutionsResult));
SolutionsServiceSuccessfulRequest.Setup(solutionsService =>
solutionsService.Solve(It.IsAny <ISolutionRequest>()))
.Returns(Task.FromResult(new SolutionResult()
{
Success = true,
Message = SolutionsMessages.SudokuSolutionFoundMessage,
Solution = (SudokuSolution)MockSolutionsRepository
.SolutionsRepositorySuccessfulRequest
.Object
.Create(It.IsAny <SudokuSolution>())
.Result
.Object
} as ISolutionResult));
SolutionsServiceSuccessfulRequest.Setup(solutionsService =>
solutionsService.Generate()).Returns(
Task.FromResult(new SolutionResult()
{
Success = MockSolutionsRepository
.SolutionsRepositorySuccessfulRequest
.Object
.Create(It.IsAny <SudokuSolution>())
.Result
.Success,
Message = SolutionsMessages.SolutionGeneratedMessage,
Solution = (SudokuSolution)MockSolutionsRepository
.SolutionsRepositorySuccessfulRequest
.Object
.Create(It.IsAny <SudokuSolution>())
.Result
.Object
} as ISolutionResult));
SolutionsServiceSuccessfulRequest.Setup(solutionsService =>
solutionsService.AddSolutions(It.IsAny <int>())).Returns(
Task.FromResult(new BaseResult()
{
Success = MockSolutionsRepository
.SolutionsRepositorySuccessfulRequest
.Object
.AddSolutions(It.IsAny <List <ISudokuSolution> >())
.Result
.Success,
Message = SolutionsMessages.SolutionsAddedMessage
} as IBaseResult));
SolutionsServiceFailedRequest.Setup(solutionsService =>
solutionsService.GetSolution(It.IsAny <int>(), It.IsAny <bool>()))
.Returns(Task.FromResult(new SolutionResult()
{
Success = MockSolutionsRepository
.SolutionsRepositoryFailedRequest
.Object
.GetById(It.IsAny <int>(), It.IsAny <bool>())
.Result
.Success,
Message = SolutionsMessages.SolutionNotFoundMessage,
Solution = (SudokuSolution)MockSolutionsRepository
.SolutionsRepositoryFailedRequest
.Object
.GetById(It.IsAny <int>(), It.IsAny <bool>())
.Result
.Object
} as ISolutionResult));
SolutionsServiceFailedRequest.Setup(solutionsService =>
solutionsService.GetSolutions(It.IsAny <BaseRequest>(), It.IsAny <bool>()))
.Returns(Task.FromResult(new SolutionsResult()
{
Success = MockSolutionsRepository
.SolutionsRepositoryFailedRequest
.Object
.GetAll(It.IsAny <bool>())
.Result
.Success,
Message = SolutionsMessages.SolutionsNotFoundMessage,
Solutions = null
} as ISolutionsResult));
SolutionsServiceFailedRequest.Setup(solutionsService =>
solutionsService.Solve(It.IsAny <ISolutionRequest>()))
.Returns(Task.FromResult(new SolutionResult()
{
Success = false,
Message = SolutionsMessages.SudokuSolutionNotFoundMessage,
Solution = (SudokuSolution)MockSolutionsRepository
.SolutionsRepositoryFailedRequest
.Object
.Create(It.IsAny <SudokuSolution>())
.Result
.Object
} as ISolutionResult));
SolutionsServiceFailedRequest.Setup(solutionsService =>
solutionsService.Generate()).Returns(
Task.FromResult(new SolutionResult()
{
Success = MockSolutionsRepository
.SolutionsRepositoryFailedRequest
.Object
.Create(It.IsAny <SudokuSolution>())
.Result
.Success,
Message = SolutionsMessages.SolutionNotGeneratedMessage,
Solution = (SudokuSolution)MockSolutionsRepository
.SolutionsRepositoryFailedRequest
.Object
.Create(It.IsAny <SudokuSolution>())
.Result
.Object
} as ISolutionResult));
SolutionsServiceFailedRequest.Setup(solutionsService =>
solutionsService.AddSolutions(It.IsAny <int>())).Returns(
Task.FromResult(new BaseResult()
{
Success = MockSolutionsRepository
.SolutionsRepositoryFailedRequest
.Object
.AddSolutions(It.IsAny <List <ISudokuSolution> >())
.Result
.Success,
Message = SolutionsMessages.SolutionsNotAddedMessage
} as IBaseResult));
SolutionsServiceSolveFailedRequest.Setup(solutionsService =>
solutionsService.Solve(It.IsAny <ISolutionRequest>()))
.Returns(Task.FromResult(new SolutionResult()
{
Success = true,
Message = SolutionsMessages.SudokuSolutionNotFoundMessage,
Solution = null
} as ISolutionResult));
}
public void Setup()
{
_mockUsersRepository = new MockUsersRepository();
_mockPcPartsRepository = new MockPcPartsRepository();
}
