/** * Executes the {@link Runnable#run()} method on provided argument and verifies the expectations * @throws SniffyAssertionError if wrong number of queries was executed * @since 2.0 */ public C run(Runnable runnable) throws SniffyAssertionError { checkOpened(); try { runnable.run(); } catch (Throwable e) { throw verifyAndAddToException(e); } verify(); return self(); }
/** * Alias for {@link #verify()} method; it is useful for try-with-resource API: * <pre> * <code> * {@literal @}Test * public void testTryWithResourceApi() throws SQLException { * final Connection connection = DriverManager.getConnection("sniffer:jdbc:h2:mem:", "sa", "sa"); * try (@SuppressWarnings("unused") Spy s = Sniffer.expectAtMostOnce(); * Statement statement = connection.createStatement()) { * statement.execute("SELECT 1 FROM DUAL"); * } * } * } * </code> * </pre> * @since 2.0 */ public void close() { try { verify(); } finally { Sniffy.removeSpyReference(selfReference); closed = true; StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace(); closeStackTrace = new StackTraceElement[stackTrace.length - 1]; System.arraycopy(stackTrace, 1, closeStackTrace, 0, stackTrace.length - 1); } }
/** * Executes the {@link Callable#call()} method on provided argument and verifies the expectations * @throws SniffyAssertionError if wrong number of queries was executed * @since 2.0 */ public <V> SpyWithValue<V> call(Callable<V> callable) throws SniffyAssertionError { checkOpened(); V result; try { result = callable.call(); } catch (Throwable e) { throw verifyAndAddToException(e); } verify(); return new SpyWithValue<V>(result); }
/** * Alias for {@link #verify()} method; it is useful for try-with-resource API: * <pre> * <code> * {@literal @}Test * public void testTryWithResourceApi() throws SQLException { * final Connection connection = DriverManager.getConnection("sniffer:jdbc:h2:mem:", "sa", "sa"); * try (@SuppressWarnings("unused") Spy s = Sniffer.expectAtMostOnce(); * Statement statement = connection.createStatement()) { * statement.execute("SELECT 1 FROM DUAL"); * } * } * } * </code> * </pre> * @since 2.0 */ public void close() { try { verify(); } finally { Sniffy.removeSpyReference(selfReference); closed = true; StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace(); closeStackTrace = new StackTraceElement[stackTrace.length - 1]; System.arraycopy(stackTrace, 1, closeStackTrace, 0, stackTrace.length - 1); } }
/** * Executes the {@link Runnable#run()} method on provided argument and verifies the expectations * @throws SniffyAssertionError if wrong number of queries was executed * @since 2.0 */ public C run(Runnable runnable) throws SniffyAssertionError { checkOpened(); try { runnable.run(); } catch (Throwable e) { throw verifyAndAddToException(e); } verify(); return self(); }
private RuntimeException verifyAndAddToException(Throwable e) { try { verify(); } catch (SniffyAssertionError ae) { if (!ExceptionUtil.addSuppressed(e, ae)) { ae.printStackTrace(); } } throwException(e); return new RuntimeException(e); }
/** * Executes the {@link Callable#call()} method on provided argument and verifies the expectations * @throws SniffyAssertionError if wrong number of queries was executed * @since 2.0 */ public <V> SpyWithValue<V> call(Callable<V> callable) throws SniffyAssertionError { checkOpened(); V result; try { result = callable.call(); } catch (Throwable e) { throw verifyAndAddToException(e); } verify(); return new SpyWithValue<V>(result); }
private RuntimeException verifyAndAddToException(Throwable e) { try { verify(); } catch (SniffyAssertionError ae) { if (!ExceptionUtil.addSuppressed(e, ae)) { ae.printStackTrace(); } } throwException(e); return new RuntimeException(e); }
/** * Executes the {@link io.sniffy.Executable#execute()} method on provided argument and verifies the expectations * @throws SniffyAssertionError if wrong number of queries was executed * @since 3.1 */ @Override public C execute(io.sniffy.Executable executable) throws SniffyAssertionError { checkOpened(); try { executable.execute(); } catch (Throwable e) { throw verifyAndAddToException(e); } verify(); return self(); }
@Test public void testFunctionalApi() throws SQLException { // tag::testFunctionalApi[] final Connection connection = DriverManager.getConnection("sniffy:jdbc:h2:mem:", "sa", "sa"); // <1> Sniffy.execute( () -> connection.createStatement().execute("SELECT 1 FROM DUAL") ).verify(SqlQueries.atMostOneQuery()); // <2> // end::testFunctionalApi[] }
/** * Executes the {@link io.sniffy.Executable#execute()} method on provided argument and verifies the expectations * @throws SniffyAssertionError if wrong number of queries was executed * @since 3.1 */ @Override public C execute(io.sniffy.Executable executable) throws SniffyAssertionError { checkOpened(); try { executable.execute(); } catch (Throwable e) { throw verifyAndAddToException(e); } verify(); return self(); }
@Test public void testVerifyApi() throws SQLException { // tag::testVerifyApi[] Connection connection = DriverManager.getConnection("sniffy:jdbc:h2:mem:", "sa", "sa"); // <1> Spy<?> spy = Sniffy.spy(); // <2> connection.createStatement().execute("SELECT 1 FROM DUAL"); // <3> spy.verify(SqlQueries.atMostOneQuery()); // <4> spy.verify(SqlQueries.noneQueries().otherThreads()); // <5> // end::testVerifyApi[] }
@Test public void testRecordQueriesNegativeQueryType() throws Exception { try { Sniffer.run(BaseTest::executeStatement).verify(1, Query.INSERT); fail(); } catch (WrongNumberOfQueriesError e) { assertNotNull(e); } }
@Test public void testVerifyExact() throws Exception { // test positive Spy spy = Sniffy.spy(); executeStatement(); spy.verify(1); // test negative case 1 spy = Sniffy.spy(); try { spy.verify(1); fail(); } catch (WrongNumberOfQueriesError e) { assertNotNull(e); } // test negative case 2 spy = Sniffy.spy(); executeStatements(2); try { spy.verify(1); fail(); } catch (WrongNumberOfQueriesError e) { assertNotNull(e); } }
@Test public void testVerifyMultipleFailures() throws Exception { try { Sniffer.expectAtLeast(1, Threads.CURRENT).expectAtLeast(1, Threads.OTHERS).verify(); } catch (WrongNumberOfQueriesError e) { assertNotNull(e); assertNotNull(e.getCause()); assertTrue(WrongNumberOfQueriesError.class.isAssignableFrom(e.getCause().getClass())); assertNull(e.getCause().getCause()); } }
@Test public void testVerifyExact() throws Exception { // test positive case 1 Spy spy = Sniffy.spy(); executeStatement(); spy.verify(1, Threads.CURRENT); // test positive case 2 spy = Sniffy.spy(); executeStatement(); executeStatementInOtherThread(); spy.verify(1, Threads.CURRENT); // test negative case 1 spy = Sniffy.spy(); try { spy.verify(1, Threads.CURRENT); fail(); } catch (WrongNumberOfQueriesError e) { assertNotNull(e); } // test negative case 2 spy = Sniffy.spy(); executeStatement(); executeStatementInOtherThread(); try { spy.verify(2, Threads.CURRENT); fail(); } catch (WrongNumberOfQueriesError e) { assertNotNull(e); } }
@Test public void testSpyClosed() throws Exception { Spy spy = Sniffer.execute(() -> { executeStatement(); Thread thread = new Thread(BaseTest::executeStatement); thread.start(); thread.join(); }).expectAtMostOnce(Threads.OTHERS); spy.close(); try { spy.verify(1); } catch (Spy.SpyClosedException e) { assertNotNull(e); assertNotNull(e.getCloseStackTrace()); assertNotNull(e.getCloseStackTrace()[1]); StackTraceElement stackTraceElement = e.getCloseStackTrace()[1]; assertEquals("io.sniffy.SnifferTest", stackTraceElement.getClassName()); assertEquals("testSpyClosed", stackTraceElement.getMethodName()); } }
@Test public void testVerifyExactUpdate() throws Exception { // test positive Spy spy = Sniffy.spy(); executeStatement(Query.SELECT); executeStatement(Query.INSERT); executeStatement(Query.UPDATE); executeStatement(Query.DELETE); executeStatement(Query.MERGE); executeStatement(Query.OTHER); spy.verify(1, Query.UPDATE); spy.verify(6, Query.ANY); // test negative case 1 spy = Sniffy.spy(); try { spy.verify(1); fail(); } catch (WrongNumberOfQueriesError e) { assertNotNull(e); } // test negative case 2 spy = Sniffy.spy(); executeStatements(2, Query.UPDATE); try { spy.verify(1, Query.UPDATE); fail(); } catch (WrongNumberOfQueriesError e) { assertNotNull(e); } }