jars_archive/mysql-connector-java-5.1.10/src/testsuite/regression/DataSourceRegressionTest.java

/*
 Copyright  2002-2006 MySQL AB, 2008 Sun Microsystems

 This program is free software; you can redistribute it and/or modify
 it under the terms of version 2 of the GNU General Public License as 
 published by the Free Software Foundation.

 There are special exceptions to the terms and conditions of the GPL 
 as it is applied to this software. View the full text of the 
 exception in file EXCEPTIONS-CONNECTOR-J in the directory of this 
 software distribution.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA



 */
package testsuite.regression;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Method;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Hashtable;

import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.Name;
import javax.naming.NameParser;
import javax.naming.RefAddr;
import javax.naming.Reference;
import javax.naming.spi.ObjectFactory;
import javax.sql.ConnectionPoolDataSource;
import javax.sql.DataSource;
import javax.sql.PooledConnection;

import testsuite.BaseTestCase;
import testsuite.simple.DataSourceTest;

import com.mysql.jdbc.ConnectionProperties;
import com.mysql.jdbc.NonRegisteringDriver;
import com.mysql.jdbc.integration.jboss.MysqlValidConnectionChecker;
import com.mysql.jdbc.jdbc2.optional.MysqlConnectionPoolDataSource;
import com.mysql.jdbc.jdbc2.optional.MysqlDataSource;
import com.mysql.jdbc.jdbc2.optional.MysqlDataSourceFactory;
import com.mysql.jdbc.jdbc2.optional.MysqlXADataSource;

/**
 * Tests fixes for bugs related to datasources.
 * 
 * @author Mark Matthews
 * 
 * @version $Id: DataSourceRegressionTest.java,v 1.1.2.1 2005/05/13 18:58:38
 *          mmatthews Exp $
 */
public class DataSourceRegressionTest extends BaseTestCase {

	public final static String DS_DATABASE_PROP_NAME = "com.mysql.jdbc.test.ds.db";

	public final static String DS_HOST_PROP_NAME = "com.mysql.jdbc.test.ds.host";

	public final static String DS_PASSWORD_PROP_NAME = "com.mysql.jdbc.test.ds.password";

	public final static String DS_PORT_PROP_NAME = "com.mysql.jdbc.test.ds.port";

	public final static String DS_USER_PROP_NAME = "com.mysql.jdbc.test.ds.user";

	private Context ctx;

	private File tempDir;

	/**
	 * Creates a new DataSourceRegressionTest suite for the given test name
	 * 
	 * @param name
	 *            the name of the testcase to run.
	 */
	public DataSourceRegressionTest(String name) {
		super(name);
	}

	/**
	 * Runs all test cases in this test suite
	 * 
	 * @param args
	 */
	public static void main(String[] args) {
		junit.textui.TestRunner.run(DataSourceTest.class);
	}

	/**
	 * Sets up this test, calling registerDataSource() to bind a DataSource into
	 * JNDI, using the FSContext JNDI provider from Sun
	 * 
	 * @throws Exception
	 *             if an error occurs.
	 */
	public void setUp() throws Exception {
		super.setUp();
		createJNDIContext();
	}

	/**
	 * Un-binds the DataSource, and cleans up the filesystem
	 * 
	 * @throws Exception
	 *             if an error occurs
	 */
	public void tearDown() throws Exception {
		this.ctx.unbind(this.tempDir.getAbsolutePath() + "/test");
		this.ctx.unbind(this.tempDir.getAbsolutePath() + "/testNoUrl");
		this.ctx.close();
		this.tempDir.delete();

		super.tearDown();
	}

	/**
	 * Tests fix for BUG#4808- Calling .close() twice on a PooledConnection
	 * causes NPE.
	 * 
	 * @throws Exception
	 *             if an error occurs.
	 */
	public void testBug4808() throws Exception {
		MysqlConnectionPoolDataSource ds = new MysqlConnectionPoolDataSource();
		ds.setURL(BaseTestCase.dbUrl);
		PooledConnection closeMeTwice = ds.getPooledConnection();
		closeMeTwice.close();
		closeMeTwice.close();

	}

