archiva/archiva-modules/archiva-base/archiva-repository-layer/src/test/java/org/apache/archiva/repository/RepositoryRegistryTest.java

package org.apache.archiva.repository;

/*
 * 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 org.apache.archiva.configuration.ArchivaConfiguration;
import org.apache.archiva.configuration.Configuration;
import org.apache.archiva.configuration.ManagedRepositoryConfiguration;
import org.apache.archiva.configuration.RemoteRepositoryConfiguration;
import org.apache.archiva.test.utils.ArchivaSpringJUnit4ClassRunner;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;

import javax.inject.Inject;
import java.io.IOException;
import java.net.URISyntaxException;
import java.net.URL;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.util.Collection;

import static org.junit.Assert.*;

/**
 * Test for RepositoryRegistry
 */
@RunWith(ArchivaSpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { "classpath*:/META-INF/spring-context.xml", "classpath:/spring-context.xml" })
public class RepositoryRegistryTest
{

    @Inject
    RepositoryRegistry repositoryRegistry;

    @Inject
    ArchivaConfiguration archivaConfiguration;

    private static final Path userCfg = Paths.get(System.getProperty( "user.home" ), ".m2/archiva.xml");

    private static Path cfgCopy;
    private static Path archivaCfg;

    @BeforeClass
    public static void classSetup() throws IOException, URISyntaxException
    {
        URL archivaCfgUri = Thread.currentThread().getContextClassLoader().getResource( "archiva.xml" );
        if (archivaCfgUri!=null) {
            archivaCfg = Paths.get(archivaCfgUri.toURI());
            cfgCopy = Files.createTempFile( "archiva-backup", ".xml" );
            Files.copy( archivaCfg, cfgCopy, StandardCopyOption.REPLACE_EXISTING);
        }
    }

    @AfterClass
    public static void classTearDown() throws IOException
    {
        if (cfgCopy!=null) {
            Files.deleteIfExists( cfgCopy );
        }
    }

    @Before
    public void setUp( ) throws Exception
    {
        assertNotNull( repositoryRegistry );
        Files.deleteIfExists( userCfg );
        URL archivaCfgUri = Thread.currentThread().getContextClassLoader().getResource( "archiva.xml" );
        if (archivaCfgUri!=null) {
            archivaCfg = Paths.get(archivaCfgUri.toURI());
            if (Files.exists(cfgCopy))
            {
                Files.copy( cfgCopy, archivaCfg , StandardCopyOption.REPLACE_EXISTING);
            }
        }
        archivaConfiguration.reload();
        repositoryRegistry.reload();
    }

    @After
    public void tearDown( ) throws Exception
    {
        Files.deleteIfExists( userCfg );
        if (cfgCopy!=null && Files.exists(cfgCopy)) {
            Files.copy(cfgCopy, archivaCfg, StandardCopyOption.REPLACE_EXISTING);
        }
    }

    @Test
    public void getRepositories( ) throws Exception
    {
        Collection<Repository> repos = repositoryRegistry.getRepositories( );
        assertEquals( 5, repos.size( ) );
        assertTrue(repos.stream().anyMatch( rep -> rep.getId().equals("internal") ));
        assertTrue( repos.stream( ).anyMatch( rep -> rep.getId( ).equals( "snapshots") ) );
        assertTrue(repos.stream().anyMatch( rep -> rep.getId().equals( "central") ));
    }

    @Test
    public void getManagedRepositories( ) throws Exception
    {
        Collection<ManagedRepository> repos = repositoryRegistry.getManagedRepositories();
        assertEquals( 4, repos.size( ) );
        assertTrue(repos.stream().anyMatch( rep -> rep.getId().equals("internal") ));
        assertTrue( repos.stream( ).anyMatch( rep -> rep.getId( ).equals( "snapshots") ) );
    }

    @Test
    public void getRemoteRepositories( ) throws Exception
    {
        Collection<RemoteRepository> repos = repositoryRegistry.getRemoteRepositories( );
        assertEquals( 1, repos.size( ) );
        assertTrue(repos.stream().anyMatch( rep -> rep.getId().equals( "central") ));
    }

