Jak przetestować JNDI datasource ze sprężyną?

Możesz użyć SimpleNamingContextBuilder, aby udostępnić źródło danych jndi dla Twoich testów:

    SimpleNamingContextBuilder builder = new SimpleNamingContextBuilder();
    builder.bind("java:comp/env/jdbc/mydatasource", dataSource);
    builder.activate();

Https://fisheye.springsource.org/browse/spring-framework/spring-test/src/main/java/org/springframework/mock/jndi/SimpleNamingContextBuilder.java?hb=true

To nie jest dokładnie wyśmiewanie źródła danych, ale sprawia, że źródło danych jest dostępne za pośrednictwem jndi do testów.

Możesz stworzyć własne mock DataSource, rozszerzając AbstractDataSource Springa.

import java.sql.Connection;
import java.sql.SQLException;

import org.springframework.jdbc.datasource.AbstractDataSource;

/**
 * Mock implementation of DataSource suitable for use in testing.
 * 
 *
 */
public class MockDataSource extends AbstractDataSource {
    private Connection connection;

    /**
     * Sets the connection returned by javax.sql.DataSource#getConnection()
     * and javax.sql.DataSource#getConnection(java.lang.String, java.lang.String)
     * 
     * @param connection
     */
    public void setConnection(Connection connection) {
        this.connection = connection;
    }

    /*
     * (non-Javadoc)
     * @see javax.sql.DataSource#getConnection()
     */
    public Connection getConnection()
            throws SQLException {
        return connection;
    }

    /*
     * (non-Javadoc)
     * @see javax.sql.DataSource#getConnection(java.lang.String, java.lang.String)
     */
    public Connection getConnection(String username, String password)
            throws SQLException {
        return connection;
    }
}

Oddzieliłbym wyszukiwanie JNDI połączenia od reszty kodu. Wprowadź źródło danych do obiektów dostępu do danych (Daos) i użyj MockDataSource do testowania DAOs.

Zawsze możesz stworzyć fasolę.test.konfiguracja xml, gdzie po raz pierwszy odwołujesz się do fasolek.xml, a następnie nadpisać konfigurację datasource:

Src / main/resources / beans.xml

<!-- Database configuration -->
<import resource="beans.datasource.jndi.xml" />

Src / test/resources / beans.test.xml

<import resource="beans.xml" />
<import resource="beans.datasource.test.xml" />

Klasa Testu JUnit:

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { "classpath:/beans.test.xml" })
public class ASRTests
{
...
}

W Twoim JNDI Bean, zadeklaruj odniesienie

<jee:jndi-lookup expected-type="javax.sql.DataSource" id="mysqlDataSource" jndi-name="jdbc/mysql"/>

W Twoim teście zadeklaruj źródło danych

<bean id="mysqlDataSource" ...>
...
</bean>

Należy pamiętać, aby przenieść test datasource bean do folderu testowego.

Spring ' s org.springframework.jndi.JndiObjectFactoryBean najlepiej nadaje się do szukania JNDI. Zgodnie z jego dokumentacją, umożliwia wstrzykiwanie wartości domyślnych, jak również dla przypadków testowych spring based.

Zobacz poniższą konfigurację spring (nazwaną jako spring-test-db-config.xml)

<bean id="dataSource" class="oracle.jdbc.pool.OracleDataSource">
    <property name="URL" value="jdbc:oracle:thin:@localhost:1521:XE"/>
    <property name="user" value="UNITTEST"/>
    <property name="password" value="UNITTEST"/>
</bean>

<bean id="dataSourceFromJndi" class="org.springframework.jndi.JndiObjectFactoryBean">
    <!-- Any junk value will suffice as that is always gonna throw NamingException -->
    <property name="jndiName" value="jdbc/Ds"/>
    <property name="defaultObject" ref="dataSource"/>
</bean>

Dodaj bean zdefiniowany w innym pliku konfiguracyjnym odnosi się do dataSourceFromJndi bean

<!-- START OF SERVICES -->
<bean class="com.sample.Service" >
    <property name="dataSource" ref="dataSourceFromJndi" />
</bean>

Zaletą tego podejścia jest to, że można przechowywać 2 różne pliki konfiguracyjne DB - jeden do produkcji, a drugi do testów jednostkowych. Wystarczy zaimportować ten właściwy. Konfiguracja testowa będzie zawierać domyślny obiekt.

Java Config.....

Junit Test Case

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {DatabaseConfigStub.class}, loader= AnnotationConfigContextLoader.class)
public class DatabaseConfigTest  {

@Autowired
private DataSource datasource;
@Autowired
private JdbcTemplate jdbcTemplate;


@Before
public void setUp() throws Exception {

}

@After
public void tearDown() throws Exception {
}

@Test
public void testDataSource() {
    assertNotNull(datasource);
    assertNotNull(jdbcTemplate);
}

}

DatabaseConfigStub

public class DatabaseConfigStub {

private static final Logger log = Logger.getLogger(DatabaseConfigStub.class);

        private static final String DS_NAME = "jdbc/DS_NAME";

@Bean
DataSource dataSource() {
    JndiObjectFactoryBean jndiObjectBean = EasyMock.createMock(JndiObjectFactoryBean.class);
    jndiObjectBean.setJndiName(DS_NAME);
    jndiObjectBean.setResourceRef(true);
    jndiObjectBean.setProxyInterfaces(DataSource.class);

    EasyMock.expect( (DataSource)jndiObjectBean.getObject()).andReturn(new DataSource() {

            public <T> T unwrap(Class<T> iface) throws SQLException {
                // TODO Auto-generated method stub
                return null;
            }

            public boolean isWrapperFor(Class<?> iface) throws SQLException {
                // TODO Auto-generated method stub
                return false;
            }

            public void setLoginTimeout(int seconds) throws SQLException {
                // TODO Auto-generated method stub

            }

            public void setLogWriter(PrintWriter out) throws SQLException {
                // TODO Auto-generated method stub

            }

            public int getLoginTimeout() throws SQLException {
                // TODO Auto-generated method stub
                return 0;
            }

            public PrintWriter getLogWriter() throws SQLException {
                // TODO Auto-generated method stub
                return null;
            }

            public Connection getConnection(String username, String password)
                    throws SQLException {
                // TODO Auto-generated method stub
                return null;
            }

            public Connection getConnection() throws SQLException {
                // TODO Auto-generated method stub
                return null;
            }
        }
    );
    EasyMock.replay(jndiObjectBean);

    return (DataSource) jndiObjectBean.getObject();
}

@Bean
JdbcTemplate jdbcTemplate(){
    return new JdbcTemplate( dataSource());
}

}

Możesz również użyć Simple-JNDI. Jest to implementacja JNDI w pamięci do pracy z kontekstami JNDI poza kontenerem J2EE. Pozwala używać tego samego pliku definicji bean w produkcji i testach. Załóżmy, że to jest twoja definicja fasoli w produkcji:

<bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean">
    <property name="jndiName" value="java:comp/env/jdbc/DataSource"/>
</bean>
<bean id="dao" class="my.Dao">
    <property name="dataSource" ref="dataSource" />
</bean>

Utwórz plik właściwości w ten sposób

type=javax.sql.DataSource
driverClassName=org.gjt.mm.mysql.Driver
url=jdbc:mysql://localhost/testdb
username=user_name
password=password

Put Simple-JNDI i a jndi.Plik Właściwości z małą konfiguracją w ścieżce classpath. Następnie uzyskaj dostęp do źródła danych jak zwykle.

Więcej o Simple-JNDI jest znalezione tutaj.