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

   1 package org.apache.archiva.redback.common.ldap.role;
   2 /*
   3  * Licensed to the Apache Software Foundation (ASF) under one
   4  * or more contributor license agreements.  See the NOTICE file
   5  * distributed with this work for additional information
   6  * regarding copyright ownership.  The ASF licenses this file
   7  * to you under the Apache License, Version 2.0 (the
   8  * "License"); you may not use this file except in compliance
   9  * with the License.  You may obtain a copy of the License at
  10  *
  11  * http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing,
  14  * software distributed under the License is distributed on an
  15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  16  * KIND, either express or implied.  See the License for the
  17  * specific language governing permissions and limitations
  18  * under the License.
  19  */
  20
  21 import junit.framework.TestCase;
  22 import org.apache.archiva.redback.common.ldap.connection.LdapConnection;
  23 import org.apache.archiva.redback.common.ldap.connection.LdapConnectionFactory;
  24 import org.apache.archiva.redback.components.apacheds.ApacheDs;
  25 import org.apache.archiva.redback.policy.PasswordEncoder;
  26 import org.apache.archiva.redback.policy.encoders.SHA1PasswordEncoder;
  27 import org.fest.assertions.Assertions;
  28 import org.junit.After;
  29 import org.junit.Before;
  30 import org.junit.Test;
  31 import org.junit.runner.RunWith;
  32 import org.slf4j.Logger;
  33 import org.slf4j.LoggerFactory;
  34 import org.springframework.test.annotation.DirtiesContext;
  35 import org.springframework.test.context.ContextConfiguration;
  36 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
  37
  38 import javax.inject.Inject;
  39 import javax.inject.Named;
  40 import javax.naming.NamingEnumeration;
  41 import javax.naming.NamingException;
  42 import javax.naming.directory.Attribute;
  43 import javax.naming.directory.Attributes;
  44 import javax.naming.directory.BasicAttribute;
  45 import javax.naming.directory.BasicAttributes;
  46 import javax.naming.directory.DirContext;
  47 import javax.naming.directory.InitialDirContext;
  48 import javax.naming.directory.SearchControls;
  49 import javax.naming.directory.SearchResult;
  50 import java.util.ArrayList;
  51 import java.util.Arrays;
  52 import java.util.HashMap;
  53 import java.util.List;
  54 import java.util.Map;
  55
  56 /**
  57  * @author Olivier Lamy
  58  */
  59 @RunWith(SpringJUnit4ClassRunner.class)
  60 @ContextConfiguration(
  61     locations = { "classpath*:/META-INF/spring-context.xml", "classpath:/spring-context-role-mapper.xml" })
  62 @DirtiesContext(classMode = DirtiesContext.ClassMode.AFTER_EACH_TEST_METHOD)
  63 public class TestLdapRoleMapper
  64     extends TestCase
  65 {
  66
  67     Logger log = LoggerFactory.getLogger( getClass() );
  68
  69     @Inject
  70     @Named(value = "apacheDS#test")
  71     private ApacheDs apacheDs;
  72
  73     private String suffix;
  74
  75     private String groupSuffix;
  76
  77     private PasswordEncoder passwordEncoder;
  78
  79     //@Inject
  80     //private LdapCacheService ldapCacheService;
  81
  82     @Inject
  83     @Named(value = "ldapRoleMapper#test")
  84     LdapRoleMapper ldapRoleMapper;
  85
  86     @Inject
  87     LdapConnectionFactory ldapConnectionFactory;
  88
  89     LdapConnection ldapConnection;
  90
  91     DirContext context;
  92
  93     private Map<String, List<String>> usersPerGroup;
  94
  95     private List<String> users;
  96
  97     @Before
  98     public void setUp()
  99         throws Exception
 100     {
 101         super.setUp();
 102
 103         usersPerGroup = new HashMap<String, List<String>>( 3 );
 104
 105         usersPerGroup.put( "internal-repo-manager", Arrays.asList( "admin", "user.9" ) );
 106         usersPerGroup.put( "internal-repo-observer", Arrays.asList( "admin", "user.7", "user.8" ) );
 107         usersPerGroup.put( "archiva-admin", Arrays.asList( "admin", "user.7" ) );
 108
 109         users = new ArrayList<String>( 4 );
 110         users.add( "admin" );
 111         users.add( "user.7" );
 112         users.add( "user.8" );
 113         users.add( "user.9" );
 114
 115         passwordEncoder = new SHA1PasswordEncoder();
 116
 117         groupSuffix = apacheDs.addSimplePartition( "test", new String[]{ "archiva", "apache", "org" } ).getSuffix();
 118
 119         log.info( "groupSuffix: {}", groupSuffix );
 120
 121         suffix = "ou=People,dc=archiva,dc=apache,dc=org";
 122
 123         log.info( "DN Suffix: {}", suffix );
 124
 125         apacheDs.startServer();
 126
 127         BasicAttribute objectClass = new BasicAttribute( "objectClass" );
 128         objectClass.add( "top" );
 129         objectClass.add( "organizationalUnit" );
 130
 131         Attributes attributes = new BasicAttributes( true );
 132         attributes.put( objectClass );
 133         attributes.put( "organizationalUnitName", "foo" );
 134
 135         apacheDs.getAdminContext().createSubcontext( suffix, attributes );
 136
 137         makeUsers();
 138
 139         createGroups();
 140
 141
 142     }
 143
 144     @After
 145     public void tearDown()
 146         throws Exception
 147     {
 148         // clear cache
 149         //ldapCacheService.removeAllUsers();
 150
 151         InitialDirContext context = apacheDs.getAdminContext();
 152
 153         for ( String uid : users )
 154         {
 155             context.unbind( createDn( uid ) );
 156         }
 157
 158         for ( Map.Entry<String, List<String>> group : usersPerGroup.entrySet() )
 159         {
 160             context.unbind( createGroupDn( group.getKey() ) );
 161         }
 162
 163         context.unbind( suffix );
 164
 165         context.close();
 166
 167         ldapConnection.close();
 168
 169         apacheDs.stopServer();
 170
 171         super.tearDown();
 172     }
 173
 174     protected DirContext getDirContext()
 175         throws Exception
 176     {
 177         ldapConnection = ldapConnectionFactory.getConnection();
 178         context = ldapConnection.getDirContext();
 179         return context;
 180     }
 181
 182     private void createGroups()
 183         throws Exception
 184     {
 185         InitialDirContext context = apacheDs.getAdminContext();
 186
 187         for ( Map.Entry<String, List<String>> group : usersPerGroup.entrySet() )
 188         {
 189             createGroup( context, group.getKey(), createGroupDn( group.getKey() ), group.getValue() );
 190         }
 191
 192     }
 193
 194     private void createGroup( DirContext context, String groupName, String dn, List<String> users )
 195         throws Exception
 196     {
 197
 198         Attributes attributes = new BasicAttributes( true );
 199         BasicAttribute objectClass = new BasicAttribute( "objectClass" );
 200         objectClass.add( "top" );
 201         objectClass.add( "groupOfUniqueNames" );
 202         attributes.put( objectClass );
 203         attributes.put( "cn", groupName );
 204         BasicAttribute basicAttribute = new BasicAttribute( "uniquemember" );
 205         for ( String user : users )
 206         {
 207             basicAttribute.add( "uid=" + user + "," + suffix );// dc=archiva,dc=apache,dc=org" );
 208         }
 209
 210         attributes.put( basicAttribute );
 211         context.createSubcontext( dn, attributes );
 212     }
 213
 214     private void bindUserObject( DirContext context, String cn, String dn )
 215         throws Exception
 216     {
 217         Attributes attributes = new BasicAttributes( true );
 218         BasicAttribute objectClass = new BasicAttribute( "objectClass" );
 219         objectClass.add( "top" );
 220         objectClass.add( "inetOrgPerson" );
 221         objectClass.add( "person" );
 222         objectClass.add( "organizationalperson" );
 223         attributes.put( objectClass );
 224         attributes.put( "cn", cn );
 225         attributes.put( "sn", "foo" );
 226         attributes.put( "mail", cn + "@apache.org" );
 227         attributes.put( "userPassword", passwordEncoder.encodePassword( "foo" ) );
 228         attributes.put( "givenName", "foo" );
 229         context.createSubcontext( dn, attributes );
 230     }
 231
 232     private void makeUsers()
 233         throws Exception
 234     {
 235
 236         for ( String uid : users )
 237         {
 238             makeUser( uid );
 239         }
 240
 241     }
 242
 243     private void makeUser( String uid )
 244         throws Exception
 245     {
 246         InitialDirContext context = apacheDs.getAdminContext();
 247
 248         bindUserObject( context, uid, createDn( uid ) );
 249         assertExist( context, createDn( uid ), "cn", uid );
 250     }
 251
 252
 253     private void assertExist( DirContext context, String dn, String attribute, String value )
 254         throws NamingException
 255     {
 256         SearchControls ctls = new SearchControls();
 257
 258         ctls.setDerefLinkFlag( true );
 259         ctls.setSearchScope( SearchControls.ONELEVEL_SCOPE );
 260         ctls.setReturningAttributes( new String[]{ "*" } );
 261
 262         BasicAttributes matchingAttributes = new BasicAttributes();
 263         matchingAttributes.put( attribute, value );
 264         BasicAttribute objectClass = new BasicAttribute( "objectClass" );
 265         objectClass.add( "inetOrgPerson" );
 266         matchingAttributes.put( objectClass );
 267
 268         NamingEnumeration<SearchResult> results = context.search( suffix, matchingAttributes );
 269
 270         assertTrue( results.hasMoreElements() );
 271         SearchResult result = results.nextElement();
 272         Attributes attrs = result.getAttributes();
 273         Attribute testAttr = attrs.get( attribute );
 274         assertEquals( value, testAttr.get() );
 275
 276     }
 277
 278     private String createDn( String cn )
 279     {
 280         return "cn=" + cn + "," + suffix;
 281     }
 282
 283     private String createGroupDn( String cn )
 284     {
 285         return "cn=" + cn + "," + groupSuffix;
 286     }
 287
 288
 289     @Test
 290     public void getAllGroups()
 291         throws Exception
 292     {
 293         List<String> allGroups = ldapRoleMapper.getAllGroups( getDirContext() );
 294
 295         log.info( "allGroups: {}", allGroups );
 296
 297         Assertions.assertThat( allGroups ).isNotNull().isNotEmpty().contains( "archiva-admin",
 298                                                                               "internal-repo-manager" );
 299     }
 300
 301     @Test
 302     public void getGroupsMember()
 303         throws Exception
 304     {
 305         List<String> users = ldapRoleMapper.getGroupsMember( "archiva-admin", getDirContext() );
 306
 307         log.info( "users for archiva-admin: {}", users );
 308
 309         Assertions.assertThat( users ).isNotNull().isNotEmpty().hasSize( 2 ).contains( "admin", "user.7" );
 310
 311         users = ldapRoleMapper.getGroupsMember( "internal-repo-observer", getDirContext() );
 312
 313         Assertions.assertThat( users ).isNotNull().isNotEmpty().hasSize( 3 ).contains( "admin", "user.7", "user.8" );
 314     }
 315
 316     @Test
 317     public void getGroups()
 318         throws Exception
 319     {
 320         List<String> groups = ldapRoleMapper.getGroups( "admin", getDirContext() );
 321
 322         log.info( "groups for admin: {}", groups );
 323
 324         Assertions.assertThat( groups ).isNotNull().isNotEmpty().hasSize( 3 ).contains( "archiva-admin",
 325                                                                                         "internal-repo-manager",
 326                                                                                         "internal-repo-observer" );
 327
 328         groups = ldapRoleMapper.getGroups( "user.8", getDirContext() );
 329
 330         Assertions.assertThat( groups ).isNotNull().isNotEmpty().hasSize( 1 ).contains( "internal-repo-observer" );
 331
 332         groups = ldapRoleMapper.getGroups( "user.7", getDirContext() );
 333
 334         Assertions.assertThat( groups ).isNotNull().isNotEmpty().hasSize( 2 ).contains( "archiva-admin",
 335                                                                                         "internal-repo-observer" );
 336     }
 337
 338     @Test
 339     public void getRoles()
 340         throws Exception
 341     {
 342         List<String> roles = ldapRoleMapper.getRoles( "admin", getDirContext() );
 343
 344         log.info( "roles for admin: {}", roles );
 345
 346         Assertions.assertThat( roles ).isNotNull().isNotEmpty().hasSize( 3 ).contains( "Archiva System Administrator",
 347                                                                                        "Internal Repo Manager",
 348                                                                                        "Internal Repo Observer" );
 349
 350         roles = ldapRoleMapper.getRoles( "user.7", getDirContext() );
 351
 352         log.info( "roles for user.7: {}", roles );
 353
 354         Assertions.assertThat( roles ).isNotNull().isNotEmpty().hasSize( 2 ).contains( "Archiva System Administrator",
 355                                                                                        "Internal Repo Observer" );
 356
 357         roles = ldapRoleMapper.getRoles( "user.8", getDirContext() );
 358
 359         log.info( "roles for user.8: {}", roles );
 360
 361         Assertions.assertThat( roles ).isNotNull().isNotEmpty().hasSize( 1 ).contains( "Internal Repo Observer" );
 362
 363     }
 364
 365 }