    @Test
    public void getRepository( ) throws Exception
    {
        Repository repo = repositoryRegistry.getRepository( "internal" );
        assertNotNull(repo);
        assertEquals("internal", repo.getId());
        assertEquals("Archiva Managed Internal Repository", repo.getName());
        assertEquals("This is internal repository.", repo.getDescription());
        assertEquals( "default", repo.getLayout( ) );
        assertEquals("0 0 * * * ?", repo.getSchedulingDefinition());
        assertTrue(repo instanceof ManagedRepository);
        assertTrue( repo.hasIndex( ) );
        assertTrue(repo.isScanned());
        assertEquals(RepositoryType.MAVEN, repo.getType());
    }

    @Test
    public void getManagedRepository( ) throws Exception
    {
        ManagedRepository repo = repositoryRegistry.getManagedRepository( "internal" );
        assertNotNull(repo);
        assertEquals("internal", repo.getId());
        assertEquals("Archiva Managed Internal Repository", repo.getName());
        assertEquals("This is internal repository.", repo.getDescription());
        assertEquals( "default", repo.getLayout( ) );
        assertEquals("0 0 * * * ?", repo.getSchedulingDefinition());
        assertTrue( repo.hasIndex( ) );
        assertTrue(repo.isScanned());
        assertEquals(RepositoryType.MAVEN, repo.getType());
        assertTrue(repo.getActiveReleaseSchemes().contains(ReleaseScheme.RELEASE));
        assertFalse( repo.getActiveReleaseSchemes( ).contains( ReleaseScheme.SNAPSHOT ) );
        assertNotNull(repo.getContent());

        assertNull(repositoryRegistry.getManagedRepository( "xyu" ));

    }

    @Test
    public void getRemoteRepository( ) throws Exception
    {
        RemoteRepository repo = repositoryRegistry.getRemoteRepository( "central" );
        assertNotNull(repo);
        assertEquals("central", repo.getId());
        assertEquals("Central Repository", repo.getName());
        assertEquals("", repo.getDescription());
        assertEquals( "default", repo.getLayout( ) );
        assertEquals("0 0 08 ? * SUN", repo.getSchedulingDefinition());
        assertTrue( repo.hasIndex( ) );
        assertTrue(repo.isScanned());
        assertEquals(RepositoryType.MAVEN, repo.getType());

        assertEquals(35, repo.getTimeout().getSeconds());
    }

    @Test
    public void putManagedRepository( ) throws Exception
    {
        BasicManagedRepository managedRepository = BasicManagedRepository.newFilesystemInstance("test001", "Test repo", archivaConfiguration.getRepositoryBaseDir().resolve("test001"));
        managedRepository.setDescription( managedRepository.getPrimaryLocale(), "This is just a test" );
        repositoryRegistry.putRepository(managedRepository);

        assertNotNull(managedRepository.getContent());
        assertEquals(6, repositoryRegistry.getRepositories().size());

        managedRepository = BasicManagedRepository.newFilesystemInstance("central", "Test repo", archivaConfiguration.getRepositoryBaseDir().resolve("central"));
        managedRepository.setDescription( managedRepository.getPrimaryLocale(), "This is just a test" );
        ManagedRepository updatedRepo = null;
        try {
            repositoryRegistry.putRepository( managedRepository );
            throw new RuntimeException("Repository exception should be thrown, if there exists a remote repository already with that id");
        } catch (RepositoryException e) {
            // OK
        }
        managedRepository = BasicManagedRepository.newFilesystemInstance("internal", "Test repo", archivaConfiguration.getRepositoryBaseDir().resolve("internal"));
        managedRepository.setDescription( managedRepository.getPrimaryLocale(), "This is just a test" );
        updatedRepo = repositoryRegistry.putRepository( managedRepository );

        assertTrue(updatedRepo==managedRepository);
        assertNotNull(managedRepository.getContent());
        assertEquals(6, repositoryRegistry.getRepositories().size());
        ManagedRepository managedRepository1 = repositoryRegistry.getManagedRepository( "internal" );
        assertEquals("Test repo", managedRepository1.getName());
        assertTrue(managedRepository1==managedRepository);

    }

