org.apache.archiva.proxy.AbstractProxyTestCase.java Source code

Java tutorial

Introduction

Here is the source code for org.apache.archiva.proxy.AbstractProxyTestCase.java

Source

package org.apache.archiva.proxy;

/*
 * 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 net.sf.ehcache.CacheManager;
import org.apache.archiva.admin.model.beans.ManagedRepository;
import org.apache.archiva.admin.model.managed.ManagedRepositoryAdmin;
import org.apache.archiva.admin.repository.managed.DefaultManagedRepositoryAdmin;
import org.apache.archiva.common.plexusbridge.PlexusSisuBridge;
import org.apache.archiva.configuration.ArchivaConfiguration;
import org.apache.archiva.configuration.ManagedRepositoryConfiguration;
import org.apache.archiva.configuration.ProxyConnectorConfiguration;
import org.apache.archiva.configuration.RemoteRepositoryConfiguration;
import org.apache.archiva.policies.CachedFailuresPolicy;
import org.apache.archiva.policies.ChecksumPolicy;
import org.apache.archiva.policies.PropagateErrorsDownloadPolicy;
import org.apache.archiva.policies.PropagateErrorsOnUpdateDownloadPolicy;
import org.apache.archiva.policies.ReleasesPolicy;
import org.apache.archiva.policies.SnapshotsPolicy;
import org.apache.archiva.proxy.model.RepositoryProxyConnectors;
import org.apache.archiva.repository.ManagedRepositoryContent;
import org.apache.archiva.test.utils.ArchivaSpringJUnit4ClassRunner;
import org.apache.commons.io.FileUtils;
import org.apache.maven.index.NexusIndexer;
import org.apache.maven.index.context.IndexingContext;
import org.apache.maven.wagon.Wagon;
import org.easymock.EasyMock;
import org.easymock.IMocksControl;
import org.junit.After;
import org.junit.Before;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.test.context.ContextConfiguration;

import javax.inject.Inject;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.nio.charset.Charset;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collection;
import java.util.Date;
import java.util.Locale;

import static org.junit.Assert.*;

/**
 * AbstractProxyTestCase
 */
@RunWith(ArchivaSpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { "classpath*:/META-INF/spring-context.xml", "classpath:/spring-context.xml" })
public abstract class AbstractProxyTestCase {
    @Inject
    protected ApplicationContext applicationContext;

    protected static final String ID_PROXIED1 = "proxied1";

    protected static final String ID_PROXIED1_TARGET = "proxied1-target";

    protected static final String ID_PROXIED2 = "proxied2";

    protected static final String ID_PROXIED2_TARGET = "proxied2-target";

    protected static final String ID_DEFAULT_MANAGED = "default-managed-repository";

    protected static final String REPOPATH_PROXIED1 = "src/test/repositories/proxied1";

    protected static final String REPOPATH_PROXIED1_TARGET = "target/test-repository/proxied1";

    protected static final String REPOPATH_PROXIED2 = "src/test/repositories/proxied2";

    protected static final String REPOPATH_PROXIED2_TARGET = "target/test-repository/proxied2";

    protected static final String REPOPATH_DEFAULT_MANAGED = "src/test/repositories/managed";

    // protected static final String REPOPATH_DEFAULT_MANAGED_TARGET = "target/test-repository/managed";

    protected IMocksControl wagonMockControl;

    protected Wagon wagonMock;

    protected RepositoryProxyConnectors proxyHandler;

    protected ManagedRepositoryContent managedDefaultRepository;

    protected File managedDefaultDir;

    protected MockConfiguration config;

    protected Logger log = LoggerFactory.getLogger(getClass());

    WagonDelegate delegate;

    @Inject
    protected ManagedRepositoryAdmin managedRepositoryAdmin;

    @Inject
    protected PlexusSisuBridge plexusSisuBridge;

