KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > rift > coad > util > transaction > UserTransactionWrapperTest


1 /*
2  * CoadunationLib: The coaduntion library.
3  * Copyright (C) 2006 Rift IT Contracting
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Lesser General Public
7  * License as published by the Free Software Foundation; either
8  * version 2.1 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13  * Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public
16  * License along with this library; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18  *
19  * UserTransactionWrapperTest.java
20  */

21
22 package com.rift.coad.util.transaction;
23
24 // java imports
25
import junit.framework.*;
26 import javax.naming.Context JavaDoc;
27 import javax.naming.InitialContext JavaDoc;
28 import javax.transaction.UserTransaction JavaDoc;
29 import javax.transaction.Status JavaDoc;
30 import java.util.HashSet JavaDoc;
31 import java.util.Set JavaDoc;
32 import javax.transaction.xa.XAException JavaDoc;
33 import javax.transaction.xa.XAResource JavaDoc;
34 import javax.transaction.xa.Xid JavaDoc;
35
36
37 // object web imports
38
import org.objectweb.jotm.Jotm;
39
40 // coadunation imports
41
import com.rift.coad.lib.naming.NamingDirector;
42 import com.rift.coad.lib.naming.ContextManager;
43 import com.rift.coad.lib.db.DBSourceManager;
44
45 import com.rift.coad.lib.interceptor.InterceptorFactory;
46 import com.rift.coad.lib.security.RoleManager;
47 import com.rift.coad.lib.security.ThreadsPermissionContainer;
48 import com.rift.coad.lib.security.ThreadPermissionSession;
49 import com.rift.coad.lib.security.UserSession;
50 import com.rift.coad.lib.security.user.UserSessionManager;
51 import com.rift.coad.lib.security.user.UserStoreManager;
52 import com.rift.coad.lib.security.SessionManager;
53 import com.rift.coad.lib.security.login.LoginManager;
54 import com.rift.coad.lib.thread.CoadunationThreadGroup;
55
56 import com.rift.coad.lib.configuration.Configuration;
57 import com.rift.coad.lib.configuration.ConfigurationFactory;
58 import com.rift.coad.util.lock.LockRef;
59 import com.rift.coad.util.lock.ObjectLockFactory;
60 import com.rift.coad.lib.transaction.TransactionDirector;
61
62 /**
63  * This object is here to test the user transaction wrapper.
64  *
65  * @author Brett Chaldecott
66  */

67 public class UserTransactionWrapperTest extends TestCase {
68     
69     public class TransactionTestResource implements XAResource JavaDoc {
70         
71         // private member variables
72
private String JavaDoc name = null;
73         
74         /**
75          * The transaction test resource contructor
76          */

77         public TransactionTestResource(String JavaDoc name) {
78             this.name = name;
79         }
80         
81         public void commit(Xid JavaDoc xid, boolean b) throws XAException JavaDoc {
82             commit ++;
83         }
84         
85         public void end(Xid JavaDoc xid, int i) throws XAException JavaDoc {
86         }
87         
88         public void forget(Xid JavaDoc xid) throws XAException JavaDoc {
89         }
90         
91         public int getTransactionTimeout() throws XAException JavaDoc {
92             return -1;
93         }
94         
95         public boolean isSameRM(XAResource JavaDoc xAResource) throws XAException JavaDoc {
96             return this == xAResource;
97         }
98         
99         public int prepare(Xid JavaDoc xid) throws XAException JavaDoc {
100             return -1;
101         }
102         
103         public Xid JavaDoc[] recover(int i) throws XAException JavaDoc {
104             return null;
105         }
106         
107         public void rollback(Xid JavaDoc xid) throws XAException JavaDoc {
108             rollback++;
109         }
110         
111         public boolean setTransactionTimeout(int i) throws XAException JavaDoc {
112             return true;
113         }
114         
115         public void start(Xid JavaDoc xid, int i) throws XAException JavaDoc {
116             System.out.println("Start on : " + name + " id [" + xid + "]");
117         }
118         
119     }
120     
121     public UserTransactionWrapperTest(String JavaDoc testName) {
122         super(testName);
123     }
124
125     protected void setUp() throws Exception JavaDoc {
126     }
127
128     protected void tearDown() throws Exception JavaDoc {
129     }
130     
131     private int rollback = 0;
132     private int commit = 0;
133
134     /**
135      * Test of class com.rift.coad.util.transaction.UserTransactionWrapper.
136      */

137     public void testUserTransactionWrapper() throws Exception JavaDoc {
138         System.out.println("testUserTransactionWrapper");
139         
140         // init the session information
141
ThreadsPermissionContainer permissions = new ThreadsPermissionContainer();
142         SessionManager.init(permissions);
143         UserStoreManager userStoreManager = new UserStoreManager();
144         UserSessionManager sessionManager = new UserSessionManager(permissions,
145                 userStoreManager);
146         LoginManager.init(sessionManager,userStoreManager);
147         // instanciate the thread manager
148
CoadunationThreadGroup threadGroup = new CoadunationThreadGroup(sessionManager,
149                 userStoreManager);
150         
151         // add a user to the session for the current thread
152
RoleManager.getInstance();
153         
154         InterceptorFactory.init(permissions,sessionManager,userStoreManager);
155         
156         // add a new user object and add to the permission
157
Set JavaDoc set = new HashSet JavaDoc();
158         set.add("test");
159         UserSession user = new UserSession("test1", set);
160         permissions.putSession(new Long JavaDoc(Thread.currentThread().getId()),
161                 new ThreadPermissionSession(
162                 new Long JavaDoc(Thread.currentThread().getId()),user));
163         
164         // init the naming director
165
NamingDirector.init(threadGroup);
166         
167         // instanciate the transaction director
168
TransactionDirector transactionDirector = TransactionDirector.init();
169         
170         try {
171             TransactionManager.getInstance();
172             fail("Could retrieve a tranaction manager reference before init");
173         } catch (TransactionException ex) {
174             System.out.println(ex.getMessage());
175         }
176         
177         // init the transaction manager
178
ObjectLockFactory.init();
179         TransactionManager.init();
180         
181         UserTransactionWrapper instance = new UserTransactionWrapper();
182         
183         try {
184             instance.begin();
185             try {
186                 instance.begin();
187                 TransactionManager.getInstance().bindResource(
188                         new TransactionTestResource("test1"),false);
189             } finally {
190                 instance.release();
191             }
192         } finally {
193             instance.release();
194         }
195         
196         if (rollback != 1) {
197             fail("Rollback was not called on the object : " + rollback);
198         }
199         if (commit == 1) {
200             fail("Commit was called on the object");
201         }
202         
203         try {
204             instance.begin();
205             try {
206                 instance.begin();
207                 TransactionManager.getInstance().bindResource(
208                         new TransactionTestResource("test2"),false);
209             } finally {
210                 instance.release();
211             }
212             instance.commit();
213         } finally {
214             instance.release();
215         }
216         
217         if (rollback != 1) {
218             fail("Rollback was not called on the object");
219         }
220         if (commit != 1) {
221             fail("Commit was called on the object");
222         }
223     }
224
225     
226 }
227
Popular Tags