/**
* 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.stateful;
import junit.framework.TestCase;
import org.apache.openejb.OpenEJB;
import org.apache.openejb.OpenEJBException;
import org.apache.openejb.assembler.classic.AppInfo;
import org.apache.openejb.assembler.classic.Assembler;
import org.apache.openejb.assembler.classic.SecurityServiceInfo;
import org.apache.openejb.assembler.classic.TransactionServiceInfo;
import org.apache.openejb.config.AppModule;
import org.apache.openejb.config.ConfigurationFactory;
import org.apache.openejb.config.EjbModule;
import org.apache.openejb.config.PersistenceModule;
import org.apache.openejb.core.ivm.naming.InitContextFactory;
import org.apache.openejb.jee.AssemblyDescriptor;
import org.apache.openejb.jee.EjbJar;
import org.apache.openejb.jee.EjbLocalRef;
import org.apache.openejb.jee.StatefulBean;
import org.apache.openejb.jee.StatelessBean;
import org.apache.openejb.jee.jpa.unit.Persistence;
import org.apache.openejb.jee.jpa.unit.PersistenceUnit;
import org.apache.openjpa.persistence.ArgumentException;
import javax.ejb.EJB;
import javax.ejb.EJBException;
import javax.ejb.Local;
import javax.ejb.NoSuchEJBException;
import javax.ejb.Remove;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.persistence.Entity;
import javax.persistence.EntityManager;
import javax.persistence.Id;
import javax.persistence.PersistenceContext;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import static javax.persistence.PersistenceContextType.EXTENDED;
import static javax.persistence.PersistenceContextType.TRANSACTION;
public class EntityManagerPropogationTest extends TestCase {
public void test() throws Exception {
_testEMClose();
_testExtended();
_testExtendedRemove();
_testExtendedRandomRemove();
_testNotTooExtended();
_testTransaction();
_testSFTr2SFEx();
_testSFEx2SLTr2SFEx();
_testSLTr2SFEx();
}
private void _testEMClose() throws Exception {
final InitialContext ctx = new InitialContext();
final PleaseCloseMyExtendedEmBean checkExtendedWorks = (PleaseCloseMyExtendedEmBean) ctx.lookup("PleaseCloseMyExtendedEmLocalBean");
EntityManager savedReference = checkExtendedWorks.getDelegate();
checkExtendedWorks.remove();
assertFalse(savedReference.isOpen());
final PleaseCloseMyEmBean please = (PleaseCloseMyEmBean) ctx.lookup("PleaseCloseMyEmLocalBean");
savedReference = please.getDelegate();
please.remove();
assertFalse(savedReference.isOpen());
final PleaseCloseMyEmBean statelessIsEasier = (PleaseCloseMyEmBean) ctx.lookup("PleaseCloseMyLessEmLocalBean");
savedReference = statelessIsEasier.getDelegate();
statelessIsEasier.remove();
assertFalse(savedReference.isOpen());
}
public void _testExtended() throws Exception {
final InitialContext ctx = new InitialContext();
Node node = (Node) ctx.lookup("ExtendedLocalBean");
// This bean should still be attached
// when the transaction commits
final Color attached = node.create(1, "Red");
while (node.getChild() != null) {
assertTrue(node.contains(attached));
node = node.getChild();
}
}
/**
* Test that the extended persistence context can
* survive the removal of the parent
*
* @throws Exception
*/
public void _testExtendedRemove() throws Exception {
final InitialContext ctx = new InitialContext();
Node node = (Node) ctx.lookup("ExtendedLocalBean");
// This bean should still be attached
// when the transaction commits
final Color attached = node.create(2, "Blue");
while (node.getChild() != null) {
assertTrue(node.contains(attached));
final Node next = node.getChild();
node.remove();
try {
node.contains(attached);
fail("The Stateful bean should have been removed");
} catch (final NoSuchEJBException e) {
// good
}
node = next;
}
}
public void _testExtendedRandomRemove() throws Exception {
final InitialContext ctx = new InitialContext();
int size;
final Random rdm = new Random();
for (int l = 0; l < 10; l++) { // because Romain is not sure of the Random ;-)
Node node = (Node) ctx.lookup("ExtendedLocalBean");
final List<Node> nodes = new ArrayList<Node>();
final List<EntityManager> delegates = new ArrayList<EntityManager>();
while (node.getChild() != null) {
nodes.add(node);
delegates.add(node.getDelegateEntityManager());
node = node.getChild();
}
// random remove all stateful
do {
size = nodes.size();
final int i = rdm.nextInt(size);
final Node n = nodes.remove(i);
final EntityManager entityManager = delegates.remove(i);
n.remove();
if (--size == 0) {
assertFalse(entityManager.isOpen());
} else {
assertTrue(entityManager.isOpen());
}
} while (size > 0);
}
}
/**
* Test that two Stateful session bean siblings
* do not share the same extended persistence context
* <p/>
* A stateful session bean must be a child in order
* for the context to be propogated to that bean.
*
* @throws Exception
*/
public void _testNotTooExtended() throws Exception {
final InitialContext ctx = new InitialContext();
// Stateful Node tree A and Node tree B are syblings
final Node chainA = (Node) ctx.lookup("ExtendedLocalBean");
Node chainB = (Node) ctx.lookup("ExtendedLocalBean");
// This bean should still be attached
// when the transaction commits
final Color attachedA = chainA.create(3, "Green");
while (chainB.getChild() != null) {
assertFalse(chainB.contains(attachedA));
chainB = chainB.getChild();
}
}
public void _testTransaction() throws Exception {
final InitialContext ctx = new InitialContext();
Node node = (Node) ctx.lookup("TransactionLocalBean");
// This bean should not still be attached
// when the transaction commits
final Color detached = node.create(4, "Yellow");
while (node.getChild() != null) {
assertFalse(node.contains(detached));
node = node.getChild();
}
}
public void _testSFTr2SFEx() throws Exception {
final InitialContext ctx = new InitialContext();
final Node node = (Node) ctx.lookup("TransactionToExtendedLocalBean");
try {
// System.out.println("SFSB+TPC --> SFSB+EPC");
node.createUntilLeaf(5, "Yellow");
fail("5.6.3.1 Requirements for Persistence Context Propagation (persistence spec)" +
"\n\t--> we cannot have two persistence contexts associated with the transaction");
} catch (final EJBException e) {
// OK
// System.out.println(e.getMessage());
}
}
public void _testSFEx2SLTr2SFEx() throws Exception {
final InitialContext ctx = new InitialContext();
final Node node = (Node) ctx.lookup("ExtendedToTransactionLocalBean");
try {
// System.out.println("SFSB+EPC --> SLSB+TPC --> SFSB+EPC");
node.createUntilLeaf(6, "red");
} catch (final EJBException e) {
e.printStackTrace();
fail("5.6.3.1 Requirements for Persistence Context Propagation (persistence spec)" +
"\n\t--> the SFSB+EPC is the one who starts the transaction and then calls the " +
"SLSB+TPC who then calls back to the SFSB+EPC \n\t--> IT SHOULD WORK ...");
}
}
public void _testSLTr2SFEx() throws Exception {
final InitialContext ctx = new InitialContext();
final Node node = (Node) ctx.lookup("TransactionToExtendedLocalBean");
try {
// System.out.println("SLSB+TPC --> SFSB+EPC");
node.createUntilLeaf(8, "Yellow");
fail("5.6.3.1 Requirements for Persistence Context Propagation (persistence spec)" +
"\n\t--> we cannot have two persistence contexts associated with the transaction");
} catch (final EJBException e) {
// OK
// System.out.println(e.getMessage());
}
}
public void setUp() throws OpenEJBException, IOException, NamingException {
System.setProperty(javax.naming.Context.INITIAL_CONTEXT_FACTORY, InitContextFactory.class.getName());
System.setProperty("openejb.embedded", "true");
// Boot up the minimum required OpenEJB components
final Assembler assembler = new Assembler();
final ConfigurationFactory config = new ConfigurationFactory();
assembler.createTransactionManager(config.configureService(TransactionServiceInfo.class));
assembler.createSecurityService(config.configureService(SecurityServiceInfo.class));
// Start creating the test application
// Create an ejb-jar.xml for this app
final EjbJar ejbJar = new EjbJar();
ejbJar.addEnterpriseBean(new StatefulBean("PleaseCloseMyExtendedEm", PleaseCloseMyExtendedEmBean.class));
ejbJar.addEnterpriseBean(new StatefulBean("PleaseCloseMyEm", PleaseCloseMyEmBean.class));
ejbJar.addEnterpriseBean(new StatelessBean("PleaseCloseMyLessEm", PleaseCloseMyEmBean.class));
// Add six beans and link them all in a chain
addStatefulBean(ejbJar, ExtendedContextBean.class, "Extended", "Extendedx2");
addStatefulBean(ejbJar, ExtendedContextBean.class, "Extendedx2", "Extendedx3");
addStatefulBean(ejbJar, ExtendedContextBean.class, "Extendedx3", "Extendedx4");
addStatefulBean(ejbJar, ExtendedContextBean.class, "Extendedx4", "Extendedx5");
addStatefulBean(ejbJar, ExtendedContextBean.class, "ExtendedToTransaction", "StatelessTransactionToExtended");
addStatefulBean(ejbJar, ExtendedContextBean.class, "Extendedx5", "Extendedx6");
ejbJar.addEnterpriseBean(new StatefulBean("Extendedx6", EndNodeBean.class));
// Add six beans and link them all in a chain
addStatefulBean(ejbJar, TransactionContextBean.class, "Transaction", "Transactionx2");
addStatefulBean(ejbJar, TransactionContextBean.class, "Transactionx2", "Transactionx3");
addStatefulBean(ejbJar, TransactionContextBean.class, "Transactionx3", "Transactionx4");
addStatefulBean(ejbJar, TransactionContextBean.class, "Transactionx4", "Transactionx5");
addStatefulBean(ejbJar, TransactionContextBean.class, "Transactionx5", "Transactionx6");
addStatefulBean(ejbJar, TransactionContextBean.class, "TransactionToExtended", "Extendedx5");
addStatelessBean(ejbJar, TransactionContextBean.class, "StatelessTransactionToExtended", "Extendedx5");
ejbJar.addEnterpriseBean(new StatefulBean("Transactionx6", EndNodeBean.class));
ejbJar.setAssemblyDescriptor(new AssemblyDescriptor());
ejbJar.getAssemblyDescriptor().addApplicationException(IllegalArgumentException.class, false, true);
ejbJar.getAssemblyDescriptor().addApplicationException(ArgumentException.class, false, true);
// List<ContainerTransaction> declared = ejbJar.getAssemblyDescriptor().getContainerTransaction();
// declared.add(new ContainerTransaction(TransAttribute.REQUIRED, ExtendedContextBean.class.getName(), "Extendedx5", "*"));
// declared.add(new ContainerTransaction(TransAttribute.REQUIRED, ExtendedContextBean.class.getName(), "TransactionToExtended", "*"));
final EjbModule ejbModule = new EjbModule(ejbJar);
// Create an "ear"
final AppModule appModule = new AppModule(ejbModule.getClassLoader(), "test-app");
// Add the ejb-jar.xml to the ear
appModule.getEjbModules().add(ejbModule);
// Create a persistence-unit for this app
final PersistenceUnit unit = new PersistenceUnit("testUnit");
unit.addClass(Color.class);
unit.setProperty("openjpa.jdbc.SynchronizeMappings", "buildSchema(ForeignKeys=true)");
unit.getProperties().setProperty("openjpa.RuntimeUnenhancedClasses", "supported");
// Add the persistence.xml to the "ear"
appModule.addPersistenceModule(new PersistenceModule("root", new Persistence(unit)));
// Configure and assemble the ear -- aka. deploy it
final AppInfo info = config.configureApplication(appModule);
assembler.createApplication(info);
}
@Override
protected void tearDown() throws Exception {
OpenEJB.destroy();
}
private void addStatefulBean(final EjbJar ejbJar, final Class<?> ejbClass, final String name, final String reference) {
final StatefulBean bean = ejbJar.addEnterpriseBean(new StatefulBean(name, ejbClass));
bean.getEjbLocalRef().add(new EjbLocalRef("child", reference));
}
private void addStatelessBean(final EjbJar ejbJar, final Class<?> ejbClass, final String name, final String reference) {
final StatelessBean bean = ejbJar.addEnterpriseBean(new StatelessBean(name, ejbClass));
bean.getEjbLocalRef().add(new EjbLocalRef("child", reference));
}
@Entity
public static class Color {
@Id
private int id;
private String name;
public Color() {
}
public Color(final int id, final String name) {
this.id = id;
this.name = name;
}
public int getId() {
return id;
}
public void setId(final int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(final String name) {
this.name = name;
}
}
@Local
public static interface Node {
void remove();
Color create(int id, String name);
void createUntilLeaf(int id, String name);
boolean contains(Color bean);
Node getChild();
String getDelegateEntityManagerReference();
EntityManager getDelegateEntityManager();
}
public static class PleaseCloseMyExtendedEmBean {
@PersistenceContext(unitName = "testUnit", type = EXTENDED)
protected EntityManager context;
public EntityManager getDelegate() {
return (EntityManager) context.getDelegate();
}
@Remove
public void remove() {
}
}
public static class PleaseCloseMyEmBean {
@PersistenceContext(unitName = "testUnit", type = TRANSACTION)
protected EntityManager context;
public EntityManager getDelegate() {
return (EntityManager) context.getDelegate();
}
@Remove
public void remove() {
}
}
/**
* The root stateful session bean is essentially the "owner"
* of the persistence context and all children downstream
* with an EXTENDED persistence context should share the same
* persistence context and underlying EntityManager
* <p/>
* Transactions are dissabled to ensure that we aren't relying
* on the JTA propogation that also exists with an EXTENDED
* persistence context
*/
public static class ExtendedContextBean extends NodeBean {
@PersistenceContext(unitName = "testUnit", type = EXTENDED)
protected EntityManager context;
protected EntityManager getEntityManager() {
return context;
}
public EntityManager getDelegateEntityManager() {
return (EntityManager) context.getDelegate();
}
}
public static class TransactionContextBean extends NodeBean {
@PersistenceContext(unitName = "testUnit", type = TRANSACTION)
protected EntityManager context;
protected EntityManager getEntityManager() {
return context;
}
public EntityManager getDelegateEntityManager() {
return (EntityManager) context.getDelegate();
}
}
public static abstract class NodeBean implements Node {
@EJB(name = "child")
protected Node child;
public Color create(final int id, final String name) {
final Color color = new Color(id, name);
getEntityManager().persist(color);
return color;
}
public void createUntilLeaf(final int id, final String name) {
this.create(id, name);
// recursively call until the leaf is achieved
getChild().createUntilLeaf(id * 10 + 1, name);
}
protected abstract EntityManager getEntityManager();
public Node getChild() {
return child;
}
public String getDelegateEntityManagerReference() {
return getEntityManager().getDelegate().toString();
}
public boolean contains(final Color bean) throws IllegalArgumentException {
// This call should not fail as the bean was created
// via the extended persistence context we are now in
return getEntityManager().contains(bean);
}
@Remove
public void remove() {
}
}
public static class EndNodeBean implements Node {
public boolean contains(final Color color) {
return false;
}
public Color create(final int id, final String name) {
return null;
}
public void createUntilLeaf(final int id, final String name) {
return;
}
public Node getChild() {
return null;
}
public String getDelegateEntityManagerReference() {
return null;
}
public EntityManager getDelegateEntityManager() {
return null;
}
@Remove
public void remove() {
}
}
}