@Test default void retryingListenerCallingDispatchShouldNotFail() { AtomicBoolean firstExecution = new AtomicBoolean(true); AtomicBoolean successfulRetry = new AtomicBoolean(false); MailboxListener listener = event -> { if (event.getEventId().equals(EVENT_ID)) { if (firstExecution.get()) { firstExecution.set(false); throw new RuntimeException(); } eventBus().dispatch(EVENT_2, NO_KEYS).block(); successfulRetry.set(true); } }; eventBus().register(listener, GROUP_A); eventBus().dispatch(EVENT, NO_KEYS).block(); WAIT_CONDITION.until(successfulRetry::get); }
public static EventId of(String serialized) { return of(UUID.fromString(serialized)); }
public MessageMoveEvent build() { Preconditions.checkNotNull(user, "'user' is mandatory"); Preconditions.checkNotNull(messageMoves, "'messageMoves' is mandatory"); return new MessageMoveEvent(eventId.orElse(EventId.random()), user, messageMoves, messageIds.build()); } }
@Test default void removeShouldKeepConsistencyWhenConcurrentRemove() throws Exception { EventDeadLetters eventDeadLetters = eventDeadLetters(); ImmutableMap<Integer, Group> groups = concurrentGroups(); ConcurrentHashMap<Integer, Event.EventId> storedEventIds = new ConcurrentHashMap<>(); ConcurrentTestRunner.builder() .operation((threadNumber, step) -> { int operationIndex = threadNumber * OPERATION_COUNT + step; Event.EventId eventId = Event.EventId.random(); storedEventIds.put(operationIndex, eventId); eventDeadLetters.store(groups.get(threadNumber), event(eventId)).subscribe(); }) .threadCount(THREAD_COUNT) .operationCount(OPERATION_COUNT) .runSuccessfullyWithin(RUN_SUCCESSFULLY_IN); ConcurrentTestRunner.builder() .operation((threadNumber, step) -> { int operationIndex = threadNumber * OPERATION_COUNT + step; eventDeadLetters.remove(groups.get(threadNumber), storedEventIds.get(operationIndex)); }) .threadCount(THREAD_COUNT) .operationCount(OPERATION_COUNT) .runSuccessfullyWithin(RUN_SUCCESSFULLY_IN); assertThat(allEventIds()) .isEmpty(); } }
@Test default void storeShouldKeepConsistencyWhenConcurrentStore() throws Exception { EventDeadLetters eventDeadLetters = eventDeadLetters(); ImmutableMap<Integer, Group> groups = concurrentGroups(); Multimap<Integer, Event.EventId> storedEventIds = Multimaps.synchronizedSetMultimap(HashMultimap.create()); ConcurrentTestRunner.builder() .operation((threadNumber, step) -> { Event.EventId eventId = Event.EventId.random(); storedEventIds.put(threadNumber, eventId); eventDeadLetters.store(groups.get(threadNumber), event(eventId)); }) .threadCount(THREAD_COUNT) .operationCount(OPERATION_COUNT) .runSuccessfullyWithin(RUN_SUCCESSFULLY_IN); groups.forEach((groupId, group) -> { Group storedGroup = groups.get(groupId); assertThat(eventDeadLetters.failedEventIds(storedGroup).toStream()) .hasSameElementsAs(storedEventIds.get(groupId)); }); } }
@Test void quotaUsageUpdatedEventShouldNotBeNoop() { MailboxListener.QuotaUsageUpdatedEvent event = new MailboxListener.QuotaUsageUpdatedEvent(Event.EventId.random(), BOB, QUOTA_ROOT, Quota.<QuotaCount>builder() .used(QUOTA_COUNT) .computedLimit(QuotaCount.unlimited()) .build(), Quota.<QuotaSize>builder() .used(QUOTA_SIZE) .computedLimit(QuotaSize.unlimited()) .build(), Instant.now()); assertThat(event.isNoop()).isFalse(); } }
public static EventId of(UUID uuid) { return new EventId(uuid); }
public static EventId random() { return new EventId(UUID.randomUUID()); }
@Test default void listenersShouldBeAbleToDispatch() { AtomicBoolean successfulRetry = new AtomicBoolean(false); MailboxListener listener = event -> { if (event.getEventId().equals(EVENT_ID)) { eventBus().dispatch(EVENT_2, NO_KEYS).block(); successfulRetry.set(true); } }; eventBus().register(listener, GROUP_A); eventBus().dispatch(EVENT, NO_KEYS).block(); WAIT_CONDITION.until(successfulRetry::get); }
@Test void expungedShouldNotBeNoopWhenNotEmpty() { MailboxListener.Expunged expunged = new MailboxListener.Expunged(SESSION_ID, BOB, PATH, MAILBOX_ID, ImmutableSortedMap.of(UID, META_DATA), Event.EventId.random()); assertThat(expunged.isNoop()).isFalse(); }
@Test void addedShouldBeNoopWhenEmpty() { MailboxListener.Added added = new MailboxListener.Added(SESSION_ID, BOB, PATH, MAILBOX_ID, ImmutableSortedMap.of(), Event.EventId.random()); assertThat(added.isNoop()).isTrue(); }
@Test void aclDiffWithDifferentAclShouldNotBeNoop() { MailboxListener.MailboxACLUpdated aclUpdated = new MailboxListener.MailboxACLUpdated(SESSION_ID, BOB, PATH, ACLDiff.computeDiff(ACL_1, ACL_2), MAILBOX_ID, Event.EventId.random()); assertThat(aclUpdated.isNoop()).isFalse(); }
@Test void aclDiffWithSameAclShouldBeNoop() { MailboxListener.MailboxACLUpdated aclUpdated = new MailboxListener.MailboxACLUpdated(SESSION_ID, BOB, PATH, ACLDiff.computeDiff(ACL_1, ACL_1), MAILBOX_ID, Event.EventId.random()); assertThat(aclUpdated.isNoop()).isTrue(); }
@Test default void registeredListenersShouldNotReceiveNoopEvents() throws Exception { MailboxListener listener = newListener(); eventBus().register(listener, KEY_1); MailboxListener.Added noopEvent = new MailboxListener.Added(MailboxSession.SessionId.of(18), User.fromUsername("bob"), MailboxPath.forUser("bob", "mailbox"), TestId.of(58), ImmutableSortedMap.of(), Event.EventId.random()); eventBus().dispatch(noopEvent, KEY_1).block(); verify(listener, after(FIVE_HUNDRED_MS.toMillis()).never()) .event(any()); }
@Test default void groupListenersShouldNotReceiveNoopEvents() throws Exception { MailboxListener listener = newListener(); eventBus().register(listener, GROUP_A); MailboxListener.Added noopEvent = new MailboxListener.Added(MailboxSession.SessionId.of(18), User.fromUsername("bob"), MailboxPath.forUser("bob", "mailbox"), TestId.of(58), ImmutableSortedMap.of(), Event.EventId.random()); eventBus().dispatch(noopEvent, NO_KEYS).block(); verify(listener, after(FIVE_HUNDRED_MS.toMillis()).never()) .event(any()); }
@Override public Mono<Void> remove(Group registeredGroup, Event.EventId failDeliveredEventId) { Preconditions.checkArgument(registeredGroup != null, REGISTERED_GROUP_CANNOT_BE_NULL); Preconditions.checkArgument(failDeliveredEventId != null, FAIL_DELIVERED_ID_EVENT_CANNOT_BE_NULL); return Flux.fromIterable(deadLetters.get(registeredGroup)) .filter(event -> event.getEventId().equals(failDeliveredEventId)) .next() .doOnNext(event -> deadLetters.remove(registeredGroup, event)) .subscribeWith(MonoProcessor.create()) .then(); }
@Test void renameWithDifferentNameShouldNotBeNoop() { MailboxListener.MailboxRenamed mailboxRenamed = new MailboxListener.MailboxRenamed(SESSION_ID, BOB, PATH, MAILBOX_ID, OTHER_PATH, Event.EventId.random()); assertThat(mailboxRenamed.isNoop()).isFalse(); }
@Override public Mono<Event> failedEvent(Group registeredGroup, Event.EventId failDeliveredEventId) { Preconditions.checkArgument(registeredGroup != null, REGISTERED_GROUP_CANNOT_BE_NULL); Preconditions.checkArgument(failDeliveredEventId != null, FAIL_DELIVERED_ID_EVENT_CANNOT_BE_NULL); return Flux.fromIterable(deadLetters.get(registeredGroup)) .filter(event -> event.getEventId().equals(failDeliveredEventId)) .next(); }
@Test void flagsUpdatedShouldBeNoopWhenEmpty() { MailboxListener.FlagsUpdated flagsUpdated = new MailboxListener.FlagsUpdated(SESSION_ID, BOB, PATH, MAILBOX_ID, ImmutableList.of(), Event.EventId.random()); assertThat(flagsUpdated.isNoop()).isTrue(); }