@Test
  public void testLoadEventsWithDecorators() {
    UUID identifier = UUID.randomUUID();
    SpyEventPreprocessor decorator1 = new SpyEventPreprocessor();
    SpyEventPreprocessor decorator2 = new SpyEventPreprocessor();
    testSubject.setEventStreamDecorators(Arrays.asList(decorator1, decorator2));
    when(mockEventStore.readEvents("test", identifier))
        .thenReturn(
            new SimpleDomainEventStream(
                new GenericDomainEventMessage<String>(
                    identifier, (long) 1, "Mock contents", MetaData.emptyInstance()),
                new GenericDomainEventMessage<String>(
                    identifier, (long) 2, "Mock contents", MetaData.emptyInstance()),
                new GenericDomainEventMessage<String>(
                    identifier, (long) 3, "Mock contents", MetaData.emptyInstance())));
    TestAggregate aggregate = testSubject.load(identifier);
    // loading them in...
    InOrder inOrder = Mockito.inOrder(decorator1.lastSpy, decorator2.lastSpy);
    inOrder.verify(decorator2.lastSpy).next();
    inOrder.verify(decorator1.lastSpy).next();

    inOrder.verify(decorator2.lastSpy).next();
    inOrder.verify(decorator1.lastSpy).next();

    inOrder.verify(decorator2.lastSpy).next();
    inOrder.verify(decorator1.lastSpy).next();
    aggregate.apply(new StubDomainEvent());
    aggregate.apply(new StubDomainEvent());
  }
  @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());
  }
示例#3
0
  @Test
  @Ignore("TODO: think about how to deal with this limitation")
  public void canRemoveListWithSameValuesAndDifferentOne() {
    diff(listWith("prems", "prems", "encore"), listWith("prems", "encore"));
    final InOrder inOrder = inOrder(dbObjectDiff);
    inOrder.verify(dbObjectDiff).pushKey("1");
    inOrder.verify(dbObjectDiff).addSet("prems");
    inOrder.verify(dbObjectDiff).popKey();
    reset(dbObjectDiff);

    diff(listWith("encore", "prems", "autre"), listWith("encore", "autre"));
    verify(dbObjectDiff).pushKey("1");
    reset(dbObjectDiff);
  }
示例#4
0
  @Test
  public void testJustWithScheduler() {
    TestScheduler scheduler = new TestScheduler();
    Observable<Integer> observable = Observable.fromArray(1, 2).subscribeOn(scheduler);

    Subscriber<Integer> observer = TestHelper.mockSubscriber();

    observable.subscribe(observer);

    scheduler.advanceTimeBy(1, TimeUnit.MILLISECONDS);

    InOrder inOrder = inOrder(observer);
    inOrder.verify(observer, times(1)).onNext(1);
    inOrder.verify(observer, times(1)).onNext(2);
    inOrder.verify(observer, times(1)).onComplete();
    inOrder.verifyNoMoreInteractions();
  }
  @Test
  public void testSaveEventsWithDecorators() {
    SpyEventPreprocessor decorator1 = new SpyEventPreprocessor();
    SpyEventPreprocessor decorator2 = new SpyEventPreprocessor();
    testSubject.setEventStreamDecorators(Arrays.asList(decorator1, decorator2));
    testSubject.setEventStore(
        new EventStore() {
          @Override
          public void appendEvents(String type, DomainEventStream events) {
            while (events.hasNext()) {
              events.next();
            }
          }

          @Override
          public DomainEventStream readEvents(String type, Object identifier) {
            return mockEventStore.readEvents(type, identifier);
          }
        });
    UUID identifier = UUID.randomUUID();
    when(mockEventStore.readEvents("test", identifier))
        .thenReturn(
            new SimpleDomainEventStream(
                new GenericDomainEventMessage<String>(
                    identifier, (long) 3, "Mock contents", MetaData.emptyInstance())));
    TestAggregate aggregate = testSubject.load(identifier);
    aggregate.apply(new StubDomainEvent());
    aggregate.apply(new StubDomainEvent());

    CurrentUnitOfWork.commit();

    InOrder inOrder = Mockito.inOrder(decorator1.lastSpy, decorator2.lastSpy);
    inOrder.verify(decorator1.lastSpy).next();
    inOrder.verify(decorator2.lastSpy).next();

    inOrder.verify(decorator1.lastSpy).next();
    inOrder.verify(decorator2.lastSpy).next();
  }