Setting up JNDI Datasource in jUnit
Solution 1:
I've found this Blog: https://blogs.oracle.com/randystuph/entry/injecting_jndi_datasources_for_junit
About H2 Datasource: http://www.h2database.com/javadoc/org/h2/jdbcx/JdbcConnectionPool.html
So for my Code:
package com.example.test;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.sql.DataSource;
import org.h2.jdbcx.JdbcConnectionPool;
import junit.framework.TestCase;
public class JunitDataSource extends TestCase {
public void setUp() throws Exception {
// rcarver - setup the jndi context and the datasource
try {
// Create initial context
System.setProperty(Context.INITIAL_CONTEXT_FACTORY, "org.apache.naming.java.javaURLContextFactory");
System.setProperty(Context.URL_PKG_PREFIXES, "org.apache.naming");
InitialContext ic = new InitialContext();
ic.createSubcontext("java:");
ic.createSubcontext("java:/comp");
ic.createSubcontext("java:/comp/env");
ic.createSubcontext("java:/comp/env/jdbc");
JdbcConnectionPool ds = JdbcConnectionPool.create(
"jdbc:h2:file:src/main/resources/test.db;FILE_LOCK=NO;MVCC=TRUE;DB_CLOSE_ON_EXIT=TRUE", "sa", "sasasa");
// Construct DataSource
// OracleConnectionPoolDataSource ds = new
// OracleConnectionPoolDataSource();
// ds.setURL("jdbc:oracle:thin:@host:port:db");
// ds.setUser("MY_USER_NAME");
// ds.setPassword("MY_USER_PASSWORD");
ic.bind("java:/mydatasourcename", ds);
} catch (NamingException ex) {
Logger.getLogger(JunitDataSource.class.getName()).log(Level.SEVERE, null, ex);
}
}
public void testSimple() throws Exception {
// Obtain our environment naming context
Context initCtx = new InitialContext();
// Look up our datasource
DataSource ds = (DataSource) initCtx.lookup("java:/mydatasourcename");
Connection conn = ds.getConnection();
Statement stmt = conn.createStatement();
ResultSet rset = stmt.executeQuery("SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES");
while (rset.next()) {
System.out.println("<<<\t"+rset.getString("TABLE_NAME"));
}
}
}
Note: I had to add Tomcat Library and the jars inside the Tomcat's bin directory to get it working
Solution 2:
I found that the best way to do it is to use something called Simple-Jndi.
I added this to the maven file:
<dependency>
<groupId>simple-jndi</groupId>
<artifactId>simple-jndi</artifactId>
<version>0.11.4.1</version>
<scope>test</scope>
</dependency>
You can download the the package here, the download contains an instruction manual. http://code.google.com/p/osjava/downloads/detail?name=simple-jndi-0.11.4.1.zip&can=2&q=
After adding to to your project you just have to add a couple of properties files, per the instructions.
However, after you add the dependency, I believe you can add your jndi resources programmatically instead of using properties files. You do something like this: (new InitialContext()).rebind("datasource",myDatasource);
Solution 3:
I have used Simple-JNDI for this purpose for years now. It gives you an in-memory implementation of a JNDI Service and allows you to populate the JNDI environment with objects defined in property files. There is also support for loading datasources or connection pools configured in a file.
To get a connection pool you have to create a file like this:
type=javax.sql.DataSource
driver=com.sybase.jdbc3.jdbc.SybDriver
pool=myDataSource
url=jdbc:sybase:Tds:servername:5000
user=user
password=password
In your application you can access the pool via
Context ctx = new InitialContext();
DataSource ds = (DataSource) ctx.lookup("path/to/your/connectionPool");
You can find more about it at https://github.com/h-thurow/Simple-JNDI.
TomcatJNDI helps with that situation too. It can process Tomcat’s configuration files and creates the same JNDI environment as Tomcat does, but without starting a server. So you can run classes with dependencies on Tomcat’s JNDI environment in e. g. JUnit tests.
TomcatJNDI tomcatJNDI = new TomcatJNDI();
tomcatJNDI.processContextXml(new File(“tomcat-root-dir/conf/context.xml”);
tomcatJNDI.start();
Then your classes can lookup the DataSource as when they would run in Tomcat.
More about TomcatJNDI can be found here: https://github.com/h-thurow/TomcatJNDI