public void progress_time_span_is_zero_if_there_is_no_execution_context()
        {
            var sut = new ExerciseViewModelBuilder()
                .Build();

            Assert.Equal(TimeSpan.Zero, sut.ProgressTimeSpan);
        }
        public void name_returns_name_in_model(string name)
        {
            var sut = new ExerciseViewModelBuilder()
                .WithModel(new ExerciseBuilder()
                    .WithName(name))
                .Build();

            Assert.Equal(name, sut.Name);
        }
        public void is_active_is_false_if_there_is_no_execution_context()
        {
            var scheduler = new TestSchedulerService();
            var sut       = new ExerciseViewModelBuilder()
                            .WithSchedulerService(scheduler)
                            .Build();

            scheduler.AdvanceMinimal();
            Assert.False(sut.IsActive);
        }
Exemplo n.º 4
0
        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 duration_returns_duration_in_model(int durationInMs)
        {
            var action = new ActionMock(MockBehavior.Loose);

            action
            .When(x => x.Duration)
            .Return(TimeSpan.FromMilliseconds(durationInMs));

            var sut = new ExerciseViewModelBuilder()
                      .WithModel(new ExerciseBuilder()
                                 .WithBeforeExerciseAction(action))
                      .Build();

            Assert.Equal(TimeSpan.FromMilliseconds(durationInMs), sut.Duration);
        }
        public void duration_returns_duration_in_model(int durationInMs)
        {
            var action = new ActionMock(MockBehavior.Loose);

            action
                .When(x => x.Duration)
                .Return(TimeSpan.FromMilliseconds(durationInMs));

            var sut = new ExerciseViewModelBuilder()
                .WithModel(new ExerciseBuilder()
                    .WithBeforeExerciseAction(action))
                .Build();

            Assert.Equal(TimeSpan.FromMilliseconds(durationInMs), sut.Duration);
        }
        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 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 is_active_is_true_if_this_exercise_is_the_current_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();

            scheduler.AdvanceMinimal();
            Assert.False(sut.IsActive);

            executionContext.SetCurrentExercise(model);
            scheduler.AdvanceMinimal();
            Assert.True(sut.IsActive);
        }
Exemplo n.º 10
0
        public void progress_time_span_reflects_any_progression_through_the_exercise()
        {
            var model = new ExerciseBuilder()
                        .Build();
            var executionContext = new ExecutionContext();
            var sut = new ExerciseViewModelBuilder()
                      .WithExecutionContext(executionContext)
                      .WithModel(model)
                      .Build();

            executionContext.SetCurrentExercise(model);
            Assert.Equal(TimeSpan.Zero, sut.ProgressTimeSpan);

            executionContext.AddProgress(TimeSpan.FromSeconds(3));
            Assert.Equal(TimeSpan.FromSeconds(3), sut.ProgressTimeSpan);

            executionContext.AddProgress(TimeSpan.FromSeconds(2));
            Assert.Equal(TimeSpan.FromSeconds(5), sut.ProgressTimeSpan);
        }
Exemplo n.º 11
0
        public void progress_time_span_is_reset_to_zero_if_the_execution_context_changes_to_null()
        {
            var model = new ExerciseBuilder()
                        .Build();
            var executionContext        = new ExecutionContext();
            var executionContextSubject = new Subject <ExecutionContext>();
            var sut = new ExerciseViewModelBuilder()
                      .WithExecutionContext(executionContextSubject)
                      .WithModel(model)
                      .Build();

            executionContextSubject.OnNext(executionContext);
            executionContext.SetCurrentExercise(model);

            executionContext.AddProgress(TimeSpan.FromSeconds(3));
            Assert.Equal(TimeSpan.FromSeconds(3), sut.ProgressTimeSpan);

            executionContextSubject.OnNext(null);
            Assert.Equal(TimeSpan.Zero, sut.ProgressTimeSpan);
        }
Exemplo n.º 12
0
        public void progress_is_calculated_based_on_duration_and_progress_time_span(int durationInMs, int progressInMs, double expectedProgress)
        {
            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()
                      .WithExecutionContext(executionContext)
                      .WithModel(model)
                      .Build();

            executionContext.SetCurrentExercise(model);
            executionContext.AddProgress(TimeSpan.FromMilliseconds(progressInMs));

            Assert.Equal(expectedProgress, sut.Progress);
        }
Exemplo n.º 13
0
        public void progress_time_span_is_not_reset_to_zero_if_another_exercise_is_started()
        {
            var model1 = new ExerciseBuilder()
                         .WithName("model 1")
                         .Build();
            var model2 = new ExerciseBuilder()
                         .WithName("model 2")
                         .Build();
            var executionContext = new ExecutionContext();
            var sut = new ExerciseViewModelBuilder()
                      .WithExecutionContext(executionContext)
                      .WithModel(model1)
                      .Build();

            executionContext.SetCurrentExercise(model1);
            executionContext.AddProgress(TimeSpan.FromSeconds(3));
            Assert.Equal(TimeSpan.FromSeconds(3), sut.ProgressTimeSpan);

            executionContext.SetCurrentExercise(model2);
            Assert.Equal(TimeSpan.FromSeconds(3), sut.ProgressTimeSpan);

            executionContext.AddProgress(TimeSpan.FromSeconds(3));
            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);
        }
        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_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_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 is_active_is_false_if_there_is_no_execution_context()
        {
            var scheduler = new TestSchedulerService();
            var sut = new ExerciseViewModelBuilder()
                .WithSchedulerService(scheduler)
                .Build();

            scheduler.AdvanceMinimal();
            Assert.False(sut.IsActive);
        }
        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);
        }