@Rule public SniffyRule sniffyRule = new SniffyRule();

    @Rule public ExpectedException thrown = ExpectedException.none();

    @Test
    @SqlExpectation(count = @Count(1))
    public void testExpectedOneQueryGotOne() throws SQLException {
        DriverManager.getConnection("sniffy:jdbc:h2:mem:", "sa", "sa").createStatement().execute("SELECT 1 FROM DUAL"); // (4)
    }

    @Test
    @SqlExpectation(count = @Count(max = 1), query = SqlStatement.SELECT)
    public void testExpectedNotMoreThanOneSelectGotTwo() throws SQLException {
        try (Statement statement = DriverManager.getConnection("sniffy:jdbc:h2:mem:", "sa", "sa").createStatement()) {
            statement.execute("SELECT 1 FROM DUAL");
            statement.execute("SELECT 2 FROM DUAL");
        }
        thrown.expect(WrongNumberOfQueriesError.class);
    }

    @Rule public SniffyRule sniffyRule = new SniffyRule();

    @Test
    @DisableSockets
    public void testDisableSockets() throws IOException {
        try {
            new Socket("google.com", 22);
            fail("Sniffy should have thrown ConnectException");
        } catch (ConnectException e) {
            assertNotNull(e);
        }
    }

    @Test
    public void testCaptureTraffic() throws Exception {

        try (Spy<?> spy = Sniffy.spy(
                SpyConfiguration.builder().captureNetworkTraffic(true).build()) // (1)
        ) {

            performSocketOperation(); // (2)

            Map<SocketMetaData, List<NetworkPacket>> networkTraffic = spy.getNetworkTraffic( // (3)
                    Threads.ANY, // (4)
                    AddressMatchers.anyAddressMatcher(), // (5)
                    GroupingOptions.builder().
                            groupByThread(false). // (6)
                            groupByStackTrace(false). // (7)
                            groupByConnection(false). // (8)
                            build()
            );

            assertEquals(1, networkTraffic.size());

            for (Map.Entry<SocketMetaData, List<NetworkPacket>> entry : networkTraffic.entrySet()) {

                SocketMetaData socketMetaData = entry.getKey(); // (9)

                Protocol protocol = socketMetaData.getProtocol(); // say TCP
                String hostName = socketMetaData.getAddress().getHostName(); // say "hostname.acme.com"
                int port = socketMetaData.getAddress().getPort(); // say 443

                List<NetworkPacket> networkPackets = entry.getValue(); // (10)

                assertArrayEquals(REQUEST, networkPackets.get(0).getBytes());
                assertTrue(networkPackets.get(0).isSent());

                assertArrayEquals(RESPONSE, networkPackets.get(1).getBytes());
                assertFalse(networkPackets.get(1).isSent());

            }

        }

    }

<filter>
    <filter-name>sniffer</filter-name>
    <filter-class>io.sniffy.servlet.SniffyFilter</filter-class>
    <async-supported>true</async-supported>
    <init-param>
        <param-name>enabled</param-name> (1)
        <param-value>true</param-value> <!-- default: true -->
    </init-param>
    <init-param>
        <param-name>exclude-pattern</param-name> (2)
        <param-value>^/vets.html$</param-value> <!-- optional -->
    </init-param>
    <init-param>
        <param-name>inject-html</param-name> (3)
        <param-value>true</param-value> <!-- default: true -->
    </init-param>
    <init-param>
        <param-name>inject-html-exclude-pattern</param-name> (4)
        <param-value>^/peds.html$</param-value> <!-- optional -->
    </init-param>
    <init-param>
        <param-name>monitor-socket</param-name> (5)
        <param-value>false</param-value> <!-- default: true -->
    </init-param>
</filter>
<filter-mapping>
    <filter-name>sniffer</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

<?xml version="1.0" encoding="UTF-8"?>
<module xmlns="urn:jboss:module:1.3" name="io.sniffy">

    <resources>
        <resource-root path="sniffy.jar"/>
    </resources>

    <dependencies>
        <!-- Try import some well known modules with JDBC drivers -->
        <module name="com.h2database.h2" optional="true"/>

        <module name="com.oracle" optional="true"/>
        <module name="oracle.jdbc" optional="true"/>
        <module name="com.oracle.jdbc" optional="true"/>
        <!-- insert a reference to module with your JDBC driver here -->

        <module name="javax.servlet.api" export="true"/>
        <module name="sun.jdk"/>
    </dependencies>
</module>

<datasources>
        <datasource jndi-name="java:jboss/datasources/ExampleDS" pool-name="ExampleDS" enabled="true" use-java-context="true">
            <connection-url>sniffy:jdbc:h2:mem:test;DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE</connection-url>
            <driver>sniffy</driver>
            <security>
                <user-name>sa</user-name>
                <password>sa</password>
            </security>
        </datasource>
        <drivers>
            <driver name="sniffy" module="io.sniffy">
                <xa-datasource-class>io.sniffy.sql.SniffyDataSource</xa-datasource-class>
            </driver>
        </drivers>
</datasources>

<jboss-deployment-structure>
    <deployment>
        <dependencies>
            <module name="io.sniffy"/>
        </dependencies>
    </deployment>
</jboss-deployment-structure>

