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.stateless.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 table test in the database using bean-managed transaction. This class
039: * uses differents combination of 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: * Inserts the table and makes an UserTransaction.begin() before create the
063: * table.
064: * @param callOnlyTransaction says if the table must be created or only the
065: * UserTransaction.begin() and UserTransaction.commit() must be
066: * called.
067: * @param dbName database where the table must be inserted.
068: * @throws SQLException if a database error occurs.
069: * @throws NamingException if a lookup error occurs.
070: * @throws SystemException if an unexpected error occurs.
071: * @throws NotSupportedException if the resquest cannot be made.
072: */
073: void insertTableWithoutCommit(final boolean callOnlyTransaction,
074: final String dbName) throws SQLException, NamingException,
075: SystemException, NotSupportedException;
076:
077: /**
078: * Inserts the table and makes an UserTransaction.begin() before create the
079: * table and an UserTransaction.commit() after create.
080: * @param callOnlyTransaction says if the table must be created or only the
081: * UserTransaction.begin() and UserTransaction.commit() must be
082: * called.
083: * @param dbName database where the table must be inserted.
084: * @throws SQLException if a database error occurs.
085: * @throws NamingException if a lookup error occurs.
086: * @throws SystemException if an unexpected error occurs.
087: * @throws NotSupportedException if the resquest cannot be made.
088: * @throws HeuristicRollbackException if a heuristic decision was made and
089: * some relevant update was rolled back.
090: * @throws RollbackException if the transaction was rolled back instead of
091: * committed.
092: * @throws HeuristicMixedException if a heuristic decision was made and some
093: * relevant update was commited and others rolled back.
094: * @throws TransactionException if the transaction must to make a rollback.
095: */
096: void insertTableWithBeginCommit(final boolean callOnlyTransaction,
097: final String dbName) throws SQLException, NamingException,
098: SystemException, NotSupportedException,
099: HeuristicRollbackException, RollbackException,
100: HeuristicMixedException, TransactionException;
101:
102: /**
103: * Deletes the table and makes an UserTransaction.commit() after create.
104: * @param callOnlyTransaction says if the table must be created or only the
105: * UserTransaction.begin() and UserTransaction.commit() must be
106: * called.
107: * @param dbName database where the table must be inserted.
108: * @throws SQLException if a database error occurs.
109: * @throws NamingException if a lookup error occurs.
110: * @throws SystemException if an unexpected error occurs.
111: * @throws NotSupportedException if the resquest cannot be made.
112: * @throws HeuristicRollbackException if a heuristic decision was made and
113: * some relevant update was rolled back.
114: * @throws RollbackException if the transaction was rolled back instead of
115: * committed.
116: * @throws HeuristicMixedException if a heuristic decision was made and some
117: * relevant update was commited and others rolled back.
118: */
119: void deleteTableWithoutBegin(final boolean callOnlyTransaction,
120: final String dbName) throws SQLException, NamingException,
121: SystemException, NotSupportedException,
122: HeuristicRollbackException, RollbackException,
123: HeuristicMixedException;
124:
125: /**
126: * Deletes the table and makes an UserTransaction.begin() before create the
127: * table and an UserTransaction.commit() after create.
128: * @param callOnlyTransaction says if the table must be created or only the
129: * UserTransaction.begin() and UserTransaction.commit() must be
130: * called.
131: * @param dbName database where the table must be inserted.
132: * @throws SQLException if a database error occurs.
133: * @throws NamingException if a lookup error occurs.
134: * @throws SystemException if an unexpected error occurs.
135: * @throws NotSupportedException if the resquest cannot be made.
136: * @throws HeuristicRollbackException if a heuristic decision was made and
137: * some relevant update was rolled back.
138: * @throws RollbackException if the transaction was rolled back instead of
139: * committed.
140: * @throws HeuristicMixedException if a heuristic decision was made and some
141: * relevant update was commited and others rolled back.
142: * @throws TransactionException if the transaction must to make a rollback.
143: */
144: void deleteTableWithBeginCommit(final boolean callOnlyTransaction,
145: final String dbName) throws SQLException, NamingException,
146: SystemException, NotSupportedException,
147: HeuristicRollbackException, RollbackException,
148: HeuristicMixedException, TransactionException;
149:
150: /**
151: * Makes a setRollbackOnly that must to throw en exception.
152: * @throws NamingException if a lookup error occurs.
153: * @throws IllegalStateException if the bean try to call the setRollBackOnly
154: */
155: public void setRollbackOnly() throws NamingException,
156: IllegalStateException;
157:
158: /**
159: * Makes a getRollbackOnly that must to throw en exception.
160: * @throws NamingException if a lookup error occurs.
161: * @throws IllegalStateException if the bean try to call the getRollBackOnly
162: */
163: public void getRollbackOnly() throws NamingException,
164: IllegalStateException;
165:
166: }
|