	/**
	 * Tests fix for Bug#3848, port # alone parsed incorrectly
	 * 
	 * @throws Exception
	 *             ...
	 */
	public void testBug3848() throws Exception {
		String jndiName = "/testBug3848";

		String databaseName = System.getProperty(DS_DATABASE_PROP_NAME);
		String userName = System.getProperty(DS_USER_PROP_NAME);
		String password = System.getProperty(DS_PASSWORD_PROP_NAME);
		String port = System.getProperty(DS_PORT_PROP_NAME);

		// Only run this test if at least one of the above are set
		if ((databaseName != null) || (userName != null) || (password != null)
				|| (port != null)) {
			MysqlConnectionPoolDataSource ds = new MysqlConnectionPoolDataSource();

			if (databaseName != null) {
				ds.setDatabaseName(databaseName);
			}

			if (userName != null) {
				ds.setUser(userName);
			}

			if (password != null) {
				ds.setPassword(password);
			}

			if (port != null) {
				ds.setPortNumber(Integer.parseInt(port));
			}

			bindDataSource(jndiName, ds);

			ConnectionPoolDataSource boundDs = null;

			try {
				boundDs = (ConnectionPoolDataSource) lookupDatasourceInJNDI(jndiName);

				assertTrue("Datasource not bound", boundDs != null);

				Connection dsConn = null;

				try {
					dsConn = boundDs.getPooledConnection().getConnection();
				} finally {
					if (dsConn != null) {
						dsConn.close();
					}
				}
			} finally {
				if (boundDs != null) {
					this.ctx.unbind(jndiName);
				}
			}
		}
	}

	/**
	 * Tests that we can get a connection from the DataSource bound in JNDI
	 * during test setup
	 * 
	 * @throws Exception
	 *             if an error occurs
	 */
	public void testBug3920() throws Exception {
		String jndiName = "/testBug3920";

		String databaseName = System.getProperty(DS_DATABASE_PROP_NAME);
		String userName = System.getProperty(DS_USER_PROP_NAME);
		String password = System.getProperty(DS_PASSWORD_PROP_NAME);
		String port = System.getProperty(DS_PORT_PROP_NAME);
		String serverName = System.getProperty(DS_HOST_PROP_NAME);

		// Only run this test if at least one of the above are set
		if ((databaseName != null) || (serverName != null)
				|| (userName != null) || (password != null) || (port != null)) {
			MysqlConnectionPoolDataSource ds = new MysqlConnectionPoolDataSource();

			if (databaseName != null) {
				ds.setDatabaseName(databaseName);
			}

			if (userName != null) {
				ds.setUser(userName);
			}

			if (password != null) {
				ds.setPassword(password);
			}

			if (port != null) {
				ds.setPortNumber(Integer.parseInt(port));
			}

			if (serverName != null) {
				ds.setServerName(serverName);
			}

			bindDataSource(jndiName, ds);

			ConnectionPoolDataSource boundDs = null;

			try {
				boundDs = (ConnectionPoolDataSource) lookupDatasourceInJNDI(jndiName);

				assertTrue("Datasource not bound", boundDs != null);

				Connection dsCon = null;
				Statement dsStmt = null;

				try {
					dsCon = boundDs.getPooledConnection().getConnection();
					dsStmt = dsCon.createStatement();
					dsStmt.executeUpdate("DROP TABLE IF EXISTS testBug3920");
					dsStmt
							.executeUpdate("CREATE TABLE testBug3920 (field1 varchar(32))");

					assertTrue(
							"Connection can not be obtained from data source",
							dsCon != null);
				} finally {
					dsStmt.executeUpdate("DROP TABLE IF EXISTS testBug3920");

					dsStmt.close();
					dsCon.close();
				}
			} finally {
				if (boundDs != null) {
					this.ctx.unbind(jndiName);
				}
			}
		}
	}

	/** 
	 * Tests fix for BUG#19169 - ConnectionProperties (and thus some
	 * subclasses) are not serializable, even though some J2EE containers
	 * expect them to be.
	 * 
	 * @throws Exception if the test fails.
	 */
	public void testBug19169() throws Exception {
		MysqlDataSource toSerialize = new MysqlDataSource();
		toSerialize.setZeroDateTimeBehavior("convertToNull");
		
		boolean testBooleanFlag = !toSerialize.getAllowLoadLocalInfile();
		toSerialize.setAllowLoadLocalInfile(testBooleanFlag);
		
		int testIntFlag = toSerialize.getBlobSendChunkSize() + 1;
		toSerialize.setBlobSendChunkSize(String.valueOf(testIntFlag));
		
		ByteArrayOutputStream bOut = new ByteArrayOutputStream();
		ObjectOutputStream objOut = new ObjectOutputStream(bOut);
		objOut.writeObject(toSerialize);
		objOut.flush();
		
		ObjectInputStream objIn = new ObjectInputStream(new ByteArrayInputStream(bOut.toByteArray()));
		
		MysqlDataSource thawedDs = (MysqlDataSource)objIn.readObject();
		
		assertEquals("convertToNull", thawedDs.getZeroDateTimeBehavior());
		assertEquals(testBooleanFlag, thawedDs.getAllowLoadLocalInfile());
		assertEquals(testIntFlag, thawedDs.getBlobSendChunkSize());
	}
	
