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