    @Test
    public void putManagedRepositoryFromConfig( ) throws Exception
    {
        ManagedRepositoryConfiguration cfg = new ManagedRepositoryConfiguration();
        cfg.setId("test002");
        cfg.setName("This is test 002");
        ManagedRepository repo = repositoryRegistry.putRepository( cfg );
        assertNotNull(repo);
        assertEquals("test002", repo.getId());
        assertEquals("This is test 002", repo.getName());
        assertNotNull(repo.getContent());
        archivaConfiguration.reload();
        Collection<ManagedRepository> repos = repositoryRegistry.getManagedRepositories();
        assertEquals(5, repos.size());

        ManagedRepository internalRepo = repositoryRegistry.getManagedRepository( "internal" );
        cfg = new ManagedRepositoryConfiguration();
        cfg.setId("internal");
        cfg.setName("This is internal test 002");
        repo = repositoryRegistry.putRepository( cfg );
        assertTrue(internalRepo==repo);
        assertEquals("This is internal test 002",repo.getName());
        assertEquals(5, repositoryRegistry.getManagedRepositories().size());

        repositoryRegistry.reload();
        assertEquals(5, repositoryRegistry.getManagedRepositories().size());

    }

    @Test
    public void putManagedRepositoryFromConfigWithoutSave( ) throws Exception
    {
        Configuration configuration = archivaConfiguration.getConfiguration();
        ManagedRepositoryConfiguration cfg = new ManagedRepositoryConfiguration();
        cfg.setId("test002");
        cfg.setName("This is test 002");
        ManagedRepository repo = repositoryRegistry.putRepository( cfg, configuration );
        assertNotNull(repo);
        assertEquals("test002", repo.getId());
        assertEquals("This is test 002", repo.getName());
        assertNotNull(repo.getContent());
        archivaConfiguration.reload();
        assertEquals(3, archivaConfiguration.getConfiguration().getManagedRepositories().size());
        Collection<ManagedRepository> repos = repositoryRegistry.getManagedRepositories();
        assertEquals(5, repos.size());

        ManagedRepository internalRepo = repositoryRegistry.getManagedRepository( "internal" );
        cfg = new ManagedRepositoryConfiguration();
        cfg.setId("internal");
        cfg.setName("This is internal test 002");
        repo = repositoryRegistry.putRepository( cfg, configuration );
        assertTrue(internalRepo==repo);
        assertEquals("This is internal test 002",repo.getName());
        assertEquals(5, repositoryRegistry.getManagedRepositories().size());

        repositoryRegistry.reload();
        assertEquals(4, repositoryRegistry.getManagedRepositories().size());
    }

    @Test
    public void putRemoteRepository( ) throws Exception
    {
        BasicRemoteRepository remoteRepository = BasicRemoteRepository.newFilesystemInstance( "test001", "Test repo", archivaConfiguration.getRemoteRepositoryBaseDir() );
        remoteRepository.setDescription( remoteRepository.getPrimaryLocale(), "This is just a test" );
        RemoteRepository newRepo = repositoryRegistry.putRepository(remoteRepository);

        assertTrue(remoteRepository==newRepo);
        assertNotNull(remoteRepository.getContent());
        assertEquals(6, repositoryRegistry.getRepositories().size());

        remoteRepository = BasicRemoteRepository.newFilesystemInstance( "internal", "Test repo", archivaConfiguration.getRemoteRepositoryBaseDir() );
        remoteRepository.setDescription( remoteRepository.getPrimaryLocale(), "This is just a test" );
        RemoteRepository updatedRepo = null;
        try
        {
            updatedRepo = repositoryRegistry.putRepository( remoteRepository );
            throw new RuntimeException("Should throw repository exception, if repository exists already and is not the same type.");
        } catch (RepositoryException e) {
            // OK
        }

        remoteRepository = BasicRemoteRepository.newFilesystemInstance( "central", "Test repo", archivaConfiguration.getRemoteRepositoryBaseDir() );
        remoteRepository.setDescription( remoteRepository.getPrimaryLocale(), "This is just a test" );
        updatedRepo = repositoryRegistry.putRepository( remoteRepository );

        assertTrue(updatedRepo==remoteRepository);
        assertNotNull(remoteRepository.getContent());
        assertEquals(6, repositoryRegistry.getRepositories().size());
        RemoteRepository remoteRepository1 = repositoryRegistry.getRemoteRepository( "central" );
        assertEquals("Test repo", remoteRepository1.getName());
        assertTrue(remoteRepository1==remoteRepository);
    }

