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 org.apache.commons.io.FileUtils;
  24 import org.apache.jackrabbit.webdav.DavException;
  25 import org.apache.jackrabbit.webdav.DavResource;
  26 import org.apache.jackrabbit.webdav.DavServletResponse;
  27 import org.apache.jackrabbit.webdav.DavSession;
  28 import org.apache.jackrabbit.webdav.lock.ActiveLock;
  29 import org.apache.jackrabbit.webdav.lock.LockInfo;
  30 import org.apache.jackrabbit.webdav.lock.LockManager;
  31 import org.apache.jackrabbit.webdav.lock.Scope;
  32 import org.apache.jackrabbit.webdav.lock.SimpleLockManager;
  33 import org.apache.jackrabbit.webdav.lock.Type;
  34 import org.apache.maven.archiva.webdav.util.MimeTypes;
  35 import org.codehaus.plexus.spring.PlexusInSpringTestCase;
  36 import org.codehaus.plexus.spring.PlexusToSpringUtils;
  37
  38 public class DavResourceTest extends PlexusInSpringTestCase
  39 {
  40     private DavSession session;
  41
  42     private MimeTypes mimeTypes;
  43
  44     private ArchivaDavResourceLocator resourceLocator;
  45
  46     private File baseDir;
  47
  48     private final String REPOPATH = "myresource.jar";
  49
  50     private File myResource;
  51
  52     private DavResource resource;
  53
  54     private LockManager lockManager;
  55
  56     @Override
  57     protected void setUp()
  58         throws Exception
  59     {
  60         super.setUp();
  61         session = new ArchivaDavSession();
  62         mimeTypes = (MimeTypes)getApplicationContext().getBean(PlexusToSpringUtils.buildSpringId(MimeTypes.class));
  63         baseDir = getTestFile("target/DavResourceTest");
  64         baseDir.mkdirs();
  65         myResource = new File(baseDir, "myresource.jar");
  66         assertTrue("Could not create " + myResource.getAbsolutePath(), myResource.createNewFile());
  67         resourceLocator = (ArchivaDavResourceLocator)new ArchivaDavLocatorFactory().createResourceLocator("/", REPOPATH);
  68         resource = getDavResource(REPOPATH, myResource);
  69         lockManager = new SimpleLockManager();
  70         resource.addLockManager(lockManager);
  71     }
  72
  73     @Override
  74     protected void tearDown()
  75         throws Exception
  76     {
  77         super.tearDown();
  78         release(mimeTypes);
  79         FileUtils.deleteDirectory(baseDir);
  80     }
  81
  82     private DavResource getDavResource(String logicalPath, File file)
  83     {
  84         return new ArchivaDavResource(logicalPath, file.getAbsolutePath(), mimeTypes, session, resourceLocator, null);
  85     }
  86
  87     public void testIsLockable()
  88     {
  89         assertTrue(resource.isLockable(Type.WRITE, Scope.EXCLUSIVE));
  90         assertFalse(resource.isLockable(Type.WRITE, Scope.SHARED));
  91     }
  92
  93     public void testLock()
  94         throws Exception
  95     {
  96         assertEquals(0, resource.getLocks().length);
  97
  98         LockInfo info = new LockInfo(Scope.EXCLUSIVE, Type.WRITE, "/", 0, false);
  99         lockManager.createLock(info, resource);
 100
 101         assertEquals(1, resource.getLocks().length);
 102     }
 103
 104     public void testLockIfResourceUnlockable()
 105         throws Exception
 106     {
 107         assertEquals(0, resource.getLocks().length);
 108
 109         LockInfo info = new LockInfo(Scope.SHARED, Type.WRITE, "/", 0, false);
 110         try
 111         {
 112             lockManager.createLock(info, resource);
 113             fail("Did not throw dav exception");
 114         }
 115         catch (Exception e)
 116         {
 117             //Simple lock manager will die
 118         }
 119         assertEquals(0, resource.getLocks().length);
 120     }
 121
 122     public void testGetLock()
 123         throws Exception
 124     {
 125         LockInfo info = new LockInfo(Scope.EXCLUSIVE, Type.WRITE, "/", 0, false);
 126         lockManager.createLock(info, resource);
 127
 128         assertEquals(1, resource.getLocks().length);
 129
 130         //Lock should exist
 131         assertNotNull(resource.getLock(Type.WRITE, Scope.EXCLUSIVE));
 132
 133         //Lock should not exist
 134         assertNull(resource.getLock(Type.WRITE, Scope.SHARED));
 135     }
 136
 137
 138     public void testRefreshLockThrowsExceptionIfNoLockIsPresent()
 139         throws Exception
 140     {
 141         LockInfo info = new LockInfo(Scope.EXCLUSIVE, Type.WRITE, "/", 0, false);
 142
 143         assertEquals(0, resource.getLocks().length);
 144
 145         try
 146         {
 147             lockManager.refreshLock(info, "notoken", resource);
 148             fail("Did not throw dav exception");
 149         }
 150         catch (DavException e)
 151         {
 152             assertEquals(DavServletResponse.SC_PRECONDITION_FAILED, e.getErrorCode());
 153         }
 154
 155         assertEquals(0, resource.getLocks().length);
 156     }
 157
 158     public void testRefreshLock()
 159         throws Exception
 160     {
 161         LockInfo info = new LockInfo(Scope.EXCLUSIVE, Type.WRITE, "/", 0, false);
 162
 163         assertEquals(0, resource.getLocks().length);
 164
 165         lockManager.createLock(info, resource);
 166
 167         assertEquals(1, resource.getLocks().length);
 168
 169         ActiveLock lock = resource.getLocks()[0];
 170
 171         lockManager.refreshLock(info, lock.getToken(), resource);
 172
 173         assertEquals(1, resource.getLocks().length);
 174     }
 175
 176     public void testUnlock()
 177         throws Exception
 178     {
 179         LockInfo info = new LockInfo(Scope.EXCLUSIVE, Type.WRITE, "/", 0, false);
 180
 181         assertEquals(0, resource.getLocks().length);
 182
 183         lockManager.createLock(info, resource);
 184
 185         assertEquals(1, resource.getLocks().length);
 186
 187         ActiveLock lock = resource.getLocks()[0];
 188
 189         lockManager.releaseLock(lock.getToken(), resource);
 190
 191         assertEquals(0, resource.getLocks().length);
 192     }
 193
 194     public void testUnlockThrowsDavExceptionIfNotLocked()
 195         throws Exception
 196     {
 197         LockInfo info = new LockInfo(Scope.EXCLUSIVE, Type.WRITE, "/", 0, false);
 198
 199         assertEquals(0, resource.getLocks().length);
 200
 201         lockManager.createLock(info, resource);
 202
 203         assertEquals(1, resource.getLocks().length);
 204
 205         try
 206         {
 207             lockManager.releaseLock("BLAH", resource);
 208             fail("Did not throw DavException");
 209         }
 210         catch (DavException e)
 211         {
 212             assertEquals(DavServletResponse.SC_LOCKED, e.getErrorCode());
 213         }
 214
 215         assertEquals(1, resource.getLocks().length);
 216     }
 217
 218     public void testUnlockThrowsDavExceptionIfResourceNotLocked()
 219         throws Exception
 220     {
 221         assertEquals(0, resource.getLocks().length);
 222
 223         try
 224         {
 225             lockManager.releaseLock("BLAH", resource);
 226             fail("Did not throw DavException");
 227         }
 228         catch (DavException e)
 229         {
 230             assertEquals(DavServletResponse.SC_PRECONDITION_FAILED, e.getErrorCode());
 231         }
 232
 233         assertEquals(0, resource.getLocks().length);
 234     }
 235 }