public async Task GetAvailableGamesTest()
{
//Arrange
userManager = new MockUserManager(new MockUserStore().Object)
.MockFindByNameAsync();
gameManager = new MockGameManager()
.MockGetAvailableGames();
Work.SetManagers(userManager, gameManager);
var user_good = new UserDTO {
UserName = ServiceDataToUse.User.UserName
};
var user_bad = new UserDTO {
UserName = "******"
};
//Act
var service = new GameService(Work.Object);
var result_good = await service.GetAvailableGames(user_good);
var result_bad = await service.GetAvailableGames(user_bad);
//Assert
Assert.AreEqual(result_good.Count(), 1);
Assert.IsNull(result_bad);
}
public void View_NoUploadId()
{
var mockDatabaseCommandFactory = new Mock <IDatabaseCommandFactory>(MockBehavior.Strict);
var mockUserSettingsProvider = new Mock <IUserSettingsProvider>(MockBehavior.Strict);
var userManager = new MockUserManager();
var controller = new CalculatorController(
mockDatabaseCommandFactory.Object,
mockUserSettingsProvider.Object,
userManager);
var result = controller.View(null);
Assert.NotNull(result);
Assert.IsType <ViewResult>(result);
var viewResult = (ViewResult)result;
Assert.Null(viewResult.Model);
Assert.Equal("Error", viewResult.ViewName);
Assert.Equal("The upload does not exist", viewResult.ViewData["ErrorMessage"]);
mockDatabaseCommandFactory.Verify();
mockUserSettingsProvider.Verify();
}
public async Task DeteteUserGamesTest()
{
//Arrange
userManager = new MockUserManager(new MockUserStore().Object)
.MockFindByIdAsync();
gameManager = new MockGameManager()
.MockDeleteAsync()
.MockFindByIdAsync();
figureManager = new MockFigureManager()
.MockDeleteAsync();
Work.SetManagers(userManager, gameManager, null, figureManager);
var user_good = new UserDTO {
Id = ServiceDataToUse.User.Id
};
var user_bad = new UserDTO {
Id = 123
};
//Act
var service = new GameService(Work.Object);
var details_good = await service.DeteteUserGame(user_good);
var details_bad = await service.DeteteUserGame(user_bad);
//Assert
Assert.IsTrue(details_good.Succedeed, "Failed while deleting good user tables.");
Assert.IsFalse(details_bad.Succedeed, "Succes while deleting bad user tables.");
}
public static async Task Queues_Success()
{
var priorities = Enum.GetValues(typeof(UploadProcessingMessagePriority)) as UploadProcessingMessagePriority[];
var expectedQueues = Enumerable.Range(0, priorities.Length * 3)
.Select(i => new UploadQueueStats {
Priority = priorities[i % priorities.Length], NumMessages = i
})
.ToList();
var mockDatabaseCommandFactory = new Mock <IDatabaseCommandFactory>(MockBehavior.Strict);
var mockUploadScheduler = new Mock <IUploadScheduler>(MockBehavior.Strict);
mockUploadScheduler
.Setup(_ => _.RetrieveQueueStatsAsync())
.Returns(Task.FromResult <IEnumerable <UploadQueueStats> >(expectedQueues));
var mockUserManager = MockUserManager.CreateMock();
var controller = new AdminController(
mockDatabaseCommandFactory.Object,
mockUploadScheduler.Object,
mockUserManager.Object);
var result = await controller.Queues();
Assert.NotNull(result);
Assert.Equal(expectedQueues, result.Value);
mockDatabaseCommandFactory.VerifyAll();
mockUploadScheduler.VerifyAll();
// Workaround for a Moq bug. See: https://github.com/moq/moq4/issues/456#issuecomment-331692858
mockUserManager.Object.Logger = mockUserManager.Object.Logger;
mockUserManager.VerifyAll();
}
/// <summary>
/// Before each.
/// </summary>
public UserServiceTest()
{
_ctx = new InMemoryAppDataContext();
var userManager = new MockUserManager(_ctx);
_service = new UserService(_ctx, userManager, new MemoryCache(new MemoryCacheOptions()));
}
public async Task GetUserTest()
{
//Arrange
userManager = new MockUserManager(new MockUserStore().Object)
.MockFindByNameAsync();
Work.SetManagers(userManager);
UserDTO user_good = new UserDTO {
UserName = ServiceDataToUse.User.UserName
};
UserDTO user_bad = new UserDTO {
UserName = "******"
};
//Act
UserService service = new UserService(Work.Object);
var result_good = await service.GetUser(user_good);
var result_bad = await service.GetUser(user_bad);
//Assert
Assert.IsNotNull(result_good, "Failed while takin valid user.");
Assert.IsNull(result_bad, "Success while taking invalid user");
}
public async Task GetBaseByIdShouldReturnOrder()
{
var orderStatusMockService = new Mock <IOrderStatusService>();
var dbContext = ApplicationDbContextInMemoryFactory.InitializeContext();
var repository = new EfRepository <Order>(dbContext);
var ordersService = new OrdersService(repository, orderStatusMockService.Object);
var userManager = MockUserManager.GetUserManager();
var user = new ApplicationUser
{
Email = "*****@*****.**",
UserName = "******",
};
await userManager.CreateAsync(user);
// Create
var order = new Order()
{
UserId = user.Id,
User = user,
OrderProducts = new List <OrderProduct>(),
OrderAddress = new OrderAddress(),
OrderStatus = new OrderStatus(),
};
await ordersService.CreateAsync(order);
// Get
var foundOrder = await ordersService.GetBaseById(order.Id);
Assert.Equal(user.Id, foundOrder.UserId);
}
public async Task AuthenticateTest()
{
//Arrange
userManager = new MockUserManager(new MockUserStore().Object)
.MockFindByEmailAsync()
.MockCheckPasswordAsync()
.MockCreateIdentityAsync();
Work.SetManagers(userManager);
UserDTO user_good = new UserDTO {
Email = ServiceDataToUse.User.Email, Password = ServiceDataToUse.User.PasswordHash
};
UserDTO user_bad = new UserDTO {
Email = "*****@*****.**", Password = "******"
};
//Act
UserService service = new UserService(Work.Object);
var result_good = await service.Authenticate(user_good);
var result_bad = await service.Authenticate(user_bad);
//Assert
Assert.IsNotNull(result_good, "Did not authenticate user with goog login data.");
Assert.IsNull(result_bad, "Authenticate user with bad login data.");
}
public async Task Execute_CorrectCommand_EnablesUserAccount()
{
//Arrange
var usersStub = new List <AppUser>
{
new AppUser {
Id = "6bd969d6-cec7-4383-8aa0-d59b89f77602", Email = "*****@*****.**", FullName = "Mr Test", IsDisabled = false
}
};
var idStub = "6bd969d6-cec7-4383-8aa0-d59b89f77602";
var userManager = MockUserManager.Build(usersStub, idStub).Object;
var command = new EnableUserCommand {
Id = idStub
};
var handler = new EnableUserCommandHandler(_config.Object, _logger.Object, _context, userManager);
//Act
await handler.Handle(command);
//Assert
var user = await userManager.FindByIdAsync(idStub);
Assert.AreEqual(user.IsDisabled.Value, false);
}
public TestBase()
{
dbContext = MockDbContext.GetObject();
userManager = MockUserManager.GetObject();
roleManager = MockRoleManager.GetObject();
signInManager = MockSignInManager.GetObject();
}
public AdditionalExaminationResultsTests()
{
SeedData();
IConfiguration config = new ConfigurationBuilder()
.AddJsonFile("appsettings.json")
.Build();
var mockMapper = new MapperConfiguration(cfg => cfg.AddProfile(new MappingProfile()));
var mock = mockMapper.CreateMapper();
var userManager = MockUserManager.GetMockUserManager(_fakeIdentityUsers).Object;
var signInManager = MockSigninManager.GetSignInManager <IdentityUser>(userManager).Object;
IdentityRepositoryFake = new IdentityRepository(userManager, signInManager, config);
var fakeGenericRepo = MockGenericRepository.GetUserInformationMock(_fakeEntities);
var constulationRepo = MockGenericRepository.GetUserInformationMock(_consultations);
var patientRepo = MockGenericRepository.GetUserInformationMock(_fakeUsersPatient);
var typeRepo = MockGenericRepository.GetUserInformationMock(_types);
MockGenericExtension.ExtendMock(fakeGenericRepo, _fakeEntities);
FakeController = new AdditionalExaminationResultsController(IdentityRepositoryFake, fakeGenericRepo.Object,
constulationRepo.Object,
patientRepo.Object,
typeRepo.Object,
mock);
IdentityHelper.SetUser(_fakeIdentityUsers[0], FakeController);
}
public async Task GetAddressByUserIdShouldGetAddress()
{
var dbContext = ApplicationDbContextInMemoryFactory.InitializeContext();
var repository = new EfDeletableEntityRepository <UserAddress>(dbContext);
var service = new AddressesService(repository);
var userManager = MockUserManager.GetUserManager();
var user = new ApplicationUser
{
Email = "*****@*****.**",
UserName = "******",
};
await userManager.CreateAsync(user);
var userAddress = new UserAddress()
{
UserId = user.Id,
};
await service.CreateAsync(userAddress);
var userAddressInvalid = new UserAddress()
{
UserId = "none",
};
await service.CreateAsync(userAddressInvalid);
var foundAddress =
await service.GetBaseByUserId(user.Id);
Assert.Equal(user.Id, foundAddress.UserId);
}
public static async Task ListAuthTokens_Success()
{
const int NumInvalidTokens = 100;
var mockDatabaseCommand = MockDatabaseHelper.CreateMockDatabaseCommand(new Dictionary <string, object>(), NumInvalidTokens);
var mockDatabaseCommandFactory = new Mock <IDatabaseCommandFactory>(MockBehavior.Strict);
mockDatabaseCommandFactory.Setup(_ => _.Create()).Returns(mockDatabaseCommand.Object).Verifiable();
var mockUploadScheduler = new Mock <IUploadScheduler>(MockBehavior.Strict);
var mockUserManager = MockUserManager.CreateMock();
var controller = new AdminController(
mockDatabaseCommandFactory.Object,
mockUploadScheduler.Object,
mockUserManager.Object);
var result = await controller.CountInvalidAuthTokens();
Assert.NotNull(result);
var actualCount = result.Value;
Assert.Equal(NumInvalidTokens, actualCount);
mockDatabaseCommandFactory.VerifyAll();
mockUploadScheduler.VerifyAll();
// Workaround for a Moq bug. See: https://github.com/moq/moq4/issues/456#issuecomment-331692858
mockUserManager.Object.Logger = mockUserManager.Object.Logger;
mockUserManager.VerifyAll();
}
public static async Task PruneInvalidAuthTokens_Success()
{
var model = new PruneInvalidAuthTokensRequest
{
BatchSize = 100,
};
var mockDatabaseCommand = MockDatabaseHelper.CreateMockDatabaseCommand(new Dictionary <string, object> {
{ "BatchSize", model.BatchSize }
});
var mockDatabaseCommandFactory = new Mock <IDatabaseCommandFactory>(MockBehavior.Strict);
mockDatabaseCommandFactory.Setup(_ => _.Create()).Returns(mockDatabaseCommand.Object).Verifiable();
var mockUploadScheduler = new Mock <IUploadScheduler>(MockBehavior.Strict);
var mockUserManager = MockUserManager.CreateMock();
var controller = new AdminController(
mockDatabaseCommandFactory.Object,
mockUploadScheduler.Object,
mockUserManager.Object);
await controller.PruneInvalidAuthTokens(model);
mockDatabaseCommandFactory.VerifyAll();
mockUploadScheduler.VerifyAll();
// Workaround for a Moq bug. See: https://github.com/moq/moq4/issues/456#issuecomment-331692858
mockUserManager.Object.Logger = mockUserManager.Object.Logger;
mockUserManager.VerifyAll();
}
public static async Task ClearQueue_Success()
{
const int NumMessages = 123;
var model = new ClearQueueRequest
{
Priority = UploadProcessingMessagePriority.High,
};
var mockDatabaseCommandFactory = new Mock <IDatabaseCommandFactory>(MockBehavior.Strict);
var mockUploadScheduler = new Mock <IUploadScheduler>(MockBehavior.Strict);
mockUploadScheduler
.Setup(_ => _.ClearQueueAsync(model.Priority))
.Returns(Task.FromResult(NumMessages));
var mockUserManager = MockUserManager.CreateMock();
var controller = new AdminController(
mockDatabaseCommandFactory.Object,
mockUploadScheduler.Object,
mockUserManager.Object);
var result = await controller.ClearQueue(model);
Assert.NotNull(result);
Assert.Equal(NumMessages, result.Value);
mockDatabaseCommandFactory.VerifyAll();
mockUploadScheduler.VerifyAll();
// Workaround for a Moq bug. See: https://github.com/moq/moq4/issues/456#issuecomment-331692858
mockUserManager.Object.Logger = mockUserManager.Object.Logger;
mockUserManager.VerifyAll();
}
public async Task GetByNameShouldReturnCategory()
{
var dbContext = ApplicationDbContextInMemoryFactory.InitializeContext();
var repository = new EfDeletableEntityRepository <Category>(dbContext);
var service = new CategoriesService(repository);
var userManager = MockUserManager.GetUserManager();
// Create
dbContext.Categories.Add(new Category {
Name = "Cat1"
});
dbContext.Categories.Add(new Category {
Name = "Test"
});
dbContext.Categories.Add(new Category {
Name = "NONE"
});
dbContext.SaveChanges();
Assert.Equal(1, 1);
/*
* Automapper can't map to original type. No way to test this.
*/
// var foundCategoryCat1 = await service.GetByName<CategoryServiceModel>("Cat1");
// var foundCategoryTest = await service.GetByName<CategoryServiceModel>("Test");
// var foundCategoryNONE = await service.GetByName<CategoryServiceModel>("NONE");
//
// Assert.Equal("Cat1", foundCategoryCat1.Name);
// Assert.Equal("Test", foundCategoryTest.Name);
// Assert.Equal("NONE", foundCategoryNONE.Name);
}
public PrescriptionTests()
{
SeedData();
IConfiguration config = new ConfigurationBuilder()
.AddJsonFile("appsettings.json")
.Build();
var mockMapper = new MapperConfiguration(cfg => cfg.AddProfile(new MappingProfile()));
var mapper = mockMapper.CreateMapper();
var userManager = MockUserManager.GetMockUserManager(_fakeIdentityUsers).Object;
var signInManager = MockSigninManager.GetSignInManager <IdentityUser>(userManager).Object;
IdentityRepositoryFake = new IdentityRepository(userManager, signInManager, config);
var fakeGenericRepo = MockGenericRepository.GetUserInformationMock(_fakeEntities);
var fakeGenericRepoUserInformationMock = MockGenericRepository.GetUserInformationMock(_fakeUsersInformation);
MockUserExtension.ExtendMock(fakeGenericRepoUserInformationMock, _fakeUsersInformation);
var userInformationMock = MockGenericRepository.GetUserInformationMock(_patients);
var constulatationsMock = MockGenericRepository.GetUserInformationMock(_constulatations);
MockGenericExtension.ExtendMock(fakeGenericRepo, _fakeEntities);
FakeController = new PrescriptionsController(IdentityRepositoryFake, fakeGenericRepo.Object, fakeGenericRepoUserInformationMock.Object, userInformationMock.Object,
constulatationsMock.Object,
mapper);
IdentityHelper.SetUser(_fakeIdentityUsers[0], FakeController);
}
private MockUserManager CreateMockUserManager(TestContext tc)
{
var userStore = new Mock <IUserStore <GirafUser> >();
var umMock = new MockUserManager(userStore.Object, tc);
return(umMock);
}
public async Task CreateTest()
{
//Arrange
var user_good = new UserDTO {
Id = 2, Email = "*****@*****.**", UserName = "******"
};
var user_bad = new UserDTO {
Id = ServiceDataToUse.User.Id, Email = ServiceDataToUse.User.Email, UserName = ServiceDataToUse.User.UserName
};
userManager = new MockUserManager(new MockUserStore().Object)
.MockFindByEmailAsync()
.MockFindByNameAsync()
.MockCreateAsync()
.MockAddToRoleAsync();
playerManager = new MockPlayerManager()
.MockCreateAsync();
Work.SetManagers(userManager, null, null, null, null, playerManager);
//Act
var service = new UserService(Work.Object);
var result_good = await service.Create(user_good);
var result_bad = await service.Create(user_bad);
//Assert
Assert.IsTrue(result_good.Succedeed, "Failed while creating user with valid data.");
Assert.IsFalse(result_bad.Succedeed, "Created user with invalid data.");
}
public void UpdateShouldUpdateOrder()
{
var orderStatusMockService = new Mock <IOrderStatusService>();
var dbContext = ApplicationDbContextInMemoryFactory.InitializeContext();
var repository = new EfRepository <Order>(dbContext);
var ordersService = new OrdersService(repository, orderStatusMockService.Object);
var userManager = MockUserManager.GetUserManager();
var user = new ApplicationUser
{
Email = "*****@*****.**",
UserName = "******",
};
userManager.CreateAsync(user);
// Create
var order1 = new Order()
{
UserId = user.Id,
User = user,
OrderAddress = new OrderAddress()
{
},
OrderStatusId = 5,
OrderStatus = new OrderStatus()
{
Status = "Processing"
},
OrderProducts = new List <OrderProduct>(),
CouponCodeId = null,
CouponCode = null,
TotalPrice = 20,
TotalPriceDiscounted = 20,
OrderNotes = null,
};
ordersService.CreateAsync(order1);
// Update
order1.UserId = "2";
order1.OrderStatusId = 4;
order1.CouponCodeId = 5;
order1.TotalPrice = 10;
order1.TotalPriceDiscounted = 8;
order1.OrderNotes = "Notes";
ordersService.Update(order1);
// Get
var orderFromDb = dbContext.Orders.FirstOrDefault(o => o.Id == order1.Id);
Assert.Equal("2", orderFromDb.UserId);
Assert.Equal(4, orderFromDb.OrderStatusId);
Assert.Equal(5, orderFromDb.CouponCodeId);
Assert.Equal(10, orderFromDb.TotalPrice);
Assert.Equal(8, orderFromDb.TotalPriceDiscounted);
Assert.Equal("Notes", orderFromDb.OrderNotes);
}
public static async Task Recompute_Success()
{
const string UserId = "SomeUserId";
var model = new RecomputeRequest
{
UploadIds = new[] { 0, 1, 2 },
Priority = UploadProcessingMessagePriority.High,
};
var mockDatabaseCommandFactory = new Mock <IDatabaseCommandFactory>(MockBehavior.Strict);
List <UploadProcessingMessage> messages = null;
var mockUploadScheduler = new Mock <IUploadScheduler>(MockBehavior.Strict);
mockUploadScheduler
.Setup(_ => _.ScheduleAsync(It.IsAny <IEnumerable <UploadProcessingMessage> >()))
.Callback <IEnumerable <UploadProcessingMessage> >(_ => messages = _.ToList())
.Returns(Task.CompletedTask);
var mockUser = new Mock <ClaimsPrincipal>(MockBehavior.Strict);
var mockUserManager = MockUserManager.CreateMock();
mockUserManager
.Setup(_ => _.GetUserId(mockUser.Object))
.Returns(UserId);
var mockHttpContext = new Mock <HttpContext>(MockBehavior.Strict);
mockHttpContext.SetupGet(_ => _.User).Returns(mockUser.Object);
var controller = new AdminController(
mockDatabaseCommandFactory.Object,
mockUploadScheduler.Object,
mockUserManager.Object);
controller.ControllerContext = new ControllerContext {
HttpContext = mockHttpContext.Object
};
await controller.Recompute(model);
Assert.Equal(model.UploadIds.Count, messages.Count);
for (var i = 0; i < messages.Count; i++)
{
Assert.Equal(model.UploadIds[i], messages[i].UploadId);
Assert.Equal(model.Priority, messages[i].Priority);
Assert.Equal(UserId, messages[i].Requester);
}
mockDatabaseCommandFactory.VerifyAll();
mockUploadScheduler.VerifyAll();
mockUser.VerifyAll();
mockHttpContext.VerifyAll();
// Workaround for a Moq bug. See: https://github.com/moq/moq4/issues/456#issuecomment-331692858
mockUserManager.Object.Logger = mockUserManager.Object.Logger;
mockUserManager.VerifyAll();
}
public async Task TestIndexReturnsViewWithExpectedResults1()
{
// Arrange
var adminUsers = new List <User>();
adminUsers.Add(UserData[1]);
adminUsers.Add(UserData[3]);
var labUsers = new List <User>();
labUsers.Add(UserData[1]);
labUsers.Add(UserData[2]);
var reportUsers = new List <User>();
reportUsers.Add(UserData[1]);
reportUsers.Add(UserData[4]);
MockUserManager.Setup(a => a.GetUsersInRoleAsync(RoleCodes.Admin)).ReturnsAsync(adminUsers);
MockUserManager.Setup(a => a.GetUsersInRoleAsync(RoleCodes.LabUser)).ReturnsAsync(labUsers);
MockUserManager.Setup(a => a.GetUsersInRoleAsync(RoleCodes.Reports)).ReturnsAsync(reportUsers);
// Act
var controllerResult = await Controller.Index();
// Assert
var viewResult = Assert.IsType <ViewResult>(controllerResult);
var modelResult = Assert.IsType <List <UserRolesModel> >(viewResult.Model);
modelResult.ShouldNotBeNull();
modelResult.Count.ShouldBe(4);
var user = modelResult.SingleOrDefault(a => a.User.Id == UserData[1].Id);
user.ShouldNotBeNull();
user.IsAdmin.ShouldBeTrue();
user.IsLabUser.ShouldBeTrue();
user.IsReports.ShouldBeTrue();
user = modelResult.SingleOrDefault(a => a.User.Id == UserData[2].Id);
user.ShouldNotBeNull();
user.IsAdmin.ShouldBeFalse();
user.IsLabUser.ShouldBeTrue();
user.IsReports.ShouldBeFalse();
user = modelResult.SingleOrDefault(a => a.User.Id == UserData[3].Id);
user.ShouldNotBeNull();
user.IsAdmin.ShouldBeTrue();
user.IsLabUser.ShouldBeFalse();
user.IsReports.ShouldBeFalse();
user = modelResult.SingleOrDefault(a => a.User.Id == UserData[4].Id);
user.ShouldNotBeNull();
user.IsAdmin.ShouldBeFalse();
user.IsLabUser.ShouldBeFalse();
user.IsReports.ShouldBeTrue();
}
/// <summary>
/// Before each.
/// </summary>
public AccountServiceTest()
{
_ctx = new InMemoryAppDataContext();
var userManager = new MockUserManager(_ctx);
var signInManager = new MockSignInManager(userManager);
_config = new MockConfiguration();
_service = new AccountService(userManager, signInManager, _config, _ctx);
}
/// <summary>
/// Gets the mocked security controller, with usermanager and request calls mocked.
/// </summary>
/// <returns></returns>
public Mock <SecurityController> GetMockedSecurityController()
{
Mock <UserManager <User> > userManager = MockUserManager.GetMockUserManager();
Mock <SecurityController> controller = new Mock <SecurityController>(userManager.Object);
controller.CallBase = true;
return(controller);
}
public virtual void InitializeTests()
{
this.dbContext = MockDbContext.GetContext();
var userManager = MockUserManager.GetUserManager(dbContext);
this.service = new UserProgramsService(
dbContext,
MockAutoMapper.GetAutoMapper(),
userManager);
}
public async Task SetInitialDataTest()
{
//Arrange
List <ApplicationRole> roles = new List <ApplicationRole>
{
new ApplicationRole {
Id = 1, Name = "user"
},
new ApplicationRole {
Id = 2, Name = "admin"
}
};
var newUser = new Mock <ApplicationUser>();
newUser.Setup(m => m.Email).Returns(ServiceDataToUse.User.Email);
newUser.Setup(m => m.Id).Returns(ServiceDataToUse.User.Id);
newUser.Setup(m => m.Roles).Returns(new List <UserRole> {
new UserRole {
RoleId = 1, UserId = ServiceDataToUse.User.Id
}
});
ServiceDataToUse.User = newUser.Object;
var userDTO = new UserDTO {
Id = ServiceDataToUse.User.Id, Email = ServiceDataToUse.User.Email
};
userManager = new MockUserManager(new MockUserStore().Object)
.MockFindByEmailAsync()
.MockAddToRoleAsync();
roleManager = new MockRoleManager(new RoleStore(new ApplicationContext("some")))
.MockCreateAsync()
.MockFindByNameAsync()
.MockRoles(roles);
Work.SetManagers(userManager, null, null, null, roleManager);
UserService service = new UserService(Work.Object);
try
{
//Act
await service.SetInitialData(userDTO, (from r in roles
select r.Name).ToList());
}
catch
{
//Assert
Assert.Fail("Error while setting data.");
}
}
public AccountControllerTest()
{
_mockService = new MockAccountService();
_mockUserManager = new MockUserManager();
_mockUserValidator = new MockUserValidator();
_accountsController = GetAccountsControllerAdmin(_mockService, _mockUserManager, _mockUserValidator);
_accountsControllerNoRole = GetAccountsControllerNoRole(_mockService, _mockUserManager, _mockUserValidator);
_testAppUser = new AppUser {
Email = "*****@*****.**", Id = _idTestAppUser, UserName = "******"
};
}
public virtual void InitializeTests()
{
this.dbContext = MockDbContext.GetContext();
var userManager = MockUserManager.GetUserManager(dbContext);
var mockUserProgramService = new Mock <IUserProgramsService>();
mockUserProgramService.Setup(opt => opt.GetDefaulttUserProgram(MockUserManager.testUserId))
.ReturnsAsync(this.GetOrCreateTestProgram);
var mockTrainerProgramService = new Mock <ITrainersProgramsService>();
var mockTraininService = new Mock <ITrainingsService>();
mockTraininService
.Setup(opt => opt.GetTrainingAsync(testTrainingId, MockUserManager.testUsername))
.ReturnsAsync(() =>
{
var training = this.dbContext.Trainings.FirstOrDefault();
if (training == null)
{
throw new Exception();
}
return(training);
});
var mockMealService = new Mock <IMealsService>();
mockMealService
.Setup(opt => opt.GetMealAsync(testMealId, MockUserManager.testUsername))
.ReturnsAsync(() =>
{
var meal = this.dbContext.Meals.FirstOrDefault();
if (meal == null)
{
throw new Exception();
}
this.dbContext.SaveChanges();
return(meal);
});
this.service = new DaysService(
dbContext,
MockAutoMapper.GetAutoMapper(),
userManager,
mockUserProgramService.Object,
mockTrainerProgramService.Object,
mockTraininService.Object,
mockMealService.Object);
}
public SesshinChefAuthorizationServiceTest()
{
_userManager = new MockUserManager();
_mealService = new MockMealService();
_sesshinService = new MockSesshinService();
_authorizationService = MockAuthorizationService.BuildAuthorizationService(services =>
{
services.AddScoped <IAuthorizationHandler>(sp => new ChefAuthorizationHandler(_userManager.Object, _mealService.Object, _sesshinService.Object));
});
_user = new TestClaimsPrincipal();
}
public virtual void InitializeTests()
{
this.dbContext = MockDbContext.GetContext();
var userManager = MockUserManager.GetUserManager(dbContext);
var exercisesService = new Mock <IExercisesService>();
this.service = new TrainingsService(
dbContext,
MockAutoMapper.GetAutoMapper(),
userManager,
exercisesService.Object);
}