コード例 #1
0
  @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
  public void testCreateOrder() throws InterruptedException {
    OrderId orderId = new OrderId();
    commandGateway.send(new CreateOrderCommand(orderId, "TestOrder"));

    UnitOfWork unitOfWork = unitOfWorkProvider.get();
    Assert.assertEquals(
        "Order is not created", orderRepository.load(orderId).getIdentifier(), orderId);
    unitOfWork.commit();

    ItemId itemId1 = new ItemId();
    commandGateway.send(new AddOrderItemCommand(orderId, itemId1, 10));

    final AtomicBoolean injectionSuccessful = new AtomicBoolean();
    commandGateway.send(
        new RemoveOrderItemCommand(orderId, itemId1),
        new CommandCallback<Boolean>() {
          @Override
          public void onSuccess(Boolean result) {
            injectionSuccessful.set(true);
          }

          @Override
          public void onFailure(Throwable cause) {
            logger.error("Error", cause);
          }
        });

    Assert.assertTrue(
        "Injection into @CommandHandler method is not successful", injectionSuccessful.get());
  }
コード例 #3
0
 @SuppressWarnings("unchecked")
 @Override
 public void run() {
   EventMessage<?> eventMessage = createMessage();
   if (logger.isInfoEnabled()) {
     logger.info(
         "Triggered the publication of event [{}]",
         eventMessage.getPayloadType().getSimpleName());
   }
   UnitOfWork unitOfWork = unitOfWorkFactory.createUnitOfWork();
   try {
     unitOfWork.publishEvent(eventMessage, eventBus);
     unitOfWork.commit();
   } finally {
     tokens.remove(tokenId);
   }
 }
コード例 #4
0
 @Override
 public Object handle(CommandMessage<?> command, UnitOfWork unitOfWork, InterceptorChain chain)
     throws Throwable {
   AuditingUnitOfWorkListener auditListener =
       new AuditingUnitOfWorkListener(command, auditDataProvider, auditLogger);
   unitOfWork.registerListener(auditListener);
   Object returnValue = chain.proceed();
   auditListener.setReturnValue(returnValue);
   return returnValue;
 }
コード例 #5
0
 @After
 public void tearDown() {
   if (unitOfWork.isStarted()) {
     unitOfWork.rollback();
   }
 }