@Test public void reportsInnerEventsAsOffending() { CheckerResult result = runNemesisResilienceChecker( NEMESIS_START, NEMESIS_START_2, NEMESIS_STOP, NEMESIS_STOP_2); assertThat(result.valid()).isFalse(); assertThat(result.errors()).containsExactly(NEMESIS_START_2, NEMESIS_STOP); }
@Test public void onlyReportsRelevantOffendingEvents() { CheckerResult result = runNemesisResilienceChecker( NEMESIS_START, INVOKE_1, OK_1, NEMESIS_STOP, NEMESIS_START_2, NEMESIS_STOP_2); assertThat(result.valid()).isFalse(); assertThat(result.errors()).containsExactly(NEMESIS_START_2, NEMESIS_STOP_2); }
@Test public void reportsMultipleOffendingNemesisEvents() { CheckerResult result = runNemesisResilienceChecker( NEMESIS_START, NEMESIS_STOP, NEMESIS_START_2, NEMESIS_STOP_2); assertThat(result.valid()).isFalse(); assertThat(result.errors()).containsExactly(NEMESIS_START, NEMESIS_STOP, NEMESIS_START_2, NEMESIS_STOP_2); }
@Test public void shouldSuceeedOnNoEvents() { CheckerResult result = runUniquenessChecker(); assertThat(result.valid()).isTrue(); assertThat(result.errors()).isEmpty(); }
@Test public void shouldSucceedOnNoEvents() { CheckerResult result = runChecker(); assertThat(result.valid()).isTrue(); assertThat(result.errors()).isEmpty(); }
@Test public void failsOnDistributedCycle() { CheckerResult result = runNemesisResilienceChecker( NEMESIS_START, INVOKE_1, NEMESIS_STOP, NEMESIS_START_2, OK_1, NEMESIS_STOP_2); assertThat(result.valid()).isFalse(); assertThat(result.errors()).containsExactly(NEMESIS_START, NEMESIS_STOP, NEMESIS_START_2, NEMESIS_STOP_2); }
@Test public void shouldSucceedOnNoEvents() { CheckerResult result = runMonotonicChecker(); assertThat(result.valid()).isTrue(); assertThat(result.errors()).isEmpty(); }
@Test public void failsIfCycleNotBetweenInnermostEvents() { CheckerResult result = runNemesisResilienceChecker( NEMESIS_START, INVOKE_1, NEMESIS_START_2, OK_1, INVOKE_2, NEMESIS_STOP, OK_2, NEMESIS_STOP_2); assertThat(result.valid()).isFalse(); assertThat(result.errors()).containsExactly(NEMESIS_START_2, NEMESIS_STOP); }
@Test public void cannotRefreshWithoutLock() { ImmutableList<Event> eventList = ImmutableList.<Event>builder() .add(TestEventUtils.invokeRefresh(0, PROCESS_1)) .add(TestEventUtils.refreshSuccess(1, PROCESS_1)) .add(TestEventUtils.invokeRefresh(2, PROCESS_1, "alternate_lock")) .add(TestEventUtils.refreshFailure(3, PROCESS_1)) .build(); CheckerResult result = runIsolatedProcessRefreshSuccessChecker(eventList); assertThat(result.valid()).isFalse(); assertThat(result.errors()).containsExactly(eventList.get(0), eventList.get(1)); }
@Test public void cannotRefreshWithWrongLock() { ImmutableList<Event> eventList = ImmutableList.<Event>builder() .add(TestEventUtils.invokeLock(0, PROCESS_1)) .add(TestEventUtils.lockSuccess(1, PROCESS_1)) .add(TestEventUtils.invokeRefresh(2, PROCESS_1, "alternate_lock")) .add(TestEventUtils.refreshSuccess(3, PROCESS_1)) .build(); CheckerResult result = runIsolatedProcessRefreshSuccessChecker(eventList); assertThat(result.valid()).isFalse(); assertThat(result.errors()).containsExactly(eventList.get(2), eventList.get(3)); }
@Test public void cannotRefreshAfterLockFailure() { ImmutableList<Event> eventList = ImmutableList.<Event>builder() .add(TestEventUtils.invokeLock(0, PROCESS_1)) .add(TestEventUtils.lockFailure(1, PROCESS_1)) .add(TestEventUtils.invokeRefresh(2, PROCESS_1)) .add(TestEventUtils.refreshSuccess(3, PROCESS_1)) .build(); CheckerResult result = runIsolatedProcessRefreshSuccessChecker(eventList); assertThat(result.valid()).isFalse(); assertThat(result.errors()).containsExactly(eventList.get(1), eventList.get(3)); }
@Test public void infoEventsAreNotLost() { InfoEvent infoEvent = TestEventUtils.createInfoEvent(0, PROCESS_1, RequestType.LOCK); CheckerResult checkerResult = runPartitionChecker(() -> identityChecker, ImmutableList.<Event>of(infoEvent)); assertThat(checkerResult.valid()).isFalse(); assertThat(checkerResult.errors()).containsExactly(infoEvent); }
@Test public void partitioningOnlyReordersEvents() { CheckerResult checkerResult = runPartitionChecker(() -> identityChecker, eventList); assertThat(checkerResult.valid()).isFalse(); assertThat(checkerResult.errors().size()).isEqualTo(eventList.size()); assertThat(checkerResult.errors()).containsOnlyElementsOf(eventList); }
@Test public void cannotRefreshAfterUnlockFailure() { ImmutableList<Event> eventList = ImmutableList.<Event>builder() .add(TestEventUtils.invokeLock(0, PROCESS_1)) .add(TestEventUtils.lockSuccess(1, PROCESS_1)) .add(TestEventUtils.invokeUnlock(2, PROCESS_1)) .add(TestEventUtils.unlockFailure(3, PROCESS_1)) .add(TestEventUtils.invokeRefresh(4, PROCESS_1)) .add(TestEventUtils.refreshSuccess(5, PROCESS_1)) .build(); CheckerResult result = runIsolatedProcessRefreshSuccessChecker(eventList); assertThat(result.valid()).isFalse(); assertThat(result.errors()).containsExactly(eventList.get(3), eventList.get(5)); }
@Test public void shouldFailIfSameValueAppearsOnTwoProcesses() { Event event1 = TestEventUtils.timestampOk(ZERO_TIME, PROCESS_0, VALUE_A); Event event2 = TestEventUtils.timestampOk(ZERO_TIME, PROCESS_1, VALUE_A); CheckerResult result = runUniquenessChecker(event1, event2); assertThat(result.valid()).isFalse(); assertThat(result.errors()).containsExactly(event1, event2); }
@Test public void partitionsRetainRelativeOrdering() { CheckerResult checkerResult = runPartitionChecker(() -> filterChecker(LOCK_2), eventList); assertThat(checkerResult.valid()).isFalse(); assertThat(checkerResult.errors()).containsExactlyElementsOf(onlyLock2EventList); }
@Test public void shouldRecordFourEventsIfThreeEqualValues() { long time = 0; Event event1 = TestEventUtils.timestampOk(time++, PROCESS_0, VALUE_A); Event event2 = TestEventUtils.timestampOk(time++, PROCESS_0, VALUE_A); Event event3 = TestEventUtils.timestampOk(time++, PROCESS_0, VALUE_A); CheckerResult result = runUniquenessChecker(event1, event2, event3); assertThat(result.valid()).isFalse(); assertThat(result.errors()).containsExactly(event1, event2, event2, event3); }
@Test public void shouldFailIfSameValueAppearsAfterDifferentValue() { long time = 0; Event event1 = TestEventUtils.timestampOk(time++, PROCESS_0, VALUE_A); Event event2 = TestEventUtils.timestampOk(time++, PROCESS_1, VALUE_B); Event event3 = TestEventUtils.timestampOk(time++, PROCESS_1, VALUE_A); CheckerResult result = runUniquenessChecker(event1, event2, event3); assertThat(result.valid()).isFalse(); assertThat(result.errors()).containsExactly(event1, event3); }
@Test public void shouldFailOnDecreasingConfirmedReadsOnOneProcess() { long time = 0; Event event1 = TestEventUtils.invokeTimestamp(time++, PROCESS_0); Event event2 = TestEventUtils.timestampOk(time++, PROCESS_0, "1"); Event event3 = TestEventUtils.invokeTimestamp(time++, PROCESS_0); Event event4 = TestEventUtils.timestampOk(time++, PROCESS_0, "0"); CheckerResult result = runChecker(event1, event2, event3, event4); assertThat(result.valid()).isFalse(); assertThat(result.errors()).containsExactly(event2, event3, event4); }
@Test public void shouldFailOnEqualConfirmedReads() { long time = 0; Event event1 = TestEventUtils.invokeTimestamp(time++, PROCESS_0); Event event2 = TestEventUtils.timestampOk(time++, PROCESS_0, "0"); Event event3 = TestEventUtils.invokeTimestamp(time++, PROCESS_0); Event event4 = TestEventUtils.timestampOk(time++, PROCESS_0, "0"); CheckerResult result = runChecker(event1, event2, event3, event4); assertThat(result.valid()).isFalse(); assertThat(result.errors()).containsExactly(event2, event3, event4); }