private static Map<Keyword, Object> createClojureMapFromResults(CheckerResult results) { List<Map<Keyword, Object>> errorsAsClojureHistory = convertEventListToClojureHistory(results.errors()); return ImmutableMap.of( Keyword.intern("valid?"), results.valid(), Keyword.intern("errors"), errorsAsClojureHistory); }
private Map<Keyword, Object> checkHistory(List<Event> events) { List<CheckerResult> allResults = checkers.stream() .map(checker -> checker.check(events)) .collect(Collectors.toList()); return createClojureMapFromResults(CheckerResult.combine(allResults)); }
public static CheckerResult combine(List<CheckerResult> results) { return ImmutableCheckerResult.builder() .valid(results.stream() .allMatch(CheckerResult::valid)) .errors(results.stream() .flatMap(result -> result.errors().stream()) .collect(Collectors.toList())) .build(); }
private CheckerResult combineResults(List<CheckerResult> results) { List<Event> allErrors = results.stream().flatMap(result -> result.errors().stream()).collect(Collectors.toList()); boolean allValid = results.stream().allMatch(CheckerResult::valid); return ImmutableCheckerResult.builder() .valid(allValid) .errors(allErrors) .build(); } }
@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 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 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 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 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 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 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); }