/**
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.openejb.core.cmp.jpa;
import org.apache.openejb.test.entity.cmp.ComplexCmpBean;
import org.apache.openejb.test.entity.cmp.UnknownCmpBean;
import org.apache.openejb.test.entity.cmp.BasicCmpBean;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityTransaction;
import javax.sql.DataSource;
import javax.transaction.Status;
import javax.transaction.TransactionManager;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Set;
public class JpaTestObject extends junit.framework.Assert {
private EntityManagerFactory entityManagerFactory;
private TransactionManager transactionManager;
private DataSource nonJtaDs;
private EntityManager entityManager;
private EntityTransaction transaction;
private static final String MCLAUGHLIN = "Brett McLaughlin";
private static final String FLANAGAN = "David Flanagan";
private static final String TIGER = "Java 5.0 Tiger";
private static final String JAVASCRIPT = "JavaScript";
private static final String ENTERPRISE_APPS = "Building Java Enterprise Applications";
public EntityManagerFactory getEntityManagerFactory() {
return entityManagerFactory;
}
public void setEntityManagerFactory(EntityManagerFactory entityManagerFactory) {
this.entityManagerFactory = entityManagerFactory;
}
public TransactionManager getTransactionManager() {
return transactionManager;
}
public void setTransactionManager(TransactionManager transactionManager) {
this.transactionManager = transactionManager;
}
public DataSource getNonJtaDs() {
return nonJtaDs;
}
public void setNonJtaDs(DataSource nonJtaDs) {
this.nonJtaDs = nonJtaDs;
}
public void setUp() throws Exception {
}
public void tearDown() throws Exception {
if (entityManager != null && entityManager.isOpen()) {
if (transactionManager == null) {
try {
if (entityManager.getTransaction().getRollbackOnly()) {
entityManager.getTransaction().rollback();
} else {
entityManager.getTransaction().commit();
}
} catch (Exception e) {
e.printStackTrace();
}
} else {
try {
if (transactionManager.getStatus() != Status.STATUS_NO_TRANSACTION) {
transactionManager.rollback();
}
} catch (Exception e) {
e.printStackTrace();
}
}
entityManager.close();
}
nonJtaDs = null;
entityManager = null;
entityManagerFactory = null;
transactionManager = null;
}
public void jpaLifecycle() throws Exception {
newDeleteNew();
employeeTest();
billTest();
cmpText();
complexCmpText();
unknownCmpText();
manytoMany();
// beginTx();
// ABean_ABean a = new ABean_ABean();
// a.setField1(2);
// entityManager.persist(a);
// BBean_BBean b = new BBean_BBean();
// b.setField1(22);
// entityManager.persist(b);
// commitTx();
//
// beginTx();
// b = entityManager.find(BBean_BBean.class, 22);
// a = entityManager.find(ABean_ABean.class, 2);
// a.OpenEJB_addCmr("b", b);
// b.OpenEJB_addCmr("a", a);
// commitTx();
//
//// dump();
//
// beginTx();
// b = entityManager.find(BBean_BBean.class, 22);
// assertNotNull(b);
// assertEquals(new Integer(22), b.getField1());
//// a = (ABean_ABean) b.OpenEJB_getCmr("a");
//// assertNotNull(a);
//// assertEquals(new Integer(2), a.getField1());
// commitTx();
}
private void newDeleteNew() throws Exception {
beginTx();
// Create new
Person dain = new Person();
dain.setName("dain");
assertFalse(entityManager.contains(dain));
entityManager.persist(dain);
entityManager.flush();
dain = entityManager.merge(dain);
assertTrue(entityManager.contains(dain));
// Find and verify
dain = entityManager.find(Person.class, "dain");
assertNotNull(dain);
assertEquals("dain", dain.getName());
// Delete
entityManager.remove(dain);
assertFalse(entityManager.contains(dain));
// Recreate
dain = new Person();
dain.setName("dain");
assertFalse(entityManager.contains(dain));
entityManager.persist(dain);
entityManager.flush();
dain = entityManager.merge(dain);
assertTrue(entityManager.contains(dain));
// Find and verify
dain = entityManager.find(Person.class, "dain");
assertNotNull(dain); // <<<<<<< FAILS
assertEquals("dain", dain.getName());
commitTx();
}
private void employeeTest() throws Exception {
// get the pk for the inserted row
int davidPk = -1;
{
Connection connection = null;
Statement statement = null;
try {
connection = nonJtaDs.getConnection();
statement = connection.createStatement();
ResultSet resultSet = statement.executeQuery("select * from employee");
resultSet.next();
davidPk = resultSet.getInt("id");
} finally {
close(statement);
close(connection);
}
}
beginTx();
assertTrue(entityManager.isOpen());
Employee david = entityManager.find(Employee.class, davidPk);
assertTrue(entityManager.contains(david));
assertEquals(david.getId(), davidPk);
assertEquals(david.getFirstName(), "David");
assertEquals(david.getLastName(), "Blevins");
commitTx();
beginTx();
david = entityManager.find(Employee.class, davidPk);
assertTrue(entityManager.contains(david));
assertEquals(david.getId(), davidPk);
assertEquals(david.getFirstName(), "David");
assertEquals(david.getLastName(), "Blevins");
commitTx();
beginTx();
david = (Employee) entityManager.createQuery("select e from Employee e where e.firstName='David'").getSingleResult();
assertTrue(entityManager.contains(david));
assertEquals(david.getId(), davidPk);
assertEquals(david.getFirstName(), "David");
assertEquals(david.getLastName(), "Blevins");
commitTx();
beginTx();
david = entityManager.find(Employee.class, davidPk);
entityManager.remove(david);
assertFalse(entityManager.contains(david));
david = entityManager.find(Employee.class, davidPk);
assertNull(david);
commitTx();
beginTx();
Employee dain = new Employee();
dain.setFirstName("Dain");
dain.setLastName("Sundstrom");
assertFalse(entityManager.contains(dain));
entityManager.persist(dain);
// extract primary key seems to require a flush followed by a merge
entityManager.flush();
dain = entityManager.merge(dain);
int dainId = dain.getId();
assertTrue(entityManager.contains(dain));
commitTx();
beginTx();
dain = entityManager.find(Employee.class, dainId);
assertTrue(entityManager.contains(dain));
assertEquals(dain.getId(), dainId);
assertEquals(dain.getFirstName(), "Dain");
assertEquals(dain.getLastName(), "Sundstrom");
commitTx();
beginTx();
dain = (Employee) entityManager.createQuery("select e from Employee e").getSingleResult();
assertTrue(entityManager.contains(dain));
assertEquals(dain.getId(), dainId);
assertEquals(dain.getFirstName(), "Dain");
assertEquals(dain.getLastName(), "Sundstrom");
commitTx();
}
public void billTest() throws Exception {
// get the pk for the inserted row
BillPk basicPk;
{
Connection connection = null;
Statement statement = null;
try {
connection = nonJtaDs.getConnection();
statement = connection.createStatement();
ResultSet resultSet = statement.executeQuery("select * from bill");
resultSet.next();
basicPk = new BillPk(resultSet.getLong("billNumber"), resultSet.getLong("billVersion"), resultSet.getLong("billRevision"));
} finally {
close(statement);
close(connection);
}
}
beginTx();
assertTrue(entityManager.isOpen());
Bill basic = entityManager.find(Bill.class, basicPk);
assertTrue(entityManager.contains(basic));
assertTrue(basicPk.equals(new BillPk(1, 0, 0)));
assertEquals(basic.getBillNumber(), 1);
assertEquals(basic.getBillVersion(), 0);
assertEquals(basic.getBillRevision(), 0);
assertEquals(basic.getBillDescription(), "Basic Model");
commitTx();
beginTx();
basic = (Bill) entityManager.createQuery("select e from Bill e where e.billDescription='Basic Model'").getSingleResult();
assertTrue(entityManager.contains(basic));
assertTrue(basicPk.equals(new BillPk(1, 0, 0)));
assertEquals(basic.getBillNumber(), 1);
assertEquals(basic.getBillVersion(), 0);
assertEquals(basic.getBillRevision(), 0);
assertEquals(basic.getBillDescription(), "Basic Model");
commitTx();
beginTx();
basic = entityManager.find(Bill.class, basicPk);
entityManager.remove(basic);
assertFalse(entityManager.contains(basic));
basic = entityManager.find(Bill.class, basicPk);
assertNull(basic);
commitTx();
beginTx();
Bill advanced = new Bill();
advanced.setBillNumber(1000);
advanced.setBillVersion(2000);
advanced.setBillRevision(3000);
advanced.setBillDescription("This is so advanced!!");
assertFalse(entityManager.contains(advanced));
entityManager.persist(advanced);
// extract primary key seems to require a flush followed by a merge
entityManager.flush();
advanced = entityManager.merge(advanced);
BillPk advancedPk = new BillPk(advanced.getBillNumber(), advanced.getBillVersion(), advanced.getBillRevision());
assertTrue(entityManager.contains(advanced));
commitTx();
beginTx();
advanced = entityManager.find(Bill.class, advancedPk);
assertTrue(entityManager.contains(advanced));
assertTrue(advancedPk.equals(new BillPk(1000, 2000, 3000)));
assertEquals(advanced.getBillNumber(), 1000);
assertEquals(advanced.getBillVersion(), 2000);
assertEquals(advanced.getBillRevision(), 3000);
assertEquals(advanced.getBillDescription(), "This is so advanced!!");
commitTx();
beginTx();
advanced = (Bill) entityManager.createQuery("select e from Bill e").getSingleResult();
assertTrue(entityManager.contains(advanced));
assertTrue(advancedPk.equals(new BillPk(1000, 2000, 3000)));
assertEquals(advanced.getBillNumber(), 1000);
assertEquals(advanced.getBillVersion(), 2000);
assertEquals(advanced.getBillRevision(), 3000);
assertEquals(advanced.getBillDescription(), "This is so advanced!!");
commitTx();
}
private void cmpText() throws Exception {
beginTx();
BasicCmpBean basicCmpBean = new BasicCmpBean_Subclass();
basicCmpBean.ejbCreateObject("Joe Blow");
assertFalse(entityManager.contains(basicCmpBean));
entityManager.persist(basicCmpBean);
// extract primary key seems to require a flush followed by a merge
entityManager.flush();
basicCmpBean = entityManager.merge(basicCmpBean);
int joeId = basicCmpBean.getPrimaryKey();
assertTrue(entityManager.contains(basicCmpBean));
commitTx();
beginTx();
basicCmpBean = new BasicCmpBean_Subclass();
basicCmpBean.ejbCreateObject("Lloyd Dobler");
assertFalse(entityManager.contains(basicCmpBean));
entityManager.persist(basicCmpBean);
// extract primary key seems to require a flush followed by a merge
entityManager.flush();
basicCmpBean = entityManager.merge(basicCmpBean);
int lloydId = basicCmpBean.getPrimaryKey();
assertTrue(entityManager.contains(basicCmpBean));
commitTx();
beginTx();
BasicCmpBean joe = (BasicCmpBean) entityManager.createQuery("select e from BasicCmpBean_Subclass e where e.primaryKey=" + joeId).getSingleResult();
assertTrue(entityManager.contains(joe));
assertEquals(joe.getPrimaryKey(), joeId);
assertEquals(joe.getFirstName(), "Joe");
assertEquals(joe.getLastName(), "Blow");
BasicCmpBean lloyd = (BasicCmpBean) entityManager.createQuery("select e from BasicCmpBean_Subclass e where e.primaryKey=" + lloydId).getSingleResult();
assertTrue(entityManager.contains(lloyd));
assertEquals(lloyd.getPrimaryKey(), lloydId);
assertEquals(lloyd.getFirstName(), "Lloyd");
assertEquals(lloyd.getLastName(), "Dobler");
commitTx();
}
private void complexCmpText() throws Exception {
beginTx();
ComplexCmpBean complexCmpBean = new ComplexCmpBean_Subclass();
complexCmpBean.ejbCreateObject("Joe Blow");
assertFalse(entityManager.contains(complexCmpBean));
entityManager.persist(complexCmpBean);
// extract primary key seems to require a flush followed by a merge
entityManager.flush();
complexCmpBean = entityManager.merge(complexCmpBean);
assertTrue(entityManager.contains(complexCmpBean));
commitTx();
beginTx();
complexCmpBean = new ComplexCmpBean_Subclass();
complexCmpBean.ejbCreateObject("Lloyd Dobler");
assertFalse(entityManager.contains(complexCmpBean));
entityManager.persist(complexCmpBean);
// extract primary key seems to require a flush followed by a merge
entityManager.flush();
complexCmpBean = entityManager.merge(complexCmpBean);
assertTrue(entityManager.contains(complexCmpBean));
commitTx();
beginTx();
ComplexCmpBean joe = (ComplexCmpBean) entityManager.createQuery("select e from ComplexCmpBean_Subclass e where e.firstName='Joe'").getSingleResult();
assertTrue(entityManager.contains(joe));
assertEquals(joe.getFirstName(), "Joe");
assertEquals(joe.getLastName(), "Blow");
ComplexCmpBean lloyd = (ComplexCmpBean) entityManager.createQuery("select e from ComplexCmpBean_Subclass e where e.firstName='Lloyd'").getSingleResult();
assertTrue(entityManager.contains(lloyd));
assertEquals(lloyd.getFirstName(), "Lloyd");
assertEquals(lloyd.getLastName(), "Dobler");
commitTx();
}
private void unknownCmpText() throws Exception {
beginTx();
UnknownCmpBean unknownCmpBean = new UnknownCmpBean_Subclass();
unknownCmpBean.ejbCreateObject("Joe Blow");
assertFalse(entityManager.contains(unknownCmpBean));
entityManager.persist(unknownCmpBean);
// extract primary key seems to require a flush followed by a merge
entityManager.flush();
unknownCmpBean = entityManager.merge(unknownCmpBean);
Object joeId = unknownCmpBean.getPrimaryKey();
assertTrue(entityManager.contains(unknownCmpBean));
commitTx();
beginTx();
unknownCmpBean = new UnknownCmpBean_Subclass();
unknownCmpBean.ejbCreateObject("Lloyd Dobler");
assertFalse(entityManager.contains(unknownCmpBean));
entityManager.persist(unknownCmpBean);
// extract primary key seems to require a flush followed by a merge
entityManager.flush();
unknownCmpBean = entityManager.merge(unknownCmpBean);
Object lloydId = unknownCmpBean.getPrimaryKey();
assertTrue(entityManager.contains(unknownCmpBean));
commitTx();
beginTx();
UnknownCmpBean joe = (UnknownCmpBean) entityManager.createQuery("select e from UnknownCmpBean_Subclass e where e.firstName='Joe'").getSingleResult();
assertTrue(entityManager.contains(joe));
assertEquals(joe.getPrimaryKey(), joeId);
assertEquals(joe.getFirstName(), "Joe");
assertEquals(joe.getLastName(), "Blow");
UnknownCmpBean lloyd = (UnknownCmpBean) entityManager.createQuery("select e from UnknownCmpBean_Subclass e where e.firstName='Lloyd'").getSingleResult();
assertTrue(entityManager.contains(lloyd));
assertEquals(lloyd.getPrimaryKey(), lloydId);
assertEquals(lloyd.getFirstName(), "Lloyd");
assertEquals(lloyd.getLastName(), "Dobler");
commitTx();
}
private void manytoMany() throws Exception {
beginTx();
AuthorBean mcLaughlin = new AuthorBean(MCLAUGHLIN);
AuthorBean flanagan = new AuthorBean(FLANAGAN);
BookBean tiger = new BookBean(TIGER);
BookBean javaScript = new BookBean(JAVASCRIPT);
BookBean enterpriseApps = new BookBean(ENTERPRISE_APPS);
entityManager.persist(mcLaughlin);
entityManager.persist(flanagan);
entityManager.persist(tiger);
entityManager.persist(javaScript);
entityManager.persist(enterpriseApps);
commitTx();
link(MCLAUGHLIN, TIGER);
link(MCLAUGHLIN, ENTERPRISE_APPS);
link(FLANAGAN, TIGER);
link(FLANAGAN, JAVASCRIPT);
beginTx();
BookBean book = entityManager.find(BookBean.class, TIGER);
assertTrue(entityManager.contains(book));
assertEquals(book.getTitle(), TIGER);
Set<AuthorBean> authors = book.getAuthors();
assertEquals(authors.size(), 2);
commitTx();
}
private void link(String authorName, String title) throws Exception {
beginTx();
AuthorBean author = entityManager.find(AuthorBean.class, authorName);
assertNotNull("Author not found " + authorName, author);
BookBean book = entityManager.find(BookBean.class, title);
assertNotNull("Book not found " + title, book);
book.OpenEJB_addCmr("authors", author);
author.OpenEJB_addCmr("books", book);
commitTx();
}
private void createEntityManager() {
entityManager = entityManagerFactory.createEntityManager();
// OpenJPAEntityManager openjpaEM = (OpenJPAEntityManager) entityManager;
// openjpaEM.addLifecycleListener(new JpaTestObject.OpenJPALifecycleListener(), (Class[])null);
}
private void beginTx() throws Exception {
createEntityManager();
String msg = "BEGIN_TX";
log(msg);
if (transactionManager != null) {
transactionManager.begin();
entityManager.joinTransaction();
} else {
transaction = entityManager.getTransaction();
transaction.begin();
}
}
public void log(String msg) {
// System.out.println(msg);
}
private void commitTx() throws Exception {
log(" BEFORE_COMMIT_TX");
try {
if (transactionManager != null) {
transactionManager.commit();
} else {
transaction.commit();
}
} finally {
if (entityManager != null && entityManager.isOpen()) {
entityManager.close();
}
entityManager = null;
log("AFTER_COMMIT_TX");
}
}
// private class OpenJPALifecycleListener extends AbstractLifecycleListener {
// protected void eventOccurred(LifecycleEvent event) {
// int type = event.getType();
// switch (type) {
// case LifecycleEvent.BEFORE_PERSIST:
// log(" BEFORE_PERSIST");
// break;
// case LifecycleEvent.AFTER_PERSIST:
// log(" AFTER_PERSIST");
// break;
// case LifecycleEvent.AFTER_LOAD:
// log(" AFTER_LOAD");
// break;
// case LifecycleEvent.BEFORE_STORE:
// log(" BEFORE_STORE");
// break;
// case LifecycleEvent.AFTER_STORE:
// log(" AFTER_STORE");
// break;
// case LifecycleEvent.BEFORE_CLEAR:
// log(" BEFORE_CLEAR");
// break;
// case LifecycleEvent.AFTER_CLEAR:
// log(" AFTER_CLEAR");
// break;
// case LifecycleEvent.BEFORE_DELETE:
// log(" BEFORE_DELETE");
// break;
// case LifecycleEvent.AFTER_DELETE:
// log(" AFTER_DELETE");
// break;
// case LifecycleEvent.BEFORE_DIRTY:
// log(" BEFORE_DIRTY");
// break;
// case LifecycleEvent.AFTER_DIRTY:
// log(" AFTER_DIRTY");
// break;
// case LifecycleEvent.BEFORE_DIRTY_FLUSHED:
// log(" BEFORE_DIRTY_FLUSHED");
// break;
// case LifecycleEvent.AFTER_DIRTY_FLUSHED:
// log(" AFTER_DIRTY_FLUSHED");
// break;
// case LifecycleEvent.BEFORE_DETACH:
// log(" BEFORE_DETACH");
// break;
// case LifecycleEvent.AFTER_DETACH:
// log(" AFTER_DETACH");
// break;
// case LifecycleEvent.BEFORE_ATTACH:
// log(" BEFORE_ATTACH");
// break;
// case LifecycleEvent.AFTER_ATTACH:
// log(" AFTER_ATTACH");
// break;
// case LifecycleEvent.AFTER_REFRESH:
// log(" AFTER_REFRESH");
// break;
// default:
// log(" default");
// break;
// }
// super.eventOccurred(event);
// }
//
// public void beforePersist(LifecycleEvent event) {
// eventOccurred(event);
// }
//
// public void afterRefresh(LifecycleEvent event) {
// eventOccurred(event);
// }
//
// public void beforeDetach(LifecycleEvent event) {
// eventOccurred(event);
// }
//
// public void afterDetach(LifecycleEvent event) {
// eventOccurred(event);
// }
//
// public void beforeAttach(LifecycleEvent event) {
// eventOccurred(event);
// }
//
// public void afterAttach(LifecycleEvent event) {
// eventOccurred(event);
// }
// }
protected void dump() throws SQLException {
JpaTestObject.dumpTable(nonJtaDs, "employee");
JpaTestObject.dumpTable(nonJtaDs, "OneToOneA");
JpaTestObject.dumpTable(nonJtaDs, "OneToOneB");
}
public static void dumpTable(DataSource ds, String table) throws SQLException {
Connection connection = null;
Statement statement = null;
ResultSet resultSet = null;
try {
connection = ds.getConnection();
statement = connection.createStatement();
resultSet = statement.executeQuery("SELECT * FROM " + table);
ResultSetMetaData setMetaData = resultSet.getMetaData();
int columnCount = setMetaData.getColumnCount();
while(resultSet.next()) {
StringBuilder row = new StringBuilder();
for (int i = 1; i <= columnCount; i++) {
if (i > 1) {
row.append(", ");
}
String name = setMetaData.getColumnName(i);
Object value = resultSet.getObject(i);
row.append(name).append("=").append(value);
}
System.out.println(row);
}
} finally {
JpaTestObject.close(resultSet);
JpaTestObject.close(statement);
JpaTestObject.close(connection);
}
}
private static void close(ResultSet resultSet) {
if (resultSet == null) return;
try {
resultSet.close();
} catch (SQLException e) {
}
}
private static void close(Statement statement) {
if (statement == null) return;
try {
statement.close();
} catch (SQLException e) {
}
}
private static void close(Connection connection) {
if (connection == null) return;
try {
connection.close();
} catch (SQLException e) {
}
}
}