    @Before
    public void setUp() throws Exception {
        config = (MockConfiguration) applicationContext.getBean("archivaConfiguration#mock",
                ArchivaConfiguration.class);

        config.getConfiguration().setManagedRepositories(new ArrayList<ManagedRepositoryConfiguration>());
        config.getConfiguration().setRemoteRepositories(new ArrayList<RemoteRepositoryConfiguration>());
        config.getConfiguration().setProxyConnectors(new ArrayList<ProxyConnectorConfiguration>());

        // Setup source repository (using default layout)
        String name = getClass().getSimpleName();
        String repoPath = "target/test-repository/managed/" + name;

        managedDefaultRepository = createRepository(ID_DEFAULT_MANAGED, "Default Managed Repository", repoPath,
                "default");

        managedDefaultDir = new File(managedDefaultRepository.getRepoRoot());

        ManagedRepository repoConfig = managedDefaultRepository.getRepository();

        ((DefaultManagedRepositoryAdmin) applicationContext.getBean(ManagedRepositoryAdmin.class))
                .setArchivaConfiguration(config);

        applicationContext.getBean(ManagedRepositoryAdmin.class).addManagedRepository(repoConfig, false, null);

        // to prevent windauze file leaking
        removeMavenIndexes();

        ManagedRepositoryAdmin managedRepositoryAdmin = applicationContext.getBean(ManagedRepositoryAdmin.class);

        if (managedRepositoryAdmin.getManagedRepository(repoConfig.getId()) != null) {
            managedRepositoryAdmin.deleteManagedRepository(repoConfig.getId(), null, true);
        }

        managedRepositoryAdmin.addManagedRepository(repoConfig, false, null);

        // Setup target (proxied to) repository.
        saveRemoteRepositoryConfig(ID_PROXIED1, "Proxied Repository 1",
                new File(REPOPATH_PROXIED1).toURL().toExternalForm(), "default");

        // Setup target (proxied to) repository.
        saveRemoteRepositoryConfig(ID_PROXIED2, "Proxied Repository 2",
                new File(REPOPATH_PROXIED2).toURL().toExternalForm(), "default");

        // Setup the proxy handler.
        //proxyHandler = applicationContext.getBean (RepositoryProxyConnectors) lookup( RepositoryProxyConnectors.class.getName() );

        proxyHandler = applicationContext.getBean("repositoryProxyConnectors#test",
                RepositoryProxyConnectors.class);

        // Setup the wagon mock.
        wagonMockControl = EasyMock.createNiceControl();
        wagonMock = wagonMockControl.createMock(Wagon.class);

        delegate = (WagonDelegate) applicationContext.getBean("wagon#test", Wagon.class);

        delegate.setDelegate(wagonMock);

        CacheManager.getInstance().clearAll();

        log.info("\n.\\ {}() \\._________________________________________\n", name);
    }

    @After
    public void shutdown() throws Exception {
        removeMavenIndexes();
    }

    protected void removeMavenIndexes() throws Exception {
        NexusIndexer nexusIndexer = plexusSisuBridge.lookup(NexusIndexer.class);

        for (IndexingContext indexingContext : nexusIndexer.getIndexingContexts().values()) {
            nexusIndexer.removeIndexingContext(indexingContext, false);
        }
    }

    /*
    protected static final ArgumentsMatcher customWagonGetIfNewerMatcher = new ArgumentsMatcher()
    {
        
    public boolean matches( Object[] expected, Object[] actual )
    {
        if ( expected.length < 1 || actual.length < 1 )
        {
            return false;
        }
        return MockControl.ARRAY_MATCHER.matches( ArrayUtils.remove( expected, 1 ),
                                                  ArrayUtils.remove( actual, 1 ) );
    }
        
    public String toString( Object[] arguments )
    {
        return ArrayUtils.toString( arguments );
    }
    };
        
    protected static final ArgumentsMatcher customWagonGetMatcher = new ArgumentsMatcher()
    {
        
    public boolean matches( Object[] expected, Object[] actual )
    {
        if ( expected.length == 2 && actual.length == 2 )
        {
            if ( expected[0] == null && actual[0] == null )
            {
                return true;
            }
        
            if ( expected[0] == null )
            {
                return actual[0] == null;
            }
        
            if ( actual[0] == null )
            {
                return expected[0] == null;
            }
        
            return expected[0].equals( actual[0] );
        }
        return false;
    }
        
    public String toString( Object[] arguments )
    {
        return ArrayUtils.toString( arguments );
    }
    };
    */