    @Test
    public void putRemoteRepositoryFromConfig( ) throws Exception
    {
        RemoteRepositoryConfiguration cfg = new RemoteRepositoryConfiguration();
        cfg.setId("test002");
        cfg.setName("This is test 002");
        RemoteRepository repo = repositoryRegistry.putRepository( cfg );
        assertNotNull(repo);
        assertEquals("test002", repo.getId());
        assertEquals("This is test 002", repo.getName());
        assertNotNull(repo.getContent());
        archivaConfiguration.reload();
        Collection<RemoteRepository> repos = repositoryRegistry.getRemoteRepositories();
        assertEquals(2, repos.size());

        RemoteRepository internalRepo = repositoryRegistry.getRemoteRepository( "central" );
        cfg = new RemoteRepositoryConfiguration();
        cfg.setId("central");
        cfg.setName("This is central test 002");
        repo = repositoryRegistry.putRepository( cfg );
        assertTrue(internalRepo==repo);
        assertEquals("This is central test 002",repo.getName());
        assertEquals(2, repositoryRegistry.getRemoteRepositories().size());

        repositoryRegistry.reload();
        assertEquals(2, repositoryRegistry.getRemoteRepositories().size());
    }

    @Test
    public void putRemoteRepositoryFromConfigWithoutSave( ) throws Exception
    {
        Configuration configuration = archivaConfiguration.getConfiguration();
        RemoteRepositoryConfiguration cfg = new RemoteRepositoryConfiguration();
        cfg.setId("test002");
        cfg.setName("This is test 002");
        RemoteRepository repo = repositoryRegistry.putRepository( cfg, configuration );
        assertNotNull(repo);
        assertEquals("test002", repo.getId());
        assertEquals("This is test 002", repo.getName());
        assertNotNull(repo.getContent());
        archivaConfiguration.reload();
        assertEquals(1, archivaConfiguration.getConfiguration().getRemoteRepositories().size());
        Collection<RemoteRepository> repos = repositoryRegistry.getRemoteRepositories();
        assertEquals(2, repos.size());

        RemoteRepository internalRepo = repositoryRegistry.getRemoteRepository( "central" );
        cfg = new RemoteRepositoryConfiguration();
        cfg.setId("central");
        cfg.setName("This is central test 002");
        repo = repositoryRegistry.putRepository( cfg, configuration );
        assertTrue(internalRepo==repo);
        assertEquals("This is central test 002",repo.getName());
        assertEquals(2, repositoryRegistry.getRemoteRepositories().size());

        repositoryRegistry.reload();
        assertEquals(1, repositoryRegistry.getRemoteRepositories().size());
    }

    @Test
    public void removeRepository( ) throws Exception
    {
        assertEquals(5, repositoryRegistry.getRepositories().size());
        Repository repo = repositoryRegistry.getRepository( "snapshots" );
        repositoryRegistry.removeRepository( repo );
        assertEquals(4, repositoryRegistry.getRepositories().size());
        assertTrue( repositoryRegistry.getRepositories( ).stream( ).noneMatch( rep -> rep.getId( ).equals( "snapshots" ) ) );
        archivaConfiguration.reload();
        repositoryRegistry.reload();
        assertEquals(4, repositoryRegistry.getRepositories().size());
    }

    @Test
    public void removeManagedRepository( ) throws Exception
    {

        assertEquals(4, repositoryRegistry.getManagedRepositories().size());
        ManagedRepository repo = repositoryRegistry.getManagedRepository( "snapshots" );
        repositoryRegistry.removeRepository( repo );
        assertEquals(3, repositoryRegistry.getManagedRepositories().size());
        assertTrue( repositoryRegistry.getManagedRepositories( ).stream( ).noneMatch( rep -> rep.getId( ).equals( "snapshots" ) ) );
        archivaConfiguration.reload();
        repositoryRegistry.reload();
        assertEquals(3, repositoryRegistry.getManagedRepositories().size());
    }

