001: /**
002: * EasyBeans
003: * Copyright (C) 2006 Bull S.A.S.
004: * Contact: easybeans@ow2.org
005: *
006: * This library is free software; you can redistribute it and/or
007: * modify it under the terms of the GNU Lesser General Public
008: * License as published by the Free Software Foundation; either
009: * version 2.1 of the License, or any later version.
010: *
011: * This library is distributed in the hope that it will be useful,
012: * but WITHOUT ANY WARRANTY; without even the implied warranty of
013: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
014: * Lesser General Public License for more details.
015: *
016: * You should have received a copy of the GNU Lesser General Public
017: * License along with this library; if not, write to the Free Software
018: * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
019: * USA
020: *
021: * --------------------------------------------------------------------------
022: * $Id: TestExceptionHandleSupports.java 1970 2007-10-16 11:49:25Z benoitf $
023: * --------------------------------------------------------------------------
024: */package org.ow2.easybeans.tests.transaction.containermanaged.stateful;
025:
026: import java.sql.SQLException;
027:
028: import javax.ejb.EJBTransactionRolledbackException;
029:
030: import org.ow2.easybeans.tests.common.ejbs.stateful.containermanaged.transaction.SFSBContainerTransacSupportsApp01;
031: import org.ow2.easybeans.tests.common.ejbs.stateful.containermanaged.transaction.SFSBContainerTransacSupportsApp02;
032: import org.ow2.easybeans.tests.common.ejbs.stateful.containermanaged.transaction.SFSBContainerTransactionSupportsApp;
033: import org.ow2.easybeans.tests.common.ejbs.stateful.containermanaged.transaction.SFSBContainerTransactionSupportsRollback;
034: import org.ow2.easybeans.tests.common.ejbs.stateful.containermanaged.transaction.SFSBContainerTransactionSupportsRuntime;
035: import org.ow2.easybeans.tests.transaction.containermanaged.base.TestExceptionHandleBase;
036: import org.testng.annotations.BeforeMethod;
037: import org.testng.annotations.Test;
038:
039: /**
040: * Verifies if the container-managed transaction in the session bean is
041: * following the JSR 220. The container must handle the different types of
042: * exception in the transaction context. The items covered in this test are:
043: * 14.3.1
044: * @reference JSR 220-FINAL RELEASE
045: * @requirement Application Server must be running; the bean .
046: * SFSBContainerTransactionSupportsApp,
047: * SFSBContainerTransacSupportsApp01,
048: * SFSBContainerTransacSupportsApp02
049: * SFSBContainerTransactionSupportsRollback and
050: * SFSBContainerTransactionSupportstRuntime must be deployed .
051: * @setup gets the reference of the beans , cleans the database and close all
052: * transactions.
053: * @author Gisele Pinheiro Souza
054: * @author Eduardo Studzinski Estima de Castro
055: */
056: public class TestExceptionHandleSupports extends
057: TestExceptionHandleBase {
058:
059: /**
060: * Creates the bean intances, closes the transactions and cleans the
061: * database.
062: * @throws Exception if an error during the bean creation occurs.
063: */
064: @BeforeMethod
065: @Override
066: public void setup() throws Exception {
067: super .setup();
068: }
069:
070: /**
071: * Creates a bean that throws always an application exception that extends
072: * Exception and has the rollback element as false.
073: * @throws Exception if an error during the bean creation occurs.
074: */
075: @Override
076: public void createBeanApp() throws Exception {
077: super .createBeanApp(SFSBContainerTransactionSupportsApp.class);
078: }
079:
080: /**
081: * Creates a bean that throws always an application exception that extends
082: * RuntimeException and has the rollback element as false.
083: * @throws Exception if an error during the bean creation occurs.
084: */
085: @Override
086: public void createBeanApp01() throws Exception {
087: super .createBeanApp01(SFSBContainerTransacSupportsApp01.class);
088: }
089:
090: /**
091: * Creates a bean that throws always an application exception that extends
092: * RuntimeException and has the rollback element as true.
093: * @throws Exception if an error during the bean creation occurs.
094: */
095: @Override
096: public void createBeanApp02() throws Exception {
097: super .createBeanApp02(SFSBContainerTransacSupportsApp02.class);
098: }
099:
100: /**
101: * Creates a bean that throws always an application exception that extends
102: * Exception and has the rollback element as true.
103: * @throws Exception if an error during the bean creation occurs.
104: */
105: @Override
106: public void createBeanRollback() throws Exception {
107: super
108: .createBeanRollback(SFSBContainerTransactionSupportsRollback.class);
109: }
110:
111: /**
112: * Creates a bean that throws always aa runtime exception.
113: * @throws Exception if an error during the bean creation occurs.
114: */
115: @Override
116: public void createBeanRuntime() throws Exception {
117: super
118: .createBeanRuntime(SFSBContainerTransactionSupportsRuntime.class);
119: }
120:
121: /**
122: * Inserts a table in an database and after throws an application exception
123: * that extends Exception and has the rollback element as false. So, the
124: * container must not rollback the transaction and must re-throw the
125: * exception.
126: * @input -
127: * @output the correct method execution.
128: * @see org.ow2.easybeans.tests.transaction.containermanaged.base.TestExceptionHandleBase
129: * @throws Exception if an error during the tests occurs.
130: */
131: @Test(groups={"application exception tests"})
132: @Override
133: public void testNotUsingClientTransWithAppException()
134: throws Exception {
135: super .testNotUsingClientTransWithAppException();
136: }
137:
138: /**
139: * Inserts a table in an database and after throws an application exception
140: * that extends Exception and has the rollback element as false. So, the
141: * container must not rollback the transaction and must re-throw the
142: * exception.
143: * @input -
144: * @output the correct method execution.
145: * @see org.ow2.easybeans.tests.transaction.containermanaged.base.TestExceptionHandleBase
146: * @throws Exception if an error during the tests occurs.
147: */
148: @Test(groups={"application rollback exception tests"})
149: @Override
150: public void testNotUsingClientTransWithAppRollbackException()
151: throws Exception {
152: super .testNotUsingClientTransWithAppRollbackException();
153: }
154:
155: /**
156: * Inserts a table in an database and after throws a runtime exception So,
157: * the container must not rollback the transaction and must throw the
158: * EJBException.
159: * @input -
160: * @output the correct method execution.
161: * @see org.ow2.easybeans.tests.transaction.containermanaged.base.TestExceptionHandleBase
162: * @throws Exception if an error during the tests occurs.
163: */
164: @Test(groups={"runtime exception tests"})
165: @Override
166: public void testNotUsingClientTransWithRuntimeException()
167: throws Exception {
168: super .testNotUsingClientTransWithRuntimeException();
169: }
170:
171: /**
172: * Inserts a table in an database and after throws an application exception
173: * that extends RuntimeException and has the rollback element as false. So, the
174: * container must not rollback the transaction and must re-throw the
175: * exception.
176: * @input -
177: * @output the correct method execution.
178: * @see org.ow2.easybeans.tests.transaction.containermanaged.base.TestExceptionHandleBase
179: * @throws Exception if an error during the tests occurs.
180: */
181: @Test
182: @Override
183: public void testNotUsingClientTransWithAppRuntimeRollbackException()
184: throws Exception {
185: super .testNotUsingClientTransWithAppRuntimeRollbackException();
186: }
187:
188: /**
189: * Inserts a table in an database and after throws an application exception
190: * that extends RuntimeException and has the rollback element as true. So, the
191: * container must not rollback the transaction and must re-throw the
192: * exception.
193: * @input -
194: * @output the correct method execution.
195: * @see org.ow2.easybeans.tests.transaction.containermanaged.base.TestExceptionHandleBase
196: * @throws Exception if an error during the tests occurs.
197: */
198: @Test
199: @Override
200: public void testNotUsingClientTransWithAppRuntimeException()
201: throws Exception {
202: super .testNotUsingClientTransWithAppRuntimeException();
203: }
204:
205: /**
206: * Inserts a table in an database and after throws an application exception
207: * that extends Exception and has the rollback element as false. The test
208: * uses the client transaction, so, the container must not mark the client
209: * transaction for rollback and must re-throw the exception.
210: * @input -
211: * @output the correct method execution.
212: * @see org.ow2.easybeans.tests.transaction.containermanaged.base.TestExceptionHandleBase
213: * @throws Exception if an error during the tests occurs.
214: */
215: @Override
216: @Test(groups={"application exception tests"})
217: public void testUsingClientTransWithAppException() throws Exception {
218: super .testUsingClientTransWithAppException();
219: }
220:
221: /**
222: * Inserts a table in an database and after throws an application exception
223: * that extends Exception and has the rollback element as true. The test
224: * uses the client transaction, so, the container must mark the client
225: * transaction for rollback and must re-throw the exception.
226: * @input - *
227: * @output the exception when the test makes a select in the database to
228: * find the table created.
229: * @see org.ow2.easybeans.tests.transaction.containermanaged.base.TestExceptionHandleBase
230: * @throws Exception if an error during the tests occurs.
231: */
232: @Test(groups={"application rollback exception tests"},expectedExceptions=SQLException.class)
233: public void tesUsingClientTransWithAppRollbackException()
234: throws Exception {
235: super .testUsingClientTransWithAppRollbackException(false);
236: }
237:
238: /**
239: * Inserts a table in an database and after throws an application exception
240: * that extends RuntimeException and has the rollback element as false. The
241: * test uses the client transaction, so, the container must not mark the
242: * client transaction for rollback and must re-throw the exception.
243: * @input -
244: * @output the correct method execution.
245: * @see org.ow2.easybeans.tests.transaction.containermanaged.base.TestExceptionHandleBase
246: * @throws Exception if an error during the tests occurs.
247: */
248: @Test(groups={"runtime exception tests"})
249: public void testUsingClientTransWithRuntimeException()
250: throws Exception {
251: super .testUsingClientTransWithRuntimeException(
252: EJBTransactionRolledbackException.class, false);
253: }
254:
255: /**
256: * Inserts a table in an database and after throws an application exception
257: * that extends RuntimeException and has the rollback element as false. The
258: * test uses the client transaction, so, the container must not mark the
259: * client transaction for rollback and must re-throw the exception.
260: * @input -
261: * @output the correct method execution.
262: * @see org.ow2.easybeans.tests.transaction.containermanaged.base.TestExceptionHandleBase
263: * @throws Exception if an error during the tests occurs.
264: */
265: @Override
266: @Test
267: public void testUsingClientTransWithAppRuntimeException()
268: throws Exception {
269: super .testUsingClientTransWithAppRuntimeException();
270: }
271:
272: /**
273: * Inserts a table in an database and after throws an application exception
274: * that extends RuntimeException and has the rollback element as false. The
275: * test uses the client transaction, so, the container must not mark the
276: * client transaction for rollback and must re-throw the exception.
277: * @input -
278: * @output the correct method execution.
279: * @see org.ow2.easybeans.tests.transaction.containermanaged.base.TestExceptionHandleBase
280: * @throws Exception if an error during the tests occurs.
281: */
282: @Test(expectedExceptions=SQLException.class)
283: public void testUsingClientTransWithAppRuntimeRollbackException()
284: throws Exception {
285: super
286: .testUsingClientTransWithAppRuntimeRollbackException(false);
287: }
288:
289: }
|