public void skip_backwards_command_is_disabled_if_on_first_exercise() { var action = new ActionMock(MockBehavior.Loose); action .When(x => x.Execute(It.IsAny <ExecutionContext>())) .Return <ExecutionContext>( ec => { ec.IsPaused = true; return(ec.WaitWhilePaused()); }); var sut = new ExerciseProgramViewModelBuilder() .WithModel(new ExerciseProgramBuilder() .WithExercise(new ExerciseBuilder() .WithBeforeExerciseAction(action))) .Build(); sut .StartCommand .Execute() .Subscribe(); Assert.False(sut.SkipBackwardsCommand.CanExecute.FirstAsync().Wait()); }
public void execute_logs_any_error_raised_by_the_inner_action() { var waitHandle = new ManualResetEventSlim(); var logger = new LoggerMock(MockBehavior.Loose); var loggerService = new LoggerServiceMock(MockBehavior.Loose); var action = new ActionMock(MockBehavior.Loose); logger .When(x => x.Log(LogLevel.Error, It.IsAny <string>())) .Do(waitHandle.Set); loggerService .When(x => x.GetLogger(It.IsAny <Type>())) .Return(logger); action .When(x => x.Execute(It.IsAny <ExecutionContext>())) .Return(Observable.Throw <Unit>(new InvalidOperationException("Something bad happened"))); var sut = new DoNotAwaitActionBuilder() .WithLoggerService(loggerService) .WithInnerAction(action) .Build(); sut.Execute(new ExecutionContext()); Assert.True(waitHandle.Wait(TimeSpan.FromSeconds(3))); }
public void execute_executes_each_child_action_in_order() { var childCount = 10; var childExecutionOrder = new int[childCount]; var executionOrder = 0; var childActions = Enumerable .Range(0, childCount) .Select( (i, _) => { var childAction = new ActionMock(MockBehavior.Loose); childAction .When(x => x.Execute(It.IsAny <ExecutionContext>())) .Do(() => childExecutionOrder[i] = Interlocked.Increment(ref executionOrder)) .Return(Observable.Return(Unit.Default)); return(childAction); }) .ToList(); var sut = new SequenceActionBuilder() .WithChildren(childActions) .Build(); using (var context = new ExecutionContext()) { sut.Execute(context).Subscribe(); for (var i = 0; i < childExecutionOrder.Length; ++i) { Assert.Equal(i + 1, childExecutionOrder[i]); } } }
public void execute_executes_each_child_action() { var action1 = new ActionMock(MockBehavior.Loose); var action2 = new ActionMock(MockBehavior.Loose); var action3 = new ActionMock(MockBehavior.Loose); var sut = new SequenceActionBuilder() .WithChild(action1) .WithChild(action2) .WithChild(action3) .Build(); using (var context = new ExecutionContext()) { sut.Execute(context).Subscribe(); action1 .Verify(x => x.Execute(context)) .WasCalledExactlyOnce(); action2 .Verify(x => x.Execute(context)) .WasCalledExactlyOnce(); action3 .Verify(x => x.Execute(context)) .WasCalledExactlyOnce(); } }
public void skip_backwards_command_is_enabled_if_sufficient_progress_has_been_made_through_first_exercise() { var action = new ActionMock(MockBehavior.Loose); action .When(x => x.Execute(It.IsAny <ExecutionContext>())) .Return <ExecutionContext>( ec => { ec.AddProgress(TimeSpan.FromSeconds(1)); ec.IsPaused = true; return(ec.WaitWhilePaused()); }); var sut = new ExerciseProgramViewModelBuilder() .WithModel(new ExerciseProgramBuilder() .WithExercise(new ExerciseBuilder() .WithBeforeExerciseAction(action))) .Build(); sut .StartCommand .Execute() .Subscribe(); Assert.True(sut.SkipBackwardsCommand.CanExecute.FirstAsync().Wait()); }
public void execute_context_can_be_cancelled_by_longest_child_action() { var action1 = new ActionMock(MockBehavior.Loose); var action2 = new ActionMock(MockBehavior.Loose); action1 .When(x => x.Duration) .Return(TimeSpan.FromSeconds(13)); action2 .When(x => x.Duration) .Return(TimeSpan.FromSeconds(8)); action1 .When(x => x.Execute(It.IsAny <ExecutionContext>())) .Do <ExecutionContext>(ec => ec.Cancel()) .Return(Observable.Return(Unit.Default)); var sut = new ParallelActionBuilder() .WithChild(action1) .WithChild(action2) .Build(); using (var context = new ExecutionContext()) { sut.Execute(context); // can't assume certain actions did not execute because actions run in parallel, but we can check the context is cancelled Assert.True(context.IsCancelled); } }
public void execute_async_stops_executing_if_the_context_is_cancelled() { var action1 = new ActionMock(MockBehavior.Loose); var action2 = new ActionMock(MockBehavior.Loose); var action3 = new ActionMock(MockBehavior.Loose); var sut = new SequenceActionBuilder() .AddChild(action1) .AddChild(action2) .AddChild(action3) .Build(); using (var context = new ExecutionContext()) { action2 .When(x => x.ExecuteAsync(It.IsAny <ExecutionContext>())) .Do(() => context.Cancel()) .Return(Observable.Return(Unit.Default)); Assert.ThrowsAsync <OperationCanceledException>(async() => await sut.ExecuteAsync(context)); action1 .Verify(x => x.ExecuteAsync(context)) .WasCalledExactlyOnce(); action2 .Verify(x => x.ExecuteAsync(context)) .WasCalledExactlyOnce(); action3 .Verify(x => x.ExecuteAsync(context)) .WasNotCalled(); } }
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 execute_context_can_be_paused_by_child_action_that_is_not_the_longest() { var action1 = new ActionMock(MockBehavior.Loose); var action2 = new ActionMock(MockBehavior.Loose); action1 .When(x => x.Duration) .Return(TimeSpan.FromSeconds(8)); action2 .When(x => x.Duration) .Return(TimeSpan.FromSeconds(13)); action1 .When(x => x.Execute(It.IsAny <ExecutionContext>())) .Do <ExecutionContext>(ec => ec.IsPaused = true) .Return(Observables.Unit); var sut = new ParallelActionBuilder() .WithChild(action1) .WithChild(action2) .Build(); var context = new ExecutionContext(); sut.Execute(context); // can't assume certain actions did not execute because actions run in parallel, but we can check the context is paused Assert.True(context.IsPaused); }
public void Solve_should_solve_solvable_problem() { var action1 = new ActionMock("action 1"); var action2 = new ActionMock("action 2"); var initialState = new StateMock("initial state"); var state1 = new StateMock("state 1"); var state2 = new StateMock("state 2"); var problem = A.Fake <ISearchProblem <StateMock, ActionMock> >(); A.CallTo(() => problem.InitialState).Returns(initialState); A.CallTo(() => problem.GetActions(initialState)).Returns(new [] { action1 }); A.CallTo(() => problem.DoAction(initialState, action1)).Returns(state1); A.CallTo(() => problem.GetActions(state1)).Returns(new [] { action2 }); A.CallTo(() => problem.DoAction(state1, action2)).Returns(state2); A.CallTo(() => problem.IsGoal(state2)).Returns(true); var bfs = new BreadthFirstSearch <StateMock, ActionMock>(problem); bfs.Solve(); Assert.IsTrue(bfs.IsFinished); Assert.IsTrue(bfs.IsSolved); var solution = bfs.GetSolutionTo(state2).ToList(); Assert.AreEqual(new[] { action1, action2 }, solution); }
public void duration_is_calculated_as_the_sum_of_child_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(1)); action3 .When(x => x.Duration) .Return(TimeSpan.FromSeconds(7)); var sut = new SequenceActionBuilder() .WithChild(action1) .WithChild(action2) .WithChild(action3) .Build(); Assert.Equal(TimeSpan.FromSeconds(18), sut.Duration); }
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_async_executes_each_exercise() { var action1 = new ActionMock(MockBehavior.Loose); var action2 = new ActionMock(MockBehavior.Loose); var sut = new ExerciseProgramBuilder() .AddExercise(new ExerciseBuilder() .WithBeforeExerciseAction(action1)) .AddExercise(new ExerciseBuilder() .WithBeforeExerciseAction(action2)) .Build(); using (var executionContext = new ExecutionContext()) { sut.ExecuteAsync(executionContext); action1 .Verify(x => x.ExecuteAsync(executionContext)) .WasCalledExactlyOnce(); action2 .Verify(x => x.ExecuteAsync(executionContext)) .WasCalledExactlyOnce(); } }
public void is_pause_visible_cycles_correctly_if_start_command_is_executed() { var scheduler = new TestSchedulerService(); var action = new ActionMock(MockBehavior.Loose); action .When(x => x.Duration) .Return(TimeSpan.FromMinutes(1)); action .When(x => x.ExecuteAsync(It.IsAny <ExecutionContext>())) .Return <ExecutionContext>( ec => Observable .Return(Unit.Default) .Do(_ => { }) .Delay(TimeSpan.FromMinutes(1), scheduler.DefaultScheduler) .Do(_ => ec.AddProgress(TimeSpan.FromMinutes(1)))); var sut = new ExerciseProgramViewModelBuilder() .WithModel( new ExerciseProgramBuilder() .AddExercise( new ExerciseBuilder() .WithBeforeExerciseAction(action))) .WithSchedulerService(scheduler) .Build(); Assert.False(sut.IsPauseVisible); sut.StartCommand.Execute(null); scheduler.AdvanceMinimal(); Assert.True(sut.IsPauseVisible); scheduler.AdvanceBy(TimeSpan.FromMinutes(10)); Assert.False(sut.IsPauseVisible); }
public void skip_backwards_command_is_disabled_if_on_first_exercise() { var scheduler = new TestSchedulerService(); var action = new ActionMock(MockBehavior.Loose); action .When(x => x.ExecuteAsync(It.IsAny <ExecutionContext>())) .Return <ExecutionContext>( ec => { ec.IsPaused = true; return(ec.WaitWhilePausedAsync()); }); var sut = new ExerciseProgramViewModelBuilder() .WithModel(new ExerciseProgramBuilder() .AddExercise(new ExerciseBuilder() .WithBeforeExerciseAction(action))) .WithSchedulerService(scheduler) .Build(); sut.StartCommand.Execute(null); scheduler.AdvanceMinimal(); Assert.False(sut.SkipBackwardsCommand.CanExecute(null)); }
public void duration_is_the_maximum_duration_from_all_children() { var action1 = new ActionMock(); var action2 = new ActionMock(); var action3 = new ActionMock(); var action4 = new ActionMock(); action1 .When(x => x.Duration) .Return(TimeSpan.FromMilliseconds(150)); action2 .When(x => x.Duration) .Return(TimeSpan.FromSeconds(3)); action3 .When(x => x.Duration) .Return(TimeSpan.FromSeconds(5)); action4 .When(x => x.Duration) .Return(TimeSpan.FromMilliseconds(550)); var sut = new ParallelActionBuilder() .WithChild(action1) .WithChild(action2) .WithChild(action3) .WithChild(action4) .Build(); Assert.Equal(TimeSpan.FromSeconds(5), sut.Duration); }
public void GivenNonDeterministicAction_ShouldReachGoal() { var state1 = new StateMock("state 1"); var state2 = new StateMock("state 2"); var goalState = new StateMock("goal state"); var action = new ActionMock("action"); A.CallTo(() => _problem.IsGoal(goalState)).Returns(true); // available actions A.CallTo(() => _problem.GetActions(_initialState)).Returns(new [] {action}); A.CallTo(() => _problem.GetActions(state1)).Returns(new [] {action}); A.CallTo(() => _problem.GetActions(state2)).Returns(new [] {action}); // action outcomes A.CallTo(() => _problem.DoAction(_initialState, action)).Returns(new[] { state1, state2 }); A.CallTo(() => _problem.DoAction(state1, action)).Returns(new[] {goalState}); A.CallTo(() => _problem.DoAction(state2, action)).Returns(new[] {goalState}); // act var solution = CreateSearchAlgorithm(_problem, _initialState).GetSolution(); // assert Assert.AreEqual(action, solution.NextAction(_initialState)); Assert.AreEqual(action, solution.NextAction(state1)); }
public void execute_ensures_progress_of_child_actions_does_not_compound() { var action1 = new ActionMock(); var action2 = new ActionMock(); var action3 = new ActionMock(); var action4 = new ActionMock(); action1 .When(x => x.Duration) .Return(TimeSpan.FromSeconds(1)); action2 .When(x => x.Duration) .Return(TimeSpan.FromSeconds(1)); action3 .When(x => x.Duration) .Return(TimeSpan.FromSeconds(2)); action4 .When(x => x.Duration) .Return(TimeSpan.FromSeconds(1)); action1 .When(x => x.Execute(It.IsAny <ExecutionContext>())) .Do <ExecutionContext>(ec => ec.AddProgress(action1.Duration)) .Return(Observable.Return(Unit.Default)); action2 .When(x => x.Execute(It.IsAny <ExecutionContext>())) .Do <ExecutionContext>(ec => ec.AddProgress(action2.Duration)) .Return(Observable.Return(Unit.Default)); action3 .When(x => x.Execute(It.IsAny <ExecutionContext>())) .Do <ExecutionContext>(ec => ec.AddProgress(action3.Duration)) .Return(Observable.Return(Unit.Default)); action4 .When(x => x.Execute(It.IsAny <ExecutionContext>())) .Do <ExecutionContext>(ec => ec.AddProgress(action4.Duration)) .Return(Observable.Return(Unit.Default)); var sut = new ParallelActionBuilder() .WithChild(action1) .WithChild(action2) .WithChild(action3) .WithChild(action4) .Build(); using (var context = new ExecutionContext()) { sut.Execute(context); Assert.Equal(TimeSpan.FromSeconds(2), context.Progress); } }
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 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 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 ExecuteNotGenericWithNotNull() { bool executed = false; var eventMock = new ActionMock(); eventMock.TestAction += () => executed = true; eventMock.InvokeAction(); Assert.IsTrue(executed); }
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 execute_executes_each_child_action() { var action1 = new ActionMock(MockBehavior.Loose); var action2 = new ActionMock(MockBehavior.Loose); var action3 = new ActionMock(MockBehavior.Loose); var action4 = new ActionMock(MockBehavior.Loose); action1 .When(x => x.Duration) .Return(TimeSpan.FromSeconds(1)); action2 .When(x => x.Duration) .Return(TimeSpan.FromSeconds(2)); action3 .When(x => x.Duration) .Return(TimeSpan.FromSeconds(3)); action4 .When(x => x.Duration) .Return(TimeSpan.FromSeconds(4)); var sut = new ParallelActionBuilder() .WithChild(action1) .WithChild(action2) .WithChild(action3) .WithChild(action4) .Build(); using (var context = new ExecutionContext()) { sut.Execute(context); action1 .Verify(x => x.Execute(It.IsAny <ExecutionContext>())) .WasCalledExactlyOnce(); action2 .Verify(x => x.Execute(It.IsAny <ExecutionContext>())) .WasCalledExactlyOnce(); action3 .Verify(x => x.Execute(It.IsAny <ExecutionContext>())) .WasCalledExactlyOnce(); action4 .Verify(x => x.Execute(It.IsAny <ExecutionContext>())) .WasCalledExactlyOnce(); } }
public void duration_always_returns_zero_regardless_of_inner_action_duration() { var action = new ActionMock(); action .When(x => x.Duration) .Return(TimeSpan.FromSeconds(3)); var sut = new DoNotAwaitActionBuilder() .WithInnerAction(action) .Build(); Assert.Equal(TimeSpan.Zero, 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 GivenOnlyActionLeadsToGoal_FirstSolutionActionShouldGoToGoal() { var goalState = new StateMock("goal state"); var goToGoal = new ActionMock("go to goal"); A.CallTo(() => _problem.IsGoal(_initialState)).Returns(false); A.CallTo(() => _problem.IsGoal(goalState)).Returns(true); A.CallTo(() => _problem.GetActions(_initialState)).Returns(new [] {goToGoal}); A.CallTo(() => _problem.DoAction(_initialState, goToGoal)).Returns(new[] {goalState}); // act var solution = CreateSearchAlgorithm(_problem, _initialState).GetSolution(); // assert Assert.AreEqual(goToGoal, solution.NextAction(_initialState)); }
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 GivenOneActionRepeatsAndOneGoesToGoal_ShouldReturnPlanToGoal() { var goalState = new StateMock("goal state"); var repeat = new ActionMock("repeat"); var goToGoal = new ActionMock("go to goal"); A.CallTo(() => _problem.IsGoal(_initialState)).Returns(false); A.CallTo(() => _problem.IsGoal(goalState)).Returns(true); A.CallTo(() => _problem.GetActions(_initialState)).Returns(new [] {repeat, goToGoal}); A.CallTo(() => _problem.DoAction(_initialState, repeat)).Returns(new[] {_initialState}); A.CallTo(() => _problem.DoAction(_initialState, goToGoal)).Returns(new[] {goalState}); // act var solution = CreateSearchAlgorithm(_problem, _initialState).GetSolution(); // assert Assert.AreEqual(goToGoal, solution.NextAction(_initialState)); }
protected void StartPollingApp(string aAppName, string aUrl, DateTime aDateTime, out Mock<IAction> aAvailableActionMock, out Mock<IAction> aFailedActionMock) { var availableAction = new ActionMock(); var failedAction = new ActionMock(); iPollManager.StartPollingApp(aAppName, aUrl, aDateTime, availableAction.Action, failedAction.Action); aAvailableActionMock = availableAction.Mock; aFailedActionMock = failedAction.Mock; }