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