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: ItfBeanManagedTransaction.java 1970 2007-10-16 11:49:25Z benoitf $
023: * --------------------------------------------------------------------------
024: */package org.ow2.easybeans.tests.common.ejbs.stateful.beanmanaged.transaction;
025:
026: import java.sql.SQLException;
027:
028: import javax.naming.NamingException;
029: import javax.transaction.HeuristicMixedException;
030: import javax.transaction.HeuristicRollbackException;
031: import javax.transaction.NotSupportedException;
032: import javax.transaction.RollbackException;
033: import javax.transaction.SystemException;
034:
035: import org.ow2.easybeans.tests.common.exception.TransactionException;
036:
037: /**
038: * Inserts a table called Test in the database.Creates differents combinations
039: * of transaction begin/commit.
040: * @author Gisele Pinheiro Souza
041: * @author Eduardo Studzinski Estima de Castro
042: */
043: public interface ItfBeanManagedTransaction {
044:
045: /**
046: * Table used during the tests.
047: */
048: String TABLE = "BeanManaged";
049:
050: /**
051: * Constants used to say that the table must not be created, only the
052: * transaction is called.
053: */
054: boolean CALL_TRANSACTION_ONLY = true;
055:
056: /**
057: * Constants used to say that the table must be created.
058: */
059: boolean CREATE_TABLE = false;
060:
061: /**
062: * Gets the transaction.
063: * @param callOnlyTransaction if only the transactions must be called.
064: * @param dbName the database where the table is inserted.
065: * @throws SQLException if a database error occurs.
066: * @throws NamingException if a lookup error occurs.
067: */
068: void startup(final boolean callOnlyTransaction, final String dbName)
069: throws NamingException, SQLException;
070:
071: /**
072: * Inserts the table called test. The transaction is open, but it is not
073: * commited in this method.
074: * @throws SQLException if a database error occurs.
075: * @throws NamingException if a lookup error occurs.
076: * @throws SystemException if an unexpected error occurs.
077: * @throws NotSupportedException if the resquest cannot be made.
078: */
079: void insertTableWithoutCommitTransaction() throws SQLException,
080: NamingException, SystemException, NotSupportedException;
081:
082: /**
083: * Inserts the table called test. The transaction is open and commited in
084: * this method.
085: * @throws SQLException if a database error occurs.
086: * @throws NamingException if a lookup error occurs.
087: * @throws SystemException if an unexpected error occurs.
088: * @throws NotSupportedException if the resquest cannot be made.
089: * @throws HeuristicRollbackException if a heuristic decision was made and
090: * some relevant update was rolled back.
091: * @throws RollbackException if the transaction was rolled back instead of
092: * committed.
093: * @throws HeuristicMixedException if a heuristic decision was made and some
094: * relevant update was commited and others rolled back.
095: * @throws TransactionException if a rollback was made.
096: */
097: void insertTableWithBeginCommitTransaction() throws SQLException,
098: NamingException, SystemException, NotSupportedException,
099: HeuristicRollbackException, RollbackException,
100: HeuristicMixedException, TransactionException;
101:
102: /**
103: * Deletes the table called test. The transaction is not open, but it is
104: * commited in this method.
105: * @throws SQLException if a database error occurs.
106: * @throws NamingException if a lookup error occurs.
107: * @throws SystemException if an unexpected error occurs.
108: * @throws NotSupportedException if the resquest cannot be made.
109: * @throws HeuristicRollbackException if a heuristic decision was made and
110: * some relevant update was rolled back.
111: * @throws RollbackException if the transaction was rolled back instead of
112: * committed.
113: * @throws HeuristicMixedException if a heuristic decision was made and some
114: * relevant update was commited and others rolled back.
115: */
116: void dropTableWithoutBeginTransaction() throws SQLException,
117: NamingException, SystemException, NotSupportedException,
118: HeuristicRollbackException, RollbackException,
119: HeuristicMixedException, TransactionException;
120:
121: /**
122: * Deletes the table called test. The bean transaction is started and
123: * commited in this method.
124: * @throws SQLException if a database error occurs.
125: * @throws NamingException if a lookup error occurs.
126: * @throws SystemException if an unexpected error occurs.
127: * @throws NotSupportedException if the resquest cannot be made.
128: * @throws HeuristicRollbackException if a heuristic decision was made and
129: * some relevant update was rolled back.
130: * @throws RollbackException if the transaction was rolled back instead of
131: * committed.
132: * @throws HeuristicMixedException if a heuristic decision was made and some
133: * relevant update was commited and others rolled back.
134: */
135: void dropTableWithBeginCommitTransaction() throws SQLException,
136: NamingException, SystemException, NotSupportedException,
137: HeuristicRollbackException, RollbackException,
138: HeuristicMixedException, TransactionException;
139:
140: /**
141: * Creates the table called test.The bean transaction is started and
142: * commited in this method and, also, there is a nested transaction.
143: * @throws SQLException if a database error occurs.
144: * @throws NamingException if a lookup error occurs.
145: * @throws SystemException if an unexpected error occurs.
146: * @throws NotSupportedException if the resquest cannot be made.
147: * @throws HeuristicRollbackException if a heuristic decision was made and
148: * some relevant update was rolled back.
149: * @throws RollbackException if the transaction was rolled back instead of
150: * committed.
151: * @throws HeuristicMixedException if a heuristic decision was made and some
152: * relevant update was commited and others rolled back.
153: */
154: void insertTableWithNestedTrans() throws SQLException,
155: NamingException, SystemException, NotSupportedException,
156: HeuristicRollbackException, RollbackException,
157: HeuristicMixedException, TransactionException;
158:
159: /**
160: * Creates the table called test.A new transaction is created and it makes
161: * the begin and commit transaction. The bean transaction is not started or
162: * commited in this method.
163: * @throws SQLException if a database error occurs.
164: * @throws NamingException if a lookup error occurs.
165: * @throws SystemException if an unexpected error occurs.
166: * @throws NotSupportedException if the resquest cannot be made.
167: * @throws HeuristicRollbackException if a heuristic decision was made and
168: * some relevant update was rolled back.
169: * @throws RollbackException if the transaction was rolled back instead of
170: * committed.
171: * @throws HeuristicMixedException if a heuristic decision was made and some
172: * relevant update was commited and others rolled back.
173: */
174: void insertTableWithNewTransaction() throws SQLException,
175: NamingException, SystemException, NotSupportedException,
176: HeuristicRollbackException, RollbackException,
177: HeuristicMixedException, TransactionException;
178:
179: /**
180: * Obtains the bean transaction status.
181: * @return the bean transaction status.
182: * @throws SystemException if an unexpected error occurs.
183: */
184: int getTransactionStatus() throws SystemException;
185:
186: /**
187: * Inserts the table called test. The transaction is openned and after
188: * insert the table, an rollback is called.
189: * @throws SQLException if a database error occurs.
190: * @throws NamingException if a lookup error occurs.
191: * @throws SystemException if an unexpected error occurs.
192: * @throws NotSupportedException if the resquest cannot be made.
193: */
194: void insertTableWithBeginRollback() throws SQLException,
195: NamingException, SystemException, NotSupportedException;
196:
197: /**
198: * Makes a rollback in the transaction
199: * @throws IllegalStateException if a transaction is not associated with a transaction.
200: * @throws SecurityException if the transaction is not allowed to make a rollback.
201: * @throws SystemException if an unexpected error occurs.
202: */
203: public void setRollback() throws IllegalStateException,
204: SecurityException, SystemException;
205:
206: /**
207: * Makes a setRollbackOnly that must to throw en exception.
208: * @throws NamingException if a lookup error occurs.
209: * @throws IllegalStateException if the bean try to call the setRollBackOnly
210: */
211: public void setRollbackOnly() throws NamingException,
212: IllegalStateException;
213:
214: /**
215: * Makes a getRollbackOnly that must to throw en exception.
216: * @throws NamingException if a lookup error occurs.
217: * @throws IllegalStateException if the bean try to call the getRollBackOnly
218: */
219: public void getRollbackOnly() throws NamingException,
220: IllegalStateException;
221: }
|