@Test
  public void testDisruptorCommandBusRepositoryNotAvailableOutsideOfInvokerThread() {
    DisruptorCommandBus commandBus = new DisruptorCommandBus(eventStore, eventBus);
    Repository<Aggregate> repository =
        commandBus.createRepository(new GenericAggregateFactory<Aggregate>(Aggregate.class));

    AggregateAnnotationCommandHandler<Aggregate> handler =
        new AggregateAnnotationCommandHandler<Aggregate>(Aggregate.class, repository);
    AggregateAnnotationCommandHandler.subscribe(handler, commandBus);
    DefaultCommandGateway gateway = new DefaultCommandGateway(commandBus);

    // Create the aggregate
    String aggregateId = "" + System.currentTimeMillis();
    gateway.sendAndWait(new CreateCommandAndEvent(aggregateId));

    // Load the aggretate from the repository -- from "worker" thread
    UnitOfWork uow = DefaultUnitOfWork.startAndGet();
    try {
      Aggregate aggregate = repository.load(aggregateId);
      fail("Expected IllegalStateException");
    } catch (IllegalStateException e) {
      assertTrue(e.getMessage().contains("DisruptorCommandBus"));
    } finally {
      uow.rollback();
    }
  }
 @Test(timeout = 10000)
 public void testCommandsAgainstInexistentAggregatesOnlyRetriedOnce() throws Throwable {
   inMemoryEventStore.storedEvents.clear();
   testSubject =
       new DisruptorCommandBus<StubAggregate>(
           new GenericAggregateFactory<StubAggregate>(StubAggregate.class),
           inMemoryEventStore,
           eventBus,
           new MetaDataCommandTargetResolver(TARGET_AGGREGATE_PROPERTY));
   stubHandler.setRepository(testSubject);
   StubHandler spy = spy(stubHandler);
   testSubject.subscribe(StubCommand.class, spy);
   List<CommandMessage<StubCommand>> dispatchedCommands =
       new ArrayList<CommandMessage<StubCommand>>();
   for (int i = 0; i < 10; i++) {
     CommandMessage<StubCommand> subsequentCommand =
         new GenericCommandMessage<StubCommand>(
             new StubCommand(aggregateIdentifier),
             singletonMap(TARGET_AGGREGATE_PROPERTY, (Object) aggregateIdentifier));
     testSubject.dispatch(subsequentCommand);
     dispatchedCommands.add(subsequentCommand);
   }
   testSubject.stop();
   assertTrue(inMemoryEventStore.storedEvents.isEmpty());
   for (CommandMessage<StubCommand> command : dispatchedCommands) {
     // subsequent commands could be retried more that once, as the aggregate they work in is
     // blacklisted
     verify(spy, atLeast(2)).handle(same(command), isA(UnitOfWork.class));
   }
 }
  @Test
  public void testCommandProcessedAndEventsStored() throws InterruptedException {
    testSubject =
        new DisruptorCommandBus<StubAggregate>(
            new GenericAggregateFactory<StubAggregate>(StubAggregate.class),
            inMemoryEventStore,
            eventBus,
            new MetaDataCommandTargetResolver(TARGET_AGGREGATE_PROPERTY));
    testSubject.subscribe(StubCommand.class, stubHandler);
    stubHandler.setRepository(testSubject);

    for (int i = 0; i < COMMAND_COUNT; i++) {
      CommandMessage<StubCommand> command =
          new GenericCommandMessage<StubCommand>(
              new StubCommand(aggregateIdentifier),
              singletonMap(TARGET_AGGREGATE_PROPERTY, (Object) aggregateIdentifier));
      testSubject.dispatch(command);
    }

    inMemoryEventStore.countDownLatch.await(5, TimeUnit.SECONDS);
    eventBus.publisherCountDown.await(1, TimeUnit.SECONDS);
    assertEquals(
        "Seems that some events are not published", 0, eventBus.publisherCountDown.getCount());
    assertEquals(
        "Seems that some events are not stored", 0, inMemoryEventStore.countDownLatch.getCount());
  }
  @Test
  public void testCreateAggregate() {
    inMemoryEventStore.storedEvents.clear();

    testSubject =
        new DisruptorCommandBus<StubAggregate>(
            new GenericAggregateFactory<StubAggregate>(StubAggregate.class),
            inMemoryEventStore,
            eventBus,
            new MetaDataCommandTargetResolver(TARGET_AGGREGATE_PROPERTY),
            new DisruptorConfiguration()
                .setClaimStrategy(new SingleThreadedClaimStrategy(8))
                .setWaitStrategy(new SleepingWaitStrategy()));
    testSubject.subscribe(StubCommand.class, stubHandler);
    testSubject.subscribe(CreateCommand.class, stubHandler);
    testSubject.subscribe(ErrorCommand.class, stubHandler);
    stubHandler.setRepository(testSubject);

    testSubject.dispatch(
        new GenericCommandMessage<Object>(
            new CreateCommand(aggregateIdentifier),
            singletonMap(TARGET_AGGREGATE_PROPERTY, (Object) aggregateIdentifier)));

    testSubject.stop();

    DomainEventMessage lastEvent = inMemoryEventStore.storedEvents.get(aggregateIdentifier);
    assertEquals(0, lastEvent.getSequenceNumber());
    assertEquals(aggregateIdentifier, lastEvent.getAggregateIdentifier());
  }
  @SuppressWarnings("unchecked")
  @Test
  public void testCallbackInvokedBeforeUnitOfWorkCleanup() throws Throwable {
    CommandHandlerInterceptor mockInterceptor = mock(CommandHandlerInterceptor.class);
    ExecutorService customExecutor = Executors.newCachedThreadPool();
    testSubject =
        new DisruptorCommandBus<StubAggregate>(
            new GenericAggregateFactory<StubAggregate>(StubAggregate.class),
            inMemoryEventStore,
            eventBus,
            new MetaDataCommandTargetResolver(TARGET_AGGREGATE_PROPERTY),
            new DisruptorConfiguration()
                .setInvokerInterceptors(Arrays.asList(mockInterceptor))
                .setClaimStrategy(new SingleThreadedClaimStrategy(8))
                .setWaitStrategy(new SleepingWaitStrategy())
                .setExecutor(customExecutor));
    testSubject.subscribe(StubCommand.class, stubHandler);
    stubHandler.setRepository(testSubject);
    final UnitOfWorkListener mockUnitOfWorkListener = mock(UnitOfWorkListener.class);
    when(mockUnitOfWorkListener.onEventRegistered(any(EventMessage.class)))
        .thenAnswer(
            new Answer<Object>() {
              @Override
              public Object answer(InvocationOnMock invocation) throws Throwable {
                return invocation.getArguments()[0];
              }
            });
    when(mockInterceptor.handle(
            any(CommandMessage.class), any(UnitOfWork.class), any(InterceptorChain.class)))
        .thenAnswer(
            new Answer<Object>() {
              @Override
              public Object answer(InvocationOnMock invocation) throws Throwable {
                ((UnitOfWork) invocation.getArguments()[1])
                    .registerListener(mockUnitOfWorkListener);
                return ((InterceptorChain) invocation.getArguments()[2]).proceed();
              }
            });
    CommandMessage<StubCommand> command =
        new GenericCommandMessage<StubCommand>(
            new StubCommand(aggregateIdentifier),
            singletonMap(TARGET_AGGREGATE_PROPERTY, (Object) aggregateIdentifier));
    CommandCallback mockCallback = mock(CommandCallback.class);
    testSubject.dispatch(command, mockCallback);

    testSubject.stop();
    assertFalse(customExecutor.awaitTermination(250, TimeUnit.MILLISECONDS));
    customExecutor.shutdown();
    assertTrue(customExecutor.awaitTermination(5, TimeUnit.SECONDS));
    InOrder inOrder = inOrder(mockInterceptor, mockUnitOfWorkListener, mockCallback);
    inOrder
        .verify(mockInterceptor)
        .handle(any(CommandMessage.class), any(UnitOfWork.class), any(InterceptorChain.class));
    inOrder.verify(mockUnitOfWorkListener).onPrepareCommit(any(Set.class), any(List.class));
    inOrder.verify(mockUnitOfWorkListener).afterCommit();
    inOrder.verify(mockUnitOfWorkListener).onCleanup();

    verify(mockCallback).onSuccess(any());
  }
  @Test(expected = IllegalStateException.class)
  public void testCommandRejectedAfterShutdown() throws InterruptedException {
    testSubject =
        new DisruptorCommandBus<StubAggregate>(
            new GenericAggregateFactory<StubAggregate>(StubAggregate.class),
            inMemoryEventStore,
            eventBus,
            new MetaDataCommandTargetResolver(TARGET_AGGREGATE_PROPERTY));
    testSubject.subscribe(StubCommand.class, stubHandler);
    stubHandler.setRepository(testSubject);

    testSubject.stop();
    testSubject.dispatch(new GenericCommandMessage<Object>(new Object()));
  }
 @After
 public void tearDown() {
   testSubject.stop();
 }
  private CommandCallback dispatchCommands(
      CommandHandlerInterceptor mockInterceptor,
      ExecutorService customExecutor,
      GenericCommandMessage<ErrorCommand> errorCommand)
      throws Throwable {
    inMemoryEventStore.storedEvents.clear();
    testSubject =
        new DisruptorCommandBus<StubAggregate>(
            new GenericAggregateFactory<StubAggregate>(StubAggregate.class),
            inMemoryEventStore,
            eventBus,
            new MetaDataCommandTargetResolver(TARGET_AGGREGATE_PROPERTY),
            new DisruptorConfiguration()
                .setInvokerInterceptors(Arrays.asList(mockInterceptor))
                .setClaimStrategy(new MultiThreadedClaimStrategy(8))
                .setWaitStrategy(new SleepingWaitStrategy())
                .setExecutor(customExecutor)
                .setRollbackConfiguration(new RollbackOnAllExceptionsConfiguration()));
    testSubject.subscribe(StubCommand.class, stubHandler);
    testSubject.subscribe(CreateCommand.class, stubHandler);
    testSubject.subscribe(ErrorCommand.class, stubHandler);
    stubHandler.setRepository(testSubject);
    final UnitOfWorkListener mockUnitOfWorkListener = mock(UnitOfWorkListener.class);
    when(mockUnitOfWorkListener.onEventRegistered(any(EventMessage.class)))
        .thenAnswer(
            new Answer<Object>() {
              @Override
              public Object answer(InvocationOnMock invocation) throws Throwable {
                return invocation.getArguments()[0];
              }
            });
    when(mockInterceptor.handle(
            any(CommandMessage.class), any(UnitOfWork.class), any(InterceptorChain.class)))
        .thenAnswer(
            new Answer<Object>() {
              @Override
              public Object answer(InvocationOnMock invocation) throws Throwable {
                ((UnitOfWork) invocation.getArguments()[1])
                    .registerListener(mockUnitOfWorkListener);
                return ((InterceptorChain) invocation.getArguments()[2]).proceed();
              }
            });
    testSubject.dispatch(
        new GenericCommandMessage<CreateCommand>(
            new CreateCommand(aggregateIdentifier),
            singletonMap(TARGET_AGGREGATE_PROPERTY, aggregateIdentifier)));
    CommandCallback mockCallback = mock(CommandCallback.class);
    for (int t = 0; t < 1000; t++) {
      CommandMessage command;
      if (t % 100 == 10) {
        command = errorCommand;
      } else {
        command =
            new GenericCommandMessage<StubCommand>(
                new StubCommand(aggregateIdentifier),
                singletonMap(TARGET_AGGREGATE_PROPERTY, (Object) aggregateIdentifier));
      }
      testSubject.dispatch(command, mockCallback);
    }

    testSubject.stop();
    return mockCallback;
  }