/** * Exec can catch in case of an error. * @throws Exception If some problem inside */ @Test public void catchesExceptions() throws Exception { final Agent agent = Mockito.mock(Agent.class); final Events events = Mockito.mock(Events.class); Mockito.doThrow(new IOException("<bug>")).when(agent).push(events); new Exec(agent, events, new FkPipe()).run(); Mockito.verify(events).post( MockitoHamcrest.argThat( Matchers.startsWith( "Internal error (java.io.IOException): \"<bug>\"" ) ), MockitoHamcrest.argThat( Matchers.containsString( "java.io.IOException: <bug>\n" ) ) ); }
@Test public void testWarningSink() { final List<String> reasons = new ArrayList<>(); reasons.add("reason1"); reasons.add("reason2"); final Logger logger = Mockito.mock(Logger.class); final Event event = Mockito.mock(Event.class); final Sink sink = new WarningSink.Builder() .setReasons(reasons) .setLogger(logger) .build(); final String asString = sink.toString(); Assert.assertNotNull(asString); Assert.assertFalse(asString.isEmpty()); Assert.assertTrue(asString.contains(reasons.get(0))); Assert.assertTrue(asString.contains(reasons.get(1))); sink.record(event); Mockito.verifyZeroInteractions(event); Mockito.verify(logger).warn(MockitoHamcrest.argThat( Matchers.containsString(reasons.toString()))); }
@Test @SuppressFBWarnings("NP_NONNULL_PARAM_VIOLATION") public void testWarningSinkBuilderNullReasons() { final Logger logger = Mockito.mock(Logger.class); final Event event = Mockito.mock(Event.class); final Sink sink = new WarningSink.Builder() .setReasons(null) .setLogger(logger) .build(); sink.record(event); Mockito.verifyZeroInteractions(event); Mockito.verify(logger).warn(MockitoHamcrest.argThat( Matchers.containsString("Reasons must be a non-null list"))); }
/** * ExceptionDecor can transform exception to text. * @throws Exception If some problem */ @Test public void convertsExceptionToText() throws Exception { final Formattable decor = new ExceptionDecor(new IOException("ouch!")); final Appendable dest = Mockito.mock(Appendable.class); final Formatter fmt = new Formatter(dest); decor.formatTo(fmt, 0, 0, 0); Mockito.verify(dest).append( MockitoHamcrest.argThat( Matchers.allOf( Matchers.containsString( "java.io.IOException: ouch!" ), Matchers.containsString( "at com.jcabi.log.ExceptionDecorTest." ) ) ) ); }
private static DeliveryOptions withTimeout(final Long expectedTimeout) { return MockitoHamcrest.argThat(new FeatureMatcher<DeliveryOptions, Long>(IsEqual.equalTo(expectedTimeout), "timeout", "timeout") { @Override protected Long featureValueOf(DeliveryOptions deliveryOptions) { return deliveryOptions.getSendTimeout(); } }); }
@Test public void testCreateCounterNotOpen() { final org.slf4j.Logger logger = createSlf4jLoggerMock(); final Sink sink = Mockito.mock(Sink.class); @SuppressWarnings("resource") final TsdMetrics metrics = createTsdMetrics(logger, sink); metrics.close(); final Counter counter = metrics.createCounter("counter-closed"); Mockito.verify(logger).warn(MockitoHamcrest.argThat(Matchers.any(String.class))); Assert.assertNotNull(counter); }
@Test public void testIncrementCounterNotOpen() { final org.slf4j.Logger logger = createSlf4jLoggerMock(); final Sink sink = Mockito.mock(Sink.class); @SuppressWarnings("resource") final TsdMetrics metrics = createTsdMetrics(logger, sink); metrics.close(); metrics.incrementCounter("counter-closed"); Mockito.verify(logger).warn(MockitoHamcrest.argThat(Matchers.any(String.class))); }
@Test public void testResetCounterNotOpen() { final org.slf4j.Logger logger = createSlf4jLoggerMock(); final Sink sink = Mockito.mock(Sink.class); @SuppressWarnings("resource") final TsdMetrics metrics = createTsdMetrics(logger, sink); metrics.close(); metrics.resetCounter("counter-closed"); Mockito.verify(logger).warn(MockitoHamcrest.argThat(Matchers.any(String.class))); }
@Test public void testSetGaugeDoubleNotOpen() { final org.slf4j.Logger logger = createSlf4jLoggerMock(); final Sink sink = Mockito.mock(Sink.class); @SuppressWarnings("resource") final TsdMetrics metrics = createTsdMetrics(logger, sink); metrics.close(); metrics.setGauge("gauge-closed", 1.23); Mockito.verify(logger).warn(MockitoHamcrest.argThat(Matchers.any(String.class))); }
@Test public void testSetGaugeLongNotOpen() { final org.slf4j.Logger logger = createSlf4jLoggerMock(); final Sink sink = Mockito.mock(Sink.class); @SuppressWarnings("resource") final TsdMetrics metrics = createTsdMetrics(logger, sink); metrics.close(); metrics.setGauge("gauge-closed", 10L); Mockito.verify(logger).warn(MockitoHamcrest.argThat(Matchers.any(String.class))); }
@Test public void testCreateTimerNotOpen() { final org.slf4j.Logger logger = createSlf4jLoggerMock(); final Sink sink = Mockito.mock(Sink.class); @SuppressWarnings("resource") final TsdMetrics metrics = createTsdMetrics(logger, sink); metrics.close(); final Timer timer = metrics.createTimer("timer-closed"); Mockito.verify(logger).warn(MockitoHamcrest.argThat(Matchers.any(String.class))); Assert.assertNotNull(timer); }
@Test public void testSetTimerNotOpenTimeUnit() { final org.slf4j.Logger logger = createSlf4jLoggerMock(); final Sink sink = Mockito.mock(Sink.class); @SuppressWarnings("resource") final TsdMetrics metrics = createTsdMetrics(logger, sink); metrics.close(); metrics.setTimer("timer-closed", 1L, TimeUnit.MILLISECONDS); Mockito.verify(logger).warn(MockitoHamcrest.argThat(Matchers.any(String.class))); }
@Test public void testStartTimerNotOpen() { final org.slf4j.Logger logger = createSlf4jLoggerMock(); final Sink sink = Mockito.mock(Sink.class); @SuppressWarnings("resource") final TsdMetrics metrics = createTsdMetrics(logger, sink); metrics.close(); metrics.startTimer("timer-closed"); Mockito.verify(logger).warn(MockitoHamcrest.argThat(Matchers.any(String.class))); }
@Test public void testStopTimerNotOpen() { final org.slf4j.Logger logger = createSlf4jLoggerMock(); final Sink sink = Mockito.mock(Sink.class); @SuppressWarnings("resource") final TsdMetrics metrics = createTsdMetrics(logger, sink); metrics.close(); metrics.stopTimer("timer-closed"); Mockito.verify(logger).warn(MockitoHamcrest.argThat(Matchers.any(String.class))); }
@Test public void testAddAnnotationNotOpen() { final org.slf4j.Logger logger = createSlf4jLoggerMock(); final Sink sink = Mockito.mock(Sink.class); @SuppressWarnings("resource") final TsdMetrics metrics = createTsdMetrics(logger, sink); metrics.close(); metrics.addAnnotation("key", "value"); Mockito.verify(logger).warn(MockitoHamcrest.argThat(Matchers.any(String.class))); }
@Test public void testAddAnnotationsNotOpen() { final org.slf4j.Logger logger = createSlf4jLoggerMock(); final Sink sink = Mockito.mock(Sink.class); @SuppressWarnings("resource") final TsdMetrics metrics = createTsdMetrics(logger, sink); metrics.close(); // CHECKSTYLE.OFF: IllegalInstantiation - No Guava final Map<String, String> annotations = new HashMap<>(); // CHECKSTYLE.ON: IllegalInstantiation annotations.put("key1", "value1"); annotations.put("key2", "value2"); metrics.addAnnotations(annotations); Mockito.verify(logger).warn(MockitoHamcrest.argThat(Matchers.any(String.class))); }
@Test public void testCloseNotOpen() { final org.slf4j.Logger logger = createSlf4jLoggerMock(); final Sink sink = Mockito.mock(Sink.class); @SuppressWarnings("resource") final TsdMetrics metrics = createTsdMetrics(logger, sink); metrics.close(); Mockito.verifyZeroInteractions(logger); metrics.close(); Mockito.verify(logger).warn(MockitoHamcrest.argThat(Matchers.any(String.class))); }
@Test public void testStartTimerAlreadyStarted() { final org.slf4j.Logger logger = createSlf4jLoggerMock(); final Sink sink = Mockito.mock(Sink.class); final TsdMetrics metrics = createTsdMetrics(logger, sink); metrics.startTimer("timer-already-started"); metrics.startTimer("timer-already-started"); Mockito.verify(logger).warn(MockitoHamcrest.argThat(Matchers.any(String.class))); }
@Test public void testStopTimerNotStarted() { final org.slf4j.Logger logger = createSlf4jLoggerMock(); final Sink sink = Mockito.mock(Sink.class); final TsdMetrics metrics = createTsdMetrics(logger, sink); metrics.stopTimer("timer-not-started"); Mockito.verify(logger).warn(MockitoHamcrest.argThat(Matchers.any(String.class))); }
@Test public void testStopTimerAlreadyStopped() { final org.slf4j.Logger logger = createSlf4jLoggerMock(); final Sink sink = Mockito.mock(Sink.class); final TsdMetrics metrics = createTsdMetrics(logger, sink); metrics.startTimer("timer-already-stopped"); metrics.stopTimer("timer-already-stopped"); Mockito.verifyZeroInteractions(logger); metrics.stopTimer("timer-already-stopped"); Mockito.verify(logger).warn(MockitoHamcrest.argThat(Matchers.any(String.class))); }
@Test public void testIncrementAfterClose() { final AtomicBoolean isOpen = new AtomicBoolean(true); final Logger logger = Mockito.mock(Logger.class); final TsdCounter counter = new TsdCounter("counterName", isOpen, logger); counter.increment(); isOpen.set(false); Mockito.verifyZeroInteractions(logger); counter.increment(); Mockito.verify(logger).warn(MockitoHamcrest.argThat(Matchers.any(String.class))); }
@Test public void testIncrementByValueAfterClose() { final AtomicBoolean isOpen = new AtomicBoolean(true); final Logger logger = Mockito.mock(Logger.class); final TsdCounter counter = new TsdCounter("counterName", isOpen, logger); counter.increment(2L); isOpen.set(false); Mockito.verifyZeroInteractions(logger); counter.increment(2L); Mockito.verify(logger).warn(MockitoHamcrest.argThat(Matchers.any(String.class))); }
@Test public void testDecrementAfterClose() { final AtomicBoolean isOpen = new AtomicBoolean(true); final Logger logger = Mockito.mock(Logger.class); final TsdCounter counter = new TsdCounter("counterName", isOpen, logger); counter.decrement(); isOpen.set(false); Mockito.verifyZeroInteractions(logger); counter.decrement(); Mockito.verify(logger).warn(MockitoHamcrest.argThat(Matchers.any(String.class))); }
@Test public void testDecrementByValueAfterClose() { final AtomicBoolean isOpen = new AtomicBoolean(true); final Logger logger = Mockito.mock(Logger.class); final TsdCounter counter = new TsdCounter("counterName", isOpen, logger); counter.decrement(2L); isOpen.set(false); Mockito.verifyZeroInteractions(logger); counter.decrement(2L); Mockito.verify(logger).warn(MockitoHamcrest.argThat(Matchers.any(String.class))); }
@Test public void testAlreadyStopped() { final AtomicBoolean isOpen = new AtomicBoolean(true); final Logger logger = createSlf4jLoggerMock(); @SuppressWarnings("resource") final TsdTimer timer = new TsdTimer("timerName", isOpen, logger); timer.close(); Mockito.verifyZeroInteractions(logger); timer.close(); Mockito.verify(logger).warn(MockitoHamcrest.argThat(Matchers.any(String.class))); }
@Test public void testAlreadyStoppedRaceCondition() { final AtomicBoolean isOpen = new AtomicBoolean(true); final Logger logger = createSlf4jLoggerMock(); final StopWatch stopWatch = Mockito.mock(StopWatch.class); Mockito.doReturn(true).when(stopWatch).isRunning(); Mockito.doThrow(new IllegalStateException("Stopwatch already stopped")).when(stopWatch).stop(); @SuppressWarnings("resource") final TsdTimer timer = new TsdTimer("timerName", isOpen, stopWatch, logger); timer.close(); Mockito.verify(logger).warn(MockitoHamcrest.argThat(Matchers.any(String.class))); }
@Test public void testAlreadyAborted() { final AtomicBoolean isOpen = new AtomicBoolean(true); final Logger logger = createSlf4jLoggerMock(); @SuppressWarnings("resource") final TsdTimer timer = new TsdTimer("timerName", isOpen, logger); timer.abort(); Mockito.verifyZeroInteractions(logger); timer.abort(); Mockito.verify(logger).warn(MockitoHamcrest.argThat(Matchers.any(String.class))); }
@Test public void testStopAfterAbort() { final AtomicBoolean isOpen = new AtomicBoolean(true); final Logger logger = createSlf4jLoggerMock(); @SuppressWarnings("resource") final TsdTimer timer = new TsdTimer("timerName", isOpen, logger); timer.abort(); Mockito.verifyZeroInteractions(logger); timer.close(); Mockito.verify(logger).warn(MockitoHamcrest.argThat(Matchers.any(String.class))); }
@Test public void testAbortAfterStop() { final AtomicBoolean isOpen = new AtomicBoolean(true); final Logger logger = createSlf4jLoggerMock(); @SuppressWarnings("resource") final TsdTimer timer = new TsdTimer("timerName", isOpen, logger); timer.close(); Mockito.verifyZeroInteractions(logger); timer.abort(); Mockito.verify(logger).warn(MockitoHamcrest.argThat(Matchers.any(String.class))); }
@Test public void testStopAfterMetricsClosed() { final org.slf4j.Logger logger = createSlf4jLoggerMock(); final AtomicBoolean isOpen = new AtomicBoolean(true); @SuppressWarnings("resource") final TsdTimer timer = new TsdTimer("timerName", isOpen, logger); isOpen.set(false); Mockito.verify(logger, Mockito.never()).warn(MockitoHamcrest.argThat(Matchers.any(String.class))); timer.close(); Mockito.verify(logger).warn(MockitoHamcrest.argThat(Matchers.any(String.class))); }
@Test public void testAbortAfterMetricsClosed() { final org.slf4j.Logger logger = createSlf4jLoggerMock(); final AtomicBoolean isOpen = new AtomicBoolean(true); @SuppressWarnings("resource") final TsdTimer timer = new TsdTimer("timerName", isOpen, logger); isOpen.set(false); Mockito.verify(logger, Mockito.never()).warn(MockitoHamcrest.argThat(Matchers.any(String.class))); timer.abort(); Mockito.verify(logger).warn(MockitoHamcrest.argThat(Matchers.any(String.class))); }
@Test public void testGetElapsedAfterStop() { final org.slf4j.Logger logger = createSlf4jLoggerMock(); final AtomicBoolean isOpen = new AtomicBoolean(true); @SuppressWarnings("resource") final TsdTimer timer = new TsdTimer("timerName", isOpen, logger); Mockito.verify(logger, Mockito.never()).warn(MockitoHamcrest.argThat(Matchers.any(String.class))); timer.getValue(); Mockito.verify(logger).warn(MockitoHamcrest.argThat(Matchers.any(String.class))); timer.getUnit(); Mockito.verify(logger, Mockito.times(2)).warn(MockitoHamcrest.argThat(Matchers.any(String.class))); }
@Test public void testWarningSinkBuilderEmptyReasons() { final Logger logger = Mockito.mock(Logger.class); final Event event = Mockito.mock(Event.class); final Sink sink = new WarningSink.Builder() .setReasons(Collections.emptyList()) .setLogger(logger) .build(); sink.record(event); Mockito.verifyZeroInteractions(event); Mockito.verify(logger).warn(MockitoHamcrest.argThat( Matchers.containsString("Reasons must be a non-empty list"))); }
@Test @SuppressWarnings({"unchecked", "rawtypes"}) public void testStandardLogSecondTimeAfterDuration() throws InterruptedException { final Logger rateLimitLogger = new RateLimitLogger(_slf4jLogger, Duration.ofSeconds(1), Clock.systemUTC()); final Instant beforeLastLog = Instant.now(); rateLimitLogger.info("m1"); final Instant afterLastLog = Instant.now(); Mockito.verify(_slf4jLogger, Mockito.atLeastOnce()).isInfoEnabled(); Mockito.verify(_slf4jLogger).info( StenoMarker.ARRAY_MARKER, null, new String[]{"message", "_skipped", "_lastLogTime"}, new Object[]{"m1", 0, null}); Mockito.verifyNoMoreInteractions(_slf4jLogger); Thread.sleep(500); rateLimitLogger.info("m2"); // Rate limited but counted rateLimitLogger.debug("m3"); // Dropped and not counted Mockito.reset(_slf4jLogger); Mockito.doReturn(Boolean.TRUE).when(_slf4jLogger).isInfoEnabled(); Thread.sleep(1500); rateLimitLogger.info("m4"); Mockito.verify(_slf4jLogger, Mockito.atLeastOnce()).isInfoEnabled(); Mockito.verify(_slf4jLogger).info( MockitoHamcrest.argThat(Matchers.sameInstance(StenoMarker.ARRAY_MARKER)), MockitoHamcrest.argThat(Matchers.nullValue(String.class)), MockitoHamcrest.argThat(Matchers.arrayContaining("message", "_skipped", "_lastLogTime")), MockitoHamcrest.argThat( Matchers.array(new org.hamcrest.Matcher[]{ Matchers.<Object>equalTo("m4"), Matchers.<Object>equalTo(1), isBetween(beforeLastLog, afterLastLog)}))); }
/** * DocumentDecor can transform Document to text. * @throws Exception If some problem */ @Test public void convertsDocumentToText() throws Exception { final Document doc = DocumentBuilderFactory.newInstance() .newDocumentBuilder().newDocument(); doc.appendChild(doc.createElement("root")); final Formattable decor = new DomDecor(doc); final Appendable dest = Mockito.mock(Appendable.class); final Formatter fmt = new Formatter(dest); decor.formatTo(fmt, 0, 0, 0); Mockito.verify(dest).append( MockitoHamcrest.argThat(Matchers.containsString("<root/>")) ); }
public static Predicate predicateWithSelection(CharSequence expectedSelection) { return MockitoHamcrest.argThat(new PredicateMatcher.Selection(Absent.<TransactionContext>absent(), expectedSelection)); }
public static Predicate predicateWithSelection(TransactionContext tc, CharSequence expectedSelection) { return MockitoHamcrest.argThat(new PredicateMatcher.Selection(new Present<>(tc), expectedSelection)); }
@Test public void testLogBuilderSecondTimeAfterDuration() throws InterruptedException { final Logger rateLimitLogger = new RateLimitLogger(_slf4jLogger, Duration.ofSeconds(1), Clock.systemUTC()); final Instant beforeLastLog = Instant.now(); rateLimitLogger.info().setMessage("m1").log(); final Instant afterLastLog = Instant.now(); Mockito.verify(_slf4jLogger, Mockito.atLeastOnce()).isInfoEnabled(); Mockito.verify(_slf4jLogger).info( StenoMarker.LISTS_MARKER, null, Arrays.asList("message", "_skipped", "_lastLogTime"), Arrays.asList("m1", 0, null), Collections.emptyList(), Collections.emptyList()); Mockito.verifyNoMoreInteractions(_slf4jLogger); Thread.sleep(500); rateLimitLogger.info().setMessage("m2").log(); // Rate limited but counted rateLimitLogger.debug().setMessage("m3").log(); // Dropped and not counted Mockito.reset(_slf4jLogger); Mockito.doReturn(Boolean.TRUE).when(_slf4jLogger).isInfoEnabled(); Thread.sleep(1500); rateLimitLogger.info().setMessage("m4").log(); Mockito.verify(_slf4jLogger, Mockito.atLeastOnce()).isInfoEnabled(); Mockito.verify(_slf4jLogger).info( MockitoHamcrest.argThat(Matchers.sameInstance(StenoMarker.LISTS_MARKER)), MockitoHamcrest.argThat(Matchers.nullValue(String.class)), MockitoHamcrest.argThat(Matchers.contains("message", "_skipped", "_lastLogTime")), // This is brutal; for some reason a capture would not work here and the // contains(Matcher...) was getting mapped to contains(E...) even with // casting. So the matcher chain below manually asserts that the list // contains the three items in question. MockitoHamcrest.argThat( Matchers.allOf( Matchers.iterableWithSize(3), Matchers.hasItem("m4"), Matchers.hasItem(1), Matchers.hasItem(isBetween(beforeLastLog, afterLastLog)))), MockitoHamcrest.argThat(Matchers.equalTo(Collections.emptyList())), MockitoHamcrest.argThat(Matchers.equalTo(Collections.emptyList()))); }
@Test public void strikesWeakestCandidateIfNoCandidateReachedTheQuorum() { ImmutableList<VoteState<Candidate>> voteStates = ImmutableList.of( stateFor(AC_BALLOT), stateFor(A_BALLOT), stateFor(ACGH_BALLOT), stateFor(BC_BALLOT) ); ElectionStepResult<Candidate> electionStepResult = step .declareWinnerOrStrikeCandidate(FIVE, voteStates, redistributorMock, 1, CANDIDATE_STATES); verify(electionCalculationListenerMock).nobodyReachedTheQuorumYet(FIVE); verify(electionCalculationListenerMock).candidateDropped( argThat( is(aVoteDistribution(withVotesForCandidate(A, THREE), withVotesForCandidate(B, ONE), withVotesForCandidate(C, ZERO)))), eq(C) ); Matcher<Iterable<? extends VoteState<Candidate>>> newVoteStatesMatcher = containsInAnyOrder( aVoteState(allOf( withPreferredCandidate(A), withVoteWeight(ONE) )), aVoteState(allOf( withPreferredCandidate(A), withVoteWeight(ONE) )), aVoteState(allOf( withPreferredCandidate(A), withVoteWeight(ONE) )), aVoteState(allOf( withPreferredCandidate(B), withVoteWeight(ONE) )) ); verify(electionCalculationListenerMock) .voteWeightRedistributionCompleted(eq(voteStates), MockitoHamcrest.<ImmutableCollection>argThat((Matcher) newVoteStatesMatcher), argThat(is(aVoteDistribution( withVotesForCandidate(A, THREE), withVotesForCandidate(B, ONE), withNoVotes(ZERO), withInvalidVotes(ZERO))))); assertThat(electionStepResult, is(anElectionStepResult(allOf( withCandidateStates(withLooser(C)), withNumberOfElectedCandidates(is(1L)), withVoteStates(newVoteStatesMatcher) )))); }