    @Test
    public void removeManagedRepositoryWithoutSave( ) throws Exception
    {
        Configuration configuration = archivaConfiguration.getConfiguration();
        assertEquals(4, repositoryRegistry.getManagedRepositories().size());
        ManagedRepository repo = repositoryRegistry.getManagedRepository( "snapshots" );
        repositoryRegistry.removeRepository( repo, configuration );
        assertEquals(3, repositoryRegistry.getManagedRepositories().size());
        assertTrue( repositoryRegistry.getManagedRepositories( ).stream( ).noneMatch( rep -> rep.getId( ).equals( "snapshots" ) ) );
        archivaConfiguration.reload();
        repositoryRegistry.reload();
        assertEquals(4, repositoryRegistry.getManagedRepositories().size());
    }


    @Test
    public void removeRemoteRepository( ) throws Exception
    {
        assertEquals(1, repositoryRegistry.getRemoteRepositories().size());
        RemoteRepository repo = repositoryRegistry.getRemoteRepository( "central" );
        repositoryRegistry.removeRepository( repo );
        assertEquals(0, repositoryRegistry.getRemoteRepositories().size());
        assertTrue( repositoryRegistry.getRemoteRepositories( ).stream( ).noneMatch( rep -> rep.getId( ).equals( "central" ) ) );
        archivaConfiguration.reload();
        repositoryRegistry.reload();
        assertEquals(0, repositoryRegistry.getRemoteRepositories().size());
    }

    @Test
    public void removeRemoteRepositoryWithoutSave( ) throws Exception
    {
        Configuration configuration = archivaConfiguration.getConfiguration();
        assertEquals(1, repositoryRegistry.getRemoteRepositories().size());
        RemoteRepository repo = repositoryRegistry.getRemoteRepository( "central" );
        repositoryRegistry.removeRepository( repo, configuration );
        assertEquals(0, repositoryRegistry.getRemoteRepositories().size());
        assertTrue( repositoryRegistry.getRemoteRepositories( ).stream( ).noneMatch( rep -> rep.getId( ).equals( "central" ) ) );
        archivaConfiguration.reload();
        repositoryRegistry.reload();
        assertEquals(1, repositoryRegistry.getRemoteRepositories().size());
    }


    @Test
    public void cloneManagedRepo( ) throws Exception
    {
        ManagedRepository managedRepository = repositoryRegistry.getManagedRepository( "internal" );

        try
        {
            repositoryRegistry.clone(managedRepository, "snapshots");
            throw new RuntimeException("RepositoryRegistry exception should be thrown if id exists already.");
        }
        catch ( RepositoryException e )
        {
            // OK
        }

        try
        {
            repositoryRegistry.clone(managedRepository, "central");
            throw new RuntimeException("RepositoryRegistry exception should be thrown if id exists already.");
        }
        catch ( RepositoryException e )
        {
            // OK
        }

        ManagedRepository clone = repositoryRegistry.clone( managedRepository, "newinternal" );
        assertNotNull(clone);
        assertNull(clone.getContent());
        assertEquals("Archiva Managed Internal Repository", clone.getName());
        assertFalse(managedRepository==clone);

    }

    @Test
    public void cloneRemoteRepo( ) throws Exception
    {
        RemoteRepository remoteRepository = repositoryRegistry.getRemoteRepository( "central" );

        try
        {
            repositoryRegistry.clone(remoteRepository, "snapshots");
            throw new RuntimeException("RepositoryRegistry exception should be thrown if id exists already.");
        }
        catch ( RepositoryException e )
        {
            // OK
        }

        try
        {
            repositoryRegistry.clone(remoteRepository, "central");
            throw new RuntimeException("RepositoryRegistry exception should be thrown if id exists already.");
        }
        catch ( RepositoryException e )
        {
            // OK
        }

        RemoteRepository clone = repositoryRegistry.clone( remoteRepository, "newCentral" );
        assertNotNull(clone);
        assertNull(clone.getContent());
        assertEquals("Central Repository", clone.getName());
        assertFalse(remoteRepository==clone);

    }

}