/** * Returns the model that has been built. * * @return the model */ public Model build() { return modelBuilder.build(); }
public Model build() { return stepPart.getModelBuilder().build(); }
@Test public void createsNoUseCase() { Model model = modelBuilder.build(); Collection<UseCase> useCases = model.getUseCases(); assertEquals(0, useCases.size()); }
@Test public void extractsEmptyStringFromEmptyModel() throws Exception { Model model = Model.builder().build(); String templateFileName = "testextract.ftl"; StringWriter outputWriter = new StringWriter(); engine.extract(model, templateFileName, outputWriter); String output = outputWriter.toString(); assertEquals("", output); }
@Test public void createsNoSteps() { modelBuilder.useCase(USE_CASE); Model model = modelBuilder.build(); UseCase useCase = model.findUseCase(USE_CASE); Collection<Step> steps = useCase.getSteps(); assertEquals(0, steps.size()); }
@Test public void createsTwoUseCasesInOneGo() { modelBuilder.useCase(USE_CASE); modelBuilder.useCase(USE_CASE_2); Model model = modelBuilder.build(); Collection<UseCase> useCases = model.getUseCases(); assertEquals(2, useCases.size()); }
@Test public void thereIsOnlyOneBasicFlowPerUseCase() { modelBuilder.useCase(USE_CASE); Model model = modelBuilder.build(); UseCase uc = model.findUseCase(USE_CASE); assertEquals(1, uc.getFlows().size()); }
@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 modelRunnerIsRunningAfterRunCall() { Model model = modelBuilder.build(); modelRunner.run(model); assertTrue(modelRunner.isRunning()); }
@Test public void implicitlyCreatesEmptyBasicFlow() { modelBuilder.useCase(USE_CASE); Model model = modelBuilder.build(); UseCase useCase = model.findUseCase(USE_CASE); Collection<Flow> flows = useCase.getFlows(); assertEquals(1, flows.size()); assertEquals(useCase.getBasicFlow(), flows.iterator().next()); assertFalse(useCase.getBasicFlow().getFirstStep().isPresent()); }
@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 rethrowsExceptionIfExceptionIsNotHandled() { thrown.expect(IllegalStateException.class); modelBuilder.useCase(USE_CASE).basicFlow().step(CUSTOMER_ENTERS_TEXT).system(() -> { throw new IllegalStateException(); }); Model model = modelBuilder.build(); modelRunner.run(model); }
@Test public void modelRunnerIsNotRunningWhenBeingStoppedAfterRunCall() { Model model = modelBuilder.build(); modelRunner.run(model); modelRunner.stop(); assertFalse(modelRunner.isRunning()); }
@Test public void modelRunnerIsRunningAfterRunCallAndRestart() { Model model = modelBuilder.build(); modelRunner.run(model); modelRunner.restart(); assertTrue(modelRunner.isRunning()); }
@Test public void modelRunnerIsRunningWhenBeingStoppedAndRestartedAfterRunCall() { Model model = modelBuilder.build(); modelRunner.run(model); modelRunner.stop(); modelRunner.restart(); assertTrue(modelRunner.isRunning()); } }
@Test public void throwsExceptionIfActorPartIsNotSpecified() { thrown.expect(MissingUseCaseStepPart.class); thrown.expectMessage(CUSTOMER_ENTERS_TEXT); modelBuilder.useCase(USE_CASE).basicFlow().step(CUSTOMER_ENTERS_TEXT); Model model = modelBuilder.build(); modelRunner.run(model); }
@Test public void throwsExceptionIfSystemPartIsNotSpecified() { thrown.expect(MissingUseCaseStepPart.class); thrown.expectMessage(CUSTOMER_ENTERS_TEXT); modelBuilder.useCase(USE_CASE).basicFlow().step(CUSTOMER_ENTERS_TEXT).as(customer) .user(EntersText.class); Model model = modelBuilder.build(); modelRunner.as(customer).run(model); modelRunner.reactTo(entersText()); }