/**
* Copyright (C) 2009 - present by OpenGamma Inc. and the OpenGamma group of companies
*
* Please see distribution for license.
*/
package com.opengamma.util.test;
import static org.testng.AssertJUnit.assertEquals;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.apache.commons.lang.StringUtils;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.opengamma.util.ArgumentChecker;
import com.opengamma.util.db.script.DbSchemaGroupMetadata;
import com.opengamma.util.db.script.DbScriptUtils;
import com.opengamma.util.db.tool.DbTool;
import com.opengamma.util.db.tool.DbTool.TableCreationCallback;
import com.opengamma.util.time.DateUtils;
import com.opengamma.util.tuple.Triple;
/**
* Tests the creation + upgrade sequence results in the same structure as a pure create.
*/
public abstract class AbstractDbUpgradeTest implements TableCreationCallback {
private static final Map<String, Map<String, String>> s_targetSchema = Maps.newHashMap();
private final List<Triple<String, String, String>> _comparisons = Lists.newLinkedList();
private final String _schemaGroupName;
private final String _databaseType;
private final int _targetVersion;
private final int _createVersion;
private volatile DbTool _dbTool;
static {
// initialize the clock
DateUtils.initTimeZone();
}
/**
* Creates an instance.
*
* @param databaseType the database type, not null
* @param schemaGroupName the schema group name, not null
* @param targetVersion the target version
* @param createVersion the create version
*/
protected AbstractDbUpgradeTest(String databaseType, String schemaGroupName, final int targetVersion, final int createVersion) {
ArgumentChecker.notNull(schemaGroupName, "schameGroupName");
ArgumentChecker.notNull(databaseType, "databaseType");
_schemaGroupName = schemaGroupName;
_databaseType = databaseType;
_targetVersion = targetVersion;
_createVersion = createVersion;
}
//-------------------------------------------------------------------------
@BeforeMethod(alwaysRun = true)
public void setUp() throws Exception {
DbTool dbTool = getDbTool();
dbTool.setTargetVersion(_targetVersion);
dbTool.setCreateVersion(_createVersion);
dbTool.dropTestSchema();
dbTool.createTestSchema();
dbTool.createTables(DbScriptUtils.getDbSchemaGroupMetadata(_schemaGroupName), dbTool.getTestCatalog(), dbTool.getTestSchema(), _targetVersion, _createVersion, this);
dbTool.clearTestTables();
}
@AfterMethod(alwaysRun = true)
public void tearDown() {
// need to clear version cache from here
// this is messy but necessary
AbstractDbTest.s_databaseTypeVersion.clear();
}
//-------------------------------------------------------------------------
protected DbTool getDbTool() {
return initDbTool();
}
/**
* Initializes the DBTool outside the constructor.
* This works better with TestNG and Maven, where the constructor is called
* even if the test is never run.
*/
private DbTool initDbTool() {
DbTool dbTool = _dbTool;
if (dbTool == null) {
synchronized (this) {
dbTool = _dbTool;
if (dbTool == null) {
_dbTool = dbTool = DbTest.createDbTool(_databaseType, null); // CSIGNORE
}
}
}
return dbTool;
}
//-------------------------------------------------------------------------
protected Map<String, String> getVersionSchemas() {
Map<String, String> versionSchema = s_targetSchema.get(_databaseType);
if (versionSchema == null) {
versionSchema = new HashMap<>();
s_targetSchema.put(_databaseType, versionSchema);
}
return versionSchema;
}
//-------------------------------------------------------------------------
@Test(groups = TestGroup.UNIT_DB)
public void testDatabaseUpgrade() {
for (Triple<String, String, String> comparison : _comparisons) {
/*
* System.out.println(comparison.getFirst() + " expected:");
* System.out.println(comparison.getSecond());
* System.out.println(comparison.getFirst() + " found:");
* System.out.println(comparison.getThird());
*/
int diff = StringUtils.indexOfDifference(comparison.getSecond(), comparison.getThird());
if (diff >= 0) {
System.err.println("Difference at " + diff);
System.err.println("Upgraded --->..." + StringUtils.substring(comparison.getSecond(), diff - 200, diff) +
"<-!!!->" + StringUtils.substring(comparison.getSecond(), diff, diff + 200) + "...");
System.err.println(" Created --->..." + StringUtils.substring(comparison.getThird(), diff - 200, diff) +
"<-!!!->" + StringUtils.substring(comparison.getThird(), diff, diff + 200) + "...");
}
assertEquals(_databaseType + ": " + comparison.getFirst(), comparison.getSecond(), comparison.getThird());
}
}
@Override
public void tablesCreatedOrUpgraded(final int version, final DbSchemaGroupMetadata schemaGroupMetadata) {
final Map<String, String> versionSchemas = getVersionSchemas();
String key = schemaGroupMetadata.getSchemaGroupName() + "_" + version;
if (versionSchemas.containsKey(key)) {
// if we've already done the full schema, then we want to test that this upgrade has given us the same (but defer the comparison)
_comparisons.add(new Triple<String, String, String>(key, versionSchemas.get(key), _dbTool.describeDatabase(schemaGroupMetadata.getSchemaGroupName())));
} else {
// tests are run with most recent full schema first, so we can store that as a reference
versionSchemas.put(key, _dbTool.describeDatabase(schemaGroupMetadata.getSchemaGroupName()));
}
}
@Override
public String toString() {
return _databaseType + "/" + _schemaGroupName + ":" + _createVersion + " >>> " + _targetVersion;
}
}