	/**
	 * Tests fix for BUG#20242 - MysqlValidConnectionChecker for JBoss doesn't
	 * work with MySQLXADataSources.
	 * 
	 * @throws Exception if the test fails.
	 */
	public void testBug20242() throws Exception {
		if (versionMeetsMinimum(5, 0)) {
			try {
				Class.forName("org.jboss.resource.adapter.jdbc.ValidConnectionChecker");
			} catch (Exception ex) {
				return; // class not available for testing
			}
			
			MysqlXADataSource xaDs = new MysqlXADataSource();
			xaDs.setUrl(dbUrl);
			
			MysqlValidConnectionChecker checker = new MysqlValidConnectionChecker();
			assertNull(checker.isValidConnection(xaDs.getXAConnection().getConnection()));
		}	
	}
	
	private void bindDataSource(String name, DataSource ds) throws Exception {
		this.ctx.bind(this.tempDir.getAbsolutePath() + name, ds);
	}

	/**
	 * This method is separated from the rest of the example since you normally
	 * would NOT register a JDBC driver in your code. It would likely be
	 * configered into your naming and directory service using some GUI.
	 * 
	 * @throws Exception
	 *             if an error occurs
	 */
	private void createJNDIContext() throws Exception {
		this.tempDir = File.createTempFile("jnditest", null);
		this.tempDir.delete();
		this.tempDir.mkdir();
		this.tempDir.deleteOnExit();

		MysqlConnectionPoolDataSource ds;
		Hashtable env = new Hashtable();
		env.put(Context.INITIAL_CONTEXT_FACTORY,
				"com.sun.jndi.fscontext.RefFSContextFactory");
		this.ctx = new InitialContext(env);
		assertTrue("Naming Context not created", this.ctx != null);
		ds = new MysqlConnectionPoolDataSource();
		ds.setUrl(dbUrl); // from BaseTestCase
		ds.setDatabaseName("test");
		this.ctx.bind(this.tempDir.getAbsolutePath() + "/test", ds);
	}

	private DataSource lookupDatasourceInJNDI(String jndiName) throws Exception {
		NameParser nameParser = this.ctx.getNameParser("");
		Name datasourceName = nameParser.parse(this.tempDir.getAbsolutePath()
				+ jndiName);
		Object obj = this.ctx.lookup(datasourceName);
		DataSource boundDs = null;

		if (obj instanceof DataSource) {
			boundDs = (DataSource) obj;
		} else if (obj instanceof Reference) {
			//
			// For some reason, this comes back as a Reference
			// instance under CruiseControl !?
			//
			Reference objAsRef = (Reference) obj;
			ObjectFactory factory = (ObjectFactory) Class.forName(
					objAsRef.getFactoryClassName()).newInstance();
			boundDs = (DataSource) factory.getObjectInstance(objAsRef,
					datasourceName, this.ctx, new Hashtable());
		}

		return boundDs;
	}

