@Test public void includesUseCaseWithAlternativeFlowAtSecondStep_withFalseCondition() { Model model = modelBuilder .useCase(INCLUDED_USE_CASE) .basicFlow() .step(SYSTEM_HANDLES_EXCEPTION).user(Throwable.class).system(e -> e.printStackTrace()) .flow(ALTERNATIVE_FLOW).condition(() -> false) .step(CUSTOMER_ENTERS_NUMBER).user(EntersNumber.class).system(displaysEnteredNumber()) .useCase(USE_CASE) .basicFlow() .step(CUSTOMER_ENTERS_TEXT).user(EntersText.class).system(displaysEnteredText()) .step(SYSTEM_INCLUDES_USE_CASE).includesUseCase(INCLUDED_USE_CASE) .step(SYSTEM_DISPLAYS_TEXT).system(displaysConstantText()) .build(); modelRunner.run(model).reactTo(entersText(), entersNumber(), entersNumber()); assertRecordedStepNames(CUSTOMER_ENTERS_TEXT, SYSTEM_INCLUDES_USE_CASE); }
public Model buildWith(ModelBuilder modelBuilder) { Model model = modelBuilder.useCase("Get greeted") .basicFlow() .step("S1").system(this::greetsUser) .step("S2").system(this::printsHooray).reactWhile(this::lessThanThreeHooraysHaveBeenPrinted) .build(); return model; }
public Model buildWith(ModelBuilder modelBuilder) { Model model = modelBuilder.useCase("Get greeted") .basicFlow() .step("S1").system(this::promptsUserToEnterFirstName) .step("S2").user(ENTERS_FIRST_NAME).system(this::savesFirstName) .step("S3").system(this::promptsUserToEnterAge) .step("S4").user(ENTERS_AGE).system(this::savesAge) .step("S5").system(this::greetsUserWithFirstNameAndAge) .build(); return model; }
@Test public void useCasesAreUniquelyIdentifiedByName() { UseCasePart useCasePart = modelBuilder.useCase(USE_CASE); Model model = useCasePart.basicFlow() .step(SYSTEM_DISPLAYS_TEXT).system(displaysConstantText()) .flow(ALTERNATIVE_FLOW) .step(SYSTEM_DISPLAYS_TEXT_AGAIN).system(displaysConstantText()).build(); assertEquals(1, model.getUseCases().size()); assertEquals(model.findUseCase(USE_CASE), model.getUseCases().iterator().next()); }
@Test public void throwsExceptionWhenIncludedUseCaseIsDeclaredLater() { thrown.expect(NoSuchElementInModel.class); thrown.expectMessage(INCLUDED_USE_CASE); modelBuilder .useCase(USE_CASE) .basicFlow() .step(SYSTEM_INCLUDES_USE_CASE).includesUseCase(INCLUDED_USE_CASE) .step(SYSTEM_DISPLAYS_TEXT).system(displaysConstantText()) .useCase(INCLUDED_USE_CASE) .basicFlow() .step(SYSTEM_DISPLAYS_NUMBER).user(EntersNumber.class).system(displaysEnteredNumber()) .build(); } }
@Test public void reactsToFirstStepAlternativeWhen() { 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).condition(this::textIsNotAvailable) .step(CUSTOMER_ENTERS_ALTERNATIVE_TEXT).user(EntersText.class).system(displaysEnteredText()) .build(); modelRunner.run(model).reactTo(entersText()); assertRecordedStepNames(CUSTOMER_ENTERS_ALTERNATIVE_TEXT); }
@Test public void continuesAtCalledFromSecondStepOfAlternativeFlow() { 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()) .step(CUSTOMER_ENTERS_NUMBER).user(EntersNumber.class).system(displaysEnteredNumber()) .flow(ALTERNATIVE_FLOW).insteadOf(CUSTOMER_ENTERS_TEXT_AGAIN) .step(CUSTOMER_ENTERS_ALTERNATIVE_TEXT).user(EntersText.class).system(displaysEnteredText()) .step(CONTINUE).continuesAt(CUSTOMER_ENTERS_NUMBER) .build(); modelRunner.run(model).reactTo(entersText(), entersAlternativeText(), entersText(), entersNumber()); assertRecordedStepNames(CUSTOMER_ENTERS_TEXT, CUSTOMER_ENTERS_ALTERNATIVE_TEXT, CONTINUE, CUSTOMER_ENTERS_NUMBER); }
public Model buildWith(ModelBuilder modelBuilder) { Model model = modelBuilder.useCase("Get greeted") .basicFlow() .step("S1").system(this::greetsUser) .build(); return model; }
@Test public void throwsExceptionIfMoreThanOneStepCanReactInDifferentUseCases() { thrown.expect(MoreThanOneStepCanReact.class); thrown.expectMessage("Step 1"); thrown.expectMessage("Step 2 with same event as Step 1"); Model model = modelBuilder .useCase("Use Case") .basicFlow() .step("Step 1").user(String.class).system(s -> System.out.println(s)) .useCase("Another Use Case") .basicFlow() .step("Step 2 with same event as Step 1").user(String.class).system(s -> System.out.println(s)) .build(); modelRunner.run(model); modelRunner.reactTo(new String("Some text")); }
@Test public void createsTwoStepsInBasicFlowAndCheckIfTheyExistByIndex() { UseCasePart useCasePart = modelBuilder.useCase(USE_CASE); useCasePart.basicFlow() .step(SYSTEM_DISPLAYS_TEXT).system(displaysConstantText()) .step(SYSTEM_DISPLAYS_TEXT_AGAIN).system(displaysConstantText()); List<FlowStep> steps = useCasePart.getUseCase().getBasicFlow().getSteps(); assertEquals(2, steps.size()); assertEquals(SYSTEM_DISPLAYS_TEXT, steps.get(0).getName()); assertEquals(SYSTEM_DISPLAYS_TEXT_AGAIN, steps.get(1).getName()); }
@Test public void throwsExceptionIfFlowIsCreatedTwice() { thrown.expect(ElementAlreadyInModel.class); thrown.expectMessage(ALTERNATIVE_FLOW); modelBuilder .useCase(USE_CASE) .flow(ALTERNATIVE_FLOW) .step(SYSTEM_DISPLAYS_TEXT).system(displaysConstantText()) .flow(ALTERNATIVE_FLOW); }
public Model buildWith(ModelBuilder modelBuilder) { Model model = modelBuilder.useCase("Feel Stuff") .basicFlow() .step("1").user(asksForPoem).system(feelStuffUseCaseRealization::writesSadPoem) .step("2").user(asksForPoem).system(feelStuffUseCaseRealization::writesHappyPoem) .step("3").user(asksForPoem).system(feelStuffUseCaseRealization::writesFunnyPoem) .build(); return model; } }
@Test public void includeUseCaseTwoConsecutiveTimes() { Model model = modelBuilder .useCase(INCLUDED_USE_CASE) .basicFlow() .step(CUSTOMER_ENTERS_NUMBER).user(EntersNumber.class).system(displaysEnteredNumber()) .useCase(USE_CASE) .basicFlow() .step(CUSTOMER_ENTERS_TEXT).user(EntersText.class).system(displaysEnteredText()) .step(SYSTEM_INCLUDES_USE_CASE).includesUseCase(INCLUDED_USE_CASE) .step(SYSTEM_INCLUDES_USE_CASE_2).includesUseCase(INCLUDED_USE_CASE) .step(SYSTEM_DISPLAYS_TEXT).system(displaysConstantText()) .build(); modelRunner.run(model).reactTo(entersText(), entersNumber(), entersNumber()); assertRecordedStepNames(CUSTOMER_ENTERS_TEXT, SYSTEM_INCLUDES_USE_CASE, CUSTOMER_ENTERS_NUMBER, SYSTEM_INCLUDES_USE_CASE_2, CUSTOMER_ENTERS_NUMBER, SYSTEM_DISPLAYS_TEXT); }
@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 sameEventTypeReactedTo() { Model model = modelBuilder.useCase(USE_CASE) .basicFlow().anytime() .step(CUSTOMER_ENTERS_TEXT).user(EntersText.class).system(displaysEnteredText()) .flow("Alternative Flow: Could react as well").anytime() .step(CUSTOMER_ENTERS_ALTERNATIVE_TEXT).user(EntersText.class).system(displaysEnteredText()) .build(); modelRunner.run(model); Set<Class<?>> reactToTypes = modelRunner.getReactToTypes(); assertEquals(1, reactToTypes.size()); Class<?> eventTypeReactedTo = reactToTypes.iterator().next(); assertEquals(EntersText.class, eventTypeReactedTo); }
@Test public void continuesAfterCalledFromSecondStepOfAlternativeFlow() { 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()) .step(CUSTOMER_ENTERS_NUMBER).user(EntersNumber.class).system(displaysEnteredNumber()) .flow(ALTERNATIVE_FLOW).insteadOf(CUSTOMER_ENTERS_TEXT_AGAIN) .step(CUSTOMER_ENTERS_ALTERNATIVE_TEXT).user(EntersText.class).system(displaysEnteredText()) .step(CONTINUE).continuesAfter(CUSTOMER_ENTERS_TEXT_AGAIN) .build(); modelRunner.run(model).reactTo(entersText(), entersAlternativeText(), entersText(), entersNumber()); assertRecordedStepNames(CUSTOMER_ENTERS_TEXT, CUSTOMER_ENTERS_ALTERNATIVE_TEXT, CONTINUE, CUSTOMER_ENTERS_NUMBER); }
@Test public void oneStepCanReactIfEventIsRight() { Model model = modelBuilder.useCase(USE_CASE) .basicFlow() .step(CUSTOMER_ENTERS_TEXT).user(EntersText.class).system(displaysEnteredText()).build(); modelRunner.run(model); boolean canReact = modelRunner.canReactTo(entersText().getClass()); assertTrue(canReact); Set<Step> stepsThatCanReact = modelRunner.getStepsThatCanReactTo(entersText().getClass()); assertEquals(1, stepsThatCanReact.size()); assertEquals(CUSTOMER_ENTERS_TEXT, stepsThatCanReact.iterator().next().getName().toString()); }
@Test public void actorsCanBeReusedBetweenUseCases() { UseCasePart useCasePart = modelBuilder.useCase(USE_CASE); Model model = useCasePart.basicFlow() .step(CUSTOMER_ENTERS_TEXT).as(customer).user(EntersText.class).system(displaysEnteredText()) .useCase(USE_CASE_2) .basicFlow() .step(CUSTOMER_ENTERS_TEXT_AGAIN).as(customer).user(EntersText.class).system(displaysEnteredText()) .build(); Collection<Step> steps = model.getSteps(); assertEquals(2, steps.size()); Iterator<Step> stepsIt = steps.iterator(); Actor actor1 = stepsIt.next().getActors()[0]; Actor actor2 = stepsIt.next().getActors()[0]; assertTrue(actor1 == actor2); assertEquals(customer, actor1); } }
@Test public void createsTwoStepsAndPreviousStepOfSecondOneIsFirstOne() { UseCasePart useCasePart = modelBuilder.useCase(USE_CASE); useCasePart.basicFlow() .step(SYSTEM_DISPLAYS_TEXT).system(displaysConstantText()) .step(SYSTEM_DISPLAYS_TEXT_AGAIN).system(displaysConstantText()); FlowStep firstUseCaseStep = (FlowStep)useCasePart.getUseCase().findStep(SYSTEM_DISPLAYS_TEXT); FlowStep secondUseCaseStep = (FlowStep)useCasePart.getUseCase().findStep(SYSTEM_DISPLAYS_TEXT_AGAIN); assertEquals(firstUseCaseStep, secondUseCaseStep.getPreviousStepInFlow().get()); }
@Test public void createsOneStepInAlternativeFlowAndCheckIfItExistsByIndex() { UseCasePart useCasePart = modelBuilder.useCase(USE_CASE); useCasePart.basicFlow() .step(SYSTEM_DISPLAYS_TEXT).system(displaysConstantText()).flow(ALTERNATIVE_FLOW) .step(SYSTEM_DISPLAYS_TEXT_AGAIN).system(displaysConstantText()); List<FlowStep> steps = useCasePart.getUseCase().findFlow(ALTERNATIVE_FLOW).getSteps(); assertEquals(1, steps.size()); assertEquals(SYSTEM_DISPLAYS_TEXT_AGAIN, steps.get(0).getName()); }