public async Task DeleteExerciseAsyncShouldDeleteExercise()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString()).Options;
var db = new ApplicationDbContext(options);
var exercisesRepository = new EfDeletableEntityRepository <Exercise>(db);
var cloudinaryService = new Mock <ICloudinaryService>();
var fileMock = new Mock <IFormFile>();
var service = new ExercisesService(exercisesRepository, cloudinaryService.Object);
var inputModel = new AddExerciseInputModel()
{
Name = "Plamen",
Difficulty = Difficulty.Easy,
Type = ExerciseType.Abs,
VideoFile = fileMock.Object,
};
var exercise = await service.AddExerciseAsync(inputModel);
var result = await service.DeleteExerciseAsync(exercise.Id);
Assert.True(result.IsDeleted);
}
public async Task AddExerciseAsyncShouldAddExerciseProperly(
string exerciseName,
Difficulty difficulty,
ExerciseType type)
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString()).Options;
var db = new ApplicationDbContext(options);
var exercisesRepository = new EfDeletableEntityRepository <Exercise>(db);
var cloudinaryService = new Mock <ICloudinaryService>();
var fileMock = new Mock <IFormFile>();
var service = new ExercisesService(exercisesRepository, cloudinaryService.Object);
var inputModel = new AddExerciseInputModel()
{
Name = exerciseName,
Difficulty = difficulty,
Type = type,
VideoFile = fileMock.Object,
};
var result = await service.AddExerciseAsync(inputModel);
Assert.Single(exercisesRepository.All());
Assert.NotNull(result.Id);
Assert.Equal(type, inputModel.Type);
}
public async Task GetAllExercisesAsyncShouldWorkCorrectly(
string filterType)
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString()).Options;
var db = new ApplicationDbContext(options);
var exercisesRepository = new EfDeletableEntityRepository <Exercise>(db);
var cloudinaryService = new Mock <ICloudinaryService>();
var fileMock = new Mock <IFormFile>();
var service = new ExercisesService(exercisesRepository, cloudinaryService.Object);
var inputModel = new AddExerciseInputModel()
{
Name = "Test name",
Difficulty = Difficulty.Easy,
Type = ExerciseType.Abs,
VideoFile = fileMock.Object,
};
await service.AddExerciseAsync(inputModel);
var result = await service.GetAllExercisesAsync <TestExerciseModel>(filterType);
Assert.NotNull(result);
}
public async Task GetExercisesCountAsyncShouldReturnCorrectCount(int addionsCount)
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString()).Options;
var db = new ApplicationDbContext(options);
var exercisesRepository = new EfDeletableEntityRepository <Exercise>(db);
var cloudinaryService = new Mock <ICloudinaryService>();
var fileMock = new Mock <IFormFile>();
var service = new ExercisesService(exercisesRepository, cloudinaryService.Object);
var tasks = new List <Task>();
for (int i = 0; i < addionsCount; i++)
{
var inputModel = new AddExerciseInputModel()
{
Name = "Test name",
Difficulty = Difficulty.Easy,
Type = ExerciseType.Abs,
VideoFile = fileMock.Object,
};
tasks.Add(service.AddExerciseAsync(inputModel));
}
await Task.WhenAll(tasks);
var count = await service.GetExercisesCountAsync();
Assert.Equal(addionsCount, count);
}
public async Task EditExerciseAsyncShouldThrow(
string exerciseName,
string exerciseEditedName)
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString()).Options;
var db = new ApplicationDbContext(options);
var exercisesRepository = new EfDeletableEntityRepository <Exercise>(db);
var cloudinaryService = new Mock <ICloudinaryService>();
var fileMock = new Mock <IFormFile>();
var service = new ExercisesService(exercisesRepository, cloudinaryService.Object);
var inputModel = new AddExerciseInputModel()
{
Name = exerciseName,
Difficulty = Difficulty.Easy,
Type = ExerciseType.Abs,
VideoFile = fileMock.Object,
};
var exercise = await service.AddExerciseAsync(inputModel);
var editInputModel = new EditExerciseInputModel()
{
Id = exercise.Id,
Name = exerciseEditedName,
Difficulty = Difficulty.Easy,
Type = ExerciseType.Abs,
VideoUrl = "some video url",
VideoFile = fileMock.Object,
};
Assert.DoesNotContain(exerciseEditedName, exercisesRepository.All().Select(x => x.Name));
}
public void AfterAnExcerciseIsAddedTheUserIsShownAConfirmationPage()
{
var model = new AddExerciseInputModel();
var invoker = new Mock <ICommandInvoker>();
var controller = new ExercisesController(invoker.Object, null);
var result = (RedirectToRouteResult)controller.Add(model);
result.RouteName.ShouldEqual("");
}
public void WhenTheInputModelIsNotValidTheUserIsShownTheAddView()
{
var model = new AddExerciseInputModel();
var invoker = new Mock <ICommandInvoker>();
var controller = new ExercisesController(invoker.Object, null);
controller.ModelState.AddModelError("foo", "bad");
var result = (ViewResult)controller.Add(model);
result.ViewName.ShouldEqual("Index");
}
public ActionResult Add(AddExerciseInputModel inputModel)
{
if (ModelState.IsValid)
{
_invoker.Execute(new AddExerciseCommand(inputModel.Description, inputModel.Type));
TempData["Message"] = "Added new {0} exercise -- {1}".ToFormat(inputModel.Type, inputModel.Description);
return(RedirectToAction("Index"));
}
else
{
return(View("Index", inputModel));
}
}
public async Task <Exercise> AddExerciseAsync(AddExerciseInputModel inputModel)
{
Exercise exercise = new Exercise()
{
Name = inputModel.Name,
Type = inputModel.Type,
Difficulty = inputModel.Difficulty,
VideoUrl = await this.cloudinaryService.UploadVideoAsync(inputModel.VideoFile),
};
await this.exercisesRepository.AddAsync(exercise);
await this.exercisesRepository.SaveChangesAsync();
return(exercise);
}
public async Task <IActionResult> Add(AddExerciseInputModel inputModel)
{
if (!this.ModelState.IsValid || !this.cloudinaryService.IsVideoFileValid(inputModel.VideoFile))
{
if (!this.cloudinaryService.IsVideoFileValid(inputModel.VideoFile))
{
this.ModelState.AddModelError("VideoFile", "Please enter a valid video format!");
}
return(this.View(inputModel));
}
var exercise = await this.exercisesService.AddExerciseAsync(inputModel);
return(this.Redirect($"/Trainers/Exercises/Details/{exercise.Id}"));
}
public void WhenTheInputModelIsValidAnExerciseIsAdded()
{
var inputModel = new AddExerciseInputModel {
Description = "foo", Type = ExerciseType.Cardio
};
var invoker = new Mock <ICommandInvoker>();
invoker.Setup(
i => i.Execute(
It.Is <AddExerciseCommand>(
c => c.Description == inputModel.Description && c.Type == inputModel.Type)));
var controller = new ExercisesController(invoker.Object, null);
controller.Add(inputModel);
invoker.VerifyAll();
}
