private CheckerResult runChecker(List<Event> history) { Checker checker = checkerSupplier.get(); return checker.check(history); }
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)); }
private static CheckerResult runIsolatedProcessRefreshSuccessChecker(List<Event> events) { Checker isolatedProcessCorrectnessChecker = new PartitionByInvokeNameCheckerHelper(IsolatedProcessCorrectnessChecker::new); return isolatedProcessCorrectnessChecker.check(events); }
private static CheckerResult runLockCorrectnessChecker(ImmutableList<Event> events) { Checker lockCorrectnessChecker = new PartitionByInvokeNameCheckerHelper(LockCorrectnessChecker::new); return lockCorrectnessChecker.check(events); }
private static CheckerResult runRefreshCorrectnessChecker(ImmutableList<Event> events) { Checker refreshCorrectnessChecker = new PartitionByInvokeNameCheckerHelper(RefreshCorrectnessChecker::new); return refreshCorrectnessChecker.check(events); }
public static void assertNoErrors(Supplier<Checker> checker, List<Event> events) { CheckerResult result = checker.get().check(events); assertThat(result.valid()).isTrue(); assertThat(result.errors()).isEmpty(); } }
/** * This method generates a mocked Checker that returns the entire list of Events if and only if all Events in the * list are related to the specified lock name, and there is at least one InvokeEvent. * @param lockName The lock name to filter for * @return mocked Checker */ private Checker filterChecker(String lockName) { Checker mockChecker = Mockito.mock(Checker.class); Mockito.when(mockChecker.check(Matchers.anyListOf(Event.class))).then( args -> { List<Event> events = (List) args.getArguments()[0]; return checkLockName(lockName, events); }); return mockChecker; }
@Test public void universalSuccessCheckerShouldSucceedOnNoEvents() { Checker universalChecker = Mockito.mock(Checker.class); Mockito.when(universalChecker.check(Matchers.anyList())).thenReturn(validResult); assertNoError(() -> universalChecker, ImmutableList.<Event>of()); }
private Checker createMockedChecker(boolean valid, Map<Keyword, ?> ... errors) { List<Map<Keyword, ?>> listOfErrors = ImmutableList.copyOf(errors); List<Event> listOfErrorsAsEvents = listOfErrors.stream() .map(Event::fromKeywordMap) .collect(Collectors.toList()); Checker checker = mock(Checker.class); CheckerResult result = ImmutableCheckerResult.builder() .valid(valid) .errors(listOfErrorsAsEvents) .build(); when(checker.check(any())).thenReturn(result); return checker; } }
@Test public void universalSuccessCheckerShouldSucceed() { Checker universalChecker = Mockito.mock(Checker.class); Mockito.when(universalChecker.check(Matchers.anyList())).thenReturn(validResult); assertNoError(() -> universalChecker, eventList); }