public async Task DeleteChallenge_ReturnsRedirectAction_IfChallengeDeleted() { // Arrange var mockUserManager = new FakeUserManager(); var mockLoggerFactory = new Mock <ILoggerFactory>(); var mockLogger = new Mock <ILogger>(); mockLoggerFactory.Setup(f => f.CreateLogger(It.IsAny <string>())) .Returns(mockLogger.Object); var mockMapper = new Mock <IMapper>(); var mockChallengeService = new Mock <IChallengeService>(); mockChallengeService.Setup(c => c.DeleteChallengeAsync(It.IsAny <int>(), It.IsAny <int>())) .ReturnsAsync(true) // Delete challenge success .Verifiable(); var challengeController = new ChallengeController( mockUserManager, mockLoggerFactory.Object, mockMapper.Object, mockChallengeService.Object ); // Act var result = await challengeController.DeleteChallenge(It.IsAny <int>()) as RedirectToActionResult; // Assert Assert.IsType <RedirectToActionResult>(result); Assert.Equal("Challenges", result.ActionName); }
public async Task PostResults_RedirectToAction_WhenDatabaseSuccess() { // Arrange var mockUserManager = new FakeUserManager(); var mockLoggerFactory = new Mock <ILoggerFactory>(); var mockLogger = new Mock <ILogger>(); mockLoggerFactory.Setup(f => f.CreateLogger(It.IsAny <string>())) .Returns(mockLogger.Object); var mockMapper = new Mock <IMapper>(); mockMapper.Setup(m => m.Map <ChallengeResultDto>(It.IsAny <ChallengeResultViewModel>())) .Returns(new ChallengeResultDto()) .Verifiable(); var mockChallengeService = new Mock <IChallengeService>(); mockChallengeService.Setup(c => c.SetResultAsync(It.IsAny <ChallengeResultDto>())) .ReturnsAsync(true) .Verifiable(); var challengeResultViewModel = new ChallengeResultViewModel(); var challengeController = new ChallengeController( mockUserManager, mockLoggerFactory.Object, mockMapper.Object, mockChallengeService.Object ); // Act var result = await challengeController.PostResults(challengeResultViewModel) as RedirectToActionResult; // Assert Assert.IsType <RedirectToActionResult>(result); Assert.Equal("Challenges", result.ActionName); }
public async Task DeleteChallenge_ReturnsStatusCode500_IfChallengeNotDeleted() { // Arrange var mockUserManager = new FakeUserManager(); var mockLoggerFactory = new Mock <ILoggerFactory>(); var mockLogger = new Mock <ILogger>(); mockLoggerFactory.Setup(f => f.CreateLogger(It.IsAny <string>())) .Returns(mockLogger.Object); var mockMapper = new Mock <IMapper>(); var mockChallengeService = new Mock <IChallengeService>(); mockChallengeService.Setup(c => c.DeleteChallengeAsync(It.IsAny <int>(), It.IsAny <int>())) .ReturnsAsync(false) // Delete challenge error .Verifiable(); var challengeController = new ChallengeController( mockUserManager, mockLoggerFactory.Object, mockMapper.Object, mockChallengeService.Object ); // Act var result = await challengeController.DeleteChallenge(It.IsAny <int>()) as StatusCodeResult; // Assert Assert.IsType <StatusCodeResult>(result); Assert.Equal(500, result.StatusCode); }
public async Task Workouts_ReturnsAViewErrorResult_WithEmptyListofWorkouts() { // Arrange var mockUserManager = new FakeUserManager(); var mockMapper = new Mock <IMapper>(); var mockLoggerFactory = new Mock <ILoggerFactory>(); var mockLogger = new Mock <ILogger>(); mockLoggerFactory.Setup(l => l.CreateLogger(It.IsAny <string>())).Returns(mockLogger.Object); var mockWorkoutService = new Mock <IWorkoutService>(); mockWorkoutService.Setup(w => w.GetAllWorkoutsAsync(It.IsAny <int>())) .ReturnsAsync((List <WorkoutDto>)null) .Verifiable(); // Return empty list of workouts var mockExerciseService = new Mock <IExerciseService>(); var mockChallengeService = new Mock <IChallengeService>(); var mockWorkoutRepository = new Mock <IWorkoutRepository>(); var workoutController = new WorkoutController( mockLoggerFactory.Object, mockMapper.Object, mockWorkoutService.Object, mockExerciseService.Object, mockUserManager, mockWorkoutRepository.Object, mockChallengeService.Object); // Act var viewResult = await workoutController.Workouts() as ViewResult; // Assert Assert.IsType <ViewResult>(viewResult); Assert.Equal("/Error", viewResult.ViewName); }
public async Task ShareResult_ReturnsViewResultWithModel_IfChallengeExists() { // Arrange var mockUserManager = new FakeUserManager(); var mockLoggerFactory = new Mock <ILoggerFactory>(); var mockLogger = new Mock <ILogger>(); mockLoggerFactory.Setup(f => f.CreateLogger(It.IsAny <string>())) .Returns(mockLogger.Object); var mockMapper = new Mock <IMapper>(); mockMapper.Setup(m => m.Map <ShareChallengeViewModel>(It.IsAny <ChallengeDto>())) .Returns(new ShareChallengeViewModel()) .Verifiable(); var mockChallengeService = new Mock <IChallengeService>(); mockChallengeService.Setup(c => c.GetChallengeAsync(It.IsAny <int>())) .ReturnsAsync(new ChallengeDto()) // Challenge exists .Verifiable(); var challengeController = new ChallengeController( mockUserManager, mockLoggerFactory.Object, mockMapper.Object, mockChallengeService.Object ); // Act var result = await challengeController.ShareResult(It.IsAny <int>()) as ViewResult; // Assert Assert.IsType <ViewResult>(result); var model = Assert.IsType <ShareChallengeViewModel>(result.Model); // Assert.Equal(0, model.Reps); // TODO assert on all properties }
public async Task Challenge_ReturnsViewError_IfEmptyUser() { // Arrange var mockUserManager = new FakeUserManager(); var mockMapper = new Mock <IMapper>(); var mockLoggerFactory = new Mock <ILoggerFactory>(); var mockLogger = new Mock <ILogger>(); mockLoggerFactory.Setup(l => l.CreateLogger(It.IsAny <string>())).Returns(mockLogger.Object); var mockWorkoutService = new Mock <IWorkoutService>(); mockWorkoutService.Setup(w => w.GetWorkoutEntryAsync(It.IsAny <int>())) .ReturnsAsync((WorkoutEntryDto)null) .Verifiable(); var mockExerciseService = new Mock <IExerciseService>(); var mockChallengeService = new Mock <IChallengeService>(); var mockWorkoutRepository = new Mock <IWorkoutRepository>(); var workoutController = new WorkoutController( mockLoggerFactory.Object, mockMapper.Object, mockWorkoutService.Object, mockExerciseService.Object, mockUserManager, mockWorkoutRepository.Object, mockChallengeService.Object); // Act var result = await workoutController.Challenge(It.IsAny <int>(), It.IsAny <int>()) as ViewResult; // Assert Assert.IsType <ViewResult>(result); Assert.Equal("/Error", result.ViewName); }
public async Task DeleteWorkout_RedirectToWorkouts_IfDeleted() { // Arrange var mockUserManager = new FakeUserManager(); var mockMapper = new Mock <IMapper>(); var mockLoggerFactory = new Mock <ILoggerFactory>(); var mockLogger = new Mock <ILogger>(); mockLoggerFactory.Setup(l => l.CreateLogger(It.IsAny <string>())).Returns(mockLogger.Object); var mockWorkoutService = new Mock <IWorkoutService>(); mockWorkoutService.Setup(w => w.DeleteWorkoutAsync(It.IsAny <int>(), It.IsAny <int>())) .ReturnsAsync(true) .Verifiable(); var mockExerciseService = new Mock <IExerciseService>(); var mockChallengeService = new Mock <IChallengeService>(); var mockWorkoutRepository = new Mock <IWorkoutRepository>(); var workoutController = new WorkoutController( mockLoggerFactory.Object, mockMapper.Object, mockWorkoutService.Object, mockExerciseService.Object, mockUserManager, mockWorkoutRepository.Object, mockChallengeService.Object); // Act var result = await workoutController.DeleteWorkout(It.IsAny <int>()) as RedirectToActionResult; Assert.IsType <RedirectToActionResult>(result); Assert.Equal("Workouts", result.ActionName); }
public async Task ShareResult_ReturnsStatusCode500_IfChallengeNotExists() { // Arrange var mockUserManager = new FakeUserManager(); var mockLoggerFactory = new Mock <ILoggerFactory>(); var mockLogger = new Mock <ILogger>(); mockLoggerFactory.Setup(f => f.CreateLogger(It.IsAny <string>())) .Returns(mockLogger.Object); var mockMapper = new Mock <IMapper>(); var mockChallengeService = new Mock <IChallengeService>(); mockChallengeService.Setup(c => c.GetChallengeAsync(It.IsAny <int>())) .ReturnsAsync((ChallengeDto)null) // Challenge does not exist .Verifiable(); var challengeController = new ChallengeController( mockUserManager, mockLoggerFactory.Object, mockMapper.Object, mockChallengeService.Object ); // Act var result = await challengeController.ShareResult(It.IsAny <int>()) as StatusCodeResult; // Assert Assert.IsType <StatusCodeResult>(result); Assert.Equal(500, result.StatusCode); }
public async Task Challenges_ReturnsStatusCode500_WhenEmpty() { // Arrange var mockUserManager = new FakeUserManager(); var mockLoggerFactory = new Mock <ILoggerFactory>(); var mockLogger = new Mock <ILogger>(); mockLoggerFactory.Setup(f => f.CreateLogger(It.IsAny <string>())) .Returns(mockLogger.Object); var mockMapper = new Mock <IMapper>(); var mockChallengeService = new Mock <IChallengeService>(); var challengeController = new ChallengeController( mockUserManager, mockLoggerFactory.Object, mockMapper.Object, mockChallengeService.Object ); // Act var result = await challengeController.Challenges() as StatusCodeResult; // Assert Assert.IsType <StatusCodeResult>(result); Assert.Equal(500, result.StatusCode); }
public async Task PostResults_ReturnsStatusCode500_WhenServiceError() { // Arrange var mockUserManager = new FakeUserManager(); var mockLoggerFactory = new Mock <ILoggerFactory>(); var mockLogger = new Mock <ILogger>(); mockLoggerFactory.Setup(f => f.CreateLogger(It.IsAny <string>())) .Returns(mockLogger.Object); var mockMapper = new Mock <IMapper>(); var mockChallengeService = new Mock <IChallengeService>(); mockChallengeService.Setup(c => c.SetResultAsync(It.IsAny <ChallengeResultDto>())) .ReturnsAsync(false) .Verifiable(); var challengeResultViewModel = new ChallengeResultViewModel(); var challengeController = new ChallengeController( mockUserManager, mockLoggerFactory.Object, mockMapper.Object, mockChallengeService.Object ); // Act var result = await challengeController.PostResults(challengeResultViewModel) as StatusCodeResult; // Assert Assert.IsType <StatusCodeResult>(result); Assert.Equal(500, result.StatusCode); }
public async Task PostResults_ReturnsViewResultAgain_WhenModelStateIsInvalid() { // Arrange var mockUserManager = new FakeUserManager(); var mockLoggerFactory = new Mock <ILoggerFactory>(); var mockLogger = new Mock <ILogger>(); mockLoggerFactory.Setup(f => f.CreateLogger(It.IsAny <string>())) .Returns(mockLogger.Object); var mockMapper = new Mock <IMapper>(); var mockChallengeService = new Mock <IChallengeService>(); var challengeResultViewModel = new ChallengeResultViewModel(); var challengeController = new ChallengeController( mockUserManager, mockLoggerFactory.Object, mockMapper.Object, mockChallengeService.Object ); challengeController.ModelState.AddModelError("", ""); // Act var result = await challengeController.PostResults(challengeResultViewModel) as ViewResult; // Assert Assert.IsType <ViewResult>(result); var model = Assert.IsType <ChallengeResultViewModel>(result.Model); Assert.Equal(false, result.ViewData.ModelState.IsValid); }
public async Task EditWorkoutPost_ReturnsViewResult_WhenModelStateIsValid() { // Arrange var mockUserManager = new FakeUserManager(); var mockMapper = new Mock <IMapper>(); mockMapper.Setup(m => m.Map <WorkoutViewModel>(It.IsAny <WorkoutDto>())) .Returns(new WorkoutViewModel()) .Verifiable(); mockMapper.Setup(m => m.Map <ICollection <WorkoutEntryDto>, IEnumerable <WorkoutEntryViewModel> >(new List <WorkoutEntryDto>())) .Returns(new List <WorkoutEntryViewModel>()) .Verifiable(); var mockLoggerFactory = new Mock <ILoggerFactory>(); var mockLogger = new Mock <ILogger>(); mockLoggerFactory.Setup(l => l.CreateLogger(It.IsAny <string>())).Returns(mockLogger.Object); var mockWorkoutService = new Mock <IWorkoutService>(); mockWorkoutService.Setup(w => w.GetWorkoutAsync(It.IsAny <int>())) .ReturnsAsync(new WorkoutDto()) .Verifiable(); // Return workout mockWorkoutService.Setup(w => w.AddWorkoutEntryAsync(It.IsAny <AddWorkoutEntryToWorkoutDto>())) .ReturnsAsync(1) .Verifiable(); var mockExerciseService = new Mock <IExerciseService>(); mockExerciseService.Setup(e => e.GetAllExercisesAsync()) .ReturnsAsync(new List <ExerciseDto>()) .Verifiable(); // Returns exercises var mockChallengeService = new Mock <IChallengeService>(); var mockWorkoutRepository = new Mock <IWorkoutRepository>(); var workoutController = new WorkoutController( mockLoggerFactory.Object, mockMapper.Object, mockWorkoutService.Object, mockExerciseService.Object, mockUserManager, mockWorkoutRepository.Object, mockChallengeService.Object); var invalidWorkout = new WorkoutViewModel() { Set = -10, Weight = -10, Reps = -10 }; // Act var result = await workoutController.EditWorkout(invalidWorkout) as ViewResult; // Assert Assert.IsType <ViewResult>(result); Assert.IsType <WorkoutViewModel>(result.Model); Assert.Equal(true, result.ViewData.ModelState.IsValid); }
public async Task AddWorkout_ReturnsViewError_Database() { // Arrange var mockUserManager = new FakeUserManager(); var mockMapper = new Mock <IMapper>(); var mockLoggerFactory = new Mock <ILoggerFactory>(); var mockLogger = new Mock <ILogger>(); mockLoggerFactory.Setup(l => l.CreateLogger(It.IsAny <string>())).Returns(mockLogger.Object); var mockWorkoutService = new Mock <IWorkoutService>(); mockWorkoutService.Setup(w => w.GetAllWorkoutsAsync(It.IsAny <int>())) .ReturnsAsync(new List <WorkoutDto> { new WorkoutDto { } }) .Verifiable(); // Return list of workouts mockWorkoutService.Setup(w => w.AddWorkoutAsync(It.IsAny <NewWorkoutDto>())) .ReturnsAsync(0) // Error in database .Verifiable(); mockWorkoutService.Setup(w => w.GetWorkoutAsync(It.IsAny <int>())) .ReturnsAsync(new WorkoutDto { WorkoutEntryDtos = new List <WorkoutEntryDto>() }) .Verifiable(); var mockExerciseService = new Mock <IExerciseService>(); mockExerciseService.Setup(e => e.GetAllExercisesAsync()) .ReturnsAsync(new List <ExerciseDto>()) .Verifiable(); var mockChallengeService = new Mock <IChallengeService>(); var mockWorkoutRepository = new Mock <IWorkoutRepository>(); var workoutController = new WorkoutController( mockLoggerFactory.Object, mockMapper.Object, mockWorkoutService.Object, mockExerciseService.Object, mockUserManager, mockWorkoutRepository.Object, mockChallengeService.Object); // Act var result = await workoutController.AddWorkout() as ViewResult; // Assert Assert.IsType <ViewResult>(result); Assert.Equal("/Error", result.ViewName); }
public async Task EditWorkoutPost_ReturnsError_WhenModelStateIsInValid() { // Arrange var mockUserManager = new FakeUserManager(); var mockMapper = new Mock <IMapper>(); var mockLoggerFactory = new Mock <ILoggerFactory>(); var mockLogger = new Mock <ILogger>(); mockLoggerFactory.Setup(l => l.CreateLogger(It.IsAny <string>())).Returns(mockLogger.Object); var mockWorkoutService = new Mock <IWorkoutService>(); mockWorkoutService.Setup(w => w.GetWorkoutAsync(It.IsAny <int>())) .ReturnsAsync((WorkoutDto)null) .Verifiable(); // Return workout var mockExerciseService = new Mock <IExerciseService>(); mockExerciseService.Setup(e => e.GetAllExercisesAsync()) .ReturnsAsync((ICollection <ExerciseDto>)null) .Verifiable(); // Returns exercises var mockChallengeService = new Mock <IChallengeService>(); var mockWorkoutRepository = new Mock <IWorkoutRepository>(); var workoutController = new WorkoutController( mockLoggerFactory.Object, mockMapper.Object, mockWorkoutService.Object, mockExerciseService.Object, mockUserManager, mockWorkoutRepository.Object, mockChallengeService.Object); var invalidWorkout = new WorkoutViewModel() { Set = -10, Weight = -10, Reps = -10 }; workoutController.ModelState.AddModelError("", ""); // Act var result = await workoutController.EditWorkout(invalidWorkout) as ViewResult; // Assert Assert.IsType <ViewResult>(result); Assert.IsType <WorkoutViewModel>(result.Model); Assert.Equal(false, result.ViewData.ModelState.IsValid); }
public async Task DeleteEntry_RedirectToEditWorkout_IfDeleted() { // Arrange var mockUserManager = new FakeUserManager(); var mockMapper = new Mock <IMapper>(); var mockLoggerFactory = new Mock <ILoggerFactory>(); var mockLogger = new Mock <ILogger>(); mockLoggerFactory.Setup(l => l.CreateLogger(It.IsAny <string>())).Returns(mockLogger.Object); var mockWorkoutService = new Mock <IWorkoutService>(); mockWorkoutService.Setup(w => w.DeleteWorkoutEntryAsync(It.IsAny <int>(), It.IsAny <int>())) .ReturnsAsync(true) .Verifiable(); var mockExerciseService = new Mock <IExerciseService>(); var mockChallengeService = new Mock <IChallengeService>(); var mockWorkoutRepository = new Mock <IWorkoutRepository>(); var workoutController = new WorkoutController( mockLoggerFactory.Object, mockMapper.Object, mockWorkoutService.Object, mockExerciseService.Object, mockUserManager, mockWorkoutRepository.Object, mockChallengeService.Object); var expectedRedirectValues = new RouteValueDictionary() { { "controller", "Workout" }, { "action", "EditWorkout" }, { "id", 0 } }; // Act var result = await workoutController.DeleteEntry(It.IsAny <int>(), It.IsAny <int>()) as RedirectToActionResult; // Assert Assert.IsType <RedirectToActionResult>(result); Assert.Equal("EditWorkout", result.ActionName); Assert.Equal(expectedRedirectValues, result.RouteValues); }
public async Task ChallengePost_ReturnsBadRequestResult_WhenModelStateIsInvalid() { // Arrange var challengeViewModel = new NewChallengeViewModel() { Id = 1, ExerciseId = 1, ExerciseName = "Squat", Reps = -10, Set = -10, Weight = -10 }; var mockUserManager = new FakeUserManager(); var mockMapper = new Mock <IMapper>(); var mockLoggerFactory = new Mock <ILoggerFactory>(); var mockLogger = new Mock <ILogger>(); mockLoggerFactory.Setup(l => l.CreateLogger(It.IsAny <string>())).Returns(mockLogger.Object); var mockWorkoutService = new Mock <IWorkoutService>(); var mockExerciseService = new Mock <IExerciseService>(); var mockChallengeService = new Mock <IChallengeService>(); var mockWorkoutRepository = new Mock <IWorkoutRepository>(); var workoutController = new WorkoutController( mockLoggerFactory.Object, mockMapper.Object, mockWorkoutService.Object, mockExerciseService.Object, mockUserManager, mockWorkoutRepository.Object, mockChallengeService.Object); workoutController.ModelState.AddModelError("ExerciseName", "Required"); // Act var result = await workoutController.Challenge(challengeViewModel) as ViewResult; // Assert Assert.IsType <ViewResult>(result); Assert.IsType <NewChallengeViewModel>(result.Model); Assert.Equal(false, result.ViewData.ModelState.IsValid); }
public async Task Workouts_ReturnsAViewResult_WithAListofWorkouts() { // Arrange var mockUserManager = new FakeUserManager(); var mockMapper = new Mock <IMapper>(); var mockLoggerFactory = new Mock <ILoggerFactory>(); var mockLogger = new Mock <ILogger>(); mockLoggerFactory.Setup(l => l.CreateLogger(It.IsAny <string>())).Returns(mockLogger.Object); var workouts = new List <WorkoutDto> { new WorkoutDto { } }; var mockWorkoutService = new Mock <IWorkoutService>(); mockWorkoutService.Setup(w => w.GetAllWorkoutsAsync(It.IsAny <int>())) .ReturnsAsync(workouts) .Verifiable(); var mockExerciseService = new Mock <IExerciseService>(); var mockChallengeService = new Mock <IChallengeService>(); var mockWorkoutRepository = new Mock <IWorkoutRepository>(); var workoutController = new WorkoutController( mockLoggerFactory.Object, mockMapper.Object, mockWorkoutService.Object, mockExerciseService.Object, mockUserManager, mockWorkoutRepository.Object, mockChallengeService.Object); // Act var viewResult = await workoutController.Workouts() as ViewResult; // Assert Assert.IsType <ViewResult>(viewResult); var model = Assert.IsAssignableFrom <IEnumerable <WorkoutViewModel> >(viewResult.ViewData.Model); Assert.Equal(0, model.Count()); }
public async Task EditWorkoutPost_ReturnsError_EmptyModel() { // Arrange var mockUserManager = new FakeUserManager(); var mockMapper = new Mock <IMapper>(); var mockLoggerFactory = new Mock <ILoggerFactory>(); var mockLogger = new Mock <ILogger>(); mockLoggerFactory.Setup(l => l.CreateLogger(It.IsAny <string>())).Returns(mockLogger.Object); var mockWorkoutService = new Mock <IWorkoutService>(); mockWorkoutService.Setup(w => w.GetWorkoutAsync(It.IsAny <int>())) .ReturnsAsync((WorkoutDto)null) .Verifiable(); // Return workout var mockExerciseService = new Mock <IExerciseService>(); mockExerciseService.Setup(e => e.GetAllExercisesAsync()) .ReturnsAsync((ICollection <ExerciseDto>)null) .Verifiable(); // Returns exercises var mockChallengeService = new Mock <IChallengeService>(); var mockWorkoutRepository = new Mock <IWorkoutRepository>(); var workoutController = new WorkoutController( mockLoggerFactory.Object, mockMapper.Object, mockWorkoutService.Object, mockExerciseService.Object, mockUserManager, mockWorkoutRepository.Object, mockChallengeService.Object); // Act var result = await workoutController.EditWorkout((WorkoutViewModel)null) as ViewResult; // Assert Assert.IsType <ViewResult>(result); Assert.Equal("/Error", result.ViewName); }
public async Task Challenges_ReturnsChallenges_WhenNotEmpty() { // Arrange var mockUserManager = new FakeUserManager(); var mockLoggerFactory = new Mock <ILoggerFactory>(); var mockLogger = new Mock <ILogger>(); mockLoggerFactory.Setup(f => f.CreateLogger(It.IsAny <string>())) .Returns(mockLogger.Object); var mockMapper = new Mock <IMapper>(); var challenges = new List <ChallengeDto>(); var mockChallengeService = new Mock <IChallengeService>(); mockChallengeService.Setup(c => c.GetReceivedChallengesAsync(It.IsAny <int>())) .ReturnsAsync(challenges) .Verifiable(); mockChallengeService.Setup(c => c.GetGivenChallengesAsync(It.IsAny <int>())) .ReturnsAsync(challenges) .Verifiable(); var challengeController = new ChallengeController( mockUserManager, mockLoggerFactory.Object, mockMapper.Object, mockChallengeService.Object ); // Act var result = await challengeController.Challenges() as ViewResult; // Assert Assert.IsType <ViewResult>(result); var model = Assert.IsType <ChallengeViewModel>(result.Model); Assert.Equal(challenges, model.GivenChallenges); Assert.Equal(challenges, model.ReceivedChallenges); }
public async Task Challenge_ReturnsViewResult_WithModel() { // Arrange var workoutEntryDto = new WorkoutEntryDto() { Id = 1, ExerciseId = 1, ExerciseName = "Squat", Reps = 10, Set = 10, Weight = 10 }; var challengeableUserDtos = new List <ChallengeAbleUserDto>() { new ChallengeAbleUserDto { DisplayName = "Test", Id = 1 } }; var challengeViewModel = new NewChallengeViewModel() { Id = 1, ExerciseId = 1, ChallengeAbleUserDtos = challengeableUserDtos, ChallengeeId = challengeableUserDtos.First().Id, ExerciseName = "Squat", Reps = 10, Set = 10, Weight = 10 }; var mockUserManager = new FakeUserManager(); var mockMapper = new Mock <IMapper>(); mockMapper.Setup(m => m.Map <NewChallengeViewModel>(It.IsAny <WorkoutEntryDto>())) .Returns(challengeViewModel) .Verifiable(); var mockLoggerFactory = new Mock <ILoggerFactory>(); var mockLogger = new Mock <ILogger>(); mockLoggerFactory.Setup(l => l.CreateLogger(It.IsAny <string>())).Returns(mockLogger.Object); var mockWorkoutService = new Mock <IWorkoutService>(); mockWorkoutService.Setup(w => w.GetWorkoutEntryAsync(It.IsAny <int>())) .ReturnsAsync(workoutEntryDto) .Verifiable(); var mockExerciseService = new Mock <IExerciseService>(); var mockChallengeService = new Mock <IChallengeService>(); mockChallengeService.Setup(c => c.GetChallengeAbleUsersAsync(It.IsAny <int>())) .ReturnsAsync(challengeableUserDtos) .Verifiable(); var mockWorkoutRepository = new Mock <IWorkoutRepository>(); var workoutController = new WorkoutController( mockLoggerFactory.Object, mockMapper.Object, mockWorkoutService.Object, mockExerciseService.Object, mockUserManager, mockWorkoutRepository.Object, mockChallengeService.Object); // Act var result = await workoutController.Challenge(It.IsAny <int>(), It.IsAny <int>()) as ViewResult; // Assert Assert.IsType <ViewResult>(result); var model = Assert.IsType <NewChallengeViewModel>(result.Model); Assert.Equal(1, model.Id); Assert.Equal(1, model.ExerciseId); Assert.Equal(challengeableUserDtos, model.ChallengeAbleUserDtos); Assert.Equal(1, model.ChallengeeId); Assert.Equal(10, model.Reps); Assert.Equal(10, model.Set); Assert.Equal(10, model.Weight); //Assert.Equal("Challenge", result); }
public async Task AddWorkout_ReturnsEditRedirectViewResult_WithWorkoutModel() { // Arrange var mockUserManager = new FakeUserManager(); var mockMapper = new Mock <IMapper>(); var workoutEntries = new List <WorkoutEntryViewModel>(); var exercises = new List <ExerciseDto>(); var workoutViewModel = new WorkoutViewModel() { CreationDate = DateTime.MinValue, ExerciseId = 0, Name = "Workout", Exercises = exercises, Id = 0, Reps = 10, Weight = 10, Set = 10, WorkoutEntries = workoutEntries }; mockMapper.Setup(m => m.Map <WorkoutDto, WorkoutViewModel>(It.IsAny <WorkoutDto>())) .Returns(workoutViewModel) .Verifiable(); var mockLoggerFactory = new Mock <ILoggerFactory>(); var mockLogger = new Mock <ILogger>(); mockLoggerFactory.Setup(l => l.CreateLogger(It.IsAny <string>())).Returns(mockLogger.Object); var mockWorkoutService = new Mock <IWorkoutService>(); mockWorkoutService.Setup(w => w.GetAllWorkoutsAsync(It.IsAny <int>())) .ReturnsAsync(new List <WorkoutDto> { new WorkoutDto { } }) .Verifiable(); // Return list of workouts mockWorkoutService.Setup(w => w.AddWorkoutAsync(It.IsAny <NewWorkoutDto>())) .ReturnsAsync(1) .Verifiable(); mockWorkoutService.Setup(w => w.GetWorkoutAsync(It.IsAny <int>())) .ReturnsAsync(new WorkoutDto { WorkoutEntryDtos = new List <WorkoutEntryDto>() }) .Verifiable(); var mockExerciseService = new Mock <IExerciseService>(); mockExerciseService.Setup(e => e.GetAllExercisesAsync()) .ReturnsAsync(exercises); var mockChallengeService = new Mock <IChallengeService>(); var mockWorkoutRepository = new Mock <IWorkoutRepository>(); var workoutController = new WorkoutController( mockLoggerFactory.Object, mockMapper.Object, mockWorkoutService.Object, mockExerciseService.Object, mockUserManager, mockWorkoutRepository.Object, mockChallengeService.Object); //var expectedRedirectValues = new RouteValueDictionary() //{ // // TODO // { "Id", 0 }, // { "Name", "Workout" }, // { "CreationDate", DateTime.MinValue }, // //{ "WorkoutEntries", workoutEntries }, // //{ "Exercises", exercises }, // { "ExerciseId", 0 }, // { "Set", 10 }, // { "Weight", 10 }, // { "Reps", 10 } //}; // Act var result = await workoutController.AddWorkout() as RedirectToActionResult; // Assert Assert.IsType <RedirectToActionResult>(result); Assert.Equal("EditWorkout", result.ActionName); //Assert.Equal(expectedRedirectValues, result.RouteValues); }
public async Task EditWorkout_ReturnsAView_WithWorkout() { // Arrange var workoutDto = new WorkoutDto() { Name = "Workout", CreationDate = DateTime.MinValue, Id = 1, UserId = 1, WorkoutEntryDtos = new List <WorkoutEntryDto> { new WorkoutEntryDto { ExerciseId = 1, ExerciseName = "Squat", Id = 1, Reps = 10, Set = 10, Weight = 10 } } }; var exercises = new List <ExerciseDto> { new ExerciseDto { Description = "Description", Id = 1, Name = "Squat" } }; var workoutEntries = new List <WorkoutEntryViewModel> { new WorkoutEntryViewModel { ExerciseName = "Squat", Id = 1, Reps = 10, Set = 10, Weight = 10 } }; var workoutViewModel = new WorkoutViewModel() { CreationDate = DateTime.MinValue, ExerciseId = 1, Name = "Workout", Exercises = exercises, Id = 1, WorkoutEntries = workoutEntries, Reps = 10, Weight = 10, Set = 10 }; var mockUserManager = new FakeUserManager(); var mockMapper = new Mock <IMapper>(); mockMapper.Setup(m => m.Map <WorkoutViewModel>(workoutDto)) .Returns(workoutViewModel) .Verifiable(); mockMapper.Setup(m => m.Map <ICollection <WorkoutEntryDto>, IEnumerable <WorkoutEntryViewModel> >(It.IsAny <ICollection <WorkoutEntryDto> >())) .Returns(workoutEntries) .Verifiable(); var mockLoggerFactory = new Mock <ILoggerFactory>(); var mockLogger = new Mock <ILogger>(); mockLoggerFactory.Setup(l => l.CreateLogger(It.IsAny <string>())).Returns(mockLogger.Object); var mockWorkoutService = new Mock <IWorkoutService>(); mockWorkoutService.Setup(w => w.GetWorkoutAsync(It.IsAny <int>())) .ReturnsAsync(workoutDto) .Verifiable(); // Return workout var mockExerciseService = new Mock <IExerciseService>(); mockExerciseService.Setup(e => e.GetAllExercisesAsync()) .ReturnsAsync(exercises) .Verifiable(); // Returns exercises var mockChallengeService = new Mock <IChallengeService>(); var mockWorkoutRepository = new Mock <IWorkoutRepository>(); var workoutController = new WorkoutController( mockLoggerFactory.Object, mockMapper.Object, mockWorkoutService.Object, mockExerciseService.Object, mockUserManager, mockWorkoutRepository.Object, mockChallengeService.Object); // Act var result = await workoutController.EditWorkout(It.IsAny <int>()) as ViewResult; // Assert Assert.IsType <ViewResult>(result); //Assert.Equal("EditWorkout", result.ViewName); var model = Assert.IsType <WorkoutViewModel>(result.Model); Assert.Equal(DateTime.MinValue, model.CreationDate); Assert.Equal(1, model.ExerciseId); Assert.Equal("Workout", model.Name); Assert.Equal(exercises, model.Exercises); Assert.Equal(1, model.Id); Assert.Equal(workoutEntries, model.WorkoutEntries); Assert.Equal(10, model.Reps); Assert.Equal(10, model.Weight); Assert.Equal(10, model.Set); }
public async Task ChallengePost_ReturnsViewError_ChallengeNotCreated() { // Arrange var newChallengeDto = new NewChallengeDto() { Weight = 10, ChallengeeId = 1, ChallengerId = 2, ExerciseId = 1, Reps = 10 }; var challengeableUserDtos = new List <ChallengeAbleUserDto>() { new ChallengeAbleUserDto { DisplayName = "Test", Id = 1 } }; var challengeViewModel = new NewChallengeViewModel() { Id = 1, ExerciseId = 1, ChallengeAbleUserDtos = challengeableUserDtos, ChallengeeId = challengeableUserDtos.First().Id, ExerciseName = "Squat", Reps = 10, Set = 10, Weight = 10 }; var mockUserManager = new FakeUserManager(); var mockMapper = new Mock <IMapper>(); mockMapper.Setup(m => m.Map <NewChallengeDto>(It.IsAny <NewChallengeViewModel>())) .Returns(newChallengeDto) .Verifiable(); var mockLoggerFactory = new Mock <ILoggerFactory>(); var mockLogger = new Mock <ILogger>(); mockLoggerFactory.Setup(l => l.CreateLogger(It.IsAny <string>())).Returns(mockLogger.Object); var mockWorkoutService = new Mock <IWorkoutService>(); var mockExerciseService = new Mock <IExerciseService>(); var mockChallengeService = new Mock <IChallengeService>(); mockChallengeService.Setup(c => c.CreateChallengeAsync(It.IsAny <NewChallengeDto>())) .ReturnsAsync(0) // Result challenge not created .Verifiable(); var mockWorkoutRepository = new Mock <IWorkoutRepository>(); var workoutController = new WorkoutController( mockLoggerFactory.Object, mockMapper.Object, mockWorkoutService.Object, mockExerciseService.Object, mockUserManager, mockWorkoutRepository.Object, mockChallengeService.Object); // Act var result = await workoutController.Challenge(challengeViewModel) as ViewResult; // Assert Assert.IsType <ViewResult>(result); Assert.Equal("/Error", result.ViewName); }