    protected void assertChecksums(File expectedFile, String expectedSha1Contents, String expectedMd5Contents)
            throws Exception {
        File sha1File = new File(expectedFile.getAbsolutePath() + ".sha1");
        File md5File = new File(expectedFile.getAbsolutePath() + ".md5");

        if (expectedSha1Contents == null) {
            assertFalse("SHA1 File should NOT exist: " + sha1File.getPath(), sha1File.exists());
        } else {
            assertTrue("SHA1 File should exist: " + sha1File.getPath(), sha1File.exists());
            String actualSha1Contents = readChecksumFile(sha1File);
            assertEquals("SHA1 File contents: " + sha1File.getPath(), expectedSha1Contents, actualSha1Contents);
        }

        if (expectedMd5Contents == null) {
            assertFalse("MD5 File should NOT exist: " + md5File.getPath(), md5File.exists());
        } else {
            assertTrue("MD5 File should exist: " + md5File.getPath(), md5File.exists());
            String actualMd5Contents = readChecksumFile(md5File);
            assertEquals("MD5 File contents: " + md5File.getPath(), expectedMd5Contents, actualMd5Contents);
        }
    }

    protected void assertFileEquals(File expectedFile, File actualFile, File sourceFile) throws Exception {
        assertNotNull("Expected File should not be null.", expectedFile);
        assertNotNull("Actual File should not be null.", actualFile);

        assertTrue("Check actual file exists.", actualFile.exists());
        assertEquals("Check filename path is appropriate.", expectedFile.getCanonicalPath(),
                actualFile.getCanonicalPath());
        assertEquals("Check file path matches.", expectedFile.getAbsolutePath(), actualFile.getAbsolutePath());

        String expectedContents = org.apache.commons.io.FileUtils.readFileToString(sourceFile,
                Charset.defaultCharset());
        String actualContents = org.apache.commons.io.FileUtils.readFileToString(actualFile,
                Charset.defaultCharset());
        assertEquals("Check file contents.", expectedContents, actualContents);
    }

    protected void assertNotDownloaded(File downloadedFile) {
        assertNull("Found file: " + downloadedFile + "; but was expecting a failure", downloadedFile);
    }

    @SuppressWarnings("unchecked")
    protected void assertNoTempFiles(File expectedFile) {
        File workingDir = expectedFile.getParentFile();
        if ((workingDir == null) || !workingDir.isDirectory()) {
            return;
        }

        Collection<File> tmpFiles = org.apache.commons.io.FileUtils.listFiles(workingDir, new String[] { "tmp" },
                false);
        if (!tmpFiles.isEmpty()) {
            StringBuilder emsg = new StringBuilder();
            emsg.append("Found Temp Files in dir: ").append(workingDir.getPath());
            for (File tfile : tmpFiles) {
                emsg.append("\n   ").append(tfile.getName());
            }
            fail(emsg.toString());
        }
    }

