[teiid-commits] teiid SVN: r1327 - in trunk/test-integration/db/src/test/java/org/teiid/test: framework/datasource and 1 other directories.

Author: vhalbert(a)redhat.com Date: 2009-09-11 15:19:36 -0400 (Fri, 11 Sep 2009) New Revision: 1327 Added: trunk/test-integration/db/src/test/java/org/teiid/test/framework/AbstractQueryTransactionTest.java trunk/test-integration/db/src/test/java/org/teiid/test/framework/QueryExecution.java trunk/test-integration/db/src/test/java/org/teiid/test/framework/datasource/DataSourceSetupFactory.java trunk/test-integration/db/src/test/java/org/teiid/test/framework/datasource/SingleDataSourceSetup.java trunk/test-integration/db/src/test/java/org/teiid/test/framework/datasource/TwoDataSourceSetup.java trunk/test-integration/db/src/test/java/org/teiid/test/testcases/Alltaests.java trunk/test-integration/db/src/test/java/org/teiid/test/testcases/BaseAbstractTransactionTestCase.java trunk/test-integration/db/src/test/java/org/teiid/test/testcases/SingleSourceTransactionTest.java trunk/test-integration/db/src/test/java/org/teiid/test/testcases/TwoSourceTransactionTest.java Log: Teiid 773 - organize integration test Added: trunk/test-integration/db/src/test/java/org/teiid/test/framework/AbstractQueryTransactionTest.java =================================================================== --- trunk/test-integration/db/src/test/java/org/teiid/test/framework/AbstractQueryTransactionTest.java (rev 0) +++ trunk/test-integration/db/src/test/java/org/teiid/test/framework/AbstractQueryTransactionTest.java 2009-09-11 19:19:36 UTC (rev 1327) @@ -0,0 +1,143 @@ +/* + * Copyright (c) 2000-2007 MetaMatrix, Inc. + * All rights reserved. + */ +package org.teiid.test.framework; + +import static org.junit.Assert.assertNotNull; + +import java.sql.Statement; +import java.util.Properties; + +import javax.sql.XAConnection; + +import org.teiid.test.framework.connection.ConnectionStrategyFactory; +import org.teiid.test.framework.datasource.DataSourceSetupFactory; +import org.teiid.test.framework.exception.TransactionRuntimeException; + +import com.metamatrix.jdbc.api.AbstractQueryTest; +import com.metamatrix.jdbc.api.ExecutionProperties; + + +/** + * The AbstractQueryTransactionTest is the class that should be extended when + * a testcase is being created to validate certain behavior + * + * @see QueryExecution for use when direct queries to the source are used + * to validate the results of the testcase. + * + */ +public abstract class AbstractQueryTransactionTest extends AbstractQueryTest implements TransactionQueryTest{ + Properties executionProperties = null; + String testname = "NA"; + + + public AbstractQueryTransactionTest() { + super(); + } + + public AbstractQueryTransactionTest(String testname) { + super(); + this.testname = testname; + } + + public String getTestName() { + return this.testname; + } + + + public void setExecutionProperties(Properties props) { + assertNotNull(props); + this.executionProperties = props; + } + + @Override protected void assignExecutionProperties(Statement stmt) { + if (this.executionProperties != null) { + if (stmt instanceof com.metamatrix.jdbc.api.Statement) { + com.metamatrix.jdbc.api.Statement statement = (com.metamatrix.jdbc.api.Statement)stmt; + if (this.executionProperties.getProperty(ExecutionProperties.PROP_TXN_AUTO_WRAP) != null) { + statement.setExecutionProperty(ExecutionProperties.PROP_TXN_AUTO_WRAP, this.executionProperties.getProperty(ExecutionProperties.PROP_TXN_AUTO_WRAP)); + } + + if (this.executionProperties.getProperty(ExecutionProperties.PROP_FETCH_SIZE) != null) { + statement.setExecutionProperty(ExecutionProperties.PROP_FETCH_SIZE, this.executionProperties.getProperty(ExecutionProperties.PROP_FETCH_SIZE)); + } + } + } + + } + + public int getNumberRequiredDataSources() { + return 1; + } + + + @Override + public void setupDataSource() { + DataSourceSetup dss = null; + try { + + dss = DataSourceSetupFactory.createDataSourceSetup(getNumberRequiredDataSources()); + dss.setup(); + } catch(Exception e) { + throw new TransactionRuntimeException(e.getMessage()); + } + } + + + + /** + * Implement testCase(), it is the entry point to the execution of the test. + * @throws Exception + * + * @since + */ + public abstract void testCase() throws Exception; + + /** + * Indicates what should be done when a failure occurs in {@link #testCase()} + * @return + * + * @since + */ + public boolean rollbackAllways() { + return false; + } + + /** + * Override <code>before</code> if there is behavior that needs to be performed + * prior to {@link #testCase()} being called. + * + * + * @since + */ + public void before() { + } + + /** + * Override <code>after</code> if there is behavior that needs to be performed + * after {@link #testCase()} being called. + * + * + * @since + */ + public void after() { + } + + + public void cleanup() { + ConnectionStrategyFactory.destroyInstance(); + + this.closeConnection(); + } + + @Override + public XAConnection getXAConnection() { + // TODO Auto-generated method stub + return null; + } + + + + +} Property changes on: trunk/test-integration/db/src/test/java/org/teiid/test/framework/AbstractQueryTransactionTest.java ___________________________________________________________________ Name: svn:mime-type + text/plain Added: trunk/test-integration/db/src/test/java/org/teiid/test/framework/QueryExecution.java =================================================================== --- trunk/test-integration/db/src/test/java/org/teiid/test/framework/QueryExecution.java (rev 0) +++ trunk/test-integration/db/src/test/java/org/teiid/test/framework/QueryExecution.java 2009-09-11 19:19:36 UTC (rev 1327) @@ -0,0 +1,21 @@ +package org.teiid.test.framework; + +import java.sql.Connection; + +import com.metamatrix.jdbc.api.AbstractQueryTest; + +/** + * The QueryExecution class can be used to query the source directly. The intended use + * of this class is for validating results after the execution of a test case. + * + * @see AbstractQueryTransactionTest regarding creating a testcase to validate behavior. + * @author vanhalbert + * + */ +public class QueryExecution extends AbstractQueryTest { + + public QueryExecution(Connection conn) { + super(conn); + } + +} Property changes on: trunk/test-integration/db/src/test/java/org/teiid/test/framework/QueryExecution.java ___________________________________________________________________ Name: svn:mime-type + text/plain Added: trunk/test-integration/db/src/test/java/org/teiid/test/framework/datasource/DataSourceSetupFactory.java =================================================================== --- trunk/test-integration/db/src/test/java/org/teiid/test/framework/datasource/DataSourceSetupFactory.java (rev 0) +++ trunk/test-integration/db/src/test/java/org/teiid/test/framework/datasource/DataSourceSetupFactory.java 2009-09-11 19:19:36 UTC (rev 1327) @@ -0,0 +1,28 @@ +package org.teiid.test.framework.datasource; + +import org.teiid.test.framework.DataSourceSetup; +import org.teiid.test.framework.exception.QueryTestFailedException; + +public class DataSourceSetupFactory { + + public static DataSourceSetup createDataSourceSetup(int numOfDataSources) throws QueryTestFailedException { + DataSourceSetup dss = null; + + switch (numOfDataSources) { + case 1: + dss = new SingleDataSourceSetup(); + break; + + case 2: + dss = new TwoDataSourceSetup(); + break; + + default: + throw new QueryTestFailedException("Number of datasources " + numOfDataSources + " is not supported"); + + } + + return dss; + } + +} Property changes on: trunk/test-integration/db/src/test/java/org/teiid/test/framework/datasource/DataSourceSetupFactory.java ___________________________________________________________________ Name: svn:mime-type + text/plain Added: trunk/test-integration/db/src/test/java/org/teiid/test/framework/datasource/SingleDataSourceSetup.java =================================================================== --- trunk/test-integration/db/src/test/java/org/teiid/test/framework/datasource/SingleDataSourceSetup.java (rev 0) +++ trunk/test-integration/db/src/test/java/org/teiid/test/framework/datasource/SingleDataSourceSetup.java 2009-09-11 19:19:36 UTC (rev 1327) @@ -0,0 +1,77 @@ +/* + * Copyright (c) 2000-2007 MetaMatrix, Inc. + * All rights reserved. + */ +package org.teiid.test.framework.datasource; + +import org.teiid.test.framework.DataSourceSetup; +import org.teiid.test.framework.QueryExecution; +import org.teiid.test.framework.connection.ConnectionUtil; + +import com.metamatrix.jdbc.api.AbstractQueryTest; + + + +/** + * This performs the data setup for SingleSource test cases + */ +public class SingleDataSourceSetup implements DataSourceSetup { + + + @Override + public void setup() throws Exception { + // NOTE: dont close the connections here because in most cases they are reused + // to validate the results + // The connections will be closed at teardown + + System.out.println("Run SingleDataSourceSetup..."); + + + // Only one of the models are needed because pm1 and pm2 point to the same datasource + AbstractQueryTest test1 = new QueryExecution(ConnectionUtil.getSource("pm1")); //$NON-NLS-1$ + test1.execute("delete from g2"); //$NON-NLS-1$ + test1.execute("delete from g1"); //$NON-NLS-1$ + + test1.execute("select * from g1 "); + test1.assertRowCount(0); + test1.execute("select * from g2 "); + test1.assertRowCount(0); + + + + String[] sql1 = new String[100]; + + for (int i = 0; i < 100; i++) { + sql1[i] = "insert into g1 (e1, e2) values("+i+",'"+i+"')" ; + } + + test1.executeBatch(sql1); + + String[] sql2 = new String[100]; + + for (int i = 0; i < 100; i++) { + sql2[i] = "insert into g2 (e1, e2) values("+i+",'"+i+"')" ; + } + + test1.executeBatch(sql2); + + test1.execute("select * from g1 "); + test1.assertRowCount(100); + test1.execute("select * from g2 "); + test1.assertRowCount(100); + + + System.out.println("SingleDataSourceSetup Completed"); + + + + } + + @Override + public int getDataSourceCnt() { + // TODO Auto-generated method stub + return 1; + } + + +} Property changes on: trunk/test-integration/db/src/test/java/org/teiid/test/framework/datasource/SingleDataSourceSetup.java ___________________________________________________________________ Name: svn:mime-type + text/plain Added: trunk/test-integration/db/src/test/java/org/teiid/test/framework/datasource/TwoDataSourceSetup.java =================================================================== --- trunk/test-integration/db/src/test/java/org/teiid/test/framework/datasource/TwoDataSourceSetup.java (rev 0) +++ trunk/test-integration/db/src/test/java/org/teiid/test/framework/datasource/TwoDataSourceSetup.java 2009-09-11 19:19:36 UTC (rev 1327) @@ -0,0 +1,85 @@ +/* + * Copyright (c) 2000-2007 MetaMatrix, Inc. + * All rights reserved. + */ +package org.teiid.test.framework.datasource; + +import org.teiid.test.framework.DataSourceSetup; +import org.teiid.test.framework.QueryExecution; +import org.teiid.test.framework.connection.ConnectionUtil; + +import com.metamatrix.jdbc.api.AbstractQueryTest; + + + +/** + * This performs the data setup for SingleSource test cases + */ +public class TwoDataSourceSetup implements DataSourceSetup { + + + @Override + public void setup() throws Exception { + // NOTE: dont close the connections here because in most cases they are reused + // to validate the results + // The connections will be closed at teardown + + + System.out.println("Run TwoSource Setup..."); + + + AbstractQueryTest test1 = new QueryExecution(ConnectionUtil.getSource("pm1")); //$NON-NLS-1$ + test1.execute("delete from g2"); //$NON-NLS-1$ + test1.execute("delete from g1"); //$NON-NLS-1$ + + test1.execute("select * from g1 "); + test1.assertRowCount(0); + test1.execute("select * from g2 "); + test1.assertRowCount(0); + + String[] sql1 = new String[100]; + + for (int i = 0; i < 100; i++) { + sql1[i] = "insert into g1 (e1, e2) values("+i+",'"+i+"')" ; + } + + test1.executeBatch(sql1); + test1.execute("select * from g1 "); + test1.assertRowCount(100); + test1.execute("select * from g2 "); + test1.assertRowCount(0); + + AbstractQueryTest test2 = new QueryExecution(ConnectionUtil.getSource("pm2")); //$NON-NLS-1$ + test2.execute("delete from g2"); //$NON-NLS-1$ + test2.execute("delete from g1"); //$NON-NLS-1$ + + test2.execute("select * from g1 "); + test2.assertRowCount(0); + test2.execute("select * from g2 "); + test2.assertRowCount(0); + + String[] sql2 = new String[100]; + + for (int i = 0; i < 100; i++) { + sql2[i] = "insert into g2 (e1, e2) values("+i+",'"+i+"')" ; + } + + test2.executeBatch(sql2); + test2.execute("select * from g1 "); + test2.assertRowCount(0); + test2.execute("select * from g2 "); + test2.assertRowCount(100); + + System.out.println("TwoSource Setup Completed"); + + + + } + + @Override + public int getDataSourceCnt() { + // TODO Auto-generated method stub + return 2; + } + +} Property changes on: trunk/test-integration/db/src/test/java/org/teiid/test/framework/datasource/TwoDataSourceSetup.java ___________________________________________________________________ Name: svn:mime-type + text/plain Added: trunk/test-integration/db/src/test/java/org/teiid/test/testcases/Alltaests.java =================================================================== --- trunk/test-integration/db/src/test/java/org/teiid/test/testcases/Alltaests.java (rev 0) +++ trunk/test-integration/db/src/test/java/org/teiid/test/testcases/Alltaests.java 2009-09-11 19:19:36 UTC (rev 1327) @@ -0,0 +1,32 @@ +/* + * Copyright � 2000-2008 MetaMatrix, Inc. + * All rights reserved. + */ +package org.teiid.test.testcases; + +import junit.framework.Test; +import junit.framework.TestSuite; + + + +/** + * @since 1.0 + */ +public class Alltaests { + + public static void main(String[] args) { + junit.textui.TestRunner.run(Alltaests.suite()); + } + + public static Test suite() { + TestSuite suite = new TestSuite("All Integration Tests"); //$NON-NLS-1$ + //$JUnit-BEGIN$ + // suite.addTestSuite(LocalTransactionTests.class); + + //$JUnit-END$ + return suite; + } + + + +} Property changes on: trunk/test-integration/db/src/test/java/org/teiid/test/testcases/Alltaests.java ___________________________________________________________________ Name: svn:mime-type + text/plain Added: trunk/test-integration/db/src/test/java/org/teiid/test/testcases/BaseAbstractTransactionTestCase.java =================================================================== --- trunk/test-integration/db/src/test/java/org/teiid/test/testcases/BaseAbstractTransactionTestCase.java (rev 0) +++ trunk/test-integration/db/src/test/java/org/teiid/test/testcases/BaseAbstractTransactionTestCase.java 2009-09-11 19:19:36 UTC (rev 1327) @@ -0,0 +1,40 @@ +/* + * Copyright (c) 2000-2007 MetaMatrix, Inc. + * All rights reserved. + */ +package org.teiid.test.testcases; + + + +import java.sql.Connection; + +import javax.sql.XAConnection; + +import junit.framework.TestCase; + +import org.teiid.test.framework.TransactionContainer; +import org.teiid.test.framework.connection.ConnectionUtil; +import org.teiid.test.framework.exception.QueryTestFailedException; +import org.teiid.test.framework.transaction.TransactionFactory; + +public class BaseAbstractTransactionTestCase extends TestCase { + + + public BaseAbstractTransactionTestCase(String name) { + super(name); + } + + protected TransactionContainer getTransactionContainter() { + return TransactionFactory.create(); + } + + + public Connection getSource(String identifier) throws QueryTestFailedException { + return ConnectionUtil.getSource(identifier); + } + + public XAConnection getXASource(String identifier) throws QueryTestFailedException { + return ConnectionUtil.getXASource(identifier); + } + +} Property changes on: trunk/test-integration/db/src/test/java/org/teiid/test/testcases/BaseAbstractTransactionTestCase.java ___________________________________________________________________ Name: svn:mime-type + text/plain Added: trunk/test-integration/db/src/test/java/org/teiid/test/testcases/SingleSourceTransactionTest.java =================================================================== --- trunk/test-integration/db/src/test/java/org/teiid/test/testcases/SingleSourceTransactionTest.java (rev 0) +++ trunk/test-integration/db/src/test/java/org/teiid/test/testcases/SingleSourceTransactionTest.java 2009-09-11 19:19:36 UTC (rev 1327) @@ -0,0 +1,270 @@ +/* + * Copyright (c) 2000-2007 MetaMatrix, Inc. + * All rights reserved. + */ +package org.teiid.test.testcases; + +import org.teiid.test.framework.AbstractQueryTransactionTest; +import org.teiid.test.framework.QueryExecution; + +import com.metamatrix.jdbc.api.AbstractQueryTest; + + + +/** + * A common SingleSource test case among many different transaction stuff. + */ +public class SingleSourceTransactionTest extends BaseAbstractTransactionTestCase { + + public SingleSourceTransactionTest(String name) { + super(name); + } + + + /////////////////////////////////////////////////////////////////////////////////////////////// + // Single Source - Rows below 500 (for insert/update/delete) + /////////////////////////////////////////////////////////////////////////////////////////////// + + /** + * Sources = 1 + * Commands = 1, Select + * Batching = Full Processing, Single Connector Batch + * result = commit + */ + public void testSingleSourceSelect() throws Exception { + AbstractQueryTransactionTest userTxn = new AbstractQueryTransactionTest("testSingleSourceSelect") { + public void testCase() throws Exception { + execute("select * from pm1.g1 where pm1.g1.e1 < 100"); + assertRowCount(100); + } + + public void validateTestCase() throws Exception { + + } + }; + + // run test + getTransactionContainter().runTransaction(userTxn); + + // there is nothing to verify here.. + + System.out.println("Complete CommonTransactionTest.testSingleSourceSelect"); + + } + + + /** + * Sources = 1 + * Commands = 1, Update + * Batching = Full Processing, Single Connector Batch + * result = commit + */ + public void testSingleSourceUpdate() throws Exception { + AbstractQueryTransactionTest userTxn = new AbstractQueryTransactionTest("testSingleSourceUpdate") { + public void testCase() throws Exception { + execute("insert into pm1.g1 (e1, e2) values(100, '100')"); + } + public void validateTestCase() throws Exception { + // now verify the results + AbstractQueryTest test = new QueryExecution(getSource("pm1")); + test.execute("select * from g1 where e1 = 100"); + test.assertRowCount(1); + test.closeConnection(); + + } + }; + + // run test + getTransactionContainter().runTransaction(userTxn); + + + System.out.println("Complete CommonTransactionTest.testSingleSourceUpdate"); + + } + + + /** + * Sources = 1 + * Commands = 1, Update(prepared statement) + * Batching = Full Processing, Single Connector Batch + * result = commit + */ + public void testSingleSourcePreparedUpdate() throws Exception { + AbstractQueryTransactionTest userTxn = new AbstractQueryTransactionTest("testSingleSourcePreparedUpdate") { + public void testCase() throws Exception { + execute("insert into pm1.g1 (e1, e2) values(?, ?)", new Object[] {new Integer(102), "102"}); + } + public void validateTestCase() throws Exception { + // now verify the results + AbstractQueryTest test = new QueryExecution(getSource("pm1")); + test.execute("select * from g1 where e1 = 102"); + test.assertRowCount(1); + test.closeConnection(); + } + }; + + // run test + getTransactionContainter().runTransaction(userTxn); + + + System.out.println("Complete CommonTransactionTest.testSingleSourcePreparedUpdate"); + + } + + /** + * Sources = 1 + * Commands = multiple - Success + * Batching = Full Processing, Single Connector Batch + * result = commit + */ + public void testSingleSourceMultipleCommands() throws Exception { + AbstractQueryTransactionTest userTxn = new AbstractQueryTransactionTest("testSingleSourceMultipleCommands") { + public void testCase() throws Exception { + + execute("delete from pm1.g1 where pm1.g1.e1 >= ?", new Object[] {new Integer(100)}); + + execute("select * from pm1.g1"); + assertRowCount(100); + + for (int i = 100; i < 110; i++) { + Integer val = new Integer(i); + execute("insert into pm1.g1 (e1, e2) values(?,?)", new Object[] {val, val.toString()}); + execute("insert into pm1.g2 (e1, e2) values(?,?)", new Object[] {val, val.toString()}); + } + } + + public void validateTestCase() throws Exception { + // now verify the results + AbstractQueryTest test = new QueryExecution(getSource("pm1")); + test.execute("select * from g1 where e1 >= 100"); + test.assertRowCount(10); + test.execute("select * from g2 where e1 >= 100"); + test.assertRowCount(10); + test.closeConnection(); + } + }; + + // run test + getTransactionContainter().runTransaction(userTxn); + + + System.out.println("Complete CommonTransactionTest.testSingleSourceMultipleCommands"); + + } + + /** + * Sources = 1 + * Commands = 1, Select + * Batching = Partial Processing, Single Connector Batch + * result = commit + */ + public void testSingleSourcePartialProcessing() throws Exception { + AbstractQueryTransactionTest userTxn = new AbstractQueryTransactionTest("testSingleSourcePartialProcessing") { + public void testCase() throws Exception { + execute("select * from pm1.g1 where pm1.g1.e1 < 100 limit 10"); + assertRowCount(10); + } + + public void validateTestCase() throws Exception { + } + }; + + // run test + getTransactionContainter().runTransaction(userTxn); + + System.out.println("Complete CommonTransactionTest.testSingleSourcePartialProcessing"); + + } + + /** + * Sources = 1 + * Commands = multiple - Success + * Batching = Full Processing, Single Connector Batch + * result = rollback + */ + + public void xtestSingleSourceMultipleCommandsExplicitRollback() throws Exception { + // now it's empty + AbstractQueryTest test = new QueryExecution(this.getSource("pm1")); + //getSource("pm1")); + test.execute("select * from g1 where e1 >= 200 and e1 < 220"); + test.assertRowCount(0); + test.execute("select * from g2 where e1 >= 200 and e1 < 220"); + test.assertRowCount(0); + test.closeConnection(); + + + AbstractQueryTransactionTest userTxn = new AbstractQueryTransactionTest("testSingleSourceMultipleCommandsExplicitRollback") { + public void testCase() throws Exception { + for (int i = 200; i < 220; i++) { + execute("insert into pm1.g1 (e1, e2) values("+i+",'"+i+"')"); + execute("insert into pm1.g2 (e1, e2) values("+i+",'"+i+"')"); + } + } + + public boolean rollbackAllways() { + return true; + } + + public void validateTestCase() throws Exception { + // now verify the results + AbstractQueryTest test = new QueryExecution(getSource("pm1")); + //getSource("pm1")); + test.execute("select * from g1 where e1 >= 200 and e1 < 220"); + test.assertRowCount(0); + test.execute("select * from g2 where e1 >= 200 and e1 < 220"); + test.assertRowCount(0); + test.closeConnection(); + } + + + }; + + // run test + getTransactionContainter().runTransaction(userTxn); + + + System.out.println("Complete testSingleSourceMultipleCommandsExplicitRollback"); + } + + /** + * Sources = 1 + * Commands = multiple - Success + * Batching = Full Processing, Single Connector Batch + * result = rollback + */ + public void xtestSingleSourceMultipleCommandsReferentialIntegrityRollback() throws Exception { + + AbstractQueryTransactionTest userTxn = new AbstractQueryTransactionTest("testSingleSourceMultipleCommandsReferentialIntegrityRollback") { + public void testCase() throws Exception { + for (int i = 200; i < 220; i++) { + Integer val = new Integer(i); + execute("insert into pm1.g1 (e1, e2) values(?,?)", new Object[] {val, val.toString()}); + execute("insert into pm1.g2 (e1, e2) values(?,?)", new Object[] {val, val.toString()}); + } + + // force the rollback by trying to insert an invalid row. + execute("insert into pm1.g2 (e1, e2) values(?,?)", new Object[] {new Integer(9999), "9999"}); + } + + public boolean exceptionExpected() { + return true; + } + + public void validateTestCase() throws Exception { + // now verify the results + AbstractQueryTest test = new QueryExecution(getSource("pm1")); + test.execute("select * from g1 where e1 >= 200 and e1 < 220"); + test.assertRowCount(0); + test.closeConnection(); + } + }; + + // run test + getTransactionContainter().runTransaction(userTxn); + + System.out.println("Complete testSingleSourceMultipleCommandsReferentialIntegrityRollback"); + + } + +} Property changes on: trunk/test-integration/db/src/test/java/org/teiid/test/testcases/SingleSourceTransactionTest.java ___________________________________________________________________ Name: svn:mime-type + text/plain Added: trunk/test-integration/db/src/test/java/org/teiid/test/testcases/TwoSourceTransactionTest.java =================================================================== --- trunk/test-integration/db/src/test/java/org/teiid/test/testcases/TwoSourceTransactionTest.java (rev 0) +++ trunk/test-integration/db/src/test/java/org/teiid/test/testcases/TwoSourceTransactionTest.java 2009-09-11 19:19:36 UTC (rev 1327) @@ -0,0 +1,785 @@ +/* + * Copyright (c) 2000-2007 MetaMatrix, Inc. + * All rights reserved. + */ +package org.teiid.test.testcases; + +import java.sql.SQLException; +import java.util.ArrayList; + +import org.teiid.test.framework.AbstractQueryTransactionTest; +import org.teiid.test.framework.QueryExecution; + +import com.metamatrix.jdbc.api.AbstractQueryTest; + + + +/** + * A common SingleSource test case among many different transaction stuff. + */ +public class TwoSourceTransactionTest extends BaseAbstractTransactionTestCase { + + public TwoSourceTransactionTest(String name) { + super(name); + } + + + /////////////////////////////////////////////////////////////////////////////////////////////// + // Multiple Sources - Rows from 500 + /////////////////////////////////////////////////////////////////////////////////////////////// + + /** + * Sources = 2 + * Commands = 1, Select + * Batching = Full Processing, Single Connector Batch + * result = commit + */ + public void testMultipleSourceSelect() throws Exception { + AbstractQueryTransactionTest userTxn = new AbstractQueryTransactionTest("testMultipleSourceSelect") { + public void testCase() throws Exception { + execute("select * from pm1.g1 join pm2.g1 on pm1.g1.e1 = pm2.g1.e1 where pm1.g1.e1 < 100"); + assertRowCount(100); + } + + public void validateTestCase() throws Exception { + } + }; + + // run test + getTransactionContainter().runTransaction(userTxn); + + System.out.println("Complete CommonTransactionTest.testMultipleSourceSelect"); + + } + + /** + * Sources = 2 + * Commands = 1, Select + * Batching = Full Processing, Single Connector Batch + * result = commit + */ + public void testMultipleSourceVirtualSelect() throws Exception { + AbstractQueryTransactionTest userTxn = new AbstractQueryTransactionTest("testMultipleSourceVirtualSelect") { + public void testCase() throws Exception { + execute("select * from vm.g1 where vm.g1.pm1e1 < 100"); + assertRowCount(100); + } + public int getNumberRequiredDataSources(){ + return 2; + } + public void validateTestCase() throws Exception { + } + + }; + + + // run test + getTransactionContainter().runTransaction(userTxn); + + System.out.println("Complete CommonTransactionTest.testMultipleSourceVirtualSelect"); + + } + + /** + * Sources = 2 + * Commands = 1, Update + * Batching = Full Processing, Single Connector Batch + * result = commit + */ + public void testMultipleSourceUpdate() throws Exception { + AbstractQueryTransactionTest userTxn = new AbstractQueryTransactionTest("testMultipleSourceUpdate") { + public void testCase() throws Exception { + execute("insert into vm.g1 (pm1e1, pm1e2, pm2e1, pm2e2) values(500, '500', 500, '500')"); + } + + public int getNumberRequiredDataSources(){ + return 2; + } + + public void validateTestCase() throws Exception { + + // now verify the results + AbstractQueryTest test = new QueryExecution(getSource("pm1")); + test.execute("select * from g1 where e2 = '500'"); + test.assertRowCount(1); + test.closeConnection(); + + test = new QueryExecution(getSource("pm2")); + test.execute("select * from g1 where e2 = '500'"); + test.assertRowCount(1); + test.closeConnection(); + } + + }; + + + // run test + getTransactionContainter().runTransaction(userTxn); + + System.out.println("Complete CommonTransactionTest.testMultipleSourceUpdate"); + + } + + /** + * Sources = 2 + * Commands = 1, Update + * Batching = Full Processing, Single Connector Batch + * result = commit + */ + public void testMultipleSourceSelectInto() throws Exception { + AbstractQueryTransactionTest userTxn = new AbstractQueryTransactionTest("testMultipleSourceSelectInto") { + public void testCase() throws Exception { + execute("insert into vm.g1 (pm1e1, pm1e2, pm2e1, pm2e2) values(501, '501', 501, '501')"); + execute("select pm1.g1.e1, pm1.g1.e2 into pm2.g2 from pm1.g1 where pm1.g1.e1 = 501"); + } + + public int getNumberRequiredDataSources(){ + return 2; + } + + public void validateTestCase() throws Exception { + + // now verify the results + AbstractQueryTest test = new QueryExecution(getSource("pm1")); + test.execute("select * from g1 where e2 = '501'"); + test.assertRowCount(1); + test.closeConnection(); + + test = new QueryExecution(getSource("pm2")); + test.execute("select * from g1 where e2 = '501'"); + test.assertRowCount(1); + test.closeConnection(); + + } + + }; + + // run test + getTransactionContainter().runTransaction(userTxn); + + System.out.println("Complete CommonTransactionTest.testMultipleSourceSelectInto"); + + } + + /** + * Sources = 2 + * Commands = 1, Update + * Batching = Full Processing, Single Connector Batch + * result = commit + */ + public void testMultipleSourceBulkRowInsert() throws Exception { + AbstractQueryTransactionTest userTxn = new AbstractQueryTransactionTest("testMultipleSourceBulkRowInsert") { + public void testCase() throws Exception { + for (int i = 100; i < 112; i++) { + Integer val = new Integer(i); + execute("insert into vm.g1 (pm1e1, pm1e2, pm2e1, pm2e2) values(?,?,?,?)", new Object[] {val, val.toString(), val, val.toString()}); + } + execute("select pm1.g1.e1, pm1.g1.e2 into pm2.g2 from pm1.g1 where pm1.g1.e1 >= 100"); + } + + public int getNumberRequiredDataSources(){ + return 2; + } + public void validateTestCase() throws Exception { + + // now verify the results + AbstractQueryTest test = new QueryExecution(getSource("pm1")); + test.execute("select * from g1 where e1 >= 100 and e1 < 112"); + test.assertRowCount(12); + test.closeConnection(); + + test = new QueryExecution(getSource("pm2")); + test.execute("select * from g1 where e1 >= 100 and e1 < 112"); + test.assertRowCount(12); + test.execute("select * from g2 where e1 >= 100 and e1 < 112"); + test.assertRowCount(12); + test.closeConnection(); + } + + + }; + + + // run test + getTransactionContainter().runTransaction(userTxn); + + System.out.println("Complete CommonTransactionTest.testMultipleSourceBulkRowInsert"); + + } + + /** + * Sources = 2 + * Commands = 1, Update(prepared statement) + * Batching = Full Processing, Single Connector Batch + * result = commit + */ + public void testMultipleSourcePreparedUpdate() throws Exception { + AbstractQueryTransactionTest userTxn = new AbstractQueryTransactionTest("testMultipleSourcePreparedUpdate") { + public void testCase() throws Exception { + Integer value = new Integer(500); + execute("insert into vm.g1 (pm1e1, pm1e2, pm2e1, pm2e2) values(?,?,?,?)", new Object[] {value, value.toString(), value, value.toString()}); + } + public int getNumberRequiredDataSources(){ + return 2; + } + + public void validateTestCase() throws Exception { + + // now verify the results + AbstractQueryTest test = new QueryExecution(getSource("pm1")); + test.execute("select * from g1 where e1 = 500"); + test.assertRowCount(1); + test.closeConnection(); + + test = new QueryExecution(getSource("pm2")); + test.execute("select * from g1 where e1 = 500"); + test.assertRowCount(1); + test.closeConnection(); + } + + }; + + + // run test + getTransactionContainter().runTransaction(userTxn); + + System.out.println("Complete CommonTransactionTest.testMultipleSourcePreparedUpdate"); + + } + + + /** + * Sources = 2 + * Commands = multiple - Success + * Batching = Full Processing, Single Connector Batch + * result = commit + */ + public void testMultipleSourceMultipleCommands() throws Exception { + AbstractQueryTransactionTest userTxn = new AbstractQueryTransactionTest("testMultipleSourceMultipleCommands") { + public void testCase() throws Exception { + execute("delete from pm1.g2 where e1 >= ?", new Object[] {new Integer(100)}); + execute("delete from pm1.g1 where e1 >= ?", new Object[] {new Integer(100)}); + execute("delete from pm2.g2 where e1 >= ?", new Object[] {new Integer(100)}); + execute("delete from pm2.g1 where e1 >= ?", new Object[] {new Integer(100)}); + + execute("select * from pm1.g1"); + assertRowCount(100); + + for (int i = 100; i < 115; i++) { + Integer val = new Integer(i); + execute("insert into pm1.g1 (e1, e2) values(?,?)", new Object[] {val, val.toString()}); + execute("insert into pm1.g2 (e1, e2) values(?,?)", new Object[] {val, val.toString()}); + + execute("insert into pm2.g1 (e1, e2) values(?,?)", new Object[] {val, val.toString()}); + execute("insert into pm2.g2 (e1, e2) values(?,?)", new Object[] {val, val.toString()}); + } + + execute("update pm1.g1 set e2='blah' where e1 > 100"); + } + public int getNumberRequiredDataSources(){ + return 2; + } + + public void validateTestCase() throws Exception { + + // now verify the results + AbstractQueryTest test = new QueryExecution(getSource("pm1")); + test.execute("select * from g1 where e1 >= 100 and e1 < 115"); + test.assertRowCount(15); + test.execute("select * from g2 where e1 >= 100 and e1 < 115"); + test.assertRowCount(15); + test.execute("select distinct e2 from g1 where e1 > 100"); + test.assertResultsSetEquals(new String[] {"e2[varchar]", "blah"}); + test.closeConnection(); + } + + }; + + + // run test + getTransactionContainter().runTransaction(userTxn); + + System.out.println("Complete CommonTransactionTest.testMultipleSourceMultipleCommands"); + + + } + + /** + * Sources = 2 + * Commands = multiple - Success + * Batching = Full Processing, Single Connector Batch + * result = commit + */ + public void testMultipleSourceMultipleVirtualCommands() throws Exception { + AbstractQueryTransactionTest userTxn = new AbstractQueryTransactionTest("testMultipleSourceMultipleVirtualCommands") { + public void testCase() throws Exception { + + for (int i = 200; i < 207; i++) { + Integer val = new Integer(i); + execute("insert into vm.g1 (pm1e1, pm1e2, pm2e1, pm2e2) values(?,?,?,?)", new Object[] {val, val.toString(), val, val.toString()}); + execute("insert into vm.g2 (pm1e1, pm1e2, pm2e1, pm2e2) values(?,?,?,?)", new Object[] {val, val.toString(), val, val.toString()}); + } + + execute("update vm.g1 set pm1e2='blah' where pm1e1 >= 200"); + + execute("delete from vm.g2 where vm.g2.pm1e1 >= 205"); + execute("delete from vm.g1 where vm.g1.pm1e1 >= 205"); + + execute("select * from vm.g1 where pm1e1 >= 200 and pm1e1 < 207"); + assertRowCount(5); + } + public int getNumberRequiredDataSources(){ + return 2; + } + + public void validateTestCase() throws Exception { + // now verify the results + AbstractQueryTest test = new QueryExecution(getSource("pm1")); + test.execute("select * from g1 where e1 >= 200 and e1 < 207"); + test.assertRowCount(5); + test.execute("select * from g2 where e1 >= 200 and e1 < 207"); + test.assertRowCount(5); + test.execute("select distinct e2 from g1 where e1 >= 200 and e1 < 207"); + test.assertResultsSetEquals(new String[] {"e2[varchar]", "blah"}); + test.closeConnection(); + + } + + }; + + + // run test + getTransactionContainter().runTransaction(userTxn); + + System.out.println("Complete CommonTransactionTest.testMultipleSourceMultipleVirtualCommands"); + + + } + + /** + * Sources = 2 + * Commands = multiple - Success + * Batching = Full Processing, Single Connector Batch + * result = rollback + */ + public void testMultipleSourceMultipleCommandsCancel() throws Exception { + AbstractQueryTransactionTest userTxn = new AbstractQueryTransactionTest("testMultipleSourceMultipleCommandsCancel") { + + public void testCase() throws Exception { + Thread t = new Thread("Cancel Thread") { + public void run() { + try { + try { + Thread.sleep(500); + cancelQuery(); + } catch (SQLException e) { + print(e); + // debug(e.getMessage()); + } + } catch (InterruptedException e) {} + } + }; + t.start(); + executeBatch(getMultipleSourceBatch()); + } + + /** + * @see com.metamatrix.transaction.test.framework.AbstractQueryTest#exceptionExpected() + */ + public boolean exceptionExpected() { + return true; + } + + public int getNumberRequiredDataSources(){ + return 2; + } + + + public void validateTestCase() throws Exception { + // now verify the results (this may finish under one second, then this test is not valid) + AbstractQueryTest test = new QueryExecution(getSource("pm1")); + test.execute("select * from g1 where e1 >= 600 and e1 < 650"); + test.assertRowCount(0); + test.execute("select * from g2 where e1 >= 600 and e1 < 650"); + test.assertRowCount(0); + test.execute("select distinct e2 from g1 where e1 >= 600 and e1 < 650"); + test.assertRowCount(0); + test.closeConnection(); + + } + + }; + getTransactionContainter().runTransaction(userTxn); + + System.out.println("Complete CommonTransactionTest.testMultipleSourceMultipleCommandsCancel"); + + } + + /** + * Sources = 2 + * Commands = multiple - Success + * Batching = Full Processing, Single Connector Batch + * result = rollback + */ + public void testMultipleSourceTimeout() throws Exception{ + AbstractQueryTransactionTest userTxn = new AbstractQueryTransactionTest("testMultipleSourceTimeout") { + public void testCase() throws Exception { + executeBatch(getMultipleSourceBatch(), 1); // time out after 1 sec + } + + public boolean exceptionExpected() { + return true; + } + + public void after() { + if (!exceptionOccurred()) { + fail("should have failed with time out exception"); + } + else { + assertTrue(getLastException().getMessage().indexOf("Operation timed out before completion") != -1); + } + } + + public int getNumberRequiredDataSources(){ + return 2; + } + + + public void validateTestCase() throws Exception { + // now verify the results (this may finish under one second, then this test is not valid) + AbstractQueryTest test = new QueryExecution(getSource("pm1")); + test.execute("select * from g1 where e1 >= 600 and e1 < 750"); + test.assertRowCount(0); + test.execute("select * from g2 where e1 >= 600 and e1 < 750"); + test.assertRowCount(0); + test.execute("select distinct e2 from g1 where e1 >= 600 and e1 < 750"); + test.assertRowCount(0); + test.closeConnection(); + } + + }; + getTransactionContainter().runTransaction(userTxn); + + + System.out.println("Complete CommonTransactionTest.testMultipleSourceTimeout"); + + } + + + static String[] getMultipleSourceBatch() { + ArrayList<String> list = new ArrayList<String>(); + + for (int i = 600; i < 750; i++) { + list.add("insert into pm1.g1 (e1, e2) values("+i+",'"+i+"')"); + list.add("insert into pm1.g2 (e1, e2) values ("+i+",'"+i+"')"); + list.add("insert into pm2.g1 (e1, e2) values("+i+",'"+i+"')"); + list.add("insert into pm2.g2 (e1, e2) values ("+i+",'"+i+"')"); + } + + list.add("update pm1.g1 set e2='blah' where pm1.g1.e1 >= 600"); + list.add("update pm2.g1 set e2='blah' where pm2.g1.e1 >= 600"); + + list.add("delete from pm1.g2 where pm1.g2.e1 >= 610"); + list.add("delete from pm1.g1 where pm1.g1.e1 >= 610"); + list.add("delete from pm2.g2 where pm2.g2.e1 >= 610"); + list.add("delete from pm2.g1 where pm2.g1.e1 >= 610"); + + return(String[])list.toArray(new String[list.size()]); + } + + + /** + * Sources = 2 + * Commands = 1, Select + * Batching = Partial Processing, Single Connector Batch + * result = commit + * Note: This is producing the below error some times; however this is SQL Server issue. + * http://support.microsoft.com/?kbid=834849 + */ + public void testMultipleSourcePartialProcessingUsingLimit() throws Exception { + AbstractQueryTransactionTest userTxn = new AbstractQueryTransactionTest("testMultipleSourcePartialProcessingUsingLimit") { + public void testCase() throws Exception { + execute("select * from vm.g1 where pm1e1 < 100 limit 10"); + assertRowCount(10); + } + + public int getNumberRequiredDataSources(){ + return 2; + } + + + public void validateTestCase() throws Exception { + } + + }; + + // run test + getTransactionContainter().runTransaction(userTxn); + + System.out.println("Complete CommonTransactionTest.testMultipleSourcePartialProcessingUsingLimit"); + + } + + /** + * Sources = 2 + * Commands = 1, Select + * Batching = Partial Processing, Single Connector Batch + * result = commit + * Note: This is producing the below error some times; however this is SQL Server issue. + * http://support.microsoft.com/?kbid=834849 + */ + public void testMultipleSourcePartialProcessingUsingMakedep() throws Exception { + AbstractQueryTransactionTest userTxn = new AbstractQueryTransactionTest("testMultipleSourcePartialProcessingUsingMakedep") { + public void testCase() throws Exception { + execute("select pm1.g1.e1, pm1.g1.e2 from pm1.g1 LEFT OUTER JOIN pm2.g1 MAKENOTDEP ON pm1.g1.e2 = pm2.g1.e2 where pm2.g1.e1 >= 50 and pm2.g1.e1 < 100"); + assertRowCount(50); + } + + public int getNumberRequiredDataSources(){ + return 2; + } + + + public void validateTestCase() throws Exception { + } + + }; + + // run test + getTransactionContainter().runTransaction(userTxn); + + System.out.println("Complete CommonTransactionTest.testMultipleSourcePartialProcessingUsingMakedep"); + + } + + /** + * Sources = 2 + * Commands = multiple - Success + * Batching = Full Processing, Single Connector Batch + * result = rollback + */ + public void testMultipleSourceMultipleCommandsExplicitRollback() throws Exception { + AbstractQueryTransactionTest userTxn = new AbstractQueryTransactionTest("testMultipleSourceMultipleCommandsExplicitRollback") { + public void testCase() throws Exception { + + for (int i = 700; i < 720; i++) { + Integer val = new Integer(i); + execute("insert into pm1.g1 (e1, e2) values(?,?)", new Object[] {val, val.toString()}); + execute("insert into pm1.g2 (e1, e2) values(?,?)", new Object[] {val, val.toString()}); + + execute("insert into pm2.g1 (e1, e2) values(?,?)", new Object[] {val, val.toString()}); + execute("insert into pm2.g2 (e1, e2) values(?,?)", new Object[] {val, val.toString()}); + } + } + + // force the rollback + public boolean rollbackAllways() { + return true; + } + + public boolean exceptionExpected() { + return true; + } + + public int getNumberRequiredDataSources(){ + return 2; + } + + + public void validateTestCase() throws Exception { + // now verify the results + AbstractQueryTest test = new QueryExecution(getSource("pm1")); + test.execute("select * from g1 where e1 >= 700 and e1 < 720"); + test.assertRowCount(0); + test.closeConnection(); + + test = new QueryExecution(getSource("pm2")); + test.execute("select * from g1 where e1 >= 700 and e1 < 720"); + test.assertRowCount(0); + test.closeConnection(); + + } + + + }; + + // run test + getTransactionContainter().runTransaction(userTxn); + + System.out.println("Complete testMultipleSourceMultipleCommandsExplicitRollback"); + + } + + /** + * Sources = 2 + * Commands = multiple - Success + * Batching = Full Processing, Single Connector Batch + * result = rollback + */ + public void testMultipleSourceMultipleCommandsReferentialIntegrityRollback() throws Exception { + AbstractQueryTransactionTest userTxn = new AbstractQueryTransactionTest("testMultipleSourceMultipleCommandsReferentialIntegrityRollback") { + public void testCase() throws Exception { + + for (int i = 700; i < 720; i++) { + Integer val = new Integer(i); + execute("insert into pm1.g1 (e1, e2) values(?,?)", new Object[] {val, val.toString()}); + execute("insert into pm1.g2 (e1, e2) values(?,?)", new Object[] {val, val.toString()}); + + execute("insert into pm2.g1 (e1, e2) values(?,?)", new Object[] {val, val.toString()}); + execute("insert into pm2.g2 (e1, e2) values(?,?)", new Object[] {val, val.toString()}); + } + + // force the rollback by trying to insert an invalid row. + execute("insert into pm1.g2 (e1, e2) values(?,?)", new Object[] {new Integer(9999), "9999"}); + } + + public boolean exceptionExpected() { + return true; + } + + public int getNumberRequiredDataSources(){ + return 2; + } + + + public void validateTestCase() throws Exception { + // now verify the results + AbstractQueryTest test = new QueryExecution(getSource("pm1")); + test.execute("select * from g1 where e1 >= 700 and e1 < 720"); + test.assertRowCount(0); + test.closeConnection(); + + test = new QueryExecution(getSource("pm2")); + test.execute("select * from g1 where e1 >= 700 and e1 < 720"); + test.assertRowCount(0); + test.closeConnection(); + } + + }; + + // run test + getTransactionContainter().runTransaction(userTxn); + + + System.out.println("Complete testMultipleSourceMultipleCommandsReferentialIntegrityRollback"); + + } + + /** + * Sources = 2 + * Commands = 1, Update + * Batching = Full Processing, Single Connector Batch + * result = commit + */ + public void testMultipleSourceBulkRowInsertRollback() throws Exception { + AbstractQueryTransactionTest userTxn = new AbstractQueryTransactionTest("testMultipleSourceBulkRowInsertRollback") { + public void testCase() throws Exception { + for (int i = 100; i < 120; i++) { + Integer val = new Integer(i); + execute("insert into vm.g1 (pm1e1, pm1e2, pm2e1, pm2e2) values(?,?,?,?)", new Object[] {val, val.toString(), val, val.toString()}); + } + execute("select pm1.g1.e1, pm1.g1.e2 into pm2.g2 from pm1.g1 where pm1.g1.e1 >= 100"); + + // force the rollback by trying to insert an invalid row. + execute("insert into pm1.g2 (e1, e2) values(?,?)", new Object[] {new Integer(9999), "9999"}); + } + + public boolean exceptionExpected() { + return true; + } + + public int getNumberRequiredDataSources(){ + return 2; + } + + + public void validateTestCase() throws Exception { + // now verify the results + AbstractQueryTest test = new QueryExecution(getSource("pm1")); + test.execute("select * from g1 where e1 >= 100 and e1 < 120"); + test.assertRowCount(0); + test.closeConnection(); + + test = new QueryExecution(getSource("pm2")); + test.execute("select * from g1 where e1 >= 100 and e1 < 120"); + test.assertRowCount(0); + test.execute("select * from g2 where e1 >= 100 and e1 < 120"); + test.assertRowCount(0); + test.closeConnection(); + } + + }; + + // run test + getTransactionContainter().runTransaction(userTxn); + + + System.out.println("Complete testMultipleSourceBulkRowInsertRollback"); + + } + + /** + * Sources = 2 + * Commands = multiple - Success + * Batching = Full Processing, Single Connector Batch + * result = commit + */ + public void testMultipleSourceMultipleVirtualCommandsRollback() throws Exception { + AbstractQueryTransactionTest userTxn = new AbstractQueryTransactionTest("testMultipleSourceMultipleVirtualCommandsRollback") { + public void testCase() throws Exception { + + for (int i = 600; i < 615; i++) { + Integer val = new Integer(i); + execute("insert into vm.g1 (pm1e1, pm1e2, pm2e1, pm2e2) values(?,?,?,?)", new Object[] {val, val.toString(), val, val.toString()}); + execute("insert into vm.g2 (pm1e1, pm1e2, pm2e1, pm2e2) values(?,?,?,?)", new Object[] {val, val.toString(), val, val.toString()}); + } + + execute("select * from vm.g1 where pm1e1 >= 600 and pm1e1 < 615"); + assertRowCount(15); + + + execute("update vm.g1 set pm1e2='blah' where pm1e1 >= 605"); + + execute("delete from vm.g2 where vm.g2.pm1e1 >= 610"); + execute("delete from vm.g1 where vm.g1.pm1e1 >= 610"); + + execute("select * from vm.g1 where pm1e1 >= 600 and pm1e1 < 615"); + assertRowCount(10); + + // force the rollback by trying to insert an invalid row. + execute("insert into pm1.g2 (e1, e2) values(?,?)", new Object[] {new Integer(9999), "9999"}); + } + + public boolean exceptionExpected() { + return true; + } + + public int getNumberRequiredDataSources(){ + return 2; + } + + + public void validateTestCase() throws Exception { + // now verify the results + AbstractQueryTest test = new QueryExecution(getSource("pm1")); + test.execute("select * from g1 where e1 >= 600 and e1 < 615"); + test.assertRowCount(0); + test.execute("select * from g2 where e1 >= 600 and e1 < 615"); + test.assertRowCount(0); + test.execute("select distinct e2 from g1 where e1 >= 600 and e1 < 615"); + test.assertRowCount(0); + test.closeConnection(); + } + + }; + + // run test + getTransactionContainter().runTransaction(userTxn); + + + System.out.println("Complete testMultipleSourceMultipleVirtualCommandsRollback"); + + } + + +} Property changes on: trunk/test-integration/db/src/test/java/org/teiid/test/testcases/TwoSourceTransactionTest.java ___________________________________________________________________ Name: svn:mime-type + text/plain