/** * Only if the specified condition is true, the event is handled. * * @param condition * the condition that constrains when the event is handled * @return a part of the builder used to define the event's class */ public ConditionPart condition(Condition condition) { return useCase(HANDLES_EVENTS).condition(condition); }
@Before public void setup() { setupWithRecordingModelRunner(); this.secondActor = modelBuilder.actor("Second Actor"); }
public Model buildWith(ModelBuilder modelBuilder) { normalUser = modelBuilder.actor("Normal User"); anonymousUser = modelBuilder.actor("Anonymous User"); Model model = modelBuilder.useCase("Get greeted") .basicFlow() .step("S1").as(normalUser).system(this::promptsUserToEnterFirstName) .step("S2").as(normalUser).user(ENTERS_FIRST_NAME).system(this::savesFirstName) .step("S3").as(normalUser, anonymousUser).system(this::promptsUserToEnterAge) .step("S4").as(normalUser, anonymousUser).user(ENTERS_AGE).system(this::savesAge) .step("S5").as(normalUser).system(this::greetsUserWithFirstName) .step("S6").as(normalUser, anonymousUser).system(this::greetsUserWithAge) .step("S7").as(normalUser, anonymousUser).system(this::stops) .flow("Handle out-of-bounds age").insteadOf("S5").condition(this::ageIsOutOfBounds) .step("S5a_1").system(this::informsUserAboutOutOfBoundsAge) .step("S5a_2").continuesAt("S3") .flow("Handle non-numerical age").insteadOf("S5") .step("S5b_1").on(NON_NUMERICAL_AGE).system(this::informsUserAboutNonNumericalAge) .step("S5b_2").continuesAt("S3") .flow("Anonymous greeted with age only").insteadOf("S5").condition(this::ageIsOk) .step("S5c_1").as(anonymousUser).continuesAt("S6") .flow("Anonymous does not enter name").insteadOf("S1") .step("S1a_1").as(anonymousUser).continuesAt("S3") .build(); return model; }
/** * Returns the model that has been built. * * @return the model */ public Model build() { return modelBuilder.build(); }
@Test public void createsSingleStepThatHandlesUserCommandWithoutUseCaseAndWithoutFlow() { Model model = modelBuilder .on(EntersText.class).system(displaysEnteredText()) .build(); Collection<Step> steps = model.getSteps(); assertEquals(1, steps.size()); Step step = steps.iterator().next(); assertEquals("S1", step.getName()); assertEquals(model.getSystemActor(), step.getActors()[0]); }
/** * The only way to build a model and its parts is to * use the builder returned by this method. * @return the builder. */ public static ModelBuilder builder() { return new ModelBuilder(new Model()); }
@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]); }
public Model build() { return stepPart.getModelBuilder().build(); }
@Test public void oneFlowlessStepReactsWithoutUseCase() { Model model = modelBuilder .on(EntersText.class).system(displaysEnteredText()) .build(); modelRunner.run(model); Optional<Step> latestStepRun = modelRunner.reactTo(entersText()); assertEquals(EntersText.class, latestStepRun.get().getEventClass()); }
public UseCasePart useCase(String useCaseName) { Objects.requireNonNull(useCaseName); UseCasePart useCasePart = getModelBuilder().useCase(useCaseName); return useCasePart; }
@Test public void extractsFlowlessModel() throws Exception { Model model = Model.builder() .on(entersName()).system(greetsUser()) .on(Exception.class).system(logsException()) .build(); String templateFileName = "testextract_flowless.ftl"; Writer outputWriter = new StringWriter(); engine.extract(model, templateFileName, outputWriter); String output = outputWriter.toString(); assertEquals( "Use case: Handles events." + " Step: S1. On EntersName: System greets user." + " Step: S2. On Exception: System logs exception.", output); }
@Test public void accessesExistingCustomerActor() { Actor actualCustomer = modelBuilder.actor(CUSTOMER); assertEquals(customer, actualCustomer); }
public Model buildWith(ModelBuilder modelBuilder) { Model model = modelBuilder.useCase("Get greeted") .basicFlow() .step("S1").system(this::greetsUser) .build(); return model; }
@Test public void createsNoUseCase() { Model model = modelBuilder.build(); Collection<UseCase> useCases = model.getUseCases(); assertEquals(0, useCases.size()); }
@Test public void twoFlowlessStepsReactToEventsOfDifferentTypeInRightOrderWithoutUseCase() { Model model = modelBuilder .on(EntersText.class).system(displaysEnteredText()) .on(EntersNumber.class).system(displaysEnteredNumber()) .build(); modelRunner.run(model); Optional<Step> latestStepRun = modelRunner.reactTo(entersText()); assertEquals(EntersText.class, latestStepRun.get().getEventClass()); latestStepRun = modelRunner.reactTo(entersNumber()); assertEquals(EntersNumber.class, latestStepRun.get().getEventClass()); }