package org.apache.maven.archiva.webdav;
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
import java.io.File;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.apache.commons.io.FileUtils;
import org.apache.jackrabbit.webdav.DavException;
import org.apache.jackrabbit.webdav.DavResource;
import org.apache.jackrabbit.webdav.DavResourceFactory;
import org.apache.jackrabbit.webdav.DavResourceLocator;
import org.apache.jackrabbit.webdav.DavServletRequest;
import org.apache.jackrabbit.webdav.DavServletResponse;
import org.apache.jackrabbit.webdav.DavSession;
import org.apache.jackrabbit.webdav.lock.ActiveLock;
import org.apache.jackrabbit.webdav.lock.LockInfo;
import org.apache.jackrabbit.webdav.lock.LockManager;
import org.apache.jackrabbit.webdav.lock.Scope;
import org.apache.jackrabbit.webdav.lock.SimpleLockManager;
import org.apache.jackrabbit.webdav.lock.Type;
import org.apache.maven.archiva.configuration.ManagedRepositoryConfiguration;
import org.apache.maven.archiva.database.ArchivaAuditLogsDao;
import org.apache.maven.archiva.database.ArchivaDatabaseException;
import org.apache.maven.archiva.database.Constraint;
import org.apache.maven.archiva.database.ObjectNotFoundException;
import org.apache.maven.archiva.model.ArchivaAuditLogs;
import org.apache.maven.archiva.repository.audit.AuditListener;
import org.apache.maven.archiva.webdav.util.MimeTypes;
import org.codehaus.plexus.spring.PlexusInSpringTestCase;
import org.codehaus.plexus.spring.PlexusToSpringUtils;
public class DavResourceTest
extends PlexusInSpringTestCase
{
private DavSession session;
private MimeTypes mimeTypes;
private ArchivaDavResourceLocator resourceLocator;
private DavResourceFactory resourceFactory;
private File baseDir;
private final String REPOPATH = "myresource.jar";
private File myResource;
private DavResource resource;
private LockManager lockManager;
private ManagedRepositoryConfiguration repository = new ManagedRepositoryConfiguration();
private ArchivaAuditLogsDao auditLogsDao;
@Override
protected void setUp()
throws Exception
{
super.setUp();
session = new ArchivaDavSession();
auditLogsDao = new ArchivaAuditLogsDaoImpl();
mimeTypes = (MimeTypes) getApplicationContext().getBean( PlexusToSpringUtils.buildSpringId( MimeTypes.class ) );
baseDir = getTestFile( "target/DavResourceTest" );
baseDir.mkdirs();
myResource = new File( baseDir, "myresource.jar" );
assertTrue( "Could not create " + myResource.getAbsolutePath(), myResource.createNewFile() );
resourceFactory = new RootContextDavResourceFactory();
resourceLocator =
(ArchivaDavResourceLocator) new ArchivaDavLocatorFactory().createResourceLocator( "/", REPOPATH );
resource = getDavResource( resourceLocator.getHref( false ), myResource );
lockManager = new SimpleLockManager();
resource.addLockManager( lockManager );
}
@Override
protected void tearDown()
throws Exception
{
super.tearDown();
release( mimeTypes );
FileUtils.deleteDirectory( baseDir );
}
private DavResource getDavResource( String logicalPath, File file )
{
return new ArchivaDavResource( file.getAbsolutePath(), logicalPath, repository, session, resourceLocator,
resourceFactory, mimeTypes, Collections.<AuditListener> emptyList(), null, auditLogsDao );
}
public void testDeleteNonExistantResourceShould404()
throws Exception
{
File dir = new File( baseDir, "testdir" );
try
{
DavResource directoryResource = getDavResource( "/testdir", dir );
directoryResource.getCollection().removeMember( directoryResource );
fail( "Did not throw DavException" );
}
catch ( DavException e )
{
assertEquals( DavServletResponse.SC_NOT_FOUND, e.getErrorCode() );
}
}
public void testDeleteCollection()
throws Exception
{
File dir = new File( baseDir, "testdir" );
try
{
assertTrue( dir.mkdir() );
DavResource directoryResource = getDavResource( "/testdir", dir );
directoryResource.getCollection().removeMember( directoryResource );
assertFalse( dir.exists() );
}
finally
{
FileUtils.deleteDirectory( dir );
}
}
public void testDeleteResource()
throws Exception
{
assertTrue( myResource.exists() );
resource.getCollection().removeMember( resource );
assertFalse( myResource.exists() );
}
public void testIsLockable()
{
assertTrue( resource.isLockable( Type.WRITE, Scope.EXCLUSIVE ) );
assertFalse( resource.isLockable( Type.WRITE, Scope.SHARED ) );
}
public void testLock()
throws Exception
{
assertEquals( 0, resource.getLocks().length );
LockInfo info = new LockInfo( Scope.EXCLUSIVE, Type.WRITE, "/", 0, false );
lockManager.createLock( info, resource );
assertEquals( 1, resource.getLocks().length );
}
public void testLockIfResourceUnlockable()
throws Exception
{
assertEquals( 0, resource.getLocks().length );
LockInfo info = new LockInfo( Scope.SHARED, Type.WRITE, "/", 0, false );
try
{
lockManager.createLock( info, resource );
fail( "Did not throw dav exception" );
}
catch ( Exception e )
{
// Simple lock manager will die
}
assertEquals( 0, resource.getLocks().length );
}
public void testGetLock()
throws Exception
{
LockInfo info = new LockInfo( Scope.EXCLUSIVE, Type.WRITE, "/", 0, false );
lockManager.createLock( info, resource );
assertEquals( 1, resource.getLocks().length );
// Lock should exist
assertNotNull( resource.getLock( Type.WRITE, Scope.EXCLUSIVE ) );
// Lock should not exist
assertNull( resource.getLock( Type.WRITE, Scope.SHARED ) );
}
public void testRefreshLockThrowsExceptionIfNoLockIsPresent()
throws Exception
{
LockInfo info = new LockInfo( Scope.EXCLUSIVE, Type.WRITE, "/", 0, false );
assertEquals( 0, resource.getLocks().length );
try
{
lockManager.refreshLock( info, "notoken", resource );
fail( "Did not throw dav exception" );
}
catch ( DavException e )
{
assertEquals( DavServletResponse.SC_PRECONDITION_FAILED, e.getErrorCode() );
}
assertEquals( 0, resource.getLocks().length );
}
public void testRefreshLock()
throws Exception
{
LockInfo info = new LockInfo( Scope.EXCLUSIVE, Type.WRITE, "/", 0, false );
assertEquals( 0, resource.getLocks().length );
lockManager.createLock( info, resource );
assertEquals( 1, resource.getLocks().length );
ActiveLock lock = resource.getLocks()[0];
lockManager.refreshLock( info, lock.getToken(), resource );
assertEquals( 1, resource.getLocks().length );
}
public void testUnlock()
throws Exception
{
LockInfo info = new LockInfo( Scope.EXCLUSIVE, Type.WRITE, "/", 0, false );
assertEquals( 0, resource.getLocks().length );
lockManager.createLock( info, resource );
assertEquals( 1, resource.getLocks().length );
ActiveLock lock = resource.getLocks()[0];
lockManager.releaseLock( lock.getToken(), resource );
assertEquals( 0, resource.getLocks().length );
}
public void testUnlockThrowsDavExceptionIfNotLocked()
throws Exception
{
LockInfo info = new LockInfo( Scope.EXCLUSIVE, Type.WRITE, "/", 0, false );
assertEquals( 0, resource.getLocks().length );
lockManager.createLock( info, resource );
assertEquals( 1, resource.getLocks().length );
try
{
lockManager.releaseLock( "BLAH", resource );
fail( "Did not throw DavException" );
}
catch ( DavException e )
{
assertEquals( DavServletResponse.SC_LOCKED, e.getErrorCode() );
}
assertEquals( 1, resource.getLocks().length );
}
public void testUnlockThrowsDavExceptionIfResourceNotLocked()
throws Exception
{
assertEquals( 0, resource.getLocks().length );
try
{
lockManager.releaseLock( "BLAH", resource );
fail( "Did not throw DavException" );
}
catch ( DavException e )
{
assertEquals( DavServletResponse.SC_PRECONDITION_FAILED, e.getErrorCode() );
}
assertEquals( 0, resource.getLocks().length );
}
private class RootContextDavResourceFactory
implements DavResourceFactory
{
public DavResource createResource( DavResourceLocator locator, DavServletRequest request,
DavServletResponse response )
throws DavException
{
throw new UnsupportedOperationException( "Not supported yet." );
}
public DavResource createResource( DavResourceLocator locator, DavSession session )
throws DavException
{
return new ArchivaDavResource( baseDir.getAbsolutePath(), "/", repository, session, resourceLocator,
resourceFactory, mimeTypes, Collections.<AuditListener> emptyList(),
null, auditLogsDao );
}
}
private class ArchivaAuditLogsDaoImpl
implements ArchivaAuditLogsDao
{
public List<ArchivaAuditLogs> queryAuditLogs( Constraint constraint )
throws ObjectNotFoundException, ArchivaDatabaseException
{
return new ArrayList<ArchivaAuditLogs>();
}
public ArchivaAuditLogs saveAuditLogs( ArchivaAuditLogs logs )
{
return new ArchivaAuditLogs();
}
public void deleteAuditLogs( ArchivaAuditLogs logs )
throws ArchivaDatabaseException
{
}
}
}