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 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 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 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);
}
