KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > apache > jetspeed > services > security > TestPermissionManagement


1 /*
2  * Copyright 2000-2001,2004 The Apache Software Foundation.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 package org.apache.jetspeed.services.security;
18
19 import java.util.Iterator JavaDoc;
20 import java.util.HashMap JavaDoc;
21
22 // Junit imports
23 import junit.framework.Test;
24 import junit.framework.TestSuite;
25
26 import org.apache.turbine.services.TurbineServices;
27 import org.apache.turbine.util.TurbineConfig;
28 import org.apache.turbine.util.StringUtils;
29
30 // Jetspeed imports
31 import org.apache.jetspeed.test.JetspeedTestCase;
32 import org.apache.jetspeed.om.security.Permission;
33 import org.apache.jetspeed.om.security.JetspeedPermissionFactory;
34
35 import org.apache.jetspeed.services.security.JetspeedSecurityCache;
36
37 /**
38  * Unit test for PermissionManagement interface
39  *
40  * @author <a HREF="mailto:david@bluesunrise.com">David Sean Taylor</a>
41  * @version $Id: TestPermissionManagement.java,v 1.1 2004/04/07 22:02:43 jford Exp $
42  */
43
44 public class TestPermissionManagement extends JetspeedTestCase {
45
46     /**
47      * Defines the testcase name for JUnit.
48      *
49      * @param name the testcase's name.
50      */
51     public TestPermissionManagement( String JavaDoc name ) {
52         super( name );
53     }
54     
55     /**
56      * Start the tests.
57      *
58      * @param args the arguments. Not used
59      */
60     public static void main(String JavaDoc args[])
61     {
62         junit.awtui.TestRunner.main( new String JavaDoc[] { TestPermissionManagement.class.getName() } );
63     }
64  
65     public void setup()
66     {
67         //System.out.println("Setup: Testing Turbine Permission Management");
68 }
69
70     /**
71      * Creates the test suite.
72      *
73      * @return a test suite (<code>TestSuite</code>) that includes all methods
74      * starting with "test"
75      */
76     public static Test suite()
77     {
78         // All methods starting with "test" will be executed in the test suite.
79 return new TestSuite( TestPermissionManagement.class );
80     }
81
82     /**
83      * Tests getPermissions method
84      * @throws Exception
85      */
86
87     public void testGetPermissions() throws Exception JavaDoc
88     {
89         PermissionManagement service = getService();
90         Permission permission = null;
91         HashMap JavaDoc map = new HashMap JavaDoc();
92         JetspeedSecurityCache.loadRolePermissions();
93
94         try
95         {
96             Iterator JavaDoc permissions = service.getPermissions();
97             while (permissions.hasNext())
98             {
99                 permission = (Permission)permissions.next();
100                 map.put(permission.getName(), permission);
101                 //System.out.println("permission = " + permission.getName());
102 //System.out.println("id = " + permission.getId());
103 }
104             assertTrue(map.get("view") != null);
105             assertTrue(map.get("customize") != null);
106         }
107         catch (Exception JavaDoc e)
108         {
109             fail(StringUtils.stackTrace(e));
110         }
111
112         System.out.println("Completed getPermissions Test OK ");
113
114     }
115
116     /**
117      * Tests getPermissions method
118      * @throws Exception
119      */
120
121     public void testGetPermissionsForUser() throws Exception JavaDoc
122     {
123         PermissionManagement service = getService();
124         Permission permission = null;
125         HashMap JavaDoc map = new HashMap JavaDoc();
126         JetspeedSecurityCache.loadRolePermissions();
127
128         try
129         {
130             Iterator JavaDoc permissions = service.getPermissions("user");
131             while (permissions.hasNext())
132             {
133                 permission = (Permission)permissions.next();
134                 map.put(permission.getName(), permission);
135             }
136             assertTrue(map.get("view") != null);
137             assertTrue(map.get("customize") != null);
138             assertTrue(map.get("close") == null);
139
140             map.clear();
141             permissions = service.getPermissions("admin");
142             while (permissions.hasNext())
143             {
144                 permission = (Permission)permissions.next();
145                 map.put(permission.getName(), permission);
146             }
147             assertTrue(map.get("view") != null);
148             assertTrue(map.get("customize") != null);
149             assertTrue(map.get("close") != null);
150
151         }
152         catch (Exception JavaDoc e)
153         {
154             fail(StringUtils.stackTrace(e));
155         }
156
157         System.out.println("Completed getPermissions Test OK ");
158
159     }
160
161     /**
162      * Tests addPermission method
163      * @throws Exception
164      */
165
166     public void testAddPermission() throws Exception JavaDoc
167     {
168         PermissionManagement service = getService();
169         Permission permission = null;
170         JetspeedSecurityCache.loadRolePermissions();
171
172         try
173         {
174             permission = JetspeedPermissionFactory.getInstance();
175             permission.setName("bogus");
176             service.addPermission(permission);
177             System.out.println("new permission id = " + permission.getId());
178             assertTrue(permission.getId() != null);
179         }
180         catch(Exception JavaDoc e)
181         {
182             fail(StringUtils.stackTrace(e));
183         }
184         try
185         {
186             permission = JetspeedPermissionFactory.getInstance();
187             permission.setName("bogus");
188             service.addPermission(permission);
189             fail("Should've thrown a dup key exception on permission");
190         }
191         catch(Exception JavaDoc e)
192         {
193             assertTrue(e instanceof PermissionException);
194         }
195
196         System.out.println("Completed addPermission Test OK ");
197
198     }
199
200     /**
201      * Tests getRemovePermission method
202      * @throws Exception
203      */
204
205     public void testRemovePermission() throws Exception JavaDoc
206     {
207         PermissionManagement service = getService();
208         Permission permission = null;
209         JetspeedSecurityCache.loadRolePermissions();
210
211         try
212         {
213             service.removePermission("bogus");
214         }
215         catch(Exception JavaDoc e)
216         {
217             fail(StringUtils.stackTrace(e));
218         }
219         try
220         {
221             service.removePermission("catchmeifyoucan");
222             fail("Should've thrown a not found exception on permission");
223         }
224         catch(Exception JavaDoc e)
225         {
226             assertTrue(e instanceof PermissionException);
227         }
228
229         System.out.println("Completed addPermission Test OK ");
230
231     }
232
233     /**
234      * Tests getPermission method
235      * @throws Exception
236      */
237
238     public void testGetPermission() throws Exception JavaDoc
239     {
240         PermissionManagement service = getService();
241         JetspeedSecurityCache.loadRolePermissions();
242
243         try
244         {
245             Permission permission = service.getPermission("view");
246             System.out.println("*** permission id = " + permission.getId());
247             assertTrue(permission.getName().equals("view"));
248         }
249         catch (Exception JavaDoc e)
250         {
251             fail(StringUtils.stackTrace(e));
252         }
253
254         System.out.println("Completed getPermission Test OK ");
255
256     }
257
258     /**
259      * Tests savePermission method
260      * @throws Exception
261      */
262
263     public void testSavePermission() throws Exception JavaDoc
264     {
265         PermissionManagement service = getService();
266         JetspeedSecurityCache.loadRolePermissions();
267
268         try
269         {
270             Permission permission = service.getPermission("customize");
271             service.savePermission(permission);
272         }
273         catch(Exception JavaDoc e)
274         {
275             fail(StringUtils.stackTrace(e));
276         }
277
278         System.out.println("Completed savePermission Test OK ");
279
280     }
281
282     /**
283      * Tests grantPermission method
284      * @throws Exception
285      */
286     public void testGrantPermission() throws Exception JavaDoc
287     {
288         PermissionManagement service = getService();
289         Permission permission = null;
290         JetspeedSecurityCache.loadRolePermissions();
291
292         try
293         {
294             service.grantPermission("user", "close");
295         }
296         catch(Exception JavaDoc e)
297         {
298             fail(StringUtils.stackTrace(e));
299         }
300         try
301         {
302             service.grantPermission("badrole", "close");
303             fail("Should've thrown a bad role exception on grant");
304         }
305         catch(Exception JavaDoc e)
306         {
307             assertTrue(e instanceof PermissionException);
308         }
309         try
310         {
311             service.grantPermission("user", "badpermission");
312             fail("Should've thrown a bad permission exception on grant");
313         }
314         catch(Exception JavaDoc e)
315         {
316             assertTrue(e instanceof PermissionException);
317         }
318
319         System.out.println("Completed grantPermission Test OK ");
320
321     }
322
323     /**
324      * Tests revokePermission method
325      * @throws Exception
326      */
327     public void testRevokePermission() throws Exception JavaDoc
328     {
329         PermissionManagement service = getService();
330         Permission permission = null;
331         JetspeedSecurityCache.loadRolePermissions();
332
333         try
334         {
335             service.revokePermission("user", "close");
336         }
337         catch(Exception JavaDoc e)
338         {
339             fail(StringUtils.stackTrace(e));
340         }
341         try
342         {
343             service.revokePermission("badrole", "close");
344             fail("Should've thrown a bad user exception on revoke");
345         }
346         catch(Exception JavaDoc e)
347         {
348             assertTrue(e instanceof PermissionException);
349         }
350
351         System.out.println("Completed revokePermission Test OK ");
352
353     }
354
355     /**
356      * Tests hasPermission method
357      * @throws Exception
358      */
359     public void testHasPermission() throws Exception JavaDoc
360     {
361         PermissionManagement service = getService();
362         Permission permission = null;
363         JetspeedSecurityCache.loadRolePermissions();
364
365         try
366         {
367             boolean has = service.hasPermission("user", "view");
368             assertTrue(true == has);
369         }
370         catch(Exception JavaDoc e)
371         {
372             fail(StringUtils.stackTrace(e));
373         }
374         try
375         {
376             boolean has = service.hasPermission("user", "close");
377             assertTrue(false == has);
378         }
379         catch(Exception JavaDoc e)
380         {
381             fail(StringUtils.stackTrace(e));
382         }
383
384         System.out.println("Completed hasPermission Test OK ");
385
386     }
387
388   /*
389     Configuration object to run Turbine outside a servlet container
390     ( uses turbine.properties )
391     */
392     private static TurbineConfig config = null;
393     
394     /**
395     Sets up TurbineConfig using the system property:
396     <pre>turbine.properties</pre>
397     */
398     static
399     {
400         try
401         {
402             config = new TurbineConfig( "webapp", "/WEB-INF/conf/TurbineResources.properties");
403             config.init();
404         }
405         catch (Exception JavaDoc e)
406         {
407             fail(StringUtils.stackTrace(e));
408         }
409     }
410
411     private static PermissionManagement getService()
412     {
413         return (PermissionManagement)TurbineServices
414                 .getInstance()
415                 .getService(PermissionManagement.SERVICE_NAME);
416     }
417
418 }
419
420
421
422
423
424
425
Popular Tags