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);
}
static void Main(string[] args)
{
Watcher watcher1 = new Watcher("Watcher1");
Watcher watcher2 = new Watcher("Watcher2");
Watcher watcher3 = new Watcher("Watcher3");
TrainingGuy trainingGuy = new TrainingGuy();
trainingGuy.Subscribe(watcher1);
trainingGuy.Subscribe(watcher2);
trainingGuy.Subscribe(watcher3);
WorkoutController fitnessInstructor = new WorkoutController();
SwitchDownCommand switchDownCommand = (SwitchDownCommand)CommandFactory.Create(CommandFactory.commandList.SwitchDown, trainingGuy);
SwitchUpCommand switchUpCommand = (SwitchUpCommand)CommandFactory.Create(CommandFactory.commandList.SwitchUp);
switchUpCommand.SetTrainingGuy(trainingGuy);
fitnessInstructor.SetCommand(switchUpCommand);
fitnessInstructor.ExecuteCommand();
fitnessInstructor.SetCommand(switchDownCommand);
fitnessInstructor.ExecuteCommand();
fitnessInstructor.SetCommand(switchUpCommand);
fitnessInstructor.ExecuteCommand();
}
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 void InsertTest()
{
// Arrange
WorkoutTypeController controllerwt = new WorkoutTypeController();
// Act
List <WorkoutType> loadAllWt = controllerwt.Get() as List <WorkoutType>;
//grab first result
WorkoutType wt = loadAllWt[0];
// Arrange
UserController controlleru = new UserController();
// Act
List <User> loadAllU = controlleru.Get() as List <User>;
//grab first result
User u = loadAllU[0];
Workout w = new Workout {
WorkoutType = wt, StartTime = System.DateTime.Now, EndTime = new System.DateTime(2020, 11, 18), UserId = u.Id
};
// Arrange
WorkoutController controller = new WorkoutController();
// Act
int result = controller.Post(w);
// Assert
Assert.IsTrue(result > 0);
}
public void AddExercise()
{
// Act
var controller = new WorkoutController();
// Arrange
var result = controller.AddWorkout();
}
public void WorkoutHome()
{
// Act
var controller = new WorkoutController();
// Arrange
var result = controller.WorkoutHome();
// Assert
Assert.IsNotNull(result);
}
public static void Initialize(TestContext context)
{
_workoutController = new WorkoutController();
_categoryController = new CategoryController();
Mapper.Reset();
Mapper.Initialize(config =>
{
config.AddProfile <MappingProfile>();
});
}
public void LoadTest()
{
// Arrange
WorkoutController controller = new WorkoutController();
// Act
IEnumerable <Workout> result = controller.Get() as IEnumerable <Workout>;
// Assert
Assert.IsNotNull(result);
}
public void UpdateWorkouts_Test()
{
//Arrange
mockRepo.Setup(repo => repo.Workouts.FindByCondition(w => w.WorkoutId == It.IsAny <int>())).Returns(GetWorkouts());
mockRepo.Setup(repo => repo.Workouts.Update(GetWorkout()));
//Act
var controllerActionResult = new WorkoutController(mockRepo.Object).Update(It.IsAny <int>());
//Assert
Assert.NotNull(controllerActionResult);
}
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 WorkoutTest()
{
//sample models
addWorkout = new AddWorkoutBindingModel {
WorkoutId = 1, Type = "Legs", Difficulty = Difficulty.Intermediate, Time = 20
};
addExercise = new AddExerciseBindingModel {
ExerciseId = 1, Name = "Squats", Picture = "https://cdn.thespaces.com/wp-content/uploads/2020/01/Gymshark-hero-crop.jpg", Sets = 20, Weight = 20, Status = Status.Completed
};
mockRepo = new Mock <IRepositoryWrapper>();
WorkoutController = new WorkoutController(mockRepo.Object);
ExerciseController = new ExerciseController(mockRepo.Object);
}
public void DeleteWorkout()
{
// Act
var controller = new WorkoutController();
List <ExerciseType> lstExercises = new List <ExerciseType>();
WorkoutRoutine workout = WorkoutRoutine.of(10, lstExercises, 100);
// Arrange
var result = controller.DeleteWorkout(workout, 5, 5);
// Assert
Assert.IsNotNull(result);
}
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 WorkoutsTests()
{
DatabaseContext dbContext = CreateEmptyDatabase();
// create empty database
this.exerciseRepository = new ExerciseRepository(dbContext);
this.workoutRepository = new WorkoutRepository(dbContext);
this.componentRepository = new ComponentRepository(dbContext);
// create sevice
this.workoutService = new WorkoutService(this.exerciseRepository, this.workoutRepository);
this.exerciseService = new ExerciseService(this.exerciseRepository, this.componentRepository);
// create controller
this.workoutController = new WorkoutController(this.workoutService, this.exerciseService);
}
public void UpdateTest()
{
// Arrange
WorkoutController controller = new WorkoutController();
// Act
List <Workout> loadAll = controller.Get() as List <Workout>;
//grab first result
Workout w = loadAll[0];
w.EndTime = System.DateTime.Now;
int results = controller.Post(w);
Assert.IsTrue(results > 0);
}
public void DeleteTest()
{
//always fails because There is a workout that depends on this Workouttype
// Arrange
WorkoutController controller = new WorkoutController();
// Act
List <Workout> loadAll = controller.Get() as List <Workout>;
//grab first result
Workout w = loadAll[0];
int results = controller.Delete(w);
Assert.IsTrue(results > 0);
}
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 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);
}
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 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 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 WorkoutControllerTest()
{
WorkoutExcerciseRepoMock = new Mock <IWorkoutExcerciseRepo>();
WorkoutController = new WorkoutController(WorkoutExcerciseRepoMock.Object);
}
