private void start() { Model model = buildWith(Model.builder()); new ModelRunner().run(model); } }
StepPart(Step step, UseCasePart useCasePart, FlowPart useCaseFlowPart) { this.step = step; this.flowPart = useCaseFlowPart; this.modelBuilder = useCasePart.getModelBuilder(); this.userActor = modelBuilder.build().getUserActor(); this.systemActor = modelBuilder.build().getSystemActor(); }
/** * Creates a new actor in the current model. If an actor with the specified name * already exists, returns the existing actor. * * @param actorName * the name of the existing actor / actor to be created. * @return the created / found actor. */ public Actor actor(String actorName) { Actor actor = model.hasActor(actorName) ? model.findActor(actorName) : model.newActor(actorName); return actor; }
/** * Creates a new use case in the current model, and returns a part for building * its details. If a use case with the specified name already exists, returns a * part for the existing use case. * * @param useCaseName * the name of the existing use case / use case to be created. * @return the created / found use case's part. */ public UseCasePart useCase(String useCaseName) { UseCase useCase = model.hasUseCase(useCaseName) ? model.findUseCase(useCaseName) : model.newUseCase(useCaseName); return new UseCasePart(useCase, this); }
public static Actor getSystemActor(Step step) { return step.getModel().getSystemActor(); }
@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]); }
/** * Configures the runner to use the specified model. After you called * this method, the runner will accept events via {@link #reactTo(Object)}. * * <p> * As a side effect, this method immediately triggers "autonomous system * reactions". * * @param model * the model that defines the runner's behavior * @return the same model runner, for chaing with @see {@link #reactTo(Object...)} */ public ModelRunner run(Model model) { this.model = model; this.steps = model.getModifiableSteps(); this.includedUseCases = new LinkedList<>(); this.includeSteps = new LinkedList<>(); this.includedUseCase = null; this.includeStep = null; this.isRunning = true; Actor actor = user != null ? user : model.getUserActor(); as(actor).triggerAutonomousSystemReaction(); return this; }
@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()); }
public static Actor getUserActor(Step step) { return step.getModel().getUserActor(); }
@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]); }
@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()); }
/** * Includes the use case with the specified name. * * The runner starts the included use case right after the current step. The * runner returns to the current flow when it reaches the end of an included * flow. The runner then continues after the current step of the current flow. * * @param useCaseName * the name of the use case to include * @return the step system part, to ease creation of further steps and flows * @throws NoSuchElementInModel * if the included use case has not been specified before */ public StepSystemPart<ModelRunner> includesUseCase(String useCaseName) { FlowStep flowStep = (FlowStep) step; UseCase includedUseCase = flowStep.getModel().findUseCase(useCaseName); StepSystemPart<ModelRunner> stepSystemPart = as(systemActor) .system(new IncludesUseCase(includedUseCase, flowStep)); return stepSystemPart; }
@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 useCasesAreUniquelyIdentifiedByName() { UseCasePart useCasePart = modelBuilder.useCase(USE_CASE); Model model = useCasePart.basicFlow() .step(SYSTEM_DISPLAYS_TEXT).system(displaysConstantText()) .flow(ALTERNATIVE_FLOW) .step(SYSTEM_DISPLAYS_TEXT_AGAIN).system(displaysConstantText()).build(); assertEquals(1, model.getUseCases().size()); assertEquals(model.findUseCase(USE_CASE), model.getUseCases().iterator().next()); }
@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]); }
private List<Actor> userAndSystem(Actor userActor) { return Arrays.asList(userActor, userActor.getModel().getSystemActor()); }
@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 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 thereIsOnlyOneBasicFlowPerUseCase() { modelBuilder.useCase(USE_CASE); Model model = modelBuilder.build(); UseCase uc = model.findUseCase(USE_CASE); assertEquals(1, uc.getFlows().size()); }
@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]); }