FlowPart(Flow flow, UseCasePart useCasePart) { this.flow = flow; this.useCasePart = useCasePart; this.useCase = useCasePart.getUseCase(); }
/** * Start a flow with the specified name. * * @param flowName * the name of the flow. * * @return the flow part to create the steps of the flow. */ public FlowPart flow(String flowName) { Flow useCaseFlow = getUseCase().newFlow(flowName); return new FlowPart(useCaseFlow, this); }
/** * Start the "happy day scenario" where all is fine and dandy. * * @return the flow part to create the steps of the basic flow. */ public FlowPart basicFlow() { Flow useCaseFlow = getUseCase().getBasicFlow(); return new FlowPart(useCaseFlow, this); }
@Test public void flowsAreUniquelyIdentifiedByName() { UseCasePart useCasePart = modelBuilder.useCase(USE_CASE); UseCase useCase = useCasePart.getUseCase(); useCase.newFlow(ALTERNATIVE_FLOW); Flow existingFlow = useCase.findFlow(ALTERNATIVE_FLOW); assertEquals(2, useCase.getFlows().size()); // This is 2 because the basic flow always exists Iterator<Flow> flowIt = useCase.getFlows().iterator(); assertEquals(useCase.getBasicFlow(), flowIt.next()); assertEquals(existingFlow, flowIt.next()); }
@Test public void createsSingleStepWithNoPreviousStep() { UseCasePart useCasePart = modelBuilder.useCase(USE_CASE); useCasePart.basicFlow() .step(SYSTEM_DISPLAYS_TEXT).system(displaysConstantText()); Collection<Step> steps = useCasePart.getUseCase().getSteps(); assertEquals(1, steps.size()); Optional<FlowStep> previousStep = ((FlowStep) steps.iterator().next()).getPreviousStepInFlow(); assertFalse(previousStep.isPresent()); }
@Test public void createsTwoStepsAndCheckIfTheyExistInUseCaseByName() { UseCasePart useCasePart = modelBuilder.useCase(USE_CASE); useCasePart.basicFlow() .step(SYSTEM_DISPLAYS_TEXT).system(displaysConstantText()) .step(SYSTEM_DISPLAYS_TEXT_AGAIN).system(displaysConstantText()); Collection<Step> steps = useCasePart.getUseCase().getSteps(); assertEquals(2, steps.size()); boolean firstUseCaseStepExists = useCasePart.getUseCase().hasStep(SYSTEM_DISPLAYS_TEXT); boolean secondUseCaseStepExists = useCasePart.getUseCase().hasStep(SYSTEM_DISPLAYS_TEXT_AGAIN); assertTrue(firstUseCaseStepExists); assertTrue(secondUseCaseStepExists); }
@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 createsTwoStepsInDifferentFlowsThatBothHaveNoPreviousSteps() { UseCasePart useCasePart = modelBuilder.useCase(USE_CASE); useCasePart .basicFlow() .step(SYSTEM_DISPLAYS_TEXT).system(displaysConstantText()) .flow(ALTERNATIVE_FLOW) .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); assertFalse(firstUseCaseStep.getPreviousStepInFlow().isPresent()); assertFalse(secondUseCaseStep.getPreviousStepInFlow().isPresent()); }
@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 createsTwoStepsIncrementally() { UseCasePart useCasePart = modelBuilder.useCase(USE_CASE); modelBuilder.useCase(USE_CASE).basicFlow().step(SYSTEM_DISPLAYS_TEXT).system(displaysConstantText()); useCasePart = modelBuilder.useCase(USE_CASE); modelBuilder.useCase(USE_CASE).basicFlow() .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 createsSingleStepThatHandlesUserCommandWithUseCaseButWithoutFlow() { UseCasePart useCasePart = modelBuilder.useCase(USE_CASE); Model model = useCasePart .on(EntersText.class).system(displaysEnteredText()) .build(); UseCase useCase = useCasePart.getUseCase(); Collection<Step> steps = useCase.getSteps(); assertEquals(1, steps.size()); Step step = steps.iterator().next(); assertEquals("S1", step.getName()); assertEquals(USE_CASE, step.getUseCase().getName()); assertEquals(model.getSystemActor(), step.getActors()[0]); }
@Test public void createsSingleStepThatPerformsSystemReactionAutomatically() { UseCasePart useCasePart = modelBuilder.useCase(USE_CASE); Model model = useCasePart.basicFlow() .step(SYSTEM_DISPLAYS_TEXT).system(displaysConstantText()) .build(); Collection<Step> steps = useCasePart.getUseCase().getSteps(); assertEquals(1, steps.size()); Step step = steps.iterator().next(); assertEquals(SYSTEM_DISPLAYS_TEXT, step.getName()); assertEquals(USE_CASE, step.getUseCase().getName()); assertEquals(model.getSystemActor(), step.getActors()[0]); }
@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()); }
@Test public void createsSingleStepThatHandlesUserCommandWithFlow() { UseCasePart useCasePart = modelBuilder.useCase(USE_CASE); Model model = useCasePart.basicFlow() .step(CUSTOMER_ENTERS_TEXT).user(EntersText.class).system(displaysEnteredText()) .build(); UseCase useCase = useCasePart.getUseCase(); assertFalse(useCase.getBasicFlow().getCondition().isPresent()); Collection<Step> steps = useCase.getSteps(); assertEquals(1, steps.size()); Step step = steps.iterator().next(); assertEquals(CUSTOMER_ENTERS_TEXT, step.getName()); assertEquals(USE_CASE, step.getUseCase().getName()); assertEquals(model.getUserActor(), step.getActors()[0]); }
@Test public void createsSingleStepThatHandlesUserCommandWithCondition() { UseCasePart useCasePart = modelBuilder.useCase(USE_CASE); useCasePart.basicFlow().condition(() -> textIsAvailable()) .step(CUSTOMER_ENTERS_TEXT).user(EntersText.class).system(displaysEnteredText()) .build(); UseCase useCase = useCasePart.getUseCase(); assertTrue(useCase.getBasicFlow().getCondition().isPresent()); }
@Test public void createsTwoStepsWithoutFlow() { UseCasePart useCasePart = modelBuilder.useCase(USE_CASE); useCasePart .on(EntersText.class).system(displaysEnteredText()) .on(EntersNumber.class).system(displaysEnteredNumber()) .build(); Collection<Step> steps = useCasePart.getUseCase().getSteps(); assertEquals(2, steps.size()); Iterator<Step> stepIt = steps.iterator(); Step step = stepIt.next(); assertEquals("S1", step.getName()); assertEquals(USE_CASE, step.getUseCase().getName()); step = stepIt.next(); assertEquals("S2", step.getName()); assertEquals(USE_CASE, step.getUseCase().getName()); }
@Test public void createsSingleStepThatPerformsSystemReactionAutomaticallyForSpecificActor() { UseCasePart useCasePart = modelBuilder.useCase(USE_CASE); Model model = useCasePart.basicFlow() .step(SYSTEM_DISPLAYS_TEXT).as(customer).system(displaysConstantText()) .build(); Collection<Step> steps = useCasePart.getUseCase().getSteps(); assertEquals(1, steps.size()); Step step = steps.iterator().next(); assertEquals(SYSTEM_DISPLAYS_TEXT, step.getName()); assertEquals(USE_CASE, step.getUseCase().getName()); assertTrue(model.hasActor(customer.getName())); assertEquals(customer, step.getActors()[0]); }
@Test public void createsTwoStepsWithActorAndFlow() { UseCasePart useCasePart = modelBuilder.useCase(USE_CASE); Model model = useCasePart.basicFlow() .step(SYSTEM_DISPLAYS_TEXT).system(displaysConstantText()) .step(SYSTEM_DISPLAYS_NUMBER).as(customer).user(EntersNumber.class).system(displaysEnteredNumber()) .build(); assertTrue(model.getActors().contains(model.getSystemActor())); assertTrue(model.getActors().contains(customer)); Collection<Step> steps = useCasePart.getUseCase().getSteps(); assertEquals(2, steps.size()); Iterator<Step> stepIt = steps.iterator(); Step step = stepIt.next(); assertEquals(SYSTEM_DISPLAYS_TEXT, step.getName()); assertEquals(USE_CASE, step.getUseCase().getName()); step = stepIt.next(); assertEquals(SYSTEM_DISPLAYS_NUMBER, step.getName()); assertEquals(USE_CASE, step.getUseCase().getName()); }
@Test public void createsTwoActorsWithSingleUseCaseStep() { Actor anotherActor = modelBuilder.actor("Another Actor"); UseCasePart useCasePart = modelBuilder.useCase(USE_CASE); Model model = useCasePart.basicFlow() .step(CUSTOMER_ENTERS_TEXT).as(customer, anotherActor).user(EntersText.class).system(displaysEnteredText()) .build(); Actor customerActor = model.findActor(customer.getName()); List<Step> steps = customerActor.getStepsOf(useCasePart.getUseCase()); Step step = steps.get(0); assertEquals(CUSTOMER_ENTERS_TEXT, step.getName()); assertEquals(CUSTOMER_ENTERS_TEXT, step.toString()); assertEquals(USE_CASE, step.getUseCase().getName()); assertEquals(customer, step.getActors()[0]); steps = anotherActor.getStepsOf(useCasePart.getUseCase()); step = steps.get(0); assertEquals(CUSTOMER_ENTERS_TEXT, step.getName()); assertEquals(anotherActor, step.getActors()[1]); }
@Test public void createsSingleActorWithSingleUseCaseStep() { UseCasePart useCasePart = modelBuilder.useCase(USE_CASE); Model model = useCasePart.basicFlow() .step(CUSTOMER_ENTERS_TEXT).as(customer).user(EntersText.class).system(displaysEnteredText()) .build(); Actor customerActor = model.findActor(customer.getName()); List<Step> steps = customerActor.getStepsOf(useCasePart.getUseCase()); Step step = steps.get(0); assertEquals(CUSTOMER_ENTERS_TEXT, step.getName()); assertEquals(CUSTOMER_ENTERS_TEXT, step.toString()); assertEquals(USE_CASE, step.getUseCase().getName()); assertEquals(customer, step.getActors()[0]); }