Java > Open Source Codes > org > sape > carbon > services > security > management > rdbms > test > RdbmsUserManagerServiceTest


1 /*
2  * The contents of this file are subject to the Sapient Public License
3  * Version 1.0 (the "License"); you may not use this file except in compliance
4  * with the License. You may obtain a copy of the License at
5  * http://carbon.sf.net/License.html.
6  *
7  * Software distributed under the License is distributed on an "AS IS" basis,
8  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for
9  * the specific language governing rights and limitations under the License.
10  *
11  * The Original Code is The Carbon Component Framework.
12  *
13  * The Initial Developer of the Original Code is Sapient Corporation
14  *
15  * Copyright (C) 2003 Sapient Corporation. All Rights Reserved.
16  */
17
18 package org.sape.carbon.services.security.management.rdbms.test;
19
20 import java.security.Principal ;
21 import java.security.acl.Group ;
22 import java.util.HashMap ;
23 import java.util.HashSet ;
24 import java.util.Map ;
25 import java.util.Set ;
26
27 import org.sape.carbon.core.component.Lookup;
28 import org.sape.carbon.core.exception.ExceptionUtility;
29 import org.sape.carbon.services.security.management.DefaultGroupImpl;
30 import org.sape.carbon.services.security.management.DefaultUserImpl;
31 import org.sape.carbon.services.security.management.DuplicatePrincipalException;
32 import org.sape.carbon.services.security.management.SecurityManagementException;
33 import org.sape.carbon.services.security.management.UnknownGroupException;
34 import org.sape.carbon.services.security.management.UnknownPrincipalException;
35 import org.sape.carbon.services.security.management.UserManager;
36 import org.sape.carbon.services.security.management.rdbms.RdbmsUserManagerConfiguration;
37
38 import junit.extensions.ActiveTestSuite;
39 import junit.framework.Test;
40 import junit.framework.TestCase;
41 import junit.framework.TestSuite;
42
43 /**
44  * Test harness for the RdbmsUserManager implementation of the UserManager
45  * service
46  *
47  * @author Jordan Reed, September 2002
48  * @version $Revision: 1.7 $($Author: dvoet $ / $Date: 2003/10/28 19:02:01 $)
49  *
50  * @since carbon 1.2
51  */
52 public class RdbmsUserManagerServiceTest extends TestCase {
53     private static final String STANDARD_RDBMS_USERMANAGER =
54         "/security/management/test/RdbmsOracleUserManager";
55     private static final String TEST_USERNAME = "test-user";
56     private static final Map TEST_CREDENTIAL = new HashMap ();
57     private static final String TEST_STANDALONE_USERNAME =
58         "test-standalone-user";
59     private static final Map TEST_STANDALONE_CREDENTIAL = new HashMap ();
60     private static final String TEST_NONEXIST_USERNAME =
61         "non-existent-user";
62     private static final String TEST_NONEXIST_GROUPNAME =
63         "non-existent-group";
64     private static final String TEST_CHILD_GROUPNAME = "test-group";
65     private static final String TEST_PARENT_GROUPNAME = "test-group-2";
66     private static final String TEST_CYCLE_GROUPNAME = "test-group-cycle";
67
68     static {
69         TEST_STANDALONE_CREDENTIAL.put(
70             RdbmsUserManagerConfiguration.CreateUserBindParameters[0],
71             TEST_STANDALONE_USERNAME);
72         TEST_CREDENTIAL.put(
73             RdbmsUserManagerConfiguration.CreateUserBindParameters[0],
74             TEST_USERNAME);
75     }
76     /**
77      * Constructs a new instance of the test.
78      *
79      * @param name DOCUMENT ME!
80      */
81     public RdbmsUserManagerServiceTest(String name) {
82         super(name);
83     }
84
85     /**
86      * Tests creation of a user.
87      */
88     public void testCreateUser() throws SecurityManagementException {
89         UserManager userManager =
90             (UserManager) Lookup.getInstance().fetchComponent(
91                 STANDARD_RDBMS_USERMANAGER);
92
93         Principal user =
94             userManager.createUser(TEST_USERNAME, TEST_CREDENTIAL);
95
96         Principal cycledUser =
97             userManager.createUser(
98                 TEST_STANDALONE_USERNAME, TEST_STANDALONE_CREDENTIAL);
99
100         if (user == null) {
101             fail(
102                 "After call to createUser, a null user object "
103                 + "was returned.");
104         }
105     }
106
107     /**
108      * Tests that creating a user with a name that already exists will
109      * throw the proper exception.
110      */
111     public void testCreateUserDuplicatePrincipal() throws SecurityManagementException {
112         UserManager userManager =
113             (UserManager) Lookup.getInstance().fetchComponent(
114                 STANDARD_RDBMS_USERMANAGER);
115
116         try {
117             Principal user =
118                 userManager.createUser(TEST_USERNAME, TEST_CREDENTIAL);
119
120             fail(
121                 "Created use with name [" + TEST_USERNAME + "], but "
122                 + "should have thrown DuplicatePrincipalException");
123         } catch (DuplicatePrincipalException dpe) {
124             // success
125 }
126     }
127
128     /**
129      * Tests the retreival of an existent user.
130      */
131     public void testRetreiveUser() throws SecurityManagementException {
132         UserManager userManager =
133             (UserManager) Lookup.getInstance().fetchComponent(
134                 STANDARD_RDBMS_USERMANAGER);
135
136         Principal user = userManager.retreiveUser(TEST_USERNAME);
137
138         if (user == null) {
139             fail(
140                 "After call to retreiveUser for user named ["
141                 + TEST_USERNAME + "], a null user object "
142                 + "was returned.");
143         }
144     }
145
146     /**
147      * Tests the retreival of an existent user.
148      */
149     public void testRetreiveUserNullUser() throws SecurityManagementException {
150         UserManager userManager =
151             (UserManager) Lookup.getInstance().fetchComponent(
152                 STANDARD_RDBMS_USERMANAGER);
153
154         Principal user = userManager.retreiveUser(TEST_NONEXIST_USERNAME);
155
156         if (user != null) {
157             fail(
158                 "After call to retreiveUser for non-existent user named ["
159                 + TEST_NONEXIST_USERNAME
160                 + "], a full object was returned.");
161         }
162     }
163
164     /**
165      * Tests the removal of a user.
166      */
167     public void testRemoveUser() throws SecurityManagementException {
168         UserManager userManager =
169             (UserManager) Lookup.getInstance().fetchComponent(
170                 STANDARD_RDBMS_USERMANAGER);
171
172         Principal user = userManager.retreiveUser(TEST_USERNAME);
173         Principal cycledUser =
174             userManager.retreiveUser(TEST_STANDALONE_USERNAME);
175
176         try {
177             userManager.removeUser(user);
178             userManager.removeUser(cycledUser);
179         } catch (UnknownPrincipalException upe) {
180             fail(
181                 "User named " + TEST_USERNAME + "cannot be found." + upe
182                 + ExceptionUtility.captureStackTrace(upe));
183         }
184     }
185
186     /**
187      * Tests that attempting to remove a non-existent user gives the
188      * correct error.
189      */
190     public void testRemoveUserUnknownPrincipal() throws SecurityManagementException {
191         UserManager userManager =
192             (UserManager) Lookup.getInstance().fetchComponent(
193                 STANDARD_RDBMS_USERMANAGER);
194
195         Principal user = new DefaultUserImpl(TEST_NONEXIST_USERNAME);
196
197         try {
198             userManager.removeUser(user);
199             fail(
200                 "Attempted to remove non-existent principal identified "
201                 + "by name [" + TEST_NONEXIST_USERNAME
202                 + "] succeeded, but shouldn't have.");
203         } catch (UnknownPrincipalException upe) {
204             // success
205 }
206     }
207
208     /**
209      * Tests the updating credentials.
210      */
211     public void testUpdateCredential() throws SecurityManagementException {
212         String NEW_PASSWORD = "newpassword";
213
214         UserManager userManager =
215             (UserManager) Lookup.getInstance().fetchComponent(
216                 STANDARD_RDBMS_USERMANAGER);
217
218         Principal user = userManager.retreiveUser(TEST_USERNAME);
219
220         if (user == null) {
221             fail("User named [" + TEST_USERNAME + "] cannot be found.");
222         }
223
224         userManager.updateCredential(user, NEW_PASSWORD);
225
226         if (!userManager.authenticate(TEST_USERNAME, NEW_PASSWORD)) {
227             fail(
228                 "After updating user's [" + TEST_USERNAME
229                 + " password to [" + NEW_PASSWORD
230                 + "] authentication against the new password failed.");
231         }
232     }
233
234     /**
235      * Tests that attempting to update the credential of an unknown user
236      * fails.
237      */
238     public void testUpdateCredentialUnknownPrincipal() throws SecurityManagementException {
239         UserManager userManager =
240             (UserManager) Lookup.getInstance().fetchComponent(
241                 STANDARD_RDBMS_USERMANAGER);
242
243         Principal user = new DefaultUserImpl(TEST_NONEXIST_USERNAME);
244
245         try {
246             userManager.updateCredential(user, "newpassword");
247             fail(
248                 "Attempted to remove non-existent principal identified "
249                 + "by name [" + TEST_NONEXIST_USERNAME
250                 + "] succeeded, but shouldn't have.");
251         } catch (UnknownPrincipalException upe) {
252             // success
253 }
254     }
255
256     /**
257      * Tests getting back the containing groups for a user
258      */
259     public void testRetreiveGroupsForUser() throws SecurityManagementException {
260         UserManager userManager =
261             (UserManager) Lookup.getInstance().fetchComponent(
262                 STANDARD_RDBMS_USERMANAGER);
263
264         Principal user = userManager.retreiveUser(TEST_USERNAME);
265         if (user == null) {
266             fail(
267                 "Precondition for test cast not met. There is no "
268                 + "user with name [" + TEST_USERNAME + "]");
269         }
270
271         Set containingGroups = userManager.retreiveGroups(user);
272
273         if(containingGroups.size() != 1) {
274             fail("Got back containing groups for principal identified by ["
275                 + TEST_USERNAME + "]. Expected 1 containg group, but "
276                 + "got back a different number. Set ["
277                 + containingGroups
278                 + "]");
279         }
280     }
281
282     /**
283      * Tests getting back the containing groups for a group
284      */
285     public void testRetreiveGroupsForGroup() throws SecurityManagementException {
286         UserManager userManager =
287             (UserManager) Lookup.getInstance().fetchComponent(
288                 STANDARD_RDBMS_USERMANAGER);
289
290         Group group = userManager.retreiveGroup(TEST_CHILD_GROUPNAME);
291         if (group == null) {
292             fail(
293                 "Precondition for test cast not met. There is no "
294                 + "group with name [" + TEST_CHILD_GROUPNAME + "]");
295         }
296
297         Set containingGroups = userManager.retreiveGroups(group);
298
299         if(containingGroups.size() != 1) {
300             fail("Got back containing groups for group identified by ["
301                 + TEST_USERNAME + "]. Expected 1 containg group, but "
302                 + "got back a different number. Set ["
303                 + containingGroups
304                 + "]");
305         }
306     }
307
308     /**
309      * Tests that attempting to update the credential of an unknown user
310      * fails.
311      */
312     public void testRetreiveGroupsUnknownPrincipal() throws SecurityManagementException {
313         UserManager userManager =
314             (UserManager) Lookup.getInstance().fetchComponent(
315                 STANDARD_RDBMS_USERMANAGER);
316
317         Principal user = new DefaultUserImpl(TEST_NONEXIST_USERNAME);
318
319         try {
320             userManager.retreiveGroups(user);
321             fail(
322                 "Attempted to retreive groups for non-existent principal "
323                 + "identified by name [" + TEST_NONEXIST_USERNAME
324                 + "] succeeded, but shouldn't have.");
325         } catch (UnknownPrincipalException upe) {
326             // success
327 }
328     }
329
330
331     /**
332      * Tests the creation of a group.
333      */
334     public void testCreateGroup() throws SecurityManagementException {
335         UserManager userManager =
336             (UserManager) Lookup.getInstance().fetchComponent(
337                 STANDARD_RDBMS_USERMANAGER);
338
339         userManager.createGroup(TEST_CHILD_GROUPNAME);
340         userManager.createGroup(TEST_PARENT_GROUPNAME);
341         userManager.createGroup(TEST_CYCLE_GROUPNAME);
342     }
343
344     /**
345      * Tests that attempting to create a second group with the same name
346      * fails.
347      */
348     public void testCreateGroupDuplicateGroup() throws SecurityManagementException {
349         UserManager userManager =
350             (UserManager) Lookup.getInstance().fetchComponent(
351                 STANDARD_RDBMS_USERMANAGER);
352
353         try {
354             userManager.createGroup(TEST_CHILD_GROUPNAME);
355             fail(
356                 "Attempted to create duplicate group with name ["
357                 + TEST_CHILD_GROUPNAME + " succeeded, but shouldn't have.");
358         } catch (DuplicatePrincipalException dpe) {
359             // success
360 }
361     }
362
363     /**
364      * Tests the retreival of a group.
365      */
366     public void testRetreiveGroup() throws SecurityManagementException {
367         UserManager userManager =
368             (UserManager) Lookup.getInstance().fetchComponent(
369                 STANDARD_RDBMS_USERMANAGER);
370
371         Group group = userManager.retreiveGroup(TEST_CHILD_GROUPNAME);
372
373         if (group == null) {
374             fail(
375                 "After call to retreiveGroup for group named ["
376                 + TEST_CHILD_GROUPNAME
377                 + "], a null group object was returned.");
378         }
379     }
380
381     /**
382      * Tests that retreiving a non-existent group returns null.
383      */
384     public void testRetreiveGroupNullGroup() throws SecurityManagementException {
385         UserManager userManager =
386             (UserManager) Lookup.getInstance().fetchComponent(
387                 STANDARD_RDBMS_USERMANAGER);
388
389         Group group = userManager.retreiveGroup(TEST_NONEXIST_GROUPNAME);
390
391         if (group != null) {
392             fail(
393                 "After call to retreiveGroup for non-existent group named ["
394                 + TEST_CHILD_GROUPNAME
395                 + "], a non-null group object was returned.");
396         }
397     }
398
399     /**
400      * Tests the removal of a group.
401      */
402     public void testRemoveGroup() throws SecurityManagementException {
403         UserManager userManager =
404             (UserManager) Lookup.getInstance().fetchComponent(
405                 STANDARD_RDBMS_USERMANAGER);
406
407         Group group = userManager.retreiveGroup(TEST_CHILD_GROUPNAME);
408         Group group2 = userManager.retreiveGroup(TEST_PARENT_GROUPNAME);
409         Group group3 = userManager.retreiveGroup(TEST_CYCLE_GROUPNAME);
410
411         try {
412             userManager.removeGroup(group);
413             userManager.removeGroup(group2);
414             userManager.removeGroup(group3);
415         } catch (UnknownPrincipalException upe) {
416             fail(
417                 "User named " + TEST_USERNAME + " cannot be found." + upe
418                 + ExceptionUtility.captureStackTrace(upe));
419         }
420     }
421
422     /**
423      * Tests the attempted removal of non-existent group fails.
424      */
425     public void testRemoveGroupUnknownGroup() throws SecurityManagementException {
426         UserManager userManager =
427             (UserManager) Lookup.getInstance().fetchComponent(
428                 STANDARD_RDBMS_USERMANAGER);
429
430         Group group =
431             new DefaultGroupImpl(
432                 TEST_NONEXIST_GROUPNAME, new HashSet (),
433                 STANDARD_RDBMS_USERMANAGER);
434
435         try {
436             userManager.removeGroup(group);
437             fail(
438                 "Successfully removed non-existent group named ["
439                 + TEST_NONEXIST_GROUPNAME + "]");
440         } catch (UnknownPrincipalException upe) {
441             // success
442 }
443     }
444
445     /**
446      * Tests adding a user to a group.
447      */
448     public void testAddUserToGroup() throws SecurityManagementException {
449         UserManager userManager =
450             (UserManager) Lookup.getInstance().fetchComponent(
451                 STANDARD_RDBMS_USERMANAGER);
452
453         Group group = userManager.retreiveGroup(TEST_CHILD_GROUPNAME);
454         Principal user = userManager.retreiveUser(TEST_USERNAME);
455
456         if (user == null) {
457             fail(
458                 "Precondition for test cast not met. There is no "
459                 + "user with name [" + TEST_USERNAME + "]");
460         }
461
462         if (group == null) {
463             fail(
464                 "Precondition for test cast not met. There is no "
465                 + "group with name [" + TEST_CHILD_GROUPNAME + "]");
466         }
467
468         if (group.isMember(user)) {
469             fail(
470                 "Precondition for test case not met. User ["
471                 + TEST_USERNAME + "] is already a child of group ["
472                 + TEST_CHILD_GROUPNAME + "]");
473         }
474
475         userManager.addPrincipalToGroup(user, group);
476
477         group = userManager.retreiveGroup(TEST_CHILD_GROUPNAME);
478         user = userManager.retreiveUser(TEST_USERNAME);
479
480         if (!group.isMember(user)) {
481             fail(
482                 "After adding user [" + TEST_USERNAME + "] to group ["
483                 + TEST_CHILD_GROUPNAME + " isMember test returns false.");
484         }
485     }
486
487     /**
488      * Tests adding a user which is not in the user-store to a group
489      * fails.
490      */
491     public void testAddUserToGroupUnknownPrincipal() throws SecurityManagementException {
492         UserManager userManager =
493             (UserManager) Lookup.getInstance().fetchComponent(
494                 STANDARD_RDBMS_USERMANAGER);
495
496         Group group = userManager.retreiveGroup(TEST_CHILD_GROUPNAME);
497         Principal user = new DefaultUserImpl(TEST_NONEXIST_USERNAME);
498
499         if (group == null) {
500             fail(
501                 "Precondition for test cast not met. There is no "
502                 + "group with name [" + TEST_CHILD_GROUPNAME + "]");
503         }
504
505         try {
506             userManager.addPrincipalToGroup(user, group);
507             fail(
508                 "Added unknown principal [" + TEST_NONEXIST_USERNAME
509                 + " to group successfully.");
510         } catch (UnknownPrincipalException sme) {
511             // success
512 }
513     }
514
515     /**
516      * Tests that adding a user to a non-existent group gives an error.
517      *
518      * @throws UnknownPrincipalException DOCUMENT ME!
519      */
520     public void testAddUserToGroupUnknownGroup()
521         throws SecurityManagementException {
522         UserManager userManager =
523             (UserManager) Lookup.getInstance().fetchComponent(
524                 STANDARD_RDBMS_USERMANAGER);
525
526         Group group =
527             new DefaultGroupImpl(
528                 TEST_NONEXIST_GROUPNAME, new HashSet (),
529                 STANDARD_RDBMS_USERMANAGER);
530         Principal user = userManager.retreiveUser(TEST_USERNAME);
531
532         if (user == null) {
533             fail(
534                 "Precondition for test cast not met. There is no "
535                 + "user with name [" + TEST_USERNAME + "]");
536         }
537
538         try {
539             userManager.addPrincipalToGroup(user, group);
540             fail(
541                 "Added user to unknown group [" + TEST_NONEXIST_USERNAME
542                 + " successfully.");
543         } catch (UnknownGroupException sme) {
544             // success
545 }
546     }
547
548     /**
549      * Tests removing a user from group
550      */
551     public void testRemovePrincipalFromGroup() throws SecurityManagementException {
552         UserManager userManager =
553             (UserManager) Lookup.getInstance().fetchComponent(
554                 STANDARD_RDBMS_USERMANAGER);
555
556         Group group = userManager.retreiveGroup(TEST_CHILD_GROUPNAME);
557         Principal user = userManager.retreiveUser(TEST_USERNAME);
558
559         userManager.removePrincipalFromGroup(user, group);
560
561         group = userManager.retreiveGroup(TEST_CHILD_GROUPNAME);
562         user = userManager.retreiveUser(TEST_USERNAME);
563
564         if (group.isMember(user)) {
565             fail(
566                 "After removing user [" + TEST_USERNAME + "] from group ["
567                 + TEST_CHILD_GROUPNAME + " isMember test returns true.");
568         }
569     }
570
571     /**
572      * Tests removing a user from a group with a non-exist user gives an
573      * error.
574      */
575     public void testRemovePrincipalFromGroupUnknownPrincipal() throws SecurityManagementException {
576         UserManager userManager =
577             (UserManager) Lookup.getInstance().fetchComponent(
578                 STANDARD_RDBMS_USERMANAGER);
579
580         Group group = userManager.retreiveGroup(TEST_CHILD_GROUPNAME);
581         Principal user = new DefaultUserImpl(TEST_NONEXIST_USERNAME);
582
583         try {
584             userManager.removePrincipalFromGroup(user, group);
585             fail(
586                 "Was able remove non-existent principal ["
587                 + TEST_NONEXIST_USERNAME + "] from group");
588         } catch (UnknownPrincipalException sme) {
589             // success
590 }
591     }
592
593     /**
594      * Tests removing a user from a group with a non-exist group gives an
595      * error.
596      *
597      * @throws UnknownPrincipalException DOCUMENT ME!
598      */
599     public void testRemovePrincipalFromGroupUnknownGroup()
600         throws SecurityManagementException {
601         UserManager userManager =
602             (UserManager) Lookup.getInstance().fetchComponent(
603                 STANDARD_RDBMS_USERMANAGER);
604
605         Group group =
606             new DefaultGroupImpl(
607                 TEST_NONEXIST_GROUPNAME, new HashSet (),
608                 STANDARD_RDBMS_USERMANAGER);
609         Principal user = userManager.retreiveUser(TEST_USERNAME);
610
611         try {
612             userManager.removePrincipalFromGroup(user, group);
613             fail(
614                 "Was able remove principal from non-existent group ["
615                 + TEST_NONEXIST_GROUPNAME + "]");
616         } catch (UnknownGroupException sme) {
617             // success
618 }
619     }
620
621     /**
622      * Tests that a cycled group does not cause infinite recursion.
623      *
624      * @throws UnknownPrincipalException DOCUMENT ME!
625      */
626     public void testCycledGroup() throws SecurityManagementException {
627         UserManager userManager =
628             (UserManager) Lookup.getInstance().fetchComponent(
629                 STANDARD_RDBMS_USERMANAGER);
630
631         Group childGroup = userManager.retreiveGroup(TEST_CHILD_GROUPNAME);
632         Group parentGroup =
633             userManager.retreiveGroup(TEST_PARENT_GROUPNAME);
634         Group cycledGroup =
635             userManager.retreiveGroup(TEST_CYCLE_GROUPNAME);
636         Principal cycledUser =
637             userManager.retreiveUser(TEST_STANDALONE_USERNAME);
638
639         userManager.addPrincipalToGroup(cycledGroup, childGroup);
640         userManager.addPrincipalToGroup(parentGroup, cycledGroup);
641
642         if (parentGroup.isMember(cycledUser)) {
643             fail(
644                 "Found user [" + TEST_STANDALONE_USERNAME + "] in group ["
645                 + TEST_PARENT_GROUPNAME + "], but he is not a member!");
646         }
647
648         // The cycle can go forever if poorly executed. Should throw
649 // a stackoverflow currently, but if the implementation becomes
650 // iterative, it may hang.
651 }
652
653     /**
654      * Tests adding a group to a group.
655      */
656     public void testAddGroupToGroup() throws SecurityManagementException {
657         UserManager userManager =
658             (UserManager) Lookup.getInstance().fetchComponent(
659                 STANDARD_RDBMS_USERMANAGER);
660
661         Principal user = userManager.retreiveUser(TEST_USERNAME);
662         Group childGroup = userManager.retreiveGroup(TEST_CHILD_GROUPNAME);
663         Group parentGroup =
664             userManager.retreiveGroup(TEST_PARENT_GROUPNAME);
665
666         if (user == null) {
667             fail(
668                 "Precondition for test case not met. There is no "
669                 + "user with name [" + TEST_USERNAME + "]");
670         }
671
672         if (childGroup == null) {
673             fail(
674                 "Precondition for test case not met. There is no "
675                 + "group with name [" + TEST_CHILD_GROUPNAME + "]");
676         }
677
678         if (parentGroup == null) {
679             fail(
680                 "Precondition for test case not met. There is no "
681                 + "group with name [" + TEST_PARENT_GROUPNAME + "]");
682         }
683
684         if (parentGroup.isMember(childGroup)) {
685             fail(
686                 "Precondition for test case not met. Group ["
687                 + TEST_CHILD_GROUPNAME + "] is already a child of group ["
688                 + TEST_PARENT_GROUPNAME + "]");
689         }
690
691         boolean result =
692             userManager.addPrincipalToGroup(childGroup, parentGroup);
693
694         user = userManager.retreiveUser(TEST_USERNAME);
695         childGroup = userManager.retreiveGroup(TEST_CHILD_GROUPNAME);
696         parentGroup = userManager.retreiveGroup(TEST_PARENT_GROUPNAME);
697
698         if (!parentGroup.isMember(childGroup)) {
699             fail(
700                 "After adding group [" + TEST_CHILD_GROUPNAME
701                 + "] to group [" + TEST_PARENT_GROUPNAME
702                 + " isMember test returns false.");
703         }
704
705         if (!parentGroup.isMember(user)) {
706             fail(
707                 "After adding group [" + TEST_CHILD_GROUPNAME
708                 + "] to group [" + TEST_PARENT_GROUPNAME
709                 + "] isMember test returns false for child member of group ["
710                 + TEST_USERNAME + "]");
711         }
712     }
713
714     /**
715      * Tests authenticating a user
716      *
717      * @throws UnknownPrincipalException DOCUMENT ME!
718      */
719     public void testAuthenticate() throws SecurityManagementException {
720         UserManager userManager =
721             (UserManager) Lookup.getInstance().fetchComponent(
722                 STANDARD_RDBMS_USERMANAGER);
723
724         boolean authenticated =
725             userManager.authenticate(TEST_USERNAME, TEST_USERNAME);
726
727         if (!authenticated) {
728             fail(
729                 "Failed to authenticate user [" + TEST_USERNAME
730                 + "] with password [" + TEST_USERNAME + "]");
731         }
732     }
733
734     /**
735      * Tests authenticating when there is an incorrect password
736      *
737      * @throws UnknownPrincipalException DOCUMENT ME!
738      */
739     public void testAuthenticateFailure() throws SecurityManagementException {
740         String BAD_PASSWORD = "imladris";
741
742         UserManager userManager =
743             (UserManager) Lookup.getInstance().fetchComponent(
744                 STANDARD_RDBMS_USERMANAGER);
745
746         boolean authenticated =
747             userManager.authenticate(TEST_USERNAME, BAD_PASSWORD);
748
749         if (authenticated) {
750             fail(
751                 "Successfully authenticated user [" + TEST_USERNAME
752                 + "] with bad password [" + BAD_PASSWORD + "]");
753         }
754     }
755
756     /**
757      * Tests retreiving all user names.
758      *
759      * @throws UnknownPrincipalException DOCUMENT ME!
760      */
761     public void testRetreiveAllUserNames()
762         throws SecurityManagementException {
763         UserManager userManager =
764             (UserManager) Lookup.getInstance().fetchComponent(
765                 STANDARD_RDBMS_USERMANAGER);
766
767         Set allUserNames = userManager.retreiveAllUserNames();
768
769         if ((allUserNames == null) || allUserNames.isEmpty()) {
770             fail(
771                 "Call to retreiveAllUserNames returned "
772                 + " and empty set: " + allUserNames);
773         }
774     }
775
776     /**
777      * Tests retreiving all group names.
778      *
779      * @throws UnknownPrincipalException DOCUMENT ME!
780      */
781     public void testRetreiveAllGroupNames()
782         throws SecurityManagementException {
783         UserManager userManager =
784             (UserManager) Lookup.getInstance().fetchComponent(
785                 STANDARD_RDBMS_USERMANAGER);
786
787         Set allGroupNames = userManager.retreiveAllGroupNames();
788
789         if ((allGroupNames == null) || allGroupNames.isEmpty()) {
790             fail(
791                 "Call to retreiveAllGroupNames returned "
792                 + " and empty set: " + allGroupNames);
793         }
794     }
795
796     /**
797      * Method called by jUnit to get all the tests in this test case.
798      *
799      * @return Test the suite of tests in this test case
800      */
801     public static Test suite() {
802         TestSuite masterSuite = new TestSuite();
803
804         // add single threaded tests
805 Test singleThreadedTests = getSingleThreadedTests();
806
807         if (singleThreadedTests != null) {
808             masterSuite.addTest(singleThreadedTests);
809         }
810
811         // add multi threaded tests
812 Test multiThreadedTests = getMultiThreadedTests();
813
814         if (multiThreadedTests != null) {
815             masterSuite.addTest(multiThreadedTests);
816         }
817
818         return masterSuite;
819     }
820
821     /**
822      * Single threaded tests:
823      *
824      * @return Test the suite of single threaded tests in this test case
825      */
826     private static Test getSingleThreadedTests() {
827         TestSuite suite = new TestSuite();
828
829         // Add all the test data
830 suite.addTest(new RdbmsUserManagerServiceTest("testCreateUser"));
831         suite.addTest(new RdbmsUserManagerServiceTest("testCreateGroup"));
832
833
834         // Run the major tests
835 suite.addTest(new RdbmsUserManagerServiceTest("testRetreiveUser"));
836         suite.addTest(
837             new RdbmsUserManagerServiceTest("testRetreiveGroup"));
838
839         suite.addTest(
840             new RdbmsUserManagerServiceTest("testAddUserToGroup"));
841         suite.addTest(
842             new RdbmsUserManagerServiceTest("testAddGroupToGroup"));
843         suite.addTest(new RdbmsUserManagerServiceTest("testCycledGroup"));
844
845         suite.addTest(new RdbmsUserManagerServiceTest("testAuthenticate"));
846         suite.addTest(
847             new RdbmsUserManagerServiceTest("testAuthenticateFailure"));
848         suite.addTest(
849             new RdbmsUserManagerServiceTest("testUpdateCredential"));
850
851         suite.addTest(new RdbmsUserManagerServiceTest("testRetreiveGroupsForUser"));
852         suite.addTest(new RdbmsUserManagerServiceTest("testRetreiveGroupsForGroup"));
853
854         suite.addTest(
855             new RdbmsUserManagerServiceTest("testRetreiveAllUserNames"));
856         suite.addTest(
857             new RdbmsUserManagerServiceTest("testRetreiveAllGroupNames"));
858
859         // Test exceptions
860 suite.addTest(
861             new RdbmsUserManagerServiceTest(
862                 "testCreateUserDuplicatePrincipal"));
863         suite.addTest(
864             new RdbmsUserManagerServiceTest(
865                 "testRemoveUserUnknownPrincipal"));
866         suite.addTest(
867             new RdbmsUserManagerServiceTest(
868                 "testUpdateCredentialUnknownPrincipal"));
869         suite.addTest(
870             new RdbmsUserManagerServiceTest(
871                 "testCreateGroupDuplicateGroup"));
872         suite.addTest(
873             new RdbmsUserManagerServiceTest("testRemoveGroupUnknownGroup"));
874         suite.addTest(
875             new RdbmsUserManagerServiceTest("testRetreiveUserNullUser"));
876         suite.addTest(
877             new RdbmsUserManagerServiceTest("testRetreiveGroupNullGroup"));
878         suite.addTest(
879             new RdbmsUserManagerServiceTest(
880                 "testAddUserToGroupUnknownPrincipal"));
881         suite.addTest(
882             new RdbmsUserManagerServiceTest(
883                 "testAddUserToGroupUnknownGroup"));
884
885         suite.addTest(new RdbmsUserManagerServiceTest("testRetreiveGroupsUnknownPrincipal"));
886
887         suite.addTest(
888             new RdbmsUserManagerServiceTest(
889                 "testRemovePrincipalFromGroupUnknownPrincipal"));
890         suite.addTest(
891             new RdbmsUserManagerServiceTest(
892                 "testRemovePrincipalFromGroupUnknownGroup"));
893         suite.addTest(
894             new RdbmsUserManagerServiceTest(
895                 "testRemovePrincipalFromGroup"));
896
897         // Remove all the test data
898 suite.addTest(new RdbmsUserManagerServiceTest("testRemoveGroup"));
899         suite.addTest(new RdbmsUserManagerServiceTest("testRemoveUser"));
900
901         return suite;
902     }
903
904     /**
905      * Multi-Threaded tests
906      *
907      * @return Test the suite of multi-threaded tests in this test case
908      */
909     private static Test getMultiThreadedTests() {
910         TestSuite suite = new ActiveTestSuite();
911
912         return suite;
913     }
914
915     /**
916      * This method will add the give test to the give suite the specified
917      * number of times. This is best used for multi-threaded tests where
918      * suite is an instance of ActiveTestSuite and you want to run the
919      * same test in multiple threads.
920      *
921      * @param suite the suite to add the test to.
922      * @param testName the name of the test to add.
923      * @param number the number of times to add the test to the suite
924      */
925     private static void addTest(
926         TestSuite suite, String testName, int number) {
927         for (int count = 0; count < number; count++) {
928             suite.addTest(new RdbmsUserManagerServiceTest(testName));
929         }
930     }
931 }
932

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags