public void add_progress_adds_to_the_progress() { var sut = new ExecutionContext(); Assert.Equal(TimeSpan.Zero, sut.Progress); sut.AddProgress(TimeSpan.FromMilliseconds(100)); Assert.Equal(TimeSpan.FromMilliseconds(100), sut.Progress); sut.AddProgress(TimeSpan.FromMilliseconds(150)); Assert.Equal(TimeSpan.FromMilliseconds(250), sut.Progress); sut.AddProgress(TimeSpan.FromMilliseconds(13)); Assert.Equal(TimeSpan.FromMilliseconds(263), sut.Progress); }
public IObservable <Unit> Execute(ExecutionContext context) { Ensure.ArgumentNotNull(context, nameof(context)); return(Observable .Concat( this .GetEventsWithActions(context) .SelectMany(eventWithActions => eventWithActions.Actions.Select(action => new { Action = action, Event = eventWithActions.Event })) .Select( actionAndEvent => { var action = actionAndEvent.Action; var @event = actionAndEvent.Event; if (context.SkipAhead > TimeSpan.Zero && context.SkipAhead >= action.Duration) { this.logger.Debug("Skipping action {0} for event {1} because its duration ({2}) is less than the remaining skip ahead ({3}).", action, @event, action.Duration, context.SkipAhead); context.AddProgress(action.Duration); return Observable.Return(Unit.Default); } this.logger.Debug("Executing action {0} for event {1}.", action, @event); return action.Execute(context); }))); }
public IObservable<Unit> Execute(ExecutionContext context) { Ensure.ArgumentNotNull(context, nameof(context)); return Observable .Concat( this .GetEventsWithActions(context) .SelectMany(eventWithActions => eventWithActions.Actions.Select(action => new { Action = action, Event = eventWithActions.Event })) .Select( actionAndEvent => { var action = actionAndEvent.Action; var @event = actionAndEvent.Event; if (context.SkipAhead > TimeSpan.Zero && context.SkipAhead >= action.Duration) { this.logger.Debug("Skipping action {0} for event {1} because its duration ({2}) is less than the remaining skip ahead ({3}).", action, @event, action.Duration, context.SkipAhead); context.AddProgress(action.Duration); return Observable.Return(Unit.Default); } this.logger.Debug("Executing action {0} for event {1}.", action, @event); return action.Execute(context); })); }
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 IObservable <Unit> Execute(ExecutionContext context) { Ensure.ArgumentNotNull(context, nameof(context)); return(Observable .Concat( this .exercises .Select( exercise => { if (context.SkipAhead > TimeSpan.Zero && context.SkipAhead >= exercise.Duration) { this.logger.Debug("Skipping exercise '{0}' because its duration ({1}) is less than the remaining skip ahead ({2}).", exercise.Name, exercise.Duration, context.SkipAhead); context.AddProgress(exercise.Duration); return Observables.Unit; } this.logger.Debug("Executing exercise '{0}'.", exercise.Name); return exercise.Execute(context); })) .DefaultIfEmpty()); }
public IObservable<Unit> Execute(ExecutionContext context) { Ensure.ArgumentNotNull(context, nameof(context)); return Observable .Concat( this .exercises .Select( exercise => { if (context.SkipAhead > TimeSpan.Zero && context.SkipAhead >= exercise.Duration) { this.logger.Debug("Skipping exercise '{0}' because its duration ({1}) is less than the remaining skip ahead ({2}).", exercise.Name, exercise.Duration, context.SkipAhead); context.AddProgress(exercise.Duration); return Observable.Return(Unit.Default); } this.logger.Debug("Executing exercise '{0}'.", exercise.Name); return exercise.Execute(context); })) .DefaultIfEmpty(); }
public IObservable <Unit> ExecuteAsync(ExecutionContext context) { context.AssertNotNull(nameof(context)); return(Observable .Concat( this .exercises .Select( exercise => { if (context.SkipAhead > TimeSpan.Zero && context.SkipAhead >= exercise.Duration) { this.logger.Debug("Skipping exercise '{0}' because its duration ({1}) is less than the remaining skip ahead ({2}).", exercise.Name, exercise.Duration, context.SkipAhead); context.AddProgress(exercise.Duration); return Observable.Return(Unit.Default); } this.logger.Debug("Executing exercise '{0}'.", exercise.Name); return exercise.ExecuteAsync(context); })) .RunAsync(context.CancellationToken)); }
public void setting_current_exercise_resets_the_current_exercise_progress_to_zero() { var sut = new ExecutionContext(); sut.SetCurrentExercise(new ExerciseBuilder() .WithSetCount(3) .WithRepetitionCount(10) .Build()); sut.AddProgress(TimeSpan.FromMilliseconds(100)); Assert.Equal(TimeSpan.FromMilliseconds(100), sut.CurrentExerciseProgress); sut.SetCurrentExercise(new ExerciseBuilder() .WithSetCount(3) .WithRepetitionCount(10) .Build()); Assert.Equal(TimeSpan.Zero, sut.CurrentExerciseProgress); sut.AddProgress(TimeSpan.FromMilliseconds(150)); Assert.Equal(TimeSpan.FromMilliseconds(150), sut.CurrentExerciseProgress); }
public void add_progress_does_not_reduce_skip_ahead_if_it_is_already_zero() { var sut = new ExecutionContext(TimeSpan.FromSeconds(1)); Assert.Equal(TimeSpan.FromSeconds(1), sut.SkipAhead); sut.AddProgress(TimeSpan.FromMilliseconds(900)); Assert.Equal(TimeSpan.FromSeconds(0.1), sut.SkipAhead); sut.AddProgress(TimeSpan.FromMilliseconds(150)); Assert.Equal(TimeSpan.Zero, sut.SkipAhead); sut.AddProgress(TimeSpan.FromMilliseconds(1000)); Assert.Equal(TimeSpan.Zero, sut.SkipAhead); }
public void add_progress_reduces_outstanding_skip_ahead() { var sut = new ExecutionContext(TimeSpan.FromSeconds(3)); Assert.Equal(TimeSpan.FromSeconds(3), sut.SkipAhead); sut.AddProgress(TimeSpan.FromMilliseconds(100)); Assert.Equal(TimeSpan.FromSeconds(2.9), sut.SkipAhead); sut.AddProgress(TimeSpan.FromMilliseconds(150)); Assert.Equal(TimeSpan.FromSeconds(2.75), sut.SkipAhead); sut.AddProgress(TimeSpan.FromMilliseconds(1000)); Assert.Equal(TimeSpan.FromSeconds(1.75), sut.SkipAhead); }
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 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 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 progress_time_span_reflects_any_progression_through_the_exercise() { var scheduler = new TestSchedulerService(); 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); }