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

   1 package org.apache.maven.archiva.webdav;
   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 java.io.File;
  23 import java.util.Collections;
  24
  25 import org.apache.commons.io.FileUtils;
  26 import org.apache.jackrabbit.webdav.DavException;
  27 import org.apache.jackrabbit.webdav.DavResource;
  28 import org.apache.jackrabbit.webdav.DavResourceFactory;
  29 import org.apache.jackrabbit.webdav.DavResourceLocator;
  30 import org.apache.jackrabbit.webdav.DavServletRequest;
  31 import org.apache.jackrabbit.webdav.DavServletResponse;
  32 import org.apache.jackrabbit.webdav.DavSession;
  33 import org.apache.jackrabbit.webdav.lock.ActiveLock;
  34 import org.apache.jackrabbit.webdav.lock.LockInfo;
  35 import org.apache.jackrabbit.webdav.lock.LockManager;
  36 import org.apache.jackrabbit.webdav.lock.Scope;
  37 import org.apache.jackrabbit.webdav.lock.SimpleLockManager;
  38 import org.apache.jackrabbit.webdav.lock.Type;
  39 import org.apache.maven.archiva.configuration.ManagedRepositoryConfiguration;
  40 import org.apache.maven.archiva.repository.audit.AuditListener;
  41 import org.apache.maven.archiva.webdav.util.MimeTypes;
  42 import org.codehaus.plexus.spring.PlexusInSpringTestCase;
  43 import org.codehaus.plexus.spring.PlexusToSpringUtils;
  44
  45 public class DavResourceTest
  46     extends PlexusInSpringTestCase
  47 {
  48     private DavSession session;
  49
  50     private MimeTypes mimeTypes;
  51
  52     private ArchivaDavResourceLocator resourceLocator;
  53
  54     private DavResourceFactory resourceFactory;
  55
  56     private File baseDir;
  57
  58     private final String REPOPATH = "myresource.jar";
  59
  60     private File myResource;
  61
  62     private DavResource resource;
  63
  64     private LockManager lockManager;
  65
  66     private ManagedRepositoryConfiguration repository = new ManagedRepositoryConfiguration();
  67
  68     @Override
  69     protected void setUp()
  70         throws Exception
  71     {
  72         super.setUp();
  73         session = new ArchivaDavSession();
  74         mimeTypes = (MimeTypes) getApplicationContext().getBean( PlexusToSpringUtils.buildSpringId( MimeTypes.class ) );
  75         baseDir = getTestFile( "target/DavResourceTest" );
  76         baseDir.mkdirs();
  77         myResource = new File( baseDir, "myresource.jar" );
  78         assertTrue( "Could not create " + myResource.getAbsolutePath(), myResource.createNewFile() );
  79         resourceFactory = new RootContextDavResourceFactory();
  80
  81         resourceLocator =
  82             (ArchivaDavResourceLocator) new ArchivaDavLocatorFactory().createResourceLocator( "/", REPOPATH );
  83         resource = getDavResource( resourceLocator.getHref( false ), myResource );
  84         lockManager = new SimpleLockManager();
  85         resource.addLockManager( lockManager );
  86     }
  87
  88     @Override
  89     protected void tearDown()
  90         throws Exception
  91     {
  92         super.tearDown();
  93         release( mimeTypes );
  94         FileUtils.deleteDirectory( baseDir );
  95     }
  96
  97     private DavResource getDavResource( String logicalPath, File file )
  98     {
  99         return new ArchivaDavResource( file.getAbsolutePath(), logicalPath, repository, session, resourceLocator,
 100                                        resourceFactory, mimeTypes, Collections.<AuditListener> emptyList(), null );
 101     }
 102
 103     public void testDeleteNonExistantResourceShould404()
 104         throws Exception
 105     {
 106         File dir = new File( baseDir, "testdir" );
 107         try
 108         {
 109             DavResource directoryResource = getDavResource( "/testdir", dir );
 110             directoryResource.getCollection().removeMember( directoryResource );
 111             fail( "Did not throw DavException" );
 112         }
 113         catch ( DavException e )
 114         {
 115             assertEquals( DavServletResponse.SC_NOT_FOUND, e.getErrorCode() );
 116         }
 117     }
 118
 119     public void testDeleteCollection()
 120         throws Exception
 121     {
 122         File dir = new File( baseDir, "testdir" );
 123         try
 124         {
 125             assertTrue( dir.mkdir() );
 126             DavResource directoryResource = getDavResource( "/testdir", dir );
 127             directoryResource.getCollection().removeMember( directoryResource );
 128             assertFalse( dir.exists() );
 129         }
 130         finally
 131         {
 132             FileUtils.deleteDirectory( dir );
 133         }
 134     }
 135
 136     public void testDeleteResource()
 137         throws Exception
 138     {
 139         assertTrue( myResource.exists() );
 140         resource.getCollection().removeMember( resource );
 141         assertFalse( myResource.exists() );
 142     }
 143
 144     public void testIsLockable()
 145     {
 146         assertTrue( resource.isLockable( Type.WRITE, Scope.EXCLUSIVE ) );
 147         assertFalse( resource.isLockable( Type.WRITE, Scope.SHARED ) );
 148     }
 149
 150     public void testLock()
 151         throws Exception
 152     {
 153         assertEquals( 0, resource.getLocks().length );
 154
 155         LockInfo info = new LockInfo( Scope.EXCLUSIVE, Type.WRITE, "/", 0, false );
 156         lockManager.createLock( info, resource );
 157
 158         assertEquals( 1, resource.getLocks().length );
 159     }
 160
 161     public void testLockIfResourceUnlockable()
 162         throws Exception
 163     {
 164         assertEquals( 0, resource.getLocks().length );
 165
 166         LockInfo info = new LockInfo( Scope.SHARED, Type.WRITE, "/", 0, false );
 167         try
 168         {
 169             lockManager.createLock( info, resource );
 170             fail( "Did not throw dav exception" );
 171         }
 172         catch ( Exception e )
 173         {
 174             // Simple lock manager will die
 175         }
 176         assertEquals( 0, resource.getLocks().length );
 177     }
 178
 179     public void testGetLock()
 180         throws Exception
 181     {
 182         LockInfo info = new LockInfo( Scope.EXCLUSIVE, Type.WRITE, "/", 0, false );
 183         lockManager.createLock( info, resource );
 184
 185         assertEquals( 1, resource.getLocks().length );
 186
 187         // Lock should exist
 188         assertNotNull( resource.getLock( Type.WRITE, Scope.EXCLUSIVE ) );
 189
 190         // Lock should not exist
 191         assertNull( resource.getLock( Type.WRITE, Scope.SHARED ) );
 192     }
 193
 194     public void testRefreshLockThrowsExceptionIfNoLockIsPresent()
 195         throws Exception
 196     {
 197         LockInfo info = new LockInfo( Scope.EXCLUSIVE, Type.WRITE, "/", 0, false );
 198
 199         assertEquals( 0, resource.getLocks().length );
 200
 201         try
 202         {
 203             lockManager.refreshLock( info, "notoken", resource );
 204             fail( "Did not throw dav exception" );
 205         }
 206         catch ( DavException e )
 207         {
 208             assertEquals( DavServletResponse.SC_PRECONDITION_FAILED, e.getErrorCode() );
 209         }
 210
 211         assertEquals( 0, resource.getLocks().length );
 212     }
 213
 214     public void testRefreshLock()
 215         throws Exception
 216     {
 217         LockInfo info = new LockInfo( Scope.EXCLUSIVE, Type.WRITE, "/", 0, false );
 218
 219         assertEquals( 0, resource.getLocks().length );
 220
 221         lockManager.createLock( info, resource );
 222
 223         assertEquals( 1, resource.getLocks().length );
 224
 225         ActiveLock lock = resource.getLocks()[0];
 226
 227         lockManager.refreshLock( info, lock.getToken(), resource );
 228
 229         assertEquals( 1, resource.getLocks().length );
 230     }
 231
 232     public void testUnlock()
 233         throws Exception
 234     {
 235         LockInfo info = new LockInfo( Scope.EXCLUSIVE, Type.WRITE, "/", 0, false );
 236
 237         assertEquals( 0, resource.getLocks().length );
 238
 239         lockManager.createLock( info, resource );
 240
 241         assertEquals( 1, resource.getLocks().length );
 242
 243         ActiveLock lock = resource.getLocks()[0];
 244
 245         lockManager.releaseLock( lock.getToken(), resource );
 246
 247         assertEquals( 0, resource.getLocks().length );
 248     }
 249
 250     public void testUnlockThrowsDavExceptionIfNotLocked()
 251         throws Exception
 252     {
 253         LockInfo info = new LockInfo( Scope.EXCLUSIVE, Type.WRITE, "/", 0, false );
 254
 255         assertEquals( 0, resource.getLocks().length );
 256
 257         lockManager.createLock( info, resource );
 258
 259         assertEquals( 1, resource.getLocks().length );
 260
 261         try
 262         {
 263             lockManager.releaseLock( "BLAH", resource );
 264             fail( "Did not throw DavException" );
 265         }
 266         catch ( DavException e )
 267         {
 268             assertEquals( DavServletResponse.SC_LOCKED, e.getErrorCode() );
 269         }
 270
 271         assertEquals( 1, resource.getLocks().length );
 272     }
 273
 274     public void testUnlockThrowsDavExceptionIfResourceNotLocked()
 275         throws Exception
 276     {
 277         assertEquals( 0, resource.getLocks().length );
 278
 279         try
 280         {
 281             lockManager.releaseLock( "BLAH", resource );
 282             fail( "Did not throw DavException" );
 283         }
 284         catch ( DavException e )
 285         {
 286             assertEquals( DavServletResponse.SC_PRECONDITION_FAILED, e.getErrorCode() );
 287         }
 288
 289         assertEquals( 0, resource.getLocks().length );
 290     }
 291
 292     private class RootContextDavResourceFactory
 293         implements DavResourceFactory
 294     {
 295         public DavResource createResource( DavResourceLocator locator, DavServletRequest request,
 296                                            DavServletResponse response )
 297             throws DavException
 298         {
 299             throw new UnsupportedOperationException( "Not supported yet." );
 300         }
 301
 302         public DavResource createResource( DavResourceLocator locator, DavSession session )
 303             throws DavException
 304         {
 305             return new ArchivaDavResource( baseDir.getAbsolutePath(), "/", repository, session, resourceLocator,
 306                                            resourceFactory, mimeTypes, Collections.<AuditListener> emptyList(),
 307                                            null );
 308         }
 309     }
 310 }