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