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

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