    /**
     * A faster recursive copy that omits .svn directories.
     *
     * @param sourceDirectory the source directory to copy
     * @param destDirectory   the target location
     * @throws java.io.IOException if there is a copying problem
     * @todo get back into plexus-utils, share with converter module
     */
    protected void copyDirectoryStructure(File sourceDirectory, File destDirectory) throws IOException {
        if (!sourceDirectory.exists()) {
            throw new IOException("Source directory doesn't exists (" + sourceDirectory.getAbsolutePath() + ").");
        }

        File[] files = sourceDirectory.listFiles();

        String sourcePath = sourceDirectory.getAbsolutePath();

        for (int i = 0; i < files.length; i++) {
            File file = files[i];

            String dest = file.getAbsolutePath();

            dest = dest.substring(sourcePath.length() + 1);

            File destination = new File(destDirectory, dest);

            if (file.isFile()) {
                destination = destination.getParentFile();

                org.apache.commons.io.FileUtils.copyFile(file, new File(destination, file.getName()), false);
                // TODO: Change when there is a FileUtils.copyFileToDirectory(file, destination, boolean) option
                //FileUtils.copyFileToDirectory( file, destination );
            } else if (file.isDirectory()) {
                if (!".svn".equals(file.getName())) {
                    if (!destination.exists() && !destination.mkdirs()) {
                        throw new IOException(
                                "Could not create destination directory '" + destination.getAbsolutePath() + "'.");
                    }

                    copyDirectoryStructure(file, destination);
                }
            } else {
                throw new IOException("Unknown file type: " + file.getAbsolutePath());
            }
        }
    }

    protected ManagedRepositoryContent createRepository(String id, String name, String path, String layout)
            throws Exception {
        ManagedRepository repo = new ManagedRepository();
        repo.setId(id);
        repo.setName(name);
        repo.setLocation(path);
        repo.setLayout(layout);

        ManagedRepositoryContent repoContent = applicationContext.getBean("managedRepositoryContent#" + layout,
                ManagedRepositoryContent.class);
        repoContent.setRepository(repo);
        return repoContent;
    }

    /**
     * Read the first line from the checksum file, and return it (trimmed).
     */
    protected String readChecksumFile(File checksumFile) throws Exception {
        FileReader freader = null;
        BufferedReader buf = null;

        try {
            freader = new FileReader(checksumFile);
            buf = new BufferedReader(freader);
            return buf.readLine();
        } finally {
            if (buf != null) {
                buf.close();
            }

            if (freader != null) {
                freader.close();
            }
        }
    }

    protected void saveConnector(String sourceRepoId, String targetRepoId, boolean disabled) {
        saveConnector(sourceRepoId, targetRepoId, ChecksumPolicy.IGNORE, ReleasesPolicy.ALWAYS,
                SnapshotsPolicy.ALWAYS, CachedFailuresPolicy.NO, disabled);
    }

    protected void saveConnector(String sourceRepoId, String targetRepoId, String checksumPolicy,
            String releasePolicy, String snapshotPolicy, String cacheFailuresPolicy, boolean disabled) {
        saveConnector(sourceRepoId, targetRepoId, checksumPolicy, releasePolicy, snapshotPolicy,
                cacheFailuresPolicy, PropagateErrorsDownloadPolicy.QUEUE, disabled);
    }

    protected void saveConnector(String sourceRepoId, String targetRepoId, String checksumPolicy,
            String releasePolicy, String snapshotPolicy, String cacheFailuresPolicy, String errorPolicy,
            boolean disabled) {
        saveConnector(sourceRepoId, targetRepoId, checksumPolicy, releasePolicy, snapshotPolicy,
                cacheFailuresPolicy, errorPolicy, PropagateErrorsOnUpdateDownloadPolicy.NOT_PRESENT, disabled);
    }

