public void InitializeMocks(T loggerClass)
{
_loggerMock = LoggerMock.SetupMock(loggerClass);
_logger = _loggerMock.Object;
BaseMock.ShouldThrowException = false;
_httpContextMock = HttpContextMock.SetupHttpContextMock();
_httpContext = _httpContextMock.Object;
_dateTimeUtil = new DateTimeUtilMock();
_tokenHandler = JwtSecurityTokenHandlerMock.SetupMock().Object;
DbContextMock.ShouldThrowException = false;
DbContextMock.SaveChangesResult = 1;
_dbContextMock = DbContextMock.SetupDbContext <IApplicationDbContext>();
_dbContext = _dbContextMock.Object;
_tokenRepositoryMock = TokenRepositoryMock.SetupMock(_dbContext, _dateTimeUtil);
_tokenRepository = _tokenRepositoryMock.Object;
_usersRepositoryMock = UsersRepositoryMock.SetupMock(_dbContext, _dateTimeUtil);
_usersRepository = _usersRepositoryMock.Object;
_authServiceMock = AuthServiceMock.SetupMock(_usersRepository,
_tokenRepository,
_dateTimeUtil,
_logger as IEMSLogger <AuthService>,
_tokenHandler);
_authService = _authServiceMock.Object;
_usersServiceMock = UsersServiceMock.SetupMock(_usersRepository,
_logger as IEMSLogger <UsersService>, _dateTimeUtil);
_usersService = _usersServiceMock.Object;
}
public static Mock <UsersService> SetupMock(IUsersRepository usersRepository,
IEMSLogger <UsersService> logger,
IDateTimeUtil dateTimeUtil)
{
Mock <UsersService> mock = new(usersRepository, logger, dateTimeUtil);
UsersService service = new(usersRepository, logger, dateTimeUtil);
mock.Setup(m => m.AddAsync(It.IsAny <User>())).Returns <User>((user) =>
{
return(service.AddAsync(user));
});
mock.Setup(m => m.UpdateAsync(It.IsAny <User>())).Returns <User>((user) =>
{
return(service.UpdateAsync(user));
});
mock.Setup(m => m.DeleteAsync(It.IsAny <User>())).Returns <User>((user) =>
{
return(service.DeleteAsync(user));
});
mock.Setup(m => m.GetById(It.IsAny <long>())).Returns <long>((id) =>
{
return(service.GetById(id));
});
return(mock);
}
public MotivationModificatorsService(IMotivationModificatorRepository motivationModificatorRepository,
IEMSLogger <MotivationModificatorsService> logger,
IDateTimeUtil dateTimeUtil)
{
_motivationModificatorRepository = motivationModificatorRepository;
_logger = logger;
_dateTimeUtil = dateTimeUtil;
}
public AuthService(IUsersRepository usersRepository,
ITokenRepository tokenRepository,
IDateTimeUtil dateTimeUtil,
IEMSLogger <AuthService> logger,
JwtSecurityTokenHandler jwtSecurityTokenHandler) : base(logger, dateTimeUtil)
{
_tokenRepository = tokenRepository;
_usersRepository = usersRepository;
_jwtSecurityTokenHandler = jwtSecurityTokenHandler;
}
public SalaryService(IEMSLogger <SalaryService> logger,
IStaffRepository staffRepository,
IDayOffRepository dayOffRepository,
IHolidaysRepository holidaysRepository,
IPositionsRepository positionsRepository,
IMotivationModificatorRepository motivationModificatorRepository,
IOtherPaymentsRepository otherPaymentsRepository,
IDateTimeUtil dateTimeUtil)
{
_logger = logger;
_staffRepository = staffRepository;
_dayOffRepository = dayOffRepository;
_holidaysRepository = holidaysRepository;
_positionsRepository = positionsRepository;
_motivationModificatorRepository = motivationModificatorRepository;
_otherPaymentsRepository = otherPaymentsRepository;
_dateTimeUtil = dateTimeUtil;
}
public static Mock <AuthService> SetupMock(IUsersRepository usersRepository,
ITokenRepository tokenRepository,
IDateTimeUtil dateTimeUtil,
IEMSLogger <AuthService> logger,
JwtSecurityTokenHandler jwtSecurityTokenHandler)
{
Mock <AuthService> mock = new(usersRepository, tokenRepository, dateTimeUtil, logger, jwtSecurityTokenHandler);
AuthService service = new(usersRepository, tokenRepository, dateTimeUtil, logger, jwtSecurityTokenHandler);
mock.Setup(m => m.AuthUserAsync(It.IsAny <LoginUserRequest>())).Returns <LoginUserRequest>((request) =>
{
return(service.AuthUserAsync(request));
});
mock.Setup(m => m.RefreshTokenAsync(It.IsAny <TokenData>())).Returns <TokenData>((tokenData) =>
{
return(service.RefreshTokenAsync(tokenData));
});
return(mock);
}
protected void InitializeMocks()
{
// DB context
DbContextMock.ShouldThrowException = false;
DbContextMock.SaveChangesResult = 1;
_dbContextMock = DbContextMock.SetupDbContext <IApplicationDbContext>();
_dbContext = _dbContextMock.Object;
// Utils
_dateTimeUtil = new DateTimeUtilMock();
// Repositories
BaseMock.ShouldThrowException = false;
_teamsRepositoryMock = TeamsRepositoryMock.SetupMock(_dbContext, _dateTimeUtil);
_teamsRepository = _teamsRepositoryMock.Object;
_positionsRepositoryMock = PositionsRepositoryMock.SetupMock(_dbContext, _dateTimeUtil);
_positionsRepository = _positionsRepositoryMock.Object;
_dayOffRepositoryMock = DayOffsRepositoryMock.SetupMock(_dbContext, _dateTimeUtil);
_dayOffRepository = _dayOffRepositoryMock.Object;
_holidaysRepositoryMock = HolidaysRepositoryMock.SetupMock(_dbContext, _dateTimeUtil);
_holidaysRepository = _holidaysRepositoryMock.Object;
_motivationModificatorRepositoryMock = MotivationModificatorRepositoryMock.SetupMock(_dbContext, _dateTimeUtil);
_motivationModificatorRepository = _motivationModificatorRepositoryMock.Object;
_otherPaymentsRepositoryMock = OtherPaymentsRepositoryMock.SetupMock(_dbContext, _dateTimeUtil);
_otherPaymentsRepository = _otherPaymentsRepositoryMock.Object;
_peopleRepositoryMock = PeopleRepositoryMock.SetupMock(_dbContext, _dateTimeUtil);
_peopleRepository = _peopleRepositoryMock.Object;
_staffRepositoryMock = StaffRepositoryMock.SetupMock(_dbContext, _dateTimeUtil);
_staffRepository = _staffRepositoryMock.Object;
_roadMapRepositoryMock = RoadMapRepositoryMock.SetupMock(_dbContext, _dateTimeUtil);
_roadMapRepository = _roadMapRepositoryMock.Object;
}
public void InitializeMocks()
{
BaseMock.Response = null;
BaseMock.ShouldThrowException = false;
_dateTimeUtil = new DateTimeUtilMock();
_teamsClientMock = TeamsClientMock.SetupMock();
_teamsClient = _teamsClientMock.Object;
_positionsClientMock = PositionsClientMock.SetupMock();
_positionsClient = _positionsClientMock.Object;
_holidaysClientMock = HolidaysClientMock.SetupMock();
_holidaysClient = _holidaysClientMock.Object;
_dayOffsClientMock = DayOffsClientMock.SetupMock();
_dayOffsClient = _dayOffsClientMock.Object;
_motivationModificatorsClientMock = MotivationModificatorsClientMock.SetupMock();
_motivationModificatorsClient = _motivationModificatorsClientMock.Object;
_otherPaymentsClientMock = OtherPaymentsClientMock.SetupMock();
_otherPaymentsClient = _otherPaymentsClientMock.Object;
_salaryClientMock = SalaryClientMock.SetupMock();
_salaryClient = _salaryClientMock.Object;
_staffsClientMock = StaffClientMock.SetupMock();
_staffsClient = _staffsClientMock.Object;
_peopleClientMock = PeopleClientMock.SetupMock();
_peopleClient = _peopleClientMock.Object;
_roadMapsClientMock = RoadMapsClientMock.SetupMock();
_roadMapsClient = _roadMapsClientMock.Object;
}
public static Mock <StaffRepository> SetupMock(IApplicationDbContext dbContext, IDateTimeUtil dateTimeUtil)
{
Mock <StaffRepository> mock = new(dbContext, dateTimeUtil);
StaffRepository repository = new(dbContext, dateTimeUtil);
mock.Setup(m => m.AddAsync(It.IsAny <Staff>())).Returns <Staff>((staff) =>
{
return(repository.AddAsync(staff));
});
mock.Setup(m => m.UpdateAsync(It.IsAny <Staff>())).Returns <Staff>((staff) =>
{
return(repository.UpdateAsync(staff));
});
mock.Setup(m => m.DeleteAsync(It.IsAny <Staff>())).Returns <Staff>((staff) =>
{
return(repository.DeleteAsync(staff));
});
mock.Setup(m => m.GetAll()).Returns(() =>
{
ThrowExceptionIfNeeded();
return(repository.GetAll());
});
mock.Setup(m => m.GetByManagerId(It.IsAny <long>())).Returns <long>((managerId) =>
{
ThrowExceptionIfNeeded();
return(repository.GetByManagerId(managerId));
});
mock.Setup(m => m.GetByPersonId(It.IsAny <long>())).Returns <long>((personId) =>
{
ThrowExceptionIfNeeded();
return(repository.GetByPersonId(personId));
});
return(mock);
}
public OtherPaymentsService(IOtherPaymentsRepository otherPaymentsRepository, IEMSLogger <OtherPaymentsService> logger, IDateTimeUtil dateTimeUtil)
{
_logger = logger;
_dateTimeUtil = dateTimeUtil;
_otherPaymentsRepository = otherPaymentsRepository;
}
public static Mock <MotivationModificatorRepository> SetupMock(IApplicationDbContext dbContext, IDateTimeUtil dateTimeUtil)
{
Mock <MotivationModificatorRepository> mock = new(dbContext, dateTimeUtil);
MotivationModificatorRepository repository = new(dbContext, dateTimeUtil);
mock.Setup(m => m.AddAsync(It.IsAny <MotivationModificator>())).Returns <MotivationModificator>((modificator) =>
{
return(repository.AddAsync(modificator));
});
mock.Setup(m => m.UpdateAsync(It.IsAny <MotivationModificator>())).Returns <MotivationModificator>((modificator) =>
{
return(repository.UpdateAsync(modificator));
});
mock.Setup(m => m.GetByStaffId(It.IsAny <long>())).Returns <long>((staffId) =>
{
ThrowExceptionIfNeeded();
return(repository.GetByStaffId(staffId));
});
return(mock);
}
public BaseService(IEMSLogger <T> logger, IDateTimeUtil dateTimeUtil)
{
_logger = logger;
_dateTimeUtil = dateTimeUtil;
}
public static Mock <OtherPaymentsRepository> SetupMock(IApplicationDbContext dbContext, IDateTimeUtil dateTimeUtil)
{
Mock <OtherPaymentsRepository> mock = new(dbContext, dateTimeUtil);
OtherPaymentsRepository repository = new(dbContext, dateTimeUtil);
mock.Setup(m => m.AddAsync(It.IsAny <OtherPayment>())).Returns <OtherPayment>((payment) =>
{
return(repository.AddAsync(payment));
});
mock.Setup(m => m.UpdateAsync(It.IsAny <OtherPayment>())).Returns <OtherPayment>((payment) =>
{
return(repository.UpdateAsync(payment));
});
mock.Setup(m => m.DeleteAsync(It.IsAny <OtherPayment>())).Returns <OtherPayment>((payment) =>
{
return(repository.DeleteAsync(payment));
});
mock.Setup(m => m.GetByPersonId(It.IsAny <long>())).Returns <long>((personId) =>
{
ThrowExceptionIfNeeded();
return(repository.GetByPersonId(personId));
});
mock.Setup(m => m.GetByPersonIdAndDateRange(It.IsAny <long>(), It.IsAny <DateTime>(), It.IsAny <DateTime>())).Returns <long, DateTime, DateTime>(
(personId, start, end) =>
{
ThrowExceptionIfNeeded();
return(repository.GetByPersonIdAndDateRange(personId, start, end));
});
return(mock);
}
public HolidaysController(HolidaysClient holidaysClient, IEMSLogger <HolidaysController> logger, IDateTimeUtil dateTimeUtil) :
base(logger, dateTimeUtil)
{
_holidaysClient = holidaysClient;
}
public HolidaysService(IHolidaysRepository holidaysRepository, IEMSLogger <HolidaysService> logger, IDateTimeUtil dateTimeUtil)
{
_holidaysRepository = holidaysRepository;
_logger = logger;
_dateTimeUtil = dateTimeUtil;
}
public StaffService(IStaffRepository staffRepository, IEMSLogger <StaffService> logger, IDateTimeUtil dateTimeUtil)
{
_staffRepository = staffRepository;
_logger = logger;
_dateTimeUtil = dateTimeUtil;
}
public PositionsService(IPositionsRepository positionsRepository, IEMSLogger <PositionsService> logger, IDateTimeUtil dateTimeUtil)
{
_positionsRepository = positionsRepository;
_logger = logger;
_dateTimeUtil = dateTimeUtil;
}
public MotivationModificatorRepository(IApplicationDbContext context, IDateTimeUtil dateTimeUtil) : base(context, dateTimeUtil)
{
}
public static Mock <TokenRepository> SetupMock(IApplicationDbContext applicationDbContext, IDateTimeUtil dateTimeUtil)
{
Mock <TokenRepository> mock = new(applicationDbContext, dateTimeUtil);
TokenRepository repository = new(applicationDbContext, dateTimeUtil);
mock.Setup(m => m.SaveTokenAsync(It.IsAny <UserToken>())).Returns <UserToken>((token) =>
{
ThrowExceptionIfNeeded();
return(repository.SaveTokenAsync(token));
});
mock.Setup(m => m.DisableRefreshTokenAsync(It.IsAny <string>())).Returns <string>((token) =>
{
ThrowExceptionIfNeeded();
return(repository.DisableRefreshTokenAsync(token));
});
mock.Setup(m => m.GetTokenData(It.IsAny <string>())).Returns <string>((token) =>
{
return(repository.GetTokenData(token));
});
return(mock);
}
public static Mock <PeopleRepository> SetupMock(IApplicationDbContext dbContext, IDateTimeUtil dateTimeUtil)
{
Mock <PeopleRepository> mock = new(dbContext, dateTimeUtil);
PeopleRepository repository = new(dbContext, dateTimeUtil);
mock.Setup(m => m.AddAsync(It.IsAny <Person>())).Returns <Person>((person) =>
{
return(repository.AddAsync(person));
});
mock.Setup(m => m.UpdateAsync(It.IsAny <Person>())).Returns <Person>((person) =>
{
return(repository.UpdateAsync(person));
});
mock.Setup(m => m.AddContactAsync(It.IsAny <Contact>())).Returns <Contact>((contact) =>
{
return(repository.AddContactAsync(contact));
});
mock.Setup(m => m.AddPhotoAsync(It.IsAny <PersonPhoto>())).Returns <PersonPhoto>((photo) =>
{
return(repository.AddPhotoAsync(photo));
});
mock.Setup(m => m.GetAll()).Returns(() =>
{
ThrowExceptionIfNeeded();
return(repository.GetAll());
});
mock.Setup(m => m.GetById(It.IsAny <long>())).Returns <long>((id) =>
{
ThrowExceptionIfNeeded();
return(repository.GetById(id));
});
return(mock);
}
public DayOffsController(DayOffsClient dayOffsClient, IEMSLogger <DayOffsController> logger, IDateTimeUtil dateTimeUtil) :
base(logger, dateTimeUtil)
{
_dayOffsClient = dayOffsClient;
}
public PeopleController(PeopleClient peopleClient, IEMSLogger <PeopleController> logger, IDateTimeUtil dateTimeUtil) :
base(logger, dateTimeUtil)
{
_peopleClient = peopleClient;
}
public RoadMapsService(IRoadMapRepository roadMapRepository, IEMSLogger <RoadMapsService> logger, IDateTimeUtil dateTimeUtil)
{
_roadMapRepository = roadMapRepository;
_logger = logger;
_dateTimeUtil = dateTimeUtil;
}
public HolidaysRepository(IApplicationDbContext applicationDbContext, IDateTimeUtil dateTimeUtil) : base(applicationDbContext, dateTimeUtil)
{
}
public PositionsRepository(IApplicationDbContext context, IDateTimeUtil dateTimeUtil) : base(context, dateTimeUtil)
{
}
public static Mock <UsersRepository> SetupMock(IApplicationDbContext applicationDbContext, IDateTimeUtil dateTimeUtil)
{
Mock <UsersRepository> mock = new(applicationDbContext, dateTimeUtil);
UsersRepository repository = new(applicationDbContext, dateTimeUtil);
mock.Setup(m => m.VerifyUser(It.IsAny <string>(), It.IsAny <string>())).Returns <string, string>((login, password) =>
{
ThrowExceptionIfNeeded();
return(repository.VerifyUser(login, password));
});
mock.Setup(m => m.AddAsync(It.IsAny <User>())).Returns <User>((user) =>
{
return(repository.AddAsync(user));
});
mock.Setup(m => m.UpdateAsync(It.IsAny <User>())).Returns <User>((user) =>
{
return(repository.UpdateAsync(user));
});
mock.Setup(m => m.DeleteAsync(It.IsAny <User>())).Returns <User>((user) =>
{
return(repository.DeleteAsync(user));
});
mock.Setup(m => m.GetById(It.IsAny <long>())).Returns <long>((id) =>
{
ThrowExceptionIfNeeded();
return(repository.GetById(id));
});
return(mock);
}
public TeamsController(Teams.TeamsClient teamsClient, IEMSLogger <TeamsController> logger, IDateTimeUtil dateTimeUtil) :
base(logger, dateTimeUtil)
{
_teamsClient = teamsClient;
}
public DayOffsService(IDayOffRepository dayOffRepository, IEMSLogger <DayOffsService> logger, IDateTimeUtil dateTimeUtil)
{
_dateTimeUtil = dateTimeUtil;
_dayOffRepository = dayOffRepository;
_logger = logger;
}
public TeamsService(ITeamsRepository teamsRepository, IDateTimeUtil dateTimeUtil, IEMSLogger <TeamsService> logger)
{
_teamsRepository = teamsRepository;
_dateTimeUtil = dateTimeUtil;
_logger = logger;
}
public CossClient(ICossSignator signator, IDateTimeUtil dateTimeUtil, IHttpWebClient httpWebClient)
{
_signator = signator;
_dateTimeUtil = dateTimeUtil;
_httpWebClient = httpWebClient;
}
