public void execute_executes_each_exercise()
        {
            var action1 = new ActionMock(MockBehavior.Loose);
            var action2 = new ActionMock(MockBehavior.Loose);

            var sut = new ExerciseProgramBuilder()
                      .WithExercise(new ExerciseBuilder()
                                    .WithBeforeExerciseAction(action1))
                      .WithExercise(new ExerciseBuilder()
                                    .WithBeforeExerciseAction(action2))
                      .Build();
            var executionContext = new ExecutionContext();

            sut
            .Execute(executionContext)
            .Subscribe();

            action1
            .Verify(x => x.Execute(executionContext))
            .WasCalledExactlyOnce();

            action2
            .Verify(x => x.Execute(executionContext))
            .WasCalledExactlyOnce();
        }
        public void execute_completes_even_if_there_are_no_exercises()
        {
            var sut = new ExerciseProgramBuilder()
                      .Build();
            var executionContext = new ExecutionContext();

            var completed = false;

            sut
            .Execute(executionContext)
            .Subscribe(_ => completed = true);

            Assert.True(completed);
        }
        public void execute_skips_exercises_that_are_shorter_than_the_skip_ahead()
        {
            var action1 = new ActionMock(MockBehavior.Loose);
            var action2 = new ActionMock(MockBehavior.Loose);
            var action3 = new ActionMock(MockBehavior.Loose);

            action1
            .When(x => x.Duration)
            .Return(TimeSpan.FromSeconds(13));

            action2
            .When(x => x.Duration)
            .Return(TimeSpan.FromSeconds(10));

            action3
            .When(x => x.Duration)
            .Return(TimeSpan.FromSeconds(5));

            action1
            .When(x => x.Execute(It.IsAny <ExecutionContext>()))
            .Throw();

            action2
            .When(x => x.Execute(It.IsAny <ExecutionContext>()))
            .Throw();

            var sut = new ExerciseProgramBuilder()
                      .WithExercise(new ExerciseBuilder()
                                    .WithBeforeExerciseAction(action1))
                      .WithExercise(new ExerciseBuilder()
                                    .WithBeforeExerciseAction(action2))
                      .WithExercise(new ExerciseBuilder()
                                    .WithBeforeExerciseAction(action3))
                      .Build();
            var executionContext = new ExecutionContext(TimeSpan.FromSeconds(23));

            sut
            .Execute(executionContext)
            .Subscribe();

            action3
            .Verify(x => x.Execute(executionContext))
            .WasCalledExactlyOnce();
        }
        public void execute_executes_each_exercise()
        {
            var action1 = new ActionMock(MockBehavior.Loose);
            var action2 = new ActionMock(MockBehavior.Loose);

            var sut = new ExerciseProgramBuilder()
                .WithExercise(new ExerciseBuilder()
                    .WithBeforeExerciseAction(action1))
                .WithExercise(new ExerciseBuilder()
                    .WithBeforeExerciseAction(action2))
                .Build();

            using (var executionContext = new ExecutionContext())
            {
                sut.Execute(executionContext).Subscribe();

                action1
                    .Verify(x => x.Execute(executionContext))
                    .WasCalledExactlyOnce();

                action2
                    .Verify(x => x.Execute(executionContext))
                    .WasCalledExactlyOnce();
            }
        }
        public void execute_completes_even_if_there_are_no_exercises()
        {
            var sut = new ExerciseProgramBuilder()
                .Build();

            using (var executionContext = new ExecutionContext())
            {
                var completed = false;
                sut
                    .Execute(executionContext)
                    .Subscribe(_ => completed = true);

                Assert.True(completed);
            }
        }
        public void execute_skips_exercises_that_are_shorter_than_the_skip_ahead()
        {
            var action1 = new ActionMock(MockBehavior.Loose);
            var action2 = new ActionMock(MockBehavior.Loose);
            var action3 = new ActionMock(MockBehavior.Loose);

            action1
                .When(x => x.Duration)
                .Return(TimeSpan.FromSeconds(13));

            action2
                .When(x => x.Duration)
                .Return(TimeSpan.FromSeconds(10));

            action3
                .When(x => x.Duration)
                .Return(TimeSpan.FromSeconds(5));

            action1
                .When(x => x.Execute(It.IsAny<ExecutionContext>()))
                .Throw();

            action2
                .When(x => x.Execute(It.IsAny<ExecutionContext>()))
                .Throw();

            var sut = new ExerciseProgramBuilder()
                .WithExercise(new ExerciseBuilder()
                    .WithBeforeExerciseAction(action1))
                .WithExercise(new ExerciseBuilder()
                    .WithBeforeExerciseAction(action2))
                .WithExercise(new ExerciseBuilder()
                    .WithBeforeExerciseAction(action3))
                .Build();

            using (var executionContext = new ExecutionContext(TimeSpan.FromSeconds(23)))
            {
                sut.Execute(executionContext).Subscribe();

                action3
                    .Verify(x => x.Execute(executionContext))
                    .WasCalledExactlyOnce();
            }
        }