@Test public void doesNotReactWhileConditionNotFulfilled() { Model model = modelBuilder .useCase(USE_CASE) .basicFlow() .step(CUSTOMER_ENTERS_TEXT) .user(EntersText.class).system(displaysEnteredText()) .reactWhile(() -> false) .step(CUSTOMER_ENTERS_NUMBER) .user(EntersNumber.class).system(displaysEnteredNumber()) .build(); modelRunner.run(model).reactTo(entersText(), entersNumber()); assertRecordedStepNames(new String[0]); }
@Test public void printsTextAutonomouslyTwice() { Model model = modelBuilder .useCase(USE_CASE) .basicFlow() .step(SYSTEM_DISPLAYS_TEXT).system(displaysConstantText()) .step(SYSTEM_DISPLAYS_TEXT_AGAIN).system(displaysConstantText()) .build(); modelRunner.run(model); assertRecordedStepNames(SYSTEM_DISPLAYS_TEXT, SYSTEM_DISPLAYS_TEXT_AGAIN); }
@Test public void reactToStepThreeTimes() { timesDisplayed = 0; Model model = modelBuilder .useCase(USE_CASE) .basicFlow() .step(CUSTOMER_ENTERS_TEXT) .user(EntersText.class).system(displaysEnteredTextAndIncrementCounter()) .reactWhile(() -> timesDisplayed < 3) .step(CUSTOMER_ENTERS_NUMBER).user(EntersNumber.class).system(displaysEnteredNumber()) .build(); // Create way to many events to see if the repeat stops after three events modelRunner.run(model) .reactTo(entersText(), entersText(), entersText(), entersText(), entersText(), entersText(), entersText(), entersText(), entersText(), entersNumber()); assertRecordedStepNames(CUSTOMER_ENTERS_TEXT, CUSTOMER_ENTERS_TEXT, CUSTOMER_ENTERS_TEXT, CUSTOMER_ENTERS_NUMBER); } private Consumer<EntersText> displaysEnteredTextAndIncrementCounter(){
@Test public void twoSequentialStepsReactToEventsOfDifferentType() { Model model = modelBuilder .useCase(USE_CASE) .basicFlow() .step(CUSTOMER_ENTERS_TEXT).user(EntersText.class).system(displaysEnteredText()) .step(CUSTOMER_ENTERS_NUMBER).user(EntersNumber.class).system(displaysEnteredNumber()) .build(); modelRunner.run(model); reactToAndAssertEvents(entersText(), entersNumber()); }
@Test public void twoSequentialStepsReactToEventsOfSameType() { Model model = modelBuilder .useCase(USE_CASE) .basicFlow() .step(CUSTOMER_ENTERS_TEXT).user(EntersText.class).system(displaysEnteredText()) .step(CUSTOMER_ENTERS_TEXT_AGAIN).user(EntersText.class).system(displaysEnteredText()) .build(); modelRunner.run(model); reactToAndAssertEvents(entersText(), entersText()); }
@Test public void reactsToSecondStepAlternativeWhen() { Model model = modelBuilder .useCase(USE_CASE) .basicFlow() .step(CUSTOMER_ENTERS_TEXT).user(EntersText.class).system(displaysEnteredText()) .step(THIS_STEP_SHOULD_BE_SKIPPED).user(EntersText.class).system(throwsRuntimeException()) .flow(ALTERNATIVE_FLOW).condition(() -> CUSTOMER_ENTERS_TEXT.equals(latestStepName())) .step(CUSTOMER_ENTERS_ALTERNATIVE_TEXT).user(EntersText.class).system(displaysEnteredText()) .build(); modelRunner.run(model).reactTo(entersText(), entersAlternativeText()); assertRecordedStepNames(CUSTOMER_ENTERS_TEXT, CUSTOMER_ENTERS_ALTERNATIVE_TEXT); }
@Test public void doesNotReenterAlternativeFlowEvenIfItHasTrueCondition() { Model model = modelBuilder .useCase(USE_CASE) .basicFlow() .step(THIS_STEP_SHOULD_BE_SKIPPED).user(EntersText.class).system(throwsRuntimeException()) .step(THIS_STEP_SHOULD_BE_SKIPPED_AS_WELL).user(EntersText.class).system(throwsRuntimeException()) .flow(ALTERNATIVE_FLOW).anytime() .step(CUSTOMER_ENTERS_ALTERNATIVE_TEXT).user(EntersText.class).system(displaysEnteredText()) .step(CUSTOMER_ENTERS_NUMBER).user(EntersNumber.class).system(displaysEnteredNumber()) .build(); modelRunner.run(model) .reactTo(entersAlternativeText(), entersNumber(), entersAlternativeText(), entersNumber()); assertRecordedStepNames(CUSTOMER_ENTERS_ALTERNATIVE_TEXT, CUSTOMER_ENTERS_NUMBER); }
@Test public void doesNotReactToAlreadyRunStep() { Model model = modelBuilder .useCase(USE_CASE) .basicFlow() .step(CUSTOMER_ENTERS_TEXT).user(EntersText.class).system(displaysEnteredText()) .build(); modelRunner.run(model).reactTo(entersText(), entersText()); assertRecordedStepNames(CUSTOMER_ENTERS_TEXT); }
@Test public void stepWithWrongActorInDifferentFlowDoesNotReact() { Model model = modelBuilder .useCase(USE_CASE) .basicFlow() .step(CUSTOMER_ENTERS_TEXT) .as(customer).user(EntersText.class).system(displaysEnteredText()) .step(CUSTOMER_ENTERS_ALTERNATIVE_TEXT) .as(customer).user(EntersText.class).system(displaysEnteredText()) .flow(ALTERNATIVE_FLOW).insteadOf(CUSTOMER_ENTERS_ALTERNATIVE_TEXT) .step(THIS_STEP_SHOULD_BE_SKIPPED) .as(secondActor).user(EntersText.class).system(throwsRuntimeException()) .build(); modelRunner.as(customer).run(model).reactTo(entersText(), entersText()); assertEquals(CUSTOMER_ENTERS_ALTERNATIVE_TEXT, latestStepName()); }
@Test public void twoSequentialStepsReactWhenOneIsUserStepAndOtherIsSystemStep() { Model model = modelBuilder .useCase(USE_CASE) .basicFlow() .step(CUSTOMER_ENTERS_TEXT).user(EntersText.class) .step(SYSTEM_DISPLAYS_TEXT).system(displaysConstantText()) .build(); Optional<Step> latestStepRun = modelRunner.run(model).reactTo(entersText()); assertTrue(latestStepRun.map(step -> step.getName().equals(SYSTEM_DISPLAYS_TEXT)).orElse(false)); assertRecordedStepNames(CUSTOMER_ENTERS_TEXT, SYSTEM_DISPLAYS_TEXT); }
@Test public void onlyStepWithRightActorInDifferentFlowReacts() { Model model = modelBuilder .useCase(USE_CASE) .basicFlow() .step(CUSTOMER_ENTERS_TEXT) .as(secondActor).user(EntersText.class).system(throwsRuntimeException()) .flow(ALTERNATIVE_FLOW).condition(this::textIsNotAvailable) .step(CUSTOMER_ENTERS_TEXT_AGAIN) .as(customer).user(EntersText.class).system(displaysEnteredText()) .build(); modelRunner.as(customer).run(model); Optional<Step> lastStepRun = modelRunner.reactTo(entersText()); assertEquals(CUSTOMER_ENTERS_TEXT_AGAIN, lastStepRun.get().getName()); }
@Test public void doesNotReactToEmptyEventList() { Model model = modelBuilder .useCase(USE_CASE) .basicFlow() .step(CUSTOMER_ENTERS_TEXT).user(EntersText.class).system(displaysEnteredText()) .build(); Optional<Step> latestStepRun = modelRunner.run(model).reactTo(new ArrayList<Object>()); assertFalse(latestStepRun.isPresent()); assertRecordedStepNames(new String[0]); }
@Test public void twoSequentialStepsReactToEventsOfSameTypeAsList() { Model model = modelBuilder .useCase(USE_CASE) .basicFlow() .step(CUSTOMER_ENTERS_TEXT).user(EntersText.class).system(displaysEnteredText()) .step(CUSTOMER_ENTERS_TEXT_AGAIN).user(EntersText.class).system(displaysEnteredText()) .build(); modelRunner.run(model); EntersText[] eventArray = new EntersText[] {entersText(), entersText()}; List<EntersText> events = Arrays.asList(eventArray); modelRunner.reactTo(events); assertArrayEquals(eventArray, modelRunner.getRecordedEvents()); }
private Consumer<EntersText> displaysEnteredTextAndIncrementCounter(){ return enteredText -> { displaysEnteredText().accept(enteredText); timesDisplayed++; }; }
@Test public void onlyStepWithTrueConditionReacts() { Model model = modelBuilder .useCase(USE_CASE) .basicFlow() .step(CUSTOMER_ENTERS_TEXT).user(EntersText.class).system(displaysEnteredText()) .flow("Alternative Flow: Skipped").condition(() -> false) .step(THIS_STEP_SHOULD_BE_SKIPPED).user(EntersText.class).system(throwsRuntimeException()) .build(); modelRunner.run(model).reactTo(entersText(), entersText()); assertRecordedStepNames(CUSTOMER_ENTERS_TEXT); }
@Test public void stepThasHasTrueConditionReactsEvenIfOtherStepWouldBePerformedBySystem() { Model model = modelBuilder .useCase(USE_CASE) .basicFlow() .step(CUSTOMER_ENTERS_TEXT).user(EntersText.class).system(displaysEnteredText()) .flow("Alternative Flow: Skipped").condition(() -> false) .step(THIS_STEP_SHOULD_BE_SKIPPED).system(() -> System.out.println("You should not see this!")) .build(); modelRunner.run(model).reactTo(entersText(), entersText()); assertRecordedStepNames(CUSTOMER_ENTERS_TEXT); }
@Test public void oneStepInFlowReacts() { Model model = modelBuilder .useCase(USE_CASE) .basicFlow() .step(CUSTOMER_ENTERS_TEXT).user(EntersText.class).system(displaysEnteredText()) .build(); modelRunner.run(model); reactToAndAssertEvents(entersText()); }
@Test public void doesNotReactToEmptyEvents() { Model model = modelBuilder .useCase(USE_CASE) .basicFlow() .step(CUSTOMER_ENTERS_TEXT).user(EntersText.class).system(displaysEnteredText()) .build(); modelRunner.run(model).reactTo(); assertRecordedStepNames(new String[0]); }
@Test public void doesNotReactIfStepHasRightActorButFalseCondition() { Model model = modelBuilder .useCase(USE_CASE) .basicFlow() .step(CUSTOMER_ENTERS_TEXT) .as(secondActor).user(EntersText.class).system(displaysEnteredText()) .flow(ALTERNATIVE_FLOW).condition(() -> false) .step(THIS_STEP_SHOULD_BE_SKIPPED) .as(customer).user(EntersText.class).system(displaysEnteredText()) .build(); modelRunner.as(customer).run(model); Optional<Step> lastStepRun = modelRunner.reactTo(entersText()); assertFalse(lastStepRun.isPresent()); }
@Test public void reactToStepTwice() { Model model = modelBuilder .useCase(USE_CASE) .basicFlow() .step(CUSTOMER_ENTERS_TEXT) .user(EntersText.class).system(displaysEnteredText()) .reactWhile(() -> true) .step(CUSTOMER_ENTERS_NUMBER) .user(EntersNumber.class).system(displaysEnteredNumber()) .build(); modelRunner.run(model); reactToAndAssertEvents(entersText(), entersText(), entersNumber()); }