How to use

getUseCase

method

in

org.requirementsascode.UseCasePart

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]);
}