public void progress_time_span_reflects_any_progression_through_the_exercise()
{
var scheduler = new TestScheduler();
var model = new ExerciseBuilder()
.Build();
var executionContext = new ExecutionContext();
var sut = new ExerciseViewModelBuilder()
.WithSchedulerService(scheduler)
.WithExecutionContext(executionContext)
.WithModel(model)
.Build();
executionContext.SetCurrentExercise(model);
scheduler.AdvanceMinimal();
Assert.Equal(TimeSpan.Zero, sut.ProgressTimeSpan);
executionContext.AddProgress(TimeSpan.FromSeconds(3));
scheduler.AdvanceMinimal();
Assert.Equal(TimeSpan.FromSeconds(3), sut.ProgressTimeSpan);
executionContext.AddProgress(TimeSpan.FromSeconds(2));
scheduler.AdvanceMinimal();
Assert.Equal(TimeSpan.FromSeconds(5), sut.ProgressTimeSpan);
}
public void progress_is_calculated_based_on_duration_and_progress_time_span(int durationInMs, int progressInMs, double expectedProgress)
{
var scheduler = new TestScheduler();
var action = new ActionMock(MockBehavior.Loose);
action
.When(x => x.Duration)
.Return(TimeSpan.FromMilliseconds(durationInMs));
var model = new ExerciseBuilder()
.WithBeforeExerciseAction(action)
.Build();
var executionContext = new ExecutionContext();
var sut = new ExerciseViewModelBuilder()
.WithSchedulerService(scheduler)
.WithExecutionContext(executionContext)
.WithModel(model)
.Build();
executionContext.SetCurrentExercise(model);
executionContext.AddProgress(TimeSpan.FromMilliseconds(progressInMs));
scheduler.AdvanceMinimal();
Assert.Equal(expectedProgress, sut.Progress);
}
public void ctor_throws_if_execution_context_is_null()
{
var model = new ExerciseBuilder()
.Build();
Assert.Throws <ArgumentNullException>(() => new ExerciseViewModel(new TestSchedulerService(), model, null));
}
public void ctor_throws_if_scheduler_service_is_null()
{
var model = new ExerciseBuilder()
.Build();
Assert.Throws <ArgumentNullException>(() => new ExerciseViewModel(null, model, Observable.Never <ExecutionContext>()));
}
public void progress_time_span_reflects_any_progression_through_the_exercise()
{
var scheduler = new TestScheduler();
var model = new ExerciseBuilder()
.Build();
var executionContext = new ExecutionContext();
var sut = new ExerciseViewModelBuilder()
.WithSchedulerService(scheduler)
.WithExecutionContext(executionContext)
.WithModel(model)
.Build();
executionContext.SetCurrentExercise(model);
scheduler.AdvanceMinimal();
Assert.Equal(TimeSpan.Zero, sut.ProgressTimeSpan);
executionContext.AddProgress(TimeSpan.FromSeconds(3));
scheduler.AdvanceMinimal();
Assert.Equal(TimeSpan.FromSeconds(3), sut.ProgressTimeSpan);
executionContext.AddProgress(TimeSpan.FromSeconds(2));
scheduler.AdvanceMinimal();
Assert.Equal(TimeSpan.FromSeconds(5), sut.ProgressTimeSpan);
}
public void repetition_count_yields_the_repetition_count_passed_into_ctor(int repetitionCount)
{
var sut = new ExerciseBuilder()
.WithRepetitionCount(repetitionCount)
.Build();
Assert.Equal(repetitionCount, sut.RepetitionCount);
}
public void progress_time_span_is_not_reset_to_zero_if_another_exercise_is_started()
{
var scheduler = new TestScheduler();
var model1 = new ExerciseBuilder()
.WithName("model 1")
.Build();
var model2 = new ExerciseBuilder()
.WithName("model 2")
.Build();
var executionContext = new ExecutionContext();
var sut = new ExerciseViewModelBuilder()
.WithSchedulerService(scheduler)
.WithExecutionContext(executionContext)
.WithModel(model1)
.Build();
executionContext.SetCurrentExercise(model1);
executionContext.AddProgress(TimeSpan.FromSeconds(3));
scheduler.AdvanceMinimal();
Assert.Equal(TimeSpan.FromSeconds(3), sut.ProgressTimeSpan);
executionContext.SetCurrentExercise(model2);
scheduler.AdvanceMinimal();
Assert.Equal(TimeSpan.FromSeconds(3), sut.ProgressTimeSpan);
executionContext.AddProgress(TimeSpan.FromSeconds(3));
scheduler.AdvanceMinimal();
Assert.Equal(TimeSpan.FromSeconds(3), sut.ProgressTimeSpan);
}
public void ToAssignmentResultDtoShouldConvertTestResults()
{
//Arrange
var converter = new AssignmentWitResultsConverter();
var assigment = new ExerciseBuilder().Build();
var testsWithResults = new List <TestWithLastResultOfUser>
{
new TestWithLastResultOfUserBuilder().WithAssignmentId(assigment.Id).Build(),
new TestWithLastResultOfUserBuilder().WithAssignmentId(assigment.Id).Build(),
};
var assignmentWithResults = new AssignmentWithLastResultsOfUser
{
Assignment = assigment,
TestsWithLastResultOfUser = testsWithResults
};
//Act
var result = converter.ToAssignmentResultDto(assignmentWithResults);
//Assert
Assert.That(result, Is.Not.Null);
Assert.That(result.TestResults.Count, Is.EqualTo(testsWithResults.Count));
foreach (var testWithUserResults in testsWithResults)
{
Assert.That(result.TestResults, Has.Some.Matches((TestResultDto dto) => dto.TestName == testWithUserResults.Test.TestName));
}
}
public void name_yields_the_name_passed_into_ctor(string name)
{
var sut = new ExerciseBuilder()
.WithName(name)
.Build();
Assert.Equal(name, sut.Name);
}
public void execute_async_throws_if_execution_context_is_null()
{
var sut = new ExerciseBuilder()
.Build();
Assert.Throws <ArgumentNullException>(() => sut.ExecuteAsync(null));
}
public void set_count_yields_the_set_count_passed_into_ctor(int setCount)
{
var sut = new ExerciseBuilder()
.WithSetCount(setCount)
.Build();
Assert.Equal(setCount, sut.SetCount);
}
public void duration_returns_zero_if_there_are_no_actions()
{
var sut = new ExerciseBuilder()
.Build();
Assert.Equal(TimeSpan.Zero, sut.Duration);
}
public void TaggableBuilderCanBuildExerciseWithTags()
{
var builder = new ExerciseBuilder("jog",20);
builder.AddTag(new Tag("brisk"));
var exercise = builder.GetInstance();
Assert.AreEqual("jog", exercise.Type);
Assert.AreEqual(1, exercise.Tags.Count);
}
public void name_yields_the_name_passed_into_ctor(string name)
{
var sut = new ExerciseBuilder()
.WithName(name)
.Build();
Assert.Equal(name, sut.Name);
}
public void set_count_yields_the_set_count_passed_into_ctor(int setCount)
{
var sut = new ExerciseBuilder()
.WithSetCount(setCount)
.Build();
Assert.Equal(setCount, sut.SetCount);
}
public void repetition_count_yields_the_repetition_count_passed_into_ctor(int repetitionCount)
{
var sut = new ExerciseBuilder()
.WithRepetitionCount(repetitionCount)
.Build();
Assert.Equal(repetitionCount, sut.RepetitionCount);
}
public void skip_backwards_command_restarts_the_execution_context_from_the_start_of_the_previous_exercise_if_the_current_exercise_if_only_recently_started()
{
var action = new ActionMock();
action
.When(x => x.Duration)
.Return(TimeSpan.FromSeconds(10));
action
.When(x => x.Execute(It.IsAny <ExecutionContext>()))
.Return <ExecutionContext>(
ec =>
{
ec.AddProgress(TimeSpan.FromSeconds(0.5));
ec.IsPaused = true;
return(ec.WaitWhilePaused());
});
var exercise1 = new ExerciseBuilder()
.WithName("Exercise 1")
.WithBeforeExerciseAction(action)
.Build();
var exercise2 = new ExerciseBuilder()
.WithName("Exercise 2")
.WithBeforeExerciseAction(action)
.Build();
var sut = new ExerciseProgramViewModelBuilder()
.WithModel(new ExerciseProgramBuilder()
.WithExercise(exercise1)
.WithExercise(exercise2))
.Build();
var progress = sut
.WhenAnyValue(x => x.ProgressTimeSpan)
.CreateCollection();
// start from the second exercise
sut
.StartCommand
.Execute(exercise1.Duration)
.Subscribe();
sut
.SkipBackwardsCommand
.Execute()
.Subscribe();
Assert.Equal(5, progress.Count);
Assert.Equal(TimeSpan.Zero, progress[0]);
Assert.Equal(TimeSpan.FromSeconds(10), progress[1]);
Assert.Equal(TimeSpan.FromSeconds(10.5), progress[2]);
Assert.Equal(TimeSpan.Zero, progress[3]);
Assert.Equal(TimeSpan.FromSeconds(10), progress[4]);
}
public void current_exercise_reflects_that_in_the_execution_context()
{
var scheduler = new TestSchedulerService();
var action = new ActionMock();
action
.When(x => x.Duration)
.Return(TimeSpan.FromSeconds(10));
action
.When(x => x.ExecuteAsync(It.IsAny <ExecutionContext>()))
.Return <ExecutionContext>(
ec =>
{
ec.IsPaused = true;
return(ec.WaitWhilePausedAsync());
});
var exercise1 = new ExerciseBuilder()
.WithName("Exercise 1")
.WithBeforeExerciseAction(action)
.Build();
var exercise2 = new ExerciseBuilder()
.WithName("Exercise 2")
.WithBeforeExerciseAction(action)
.Build();
var exercise3 = new ExerciseBuilder()
.WithName("Exercise 3")
.WithBeforeExerciseAction(action)
.Build();
var sut = new ExerciseProgramViewModelBuilder()
.WithModel(new ExerciseProgramBuilder()
.AddExercise(exercise1)
.AddExercise(exercise2)
.AddExercise(exercise3))
.WithSchedulerService(scheduler)
.Build();
sut.StartCommand.Execute(null);
scheduler.AdvanceMinimal();
Assert.Equal("Exercise 1", sut.CurrentExercise?.Name);
sut.SkipForwardsCommand.Execute(null);
scheduler.AdvanceMinimal();
Assert.Equal("Exercise 2", sut.CurrentExercise?.Name);
sut.SkipForwardsCommand.Execute(null);
scheduler.AdvanceMinimal();
Assert.Equal("Exercise 3", sut.CurrentExercise?.Name);
sut.SkipBackwardsCommand.Execute(null);
scheduler.AdvanceMinimal();
Assert.Equal("Exercise 2", sut.CurrentExercise?.Name);
}
public void execute_async_skips_actions_that_are_shorter_than_the_skip_ahead_even_if_the_context_is_paused()
{
var action1 = new ActionMock(MockBehavior.Loose);
var action2 = new ActionMock(MockBehavior.Loose);
var action3 = new ActionMock(MockBehavior.Loose);
var eventMatcher1 = new EventMatcherMock();
var eventMatcher2 = new EventMatcherMock();
var eventMatcher3 = new EventMatcherMock();
action1
.When(x => x.Duration)
.Return(TimeSpan.FromSeconds(10));
action2
.When(x => x.Duration)
.Return(TimeSpan.FromSeconds(3));
action3
.When(x => x.Duration)
.Return(TimeSpan.FromSeconds(1));
action1
.When(x => x.ExecuteAsync(It.IsAny <ExecutionContext>()))
.Throw();
action2
.When(x => x.ExecuteAsync(It.IsAny <ExecutionContext>()))
.Throw();
eventMatcher1
.When(x => x.Matches(It.IsAny <IEvent>()))
.Return((IEvent @event) => @event is BeforeExerciseEvent);
eventMatcher2
.When(x => x.Matches(It.IsAny <IEvent>()))
.Return((IEvent @event) => @event is BeforeExerciseEvent);
eventMatcher3
.When(x => x.Matches(It.IsAny <IEvent>()))
.Return((IEvent @event) => @event is BeforeExerciseEvent);
var sut = new ExerciseBuilder()
.AddMatcherWithAction(new MatcherWithAction(eventMatcher1, action1))
.AddMatcherWithAction(new MatcherWithAction(eventMatcher2, action2))
.AddMatcherWithAction(new MatcherWithAction(eventMatcher3, action3))
.Build();
using (var executionContext = new ExecutionContext(TimeSpan.FromSeconds(13)))
{
executionContext.IsPaused = true;
sut.ExecuteAsync(executionContext);
action3
.Verify(x => x.ExecuteAsync(executionContext))
.WasCalledExactlyOnce();
}
}
public void skip_forwards_command_is_disabled_if_on_last_exercise()
{
var action = new ActionMock();
action
.When(x => x.Duration)
.Return(TimeSpan.FromSeconds(10));
action
.When(x => x.Execute(It.IsAny <ExecutionContext>()))
.Return <ExecutionContext>(
ec =>
{
ec.IsPaused = true;
return(ec.WaitWhilePaused());
});
var exercise1 = new ExerciseBuilder()
.WithName("Exercise 1")
.WithBeforeExerciseAction(action)
.Build();
var exercise2 = new ExerciseBuilder()
.WithName("Exercise 2")
.WithBeforeExerciseAction(action)
.Build();
var sut = new ExerciseProgramViewModelBuilder()
.WithModel(new ExerciseProgramBuilder()
.WithExercise(exercise1)
.WithExercise(exercise2))
.Build();
var canExecute = sut
.SkipForwardsCommand
.CanExecute
.CreateCollection();
sut
.StartCommand
.Execute()
.Subscribe();
sut
.SkipForwardsCommand
.Execute()
.Subscribe();
Assert.Equal(5, canExecute.Count);
Assert.False(canExecute[0]);
Assert.True(canExecute[1]);
Assert.False(canExecute[2]);
Assert.True(canExecute[3]);
Assert.False(canExecute[4]);
}
public void to_string_returns_correct_representation(string exerciseName)
{
var exercise = new ExerciseBuilder()
.WithName(exerciseName)
.Build();
var sut = new BeforeExerciseEvent(new ExecutionContext(), exercise);
Assert.Equal("Before Exercise '" + exerciseName + "'", sut.ToString());
}
public void to_string_returns_correct_representation(string exerciseName)
{
var exercise = new ExerciseBuilder()
.WithName(exerciseName)
.Build();
var sut = new AfterExerciseEvent(new ExecutionContext(), exercise);
Assert.Equal("After Exercise '" + exerciseName + "'", sut.ToString());
}
public void ToExerciseDetailModel_ShouldThrowArgumentExceptionIfTestsAreNotLoaded()
{
//Arrange
var exercise = new ExerciseBuilder().WithoutTestsLoaded().Build();
//Act + Assert
Assert.That(
() => _converter.ToExerciseDetailModel(exercise, new AssignmentResultDto(), new ExerciseTestRunInfoDto()),
Throws.ArgumentException);
}
public void execute_async_updates_the_current_exercise_in_the_context()
{
var sut = new ExerciseBuilder()
.Build();
var context = new ExecutionContext();
sut.ExecuteAsync(context);
Assert.Same(sut, context.CurrentExercise);
}
public void ToExerciseDetailModel_ShouldThrowArgumentExceptionIfTestRunInfoIsNotProvided()
{
//Arrange
var chapter = new ChapterBuilder().WithCourse().Build();
var exercise = new ExerciseBuilder().WithChapter(chapter).Build();
//Act + Assert
Assert.That(
() => _converter.ToExerciseDetailModel(exercise, new AssignmentResultDto(), null),
Throws.ArgumentNullException);
}
public void ToExerciseDetailModel_ShouldThrowArgumentExceptionIfCourseOfChapterOfExerciseIsNotLoaded()
{
//Arrange
var chapter = new ChapterBuilder().WithoutCourseLoaded().Build();
var exercise = new ExerciseBuilder().WithChapter(chapter).Build();
//Act + Assert
Assert.That(
() => _converter.ToExerciseDetailModel(exercise, new AssignmentResultDto(), new ExerciseTestRunInfoDto()),
Throws.ArgumentException);
}
public void ToAssignmentStatisticsDtoShouldCorrectlyGenerateStatistics()
{
//Arrange
var converter = new AssignmentWitResultsConverter();
var assigment = new ExerciseBuilder().Build();
var random = new Random();
var user1Id = random.NextPositive();
var user2Id = random.NextPositive();
var user3Id = random.NextPositive();
//create test results
//user 1 and user 2 both have one passing test
//user 3 passes no tests
var testsWithResultsOfMultipleUsers = new List <TestWithLastResultOfMultipleUsers>
{
new TestWithLastResultOfMultipleUsersBuilder()
.WithAssignmentId(assigment.Id)
.WithUserResult(user1Id, false)
.WithUserResult(user2Id, true)
.WithUserResult(user3Id, false)
.Build(),
new TestWithLastResultOfMultipleUsersBuilder()
.WithAssignmentId(assigment.Id)
.WithUserResult(user1Id, true)
.WithUserResult(user2Id, false)
.WithUserResult(user3Id, false)
.Build(),
};
var assignmentWithResultsOfMultipleUsers = new AssignmentWithLastResultsOfMultipleUsers()
{
Assignment = assigment,
TestsWithLastResultOfMultipleUsers = testsWithResultsOfMultipleUsers
};
//Act
var result = converter.ToAssignmentStatisticsDto(assignmentWithResultsOfMultipleUsers);
//Assert
Assert.That(result, Is.Not.Null);
Assert.That(result.AssignmentId, Is.EqualTo(assigment.Id));
Assert.That(result.TestPassageStatistics.Count, Is.EqualTo(2));
var firstStatistics = result.TestPassageStatistics.First();
Assert.That(firstStatistics.AmountOfPassedTests, Is.EqualTo(0));
Assert.That(firstStatistics.AmountOfUsers, Is.EqualTo(1)); //user 3
var secondStatistics = result.TestPassageStatistics.ElementAt(1);
Assert.That(secondStatistics.AmountOfPassedTests, Is.EqualTo(1));
Assert.That(secondStatistics.AmountOfUsers, Is.EqualTo(2)); //user 1 and user 2
}
public void skip_forwards_command_skips_to_the_next_exercise()
{
var action = new ActionMock();
action
.When(x => x.Duration)
.Return(TimeSpan.FromSeconds(10));
action
.When(x => x.Execute(It.IsAny <ExecutionContext>()))
.Return <ExecutionContext>(
ec =>
{
ec.IsPaused = true;
return(ec.WaitWhilePaused());
});
var exercise1 = new ExerciseBuilder()
.WithName("Exercise 1")
.WithBeforeExerciseAction(action)
.Build();
var exercise2 = new ExerciseBuilder()
.WithName("Exercise 2")
.WithBeforeExerciseAction(action)
.Build();
var sut = new ExerciseProgramViewModelBuilder()
.WithModel(new ExerciseProgramBuilder()
.WithExercise(exercise1)
.WithExercise(exercise2))
.Build();
var progress = sut
.WhenAnyValue(x => x.ProgressTimeSpan)
.CreateCollection();
sut
.StartCommand
.Execute()
.Subscribe();
sut
.SkipForwardsCommand
.Execute()
.Subscribe();
Assert.Equal(2, progress.Count);
Assert.Equal(TimeSpan.Zero, progress[0]);
Assert.Equal(TimeSpan.FromSeconds(10), progress[1]);
}
public void ToExerciseDetailModel_ShouldAlsoWorkWhenNoTestResultsAreProvided()
{
//Arrange
var chapter = new ChapterBuilder().WithCourse().Build();
var exercise = new ExerciseBuilder().WithChapter(chapter).Build();
//Act
var model = _converter.ToExerciseDetailModel(exercise, null, new ExerciseTestRunInfoDto());
//Assert
Assert.That(model, Is.Not.Null);
Assert.That(model.TestResults, Is.Not.Null);
Assert.That(model.TestResults, Has.Count.Zero);
}
public void execute_completes_even_if_there_are_no_actions()
{
var sut = new ExerciseBuilder()
.Build();
var executionContext = new ExecutionContext();
var completed = false;
sut
.Execute(executionContext)
.Subscribe(_ => completed = true);
Assert.True(completed);
}
public void execute_says_exercise_name_first()
{
var speechService = new SpeechServiceMock(MockBehavior.Loose);
var sut = new ExerciseBuilder()
.WithName("some name")
.WithSpeechService(speechService)
.Build();
sut.Execute(new ExecutionContext()).Subscribe();
speechService
.Verify(x => x.Speak("some name"))
.WasCalledExactlyOnce();
}
public void From_ShouldIgnoreNonExisingTests()
{
//Assert
var exercise = new ExerciseBuilder().Build();
_createExerciseTestRunModel = new CreateExerciseTestRunModelBuilder().WithRandomTestResultModels(1).Build();
//Act
var result = _converter.From(_createExerciseTestRunModel.Results, null, _userId, exercise);
//Assert
Assert.That(result, Is.Not.Null);
Assert.That(result.TestResults, Has.Count.Zero);
}
public void execute_async_says_exercise_name_first()
{
var speechService = new SpeechServiceMock(MockBehavior.Loose);
var sut = new ExerciseBuilder()
.WithName("some name")
.WithSpeechService(speechService)
.Build();
sut.ExecuteAsync(new ExecutionContext());
speechService
.Verify(x => x.SpeakAsync("some name", It.IsAny <CancellationToken>()))
.WasCalledExactlyOnce();
}
public void is_active_is_true_if_this_exercise_is_the_current_exercise()
{
var model = new ExerciseBuilder()
.Build();
var executionContext = new ExecutionContext();
var sut = new ExerciseViewModelBuilder()
.WithExecutionContext(executionContext)
.WithModel(model)
.Build();
Assert.False(sut.IsActive);
executionContext.SetCurrentExercise(model);
Assert.True(sut.IsActive);
}
public void ToExerciseDetailModel_ShouldHaveATestResultForEachTest()
{
//Arrange
var chapter = new ChapterBuilder().WithCourse().Build();
var numberOfTests = _random.Next(2, 10);
var exercise = new ExerciseBuilder().WithChapter(chapter).WithRandomTests(numberOfTests).Build();
//Act
var model = _converter.ToExerciseDetailModel(exercise, new AssignmentResultDto(), new ExerciseTestRunInfoDto());
//Assert
Assert.That(model, Is.Not.Null);
Assert.That(model.TestResults, Is.Not.Null);
Assert.That(model.TestResults, Has.Count.EqualTo(exercise.Tests.Count));
}
public void From_ShouldConvertRunWithEmptyListOfTestResultsIfModelDoesNotContainTestResults()
{
//Arrange
var exercise = new ExerciseBuilder().Build();
_createExerciseTestRunModel = new CreateExerciseTestRunModelBuilder().WithTestResultModels(null).Build();
//Act
var testRun = _converter.From(_createExerciseTestRunModel.Results, null, _userId, exercise);
//Assert
Assert.That(testRun, Is.Not.Null);
Assert.That(testRun.TestResults, Is.Not.Null);
Assert.That(testRun.TestResults.Count, Is.Zero);
}
public void progress_time_span_is_zero_if_no_progress_has_been_made_through_this_exercise()
{
var model1 = new ExerciseBuilder()
.Build();
var model2 = new ExerciseBuilder()
.Build();
var executionContext = new ExecutionContext();
var sut = new ExerciseViewModelBuilder()
.WithModel(model2)
.WithExecutionContext(executionContext)
.Build();
executionContext.SetCurrentExercise(model1);
executionContext.AddProgress(TimeSpan.FromSeconds(3));
Assert.Equal(TimeSpan.Zero, sut.ProgressTimeSpan);
}
public void ctor_throws_if_execution_context_is_null()
{
var model = new ExerciseBuilder()
.Build();
Assert.Throws<ArgumentNullException>(() => new ExerciseViewModel(new TestSchedulerService(), model, null));
}
public void current_exercise_reflects_that_in_the_execution_context()
{
var scheduler = new TestScheduler();
var action = new ActionMock();
action
.When(x => x.Duration)
.Return(TimeSpan.FromSeconds(10));
action
.When(x => x.Execute(It.IsAny<ExecutionContext>()))
.Return<ExecutionContext>(
ec =>
{
ec.IsPaused = true;
return ec.WaitWhilePaused();
});
var exercise1 = new ExerciseBuilder()
.WithName("Exercise 1")
.WithBeforeExerciseAction(action)
.Build();
var exercise2 = new ExerciseBuilder()
.WithName("Exercise 2")
.WithBeforeExerciseAction(action)
.Build();
var exercise3 = new ExerciseBuilder()
.WithName("Exercise 3")
.WithBeforeExerciseAction(action)
.Build();
var sut = new ExerciseProgramViewModelBuilder()
.WithModel(new ExerciseProgramBuilder()
.WithExercise(exercise1)
.WithExercise(exercise2)
.WithExercise(exercise3))
.WithScheduler(scheduler)
.Build();
sut.StartCommand.ExecuteAsync();
scheduler.AdvanceMinimal();
Assert.Equal("Exercise 1", sut.CurrentExercise?.Name);
sut.SkipForwardsCommand.ExecuteAsync();
scheduler.AdvanceMinimal();
Assert.Equal("Exercise 2", sut.CurrentExercise?.Name);
sut.SkipForwardsCommand.ExecuteAsync();
scheduler.AdvanceMinimal();
Assert.Equal("Exercise 3", sut.CurrentExercise?.Name);
sut.SkipBackwardsCommand.ExecuteAsync();
scheduler.AdvanceMinimal();
Assert.Equal("Exercise 2", sut.CurrentExercise?.Name);
}
public void execute_async_skips_actions_that_are_shorter_than_the_skip_ahead_even_if_the_context_is_paused()
{
var action1 = new ActionMock(MockBehavior.Loose);
var action2 = new ActionMock(MockBehavior.Loose);
var action3 = new ActionMock(MockBehavior.Loose);
var eventMatcher1 = new EventMatcherMock();
var eventMatcher2 = new EventMatcherMock();
var eventMatcher3 = new EventMatcherMock();
action1
.When(x => x.Duration)
.Return(TimeSpan.FromSeconds(10));
action2
.When(x => x.Duration)
.Return(TimeSpan.FromSeconds(3));
action3
.When(x => x.Duration)
.Return(TimeSpan.FromSeconds(1));
action1
.When(x => x.ExecuteAsync(It.IsAny<ExecutionContext>()))
.Throw();
action2
.When(x => x.ExecuteAsync(It.IsAny<ExecutionContext>()))
.Throw();
eventMatcher1
.When(x => x.Matches(It.IsAny<IEvent>()))
.Return((IEvent @event) => @event is BeforeExerciseEvent);
eventMatcher2
.When(x => x.Matches(It.IsAny<IEvent>()))
.Return((IEvent @event) => @event is BeforeExerciseEvent);
eventMatcher3
.When(x => x.Matches(It.IsAny<IEvent>()))
.Return((IEvent @event) => @event is BeforeExerciseEvent);
var sut = new ExerciseBuilder()
.AddMatcherWithAction(new MatcherWithAction(eventMatcher1, action1))
.AddMatcherWithAction(new MatcherWithAction(eventMatcher2, action2))
.AddMatcherWithAction(new MatcherWithAction(eventMatcher3, action3))
.Build();
using (var executionContext = new ExecutionContext(TimeSpan.FromSeconds(13)))
{
executionContext.IsPaused = true;
sut.ExecuteAsync(executionContext);
action3
.Verify(x => x.ExecuteAsync(executionContext))
.WasCalledExactlyOnce();
}
}
public void execute_completes_even_if_there_are_no_actions()
{
var sut = new ExerciseBuilder()
.Build();
using (var executionContext = new ExecutionContext())
{
var completed = false;
sut
.Execute(executionContext)
.Subscribe(_ => completed = true);
Assert.True(completed);
}
}
public void progress_time_span_is_not_reset_to_zero_if_another_exercise_is_started()
{
var scheduler = new TestSchedulerService();
var model1 = new ExerciseBuilder()
.WithName("model 1")
.Build();
var model2 = new ExerciseBuilder()
.WithName("model 2")
.Build();
var executionContext = new ExecutionContext();
var sut = new ExerciseViewModelBuilder()
.WithSchedulerService(scheduler)
.WithExecutionContext(executionContext)
.WithModel(model1)
.Build();
executionContext.SetCurrentExercise(model1);
executionContext.AddProgress(TimeSpan.FromSeconds(3));
scheduler.AdvanceMinimal();
Assert.Equal(TimeSpan.FromSeconds(3), sut.ProgressTimeSpan);
executionContext.SetCurrentExercise(model2);
scheduler.AdvanceMinimal();
Assert.Equal(TimeSpan.FromSeconds(3), sut.ProgressTimeSpan);
executionContext.AddProgress(TimeSpan.FromSeconds(3));
scheduler.AdvanceMinimal();
Assert.Equal(TimeSpan.FromSeconds(3), sut.ProgressTimeSpan);
}
public void execute_async_updates_the_current_repetitions_in_the_context()
{
var sut = new ExerciseBuilder()
.WithRepetitionCount(5)
.Build();
var context = new ExecutionContext();
var currentRepetitions = context
.ObservableForProperty(x => x.CurrentRepetition)
.Select(x => x.Value)
.CreateCollection();
sut.ExecuteAsync(context);
Assert.Equal(5, currentRepetitions.Count);
Assert.Equal(1, currentRepetitions[0]);
Assert.Equal(2, currentRepetitions[1]);
Assert.Equal(3, currentRepetitions[2]);
Assert.Equal(4, currentRepetitions[3]);
Assert.Equal(5, currentRepetitions[4]);
}
public void is_active_is_false_if_this_exercise_is_not_the_current_exercise()
{
var scheduler = new TestSchedulerService();
var model1 = new ExerciseBuilder()
.Build();
var model2 = new ExerciseBuilder()
.Build();
var executionContext = new ExecutionContext();
var sut = new ExerciseViewModelBuilder()
.WithSchedulerService(scheduler)
.WithExecutionContext(executionContext)
.WithModel(model1)
.Build();
scheduler.AdvanceMinimal();
Assert.False(sut.IsActive);
executionContext.SetCurrentExercise(model2);
scheduler.AdvanceMinimal();
Assert.False(sut.IsActive);
}
public void duration_returns_sum_of_action_durations()
{
var action1 = new ActionMock();
var action2 = new ActionMock();
var action3 = new ActionMock();
action1
.When(x => x.Duration)
.Return(TimeSpan.FromSeconds(10));
action2
.When(x => x.Duration)
.Return(TimeSpan.FromSeconds(3));
action3
.When(x => x.Duration)
.Return(TimeSpan.FromSeconds(1));
var eventMatcher1 = new EventMatcherMock();
var eventMatcher2 = new EventMatcherMock();
var eventMatcher3 = new EventMatcherMock();
eventMatcher1
.When(x => x.Matches(It.IsAny<IEvent>()))
.Return((IEvent @event) => @event is BeforeExerciseEvent);
eventMatcher2
.When(x => x.Matches(It.IsAny<IEvent>()))
.Return((IEvent @event) => @event is DuringRepetitionEvent);
eventMatcher3
.When(x => x.Matches(It.IsAny<IEvent>()))
.Return((IEvent @event) => @event is AfterSetEvent);
var sut = new ExerciseBuilder()
.WithSetCount(2)
.WithRepetitionCount(3)
.AddMatcherWithAction(new MatcherWithAction(eventMatcher1, action1))
.AddMatcherWithAction(new MatcherWithAction(eventMatcher2, action2))
.AddMatcherWithAction(new MatcherWithAction(eventMatcher3, action3))
.Build();
Assert.Equal(TimeSpan.FromSeconds(30), sut.Duration);
}
public void duration_returns_zero_if_there_are_no_actions()
{
var sut = new ExerciseBuilder()
.Build();
Assert.Equal(TimeSpan.Zero, sut.Duration);
}
public void execute_async_executes_all_appropriate_actions()
{
var action1 = new ActionMock(MockBehavior.Loose);
var action2 = new ActionMock(MockBehavior.Loose);
var action3 = new ActionMock(MockBehavior.Loose);
var eventMatcher1 = new EventMatcherMock();
var eventMatcher2 = new EventMatcherMock();
var eventMatcher3 = new EventMatcherMock();
eventMatcher1
.When(x => x.Matches(It.IsAny<IEvent>()))
.Return((IEvent @event) => @event is BeforeExerciseEvent);
eventMatcher2
.When(x => x.Matches(It.IsAny<IEvent>()))
.Return((IEvent @event) => @event is DuringRepetitionEvent);
eventMatcher3
.When(x => x.Matches(It.IsAny<IEvent>()))
.Return((IEvent @event) => @event is AfterSetEvent);
var sut = new ExerciseBuilder()
.WithSetCount(2)
.WithRepetitionCount(3)
.AddMatcherWithAction(new MatcherWithAction(eventMatcher1, action1))
.AddMatcherWithAction(new MatcherWithAction(eventMatcher2, action2))
.AddMatcherWithAction(new MatcherWithAction(eventMatcher3, action3))
.Build();
using (var executionContext = new ExecutionContext())
{
sut.ExecuteAsync(executionContext);
action1
.Verify(x => x.ExecuteAsync(executionContext))
.WasCalledExactlyOnce();
action2
.Verify(x => x.ExecuteAsync(executionContext))
.WasCalledExactly(times: 6);
action3
.Verify(x => x.ExecuteAsync(executionContext))
.WasCalledExactly(times: 2);
}
}
public void execute_async_updates_the_current_exercise_in_the_context()
{
var sut = new ExerciseBuilder()
.Build();
var context = new ExecutionContext();
sut.ExecuteAsync(context);
Assert.Same(sut, context.CurrentExercise);
}
public void execute_async_says_exercise_name_first()
{
var speechService = new SpeechServiceMock(MockBehavior.Loose);
var sut = new ExerciseBuilder()
.WithName("some name")
.WithSpeechService(speechService)
.Build();
sut.ExecuteAsync(new ExecutionContext());
speechService
.Verify(x => x.SpeakAsync("some name", It.IsAny<CancellationToken>()))
.WasCalledExactlyOnce();
}
public void progress_time_span_is_reset_to_zero_if_the_execution_context_changes_to_null()
{
var scheduler = new TestSchedulerService();
var model = new ExerciseBuilder()
.Build();
var executionContext = new ExecutionContext();
var executionContextSubject = new Subject<ExecutionContext>();
var sut = new ExerciseViewModelBuilder()
.WithSchedulerService(scheduler)
.WithExecutionContext(executionContextSubject)
.WithModel(model)
.Build();
executionContextSubject.OnNext(executionContext);
executionContext.SetCurrentExercise(model);
executionContext.AddProgress(TimeSpan.FromSeconds(3));
scheduler.AdvanceMinimal();
Assert.Equal(TimeSpan.FromSeconds(3), sut.ProgressTimeSpan);
executionContextSubject.OnNext(null);
scheduler.AdvanceMinimal();
Assert.Equal(TimeSpan.Zero, sut.ProgressTimeSpan);
}
public void execute_async_updates_the_current_set_in_the_context()
{
var sut = new ExerciseBuilder()
.WithSetCount(3)
.Build();
var context = new ExecutionContext();
var currentSets = context
.ObservableForProperty(x => x.CurrentSet)
.Select(x => x.Value)
.CreateCollection();
sut.ExecuteAsync(context);
Assert.Equal(3, currentSets.Count);
Assert.Equal(1, currentSets[0]);
Assert.Equal(2, currentSets[1]);
Assert.Equal(3, currentSets[2]);
}
public void progress_is_calculated_based_on_duration_and_progress_time_span(int durationInMs, int progressInMs, double expectedProgress)
{
var scheduler = new TestSchedulerService();
var action = new ActionMock(MockBehavior.Loose);
action
.When(x => x.Duration)
.Return(TimeSpan.FromMilliseconds(durationInMs));
var model = new ExerciseBuilder()
.WithBeforeExerciseAction(action)
.Build();
var executionContext = new ExecutionContext();
var sut = new ExerciseViewModelBuilder()
.WithSchedulerService(scheduler)
.WithExecutionContext(executionContext)
.WithModel(model)
.Build();
executionContext.SetCurrentExercise(model);
executionContext.AddProgress(TimeSpan.FromMilliseconds(progressInMs));
scheduler.AdvanceMinimal();
Assert.Equal(expectedProgress, sut.Progress);
}
public void skip_backwards_command_restarts_the_execution_context_from_the_start_of_the_previous_exercise_if_the_current_exercise_if_only_recently_started()
{
var scheduler = new TestScheduler();
var action = new ActionMock();
action
.When(x => x.Duration)
.Return(TimeSpan.FromSeconds(10));
action
.When(x => x.Execute(It.IsAny<ExecutionContext>()))
.Return<ExecutionContext>(
ec =>
{
ec.AddProgress(TimeSpan.FromSeconds(0.5));
ec.IsPaused = true;
return ec.WaitWhilePaused();
});
var exercise1 = new ExerciseBuilder()
.WithName("Exercise 1")
.WithBeforeExerciseAction(action)
.Build();
var exercise2 = new ExerciseBuilder()
.WithName("Exercise 2")
.WithBeforeExerciseAction(action)
.Build();
var sut = new ExerciseProgramViewModelBuilder()
.WithModel(new ExerciseProgramBuilder()
.WithExercise(exercise1)
.WithExercise(exercise2))
.WithScheduler(scheduler)
.Build();
var progress = sut
.WhenAnyValue(x => x.ProgressTimeSpan)
.CreateCollection();
// start from the second exercise
sut.StartCommand.ExecuteAsync(exercise1.Duration);
scheduler.AdvanceMinimal();
sut.SkipBackwardsCommand.ExecuteAsync();
scheduler.AdvanceMinimal();
Assert.Equal(5, progress.Count);
Assert.Equal(TimeSpan.Zero, progress[0]);
Assert.Equal(TimeSpan.FromSeconds(10), progress[1]);
Assert.Equal(TimeSpan.FromSeconds(10.5), progress[2]);
Assert.Equal(TimeSpan.Zero, progress[3]);
Assert.Equal(TimeSpan.FromSeconds(10), progress[4]);
}
public void ctor_throws_if_scheduler_service_is_null()
{
var model = new ExerciseBuilder()
.Build();
Assert.Throws<ArgumentNullException>(() => new ExerciseViewModel(null, model, Observable.Never<ExecutionContext>()));
}
public void skip_forwards_command_is_disabled_if_on_last_exercise()
{
var scheduler = new TestScheduler();
var action = new ActionMock();
action
.When(x => x.Duration)
.Return(TimeSpan.FromSeconds(10));
action
.When(x => x.Execute(It.IsAny<ExecutionContext>()))
.Return<ExecutionContext>(
ec =>
{
ec.IsPaused = true;
return ec.WaitWhilePaused();
});
var exercise1 = new ExerciseBuilder()
.WithName("Exercise 1")
.WithBeforeExerciseAction(action)
.Build();
var exercise2 = new ExerciseBuilder()
.WithName("Exercise 2")
.WithBeforeExerciseAction(action)
.Build();
var sut = new ExerciseProgramViewModelBuilder()
.WithModel(new ExerciseProgramBuilder()
.WithExercise(exercise1)
.WithExercise(exercise2))
.WithScheduler(scheduler)
.Build();
var canExecute = sut
.SkipForwardsCommand
.CanExecute
.CreateCollection();
sut.StartCommand.ExecuteAsync();
scheduler.AdvanceMinimal();
sut.SkipForwardsCommand.ExecuteAsync();
scheduler.AdvanceMinimal();
Assert.Equal(5, canExecute.Count);
Assert.False(canExecute[0]);
Assert.True(canExecute[1]);
Assert.False(canExecute[2]);
Assert.True(canExecute[3]);
Assert.False(canExecute[4]);
}
public void execute_says_exercise_name_first()
{
var speechService = new SpeechServiceMock(MockBehavior.Loose);
var sut = new ExerciseBuilder()
.WithName("some name")
.WithSpeechService(speechService)
.Build();
sut.Execute(new ExecutionContext()).Subscribe();
speechService
.Verify(x => x.Speak("some name"))
.WasCalledExactlyOnce();
}
public void skip_forwards_command_skips_to_the_next_exercise()
{
var scheduler = new TestScheduler();
var action = new ActionMock();
action
.When(x => x.Duration)
.Return(TimeSpan.FromSeconds(10));
action
.When(x => x.Execute(It.IsAny<ExecutionContext>()))
.Return<ExecutionContext>(
ec =>
{
ec.IsPaused = true;
return ec.WaitWhilePaused();
});
var exercise1 = new ExerciseBuilder()
.WithName("Exercise 1")
.WithBeforeExerciseAction(action)
.Build();
var exercise2 = new ExerciseBuilder()
.WithName("Exercise 2")
.WithBeforeExerciseAction(action)
.Build();
var sut = new ExerciseProgramViewModelBuilder()
.WithModel(new ExerciseProgramBuilder()
.WithExercise(exercise1)
.WithExercise(exercise2))
.WithScheduler(scheduler)
.Build();
var progress = sut
.WhenAnyValue(x => x.ProgressTimeSpan)
.CreateCollection();
sut.StartCommand.ExecuteAsync();
scheduler.AdvanceMinimal();
sut.SkipForwardsCommand.ExecuteAsync();
scheduler.AdvanceMinimal();
Assert.Equal(2, progress.Count);
Assert.Equal(TimeSpan.Zero, progress[0]);
Assert.Equal(TimeSpan.FromSeconds(10), progress[1]);
}
public void execute_async_throws_if_execution_context_is_null()
{
var sut = new ExerciseBuilder()
.Build();
Assert.Throws<ArgumentNullException>(() => sut.ExecuteAsync(null));
}
public void execute_async_does_not_skip_zero_duration_actions()
{
var action = new ActionMock(MockBehavior.Loose);
var eventMatcher = new EventMatcherMock();
eventMatcher
.When(x => x.Matches(It.IsAny<IEvent>()))
.Return((IEvent @event) => @event is BeforeExerciseEvent);
var sut = new ExerciseBuilder()
.AddMatcherWithAction(new MatcherWithAction(eventMatcher, action))
.Build();
using (var executionContext = new ExecutionContext())
{
sut.ExecuteAsync(executionContext);
action
.Verify(x => x.ExecuteAsync(executionContext))
.WasCalledExactlyOnce();
}
}
