public async Task GetEventsShouldReturnCorrectEventsForWorkout()
{
var optionsBuilder = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString());
var dbContext = new ApplicationDbContext(optionsBuilder.Options);
var workoutService = new WorkoutsService(dbContext);
var type = new WorkoutType
{
Name = "testName",
};
var workout = new Workout
{
Date = DateTime.Now.Date,
Type = type,
UserId = "Icaka99",
};
await dbContext.AddAsync(workout);
await dbContext.SaveChangesAsync();
var result = workoutService.GetEvents("Icaka99");
Assert.NotNull(result);
Assert.Single(result);
Assert.Equal("testName", result.FirstOrDefault().Title);
Assert.Equal(DateTime.Now.Date, result.FirstOrDefault().Date);
}
public async Task AssignMuscleGroupsShouldAssignCorrectMuscleGroupsToExercise()
{
var optionsBuilder = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString());
var dbContext = new ApplicationDbContext(optionsBuilder.Options);
var workoutService = new WorkoutsService(dbContext);
var muscleGroup = new MuscleGroup
{
Name = "testName",
};
await dbContext.MuscleGroups.AddAsync(muscleGroup);
await dbContext.SaveChangesAsync();
var exerciseToAdd = new ExerciseInputModel();
var result = workoutService.AssignMuscleGroups(exerciseToAdd);
Assert.NotNull(result.MuscleGroups);
Assert.Equal("testName", result.MuscleGroups.FirstOrDefault().Text);
Assert.Equal("1", result.MuscleGroups.FirstOrDefault().Value);
}
public async Task AssignWorkoutTypesShouldAssignCorrectWorkoutTypesToWorkout()
{
var optionsBuilder = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString());
var dbContext = new ApplicationDbContext(optionsBuilder.Options);
var workoutService = new WorkoutsService(dbContext);
var workoutType = new WorkoutType
{
Name = "testName",
};
await dbContext.WorkoutTypes.AddAsync(workoutType);
await dbContext.SaveChangesAsync();
var workoutToAdd = new WorkoutInputModel
{
Date = DateTime.Now.Date,
Duration = 180,
TypeId = 1,
UserId = "Icaka99",
};
var result = workoutService.AssignWorkoutTypes(workoutToAdd);
Assert.NotNull(result.Types);
Assert.Equal("testName", result.Types.FirstOrDefault().Text);
Assert.Equal("1", result.Types.FirstOrDefault().Value);
}
private WorkoutsService CreateWorkoutsService()
{
var userId = Guid.Parse(User.Identity.GetUserId());
var service = new WorkoutsService(userId);
return(service);
}
// GET: Workouts
public ActionResult Index()
{
var userId = Guid.Parse(User.Identity.GetUserId());
var service = new WorkoutsService(userId);
var model = service.GetWorkouts();
return(View(model));
}
public async Task DeleteWorkoutShouldWorkCorrectly()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()).Options;
var dbContext = new ApplicationDbContext(options);
var position = new Position
{
Name = PositionName.PowerForward,
Description = "Power Forward position",
Playstyle = "You play like a PF",
};
var workout = new Workout
{
Name = "Workout Five",
Description = "Some kind of randommm description again",
PositionId = position.Id,
VideoUrl = "test youtube link 5",
ImageUrl = "5testimg",
};
var workoutsRepository = new EfDeletableEntityRepository <Workout>(dbContext);
var positionsRepository = new EfDeletableEntityRepository <Position>(dbContext);
var positionsService = new PositionsService(positionsRepository);
var moqCloudinaryService = new Mock <ICloudinaryService>();
var coachRepository = new EfDeletableEntityRepository <Coach>(dbContext);
var coachesService = new CoachesService(coachRepository, moqCloudinaryService.Object);
var service = new WorkoutsService(moqCloudinaryService.Object, workoutsRepository, positionsService, coachesService);
var workoutId = workout.Id;
await dbContext.Positions.AddAsync(position);
await dbContext.Workouts.AddAsync(workout);
await dbContext.SaveChangesAsync();
await service.DeleteAsync(workoutId);
var workoutxd = service.GetWorkoutById(workoutId);
Assert.Null(workoutxd);
}
private bool SetStarState(int Id, bool newState)
{
var userId = Guid.Parse(User.Identity.GetUserId());
var service = new WorkoutsService(userId);
var detail = service.GetWorkoutById(Id);
var updateWorkout =
new WorkoutsEdit
{
Id = detail.Id,
Name = detail.Name,
//Ratings = detail.Ratings,
IsStarred = newState
};
return(service.UpdateWorkout(updateWorkout));
}
public void GetWorkoutByIdShouldReturnNullIfWorkoutDoesntExist()
{
var workouts = new List <Workout>
{
new Workout
{
Id = "workoutId123",
Name = "Workout One",
Description = "Some kind of workout description",
Position = new Position
{
Name = PositionName.ShootingGuard,
Description = "Shooting guard position",
Playstyle = "You play like a shooting guard",
},
VideoUrl = "test youtube link",
},
new Workout
{
Id = "workoutId456",
Name = "Workout Two",
Description = "Some kind of random description",
Position = new Position
{
Name = PositionName.PointGuard,
Description = "Point guard position",
Playstyle = "You play like a point guard",
},
VideoUrl = "test youtube link 2",
},
};
var positionsService = new PositionsService(this.positionsRepository.Object);
var coachesService = new CoachesService(this.coachRepository.Object, this.moqCloudinaryService.Object);
this.workoutsRepository.Setup(r => r.AllAsNoTracking()).Returns(() => workouts.AsQueryable());
var service = new WorkoutsService(this.moqCloudinaryService.Object, this.workoutsRepository.Object, positionsService, coachesService);
var workout = service.GetWorkoutById("notexistingworkout");
Assert.Null(workout);
this.workoutsRepository.Verify(x => x.AllAsNoTracking(), Times.Once);
}
public async Task GetWorkoutIdFromDateShouldReturnCorrectWorkoutId()
{
var optionsBuilder = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString());
var dbContext = new ApplicationDbContext(optionsBuilder.Options);
var workoutService = new WorkoutsService(dbContext);
var workoutToAdd = new WorkoutInputModel
{
Date = DateTime.Now.Date,
};
await workoutService.CreateAsync(workoutToAdd, "Icaka99");
var result = workoutService.GetWorkoutIdFromDate(DateTime.Now.Date.ToString("yy-MM-dd"));
Assert.Equal(1, result);
}
public async Task CreateExerciseMethodShouldAddCorrectNewExerciseToDbAndWorkout()
{
var optionsBuilder = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString());
var dbContext = new ApplicationDbContext(optionsBuilder.Options);
var workoutService = new WorkoutsService(dbContext);
var workoutToAdd = new WorkoutInputModel
{
Date = DateTime.Now.Date,
Duration = 180,
TypeId = 2,
};
await workoutService.CreateAsync(workoutToAdd, "Icaka99");
var sets = new List <SetInputModel>
{
new SetInputModel {
ExerciseId = 2, Reps = 1,
},
};
var exerciseToAdd = new ExerciseInputModel
{
MuscleGroupId = 1,
Name = "testName",
WorkoutId = 1,
Sets = sets,
};
await workoutService.CreateExerciseAsync(exerciseToAdd);
Assert.True(dbContext.Exercises.Any());
Assert.Equal(2, dbContext.Exercises.FirstOrDefault().Id);
Assert.Equal(1, dbContext.Exercises.FirstAsync().Result.MuscleGroupId);
Assert.Equal("testName", dbContext.Exercises.FirstAsync().Result.Name);
Assert.True(dbContext.Exercises.FirstAsync().Result.Sets.Any());
Assert.Equal(1, dbContext.Exercises.FirstAsync().Result.Sets.FirstOrDefault().Reps);
Assert.Equal(2, dbContext.Exercises.FirstAsync().Result.Sets.FirstOrDefault().ExerciseId);
}
public WorkoutsServiceTests()
{
var options = new DbContextOptionsBuilder <TrainConnectedDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options;
var dbContext = new TrainConnectedDbContext(options);
AutoMapperConfig.RegisterMappings(new[]
{
typeof(ErrorViewModel).GetTypeInfo().Assembly,
typeof(WorkoutActivityEditInputModel).GetTypeInfo().Assembly,
});
this.workoutsRepository = new EfRepository <Workout>(dbContext);
this.usersRepository = new EfRepository <TrainConnectedUser>(dbContext);
this.workoutActivityRepository = new EfRepository <WorkoutActivity>(dbContext);
this.usersWorkoutsRepository = new EfRepository <TrainConnectedUsersWorkouts>(dbContext);
this.paymentMethodsRepository = new EfRepository <PaymentMethod>(dbContext);
this.workoutsPaymentsMethodsRepository = new EfRepository <WorkoutsPaymentMethods>(dbContext);
this.workoutsService = new WorkoutsService(this.workoutsRepository, this.usersRepository, this.workoutActivityRepository, this.usersWorkoutsRepository, this.paymentMethodsRepository, this.workoutsPaymentsMethodsRepository);
}
public async Task CreateMethodShouldAddCorrectNewWorkoutToDb()
{
var optionsBuilder = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString());
var dbContext = new ApplicationDbContext(optionsBuilder.Options);
var workoutService = new WorkoutsService(dbContext);
var workoutToAdd = new WorkoutInputModel
{
Date = DateTime.Now.Date,
Duration = 180,
TypeId = 2,
};
await workoutService.CreateAsync(workoutToAdd, "Icaka99");
Assert.True(dbContext.Workouts.Any());
Assert.Equal(DateTime.Now.Date, dbContext.Workouts.FirstAsync().Result.Date);
Assert.Equal(180, dbContext.Workouts.FirstAsync().Result.Duration.TotalMinutes);
Assert.Equal(2, dbContext.Workouts.FirstAsync().Result.TypeId);
Assert.Equal("Icaka99", dbContext.Workouts.FirstAsync().Result.UserId);
}
public async Task AddWorkoutShouldCreateWorkoutAndAddItToCoach()
{
var workouts = new List <Workout>
{
new Workout
{
Id = "workoutId123",
Name = "Workout One",
Description = "Some kind of workout description",
Position = new Position
{
Id = "PositionOne",
Name = PositionName.ShootingGuard,
Description = "Shooting guard position",
Playstyle = "You play like a shooting guard",
},
VideoUrl = "test youtube link",
PositionId = "PositionOne",
Picture = new Picture {
Id = "pic", Url = "test url"
},
PictureId = "pic",
ImageUrl = "testimg",
AddedByCoach = new Coach
{
Id = "c1",
Name = "Coach1",
Description = "desc1",
Experience = 2,
Phone = "321312312",
Email = "*****@*****.**",
User = new ApplicationUser {
Id = "coachuser"
},
UserId = "coachuser",
Picture = new Picture {
Id = "cpic", Url = "test xurl"
},
PictureId = "cpic",
},
},
};
this.positionsRepository.Setup(r => r.AllAsNoTracking()).Returns(() => new List <Position>
{
new Position
{
Id = "PositionOne",
Name = PositionName.ShootingGuard,
Description = "Shooting guard position",
Playstyle = "You play like a shooting guard",
},
}.AsQueryable());
var positionsService = new PositionsService(this.positionsRepository.Object);
this.coachRepository.Setup(r => r.AllAsNoTracking()).Returns(() => new List <Coach>
{
new Coach
{
Id = "c1",
Name = "Coach1",
Description = "desc1",
Experience = 2,
Phone = "321312312",
Email = "*****@*****.**",
User = new ApplicationUser {
Id = "coachuser"
},
UserId = "coachuser",
Picture = new Picture {
Id = "cpic", Url = "test xurl"
},
PictureId = "cpic",
},
}.AsQueryable());
var coachesService = new CoachesService(this.coachRepository.Object, this.moqCloudinaryService.Object);
this.workoutsRepository.Setup(r => r.AllAsNoTracking()).Returns(() => workouts.AsQueryable());
var service = new WorkoutsService(this.moqCloudinaryService.Object, this.workoutsRepository.Object, positionsService, coachesService);
// Arrange
var fileMock = new Mock <IFormFile>();
// Setup mock file using a memory stream
var content = "Hello World from a Fake File";
var fileName = "test.pdf";
var ms = new MemoryStream();
var writer = new StreamWriter(ms);
writer.Write(content);
writer.Flush();
ms.Position = 0;
fileMock.Setup(_ => _.OpenReadStream()).Returns(ms);
fileMock.Setup(_ => _.FileName).Returns(fileName);
fileMock.Setup(_ => _.Length).Returns(ms.Length);
var file = fileMock.Object;
this.workoutsRepository.Setup(r => r.AddAsync(It.IsAny <Workout>())).Callback((Workout workout) => workouts.Add(workout));
var inputModel = new CreateWorkoutInputModel
{
Name = "Workout for beginners",
Description = "This workout is for beginners and it will help them",
PositionName = PositionName.ShootingGuard,
VideoUrl = "testvideourl",
Image = file,
};
await service.CreateAsync(inputModel, "coachuser");
Assert.Contains(workouts, x => x.Name == "Workout for beginners");
Assert.Equal(2, workouts.Count);
this.workoutsRepository.Verify(x => x.AllAsNoTracking(), Times.Never);
}
public void GetAllShouldReturnChosenWorkoutWhenFilteredForIt()
{
var workouts = new List <Workout>
{
new Workout
{
Id = "workoutId123",
Name = "Workout One",
Description = "Some kind of workout description",
Position = new Position
{
Id = "PositionOne",
Name = PositionName.ShootingGuard,
Description = "Shooting guard position",
Playstyle = "You play like a shooting guard",
},
VideoUrl = "test youtube link",
PositionId = "PositionOne",
Picture = new Picture {
Id = "pic", Url = "test url"
},
PictureId = "pic",
ImageUrl = "testimg",
AddedByCoach = new Coach
{
Id = "c1",
Name = "Coach1",
Description = "desc1",
Experience = 2,
Phone = "321312312",
Email = "*****@*****.**",
User = new ApplicationUser {
Id = "coachuser"
},
UserId = "coachuser",
Picture = new Picture {
Id = "cpic", Url = "test xurl"
},
PictureId = "cpic",
},
},
new Workout
{
Id = "workoutId456",
Name = "Workout Two",
Description = "Some kind of random description",
Position = new Position
{
Id = "PositionTwo",
Name = PositionName.PointGuard,
Description = "Point guard position",
Playstyle = "You play like a point guard",
},
PositionId = "PositionTwo",
VideoUrl = "test youtube link 2",
Picture = new Picture {
Id = "2pic", Url = "test 2url"
},
PictureId = "2pic",
ImageUrl = "2testimg",
AddedByCoach = new Coach
{
Id = "c2",
Name = "Coach2",
Description = "desc2",
Experience = 8,
Phone = "322312312",
Email = "*****@*****.**",
User = new ApplicationUser {
Id = "coachuser2"
},
UserId = "coachuser2",
Picture = new Picture {
Id = "cpic2", Url = "test xurl2"
},
PictureId = "cpic2",
},
},
new Workout
{
Id = "workoutId789",
Name = "Workout Three",
Description = "Some kind of random description again",
Position = new Position
{
Id = "PositionThree",
Name = PositionName.Center,
Description = "Center position",
Playstyle = "You play like a center",
},
PositionId = "PositionThree",
VideoUrl = "test youtube link 3",
Picture = new Picture {
Id = "3pic", Url = "test 3url"
},
PictureId = "3pic",
ImageUrl = "3testimg",
AddedByCoach = new Coach
{
Id = "c3",
Name = "Coach3",
Description = "desc3",
Experience = 5,
Phone = "32235412",
Email = "*****@*****.**",
User = new ApplicationUser {
Id = "coachuser3"
},
UserId = "coachuser3",
Picture = new Picture {
Id = "cpic3", Url = "test xurl3"
},
PictureId = "cpic3",
},
},
new Workout
{
Id = "workoutId21312312",
Name = "Workout Four",
Description = "Some kind of random description agaixn",
Position = new Position
{
Id = "PositionFour",
Name = PositionName.SmallForward,
Description = "Small Forward position",
Playstyle = "You play like a SF",
},
PositionId = "PositionFour",
VideoUrl = "test youtube link 4",
Picture = new Picture {
Id = "4pic", Url = "test 4url"
},
PictureId = "4pic",
ImageUrl = "4testimg",
AddedByCoach = new Coach
{
Id = "c4",
Name = "Coach4",
Description = "desc4",
Experience = 6,
Phone = "32235212",
Email = "*****@*****.**",
User = new ApplicationUser {
Id = "coachuser4"
},
UserId = "coachuser4",
Picture = new Picture {
Id = "cpic4", Url = "test xurl4"
},
PictureId = "cpic4",
},
},
new Workout
{
Id = "workoutId2312312312312",
Name = "Workout Five",
Description = "Some kind of randommm description again",
Position = new Position
{
Id = "PositionFive",
Name = PositionName.PowerForward,
Description = "Power Forward position",
Playstyle = "You play like a PF",
},
PositionId = "PositionFive",
VideoUrl = "test youtube link 5",
Picture = new Picture {
Id = "5pic", Url = "test 5url"
},
PictureId = "5pic",
ImageUrl = "5testimg",
AddedByCoach = new Coach
{
Id = "c5",
Name = "Coach5",
Description = "desc5",
Experience = 9,
Phone = "34435212",
Email = "*****@*****.**",
User = new ApplicationUser {
Id = "coachuser5"
},
UserId = "coachuser5",
Picture = new Picture {
Id = "cpic5", Url = "test xurl5"
},
PictureId = "cpic5",
},
},
};
var positionsService = new PositionsService(this.positionsRepository.Object);
var coachesService = new CoachesService(this.coachRepository.Object, this.moqCloudinaryService.Object);
this.workoutsRepository.Setup(r => r.AllAsNoTracking()).Returns(() => workouts.AsQueryable());
var service = new WorkoutsService(this.moqCloudinaryService.Object, this.workoutsRepository.Object, positionsService, coachesService);
var inputModel = new SearchWorkoutInputModel
{
PointGuard = true,
ShootingGuard = false,
SmallForward = false,
PowerForward = false,
Center = false,
};
var workoutsAll = service.GetSearchedPositions <WorkoutInListViewModel>(inputModel, 1, 12);
Assert.Equal("Workout Two", workoutsAll.Workouts.First().Name);
Assert.Single(workoutsAll.Workouts);
this.workoutsRepository.Verify(x => x.AllAsNoTracking(), Times.Once);
}
public void GetWorkoutForEditShouldThrowExceptionIfWorkoutNotFound()
{
var workouts = new List <Workout>
{
new Workout
{
Id = "workoutId2312312312312",
Name = "Workout Five",
Description = "Some kind of randommm description again",
Position = new Position
{
Id = "PositionFive",
Name = PositionName.PowerForward,
Description = "Power Forward position",
Playstyle = "You play like a PF",
},
PositionId = "PositionFive",
VideoUrl = "test youtube link 5",
Picture = new Picture {
Id = "5pic", Url = "test 5url"
},
PictureId = "5pic",
ImageUrl = "5testimg",
AddedByCoach = new Coach
{
Id = "c5",
Name = "Coach5",
Description = "desc5",
Experience = 9,
Phone = "34435212",
Email = "*****@*****.**",
User = new ApplicationUser {
Id = "coachuser5"
},
UserId = "coachuser5",
Picture = new Picture {
Id = "cpic5", Url = "test xurl5"
},
PictureId = "cpic5",
},
CoachId = "c5",
},
};
this.positionsRepository.Setup(r => r.AllAsNoTracking()).Returns(() => new List <Position>
{
new Position
{
Id = "PositionFive",
Name = PositionName.PowerForward,
Description = "Power Forward position",
Playstyle = "You play like a PF",
},
}.AsQueryable());
var positionsService = new PositionsService(this.positionsRepository.Object);
var coachesService = new CoachesService(this.coachRepository.Object, this.moqCloudinaryService.Object);
this.workoutsRepository.Setup(r => r.AllAsNoTracking()).Returns(() => workouts.AsQueryable());
var service = new WorkoutsService(this.moqCloudinaryService.Object, this.workoutsRepository.Object, positionsService, coachesService);
Assert.Throws <InvalidOperationException>(() => service.GetWorkoutForEdit("notexistingId"));
this.workoutsRepository.Verify(x => x.AllAsNoTracking(), Times.Once);
}
public async Task EditWorkoutShouldUpdateCorrectly()
{
var workouts = new List <Workout>
{
new Workout
{
Id = "workoutId2312312312312",
Name = "Workout Five",
Description = "Some kind of randommm description again",
Position = new Position
{
Id = "PositionFive",
Name = PositionName.PowerForward,
Description = "Power Forward position",
Playstyle = "You play like a PF",
},
PositionId = "PositionFive",
VideoUrl = "test youtube link 5",
Picture = new Picture {
Id = "5pic", Url = "test 5url"
},
PictureId = "5pic",
ImageUrl = "5testimg",
AddedByCoach = new Coach
{
Id = "c5",
Name = "Coach5",
Description = "desc5",
Experience = 9,
Phone = "34435212",
Email = "*****@*****.**",
User = new ApplicationUser {
Id = "coachuser5"
},
UserId = "coachuser5",
Picture = new Picture {
Id = "cpic5", Url = "test xurl5"
},
PictureId = "cpic5",
},
CoachId = "c5",
},
};
this.positionsRepository.Setup(r => r.AllAsNoTracking()).Returns(() => new List <Position>
{
new Position
{
Id = "PositionFive",
Name = PositionName.PowerForward,
Description = "Power Forward position",
Playstyle = "You play like a PF",
},
}.AsQueryable());
var positionsService = new PositionsService(this.positionsRepository.Object);
var coachesService = new CoachesService(this.coachRepository.Object, this.moqCloudinaryService.Object);
this.workoutsRepository.Setup(r => r.AllAsNoTracking()).Returns(() => workouts.AsQueryable());
var service = new WorkoutsService(this.moqCloudinaryService.Object, this.workoutsRepository.Object, positionsService, coachesService);
var model = new EditWorkoutViewModel
{
Id = "workoutId2312312312312",
Name = "Changed name",
Description = "Some kind of randommm description again",
PositionName = PositionName.PowerForward,
VideoUrl = "test youtube link CHANGED",
CoachId = "c5",
};
await service.EditAsync(model);
var workout = service.GetWorkoutById("workoutId2312312312312");
Assert.Equal("Changed name", workout.Name);
Assert.Equal("test youtube link CHANGED", workout.VideoUrl);
this.workoutsRepository.Verify(x => x.AllAsNoTracking(), Times.AtMost(2));
}
public async Task GetDetailsShouldReturnAllCorrectDetailsAboutWorkoutById()
{
var optionsBuilder = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString());
var dbContext = new ApplicationDbContext(optionsBuilder.Options);
var workoutService = new WorkoutsService(dbContext);
var user = new ApplicationUser {
UserName = "******", Id = "Icaka99"
};
var type = new WorkoutType {
Name = "testWorkoutTypeName", Id = 2
};
var muscleGroup = new MuscleGroup {
Name = "testMuscleGroupName", Id = 2
};
var sets = new List <Set>
{
new Set {
ExerciseId = 2, Reps = 1,
},
};
var exercises = new List <Exercise>()
{
new Exercise
{
Id = 2,
Name = "testExerciseName",
MuscleGroup = muscleGroup,
WorkoutId = 1,
Sets = sets,
MuscleGroupId = 2,
},
};
var workout = new Workout
{
Date = DateTime.Now.Date,
Duration = TimeSpan.FromMinutes(180),
TypeId = 2,
User = user,
UserId = user.Id,
Type = type,
Exercises = exercises,
};
await dbContext.AddAsync(workout);
await dbContext.SaveChangesAsync();
var result = workoutService.GetDetails(1);
Assert.NotNull(result);
Assert.Equal(DateTime.Now.Date, result.Date);
Assert.Equal(180, result.Duration);
Assert.Equal(1, result.Id);
Assert.Equal("Icaka99", result.UserUserName);
Assert.Equal("testWorkoutTypeName", result.WorkoutType.Name);
Assert.Equal(2, result.WorkoutType.Id);
Assert.Equal(2, result.Exercises.FirstOrDefault().Id);
Assert.Equal("testMuscleGroupName", result.Exercises.FirstOrDefault().MuscleGroup.Name);
Assert.Equal(2, result.Exercises.FirstOrDefault().MuscleGroup.Id);
Assert.Equal("testExerciseName", result.Exercises.FirstOrDefault().Name);
Assert.Equal(1, result.Exercises.FirstOrDefault().Sets.FirstOrDefault().Reps);
}
public WorkoutsController(WorkoutsService ws)
{
_ws = ws;
}