	public void testCSC4616() throws Exception {
		MysqlConnectionPoolDataSource ds = new MysqlConnectionPoolDataSource();
		ds.setURL(BaseTestCase.dbUrl);
		PooledConnection pooledConn = ds.getPooledConnection();
		Connection physConn = pooledConn.getConnection();
		Statement physStatement = physConn.createStatement();

		Method enableStreamingResultsMethodStmt = Class.forName(
				"com.mysql.jdbc.jdbc2.optional.StatementWrapper").getMethod(
				"enableStreamingResults", new Class[0]);
		enableStreamingResultsMethodStmt.invoke(physStatement, new Class[0]);
		this.rs = physStatement.executeQuery("SELECT 1");

		try {
			physConn.createStatement().executeQuery("SELECT 2");
			fail("Should have caught a streaming exception here");
		} catch (SQLException sqlEx) {
			assertTrue(sqlEx.getMessage() != null
					&& sqlEx.getMessage().indexOf("Streaming") != -1);
		} finally {
			if (this.rs != null) {
				this.rs.close();
				this.rs = null;
			}
		}

		PreparedStatement physPrepStmt = physConn.prepareStatement("SELECT 1");
		Method enableStreamingResultsMethodPstmt = Class.forName(
				"com.mysql.jdbc.jdbc2.optional.PreparedStatementWrapper")
				.getMethod("enableStreamingResults", new Class[0]);
		enableStreamingResultsMethodPstmt.invoke(physPrepStmt, new Class[0]);

		this.rs = physPrepStmt.executeQuery();

		try {
			physConn.createStatement().executeQuery("SELECT 2");
			fail("Should have caught a streaming exception here");
		} catch (SQLException sqlEx) {
			assertTrue(sqlEx.getMessage() != null
					&& sqlEx.getMessage().indexOf("Streaming") != -1);
		} finally {
			if (this.rs != null) {
				this.rs.close();
				this.rs = null;
			}
		}
	}

	/**
	 * Tests fix for BUG#16791 - NullPointerException in MysqlDataSourceFactory
	 * due to Reference containing RefAddrs with null content.
	 * 
	 * @throws Exception if the test fails
	 */
	public void testBug16791() throws Exception {
		MysqlDataSource myDs = new MysqlDataSource();
		myDs.setUrl(dbUrl);
		Reference asRef = myDs.getReference();
		System.out.println(asRef);
		
		removeFromRef(asRef, "port");
		removeFromRef(asRef, NonRegisteringDriver.USER_PROPERTY_KEY);
		removeFromRef(asRef, NonRegisteringDriver.PASSWORD_PROPERTY_KEY);
		removeFromRef(asRef, "serverName");
		removeFromRef(asRef, "databaseName");
		
		MysqlDataSource newDs = (MysqlDataSource)new MysqlDataSourceFactory().getObjectInstance(asRef, null, null, null);
	}

	private void removeFromRef(Reference ref, String key) {
		int size = ref.size();
		
		for (int i = 0; i < size; i++) {
			RefAddr refAddr = ref.get(i);
			if (refAddr.getType().equals(key)) {
				ref.remove(i);
				break;
			}
		}
	}
	
	/**
	 * Tests fix for BUG#32101 - When using a connection from our ConnectionPoolDataSource,
     * some Connection.prepareStatement() methods would return null instead of
     * a prepared statement.
     * 
	 * @throws Exception
	 */
	public void testBug32101() throws Exception {
		MysqlConnectionPoolDataSource ds = new MysqlConnectionPoolDataSource();
		ds.setURL(BaseTestCase.dbUrl);
		PooledConnection pc = ds.getPooledConnection();
		assertNotNull(pc.getConnection().prepareStatement("SELECT 1"));
		assertNotNull(pc.getConnection().prepareStatement("SELECT 1", Statement.RETURN_GENERATED_KEYS));
		assertNotNull(pc.getConnection().prepareStatement("SELECT 1", new int[0]));
		assertNotNull(pc.getConnection().prepareStatement("SELECT 1", new String[0]));
		assertNotNull(pc.getConnection().prepareStatement("SELECT 1", ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY));
		assertNotNull(pc.getConnection().prepareStatement("SELECT 1", ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY, ResultSet.HOLD_CURSORS_OVER_COMMIT));
	}

	public void testBug35810() throws Exception {
		int defaultConnectTimeout = ((ConnectionProperties) this.conn).getConnectTimeout();
		int nonDefaultConnectTimeout = defaultConnectTimeout + 1000 * 2;
		MysqlConnectionPoolDataSource cpds = new MysqlConnectionPoolDataSource();
		String dsUrl = BaseTestCase.dbUrl;
		if (dsUrl.indexOf("?") == -1) {
			dsUrl += "?";
		} else {
			dsUrl += "&";
		}
		
		dsUrl += "connectTimeout=" + nonDefaultConnectTimeout;
		cpds.setUrl(dsUrl);
		
		Connection dsConn = cpds.getPooledConnection().getConnection();
		int configuredConnectTimeout = ((ConnectionProperties) dsConn).getConnectTimeout();
		
		assertEquals("Connect timeout spec'd by URL didn't take", nonDefaultConnectTimeout, configuredConnectTimeout);
		assertFalse("Connect timeout spec'd by URL didn't take", defaultConnectTimeout == configuredConnectTimeout);
	}
}