Author: vhalbert(a)redhat.com Date: 2009-10-06 11:15:15 -0400 (Tue, 06 Oct 2009) New Revision: 1526 Modified: trunk/test-integration/db/src/main/java/org/teiid/test/framework/ConfigPropertyLoader.java trunk/test-integration/db/src/main/java/org/teiid/test/framework/TransactionContainer.java trunk/test-integration/db/src/main/java/org/teiid/test/framework/TransactionQueryTest.java trunk/test-integration/db/src/main/java/org/teiid/test/framework/connection/ConnectionStrategy.java trunk/test-integration/db/src/main/java/org/teiid/test/framework/datasource/DataSource.java trunk/test-integration/db/src/main/java/org/teiid/test/framework/datasource/DataSourceFactory.java trunk/test-integration/db/src/main/java/org/teiid/test/framework/transaction/LocalTransaction.java Log: Teiid 773 - updated logic to support fine grain control over which datasource type is assigned to which model Modified: trunk/test-integration/db/src/main/java/org/teiid/test/framework/ConfigPropertyLoader.java =================================================================== --- trunk/test-integration/db/src/main/java/org/teiid/test/framework/ConfigPropertyLoader.java 2009-10-06 15:13:18 UTC (rev 1525) +++ trunk/test-integration/db/src/main/java/org/teiid/test/framework/ConfigPropertyLoader.java 2009-10-06 15:15:15 UTC (rev 1526) @@ -1,5 +1,7 @@ package org.teiid.test.framework; +import java.util.HashMap; +import java.util.Map; import java.util.Properties; import org.teiid.test.framework.exception.TransactionRuntimeException; @@ -13,7 +15,7 @@ * These properties only live for the duration of one test. * * NOTE: System properties set by the VM will be considered long living. This is so the - * -Dusedatasources option can be maintained for the duration of a set of tests. + * -Dusedatasources ( {@link ConfigPropertyNames#USE_DATASOURCES_PROP} ) option can be maintained for the duration of a set of tests. * * * @author vanhalbert @@ -28,6 +30,8 @@ public static final String DEFAULT_CONFIG_FILE_NAME = "default-config.properties"; private Properties props = null; + + private Map<String, String>modelAssignedDatabaseType = new HashMap<String, String>(5); private ConfigPropertyLoader() { } @@ -66,6 +70,14 @@ public Properties getProperties() { return props; } + + public Map getModelAssignedDatabaseTypes() { + return this.modelAssignedDatabaseType; + } + + public void setModelAssignedToDatabaseType(String modelname, String dbtype) { + this.modelAssignedDatabaseType.put(modelname, dbtype); + } private void loadProperties(String filename) { Modified: trunk/test-integration/db/src/main/java/org/teiid/test/framework/TransactionContainer.java =================================================================== --- trunk/test-integration/db/src/main/java/org/teiid/test/framework/TransactionContainer.java 2009-10-06 15:13:18 UTC (rev 1525) +++ trunk/test-integration/db/src/main/java/org/teiid/test/framework/TransactionContainer.java 2009-10-06 15:15:15 UTC (rev 1526) @@ -61,12 +61,14 @@ // cleanup all defined datasources for the last test and // any overrides regarding inclusions and exclusions. - this.dsfactory.cleanup(); - + if (dsfactory != null) { + this.dsfactory.cleanup(); + } // cleanup all connections created for this test. - connStrategy.shutdown(); - + if (connStrategy != null) { + connStrategy.shutdown(); + } } } @@ -79,15 +81,16 @@ try { setUp(test); + test.setConnectionStrategy(connStrategy); + - if (test.getNumberRequiredDataSources() > this.dsfactory.getNumberAvailableDataSources()) { - detail(test.getTestName() + " will not be run, it requires " + test.getNumberRequiredDataSources() + - " datasources, but only available is " + this.dsfactory.getNumberAvailableDataSources()); + if (!test.hasRequiredDataSources()) { return; } + + - test.setConnectionStrategy(connStrategy); - test.setupDataSource(); + test.setupDataSource(); debug(" setConnection"); Modified: trunk/test-integration/db/src/main/java/org/teiid/test/framework/TransactionQueryTest.java =================================================================== --- trunk/test-integration/db/src/main/java/org/teiid/test/framework/TransactionQueryTest.java 2009-10-06 15:13:18 UTC (rev 1525) +++ trunk/test-integration/db/src/main/java/org/teiid/test/framework/TransactionQueryTest.java 2009-10-06 15:15:15 UTC (rev 1526) @@ -62,18 +62,16 @@ void setConnectionStrategy(ConnectionStrategy connStrategy); /** - * The test case has to specify how many sources its using so that the correct - * data setup is performed. - * @return int is the number of datasources in use + * Indicates if the test has the required datasources in order to execute. + * If it doesn't have the required datasources, it will be bypassed for execution. + * @return true if the test has the required sources to execute * * @since */ - - int getNumberRequiredDataSources(); + boolean hasRequiredDataSources(); + - - /** * Called by the {@link TransactionContainer} prior to testcase processing so that * the responsibility for performing datasource setup can be done Modified: trunk/test-integration/db/src/main/java/org/teiid/test/framework/connection/ConnectionStrategy.java =================================================================== --- trunk/test-integration/db/src/main/java/org/teiid/test/framework/connection/ConnectionStrategy.java 2009-10-06 15:13:18 UTC (rev 1525) +++ trunk/test-integration/db/src/main/java/org/teiid/test/framework/connection/ConnectionStrategy.java 2009-10-06 15:15:15 UTC (rev 1526) @@ -79,7 +79,7 @@ } private void shutDownSources(Map<String, ConnectionStrategy> sources) { - for (Iterator it=sources.keySet().iterator(); it.hasNext(); ){ + for (Iterator<String> it=sources.keySet().iterator(); it.hasNext(); ){ ConnectionStrategy cs = sources.get(it.next()); try { cs.shutdown(); @@ -114,6 +114,10 @@ return env; } + public int getNumberAvailableDataSources() { + return this.dsFactory.getNumberAvailableDataSources(); + } + public Map<String, DataSource> getDataSources() { return this.datasources; } Modified: trunk/test-integration/db/src/main/java/org/teiid/test/framework/datasource/DataSource.java =================================================================== --- trunk/test-integration/db/src/main/java/org/teiid/test/framework/datasource/DataSource.java 2009-10-06 15:13:18 UTC (rev 1525) +++ trunk/test-integration/db/src/main/java/org/teiid/test/framework/datasource/DataSource.java 2009-10-06 15:15:15 UTC (rev 1526) @@ -49,23 +49,7 @@ return this.dbtype; } - - /** - * These types match the "ddl" directories for supported database types - * and it also found in the datasources connection.properties defined by the DB_TYPE property - * @author vanhalbert - * - */ - public static interface DataSourcTypes{ - public static String MYSQL = "mysql"; - public static String ORACLE = "oracle"; - public static String POSTRES = "postgres"; - public static String SQLSERVER = "sqlserver"; - public static String DB2 = "db2"; - public static String SYBASE = "sybase"; - public static String DERBY = "derby"; + - } - } Modified: trunk/test-integration/db/src/main/java/org/teiid/test/framework/datasource/DataSourceFactory.java =================================================================== --- trunk/test-integration/db/src/main/java/org/teiid/test/framework/datasource/DataSourceFactory.java 2009-10-06 15:13:18 UTC (rev 1525) +++ trunk/test-integration/db/src/main/java/org/teiid/test/framework/datasource/DataSourceFactory.java 2009-10-06 15:15:15 UTC (rev 1526) @@ -16,32 +16,73 @@ /** * The DataSourceFactory is responsible for managing the datasources used during a single test. - * It ensures the same data source is used in both the connector binding and during validation. - * Otherwise, validation may be validating against a source for which the test didn't run. + * It ensures the same data source is used in both the connector binding and during validation to ensure validation is performed + * against the same datasource the test was performed on. + * + * The following are the available options for controlling which datasources are used during a test: + * <li>Control which datasources are used and to which model they are assigned</li> * - * A test has the option of specifying the following properties to control which data sources are / or not used + * <p> + * Use the {@link ConfigPropertyNames#USE_DATASOURCES_PROP} property to specify a comma delimited ordered list to control which data sources to use. * - * <li>{@link ConfigPropertyNames#USE_DATASOURCES_PROP} : is a comma delimited ordered list to control which data sources to use</li> + * <br><br> + * This will enable integration testing to be setup to use well known combinations, to ensure coverage and makes it easier to replicate issues. * - * This is an ordered list because based on the model:order mapping in the config.properties file will map to the ordered list - * respectfully. + * This indicates to use only the specified datasources for this test. This option can be used in test cases where only + * specific sources are to be used and tested against. * - * Example: in the config.properties may specify: - * pm1=1 - * pm2=2 + * This ordered list will map to the model:order mapping in the config.properties file. + * <br><br> + * Example: in the config.properties file, the models in the test and their order can be specified: + * <li> pm1=1 </li> + * <li> pm2=2 </li> + * <br> * - * Set ConfigPropertyNames.USE_DATASOURCES_PROP=oracle,sqlserver + * Then set property: ConfigPropertyNames.USE_DATASOURCES_PROP=oracle,sqlserver * - * This indicates that when a datasource is requested for "pm1", then oracle datasource will be returned. And when a data source - * for "pm2" is requested, then a data source representing sqlserver will be returned. + * This will use oracle and sqlserver datasources in the test, and when a datasource is requested for model "pm1", the oracle datasource will be returned. And when a data source + * for "pm2" is requested, the data source mapped to 2nd ordered datasource of sqlserver will be returned. + * + * </p> + * <li>Control which datasources of a specific database type to exclude</li> + * <p> + * + * Use the {@link ConfigPropertyNames#EXCLUDE_DATASBASE_TYPES_PROP} property to specify a comma delimited list of {@link DataBaseTypes} to exclude. + * <br><br> + * This will remove all datasources of a specific database type from the list of available datasources. This option will be applied after + * {@link ConfigPropertyNames#USE_DATASOURCES_PROP} option. This is done because there are some test that will not work with certain database + * types, and therefore, if the required datasources are not met, the test will be bypassed for execution. + *</p> + * <li>Control for a specfic model, which database type of datasource to be assigned</li> + * <p> + * This option gives the developer even more fine grain control of how datasources are assigned. There are cases where a specific model must be assigned + * to a datasource of a specific database type. * - * <li>{@link ConfigPropertyNames#EXCLUDE_DATASBASE_TYPES_PROP} : is a comma delimited list indicating which data sources not use - * during that specific test. - * + * To use this option, + * + * </p> * @author vanhalbert * */ public class DataSourceFactory { + + /** + * These types match the "ddl" directories for supported database types + * and it also found in the datasources connection.properties defined by the DB_TYPE property + * These are also the values used to specify the required database types. + * + */ + public static interface DataBaseTypes{ + public static String MYSQL = "mysql"; + public static String ORACLE = "oracle"; + public static String POSTRES = "postgres"; + public static String SQLSERVER = "sqlserver"; + public static String DB2 = "db2"; + public static String SYBASE = "sybase"; + public static String DERBY = "derby"; + public static String ANY = "any"; + + } // the DO_NO_USE_DEFAULT will be passed in when the test are run from maven and no property is passed in for UseDataSources private static final String DO_NOT_USE_DEFAULT="${usedatasources}"; @@ -50,24 +91,31 @@ // contains the names of the datasources when the -Dusedatasources option is used private Map<String, String> useDS = null; - private Map<String, DataSource> useDataSources = null; + // contains all the datasources available to be used + private Map<String, DataSource> availDS = null; // map of the datasources assigned to with model - private Map<String, DataSource> modelToDatasourceMap = new HashMap<String, DataSource>(); // key - // = - // modelname - // + - // "_" - // + - // datasourceid + private Map<String, DataSource> modelToDatasourceMap = new HashMap<String, DataSource>(); // key = modelname + + // contains any dbtype preconditions on a model, which requires a model to be assigned a certain database type + private Map<String, String> requiredDataBaseTypes = null; // key=modelname value=dbtype // this set is use to track datasources that have already been assigned private Set<String> assignedDataSources = new HashSet<String>(); private int lastassigned = 0; + + // indicates if the datasource requirements have been, it will be false in the case + // a specific dbtype is required and that type was not one of the available types defined + private boolean metDBRequiredTypes = true; + + // indicates that there are required dbtypes to consider + private boolean hasRequiredDBTypes = false; + public DataSourceFactory(ConfigPropertyLoader config) { this.configprops = config; + this.requiredDataBaseTypes = config.getModelAssignedDatabaseTypes(); config(); } @@ -88,8 +136,21 @@ Map<String, DataSource> availDatasources = DataSourceMgr.getInstance().getDataSources(); - useDataSources = new HashMap<String, DataSource>(availDatasources.size()); + availDS = new HashMap<String, DataSource>(availDatasources.size()); + String excludeprop = configprops + .getProperty(ConfigPropertyNames.EXCLUDE_DATASBASE_TYPES_PROP); + + Set<String> excludedDBTypes = null; + + if (excludeprop != null && excludeprop.length() > 0) { + List<String> eprops = StringUtil.split(excludeprop, ","); + excludedDBTypes = new HashSet<String>(eprops.size()); + excludedDBTypes.addAll(eprops); + System.out.println("EXCLUDE datasources: " + excludeprop); + } + + String limitdsprop = configprops .getProperty(ConfigPropertyNames.USE_DATASOURCES_PROP); if (limitdsprop != null && limitdsprop.length() > 0 && ! limitdsprop.equalsIgnoreCase(DO_NOT_USE_DEFAULT)) { @@ -102,46 +163,100 @@ int i = 1; for (Iterator<String> it = dss.iterator(); it.hasNext(); i++) { String dssName = it.next(); - useDS.put(String.valueOf(i), dssName); ds = availDatasources.get(dssName); - useDataSources.put(dssName, ds); + if (!excludedDBTypes.contains(ds.getDBType())) { + useDS.put(String.valueOf(i), dssName); + + availDS.put(dssName, ds); + } + } } else { - useDataSources.putAll(availDatasources); + for (Iterator<DataSource> it = availDatasources.values().iterator(); it.hasNext(); ) { + DataSource ds = it.next(); + if (!excludedDBTypes.contains(ds.getDBType())) { + availDS.put(ds.getName(), ds); + + // availDS.putAll(availDatasources); + } + } } - String excludeprop = configprops - .getProperty(ConfigPropertyNames.EXCLUDE_DATASBASE_TYPES_PROP); +// String excludeprop = configprops +// .getProperty(ConfigPropertyNames.EXCLUDE_DATASBASE_TYPES_PROP); +// +// Set<String> excludedDBTypes = null; +// +// if (excludeprop != null && excludeprop.length() > 0) { +// List<String> eprops = StringUtil.split(excludeprop, ","); +// excludedDBTypes = new HashSet<String>(eprops.size()); +// excludedDBTypes.addAll(eprops); +// System.out.println("EXCLUDE datasources: " + excludeprop); +// +// Iterator<DataSource> it = availDS.values().iterator(); +// +// // go thru all the datasources and remove those that are excluded +// while (it.hasNext()) { +// DataSource checkit = it.next(); +// +// if (excludedDBTypes.contains(checkit.getDBType())) { +// it.remove(); +// +// if (useDS != null) { +// useDS +// } +// } +// +// +// } +// +// } - Set<String> excludedDBTypes = null; - - if (excludeprop != null && excludeprop.length() > 0) { - List<String> eprops = StringUtil.split(excludeprop, ","); - excludedDBTypes = new HashSet<String>(eprops.size()); - excludedDBTypes.addAll(eprops); - System.out.println("EXCLUDE datasources: " + excludeprop); + + if (requiredDataBaseTypes != null) { + this.hasRequiredDBTypes = true; - Iterator<DataSource> it = useDataSources.values().iterator(); + Iterator<String> rit = this.requiredDataBaseTypes.keySet().iterator(); // go thru all the datasources and remove those that are excluded - while (it.hasNext()) { - DataSource checkit = it.next(); + while (rit.hasNext()) { + String modelName = rit.next(); + String rdbtype = this.requiredDataBaseTypes.get(modelName); + + Iterator<DataSource> ait = availDS.values().iterator(); - if (excludedDBTypes.contains(checkit.getDBType())) { - it.remove(); + metDBRequiredTypes = false; + + // go thru all the datasources and find the matching datasource of the correct dbtype + while (ait.hasNext()) { + DataSource ds = ait.next(); + if (ds.getDBType().equalsIgnoreCase(rdbtype)) { + assignedDataSources.add(ds.getName()); + + modelToDatasourceMap.put(modelName, ds); + metDBRequiredTypes = true; + + } + + } + + if (!metDBRequiredTypes) { + // did find a required dbtype, no need going any further + break; + } + } - } - + } } public int getNumberAvailableDataSources() { - return this.useDataSources.size(); + return (metDBRequiredTypes ? this.availDS.size() :0); } public synchronized DataSource getDatasource(String datasourceid, @@ -155,7 +270,8 @@ // corresponds to the same datasource String key = null; - key = modelName + "_" + datasourceid; + key = modelName; + //+ "_" + datasourceid; // if the datasourceid represents a group name, then use the group name // so that all future request using that group name for a specified @@ -164,49 +280,64 @@ if (modelToDatasourceMap.containsKey(key)) { return modelToDatasourceMap.get(key); } + + if (this.hasRequiredDBTypes) { + if (this.requiredDataBaseTypes.containsKey(modelName)) { + String dbtype = this.requiredDataBaseTypes.get(modelName); + + Iterator<DataSource> it = availDS.values().iterator(); - if (useDS != null) { - String dsname = useDS.get(datasourceid); - if (dsname != null) { - ds = useDataSources.get(dsname); - if (ds == null) { - throw new QueryTestFailedException("Datasource name " - + dsname - + " was not found in the allDatasources map"); + // need to go thru all the datasources to know if any has already been + // assigned + // because the datasourceid passed in was a group name + while (it.hasNext()) { + DataSource checkit = it.next(); + if (dbtype.equalsIgnoreCase(checkit.getDBType())) { + ds = checkit; + break; + } + } - } else { - throw new QueryTestFailedException("Model:id " + modelName - + ":" + datasourceid - + " did not map to the usedatasources: " - + useDS.toString()); + } + + } if (useDS != null) { + String dsname = useDS.get(datasourceid); + if (dsname != null) { + ds = availDS.get(dsname); + if (ds == null) { + throw new QueryTestFailedException("Datasource name " + + dsname + + " was not found in the allDatasources map"); + + } + } else { + throw new QueryTestFailedException("Model:id " + modelName + + ":" + datasourceid + + " did not map to the usedatasources: " + + useDS.toString()); + + } + - modelToDatasourceMap.put(key, ds); - return ds; - - } - - Iterator<DataSource> it = useDataSources.values().iterator(); - - // need to go thru all the datasources to know if any has already been - // assigned - // because the datasourceid passed in was a group name - while (it.hasNext()) { - DataSource checkit = it.next(); - -// if (excludedDBTypes != null -// && excludedDBTypes.contains(checkit.getDBType())) { -// continue; -// } - - if (!assignedDataSources.contains(checkit.getName())) { - ds = checkit; - assignedDataSources.add(ds.getName()); - break; + } else { + + Iterator<DataSource> it = availDS.values().iterator(); + + // need to go thru all the datasources to know if any has already been + // assigned + // because the datasourceid passed in was a group name + while (it.hasNext()) { + DataSource checkit = it.next(); + + if (!assignedDataSources.contains(checkit.getName())) { + ds = checkit; + break; + } + } - } if (ds == null) { @@ -223,7 +354,7 @@ if (cnt == this.lastassigned) { - ds = useDataSources.get(dsname); + ds = availDS.get(dsname); this.lastassigned++; if (lastassigned >= assignedDataSources.size()) { @@ -243,6 +374,8 @@ } + assignedDataSources.add(ds.getName()); + modelToDatasourceMap.put(key, ds); return ds; @@ -287,7 +420,7 @@ try { - DataSource dsfind = factory.getDatasource("2", "model1"); + DataSource dsfind = factory.getDatasource("2", "model2"); if (dsfind == null) { throw new RuntimeException("No datasource was not found as the 2nd datasource"); @@ -335,6 +468,8 @@ if (ds1 == null) { throw new RuntimeException("No datasource was found for: model:" + k); + } if (ds1.getDBType().equalsIgnoreCase(DataSourceFactory.DataBaseTypes.SQLSERVER)) { + throw new RuntimeException("sqlserver dbtype should have been excluded"); } } @@ -346,7 +481,71 @@ throw new RuntimeException("The process was not able to reassign an already used datasource"); } + + factory.cleanup(); + + + // test required database types + // test 1 source + config = ConfigPropertyLoader.createInstance(); + + config.setModelAssignedToDatabaseType("pm1", DataSourceFactory.DataBaseTypes.ORACLE); + + factory = new DataSourceFactory(config); + + DataSource ds1 = factory.getDatasource("1","pm1"); + if (!ds1.getDBType().equalsIgnoreCase(DataSourceFactory.DataBaseTypes.ORACLE)) { + throw new RuntimeException("Required DB Type of oracle for model pm1 is :" + ds1.getDBType()); + } + + System.out.println("Test1 Required DS1 " + ds1.getDBType()); + factory.cleanup(); + + // test required database types + // test 2 sources, 1 required and other ANY + config = ConfigPropertyLoader.createInstance(); + + + config.setModelAssignedToDatabaseType("pm2", DataSourceFactory.DataBaseTypes.SQLSERVER); + config.setModelAssignedToDatabaseType("pm1", DataSourceFactory.DataBaseTypes.ANY); + + factory = new DataSourceFactory(config); + + DataSource ds2 = factory.getDatasource("2","pm2"); + if (!ds2.getDBType().equalsIgnoreCase(DataSourceFactory.DataBaseTypes.SQLSERVER)) { + throw new RuntimeException("Required DB Type of sqlserver for model pm2 is :" + ds2.getDBType()); + } + System.out.println("Test2 Required DS2 " + ds2.getDBType()); + + factory.cleanup(); + + + // test required database types + // test 2 sources, 2 required + config = ConfigPropertyLoader.createInstance(); + + + config.setModelAssignedToDatabaseType("pm2", DataSourceFactory.DataBaseTypes.SQLSERVER); + config.setModelAssignedToDatabaseType("pm1", DataSourceFactory.DataBaseTypes.ORACLE); + + factory = new DataSourceFactory(config); + + DataSource ds3a = factory.getDatasource("2","pm2"); + if (!ds3a.getDBType().equalsIgnoreCase(DataSourceFactory.DataBaseTypes.SQLSERVER)) { + throw new RuntimeException("Required DB Type of sqlserver for model pm12 is :" + ds3a.getDBType()); + } + + DataSource ds3b = factory.getDatasource("2","pm1"); + if (!ds3b.getDBType().equalsIgnoreCase(DataSourceFactory.DataBaseTypes.ORACLE)) { + throw new RuntimeException("Required DB Type of oracle for model pm1 is :" + ds3b.getDBType()); + } + System.out.println("Test3 Required DS3a " + ds3a.getDBType()); + System.out.println("Test3 Required DS3b " + ds3b.getDBType()); + + factory.cleanup(); + + } catch (QueryTestFailedException e) { e.printStackTrace(); } Modified: trunk/test-integration/db/src/main/java/org/teiid/test/framework/transaction/LocalTransaction.java =================================================================== --- trunk/test-integration/db/src/main/java/org/teiid/test/framework/transaction/LocalTransaction.java 2009-10-06 15:13:18 UTC (rev 1525) +++ trunk/test-integration/db/src/main/java/org/teiid/test/framework/transaction/LocalTransaction.java 2009-10-06 15:15:15 UTC (rev 1526) @@ -35,7 +35,7 @@ } protected void after(TransactionQueryTest test) { - // boolean exception = false; + boolean exception = false; try { if (test.rollbackAllways()|| test.exceptionOccurred()) { test.getConnection().rollback(); @@ -45,7 +45,7 @@ test.getConnection().commit(); } } catch (SQLException se) { -// exception = true; + exception = true; // if exception, try to trigger the rollback try { test.getConnection().rollback(); @@ -58,13 +58,13 @@ } finally { // if an exception occurs and the autocommit is set to true - while doing a transaction // will generate a new exception overriding the first exception -// if (!exception) { -// try { -// test.getConnection().setAutoCommit(true); -// } catch (SQLException e) { -// throw new RuntimeException(e); -// } -// } + if (!exception) { + try { + test.getConnection().setAutoCommit(true); + } catch (SQLException e) { + throw new RuntimeException(e); + } + } } }