<Resource name="jdbc/myoracle" auth="Container"
    type="javax.sql.DataSource" driverClassName="io.sniffy.sql.SniffyDriver"
    url="sniffy:jdbc:oracle:thin:@127.0.0.1:1521:mysid"
    username="scott" password="tiger" maxTotal="20" maxIdle="10"
    maxWaitMillis="-1"/>

        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)

        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)

        final Connection connection = DriverManager.getConnection("sniffy:jdbc:h2:mem:", "sa", "sa"); // (1)
        try (@SuppressWarnings("unused") Spy s = Sniffy. // (2)
                expect(SqlQueries.atMostOneQuery()).
                expect(SqlQueries.noneQueries().otherThreads());
             Statement statement = connection.createStatement()) {
            statement.execute("SELECT 1 FROM DUAL");
        }

        SharedConnectionDataSource sharedConnectionDataSource = new SharedConnectionDataSource(targetDataSource); // (1)

        sharedConnectionDataSource.setCurrentThreadAsMaster(); // (2)

        try (Connection masterConnection = sharedConnectionDataSource.getConnection(); // (3)
             Connection slaveConnection = newSingleThreadExecutor().submit(
                     (Callable<Connection>) sharedConnectionDataSource::getConnection).get() // (4)
        ) {
            assertEquals(masterConnection, slaveConnection); // (5)
        } finally {
            sharedConnectionDataSource.resetMasterConnection(); // (6)
        }

package io.sniffy.test.spring.usage;

import io.sniffy.test.spring.DataSourceTestConfiguration;
import io.sniffy.test.spring.EnableSharedConnection;
import io.sniffy.test.spring.SharedConnection;
import io.sniffy.test.spring.SniffySpringTestListener;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.test.annotation.Rollback;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.TestExecutionListeners;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;
import ru.yandex.qatools.allure.annotations.Features;

import java.sql.SQLException;
import java.util.Arrays;
import java.util.concurrent.ExecutionException;

import static java.util.concurrent.Executors.newSingleThreadExecutor;
import static org.junit.Assert.assertEquals;
import static org.springframework.test.context.TestExecutionListeners.MergeMode.MERGE_WITH_DEFAULTS;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {DataSourceTestConfiguration.class, SpringSharedConnectionUsageTest.class})
@TestExecutionListeners(value = SniffySpringTestListener.class, mergeMode = MERGE_WITH_DEFAULTS) // (1)
@EnableSharedConnection // (2)
@Transactional
@Rollback
public class SpringSharedConnectionUsageTest {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Test
    @SharedConnection // (3)
    @Features("issue/344")
    public void testSharedConnectionTwoRows() throws SQLException, ExecutionException, InterruptedException {

        jdbcTemplate.batchUpdate(
                "INSERT INTO PUBLIC.PROJECT (ID, NAME) VALUES (SEQ_PROJECT.NEXTVAL, ?)",
                Arrays.asList(new Object[]{"foo"}, new Object[]{"bar"})
        ); // (4)

        assertEquals(2, newSingleThreadExecutor().submit(
                () -> jdbcTemplate.queryForObject("SELECT COUNT(*) FROM PUBLIC.PROJECT", Integer.class) // (5)
        ).get().intValue());

    }

}

@TestExecutionListeners(value = SniffySpringTestListener.class, mergeMode = MERGE_WITH_DEFAULTS)

    @Test
    public void testCaptureTraffic() throws Exception {

        try (Spy<?> spy = Sniffy.spy(
                SpyConfiguration.builder().captureNetworkTraffic(true).build()) // (1)
        ) {

            performSocketOperation(); // (2)

            Map<SocketMetaData, List<NetworkPacket>> networkTraffic = spy.getNetworkTraffic( // (3)
                    Threads.ANY, // (4)
                    AddressMatchers.anyAddressMatcher(), // (5)
                    GroupingOptions.builder().
                            groupByThread(false). // (6)
                            groupByStackTrace(false). // (7)
                            groupByConnection(false). // (8)
                            build()
            );

            assertEquals(1, networkTraffic.size());

            for (Map.Entry<SocketMetaData, List<NetworkPacket>> entry : networkTraffic.entrySet()) {

                SocketMetaData socketMetaData = entry.getKey(); // (9)

                Protocol protocol = socketMetaData.getProtocol(); // say TCP
                String hostName = socketMetaData.getAddress().getHostName(); // say "hostname.acme.com"
                int port = socketMetaData.getAddress().getPort(); // say 443

                List<NetworkPacket> networkPackets = entry.getValue(); // (10)

                assertArrayEquals(REQUEST, networkPackets.get(0).getBytes());
                assertTrue(networkPackets.get(0).isSent());

                assertArrayEquals(RESPONSE, networkPackets.get(1).getBytes());
                assertFalse(networkPackets.get(1).isSent());

            }

        }

    }

Map<SocketMetaData, List<NetworkPacket>> decryptedNetworkTraffic = spy.getDecryptedNetworkTraffic(
        Threads.CURRENT,
        AddressMatchers.exactAddressMatcher("www.google.com:443"),
        GroupingOptions.builder().
                groupByConnection(false).
                groupByStackTrace(false).
                groupByThread(false).
                build()
);

sniffy:jdbc:h2:mem: