/*******************************************************************************
* Copyright (c) 1998, 2015 Oracle and/or its affiliates. All rights reserved.
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
* which accompanies this distribution.
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* Contributors:
* Oracle - initial API and implementation from Oracle TopLink
******************************************************************************/
package org.eclipse.persistence.testing.tests.flashback;
import java.util.*;
import java.math.*;
import org.eclipse.persistence.testing.models.employee.domain.*;
import org.eclipse.persistence.expressions.*;
import org.eclipse.persistence.history.*;
import org.eclipse.persistence.internal.history.*;
import org.eclipse.persistence.internal.sessions.AbstractSession;
import org.eclipse.persistence.platform.database.OraclePlatform;
import org.eclipse.persistence.queries.*;
import org.eclipse.persistence.mappings.querykeys.*;
import org.eclipse.persistence.sessions.DatabaseLogin;
import org.eclipse.persistence.sessions.Session;
import org.eclipse.persistence.exceptions.*;
import org.eclipse.persistence.testing.framework.*;
/**
* <b>Purpose:</b> Tests all those unique scenarios involving
* Flashback that can not easily be generalized into a few
* generic cases.
*/
public class FlashbackUnitTestSuite extends TestSuite {
public FlashbackUnitTestSuite() {
setDescription("Fast unit testing of the flashback feature.");
}
protected Object getSystemChangeNumber() {
return ((FlashbackTestModel)getContainer()).getSystemChangeNumber();
}
protected Object getTimestamp() {
return FlashbackTestModel.getTimestamp();
}
protected AsOfClause getAsOfClause() {
return ((FlashbackTestModel)getContainer()).getAsOfClause();
}
public void _testAsOfStringLiteralTest() {
if (getSession().getProject().hasGenericHistorySupport()) {
return;
}
ValueReadQuery scnQuery = ((OraclePlatform)getSession().getPlatform()).getSystemChangeNumberQuery();
long sCNNow = ((BigDecimal)getSession().executeQuery(scnQuery)).longValue();
long testSCN = ((Number)getAsOfClause().getValue()).longValue();
ExpressionBuilder builder = new ExpressionBuilder(Employee.class);
AsOfClause sCNClause = new AsOfSCNClause(builder.value("" + sCNNow + " - " + (sCNNow - testSCN)));
ReadAllQuery query = new ReadAllQuery(Employee.class);
query.setAsOfClause(sCNClause);
query.dontMaintainCache();
Vector result = (Vector)getSession().executeQuery(query);
if (result.size() != 12) {
throw new TestErrorException("Expected 12 objects, read " + result.size());
}
}
public void _testAsOfParameterTest() {
ReadAllQuery query = new ReadAllQuery(Employee.class);
query.dontMaintainCache();
query.addArgument("ASOFCLAUSE");
Vector arguments = new Vector();
Object value = getAsOfClause().getValue();
arguments.add(value);
Expression parameterExp = query.getExpressionBuilder().getParameter("ASOFCLAUSE");
if (getAsOfClause().isAsOfSCNClause()) {
query.setAsOfClause(new AsOfSCNClause(parameterExp));
} else {
query.setAsOfClause(new AsOfClause(parameterExp));
}
Vector result = (Vector)getSession().executeQuery(query, arguments);
if (result.size() != 12) {
throw new TestErrorException("Expected 12 objects, read " + result.size());
}
/*arguments.set(0, new java.sql.Timestamp(System.currentTimeMillis()));
result = (Vector)getSession().executeQuery(query, arguments);
if (result.size() != 0) {
throw new TestErrorException("Expected 0 objects, read " + result.size());
}*/
}
public void _testAsOfCurrentTimeMillisTest() {
if (getSession().getProject().hasGenericHistorySupport()) {
return;
}
// Must get the current time from the database as a future or too long pass time will trigger an error.
long value = ((Date)getSession().executeQuery(new ValueReadQuery("Select SYSDATE from DUAL"))).getTime();
AsOfClause clause = new AsOfClause(value);
ReadAllQuery query = new ReadAllQuery(Employee.class);
query.dontMaintainCache();
query.setAsOfClause(clause);
Vector employees = (Vector)getSession().executeQuery(query);
// Since the current time gets mapped to the SCN +/- 5 minutes,
// the query of the current time may, or may contain employees,
// so cannot verify the result, just make sure the query worked.
}
public void _testAsOfCurrentTimeMillisParameterTest() {
if (getSession().getProject().hasGenericHistorySupport()) {
return;
}
// Must get the current time from the database as a future or too long pass time will trigger an error.
long value = ((Date)getSession().executeQuery(new ValueReadQuery("Select SYSDATE from DUAL"))).getTime();
AsOfClause clause = new AsOfClause((new ExpressionBuilder()).getParameter("TIME"));
ReadAllQuery query = new ReadAllQuery(Employee.class);
query.dontMaintainCache();
query.setAsOfClause(clause);
query.addArgument("TIME");
Vector arguments = new Vector();
arguments.add(new Long(value));
Vector employees = (Vector)getSession().executeQuery(query, arguments);
if (employees.size() != 0) {
throw new TestErrorException("Somehow the long value was not converted to a proper timestamp. Check the SQL against: " + value);
}
}
public void _testAsOfExpressionMathTest() {
if (!getAsOfClause().isAsOfSCNClause()) {
return;
}
ValueReadQuery scnQuery = ((OraclePlatform)getSession().getPlatform()).getSystemChangeNumberQuery();
long sCNNow = ((BigDecimal)getSession().executeQuery(scnQuery)).longValue();
long testSCN = ((BigDecimal)getAsOfClause().getValue()).longValue();
ExpressionBuilder builder = new ExpressionBuilder();
Expression expression = ExpressionMath.subtract(builder.value(sCNNow), builder.value(sCNNow - testSCN));
ReadAllQuery query = new ReadAllQuery(Employee.class);
query.setAsOfClause(new AsOfSCNClause(expression));
query.dontMaintainCache();
Vector result = (Vector)getSession().executeQuery(query);
if (result.size() != 12) {
throw new TestErrorException("Expected 12 objects, read " + result.size());
}
}
/**
* A query result can be cached normally if the builder is not as of
* a past time. However, if this condition is true but a a joined attribute
* as of a past time is added, what will happen?
* <p>What should happen is either an exception should be thrown, or the
* joined attribute should be read as of the current time. This test will find out
* which.
*/
public void _testCacheCorruptedByJoinedAttributeTest() {
// Try reading all projects now connected to all projects as of a past time.
try {
getSession().getIdentityMapAccessor().initializeIdentityMaps();
ExpressionBuilder project = new ExpressionBuilder(LargeProject.class);
ExpressionBuilder oldProject = new ExpressionBuilder(LargeProject.class);
oldProject.asOf(getAsOfClause());
Expression criteria = project.equal(oldProject).and(oldProject.get("teamLeader").notNull());
ReadAllQuery query = new ReadAllQuery(LargeProject.class, criteria);
query.addJoinedAttribute(oldProject.get("teamLeader"));
Vector projects = (Vector)getSession().executeQuery(query);
for (int i = 0; i < projects.size(); i++) {
LargeProject next = (LargeProject)projects.get(i);
if (next.getTeamLeader() != null) {
throw new TestErrorException("The dynamic query must still return objects as they exist now, even if a joined attribute is added as of a past time.");
}
}
} finally {
getSession().getIdentityMapAccessor().initializeIdentityMaps();
}
}
/**
* Tests corruption from joined attributes again.
* This test is simpler and more lethal than the previous one, for it cuts to
* the core of the problem. To tell if past rows are being returned, we can
* not just look at the builder.
*/
public void _testCacheCorruptedByJoinedAttribute2Test() {
// Try reading all projects now connected to all projects as of a past time.
try {
getSession().getIdentityMapAccessor().initializeIdentityMaps();
ExpressionBuilder project = new ExpressionBuilder(LargeProject.class);
Expression criteria = project.get("teamLeader").asOf(getAsOfClause()).notNull();
ReadAllQuery query = new ReadAllQuery(LargeProject.class, criteria);
query.addJoinedAttribute("teamLeader");
Vector projects = (Vector)getSession().executeQuery(query);
for (int i = 0; i < projects.size(); i++) {
LargeProject next = (LargeProject)projects.get(i);
if (next.getTeamLeader() != null) {
throw new TestErrorException("The dynamic query must still return objects as they exist now, even if a joined attribute is added on an attribute read as of a past time.");
}
}
} finally {
getSession().getIdentityMapAccessor().initializeIdentityMaps();
}
}
/**
* Tests corruption from joined attributes again.
* This test is simpler and more lethal than the previous one, for it cuts to
* the core of the problem. To tell if past rows are being returned, we can
* not just look at the builder.
*/
public void _testCacheCorruptedByBatchAttributeTest() {
// Try reading all projects now connected to all projects as of a past time.
try {
getSession().getIdentityMapAccessor().initializeIdentityMaps();
ExpressionBuilder project = new ExpressionBuilder(LargeProject.class);
Expression criteria = project.get("teamLeader").asOf(getAsOfClause()).notNull();
ReadAllQuery query = new ReadAllQuery(LargeProject.class, criteria);
query.addBatchReadAttribute("teamLeader");
Vector projects = (Vector)getSession().executeQuery(query);
for (int i = 0; i < projects.size(); i++) {
LargeProject next = (LargeProject)projects.get(i);
if (next.getTeamLeader() != null) {
throw new TestErrorException("The dynamic query must still return objects as they exist now, even if a batched attribute is added on an attribute read as of a past time.");
}
}
} finally {
getSession().getIdentityMapAccessor().initializeIdentityMaps();
}
}
/**
* This is testing for a condition that should never happen.
*/
public void _testCacheIsolationTest() {
getSession().getIdentityMapAccessor().initializeIdentityMaps();
Session hs = getSession().acquireHistoricalSession(getAsOfClause());
try {
hs.readAllObjects(Employee.class);
Vector employees = ((AbstractSession)getSession()).getIdentityMapAccessorInstance().getAllFromIdentityMap(null, Employee.class, null);
if ((employees != null) && (employees.size() > 0)) {
throw new TestErrorException("" + employees.size() + " objects read in a HistoricalSession were cached in the global session.");
}
} finally {
hs.release();
}
}
/**
* This is testing for a condition that should never happen.
*/
public void _testCacheIsolationAcrossRelationshipsTest() {
getSession().getIdentityMapAccessor().initializeIdentityMaps();
Session hs = getSession().acquireHistoricalSession(getAsOfClause());
try {
Vector pastEmployees = hs.readAllObjects(Employee.class);
for (int i = 0; i < pastEmployees.size(); i++) {
Employee employee = (Employee)pastEmployees.get(i);
employee.getProjects();
employee.getAddress();
employee.getPhoneNumbers();
}
Vector projects = ((AbstractSession)getSession()).getIdentityMapAccessorInstance().getAllFromIdentityMap(null, Project.class, null);
Vector addresses = ((AbstractSession)getSession()).getIdentityMapAccessorInstance().getAllFromIdentityMap(null, Address.class, null);
Vector phoneNumbers = ((AbstractSession)getSession()).getIdentityMapAccessorInstance().getAllFromIdentityMap(null, PhoneNumber.class, null);
if ((projects.size() > 0) || (addresses.size() > 0) || (phoneNumbers.size() > 0)) {
throw new TestErrorException("" + projects.size() + " projects, " + addresses.size() + " addresses, and " + phoneNumbers.size() + " phone numbers read in a HistoricalSession were cached in the global session.");
}
} finally {
hs.release();
}
}
public void _testCannotExecuteWriteInHistoricalSessionExceptionTest() {
Session hs = getSession().acquireHistoricalSession(getAsOfClause());
try {
((org.eclipse.persistence.internal.sessions.AbstractSession)hs).writeObject(new Employee());
throw new TestErrorException("Exception not thrown in executing a write in a TimeAwareSession.");
} catch (ValidationException ve) {
if (ve.getErrorCode() != QueryException.INVALID_QUERY_ON_HISTORICAL_SESSION) {
throw new TestErrorException("Wrong exception thrown.", ve);
}
} catch (TestErrorException tee) {
throw tee;
} catch (Exception e) {
throw new TestErrorException("Exception not thrown in executing a write in a Historical session. Instead triggered: ", e);
} finally {
hs.release();
}
}
public void _testDynamicQueryUsingParallelExpressionTest() {
// Try reading all projects now connected to all projects as of a past time.
try {
getSession().getIdentityMapAccessor().initializeIdentityMaps();
ExpressionBuilder project = new ExpressionBuilder(LargeProject.class);
ExpressionBuilder oldProject = new ExpressionBuilder(LargeProject.class);
oldProject.asOf(getAsOfClause());
Expression criteria = project.equal(oldProject).and(oldProject.get("teamLeader").notNull());
Vector projects = getSession().readAllObjects(LargeProject.class, criteria);
if (projects.size() != 3) {
throw new TestErrorException("Expected to read 6 projects, instead read: " + projects.size());
}
for (int i = 0; i < projects.size(); i++) {
LargeProject next = (LargeProject)projects.get(i);
if (next.getTeamLeader() != null) {
throw new TestErrorException("The dynamic query must still return objects as they exist now.");
}
}
} finally {
getSession().getIdentityMapAccessor().initializeIdentityMaps();
}
}
public void _testDynamicQueryUsingQueryKeyTest() {
// Try reading all projects now connected to all projects as of a past time.
try {
getSession().getIdentityMapAccessor().initializeIdentityMaps();
ExpressionBuilder builder = new ExpressionBuilder(LargeProject.class);
Expression joinCriteria = builder.getField("PROJECT.PROJ_ID").equal(builder.getParameter("PROJECT.PROJ_ID"));
OneToOneQueryKey self = new OneToOneQueryKey();
self.setName("this");
self.setJoinCriteria(joinCriteria);
self.setReferenceClass(LargeProject.class);
getSession().getDescriptor(LargeProject.class).addQueryKey(self);
ExpressionBuilder project = new ExpressionBuilder(LargeProject.class);
Expression oldProject = project.get("this");
oldProject.asOf(getAsOfClause());
Expression criteria = oldProject.get("teamLeader").notNull();
Vector projects = getSession().readAllObjects(LargeProject.class, criteria);
if (projects.size() != 3) {
throw new TestErrorException("Expected to read 6 projects, instead read: " + projects.size());
}
for (int i = 0; i < projects.size(); i++) {
LargeProject next = (LargeProject)projects.get(i);
if (next.getTeamLeader() != null) {
throw new TestErrorException("The dynamic query must still return objects as they exist now.");
}
}
} finally {
getSession().getIdentityMapAccessor().initializeIdentityMaps();
}
}
public void _testNoNestedHistoricalSessionsAllowedExceptionTest() {
Session hs = getSession().acquireHistoricalSession(getAsOfClause());
try {
Session nhs = hs.acquireHistoricalSession(getAsOfClause());
nhs.release();
throw new TestErrorException("Exception not thrown in acquiring a nested HistoricalSession.");
} catch (ValidationException ve) {
if (ve.getErrorCode() != ValidationException.CANNOT_ACQUIRE_HISTORICAL_SESSION) {
throw new TestErrorException("Wrong exception thrown.", ve);
}
} catch (TestErrorException tee) {
throw tee;
} catch (Exception e) {
throw new TestErrorException("Exception not thrown in reading past versions of objects into the global cache. Instead triggered: ", e);
} finally {
hs.release();
}
}
public void _testNoTransactionsInHistoricalSessionExceptionTest() {
HistoricalSession hs = (HistoricalSession)getSession().acquireHistoricalSession(getAsOfClause());
try {
hs.beginTransaction();
hs.rollbackTransaction();
throw new TestErrorException("Exception not thrown in beginning a transaction.");
} catch (ValidationException ve1) {
if (ve1.getErrorCode() != ValidationException.OPERATION_NOT_SUPPORTED) {
throw new TestErrorException("Wrong exception thrown.", ve1);
} else {
try {
hs.commitTransaction();
} catch (ValidationException ve2) {
if (ve2.getErrorCode() != ValidationException.OPERATION_NOT_SUPPORTED) {
throw new TestErrorException("Wrong exception thrown.", ve2);
} else {
try {
hs.rollbackTransaction();
} catch (ValidationException ve3) {
if (ve3.getErrorCode() != ValidationException.OPERATION_NOT_SUPPORTED) {
throw new TestErrorException("Wrong exception thrown.", ve3);
} else {
try {
hs.acquireUnitOfWork();
} catch (ValidationException ve4) {
if (ve4.getErrorCode() != ValidationException.OPERATION_NOT_SUPPORTED) {
throw new TestErrorException("Wrong exception thrown.", ve4);
}
}
}
}
}
}
}
} catch (TestErrorException tee) {
throw tee;
} catch (Exception e) {
throw new TestErrorException("Exception not thrown in reading past versions of objects into the global cache. Instead triggered: ", e);
} finally {
hs.release();
}
}
public void _testParameterBindingTest() {
ExpressionBuilder builder = new ExpressionBuilder();
Expression expression = builder.get("firstName").equal(builder.getParameter("FIRSTNAME"));
Vector arguments = new Vector();
arguments.add("Bob");
ReadObjectQuery query = new ReadObjectQuery(Employee.class);
query.setAsOfClause(getAsOfClause());
query.dontMaintainCache();
query.addArgument("FIRSTNAME");
Employee result = (Employee)getSession().executeQuery(query, arguments);
if (!result.getFirstName().equals("Bob")) {
throw new TestErrorException("Expected Bob, read " + result);
}
arguments.set(0, "Sarah");
result = (Employee)getSession().executeQuery(query, arguments);
if (!result.getFirstName().equals("Sarah")) {
throw new TestErrorException("Expected Sarah, read " + result);
}
}
/**
* Tests the entire point of a TimeAwareSession, which is to allow
* caching of read results, which in turn guarantees that circular references
* form a circle, not an infinite loop.
*/
public void _testSuccessfulCachingTest() {
getSession().getIdentityMapAccessor().initializeIdentityMaps();
Session hs = getSession().acquireHistoricalSession(getAsOfClause());
try {
Employee pastManager = (Employee)hs.readObject(Employee.class, new ExpressionBuilder().anyOf("managedEmployees").get("id").greaterThan(0));
Vector employees = pastManager.getManagedEmployees();
for (int i = 0; i < employees.size(); i++) {
Employee employee = (Employee)employees.get(i);
if (employee.getManager() != pastManager) {
throw new TestErrorException("Objects read in a HistoricalSession are not being cached properly by identity.");
}
}
} finally {
hs.release();
}
}
public void _testOuterJoinTest() {
internalOuterJoinTest(true);
}
public void _testOuterJoinTestWithoutAsOf() {
internalOuterJoinTest(false);
}
void internalOuterJoinTest(boolean withAsOf) {
ReadAllQuery query = new ReadAllQuery(LargeProject.class);
ExpressionBuilder builder = query.getExpressionBuilder();
Expression expression = builder.getAllowingNull("teamLeader").get("firstName").equal("Sarah");
expression = expression.or(builder.get("name").equal("TOPEmployee Management"));
query.setSelectionCriteria(expression);
query.dontMaintainCache();
if(withAsOf) {
query.setAsOfClause(getAsOfClause());
}
Vector result = (Vector)getSession().executeQuery(query);
getSession().getIdentityMapAccessor().initializeIdentityMaps();
int expectedSize = (withAsOf ? 2 : 1);
if ((result == null) || (result.size() != expectedSize)) {
throw new TestErrorException("Expected "+expectedSize+" objects, read " + result.size());
}
}
public void _testHistoricalQueriesMustPreserveGlobalCacheExceptionTest() {
ReadAllQuery query = new ReadAllQuery(Employee.class);
query.setSelectionCriteria(query.getExpressionBuilder().get("firstName").equal("Bob"));
query.setAsOfClause(new AsOfSCNClause(new Long(0)));
try {
getSession().executeQuery(query);
getSession().getIdentityMapAccessor().initializeIdentityMaps();
throw new TestErrorException("Exception not thrown in reading past versions of objects into the global cache.");
} catch (QueryException qe) {
if (qe.getErrorCode() != QueryException.HISTORICAL_QUERIES_MUST_PRESERVE_GLOBAL_CACHE) {
throw new TestErrorException("Wrong exception thrown.", qe);
}
} catch (TestErrorException tee) {
throw tee;
} catch (Exception e) {
throw new TestErrorException("Exception not thrown in reading past versions of objects into the global cache. Instead triggered: ", e);
}
}
public void _testHistoricalQueriesOnlySupportedOnOracleExceptionTest() {
boolean genericHistory = getSession().getProject().hasGenericHistorySupport();
ReadAllQuery query = new ReadAllQuery(Employee.class);
query.setSelectionCriteria(query.getExpressionBuilder().get("firstName").equal("Bob"));
query.setAsOfClause(getAsOfClause());
query.dontMaintainCache();
DatabaseLogin oldLogin = getSession().getLogin();
DatabaseLogin newLogin = (DatabaseLogin)oldLogin.clone();
newLogin.useAccess();
try {
getAbstractSession().setLogin(newLogin);
getSession().executeQuery(query);
getSession().getIdentityMapAccessor().initializeIdentityMaps();
if (!genericHistory) {
throw new TestErrorException("Exception not thrown in reading past versions of objects outside of Oracle.");
}
} catch (QueryException qe) {
if (qe.getErrorCode() != QueryException.HISTORICAL_QUERIES_ONLY_SUPPORTED_ON_ORACLE) {
throw new TestErrorException("Wrong exception thrown.", qe);
}
} catch (TestErrorException tee) {
throw tee;
} catch (Exception e) {
throw new TestErrorException("Exception not thrown in reading past versions of objects outside of Oracle. Instead triggered: " + e.toString(), e);
} finally {
getAbstractSession().setLogin(oldLogin);
}
}
public void _testHistoricalSessionOnlySupportedOnOracleExceptionTest() {
if (getSession().getProject().hasGenericHistorySupport()) {
return;
}
DatabaseLogin oldLogin = getSession().getLogin();
DatabaseLogin newLogin = (DatabaseLogin)oldLogin.clone();
newLogin.useAccess();
try {
getAbstractSession().setLogin(newLogin);
Session hs = getSession().acquireHistoricalSession(getAsOfClause());
hs.release();
throw new TestErrorException("Exception not thrown in acquiring a HistoricalSession outside of Oracle.");
} catch (ValidationException ve) {
if (ve.getErrorCode() != ValidationException.HISTORICAL_SESSION_ONLY_SUPPORTED_ON_ORACLE) {
throw new TestErrorException("Wrong exception thrown.", ve);
}
} catch (TestErrorException tee) {
throw tee;
} catch (Exception e) {
throw new TestErrorException("Exception not thrown in reading past versions of objects into the global cache. Instead triggered: ", e);
} finally {
getAbstractSession().setLogin(oldLogin);
}
}
public void addTests() {
addTest(new UnitTestCase("AsOfCurrentTimeMillisTest"));
// broken addTest(new UnitTestCase("AsOfCurrentTimeMillisParameterTest"));
addTest(new UnitTestCase("AsOfExpressionMathTest"));
addTest(new UnitTestCase("AsOfParameterTest"));
addTest(new UnitTestCase("AsOfStringLiteralTest"));
// broken addTest(new UnitTestCase("CacheCorruptedByJoinedAttributeTest"));
//broken addTest(new UnitTestCase("CacheCorruptedByJoinedAttribute2Test"));
addTest(new UnitTestCase("CacheCorruptedByBatchAttributeTest"));
addTest(new UnitTestCase("CacheIsolationTest"));
addTest(new UnitTestCase("CacheIsolationAcrossRelationshipsTest"));
addTest(new UnitTestCase("CannotExecuteWriteInHistoricalSessionExceptionTest"));
addTest(new UnitTestCase("DynamicQueryUsingQueryKeyTest"));
addTest(new UnitTestCase("DynamicQueryUsingParallelExpressionTest"));
addTest(new UnitTestCase("NoNestedHistoricalSessionsAllowedExceptionTest"));
addTest(new UnitTestCase("NoTransactionsInHistoricalSessionExceptionTest"));
addTest(new UnitTestCase("SuccessfulCachingTest"));
addTest(new UnitTestCase("OuterJoinTest"));
addTest(new UnitTestCase("OuterJoinTestWithoutAsOf"));
addTest(new UnitTestCase("HistoricalQueriesMustPreserveGlobalCacheExceptionTest"));
addTest(new UnitTestCase("HistoricalQueriesOnlySupportedOnOracleExceptionTest"));
addTest(new UnitTestCase("HistoricalSessionOnlySupportedOnOracleExceptionTest"));
}
}