    protected void saveConnector(String sourceRepoId, String targetRepoId, String checksumPolicy,
            String releasePolicy, String snapshotPolicy, String cacheFailuresPolicy, String errorPolicy,
            String errorOnUpdatePolicy, boolean disabled) {
        ProxyConnectorConfiguration connectorConfig = new ProxyConnectorConfiguration();
        connectorConfig.setSourceRepoId(sourceRepoId);
        connectorConfig.setTargetRepoId(targetRepoId);
        connectorConfig.addPolicy(ProxyConnectorConfiguration.POLICY_CHECKSUM, checksumPolicy);
        connectorConfig.addPolicy(ProxyConnectorConfiguration.POLICY_RELEASES, releasePolicy);
        connectorConfig.addPolicy(ProxyConnectorConfiguration.POLICY_SNAPSHOTS, snapshotPolicy);
        connectorConfig.addPolicy(ProxyConnectorConfiguration.POLICY_CACHE_FAILURES, cacheFailuresPolicy);
        connectorConfig.addPolicy(ProxyConnectorConfiguration.POLICY_PROPAGATE_ERRORS, errorPolicy);
        connectorConfig.addPolicy(ProxyConnectorConfiguration.POLICY_PROPAGATE_ERRORS_ON_UPDATE,
                errorOnUpdatePolicy);
        connectorConfig.setDisabled(disabled);

        int count = config.getConfiguration().getProxyConnectors().size();
        config.getConfiguration().addProxyConnector(connectorConfig);

        // Proper Triggering ...
        String prefix = "proxyConnectors.proxyConnector(" + count + ")";
        config.triggerChange(prefix + ".sourceRepoId", connectorConfig.getSourceRepoId());
        config.triggerChange(prefix + ".targetRepoId", connectorConfig.getTargetRepoId());
        config.triggerChange(prefix + ".proxyId", connectorConfig.getProxyId());
        config.triggerChange(prefix + ".policies.releases", connectorConfig.getPolicy("releases", ""));
        config.triggerChange(prefix + ".policies.checksum", connectorConfig.getPolicy("checksum", ""));
        config.triggerChange(prefix + ".policies.snapshots", connectorConfig.getPolicy("snapshots", ""));
        config.triggerChange(prefix + ".policies.cache-failures", connectorConfig.getPolicy("cache-failures", ""));
        config.triggerChange(prefix + ".policies.propagate-errors",
                connectorConfig.getPolicy("propagate-errors", ""));
        config.triggerChange(prefix + ".policies.propagate-errors-on-update",
                connectorConfig.getPolicy("propagate-errors-on-update", ""));
    }

    protected void saveManagedRepositoryConfig(String id, String name, String path, String layout) {
        ManagedRepositoryConfiguration repoConfig = new ManagedRepositoryConfiguration();

        repoConfig.setId(id);
        repoConfig.setName(name);
        repoConfig.setLayout(layout);

        repoConfig.setLocation(path);

        int count = config.getConfiguration().getManagedRepositories().size();
        config.getConfiguration().addManagedRepository(repoConfig);

        String prefix = "managedRepositories.managedRepository(" + count + ")";
        config.triggerChange(prefix + ".id", repoConfig.getId());
        config.triggerChange(prefix + ".name", repoConfig.getName());
        config.triggerChange(prefix + ".location", repoConfig.getLocation());
        config.triggerChange(prefix + ".layout", repoConfig.getLayout());
    }

    protected void saveRemoteRepositoryConfig(String id, String name, String url, String layout) {
        RemoteRepositoryConfiguration repoConfig = new RemoteRepositoryConfiguration();

        repoConfig.setId(id);
        repoConfig.setName(name);
        repoConfig.setLayout(layout);
        repoConfig.setUrl(url);

        int count = config.getConfiguration().getRemoteRepositories().size();
        config.getConfiguration().addRemoteRepository(repoConfig);

        String prefix = "remoteRepositories.remoteRepository(" + count + ")";
        config.triggerChange(prefix + ".id", repoConfig.getId());
        config.triggerChange(prefix + ".name", repoConfig.getName());
        config.triggerChange(prefix + ".url", repoConfig.getUrl());
        config.triggerChange(prefix + ".layout", repoConfig.getLayout());
    }

