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

   1 package org.apache.archiva.redback.users.ldap;
   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 junit.framework.TestCase;
  23 import org.apache.archiva.redback.policy.PasswordEncoder;
  24 import org.apache.archiva.redback.users.User;
  25 import org.apache.archiva.redback.common.ldap.connection.LdapConnection;
  26 import org.apache.archiva.redback.common.ldap.connection.LdapConnectionFactory;
  27 import org.apache.archiva.redback.policy.encoders.SHA1PasswordEncoder;
  28 import org.apache.archiva.redback.users.UserManager;
  29 import org.apache.archiva.redback.users.UserNotFoundException;
  30 import org.apache.archiva.redback.users.ldap.service.LdapCacheService;
  31 import org.apache.archiva.redback.components.apacheds.ApacheDs;
  32 import org.junit.After;
  33 import org.junit.Before;
  34 import org.junit.Test;
  35 import org.junit.runner.RunWith;
  36 import org.slf4j.Logger;
  37 import org.slf4j.LoggerFactory;
  38 import org.springframework.test.context.ContextConfiguration;
  39 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
  40
  41 import javax.inject.Inject;
  42 import javax.inject.Named;
  43 import javax.naming.NamingEnumeration;
  44 import javax.naming.NamingException;
  45 import javax.naming.directory.Attribute;
  46 import javax.naming.directory.Attributes;
  47 import javax.naming.directory.BasicAttribute;
  48 import javax.naming.directory.BasicAttributes;
  49 import javax.naming.directory.DirContext;
  50 import javax.naming.directory.InitialDirContext;
  51 import javax.naming.directory.SearchControls;
  52 import javax.naming.directory.SearchResult;
  53 import java.util.List;
  54
  55
  56 /**
  57  * LdapUserManagerTest
  58  *
  59  * @author <a href="mailto:jesse@codehaus.org">Jesse McConnell</a>
  60  * @version $Id$
  61  */
  62
  63 @RunWith( SpringJUnit4ClassRunner.class )
  64 @ContextConfiguration( locations = { "classpath*:/META-INF/spring-context.xml", "classpath*:/spring-context.xml" } )
  65 public class LdapUserManagerTest
  66     extends TestCase
  67 {
  68
  69     protected Logger log = LoggerFactory.getLogger( getClass() );
  70
  71     @Inject
  72     @Named(value = "userManager#ldap")
  73     private UserManager userManager;
  74
  75     @Inject
  76     @Named( value = "apacheDS#test" )
  77     private ApacheDs apacheDs;
  78
  79     private String suffix;
  80
  81     private PasswordEncoder passwordEncoder;
  82
  83     @Inject
  84     @Named(value = "ldapConnectionFactory#configurable")
  85     private LdapConnectionFactory connectionFactory;
  86
  87     @Inject
  88     private LdapCacheService ldapCacheService;
  89
  90     public void testFoo()
  91         throws Exception
  92     {
  93
  94     }
  95
  96     @Before
  97     public void setUp()
  98         throws Exception
  99     {
 100         super.setUp();
 101
 102         passwordEncoder = new SHA1PasswordEncoder();
 103
 104         suffix = apacheDs.addSimplePartition( "test", new String[] { "redback", "plexus", "codehaus", "org" } )
 105             .getSuffix();
 106
 107         log.info( "DN Suffix: " + suffix );
 108
 109         apacheDs.startServer();
 110
 111         clearManyUsers();
 112
 113         makeUsers();
 114
 115     }
 116
 117     @After
 118     public void tearDown()
 119         throws Exception
 120     {
 121         // clear cache
 122         ldapCacheService.removeAllUsers();
 123
 124         InitialDirContext context = apacheDs.getAdminContext();
 125
 126         context.unbind( createDn( "jesse" ) );
 127
 128         context.unbind( createDn( "joakim" ) );
 129
 130         apacheDs.stopServer();
 131
 132         super.tearDown();
 133     }
 134
 135     private void makeUsers()
 136         throws Exception
 137     {
 138         InitialDirContext context = apacheDs.getAdminContext();
 139
 140         String cn = "jesse";
 141         bindUserObject( context, cn, createDn( cn ) );
 142         assertExist( context, createDn( cn ), "cn", cn );
 143
 144         cn = "joakim";
 145         bindUserObject( context, cn, createDn( cn ) );
 146         assertExist( context, createDn( cn ), "cn", cn );
 147
 148     }
 149
 150     @Test
 151     public void testConnection()
 152         throws Exception
 153     {
 154         assertNotNull( connectionFactory );
 155
 156         LdapConnection connection = null;
 157         try
 158         {
 159         connection = connectionFactory.getConnection();
 160
 161         assertNotNull( connection );
 162
 163         DirContext context = connection.getDirContext();
 164
 165         assertNotNull( context );
 166         } finally {
 167             connection.close();
 168         }
 169     }
 170
 171     @Test
 172     public void testDirectUsersExistence()
 173         throws Exception
 174     {
 175         LdapConnection connection = null;
 176         try
 177         {
 178         connection = connectionFactory.getConnection();
 179
 180         DirContext context = connection.getDirContext();
 181
 182         assertExist( context, createDn( "jesse" ), "cn", "jesse" );
 183         assertExist( context, createDn( "joakim" ), "cn", "joakim" );
 184         } finally {
 185             connection.close();
 186         }
 187
 188     }
 189
 190     @Test
 191     public void testUserManager()
 192         throws Exception
 193     {
 194         assertNotNull( userManager );
 195
 196         //assertNull( ldapCacheService.getUser( "jesse" ) );
 197
 198         assertTrue( userManager.userExists( "jesse" ) );
 199
 200         //assertNotNull( ldapCacheService.getUser( "jesse" ) );
 201
 202         List<User> users = userManager.getUsers();
 203
 204         assertNotNull( users );
 205
 206         assertEquals( 2, users.size() );
 207
 208         User jesse = userManager.findUser( "jesse" );
 209
 210         assertNotNull( jesse );
 211
 212         assertEquals( "jesse", jesse.getPrincipal().toString() );
 213         assertEquals( "jesse@apache.org", jesse.getEmail() );
 214         assertEquals( "foo", jesse.getFullName() );
 215         System.out.println( "=====>"+jesse.getEncodedPassword());
 216         System.out.println( "=====>"+passwordEncoder.encodePassword( "foo" ));
 217         assertTrue( passwordEncoder.isPasswordValid( jesse.getEncodedPassword(), "foo" ) );
 218
 219     }
 220
 221     @Test
 222     public void testUserNotFoundException()
 223         throws Exception
 224     {
 225         try
 226         {
 227             userManager.findUser( "foo bar" );
 228             fail( "not a UserNotFoundException with an unknown user" );
 229         }
 230         catch ( UserNotFoundException e )
 231         {
 232             // cool it works !
 233         }
 234     }
 235
 236     @Test
 237     public void testWithManyUsers()
 238         throws Exception
 239     {
 240         makeManyUsers();
 241
 242         assertNotNull( userManager );
 243
 244         assertTrue( userManager.userExists( "user10" ) );
 245
 246         List<User> users = userManager.getUsers();
 247
 248         assertNotNull( users );
 249
 250         assertEquals( 10002, users.size() );
 251
 252         User user10 = userManager.findUser( "user10" );
 253
 254         assertNotNull( user10 );
 255     }
 256
 257     private void makeManyUsers()
 258         throws Exception
 259     {
 260         InitialDirContext context = apacheDs.getAdminContext();
 261
 262         for ( int i = 0 ; i < 10000 ; i++ )
 263         {
 264             String cn = "user"+i;
 265             bindUserObject( context, cn, createDn( cn ) );
 266         }
 267
 268     }
 269
 270     private void clearManyUsers()
 271         throws Exception
 272     {
 273         InitialDirContext context = apacheDs.getAdminContext();
 274
 275         for ( int i = 0 ; i < 10000 ; i++ )
 276         {
 277             String cn = "user"+i;
 278             try
 279             {
 280                 context.unbind( createDn( cn ) );
 281             }
 282             catch ( NamingException e )
 283             {
 284                 // OK lets try with next one
 285             }
 286         }
 287
 288     }
 289
 290     private void bindUserObject( DirContext context, String cn, String dn )
 291         throws Exception
 292     {
 293         Attributes attributes = new BasicAttributes( true );
 294         BasicAttribute objectClass = new BasicAttribute( "objectClass" );
 295         objectClass.add( "top" );
 296         objectClass.add( "inetOrgPerson" );
 297         objectClass.add( "person" );
 298         objectClass.add( "organizationalperson" );
 299         attributes.put( objectClass );
 300         attributes.put( "cn", cn );
 301         attributes.put( "sn", "foo" );
 302         attributes.put( "mail", cn+"@apache.org" );
 303         attributes.put( "userPassword", passwordEncoder.encodePassword( "foo" ) );
 304         attributes.put( "givenName", "foo" );
 305         context.createSubcontext( dn, attributes );
 306     }
 307
 308     private String createDn( String cn )
 309     {
 310         return "cn=" + cn + "," + suffix;
 311     }
 312
 313     private void assertExist( DirContext context, String dn, String attribute, String value )
 314         throws NamingException
 315     {
 316         SearchControls ctls = new SearchControls();
 317
 318         ctls.setDerefLinkFlag( true );
 319         ctls.setSearchScope( SearchControls.ONELEVEL_SCOPE );
 320         ctls.setReturningAttributes( new String[] { "*" } );
 321
 322         BasicAttributes matchingAttributes = new BasicAttributes();
 323         matchingAttributes.put( attribute, value );
 324         BasicAttribute objectClass = new BasicAttribute( "objectClass" );
 325         objectClass.add( "inetOrgPerson" );
 326         matchingAttributes.put( objectClass );
 327
 328         NamingEnumeration<SearchResult> results = context.search( suffix, matchingAttributes );
 329         // NamingEnumeration<SearchResult> results = context.search( suffix, "(" + attribute + "=" + value + ")", ctls
 330         // );
 331
 332         assertTrue( results.hasMoreElements() );
 333         SearchResult result = results.nextElement();
 334         Attributes attrs = result.getAttributes();
 335         Attribute testAttr = attrs.get( attribute );
 336         assertEquals( value, testAttr.get() );
 337
 338     }
 339
 340 }