/******************************************************************************* | |
* Copyright (c) 1998, 2013 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: | |
* 07/16/2009 Andrei Ilitchev | |
* - Bug 282553: JPA 2.0 JoinTable support for OneToOne and ManyToOne | |
******************************************************************************/ | |
package org.eclipse.persistence.testing.tests.onetoonejointable; | |
import java.util.List; | |
import java.util.Vector; | |
import org.eclipse.persistence.expressions.Expression; | |
import org.eclipse.persistence.expressions.ExpressionBuilder; | |
import org.eclipse.persistence.expressions.ExpressionMath; | |
import org.eclipse.persistence.internal.sessions.AbstractSession; | |
import org.eclipse.persistence.platform.database.TimesTenPlatform; | |
import org.eclipse.persistence.queries.Call; | |
import org.eclipse.persistence.queries.ReadAllQuery; | |
import org.eclipse.persistence.queries.ReportQuery; | |
import org.eclipse.persistence.queries.SQLCall; | |
import org.eclipse.persistence.sessions.UnitOfWork; | |
import org.eclipse.persistence.tools.schemaframework.PopulationManager; | |
import org.eclipse.persistence.testing.framework.*; | |
import org.eclipse.persistence.testing.models.onetoonejointable.*; | |
import org.eclipse.persistence.testing.tests.expressions.ReadObjectExpressionTest; | |
import org.eclipse.persistence.testing.tests.writing.ComplexUpdateTest; | |
/** | |
* This model tests reading/writing/deleting through using the employee demo. | |
*/ | |
public class OneToOneJoinTableEmployeeBasicTestModel extends TestModel { | |
/** | |
* Return the JUnit suite to allow JUnit runner to find it. | |
* Unfortunately JUnit only allows suite methods to be static, | |
* so it is not possible to generically do this. | |
*/ | |
public static junit.framework.TestSuite suite() { | |
return new OneToOneJoinTableEmployeeBasicTestModel(); | |
} | |
public OneToOneJoinTableEmployeeBasicTestModel() { | |
setDescription("This model tests reading/writing/deleting using the employee demo."); | |
} | |
public OneToOneJoinTableEmployeeBasicTestModel(boolean isSRG) { | |
this(); | |
this.isSRG = isSRG; | |
} | |
public void addRequiredSystems() { | |
addRequiredSystem(new EmployeeSystem()); | |
} | |
public void addTests() { | |
addTest(getReadObjectTestSuite()); | |
addTest(getUpdateObjectTestSuite()); | |
addTest(getInsertObjectTestSuite()); | |
addTest(getUOWInsertObjectTestSuite()); | |
addTest(getDeleteObjectTestSuite()); | |
addTest(getReadAllTestSuite()); | |
addTest(new ExpressionTestSuite()); | |
} | |
public static TestSuite getDeleteObjectTestSuite() { | |
TestSuite suite = getSRGDeleteObjectTestSuite(); | |
//Add new tests here ... | |
return suite; | |
} | |
//SRG test set is maintained by QA only, do NOT add any new tests into it. | |
public static TestSuite getSRGDeleteObjectTestSuite() { | |
TestSuite suite = new TestSuite(); | |
suite.setName("EmployeeDeleteObjectTestSuite"); | |
suite.setDescription("This suite tests the deletion of each object in the employee demo."); | |
Class employeeClass = Employee.class; | |
Class largeProjectClass = LargeProject.class; | |
Class smallProjectClass = SmallProject.class; | |
PopulationManager manager = PopulationManager.getDefaultManager(); | |
suite.addTest(new EmployeeDeleteTest(manager.getObject(employeeClass, "0001"))); | |
suite.addTest(new EmployeeDeleteTest(manager.getObject(employeeClass, "0002"))); | |
suite.addTest(new EmployeeDeleteTest(manager.getObject(employeeClass, "0003"))); | |
suite.addTest(new EmployeeDeleteTest(manager.getObject(employeeClass, "0004"))); | |
suite.addTest(new EmployeeDeleteTest(manager.getObject(employeeClass, "0005"))); | |
suite.addTest(new ProjectDeleteTest(manager.getObject(smallProjectClass, "0001"))); | |
suite.addTest(new ProjectDeleteTest(manager.getObject(smallProjectClass, "0002"))); | |
suite.addTest(new ProjectDeleteTest(manager.getObject(smallProjectClass, "0003"))); | |
suite.addTest(new ProjectDeleteTest(manager.getObject(largeProjectClass, "0001"))); | |
suite.addTest(new ProjectDeleteTest(manager.getObject(largeProjectClass, "0002"))); | |
suite.addTest(new ProjectDeleteTest(manager.getObject(largeProjectClass, "0003"))); | |
return suite; | |
} | |
public static TestSuite getInsertObjectTestSuite() { | |
TestSuite suite = getSRGInsertObjectTestSuite(); | |
//Add new tests here ... | |
return suite; | |
} | |
//SRG test set is maintained by QA only, do NOT add any new tests into it. | |
public static TestSuite getSRGInsertObjectTestSuite() { | |
TestSuite suite = new TestSuite(); | |
suite.setName("EmployeeInsertObjectTestSuite"); | |
suite.setDescription("This suite tests the insertion of each object in the employee demo."); | |
EmployeePopulator system = new EmployeePopulator(); | |
suite.addTest(new InsertObjectTest(system.basicEmployeeExample1())); | |
suite.addTest(new InsertObjectTest(system.basicEmployeeExample2())); | |
suite.addTest(new InsertObjectTest(system.basicEmployeeExample3())); | |
suite.addTest(new InsertObjectTest(system.basicEmployeeExample4())); | |
suite.addTest(new InsertObjectTest(system.basicEmployeeExample5())); | |
suite.addTest(new InsertObjectTest(system.basicSmallProjectExample1())); | |
suite.addTest(new InsertObjectTest(system.basicSmallProjectExample2())); | |
suite.addTest(new InsertObjectTest(system.basicSmallProjectExample3())); | |
suite.addTest(new InsertObjectTest(system.basicLargeProjectExample1())); | |
suite.addTest(new InsertObjectTest(system.basicLargeProjectExample2())); | |
suite.addTest(new InsertObjectTest(system.basicLargeProjectExample3())); | |
return suite; | |
} | |
public static TestSuite getReadAllTestSuite() { | |
TestSuite suite = getSRGReadAllTestSuite(); | |
//Add new tests here ... | |
Expression orderBy = new ExpressionBuilder().get("firstName").ascending(); | |
Call call = new SQLCall("SELECT t0.VERSION, t1.EMP_ID, t0.L_NAME, t0.F_NAME, t1.SALARY, t0.EMP_ID, t0.GENDER FROM OTOJT_EMPLOYEE t0, OTOJT_SALARY t1 WHERE t1.EMP_ID = t0.EMP_ID"); | |
suite.addTest(new ReadAllCallWithOrderingTest(Employee.class, 12, call, orderBy)); | |
suite.addTest(new JoinTest()); | |
suite.addTest(new JoinTest_SelectByFirstName()); | |
suite.addTest(new BatchReadingTest()); | |
suite.addTest(new BatchReadingTest_SelectByFirstName()); | |
return suite; | |
} | |
//SRG test set is maintained by QA only, do NOT add any new tests into it. | |
public static TestSuite getSRGReadAllTestSuite() { | |
TestSuite suite = new TestSuite(); | |
suite.setName("EmployeeReadAllTestSuite"); | |
suite.setDescription("This suite tests the reading of all the objects of each class in the employee demo."); | |
suite.addTest(new ReadAllTest(Employee.class, 12)); | |
suite.addTest(new ReadAllTest(Project.class, 15)); | |
suite.addTest(new ReadAllTest(LargeProject.class, 5)); | |
suite.addTest(new ReadAllTest(SmallProject.class, 10)); | |
suite.addTest(new ReadAllCallTest(Employee.class, 12, new SQLCall("SELECT t0.VERSION, t1.EMP_ID, t0.L_NAME, t0.F_NAME, t1.SALARY, t0.EMP_ID, t0.GENDER FROM OTOJT_EMPLOYEE t0, OTOJT_SALARY t1 WHERE t1.EMP_ID = t0.EMP_ID"))); | |
return suite; | |
} | |
public static TestSuite getReadObjectTestSuite() { | |
TestSuite suite = getSRGReadObjectTestSuite(); | |
//Add new tests here ... | |
return suite; | |
} | |
//SRG test set is maintained by QA only, do NOT add any new tests into it. | |
public static TestSuite getSRGReadObjectTestSuite() { | |
TestSuite suite = new TestSuite(); | |
suite.setName("EmployeeReadObjectTestSuite"); | |
suite.setDescription("This suite test the reading of each object in the employee demo."); | |
Class employeeClass = Employee.class; | |
Class largeProjectClass = LargeProject.class; | |
Class smallProjectClass = SmallProject.class; | |
PopulationManager manager = PopulationManager.getDefaultManager(); | |
suite.addTest(new ReadObjectTest(manager.getObject(employeeClass, "0001"))); | |
suite.addTest(new ReadObjectTest(manager.getObject(employeeClass, "0002"))); | |
suite.addTest(new ReadObjectTest(manager.getObject(employeeClass, "0003"))); | |
suite.addTest(new ReadObjectTest(manager.getObject(employeeClass, "0004"))); | |
suite.addTest(new ReadObjectTest(manager.getObject(employeeClass, "0005"))); | |
Employee employee = (Employee)manager.getObject(employeeClass, "0001"); | |
suite.addTest(new ReadObjectCallTest(employeeClass, new SQLCall("SELECT t0.VERSION, t1.EMP_ID, t0.L_NAME, t0.F_NAME, t1.SALARY, t0.EMP_ID, t0.GENDER FROM OTOJT_EMPLOYEE t0, OTOJT_SALARY t1 WHERE t1.EMP_ID = t0.EMP_ID AND t0.F_NAME = '"+employee.getFirstName()+"' AND t0.L_NAME = '"+employee.getLastName()+"'"))); | |
employee = (Employee)manager.getObject(employeeClass, "0002"); | |
suite.addTest(new ReadObjectCallTest(employeeClass, new SQLCall("SELECT t0.VERSION, t1.EMP_ID, t0.L_NAME, t0.F_NAME, t1.SALARY, t0.EMP_ID, t0.GENDER FROM OTOJT_EMPLOYEE t0, OTOJT_SALARY t1 WHERE t1.EMP_ID = t0.EMP_ID AND t0.F_NAME = '"+employee.getFirstName()+"' AND t0.L_NAME = '"+employee.getLastName()+"'"))); | |
employee = (Employee)manager.getObject(employeeClass, "0003"); | |
suite.addTest(new ReadObjectCallTest(employeeClass, new SQLCall("SELECT t0.VERSION, t1.EMP_ID, t0.L_NAME, t0.F_NAME, t1.SALARY, t0.EMP_ID, t0.GENDER FROM OTOJT_EMPLOYEE t0, OTOJT_SALARY t1 WHERE t1.EMP_ID = t0.EMP_ID AND t0.F_NAME = '"+employee.getFirstName()+"' AND t0.L_NAME = '"+employee.getLastName()+"'"))); | |
Project project = (Project)manager.getObject(largeProjectClass, "0001"); | |
ReadObjectTest test = new ReadObjectTest(project); | |
test.setQuery(new org.eclipse.persistence.queries.ReadObjectQuery(Project.class, new org.eclipse.persistence.expressions.ExpressionBuilder().get("id").equal(project.getId()))); | |
suite.addTest(test); | |
suite.addTest(new ReadObjectTest(manager.getObject(smallProjectClass, "0001"))); | |
suite.addTest(new ReadObjectTest(manager.getObject(smallProjectClass, "0002"))); | |
suite.addTest(new ReadObjectTest(manager.getObject(smallProjectClass, "0003"))); | |
suite.addTest(new ReadObjectTest(manager.getObject(largeProjectClass, "0001"))); | |
suite.addTest(new ReadObjectTest(manager.getObject(largeProjectClass, "0002"))); | |
suite.addTest(new ReadObjectTest(manager.getObject(largeProjectClass, "0003"))); | |
return suite; | |
} | |
public static TestSuite getUpdateObjectTestSuite() { | |
TestSuite suite = getSRGUpdateObjectTestSuite(); | |
//Add new tests here ... | |
suite.addTest(new ManyToManyReadOnlyMappingUpdateTest()); | |
suite.addTest(new AddRemoveTest()); | |
return suite; | |
} | |
//SRG test set is maintained by QA only, do NOT add any new tests into it. | |
public static TestSuite getSRGUpdateObjectTestSuite() { | |
TestSuite suite = new TestSuite(); | |
suite.setName("EmployeeUpdateObjectTestSuite"); | |
suite.setDescription("This suite tests the updating of each object in the employee demo."); | |
Class employeeClass = Employee.class; | |
Class largeProjectClass = LargeProject.class; | |
Class smallProjectClass = SmallProject.class; | |
PopulationManager manager = PopulationManager.getDefaultManager(); | |
suite.addTest(new WriteObjectTest(manager.getObject(employeeClass, "0001"))); | |
suite.addTest(new UnitOfWorkBasicUpdateObjectTest(manager.getObject(employeeClass, "0001"))); | |
suite.addTest(new UnitOfWorkBasicUpdateObjectTest(manager.getObject(employeeClass, "0002"))); | |
suite.addTest(new UnitOfWorkBasicUpdateObjectTest(manager.getObject(employeeClass, "0003"))); | |
suite.addTest(new UnitOfWorkBasicUpdateObjectTest(manager.getObject(employeeClass, "0004"))); | |
suite.addTest(new UnitOfWorkBasicUpdateObjectTest(manager.getObject(employeeClass, "0005"))); | |
suite.addTest(new WriteObjectTest(manager.getObject(smallProjectClass, "0001"))); | |
suite.addTest(new UnitOfWorkBasicUpdateObjectTest(manager.getObject(smallProjectClass, "0001"))); | |
suite.addTest(new UnitOfWorkBasicUpdateObjectTest(manager.getObject(smallProjectClass, "0002"))); | |
suite.addTest(new UnitOfWorkBasicUpdateObjectTest(manager.getObject(smallProjectClass, "0003"))); | |
suite.addTest(new WriteObjectTest(manager.getObject(largeProjectClass, "0001"))); | |
suite.addTest(new UnitOfWorkBasicUpdateObjectTest(manager.getObject(largeProjectClass, "0001"))); | |
suite.addTest(new UnitOfWorkBasicUpdateObjectTest(manager.getObject(largeProjectClass, "0002"))); | |
suite.addTest(new UnitOfWorkBasicUpdateObjectTest(manager.getObject(largeProjectClass, "0003"))); | |
return suite; | |
} | |
static class ManyToManyReadOnlyMappingUpdateTest extends ComplexUpdateTest { | |
ManyToManyReadOnlyMappingUpdateTest() { | |
super(); | |
usesUnitOfWork = true; | |
setName("ManyToManyReadOnlyMappingUpdateTest"); | |
} | |
public void setup() { | |
// find Project with at least one Employee | |
List<Project> projects = getSession().readAllObjects(Project.class); | |
for(int i=0; i < projects.size(); i++) { | |
if(projects.get(i).getEmployees().size() > 0) { | |
originalObject = projects.get(i); | |
break; | |
} | |
} | |
super.setup(); | |
} | |
// remove all employees | |
protected void changeObject() { | |
Project project = (Project)this.workingCopy; | |
int size = project.getEmployees().size(); | |
if(size == 0) { | |
throw new TestProblemException("Project was supposed to have Employees, but doesn't have any."); | |
} else { | |
for(int i = size-1; 0 <= i; i--) { | |
project.removeEmployee(project.getEmployees().get(i)); | |
} | |
} | |
} | |
} | |
static class AddRemoveTest extends TestCase { | |
Employee employee; | |
Address address1, address2; | |
Project project1, project2; | |
boolean useAddress; | |
boolean useProjects; | |
AddRemoveTest() { | |
super(); | |
setName("AddRemoveTest"); | |
} | |
public void setup() { | |
useAddress = true; | |
useProjects = true; | |
} | |
public void test() { | |
employee = new Employee(); | |
employee.setFirstName("AddRemoveTest"); | |
if(useAddress) { | |
address1 = new Address(); | |
address1.setCity("city1"); | |
} | |
if(useProjects) { | |
project1 = new SmallProject("project1"); | |
} | |
// insert employee with address/project | |
UnitOfWork uow = getSession().acquireUnitOfWork(); | |
Employee employeeClone = (Employee)uow.registerObject(employee); | |
if(useAddress) { | |
Address address1Clone = (Address)uow.registerObject(address1); | |
employeeClone.setAddress(address1Clone); | |
} | |
if(useProjects) { | |
Project project1Clone = (Project)uow.registerObject(project1); | |
employeeClone.addProject(project1Clone); | |
} | |
uow.commit(); | |
// remove address/project from employee | |
uow = getSession().acquireUnitOfWork(); | |
employeeClone = (Employee)uow.registerObject(employee); | |
if(useAddress) { | |
employeeClone.setAddress(null); | |
} | |
if(useProjects) { | |
employeeClone.removeProject(employeeClone.getProjects().get(0)); | |
} | |
uow.commit(); | |
// set address/project into employee | |
uow = getSession().acquireUnitOfWork(); | |
employeeClone = (Employee)uow.registerObject(employee); | |
if(useAddress) { | |
Address address1Clone = (Address)uow.registerObject(address1); | |
employeeClone.setAddress(address1Clone); | |
} | |
if(useProjects) { | |
Project project1Clone = (Project)uow.registerObject(project1); | |
employeeClone.addProject(project1Clone); | |
} | |
uow.commit(); | |
// override address/project in employee | |
uow = getSession().acquireUnitOfWork(); | |
employeeClone = (Employee)uow.registerObject(employee); | |
if(useAddress) { | |
address2 = new Address(); | |
address2.setCity("city2"); | |
Address address2Clone = (Address)uow.registerObject(address2); | |
employeeClone.setAddress(address2Clone); | |
} | |
if(useProjects) { | |
project2 = new LargeProject("project2"); | |
Project project2Clone = (Project)uow.registerObject(project2); | |
employeeClone.addProject(project2Clone); | |
} | |
uow.commit(); | |
// delete employee | |
uow = getSession().acquireUnitOfWork(); | |
uow.deleteObject(employee); | |
uow.commit(); | |
employee = null; | |
} | |
public void reset() { | |
UnitOfWork uow = getSession().acquireUnitOfWork(); | |
if(employee != null) { | |
uow.deleteObject(employee); | |
} | |
if(useAddress) { | |
if(address1 != null) { | |
uow.deleteObject(address1); | |
} | |
if(address2 != null) { | |
uow.deleteObject(address2); | |
} | |
} | |
if(useProjects) { | |
if(project1 != null) { | |
uow.deleteObject(project1); | |
} | |
if(project2 != null) { | |
uow.deleteObject(project2); | |
} | |
} | |
uow.commit(); | |
} | |
} | |
static class JoinTest extends TestCase { | |
public JoinTest() { | |
super(); | |
setName("JoinTest - no selection criteria"); | |
setDescription("Tests reading of Employees with join expressions."); | |
} | |
void setSelectionCriteria(ReadAllQuery query) { | |
} | |
public void test() { | |
ReadAllQuery query = new ReadAllQuery(); | |
query.setReferenceClass(Employee.class); | |
setSelectionCriteria(query); | |
ReadAllQuery controlQuery = (ReadAllQuery)query.clone(); | |
Expression address = query.getExpressionBuilder().getAllowingNull("address"); | |
query.addJoinedAttribute(address); | |
Expression projectLed = query.getExpressionBuilder().getAllowingNull("projectLed"); | |
query.addJoinedAttribute(projectLed); | |
Expression manager = query.getExpressionBuilder().getAllowingNull("manager"); | |
query.addJoinedAttribute(manager); | |
Expression managerProjectLed = manager.getAllowingNull("projectLed"); | |
query.addJoinedAttribute(managerProjectLed); | |
String errorMsg = JoinedAttributeTestHelper.executeQueriesAndCompareResults(controlQuery, query, (AbstractSession)getSession()); | |
if(errorMsg.length() > 0) { | |
throw new TestErrorException(errorMsg); | |
} | |
} | |
} | |
static class JoinTest_SelectByFirstName extends JoinTest { | |
public JoinTest_SelectByFirstName() { | |
super(); | |
setName("JoinTest - select by first name"); | |
} | |
void setSelectionCriteria(ReadAllQuery query) { | |
query.setSelectionCriteria(query.getExpressionBuilder().get("firstName").like("J%")); | |
} | |
} | |
static class BatchReadingTest extends TestCase { | |
boolean shouldPrintDebugOutput = false; | |
public BatchReadingTest() { | |
setName("EmployeeBatchReadingTest - no selection criteria"); | |
setDescription("Tests batch reading of Employees with batch expression address"); | |
} | |
void setSelectionCriteria(ReadAllQuery query) { | |
} | |
public void test() { | |
// clear cache | |
getSession().getIdentityMapAccessor().initializeAllIdentityMaps(); | |
// create batch read query, set its selectionCriteria | |
ReadAllQuery query = new ReadAllQuery(Employee.class); | |
setSelectionCriteria(query); | |
// before adding batch read attributes clone the query to create control query | |
ReadAllQuery controlQuery = (ReadAllQuery)query.clone(); | |
// add batch read attributes | |
Expression addressExp = query.getExpressionBuilder().get("address"); | |
query.addBatchReadAttribute(addressExp); | |
// execute the query | |
List employees = (List)getSession().executeQuery(query); | |
if(employees.isEmpty()) { | |
throw new TestProblemException("No Employees were read"); | |
} | |
// need to instantiate only a single Address to trigger sql that reads data from the db for all. | |
// still need to trigger all the indirections - but (except the first one) they are not accessing the db | |
// (the data is already cached in the value holders). | |
printDebug("Trigger batch reading results"); | |
boolean isConnected = true; | |
for(int i=0; i < employees.size(); i++) { | |
Address address = ((Employee)employees.get(i)).getAddress(); | |
if(isConnected) { | |
// need to instantiate only a single Address to trigger sql that reads data from the db for all Addresses. | |
// to ensure that no other sql is issued close connection. | |
((AbstractSession)getSession()).getAccessor().closeConnection(); | |
isConnected = false; | |
} | |
} | |
if(!isConnected) { | |
// reconnect connection | |
((AbstractSession)getSession()).getAccessor().reestablishConnection((AbstractSession)getSession()); | |
} | |
printDebug(""); | |
// obtain control results | |
// clear cache | |
getSession().getIdentityMapAccessor().initializeAllIdentityMaps(); | |
// execute control query | |
List controlEmployees = (List)getSession().executeQuery(controlQuery); | |
// instantiate all value holders that the batch query expected to instantiate | |
printDebug("Trigger control results"); | |
for(int i=0; i < controlEmployees.size(); i++) { | |
Address address = ((Employee)controlEmployees.get(i)).getAddress(); | |
} | |
// compare results | |
String errorMsg = JoinedAttributeTestHelper.compareCollections(employees, controlEmployees, getSession().getClassDescriptor(Employee.class), ((AbstractSession)getSession())); | |
if(errorMsg.length() > 0) { | |
throw new TestErrorException(errorMsg); | |
} | |
} | |
void printDebug(String msg) { | |
if(this.shouldPrintDebugOutput) { | |
System.out.println(msg); | |
} | |
} | |
} | |
static class BatchReadingTest_SelectByFirstName extends BatchReadingTest { | |
public BatchReadingTest_SelectByFirstName() { | |
super(); | |
setName("EmployeeBatchReadingTest - select by first name"); | |
} | |
void setSelectionCriteria(ReadAllQuery query) { | |
query.setSelectionCriteria(query.getExpressionBuilder().get("firstName").like("J%")); | |
} | |
} | |
// copied 6 methods from org.eclipse.persistence.testing.tests.expressions.ExpressionTestSuite | |
static class ExpressionTestSuite extends TestSuite { | |
public ExpressionTestSuite() { | |
setName("ExpressionTestSuite"); | |
setDescription("This suite tests expressions."); | |
} | |
public void addTests() { | |
addMultipleAndsTest(); | |
addMultipleAndsTest2(); | |
addMultipleAndsTest3(); | |
addMultipleAndsTest4(); | |
addMultipleAndsTest5(); | |
addMultipleAndsTest6(); | |
addEqualUnneccessaryJoinTest(); | |
addManagersOfWealthyMarriedAtWorkEmployeesTest(); | |
addOneToManyJoin2WithBatchReadTest(); | |
} | |
private void addMultipleAndsTest() { | |
ExpressionBuilder builder = new ExpressionBuilder(); | |
//this is a bug, wrong generated SQL like... ADDRESS.ADDRESS_ID = EMPLOYEE.ADDR_ID... | |
//however, it should be ... ADDRESS.ADDRESS_ID = 0... | |
Expression expression = builder.get("address").equal(new Address()).and(builder.get("lastName").notEqual("foopoyp")); | |
ReadAllExpressionTest test = new ReadAllExpressionTest(Employee.class, 0); | |
test.setExpression(expression); | |
test.setName("MultipleAndsExpressionTest"); | |
test.setDescription("Test object equality with object will null primary key"); | |
addTest(test); | |
} | |
private void addMultipleAndsTest2() { | |
//there is a bug, generated SQL looks like ... (ADDRESS.ADDRESS_ID = 123456)) AND (ADDRESS.ADDRESS_ID = EMPLOYEE.ADDR_ID)... | |
//should be: ...EMPLOYEE.ADDR_ID = 123456... no join needed! | |
ExpressionBuilder builder = new ExpressionBuilder(); | |
Address a = new Address(); | |
a.setId(new java.math.BigDecimal(123456)); | |
Expression expression = builder.get("address").equal(a).and(builder.get("id").greaterThan(800)); | |
ReadAllExpressionTest test = new ReadAllExpressionTest(Employee.class, 0); | |
test.setQuery(new ReadAllQuery(Employee.class, expression)); | |
test.getQuery().addAscendingOrdering("id"); | |
test.setExpression(expression); | |
test.setName("MultipleAndsExpressionTest2"); | |
test.setDescription("Test multiple ands with object equality"); | |
addTest(test); | |
} | |
private void addMultipleAndsTest3() { | |
//there is a bug, generated wrong SQL looks like ... FROM ADDRESS t3, SALARY t2, EMPLOYEE t1 WHERE (((((t1.EMP_ID > '800') AND ) AND (t1.EMP_ID = t2.EMP_ID)) AND (t3.ADDRESS_ID = 123456))... | |
ExpressionBuilder builder = new ExpressionBuilder(); | |
Address a = new Address(); | |
a.setId(new java.math.BigDecimal(123456)); | |
Expression expression = builder.get("id").greaterThan(800).and(builder.get("address").equal(a)); | |
ReadAllExpressionTest test = new ReadAllExpressionTest(Employee.class, 0); | |
test.setQuery(new ReadAllQuery(Employee.class, expression)); | |
test.getQuery().addAscendingOrdering("id"); | |
test.setExpression(expression); | |
test.setName("MultipleAndsExpressionTest3"); | |
test.setDescription("Test multiple ands with object equality"); | |
addTest(test); | |
} | |
private void addMultipleAndsTest4() { | |
// This tests the case of a tree where the top-level AND should print, even though | |
// both branches underneath it are partly suppressed. | |
ExpressionBuilder builder = new ExpressionBuilder(); | |
Address address1 = new Address(); | |
address1.setId(new java.math.BigDecimal(999999876)); | |
Address address2 = new Address(); | |
address2.setId(new java.math.BigDecimal(999999877)); | |
Expression expression1 = builder.get("address").equal(address1).or(builder.get("lastName").equal("Smith")); | |
Expression expression2 = builder.get("address").equal(address2).or(builder.get("firstName").equal("Bob")); | |
ReadAllExpressionTest test = new ReadAllExpressionTest(Employee.class, 1); | |
test.setExpression(expression1.and(expression2)); | |
test.setName("MultipleAndsExpressionTest4"); | |
test.setDescription("Test multiple booleans with supression in each branch"); | |
addTest(test); | |
} | |
private void addMultipleAndsTest5() { | |
ExpressionBuilder builder = new ExpressionBuilder(); | |
//this is a bug, Ill-formed expression in query, attempting to print an object reference into a | |
//SQL statement for Query Key address{DatabaseTable(t1)=DatabaseTable(ADDRESS)} | |
//however, it should be ... EMPLOYEE.ADDRESS_ID = 0 (null)... | |
Expression expression = builder.get("address").equal(null).and(builder.get("lastName").notEqual("foopoyp")); | |
ReadAllExpressionTest test = new ReadAllExpressionTest(Employee.class, 0); | |
test.setExpression(expression); | |
test.setName("MultipleAndsExpressionTest5"); | |
test.setDescription("Test multiple ands expression"); | |
addTest(test); | |
} | |
private void addMultipleAndsTest6() { | |
ExpressionBuilder builder = new ExpressionBuilder(); | |
//this is a bug, Ill-formed expression in query, attempting to print an object reference into a | |
//SQL statement for Query Key address{DatabaseTable(t1)=DatabaseTable(ADDRESS)} | |
//however, it should be ... EMPLOYEE.ADDRESS_ID = 0 (null)... | |
Expression expression = builder.get("address").isNull().and(builder.get("lastName").notEqual("foopoyp")); | |
ReadAllExpressionTest test = new ReadAllExpressionTest(Employee.class, 0); | |
test.setExpression(expression); | |
test.setName("MultipleAndsExpressionTest6"); | |
test.setDescription("Test multiple ands expression"); | |
addTest(test); | |
} | |
/* | |
* bug 5683148/2380: Reducing unnecessary joins on an equality check between the a statement | |
* and itself | |
*/ | |
private void addEqualUnneccessaryJoinTest() { | |
Employee employee = (Employee)PopulationManager.getDefaultManager().getObject(new Employee().getClass(), "0008"); | |
ExpressionBuilder builder = new ExpressionBuilder(); | |
Expression expression = builder.get("firstName").equal("Fred").or(builder.get("manager").notEqual(builder.get("manager"))); | |
ReadObjectExpressionTest test = new ReadObjectExpressionTest(employee, expression); | |
test.setName("EqualUnneccessaryJoinTest"); | |
test.setDescription("Test = expression does not create an extra unneccessary join"); | |
addTest(test); | |
} | |
/** | |
* @bug 2612185 Support ReportItems,OrderBy Expressions from Parallel Builders. | |
* Find all managers of employees who have a spouse at work and a family | |
* income in excess of 100,000. | |
*/ | |
private void addManagersOfWealthyMarriedAtWorkEmployeesTest() { | |
ExpressionBuilder builder = new ExpressionBuilder(); | |
ExpressionBuilder innerBuilder = new ExpressionBuilder(Employee.class); | |
ExpressionBuilder innerSpouses = new ExpressionBuilder(Employee.class); | |
Expression innerExpression = innerBuilder.get("manager").equal(builder); | |
innerExpression = innerExpression.and(innerBuilder.get("lastName").equal(innerSpouses.get("lastName"))); | |
innerExpression = innerExpression.and(innerBuilder.get("gender").notEqual(innerSpouses.get("gender"))); | |
ReportQuery subquery = new ReportQuery(Employee.class, innerBuilder); | |
subquery.addAverage("family income", ExpressionMath.add(innerBuilder.get("salary"), innerSpouses.get("salary"))); | |
subquery.setSelectionCriteria(innerExpression); | |
Expression expression = builder.subQuery(subquery).equal(140000); | |
ReadAllExpressionTest test = new ReadAllExpressionTest(Employee.class, 2); | |
test.setExpression(expression); | |
test.testBatchAttributesOnEmployee(); | |
test.setName("ManagersOfWealthyMarriedAtWorkEmployeesTest"); | |
test.setDescription("Test executing query where subselect is a ReportQuery with ReportItems from multiple builders. Does not tests batch reading. For 2612185."); | |
test.addUnsupportedPlatform(TimesTenPlatform.class); | |
addTest(test); | |
} | |
/** | |
* @bug 2720149 INVALID SQL WHEN USING BATCH READS AND MULTIPLE ANYOFS | |
*/ | |
private void addOneToManyJoin2WithBatchReadTest() { | |
ExpressionBuilder builder = new ExpressionBuilder(); | |
Expression expression = builder.anyOf("managedEmployees").get("lastName").like("Sa%"); | |
Expression exp2 = builder.anyOf("managedEmployees").get("firstName").like("B%"); | |
expression = expression.and(exp2); | |
ReadAllExpressionTest test = new ReadAllExpressionTest(Employee.class, 1); | |
test.setExpression(expression); | |
test.testBatchAttributesOnEmployee(); | |
test.setName("OneToManyJoin2WithBatchReadTest"); | |
test.setDescription("Test a join across a 1:many relation with 2 anyOf clauses, and test again as part of a batch read."); | |
addTest(test); | |
} | |
} | |
public static TestSuite getUOWInsertObjectTestSuite() { | |
TestSuite suite = new TestSuite(); | |
suite.setName("EmployeeUOWBasicInsertObjectTestSuite"); | |
suite.setDescription("This suite tests the insertion of each object in the employee demo using uow."); | |
EmployeePopulator populator = new EmployeePopulator(); | |
suite.addTest(new UnitOfWorkBasicInsertObjectTest(populator.basicEmployeeExample1())); | |
suite.addTest(new UnitOfWorkBasicInsertObjectTest(populator.basicEmployeeExample2())); | |
suite.addTest(new UnitOfWorkBasicInsertObjectTest(populator.basicEmployeeExample3())); | |
suite.addTest(new UnitOfWorkBasicInsertObjectTest(populator.basicEmployeeExample4())); | |
suite.addTest(new UnitOfWorkBasicInsertObjectTest(populator.basicEmployeeExample5())); | |
return suite; | |
} | |
static class EmployeeDeleteTest extends DeleteObjectTest { | |
public EmployeeDeleteTest(Object originalObject) { | |
super(originalObject); | |
} | |
protected void setup() { | |
super.setup(); | |
// Must drop references first to appease constraints. | |
getSession().executeNonSelectingCall(new SQLCall("delete from OTOJT_PROJ_LEADER where EMP_ID = " + ((Employee)getOriginalObject()).getId())); | |
getSession().executeNonSelectingCall(new SQLCall("delete from OTOJT_EMP_MANAGER where MANAGER_ID = " + ((Employee)getOriginalObject()).getId())); | |
} | |
} | |
static class ProjectDeleteTest extends DeleteObjectTest { | |
public ProjectDeleteTest(Object originalObject) { | |
super(originalObject); | |
} | |
protected void setup() { | |
super.setup(); | |
// Must drop references first to appease constraints. | |
getSession().executeNonSelectingCall(new SQLCall("delete from OTOJT_PROJ_EMP where PROJ_ID = " + ((Project)getOriginalObject()).getId())); | |
} | |
} | |
static class ReadAllExpressionTest extends org.eclipse.persistence.testing.tests.expressions.ReadAllExpressionTest { | |
public ReadAllExpressionTest(Class referenceClass, int originalObjectsSize) { | |
super(referenceClass, originalObjectsSize); | |
} | |
protected void setupBatchAttributes() { | |
getQuery().addBatchReadAttribute("children"); | |
getQuery().addBatchReadAttribute("address"); | |
getQuery().addBatchReadAttribute("responsibilitiesList"); | |
getQuery().addBatchReadAttribute("projects"); | |
} | |
protected void testBatchAttributes() { | |
Vector result = (Vector) this.objectsFromDatabase; | |
List children = ((Employee) result.elementAt(0)).getChildren(); | |
((Employee) result.elementAt(0)).getResponsibilitiesList().size(); | |
((Employee) result.elementAt(0)).getProjects().size(); | |
if ((children == null) || (children.size() == 0)) { | |
throw new TestErrorException("The original query was corrupted when made part of a batch query."); | |
} | |
if (((Employee) result.elementAt(0)).getAddress() == null) { | |
throw new TestErrorException("The original query was corrupted when made part of a batch query."); | |
} | |
} | |
} | |
} |