private void start() { Model model = buildWith(Model.builder()); new ModelRunner().run(model).reactTo(entersText()); } }
private void start() { Model model = buildWith(Model.builder()); ModelRunner modelRunner = new ModelRunner(); modelRunner.as(anonymousUser()).run(model); while (!systemStopped()) modelRunner.reactTo(entersText()); exitSystem(); }
@Test public void recordSingleEvent() { Model model = modelBuilder.useCase(USE_CASE) .on(EntersText.class).system(displaysEnteredText()) .build(); modelRunner.run(model).startRecording(); modelRunner.reactTo(entersText()); assertEquals(1, modelRunner.getRecordedEvents().length); assertEquals(EntersText.class, modelRunner.getRecordedEvents()[0].getClass()); assertEquals(1, modelRunner.getRecordedStepNames().length); assertEquals("S1", modelRunner.getRecordedStepNames()[0]); }
/** * Restarts the runner, resetting it to its original defaults ("no flow has been * run, no step has been run"). */ public void restart() { setLatestStep(null); run(model); }
static ModelRunner runnerOf(Model model) { ModelRunner modelRunner = new ModelRunner(); modelRunner.run(model); return modelRunner; }
@Test public void testHelloWorld06_AsAnonymousUserHandleNonNumericalAge() { HelloWorld06 example = new HelloWorld06(); model = example.buildWith(modelBuilder); modelRunner.as(example.anonymousUser()).run(model).reactTo(new EntersText("NotANumber")); assertRecordedStepNames("S1a_1", "S3", "S4", "S5b_1", "S5b_2", "S3"); }
@Test public void twoFlowlessStepsReactWhenConditionIsTrueInSecondStepWithoutEvent() { Model model = modelBuilder.useCase(USE_CASE) .on(EntersText.class).system(displaysEnteredText()) .condition(() -> modelRunner.getLatestStep().isPresent() && modelRunner.getLatestStep().get().getEventClass().equals(EntersText.class)).system(displaysConstantText()) .build(); modelRunner.run(model).reactTo(entersText()); assertEquals(ModelRunner.class, modelRunner.getLatestStep().get().getEventClass()); }
protected void setupWithRecordingModelRunner() { this.modelRunner = new ModelRunner().startRecording(); this.modelBuilder = Model.builder(); this.customer = modelBuilder.actor(CUSTOMER); this.displayedText = null; }
@Test public void printsTextAutonomouslyOnlyIfActorIsRightInSecondStep() { Model model = modelBuilder .useCase(USE_CASE) .basicFlow() .step(SYSTEM_DISPLAYS_TEXT).system(displaysConstantText()) .step(SYSTEM_DISPLAYS_TEXT_AGAIN).as(customer).system(displaysConstantText()) .build(); modelRunner.as(customer).run(model); assertRecordedStepNames(SYSTEM_DISPLAYS_TEXT, SYSTEM_DISPLAYS_TEXT_AGAIN); }
@Test public void testHelloWorld01() { HelloWorld01 example = new HelloWorld01(); model = example.buildWith(modelBuilder); modelRunner.run(model); assertRecordedStepNames("S1"); }
public void start() { ModelBuilder modelBuilder = Model.builder(); Model model = modelBuilder.useCase("Measure performance of simple mathematical operations") .basicFlow() .step("S1").system(this::addsTwoNumbers) .step("S2").system(this::calculatesTwoToThePowerOfAThousand) .step("S3").system(this::displaysResults).build(); ModelRunner modelRunner = new ModelRunner(); modelRunner.handleWith(this::measuresPerformance); modelRunner.run(model); }
@Test public void recordsStepWithEvent() { ReactionAsConsumer reactionAsConsumer = new ReactionAsConsumer(); Model model = modelBuilder.useCase(USE_CASE).condition(new AlwaysTrue()).on(EntersText.class) .system(reactionAsConsumer).build(); modelRunner.handleWith(recordStepDetails()); modelRunner.run(model); modelRunner.reactTo(entersText()); Object condition = optionalCondition.get(); assertTrue(condition instanceof AlwaysTrue); Object event = optionalEvent.get(); assertTrue(event instanceof EntersText); assertEquals(reactionAsConsumer, systemReaction); }
@Test public void recordsEventWithUnhandledEventHandler() { Model model = modelBuilder.useCase(USE_CASE).on(EntersText.class).system(displaysEnteredText()).build(); modelRunner.handleUnhandledWith(this::eventRecordingEventHandler); modelRunner.run(model); modelRunner.reactTo(entersNumber()); Object event = optionalEvent.get(); assertTrue(event instanceof EntersNumber); }
@Test public void doesNotReactToEventIfNotRunning() { Model model = modelBuilder .useCase(USE_CASE) .basicFlow() .step(CUSTOMER_ENTERS_TEXT).user(EntersText.class).system(displaysEnteredText()) .build(); modelRunner.run(model); modelRunner.stop(); Optional<Step> latestStepRun = modelRunner.reactTo(entersText()); assertFalse(latestStepRun.isPresent()); assertRecordedStepNames(new String[0]); }
@Test public void recordIsEmptyIfRecordingWasStoppedBeforeBeingStarted() { Model model = modelBuilder.useCase(USE_CASE) .on(EntersText.class).system(displaysEnteredText()) .build(); modelRunner.run(model).stopRecording(); assertEquals(0, modelRunner.getRecordedEvents().length); assertEquals(0, modelRunner.getRecordedStepNames().length); }
@Test public void recordIsEmptyForFreshlyRunModel() { Model model = modelBuilder.useCase(USE_CASE) .on(EntersText.class).system(displaysEnteredText()) .build(); modelRunner.run(model); assertEquals(0, modelRunner.getRecordedEvents().length); assertEquals(0, modelRunner.getRecordedStepNames().length); }
@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 recordsAutonomousSystemReactionStep() { stepName = ""; ReactionAsRunnable reactionAsRunnable = new ReactionAsRunnable(); Model model = modelBuilder.useCase(USE_CASE).basicFlow().step(SYSTEM_DISPLAYS_TEXT) .system(reactionAsRunnable).build(); modelRunner.handleWith(recordStepDetails()); modelRunner.run(model); assertRecordedStepNames(SYSTEM_DISPLAYS_TEXT); assertEquals(SYSTEM_DISPLAYS_TEXT, stepName); assertFalse(optionalEvent.isPresent()); assertFalse(optionalCondition.isPresent()); assertEquals(reactionAsRunnable, systemReaction); }