private String getStepNameOrIncludedUseCase(Step step) { String stepNameOrIncludedUseCase = ""; if (hasSystemReaction(step)) { Consumer<?> systemReaction = step.getSystemReaction(); if (systemReaction instanceof AbstractContinues) { stepNameOrIncludedUseCase = " " + ((AbstractContinues) systemReaction).getStepName(); } else if (systemReaction instanceof IncludesUseCase) { stepNameOrIncludedUseCase = " " + ((IncludesUseCase) systemReaction).getIncludedUseCase().getName(); } } return stepNameOrIncludedUseCase; } }
@Test public void createsSingleUseCase() { modelBuilder.useCase(USE_CASE); Model model = modelBuilder.build(); assertTrue(model.hasUseCase(USE_CASE)); Collection<UseCase> useCases = model.getUseCases(); assertEquals(1, useCases.size()); assertEquals(USE_CASE, useCases.iterator().next().getName()); }
@Test public void accessesExistingUseCaseTwice() { modelBuilder.useCase(USE_CASE); modelBuilder.useCase(USE_CASE); Model model = modelBuilder.build(); assertTrue(model.hasUseCase(USE_CASE)); Collection<UseCase> useCases = model.getUseCases(); assertEquals(1, useCases.size()); assertEquals(USE_CASE, useCases.iterator().next().getName()); }
@Test public void createsSingleActorWithSingleUseCase() { 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); Set<UseCase> useCases = customerActor.getUseCases(); assertEquals(1, useCases.size()); UseCase actualUseCase = useCases.iterator().next(); assertEquals(USE_CASE, actualUseCase.getName()); }
@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 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 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 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 createsSingleStepThatHandlesSystemEvent() { UseCasePart useCasePart = modelBuilder.useCase(USE_CASE); Model model = useCasePart.basicFlow() .step(SYSTEM_DISPLAYS_TEXT).on(EntersText.class).system(displaysEnteredText()) .build(); UseCase useCase = model.findUseCase(USE_CASE); Collection<Step> steps = useCase.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 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 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]); }
@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]); }