JcrRepositoryStatisticsGatheringTest.java

package org.apache.archiva.metadata.repository.stats;

/*
 * 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 junit.framework.TestCase;
import org.apache.archiva.metadata.repository.MetadataRepository;
import org.apache.archiva.metadata.repository.RepositorySessionFactory;
import org.apache.commons.io.FileUtils;
import org.apache.jackrabbit.commons.JcrUtils;
import org.apache.jackrabbit.core.TransientRepository;

import javax.inject.Inject;
import javax.jcr.ImportUUIDBehavior;
import javax.jcr.NamespaceRegistry;
import javax.jcr.Node;
import javax.jcr.RepositoryException;
import javax.jcr.Session;
import javax.jcr.SimpleCredentials;
import javax.jcr.Workspace;
import javax.jcr.nodetype.NodeTypeManager;
import javax.jcr.nodetype.NodeTypeTemplate;
import java.io.File;
import java.io.IOException;
import java.util.Calendar;
import java.util.Date;
import java.util.zip.GZIPInputStream;

import org.apache.archiva.test.utils.ArchivaBlockJUnit4ClassRunner;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;

import static org.mockito.Mockito.*;

@RunWith( ArchivaBlockJUnit4ClassRunner.class )
public class JcrRepositoryStatisticsGatheringTest
    extends TestCase
{
    private static final int TOTAL_FILE_COUNT = 1000;

    private static final int NEW_FILE_COUNT = 500;

    private static final String TEST_REPO = "test-repo";

    private RepositoryStatisticsManager repositoryStatisticsManager;

    private MetadataRepository metadataRepository;

    @Inject
    private RepositorySessionFactory repositorySessionFactory;

    private Session session;

    @Override
    @Before
    public void setUp()
        throws Exception
    {
        super.setUp();

        File confFile = new File( "src/test/repository.xml" );
        File dir = new File( "target/jcr" );
        FileUtils.deleteDirectory( dir );

        assertTrue( confFile.exists() );
        assertFalse( dir.exists() );

        TransientRepository repository = new TransientRepository( confFile, dir );
        session = repository.login( new SimpleCredentials( "username", "password".toCharArray() ) );

        // TODO: perhaps have an archiva-jcr-utils module shared by these plugins that does this and can contain
        //      structure information
        Workspace workspace = session.getWorkspace();
        NamespaceRegistry registry = workspace.getNamespaceRegistry();
        registry.registerNamespace( "archiva", "http://archiva.apache.org/jcr/" );

        NodeTypeManager nodeTypeManager = workspace.getNodeTypeManager();
        registerMixinNodeType( nodeTypeManager, "archiva:namespace" );
        registerMixinNodeType( nodeTypeManager, "archiva:project" );
        registerMixinNodeType( nodeTypeManager, "archiva:projectVersion" );
        registerMixinNodeType( nodeTypeManager, "archiva:artifact" );
        registerMixinNodeType( nodeTypeManager, "archiva:facet" );

        metadataRepository = mock( MetadataRepository.class );
        when( metadataRepository.canObtainAccess( Session.class ) ).thenReturn( true );
        when( metadataRepository.obtainAccess( Session.class ) ).thenReturn( session );

        repositoryStatisticsManager = new DefaultRepositoryStatisticsManager();
    }

    private static void registerMixinNodeType( NodeTypeManager nodeTypeManager, String type )
        throws RepositoryException
    {
        NodeTypeTemplate nodeType = nodeTypeManager.createNodeTypeTemplate();
        nodeType.setMixin( true );
        nodeType.setName( type );
        nodeTypeManager.registerNodeType( nodeType, false );
    }

    @Override
    @After
    public void tearDown()
        throws Exception
    {
        if ( session != null )
        {
            session.logout();
        }

        super.tearDown();
    }

    @Test
    public void testJcrStatisticsQuery()
        throws Exception
    {
        Calendar cal = Calendar.getInstance();
        Date endTime = cal.getTime();
        cal.add( Calendar.HOUR, -1 );
        Date startTime = cal.getTime();

        loadContentIntoRepo( TEST_REPO );
        loadContentIntoRepo( "another-repo" );

        repositoryStatisticsManager.addStatisticsAfterScan( metadataRepository, TEST_REPO, startTime, endTime,
                                                            TOTAL_FILE_COUNT, NEW_FILE_COUNT );

        RepositoryStatistics expectedStatistics = new RepositoryStatistics();
        expectedStatistics.setNewFileCount( NEW_FILE_COUNT );
        expectedStatistics.setTotalFileCount( TOTAL_FILE_COUNT );
        expectedStatistics.setScanEndTime( endTime );
        expectedStatistics.setScanStartTime( startTime );
        expectedStatistics.setTotalArtifactFileSize( 95954585 );
        expectedStatistics.setTotalArtifactCount( 269 );
        expectedStatistics.setTotalGroupCount( 1 );
        expectedStatistics.setTotalProjectCount( 43 );
        expectedStatistics.setTotalCountForType( "zip", 1 );
        expectedStatistics.setTotalCountForType( "gz", 1 ); // FIXME: should be tar.gz
        expectedStatistics.setTotalCountForType( "java-source", 10 );
        expectedStatistics.setTotalCountForType( "jar", 108 );
        expectedStatistics.setTotalCountForType( "xml", 3 );
        expectedStatistics.setTotalCountForType( "war", 2 );
        expectedStatistics.setTotalCountForType( "pom", 144 );
        expectedStatistics.setRepositoryId( TEST_REPO );

        verify( metadataRepository ).addMetadataFacet( TEST_REPO, expectedStatistics );
    }

    private void loadContentIntoRepo( String repoId )
        throws RepositoryException, IOException
    {
        Node n = JcrUtils.getOrAddNode( session.getRootNode(), "repositories" );
        n = JcrUtils.getOrAddNode( n, repoId );
        n = JcrUtils.getOrAddNode( n, "content" );
        n = JcrUtils.getOrAddNode( n, "org" );
        n = JcrUtils.getOrAddNode( n, "apache" );

        GZIPInputStream inputStream = new GZIPInputStream( getClass().getResourceAsStream( "/artifacts.xml.gz" ) );
        session.importXML( n.getPath(), inputStream, ImportUUIDBehavior.IMPORT_UUID_CREATE_NEW );
        session.save();
    }
}