public PagedResult <ExerciseDTO> GetExercises(Token token, ExerciseSearchCriteria searchCriteria, PartialRetrievingInfo retrievingInfo)
{
var securityInfo = SecurityManager.EnsureAuthentication(token);
ExerciseService service = new ExerciseService(Session, securityInfo, Configuration);
return(service.GetExercises(searchCriteria, retrievingInfo));
}
public ExerciseDTO SaveExercise(Token token, ExerciseDTO exercise)
{
var securityInfo = SecurityManager.EnsureAuthentication(token);
ExerciseService service = new ExerciseService(Session, securityInfo, Configuration);
return(service.SaveExercise(exercise));
}
public void Init()
{
_mock = new Mock <IExerciseRepositoryDTO>();
_exerciseService = new ExerciseService(_mock.Object);
_exercises = new List <ExerciseDTO>
{
new ExerciseDTO
{
Id = 1,
Name = "Tightening",
CreatedDate = DateTime.Now,
ModifiedDate = DateTime.Now
},
new ExerciseDTO
{
Id = 2,
Name = "Dips",
CreatedDate = DateTime.Now,
ModifiedDate = DateTime.Now
},
new ExerciseDTO
{
Id = 3,
Name = "Curl up",
CreatedDate = DateTime.Now,
ModifiedDate = DateTime.Now
}
};
}
public void SetUp()
{
days = new List <Day>
{
new Day {
Id = 1, Name = "Monday", IsRestDay = false
},
new Day {
Id = 2, Name = "Tuesday", IsRestDay = true
}
};
exercises = new List <Exercise>
{
new Exercise {
Id = 1, Day = days[0], Name = "Bench", Reps = 10, Sets = 4, WeightInKg = 100
}
};
dbContext = new Mock <FitRoutineContext>();
dbContext.Setup(p => p.Days)
.Returns(DbContextMock.GetQueryableMockDbSet(days));
dbContext.Setup(p => p.Exercises)
.Returns(DbContextMock.GetQueryableMockDbSet(exercises));
dbContext.Setup(p => p.SaveChanges()).Returns(1);
service = new ExerciseService(dbContext.Object);
}
public void ExerciseService_TimerTick_SignalsActiveSubExerciseChanged(int elapsedTicks, SubExercise expectedOldSubExercise, SubExercise expectedNewSubExercise)
{
// Arrange
var actualOldSubExercise = SubExercise.Undefined;
var actualNewSubExercise = SubExercise.Undefined;
var stubTimerService = Substitute.For <ITimerService>();
var stubExerciseTrackerService = Substitute.For <IExerciseTrackerService>();
var unitUnderTest = ExerciseService.ExerciseServiceFromString(string.Empty, CreateTestExerciseConfiguration(), stubTimerService, stubExerciseTrackerService);
bool handled = false;
unitUnderTest.Run();
for (var i = 0; i < elapsedTicks - 1; i++)
{
stubTimerService.Elapsed += Raise.Event();
}
unitUnderTest.ActiveSubExerciseChanged += (sender, args) =>
{
if (!handled)
{
actualOldSubExercise = args.OldSubExercise;
actualNewSubExercise = args.NewSubExercise;
handled = true;
}
};
// Act
stubTimerService.Elapsed += Raise.Event();
// Assert
Assert.AreEqual(expectedOldSubExercise, actualOldSubExercise);
Assert.AreEqual(expectedNewSubExercise, actualNewSubExercise);
}
private List<Exercise> GetExercises()
{
var exerciseService = new ExerciseService(new ExerciseRepository(), new MuscleRepository());
List<Exercise> allExercises = exerciseService.GetAll();
return allExercises;
}
public void ExerciseService_PrepareExerciseServiceFromJsonWithEmptyString_CreatesDefault()
{
// Arrange
var eventThrown = false;
var exerciseConfiguration = new ExerciseConfiguration
{
NoOfRepetitions = 8,
DurationPerStance = 10,
PreparationDuration = 3
};
Exercise actualExercise = null;
var expectedExercise = new Exercise(exerciseConfiguration);
var stubTimerService = Substitute.For <ITimerService>();
var stubExerciseTrackerService = Substitute.For <IExerciseTrackerService>();
var unitUnderTest = ExerciseService.ExerciseServiceFromString(string.Empty, exerciseConfiguration, stubTimerService, stubExerciseTrackerService);
unitUnderTest.ExerciseChanged += (sender, args) =>
{
eventThrown = true;
actualExercise = args.Exercise;
};
// Act
unitUnderTest.PrepareForNewExercise();
// Assert
// TODO: Move this to a sepparate test
Assert.IsTrue(eventThrown, "Expected exercise changed event thrown");
Assert.AreEqual(expectedExercise.ToString(), actualExercise.ToString());
}
public void ExerciseService_Stop_SignalsActiveSubExerciseChnaged()
{
// Arrange
var actualOldSubExercise = SubExercise.Undefined;
var actualNewSubExercise = SubExercise.Undefined;
var stubTimerService = Substitute.For <ITimerService>();
var stubExerciseTrackerService = Substitute.For <IExerciseTrackerService>();
var unitUnderTest = ExerciseService.ExerciseServiceFromString(string.Empty, CreateTestExerciseConfiguration(), stubTimerService, stubExerciseTrackerService);
unitUnderTest.Run();
for (var i = 0; i < 193; i++)
{
stubTimerService.Elapsed += Raise.Event();
}
unitUnderTest.ActiveSubExerciseChanged += (sender, args) =>
{
actualOldSubExercise = args.OldSubExercise;
actualNewSubExercise = args.NewSubExercise;
};
// Act
unitUnderTest.Stop();
// Assert
Assert.AreEqual(SubExercise.ShortLeft, actualOldSubExercise);
Assert.AreEqual(SubExercise.Undefined, actualNewSubExercise);
}
public async Task UpdateExercise_UpdatesExistingExercise()
{
var exercise = new Exercise
{
Title = "Exercise Title",
Body = "Exercise Body"
};
using (var context = new ApplicationDbContext(Options))
{
context.Exercises.Add(exercise);
context.SaveChanges();
}
exercise.Title = "Updated Title";
exercise.Body = "Update Body";
using (var context = new ApplicationDbContext(Options))
{
var service = new ExerciseService(context);
Exercise updatedExercise = await service.UpdateExercise(exercise);
Assert.AreEqual(exercise, updatedExercise);
}
using (var context = new ApplicationDbContext(Options))
{
Exercise retrievedExercise = context.Exercises.Single();
Assert.AreEqual(exercise.Id, retrievedExercise.Id);
Assert.AreEqual(exercise.Title, retrievedExercise.Title);
Assert.AreEqual(exercise.Body, retrievedExercise.Body);
}
}
public void ExerciseService_TimerTick_ExerciseChangedCorrect(int elapsedTicks, string testCaseDescription, string expectedExerciseState)
{
// Arrange
var stubTimerService = Substitute.For <ITimerService>();
var stubExerciseTrackerService = Substitute.For <IExerciseTrackerService>();
var unitUnderTest = ExerciseService.ExerciseServiceFromString(string.Empty, CreateTestExerciseConfiguration(), stubTimerService, stubExerciseTrackerService);
Exercise actualExercise = null;
bool handled = false;
unitUnderTest.Run();
for (var i = 0; i < elapsedTicks - 1; i++)
{
stubTimerService.Elapsed += Raise.Event();
}
unitUnderTest.ExerciseChanged += (sender, args) =>
{
if (!handled)
{
actualExercise = args.Exercise;
handled = true;
}
};
// Act
stubTimerService.Elapsed += Raise.Event();
// Assert
Assert.AreEqual(expectedExerciseState, actualExercise.ToString(), $"TestCase {testCaseDescription} failed");
}
public async Task AddExercise_PersistsExercise()
{
var exercise = new Exercise
{
Title = "Exercise Title",
Body = "Exercise Body"
};
using (var context = new ApplicationDbContext(Options))
{
var service = new ExerciseService(context);
Exercise addedExercise = await service.AddExercise(exercise);
Assert.AreEqual(addedExercise, exercise);
Assert.AreNotEqual(0, addedExercise.Id);
}
using (var context = new ApplicationDbContext(Options))
{
Exercise retrievedExercise = context.Exercises.Single();
Assert.AreEqual(exercise.Title, retrievedExercise.Title);
Assert.AreEqual(exercise.Body, retrievedExercise.Body);
}
}
public ExercisesListPage()
{
InitializeComponent();
Service = new ExerciseService();
listExercises.ItemsSource = Service.GetList();
Title = "Available Exercises";
}
public void CanGetExerciseById()
{
//Arrange:
Exercise exercise = new Exercise()
{
Id = 1,
ExerciseName = "ExerciseName",
ExerciseTextBody = "ExerciseTextBody",
DifficultyLevel = 10
};
ExerciseVM exerciseVM = new ExerciseVM()
{
ExerciseName = "ExerciseName",
ExerciseTextBody = "ExerciseTextBody",
DifficultyLevel = 10
};
var mock = new Mock <IExerciseRepository>();
mock.Setup(s => s.GetExerciseById(1)).Returns(exercise);
//Act:
var exerciseService = new ExerciseService(mock.Object);
var returnData = exerciseService.GetExerciceById(1);
//Assert:
returnData.Should().BeOfType(typeof(ExerciseVM));
returnData.Should().Equals(exerciseVM);
}
public void GetAllExerciseNames_ShouldReturnICollectionOfTwoStringsWhenTwoExercisesArePresentInTheRepo()
{
var exercisesRepoStub = new Mock <IEfRepostory <Exercise> >();
var unitOfWorkStub = new Mock <IUnitOfWork>();
var list = new List <Exercise>();
var exerciseOne = new Exercise();
exerciseOne.Name = "gosho";
var exerciseTwo = new Exercise
{
Name = "pesho"
};
list.Add(exerciseOne);
list.Add(exerciseTwo);
var dbSetStub = list.AsQueryable();
var sut = new ExerciseService(exercisesRepoStub.Object, unitOfWorkStub.Object);
exercisesRepoStub.Setup(x => x.All).Returns(dbSetStub);
var result = sut.GetAllExerciseNames();
Assert.AreEqual(2, result.Count);
}
public void ExerciseOperation(Token token, ExerciseOperationParam param)
{
var securityInfo = SecurityManager.EnsureAuthentication(token);
var service = new ExerciseService(Session, securityInfo, Configuration);
service.ExerciseOperation(param);
}
public void Should_UpdateExercise_ReturnCorrectExercise_WhenServiceUpdateCalled()
{
var exerciseType = new ExerciseType()
{
Id = 1, Name = "dummy Exercise Type"
};
var exerciseVm = new NewExerciseVm()
{
Id = 1,
Name = "dummy exercise",
ExerciseTypeId = 1
};
var exerciseRepo = new Mock <IExerciseRepository>();
var exerciseTypeRepo = new Mock <IExerciseTypeRepository>();
var mapper = new Mock <IMapper>();
exerciseTypeRepo.Setup(r => r.GetExerciseTypeById(exerciseType.Id)).Returns(exerciseType);
var objectUnderTest = new ExerciseService(exerciseRepo.Object, exerciseTypeRepo.Object, mapper.Object);
objectUnderTest.UpdateExercise(exerciseVm);
exerciseRepo.Verify(r => r.UpdateExercise(It.IsAny <Exercise>()), Times.Once);
}
public void Should_GetExercise_ReturnCorrectExercise_WhenServiceGetExerciseCalled()
{
var exercise = new Exercise()
{
Id = 1, Name = "dummy Exercise", ExerciseType = new ExerciseType()
{
Id = 1, Name = "dummy exercise type"
}
};
var expectedResult = new ExerciseForListVm()
{
Id = 1,
Name = "dummy Exercise",
ExerciseTypeName = exercise.ExerciseType.Name,
};
var exerciseRepo = new Mock <IExerciseRepository>();
var exerciseTypeRepo = new Mock <IExerciseTypeRepository>();
var mapper = new Mock <IMapper>();
exerciseRepo.Setup(r => r.GetExerciseById(exercise.Id)).Returns(exercise);
var objectUnderTest = new ExerciseService(exerciseRepo.Object, exerciseTypeRepo.Object, mapper.Object);
var result = objectUnderTest.GetExercise(exercise.Id);
exerciseRepo.Verify(r => r.GetExerciseById(exercise.Id), Times.Once);
Assert.Equal(expectedResult.Id, result.Id);
Assert.Equal(expectedResult.Name, result.Name);
Assert.Equal(expectedResult.ExerciseTypeName, result.ExerciseTypeName);
}
public async Task DeleteRule(int id)
{
var service = new ExerciseService();
var result = await service.DeleteRuleAsync(id);
if (result)
{
await SetRules();
}
else
{
var contentDialog = new ContentDialog
{
Background = new SolidColorBrush(Colors.LemonChiffon),
Content = new TextBlock
{
FontSize = 18,
Text = "A szabályhoz feladat tartozik, ezért nem törölhető.",
TextWrapping = Windows.UI.Xaml.TextWrapping.Wrap,
Margin = new Windows.UI.Xaml.Thickness(20)
},
CloseButtonText = "Ok"
};
await contentDialog.ShowAsync();
}
}
public IHttpActionResult Get(string exerciseName)
{
ExerciseService exerciseService = CreateExerciseService();
var exercise = exerciseService.GetExerciseByName(exerciseName);
return(Ok(exercise));
}
public void Should_RepoAddExercise_BeCalled_WhenServiceAddExerciseCalled()
{
var exerciseType = new ExerciseType()
{
Id = 1, Name = "dummy Exercise Type"
};
var exerciseVm = new NewExerciseVm()
{
Id = 1,
Name = "Dummy",
ExerciseTypeId = exerciseType.Id,
};
var exerciseRepo = new Mock <IExerciseRepository>();
var exerciseTypeRepo = new Mock <IExerciseTypeRepository>();
var mapper = new Mock <IMapper>();
exerciseTypeRepo.Setup(r => r.GetExerciseTypeById(exerciseType.Id)).Returns(exerciseType);
var objectUnderTest = new ExerciseService(exerciseRepo.Object, exerciseTypeRepo.Object, mapper.Object);
var result = objectUnderTest.AddExercise(exerciseVm);
exerciseRepo.Verify(r => r.AddExercise(It.IsAny <Exercise>()), Times.Once);
Assert.Equal(exerciseType.Id, result);
}
public IHttpActionResult Get()
{
ExerciseService exerciseService = CreateExerciseService();
var exercises = exerciseService.GetExercises();
return(Ok(exercises));
}
public IHttpActionResult Get(int id)
{
ExerciseService exerciseService = CreateExerciseService();
var exercise = exerciseService.GetExerciseById(id);
return(Ok(exercise));
}
public ActionResult Progress()
{
var userId = Guid.Parse(User.Identity.GetUserId());
var service = new ExerciseService(userId);
var manager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(new ApplicationDbContext()));
var currentUser = manager.FindById(User.Identity.GetUserId());
using (var context = new ApplicationDbContext())
{
var query = from b in context.Workouts
where b.OwnerId == userId
select b.CaloriesBurned;
List <double> plist = query.ToList();
ViewBag.caloriesBurned = plist;
var query2 = from b in context.Workouts
where b.OwnerId == userId
select b.Type;
List <string> elist = query2.ToList();
ViewBag.type = elist;
}
return(View());
}
private ExerciseService CreateExerciseService()
{
var userId = Guid.Parse(User.Identity.GetUserId());
var exerciseService = new ExerciseService(userId);
return(exerciseService);
}
public ExercisesController(ExerciseService exerciseService, MuscleGroupService muscleGroupService, ExerciseListService exerciseListService, IMemoryCache cache)
{
_exerciseService = exerciseService;
_muscleGroupService = muscleGroupService;
_exerciseListService = exerciseListService;
_cache = cache;
}
public ActionResult Edit(int id)
{
_trainerService = new TrainerService(Guid.Parse(User.Identity.GetUserId()));
_exerciseService = new ExerciseService(Guid.Parse(User.Identity.GetUserId()));
ViewBag.ExerciseId = new SelectList(_exerciseService.GetExercise().ToList(), "ExerciseId", "NameOfExercise");
ViewBag.TrainerId = new SelectList(_trainerService.GetTrainer().ToList(), "TrainerId", "TrainerName");
var service = CreateWorkoutService();
var eService = CreateExerciseService();
var tService = CreateTrainerService();
var detail = service.GetWorkoutById(id);
var exercises = eService.GetExercise();
var trainers = tService.GetTrainer();
var model =
new WorkoutEdit
{
WorkoutId = detail.WorkoutId,
NameOfWorkout = detail.NameOfWorkout,
TrainerId = detail.TrainerId,
ExerciseId = detail.ExerciseId,
Day = detail.Day,
Duration = detail.Duration,
DayOfWorkout = detail.DayOfWorkout,
Exercise = exercises,
Trainer = trainers
};
return(View(model));
}
private PaginationResult <ExerciseBrief> Run(Action <SearchExerciseRequest> requestAction = null)
{
var request = new SearchExerciseRequest();
requestAction?.Invoke(request);
return(ExerciseService.Search(request));
}
public ActionResult Delete(int id)
{
var userId = Guid.Parse(User.Identity.GetUserId());
var service = new ExerciseService(userId);
var model = service.GetWorkoutById(id);
return(View(model));
}
public ExerciseServiceTests()
{
_fixture = new Fixture();
_exerciseRepository = Substitute.For <IExerciseRepository>();
_mapper = Substitute.For <IMapper>();
_mapper = AutoMapperConfig.Initialize();
_sut = new ExerciseService(_exerciseRepository, _mapper);
}
// GET: Exercise
public ActionResult Index()
{
var userId = Guid.Parse(User.Identity.GetUserId());
var service = new ExerciseService(userId);
var model = service.GetExercises();
return(View(model));
}
public SavedController(
ExerciseService exerciseService,
WorkoutService workoutService,
UserManager <ApplicationUser> userManager)
{
_workoutService = workoutService;
_exerciseService = exerciseService;
_userManager = userManager;
}
