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