source.dussan.org Git - archiva.git/blob

   1 package org.apache.archiva.redback.struts2.action.admin;
   2
   3 /*
   4  * Licensed to the Apache Software Foundation (ASF) under one
   5  * or more contributor license agreements.  See the NOTICE file
   6  * distributed with this work for additional information
   7  * regarding copyright ownership.  The ASF licenses this file
   8  * to you under the Apache License, Version 2.0 (the
   9  * "License"); you may not use this file except in compliance
  10  * with the License.  You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing,
  15  * software distributed under the License is distributed on an
  16  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  17  * KIND, either express or implied.  See the License for the
  18  * specific language governing permissions and limitations
  19  * under the License.
  20  */
  21
  22 import com.google.common.collect.Lists;
  23 import com.opensymphony.xwork2.Action;
  24 import com.opensymphony.xwork2.ActionProxy;
  25 import org.apache.archiva.redback.authentication.AuthenticationException;
  26 import org.apache.archiva.redback.rbac.RbacObjectInvalidException;
  27 import org.apache.archiva.redback.rbac.Role;
  28 import org.apache.archiva.redback.users.UserNotFoundException;
  29 import org.apache.archiva.redback.authorization.AuthorizationResult;
  30 import org.apache.archiva.redback.policy.AccountLockedException;
  31 import org.apache.archiva.redback.rbac.RbacManagerException;
  32 import org.apache.archiva.redback.struts2.model.ApplicationRoleDetails;
  33 import org.apache.archiva.redback.struts2.model.ApplicationRoleDetails.RoleTableCell;
  34 import org.apache.archiva.redback.integration.interceptor.SecureActionBundle;
  35 import org.apache.archiva.redback.integration.interceptor.SecureActionException;
  36 import org.junit.Before;
  37 import org.junit.Ignore;
  38 import org.junit.Test;
  39
  40 import java.util.ArrayList;
  41 import java.util.Arrays;
  42 import java.util.List;
  43
  44 /**
  45  * @todo missing tests for success/fail on standard show/edit functions (non security testing related)
  46  */
  47 public class AssignmentsActionTest
  48     extends AbstractUserCredentialsActionTest
  49 {
  50  //@Rule public TestName name = new TestName();
  51  // xxx help for jdk 7 investigation
  52     private AssignmentsAction action;
  53
  54   /*  public static final List<String> favorites =
  55         Arrays.asList("user", "user2","user3","user-admin");
  56    xxx help for jdk 7 investigation
  57   private void displayInfo(boolean before) throws RbacObjectNotFoundException, RbacManagerException {
  58     System.err.print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
  59     if (before) {
  60       System.err.print("(b)");
  61     } else {
  62       System.err.print("(a)");
  63     }
  64     System.err.println(name.getMethodName());
  65     for (String user : favorites) {
  66       if (rbacManager.userAssignmentExists(user)) {
  67         for (String s : rbacManager.getUserAssignment(user).getRoleNames()) {
  68           System.err.println("--" + user + ">>" + s);
  69         }
  70       }
  71     }
  72     System.err.println("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<");
  73   }*/
  74
  75     @Before
  76     public void setUp()
  77         throws Exception
  78     {
  79         super.setUp();
  80
  81         ActionProxy actionProxy = getActionProxy( "/security/assignments" );
  82         action = (AssignmentsAction) actionProxy.getAction();
  83
  84         login( action, "user", PASSWORD );
  85         action.setPrincipal( "user2" );
  86         //displayInfo(true);//xxx help for jdk 7 investigation
  87
  88     }
  89
  90   /*@After xxx help for jdk 7 investigation
  91   @Override
  92   public void after() {
  93     super.after();
  94     try {
  95        displayInfo(false);
  96     } catch (RbacObjectNotFoundException ex) {
  97       Logger.getLogger(AssignmentsActionTest.class.getName()).log(Level.SEVERE, null, ex);
  98     } catch (RbacObjectInvalidException ex) {
  99       Logger.getLogger(AssignmentsActionTest.class.getName()).log(Level.SEVERE, null, ex);
 100     } catch (RbacManagerException ex) {
 101       Logger.getLogger(AssignmentsActionTest.class.getName()).log(Level.SEVERE, null, ex);
 102     }
 103   }*/
 104     /**
 105      * Check security - show/edituser should fail if the permission 'user-management-user-role' is not present, but a
 106      * valid 'user-management-role-grant' is.
 107      */
 108     @Test
 109     public void testUserWithOnlyRoleGrantHasNoAccess()
 110         throws Exception
 111     {
 112
 113         addAssignment( "user", "Grant Administrator - default" );
 114
 115         List<SecureActionBundle.AuthorizationTuple> authorizationTuples = getTuples();
 116         for ( SecureActionBundle.AuthorizationTuple tuple : authorizationTuples )
 117         {
 118             AuthorizationResult authzResult = system.authorize( session, tuple.getOperation(), tuple.getResource() );
 119
 120             assertFalse( authzResult.isAuthorized() );
 121         }
 122
 123         rbacManager.getUserAssignment( "user" ).removeRoleName( "Grant Administrator - default" );
 124     }
 125
 126     /**
 127      * Check security - check success if the permission 'user-management-user-role' is present along with global
 128      * 'user-management-role-grant'.
 129      */
 130     @Test
 131     public void testUserWithOnlyRoleGrantHasAccess()
 132         throws Exception
 133     {
 134         addAssignment( "user", "Project Administrator - default" );
 135
 136         List<SecureActionBundle.AuthorizationTuple> authorizationTuples = getTuples();
 137         boolean result = false;
 138         for ( SecureActionBundle.AuthorizationTuple tuple : authorizationTuples )
 139         {
 140             AuthorizationResult authzResult = system.authorize( session, tuple.getOperation(), tuple.getResource() );
 141
 142             result |= authzResult.isAuthorized();
 143         }
 144         assertTrue( result );
 145         rbacManager.getUserAssignment( "user" ).removeRoleName( "Project Administrator - default" );
 146     }
 147
 148     private List<SecureActionBundle.AuthorizationTuple> getTuples()
 149         throws SecureActionException
 150     {
 151         return action.getSecureActionBundle().getAuthorizationTuples();
 152     }
 153
 154     /**
 155      * Check roles can be assigned if the user has no previous assignments.
 156      */
 157     @Test
 158     public void testShowWhenUserHasNoAssignments()
 159         throws Exception
 160     {
 161         addAssignment( "user", "Project Administrator - default" );
 162
 163         action.setPrincipal( "user3" );
 164
 165         assertEquals( Action.SUCCESS, action.show() );
 166
 167         assertEquals( 2, action.getApplicationRoleDetails().size() );
 168         rbacManager.getUserAssignment( "user" ).removeRoleName( "Project Administrator - default" );
 169     }
 170
 171     /**
 172      * Check security - show should filter out roles that the 'user-management-role-grant' is not present for
 173      */
 174     @Test
 175     public void testRoleGrantFilteringOnShow()
 176         throws Exception
 177     {
 178         addAssignment( "user", "Project Administrator - default" );
 179
 180         assertEquals( Action.SUCCESS, action.show() );
 181
 182         assertEquals( 2, action.getApplicationRoleDetails().size() );
 183         ApplicationRoleDetails details = (ApplicationRoleDetails) action.getApplicationRoleDetails().get( 0 );
 184         assertEquals( "System", details.getName() );
 185         assertEquals( "Roles that apply system-wide, across all of the applications", details.getDescription() );
 186         assertEquals( "found roles " + details.getAvailableRoles(), 0, details.getAvailableRoles().size() );
 187         details = (ApplicationRoleDetails) action.getApplicationRoleDetails().get( 1 );
 188         assertEquals( "Continuum", details.getName() );
 189         assertEquals( "found roles " + details.getAvailableRoles(), 0, details.getAvailableRoles().size() );
 190
 191         // This table rendering code clearly has to go
 192         List<List<RoleTableCell>> table = details.getTable();
 193         assertEquals( 1, table.size() );
 194         assertRow( table, 0, "default", "Project Administrator - default", false );
 195         rbacManager.getUserAssignment( "user" ).removeRoleName( "Project Administrator - default" );
 196     }
 197
 198     @SuppressWarnings( "unchecked" )
 199     private void assertRow( List table, int index, String name, String label, boolean assigned )
 200     {
 201         List<RoleTableCell> row = (List<RoleTableCell>) table.get( index );
 202         assertEquals( name, row.get( 0 ).getName() );
 203         assertEquals( label, row.get( 1 ).getName() );
 204         assertEquals( assigned, row.get( 2 ).isAssigned() );
 205     }
 206
 207     /**
 208      * Check security - show should not filter out roles if 'user-management-role-grant' is present for the global
 209      * resource
 210      */
 211     // TODO: currently returns all roles - we really want all templated roles
 212     // public void testRoleGrantFilteringOnShowGlobalGrant()
 213     // throws RbacObjectInvalidException, RbacManagerException
 214     // {
 215     // addAssignment( "user", "Global Grant Administrator" );
 216     //
 217     // assertEquals( Action.SUCCESS, action.show() );
 218     //
 219     // assertEquals( 2, action.getApplicationRoleDetails().size() );
 220     // ApplicationRoleDetails details = (ApplicationRoleDetails) action.getApplicationRoleDetails().get( 0 );
 221     // assertEquals( "redback-xwork-integration-core", details.getName() );
 222     // assertEquals( 0, details.getAvailableRoles().size() );
 223     //
 224     // details = (ApplicationRoleDetails) action.getApplicationRoleDetails().get( 1 );
 225     // assertEquals( "Continuum", details.getName() );
 226     // assertEquals( 0, details.getAvailableRoles().size() );
 227     //
 228     // List table = details.getTable();
 229     // assertEquals( 2, table.size() );
 230     // assertRow( table, 0, "default", "Project Administrator - default", false );
 231     // assertRow( table, 1, "other", "Project Administrator - other", false );
 232     // }
 233
 234     /**
 235      * Check security - edituser should skip adding a role that 'user-management-role-grant' is not present for a
 236      * non-templated role
 237      */
 238     @Test
 239     public void testRoleGrantFilteringOnAddRolesNotPermittedTemplated()
 240         throws RbacObjectInvalidException, RbacManagerException
 241     {
 242         addAssignment( "user", "Project Administrator - default" );
 243
 244         // set addDSelectedRoles (dynamic --> Resource Roles) and addNDSelectedRoles (non-dynamic --> Available Roles)
 245         List<String> dSelectedRoles = new ArrayList<String>();
 246         dSelectedRoles.add( "Project Administrator - other" );
 247
 248         action.setAddDSelectedRoles( dSelectedRoles );
 249
 250         assertTrue( rbacManager.getUserAssignment( "user2" ).getRoleNames().isEmpty() );
 251
 252         assertEquals( Action.SUCCESS, action.edituser() );
 253
 254         assertTrue( rbacManager.getUserAssignment( "user2" ).getRoleNames().isEmpty() );
 255         rbacManager.getUserAssignment( "user" ).removeRoleName( "Project Administrator - default" );
 256     }
 257
 258     /**
 259      * Check security - edituser should skip adding a role that 'user-management-role-grant' is not present for a
 260      * templated role
 261      */
 262     @Test
 263     public void testRoleGrantFilteringOnAddRolesNotPermittedNotTemplated()
 264         throws RbacObjectInvalidException, RbacManagerException
 265     {
 266         addAssignment( "user", "Project Administrator - default" );
 267
 268         // set addDSelectedRoles (dynamic --> Resource Roles) and addNDSelectedRoles (non-dynamic --> Available Roles)
 269         List<String> ndSelectedRoles = new ArrayList<String>();
 270         ndSelectedRoles.add( "Continuum Group Project Administrator" );
 271
 272         action.setAddNDSelectedRoles( ndSelectedRoles );
 273
 274         assertTrue( rbacManager.getUserAssignment( "user2" ).getRoleNames().isEmpty() );
 275
 276         assertEquals( Action.SUCCESS, action.edituser() );
 277
 278         assertTrue( rbacManager.getUserAssignment( "user2" ).getRoleNames().isEmpty() );
 279         rbacManager.getUserAssignment( "user" ).removeRoleName( "Project Administrator - default" );
 280     }
 281
 282     /**
 283      * Check security - edituser should succeed if adding a role that 'user-management-role-grant' is present for
 284      * untemplated roles
 285      */
 286     @Test
 287     public void testRoleGrantFilteringOnAddRolesPermittedNotTemplated()
 288         throws RbacObjectInvalidException, RbacManagerException, AccountLockedException, AuthenticationException,
 289         UserNotFoundException
 290     {
 291         addAssignment( "user", "Global Grant Administrator" );
 292
 293         // set addDSelectedRoles (dynamic --> Resource Roles) and addNDSelectedRoles (non-dynamic --> Available Roles)
 294         List<String> ndSelectedRoles = new ArrayList<String>();
 295         ndSelectedRoles.add( "Continuum Group Project Administrator" );
 296
 297         action.setAddNDSelectedRoles( ndSelectedRoles );
 298
 299         assertTrue( rbacManager.getUserAssignment( "user2" ).getRoleNames().isEmpty() );
 300
 301         assertEquals( Action.SUCCESS, action.edituser() );
 302
 303         assertEquals( Lists.<String>newArrayList( "Continuum Group Project Administrator" ),
 304                       rbacManager.getUserAssignment( "user2" ).getRoleNames() );
 305
 306         rbacManager.getUserAssignment( "user2" ).removeRoleName( "Continuum Group Project Administrator" );
 307         rbacManager.getUserAssignment( "user" ).removeRoleName( "Global Grant Administrator" );
 308     }
 309
 310     /**
 311      * Check security - edituser should succeed if adding a role that 'user-management-role-grant' is present for
 312      * templated roles
 313      */
 314     @Ignore
 315     public void testRoleGrantFilteringOnAddRolesPermittedTemplated()
 316         throws Exception
 317     {
 318
 319         rbacManager.removeUserAssignment( "user" );
 320
 321         addAssignment( "user", "Project Administrator - default" );
 322
 323         // set addDSelectedRoles (dynamic --> Resource Roles) and addNDSelectedRoles (non-dynamic --> Available Roles)
 324         List<String> dSelectedRoles = new ArrayList<String>();
 325         dSelectedRoles.add( "Project Administrator - default" );
 326
 327         ActionProxy actionProxy = getActionProxy( "/security/assignments" );
 328         AssignmentsAction newAction = (AssignmentsAction) actionProxy.getAction();
 329
 330         login( newAction, "user", PASSWORD );
 331
 332         newAction.setPrincipal( "user2" );
 333
 334         newAction.setAddDSelectedRoles( dSelectedRoles );
 335
 336         assertTrue( rbacManager.getUserAssignment( "user2" ).getRoleNames().isEmpty() );
 337
 338         assertEquals( Action.SUCCESS, newAction.edituser() );
 339
 340         assertEquals( Arrays.asList( "Project Administrator - default" ),
 341                       rbacManager.getUserAssignment( "user2" ).getRoleNames() );
 342     }
 343
 344     /**
 345      * Check security - edituser should succeed if adding a role that 'user-management-role-grant' is present for
 346      * templated roles
 347      */
 348     @Test
 349     public void testRoleGrantFilteringOnAddRolesPermittedTemplatedExistingRole()
 350         throws Exception
 351     {
 352         addAssignment( "user", "Project Administrator - default" );
 353
 354         // cleanup before next test
 355         rbacManager.removeUserAssignment( "user2" );
 356
 357         addAssignment( "user2", "Project Administrator - other" );
 358
 359         // set addDSelectedRoles (dynamic --> Resource Roles) and addNDSelectedRoles (non-dynamic --> Available Roles)
 360         List<String> dSelectedRoles = new ArrayList<String>();
 361         dSelectedRoles.add( "Project Administrator - default" );
 362
 363         ActionProxy actionProxy = getActionProxy( "/security/assignments" );
 364         AssignmentsAction newAction = (AssignmentsAction) actionProxy.getAction();
 365
 366         login( newAction, "user2", PASSWORD );
 367
 368         newAction.setPrincipal( "user2" );
 369
 370         newAction.setAddDSelectedRoles( dSelectedRoles );
 371
 372         assertEquals( Arrays.asList( "Project Administrator - other" ),
 373                       rbacManager.getUserAssignment( "user2" ).getRoleNames() );
 374
 375         assertEquals( Action.SUCCESS, newAction.edituser() );
 376
 377         //assertEquals( Arrays.asList( "Project Administrator - default", "Project Administrator - other" ),
 378         //              rbacManager.getUserAssignment( "user2" ).getRoleNames() );
 379         rbacManager.getUserAssignment( "user" ).removeRoleName( "Project Administrator - default" );
 380
 381     }
 382
 383     /**
 384      * Check security - edituser should fail if removing a role that 'user-management-role-grant' is not present for
 385      * untemplated roles
 386      */
 387     @Test
 388     public void testRoleGrantFilteringOnRemoveRolesNotPermittedNotTemplated()
 389         throws Exception
 390     {
 391
 392         rbacManager.removeUserAssignment( "user2" );
 393
 394         addAssignment( "user", "Project Administrator - default" );
 395
 396         addAssignment( "user2", "Continuum Group Project Administrator" );
 397
 398         ActionProxy actionProxy = getActionProxy( "/security/assignments" );
 399         AssignmentsAction newAction = (AssignmentsAction) actionProxy.getAction();
 400
 401         login( newAction, "user2", PASSWORD );
 402
 403         newAction.setPrincipal( "user2" );
 404
 405         // set addDSelectedRoles (dynamic --> Resource Roles) and addNDSelectedRoles (non-dynamic --> Available Roles)
 406         List<String> ndSelectedRoles = new ArrayList<String>();
 407         newAction.setAddNDSelectedRoles( ndSelectedRoles );
 408
 409         assertEquals( Arrays.asList( "Continuum Group Project Administrator" ),
 410                       rbacManager.getUserAssignment( "user2" ).getRoleNames() );
 411
 412         assertEquals( Action.SUCCESS, newAction.edituser() );
 413
 414         assertEquals( Arrays.asList( "Continuum Group Project Administrator" ),
 415                       rbacManager.getUserAssignment( "user2" ).getRoleNames() );
 416
 417         rbacManager.getUserAssignment( "user2" ).removeRoleName( "Continuum Group Project Administrator" );
 418         rbacManager.getUserAssignment( "user" ).removeRoleName( "Project Administrator - default" );
 419     }
 420
 421     /**
 422      * Check security - edituser should fail if removing a role that 'user-management-role-grant' is not present for
 423      * templated roles
 424      */
 425     @Ignore
 426     public void testRoleGrantFilteringOnRemoveRolesNotPermittedTemplated()
 427         throws Exception
 428     {
 429         rbacManager.removeUserAssignment( "user2" );
 430
 431         addAssignment( "user", "Project Administrator - other" );
 432
 433         addAssignment( "user2", "Project Administrator - default" );
 434
 435         // set addDSelectedRoles (dynamic --> Resource Roles) and addNDSelectedRoles (non-dynamic --> Available Roles)
 436         List<String> dSelectedRoles = new ArrayList<String>();
 437
 438         ActionProxy actionProxy = getActionProxy( "/security/assignments" );
 439         AssignmentsAction newAction = (AssignmentsAction) actionProxy.getAction();
 440
 441         login( newAction, "user2", PASSWORD );
 442
 443         newAction.setPrincipal( "user2" );
 444
 445         newAction.setAddDSelectedRoles( dSelectedRoles );
 446
 447         assertEquals( Arrays.asList( "Project Administrator - default" ),
 448                       rbacManager.getUserAssignment( "user2" ).getRoleNames() );
 449
 450         assertEquals( Action.SUCCESS, newAction.edituser() );
 451
 452         assertEquals( Arrays.asList( "Project Administrator - default" ),
 453                       rbacManager.getUserAssignment( "user2" ).getRoleNames() );
 454     }
 455
 456     /**
 457      * Check security - edituser should succeed if removing a role that 'user-management-role-grant' is present for
 458      * untemplated roles
 459      */
 460     @Test
 461     public void testRoleGrantFilteringOnRemoveRolesPermittedNotTemplated()
 462         throws Exception
 463     {
 464         addAssignment( "user", "Global Grant Administrator" );
 465
 466         addAssignment( "user2", "Continuum Group Project Administrator" );
 467
 468         // set addDSelectedRoles (dynamic --> Resource Roles) and addNDSelectedRoles (non-dynamic --> Available Roles)
 469         List<String> ndSelectedRoles = new ArrayList<String>();
 470         action.setAddNDSelectedRoles( ndSelectedRoles );
 471
 472         assertEquals( Arrays.asList( "Continuum Group Project Administrator" ),
 473                       rbacManager.getUserAssignment( "user2" ).getRoleNames() );
 474
 475         assertEquals( Action.SUCCESS, action.edituser() );
 476
 477         assertTrue( rbacManager.getUserAssignment( "user2" ).getRoleNames().isEmpty() );
 478
 479         rbacManager.getUserAssignment( "user" ).removeRoleName( "Global Grant Administrator" );
 480     }
 481
 482     /**
 483      * Check security - edituser should succeed if removing a role that 'user-management-role-grant' is present for
 484      * templated roles and there is an existing role that is not assignable by the current user.
 485      */
 486     @Test
 487     public void testRoleGrantFilteringOnRemoveRolesPermittedTemplatedExistingRole()
 488         throws Exception
 489     {
 490         addAssignment( "user", "Project Administrator - default" );
 491
 492         rbacManager.removeUserAssignment( "user2" );
 493
 494         addAssignment( "user2", "Project Administrator - default" );
 495         addAssignment( "user2", "Project Administrator - other" );
 496         addAssignment( "user2", "Registered User" );
 497
 498         // set addDSelectedRoles (dynamic --> Resource Roles) and addNDSelectedRoles (non-dynamic --> Available Roles)
 499         List<String> dSelectedRoles = new ArrayList<String>();
 500         dSelectedRoles.add( "Project Administrator - other" );
 501         dSelectedRoles.add( "Registered User" );
 502         action.setAddDSelectedRoles( dSelectedRoles );
 503
 504         assertEquals(
 505             Arrays.asList( "Project Administrator - default", "Project Administrator - other", "Registered User" ),
 506             rbacManager.getUserAssignment( "user2" ).getRoleNames() );
 507
 508         assertEquals( Action.SUCCESS, action.edituser() );
 509
 510         // Roles may be out of order, due to removal and subsequent re-add
 511         List<String> user2roles = rbacManager.getUserAssignment( "user2" ).getRoleNames();
 512         assertTrue( user2roles.contains( "Project Administrator - other" ) );
 513         assertTrue( user2roles.contains( "Registered User" ) );
 514
 515
 516         // back to initial
 517         rbacManager.getUserAssignment( "user2" ).removeRoleName( "Registered User" );
 518         rbacManager.getUserAssignment( "user2" ).removeRoleName( "Project Administrator - other" );
 519         rbacManager.getUserAssignment( "user" ).removeRoleName( "Project Administrator - default" );
 520     }
 521
 522     /**
 523      * Check security - edituser should succeed if removing a role that 'user-management-role-grant' is present for
 524      * templated roles
 525      */
 526     @Test
 527     public void testRoleGrantFilteringOnRemoveRolesPermittedTemplated()
 528         throws Exception
 529     {
 530         rbacManager.removeUserAssignment( "user2" );
 531
 532         addAssignment( "user", "Project Administrator - default" );
 533
 534         addAssignment( "user2", "Project Administrator - default" );
 535
 536         // set addDSelectedRoles (dynamic --> Resource Roles) and addNDSelectedRoles (non-dynamic --> Available Roles)
 537         List<String> dSelectedRoles = new ArrayList<String>();
 538         action.setAddDSelectedRoles( dSelectedRoles );
 539
 540         assertEquals( Arrays.asList( "Project Administrator - default" ),
 541                       rbacManager.getUserAssignment( "user2" ).getRoleNames() );
 542
 543         assertEquals( Action.SUCCESS, action.edituser() );
 544
 545         assertTrue( rbacManager.getUserAssignment( "user2" ).getRoleNames().isEmpty() );
 546
 547         rbacManager.getUserAssignment( "user" ).removeRoleName( "Project Administrator - default" );
 548     }
 549
 550     /**
 551      * Check security - show should succeed and display all roles, even without 'user-management-role-grant' or
 552      * 'user-management-user-role' for the user administrators.
 553      *
 554      * @throws org.apache.archiva.redback.policy.MustChangePasswordException
 555      */
 556     @Test
 557     public void testSystemAdminCanShowRoles()
 558         throws Exception
 559     {
 560
 561         login( action, "admin", PASSWORD );
 562
 563         assertEquals( Action.SUCCESS, action.show() );
 564
 565         assertEquals( 2, action.getApplicationRoleDetails().size() );
 566         ApplicationRoleDetails details = (ApplicationRoleDetails) action.getApplicationRoleDetails().get( 0 );
 567         assertEquals( "System", details.getName() );
 568         assertEquals( "Roles that apply system-wide, across all of the applications", details.getDescription() );
 569         assertEquals( 4, details.getAvailableRoles().size() );
 570         assertEquals( "Guest", details.getAvailableRoles().get( 0 ) );
 571         assertEquals( "Registered User", details.getAvailableRoles().get( 1 ) );
 572         assertEquals( "System Administrator", details.getAvailableRoles().get( 2 ) );
 573         assertEquals( "User Administrator", details.getAvailableRoles().get( 3 ) );
 574
 575         details = (ApplicationRoleDetails) action.getApplicationRoleDetails().get( 1 );
 576         assertEquals( "Continuum", details.getName() );
 577
 578         assertEquals( 2, details.getAvailableRoles().size() );
 579         assertEquals( "Continuum Group Project Administrator", details.getAvailableRoles().get( 0 ) );
 580         assertEquals( "Global Grant Administrator", details.getAvailableRoles().get( 1 ) );
 581
 582         List<List<RoleTableCell>> table = details.getTable();
 583         assertEquals( 2, table.size() );
 584         assertRow( table, 0, "default", "Project Administrator - default", false );
 585         assertRow( table, 1, "other", "Project Administrator - other", false );
 586     }
 587
 588     /**
 589      * Check security - show should succeed and display all roles, even without 'user-management-role-grant' or
 590      * 'user-management-user-role' for the user administrators.
 591      */
 592     @Test
 593     public void testUserAdminCanShowRoles()
 594         throws Exception
 595     {
 596
 597         ActionProxy actionProxy = getActionProxy( "/security/assignments" );
 598         AssignmentsAction newAction = (AssignmentsAction) actionProxy.getAction();
 599
 600         login( newAction, "user-admin", PASSWORD );
 601
 602         newAction.setPrincipal( "user-admin" );
 603
 604         assertEquals( Action.SUCCESS, newAction.show() );
 605
 606         assertEquals( 2, newAction.getApplicationRoleDetails().size() );
 607         ApplicationRoleDetails details = (ApplicationRoleDetails) newAction.getApplicationRoleDetails().get( 0 );
 608         assertEquals( "System", details.getName() );
 609         assertEquals( "Roles that apply system-wide, across all of the applications", details.getDescription() );
 610         // TODO assertEquals( 3, details.getAvailableRoles().size() );
 611         assertEquals( "Guest", details.getAvailableRoles().get( 0 ) );
 612         assertEquals( "not role Registered User roles : " + details.getAvailableRoles(), "Registered User",
 613                       details.getAvailableRoles().get( 1 ) );
 614         // TODO: assertEquals( "User Administrator", details.getAvailableRoles().get( 2 ) );
 615
 616         details = newAction.getApplicationRoleDetails().get( 1 );
 617         assertEquals( "Continuum", details.getName() );
 618
 619         assertEquals( 2, details.getAvailableRoles().size() );
 620         assertEquals( "Continuum Group Project Administrator", details.getAvailableRoles().get( 0 ) );
 621         assertEquals( "Global Grant Administrator", details.getAvailableRoles().get( 1 ) );
 622
 623         List<List<RoleTableCell>> table = details.getTable();
 624         assertEquals( 2, table.size() );
 625         assertRow( table, 0, "default", "Project Administrator - default", false );
 626         assertRow( table, 1, "other", "Project Administrator - other", false );
 627     }
 628
 629     /**
 630      * Check security - edituser should succeed in adding a role, even without 'user-management-role-grant' or
 631      * 'user-management-user-role' for the user administrators.
 632      */
 633     @Test
 634     public void testUserAdminCanAddRoles()
 635         throws Exception
 636     {
 637         login( action, "user-admin", PASSWORD );
 638
 639         // set addDSelectedRoles (dynamic --> Resource Roles) and addNDSelectedRoles (non-dynamic --> Available Roles)
 640         List<String> ndSelectedRoles = new ArrayList<String>();
 641         ndSelectedRoles.add( "Continuum Group Project Administrator" );
 642
 643         action.setAddNDSelectedRoles( ndSelectedRoles );
 644
 645         // set addDSelectedRoles (dynamic --> Resource Roles) and addNDSelectedRoles (non-dynamic --> Available Roles)
 646         List<String> dSelectedRoles = new ArrayList<String>();
 647         dSelectedRoles.add( "Project Administrator - default" );
 648
 649         action.setAddDSelectedRoles( dSelectedRoles );
 650
 651         assertTrue( rbacManager.getUserAssignment( "user2" ).getRoleNames().isEmpty() );
 652
 653         assertEquals( Action.SUCCESS, action.edituser() );
 654
 655         assertEquals( Arrays.asList( "Continuum Group Project Administrator", "Project Administrator - default" ),
 656                       rbacManager.getUserAssignment( "user2" ).getRoleNames() );
 657
 658         // back to inital
 659         rbacManager.getUserAssignment( "user2" ).removeRoleName( "Continuum Group Project Administrator" );
 660         rbacManager.getUserAssignment( "user2" ).removeRoleName( "Project Administrator - default" );
 661     }
 662
 663     /**
 664      * Check security - edituser should succeed in removing a role, even without 'user-management-role-grant' or
 665      * 'user-management-user-role' for the user administrators.
 666      */
 667     @Test
 668     public void testUserAdminCanRemoveRoles()
 669         throws Exception
 670     {
 671         login( action, "user-admin", PASSWORD );
 672
 673         rbacManager.removeUserAssignment( "user2" );
 674
 675         addAssignment( "user2", "Continuum Group Project Administrator" );
 676         addAssignment( "user2", "Project Administrator - default" );
 677
 678         // set addDSelectedRoles (dynamic --> Resource Roles) and addNDSelectedRoles (non-dynamic --> Available Roles)
 679         List<String> ndSelectedRoles = new ArrayList<String>();
 680         action.setAddNDSelectedRoles( ndSelectedRoles );
 681
 682         List<String> dSelectedRoles = new ArrayList<String>();
 683         action.setAddDSelectedRoles( dSelectedRoles );
 684
 685         assertEquals( Arrays.asList( "Continuum Group Project Administrator", "Project Administrator - default" ),
 686                       rbacManager.getUserAssignment( "user2" ).getRoleNames() );
 687
 688         assertEquals( Action.SUCCESS, action.edituser() );
 689
 690         assertTrue( rbacManager.getUserAssignment( "user2" ).getRoleNames().isEmpty() );
 691     }
 692
 693     /**
 694      * Check that a configured struts2 redback app only removes roles configured for the app. Without this, redback
 695      * applications sharing a user database will remove each other's roles on save.
 696      */
 697     @Test
 698     public void testUserAdminCannotRemoveNonAppRoles()
 699         throws Exception
 700     {
 701         login( action, "user-admin", PASSWORD );
 702
 703         // Create a role that isn't configured for apps
 704         String nonAppRoleName = "Other App Role";
 705         Role nonAppRole = rbacManager.createRole( nonAppRoleName );
 706         rbacManager.saveRole( nonAppRole );
 707
 708         rbacManager.removeUserAssignment( "user2" );
 709
 710         addAssignment( "user2", "Continuum Group Project Administrator" );
 711         addAssignment( "user2", "Project Administrator - default" );
 712         addAssignment( "user2", nonAppRoleName );
 713
 714         // set addDSelectedRoles (dynamic --> Resource Roles) and addNDSelectedRoles (non-dynamic --> Available Roles)
 715         List<String> ndSelectedRoles = new ArrayList<String>();
 716         action.setAddNDSelectedRoles( ndSelectedRoles );
 717
 718         List<String> dSelectedRoles = new ArrayList<String>();
 719         action.setAddDSelectedRoles( dSelectedRoles );
 720
 721         assertEquals(
 722             Arrays.asList( "Continuum Group Project Administrator", "Project Administrator - default", nonAppRoleName ),
 723             rbacManager.getUserAssignment( "user2" ).getRoleNames() );
 724
 725         assertEquals( Action.SUCCESS, action.edituser() );
 726
 727         // All roles except role from other app should be removed.
 728         List<String> user2roles = rbacManager.getUserAssignment( "user2" ).getRoleNames();
 729         assertTrue( !user2roles.contains( "Continuum Group Project Administrator" ) );
 730         assertTrue( !user2roles.contains( "Project Administrator - default" ) );
 731         assertTrue( user2roles.contains( nonAppRoleName ) );
 732
 733         // back to initial
 734         rbacManager.removeRole( nonAppRole );
 735         rbacManager.getUserAssignment( "user2" ).removeRoleName( nonAppRoleName );
 736     }
 737 }