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

   1 package org.apache.archiva.redback.rbac.ldap;
   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.components.apacheds.ApacheDs;
  23 import org.apache.archiva.redback.policy.PasswordEncoder;
  24 import org.apache.archiva.redback.policy.encoders.SHA1PasswordEncoder;
  25 import org.apache.archiva.redback.users.UserManager;
  26 import org.apache.archiva.redback.users.ldap.service.LdapCacheService;
  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.NameClassPair;
  41 import javax.naming.NamingEnumeration;
  42 import javax.naming.NamingException;
  43 import javax.naming.directory.Attribute;
  44 import javax.naming.directory.Attributes;
  45 import javax.naming.directory.BasicAttribute;
  46 import javax.naming.directory.BasicAttributes;
  47 import javax.naming.directory.DirContext;
  48 import javax.naming.directory.InitialDirContext;
  49 import javax.naming.directory.SearchControls;
  50 import javax.naming.directory.SearchResult;
  51 import java.util.ArrayList;
  52 import java.util.Arrays;
  53 import java.util.HashMap;
  54 import java.util.List;
  55 import java.util.Map;
  56
  57 /**
  58  * @author Olivier Lamy
  59  */
  60 @RunWith(SpringJUnit4ClassRunner.class)
  61 @ContextConfiguration(locations = { "classpath*:/META-INF/spring-context.xml", "classpath*:/spring-context.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 = "userManager#ldap")
  71     private UserManager userManager;
  72
  73     @Inject
  74     @Named(value = "apacheDS#test")
  75     private ApacheDs apacheDs;
  76
  77     private String suffix;
  78
  79     private String groupSuffix;
  80
  81     private PasswordEncoder passwordEncoder;
  82
  83     @Inject
  84     private LdapCacheService ldapCacheService;
  85
  86     @Inject
  87     @Named(value = "ldapRoleMapper#test")
  88     LdapRoleMapper ldapRoleMapper;
  89
  90     private Map<String, List<String>> usersPerGroup;
  91
  92     private List<String> users;
  93
  94     @Before
  95     public void setUp()
  96         throws Exception
  97     {
  98         super.setUp();
  99
 100         usersPerGroup = new HashMap<String, List<String>>( 3 );
 101
 102         usersPerGroup.put( "internal-repo-manager", Arrays.asList( "admin", "user.9" ) );
 103         usersPerGroup.put( "internal-repo-observer", Arrays.asList( "admin", "user.7", "user.8" ) );
 104         usersPerGroup.put( "archiva-admin", Arrays.asList( "admin", "user.7" ) );
 105
 106         users = new ArrayList<String>( 4 );
 107         users.add( "admin" );
 108         users.add( "user.7" );
 109         users.add( "user.8" );
 110         users.add( "user.9" );
 111
 112         passwordEncoder = new SHA1PasswordEncoder();
 113
 114         groupSuffix = apacheDs.addSimplePartition( "test", new String[]{ "archiva", "apache", "org" } ).getSuffix();
 115
 116         log.info( "groupSuffix: {}", groupSuffix );
 117
 118         suffix = "ou=People,dc=archiva,dc=apache,dc=org";
 119
 120         log.info( "DN Suffix: {}", suffix );
 121
 122         apacheDs.startServer();
 123
 124         BasicAttribute objectClass = new BasicAttribute( "objectClass" );
 125         objectClass.add( "top" );
 126         objectClass.add( "organizationalUnit" );
 127
 128         Attributes attributes = new BasicAttributes( true );
 129         attributes.put( objectClass );
 130         attributes.put( "organizationalUnitName", "foo" );
 131         //attributes.put( "ou", "People" );
 132
 133         apacheDs.getAdminContext().createSubcontext( suffix, attributes );
 134
 135         makeUsers();
 136
 137         createGroups();
 138     }
 139
 140     @After
 141     public void tearDown()
 142         throws Exception
 143     {
 144         // clear cache
 145         ldapCacheService.removeAllUsers();
 146
 147         InitialDirContext context = apacheDs.getAdminContext();
 148
 149         for ( String uid : users )
 150         {
 151             context.unbind( createDn( uid ) );
 152         }
 153
 154         for ( Map.Entry<String, List<String>> group : usersPerGroup.entrySet() )
 155         {
 156             context.unbind( createGroupDn( group.getKey() ) );
 157         }
 158
 159         context.unbind( suffix );
 160
 161         apacheDs.stopServer();
 162
 163         super.tearDown();
 164     }
 165
 166     private void createGroups()
 167         throws Exception
 168     {
 169         InitialDirContext context = apacheDs.getAdminContext();
 170
 171         for ( Map.Entry<String, List<String>> group : usersPerGroup.entrySet() )
 172         {
 173             createGroup( context, group.getKey(), createGroupDn( group.getKey() ), group.getValue() );
 174         }
 175
 176     }
 177
 178     private void createGroup( DirContext context, String groupName, String dn, List<String> users )
 179         throws Exception
 180     {
 181
 182         Attributes attributes = new BasicAttributes( true );
 183         BasicAttribute objectClass = new BasicAttribute( "objectClass" );
 184         objectClass.add( "top" );
 185         objectClass.add( "groupOfUniqueNames" );
 186         attributes.put( objectClass );
 187         attributes.put( "cn", groupName );
 188         BasicAttribute basicAttribute = new BasicAttribute( "uniquemember" );
 189         for ( String user : users )
 190         {
 191             basicAttribute.add( "uid=" + user + "," + suffix );// dc=archiva,dc=apache,dc=org" );
 192         }
 193
 194         attributes.put( basicAttribute );
 195         context.createSubcontext( dn, attributes );
 196     }
 197
 198     private void bindUserObject( DirContext context, String cn, String dn )
 199         throws Exception
 200     {
 201         Attributes attributes = new BasicAttributes( true );
 202         BasicAttribute objectClass = new BasicAttribute( "objectClass" );
 203         objectClass.add( "top" );
 204         objectClass.add( "inetOrgPerson" );
 205         objectClass.add( "person" );
 206         objectClass.add( "organizationalperson" );
 207         attributes.put( objectClass );
 208         attributes.put( "cn", cn );
 209         attributes.put( "sn", "foo" );
 210         attributes.put( "mail", cn + "@apache.org" );
 211         attributes.put( "userPassword", passwordEncoder.encodePassword( "foo" ) );
 212         attributes.put( "givenName", "foo" );
 213         context.createSubcontext( dn, attributes );
 214     }
 215
 216     private void makeUsers()
 217         throws Exception
 218     {
 219
 220         for ( String uid : users )
 221         {
 222             makeUser( uid );
 223         }
 224
 225     }
 226
 227     private void makeUser( String uid )
 228         throws Exception
 229     {
 230         InitialDirContext context = apacheDs.getAdminContext();
 231
 232         bindUserObject( context, uid, createDn( uid ) );
 233         assertExist( context, createDn( uid ), "cn", uid );
 234     }
 235
 236
 237     private void assertExist( DirContext context, String dn, String attribute, String value )
 238         throws NamingException
 239     {
 240         SearchControls ctls = new SearchControls();
 241
 242         ctls.setDerefLinkFlag( true );
 243         ctls.setSearchScope( SearchControls.ONELEVEL_SCOPE );
 244         ctls.setReturningAttributes( new String[]{ "*" } );
 245
 246         BasicAttributes matchingAttributes = new BasicAttributes();
 247         matchingAttributes.put( attribute, value );
 248         BasicAttribute objectClass = new BasicAttribute( "objectClass" );
 249         objectClass.add( "inetOrgPerson" );
 250         matchingAttributes.put( objectClass );
 251
 252         NamingEnumeration<SearchResult> results = context.search( suffix, matchingAttributes );
 253
 254         assertTrue( results.hasMoreElements() );
 255         SearchResult result = results.nextElement();
 256         Attributes attrs = result.getAttributes();
 257         Attribute testAttr = attrs.get( attribute );
 258         assertEquals( value, testAttr.get() );
 259
 260     }
 261
 262     private String createDn( String cn )
 263     {
 264         return "cn=" + cn + "," + suffix;
 265     }
 266
 267     private String createGroupDn( String cn )
 268     {
 269         return "cn=" + cn + "," + groupSuffix;
 270     }
 271
 272     @Test
 273     public void getAllGroups()
 274         throws Exception
 275     {
 276         List<String> allGroups = ldapRoleMapper.getAllGroups();
 277
 278         log.info( "allGroups: {}", allGroups );
 279
 280         Assertions.assertThat( allGroups ).isNotNull().isNotEmpty().contains( "archiva-admin",
 281                                                                               "internal-repo-manager" );
 282     }
 283
 284     @Test
 285     public void getGroupsMember()
 286         throws Exception
 287     {
 288         List<String> users = ldapRoleMapper.getGroupsMember( "archiva-admin" );
 289
 290         log.info( "users for archiva-admin: {}", users );
 291
 292         Assertions.assertThat( users ).isNotNull().isNotEmpty().hasSize( 2 ).contains( "admin", "user.7" );
 293
 294         users = ldapRoleMapper.getGroupsMember( "internal-repo-observer" );
 295
 296         Assertions.assertThat( users ).isNotNull().isNotEmpty().hasSize( 3 ).contains( "admin", "user.7", "user.8" );
 297     }
 298
 299     @Test
 300     public void getGroups()
 301         throws Exception
 302     {
 303         List<String> roles = ldapRoleMapper.getGroups( "admin" );
 304
 305         log.info( "roles for admin: {}", roles );
 306
 307         Assertions.assertThat( roles ).isNotNull().isNotEmpty().hasSize( 3 ).contains( "archiva-admin",
 308                                                                                        "internal-repo-manager",
 309                                                                                        "internal-repo-observer" );
 310
 311         roles = ldapRoleMapper.getGroups( "user.8" );
 312
 313         Assertions.assertThat( roles ).isNotNull().isNotEmpty().hasSize( 1 ).contains( "internal-repo-observer" );
 314
 315         roles = ldapRoleMapper.getGroups( "user.7" );
 316
 317         Assertions.assertThat( roles ).isNotNull().isNotEmpty().hasSize( 2 ).contains( "archiva-admin",
 318                                                                                        "internal-repo-observer" );
 319     }
 320 }