[teiid-commits] teiid SVN: r1327 - in trunk/test-integration/db/src/test/java/org/teiid/test: framework/datasource and 1 other directories.
teiid-commits at lists.jboss.org
teiid-commits at lists.jboss.org
Fri Sep 11 15:19:37 EDT 2009
Author: vhalbert at 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
More information about the teiid-commits
mailing list