    protected File saveTargetedRepositoryConfig(String id, String originalPath, String targetPath, String layout)
            throws IOException {
        File repoLocation = new File(targetPath);
        FileUtils.deleteDirectory(repoLocation);
        copyDirectoryStructure(new File(originalPath), repoLocation);

        saveRemoteRepositoryConfig(id, "Target Repo-" + id, targetPath, layout);

        return repoLocation;
    }

    /**
     * Copy the specified resource directory from the src/test/repository/managed/ to
     * the testable directory under target/test-repository/managed/${testName}/
     *
     * @param resourcePath
     * @throws IOException
     */
    protected void setupTestableManagedRepository(String resourcePath) throws IOException {
        String resourceDir = resourcePath;

        if (!resourcePath.endsWith("/")) {
            int idx = resourcePath.lastIndexOf('/');
            resourceDir = resourcePath.substring(0, idx);
        }

        File sourceRepoDir = new File(REPOPATH_DEFAULT_MANAGED);
        File sourceDir = new File(sourceRepoDir, resourceDir);

        File destRepoDir = managedDefaultDir;
        File destDir = new File(destRepoDir, resourceDir);

        // Cleanout destination dirs.
        if (destDir.exists()) {
            FileUtils.deleteDirectory(destDir);
        }

        // Make the destination dir.
        destDir.mkdirs();

        // Test the source dir.
        if (!sourceDir.exists()) {
            // This is just a warning.
            log.error("[WARN] Skipping setup of testable managed repository, source dir does not exist: {}", //
                    sourceDir);
        } else {

            // Test that the source is a dir.
            if (!sourceDir.isDirectory()) {
                fail("Unable to setup testable managed repository, source is not a directory: " + sourceDir);
            }

            // Copy directory structure.
            copyDirectoryStructure(sourceDir, destDir);
        }
    }

    protected void setManagedNewerThanRemote(File managedFile, File remoteFile) {
        setManagedNewerThanRemote(managedFile, remoteFile, 55000);
    }

    protected void setManagedNewerThanRemote(File managedFile, File remoteFile, long time) {
        assertTrue("Managed File should exist: ", managedFile.exists());
        assertTrue("Remote File should exist: ", remoteFile.exists());

        managedFile.setLastModified(remoteFile.lastModified() + time);

        assertTrue(managedFile.lastModified() > remoteFile.lastModified());
    }

    protected void setManagedOlderThanRemote(File managedFile, File remoteFile) {
        setManagedOlderThanRemote(managedFile, remoteFile, 55000);
    }

    protected void setManagedOlderThanRemote(File managedFile, File remoteFile, long time) {
        assertTrue("Managed File should exist: ", managedFile.exists());
        assertTrue("Remote File should exist: ", remoteFile.exists());

        managedFile.setLastModified(remoteFile.lastModified() - time);

        assertTrue(managedFile.lastModified() < remoteFile.lastModified());

    }

    protected void assertNotModified(File file, long expectedModificationTime) {
        assertEquals("File <" + file.getAbsolutePath() + "> not have been modified.", expectedModificationTime,
                file.lastModified());
    }

    protected void assertNotExistsInManagedDefaultRepo(File file) throws Exception {
        String managedDefaultPath = managedDefaultDir.getCanonicalPath();
        String testFile = file.getCanonicalPath();

        assertTrue("Unit Test Failure: File <" + testFile
                + "> should be have been defined within the managed default path of <" + managedDefaultPath + ">",
                testFile.startsWith(managedDefaultPath));

        assertFalse("File < " + testFile + "> should not exist in managed default repository.", file.exists());
    }

    protected static Date getFutureDate() throws ParseException {
        Calendar cal = Calendar.getInstance();
        cal.add(Calendar.YEAR, 1);
        return cal.getTime();
    }

    protected static Date getPastDate() throws ParseException {
        return new SimpleDateFormat("yyyy-MM-dd", Locale.US).parse("2000-01-01");
    }
}