source.dussan.org Git - archiva.git/blob

   1 package org.apache.archiva.reports.consumers;
   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 junit.framework.TestCase;
  23 import org.apache.archiva.admin.model.beans.ManagedRepository;
  24 import org.apache.archiva.metadata.model.ArtifactMetadata;
  25 import org.apache.archiva.metadata.model.MetadataFacet;
  26 import org.apache.archiva.metadata.repository.MetadataRepository;
  27 import org.apache.archiva.metadata.repository.RepositorySession;
  28 import org.apache.archiva.metadata.repository.RepositorySessionFactory;
  29 import org.apache.archiva.metadata.repository.storage.RepositoryPathTranslator;
  30 import org.apache.archiva.reports.RepositoryProblemFacet;
  31 import org.apache.archiva.consumers.ConsumerException;
  32 import org.junit.Before;
  33 import org.junit.Test;
  34 import org.junit.runner.RunWith;
  35 import org.mockito.ArgumentCaptor;
  36 import org.mockito.Matchers;
  37 import org.springframework.context.ApplicationContext;
  38 import org.springframework.test.context.ContextConfiguration;
  39
  40 import javax.inject.Inject;
  41 import javax.inject.Named;
  42 import java.io.File;
  43 import java.io.FileNotFoundException;
  44 import java.nio.file.NoSuchFileException;
  45 import java.util.Arrays;
  46 import java.util.Date;
  47 import org.apache.archiva.test.utils.ArchivaSpringJUnit4ClassRunner;
  48
  49 import static org.mockito.Mockito.*;
  50 import org.springframework.test.annotation.DirtiesContext;
  51
  52 @SuppressWarnings( { "ThrowableInstanceNeverThrown" } )
  53 @RunWith( ArchivaSpringJUnit4ClassRunner.class )
  54 @ContextConfiguration( locations = { "classpath*:/META-INF/spring-context.xml", "classpath:/spring-context.xml" } )
  55 @DirtiesContext( classMode = DirtiesContext.ClassMode.AFTER_EACH_TEST_METHOD )
  56 public class DuplicateArtifactsConsumerTest
  57     extends TestCase
  58 {
  59     @Inject
  60     @Named( value = "knownRepositoryContentConsumer#duplicate-artifacts" )
  61     private DuplicateArtifactsConsumer consumer;
  62
  63     private ManagedRepository config;
  64
  65     private MetadataRepository metadataRepository;
  66
  67     private static final String TEST_REPO = "test-repo";
  68
  69     private static final String TEST_CHECKSUM = "edf5938e646956f445c6ecb719d44579cdeed974";
  70
  71     private static final String TEST_PROJECT = "test-artifact";
  72
  73     private static final String TEST_NAMESPACE = "com.example.test";
  74
  75     private static final String TEST_FILE =
  76         "com/example/test/test-artifact/1.0-SNAPSHOT/test-artifact-1.0-20100308.230825-1.jar";
  77
  78     private static final String TEST_VERSION = "1.0-20100308.230825-1";
  79
  80     private static final ArtifactMetadata TEST_METADATA = createMetadata( TEST_VERSION );
  81
  82     @Inject
  83     @Named( value = "repositoryPathTranslator#maven2" )
  84     private RepositoryPathTranslator pathTranslator;
  85
  86     @Inject
  87     ApplicationContext applicationContext;
  88
  89
  90     @Before
  91     @Override
  92     public void setUp()
  93         throws Exception
  94     {
  95         super.setUp();
  96
  97         assertNotNull( consumer );
  98
  99         config = new ManagedRepository();
 100         config.setId( TEST_REPO );
 101         config.setLocation( new File( "target/test-repository" ).getAbsolutePath() );
 102
 103         metadataRepository = mock( MetadataRepository.class );
 104
 105         RepositorySession session = mock( RepositorySession.class );
 106         when( session.getRepository() ).thenReturn( metadataRepository );
 107
 108         RepositorySessionFactory factory = applicationContext.getBean( RepositorySessionFactory.class );
 109         //(RepositorySessionFactory) lookup( RepositorySessionFactory.class );
 110         when( factory.createSession() ).thenReturn( session );
 111
 112         when( pathTranslator.getArtifactForPath( TEST_REPO, TEST_FILE ) ).thenReturn( TEST_METADATA );
 113     }
 114
 115     @Test
 116     public void testConsumerArtifactNotDuplicated()
 117         throws Exception
 118     {
 119         when( metadataRepository.getArtifactsByChecksum( TEST_REPO, TEST_CHECKSUM ) ).thenReturn(
 120             Arrays.asList( TEST_METADATA ) );
 121
 122         consumer.beginScan( config, new Date() );
 123         consumer.processFile( TEST_FILE );
 124         consumer.completeScan();
 125
 126         verify( metadataRepository, never() ).addMetadataFacet( eq( TEST_REPO ), Matchers.<MetadataFacet>anyObject() );
 127     }
 128
 129     // TODO: Doesn't currently work
 130 //    public void testConsumerArtifactNotDuplicatedForOtherSnapshots()
 131 //        throws ConsumerException
 132 //    {
 133 //        when( metadataRepository.getArtifactsByChecksum( TEST_REPO, TEST_CHECKSUM ) ).thenReturn( Arrays.asList(
 134 //            TEST_METADATA, createMetadata( "1.0-20100309.002023-2" ) ) );
 135 //
 136 //        consumer.beginScan( config, new Date() );
 137 //        consumer.processFile( TEST_FILE );
 138 //        consumer.completeScan();
 139 //
 140 //        verify( metadataRepository, never() ).addMetadataFacet( eq( TEST_REPO ), Matchers.<MetadataFacet>anyObject() );
 141 //    }
 142
 143     @Test
 144     public void testConsumerArtifactDuplicated()
 145         throws Exception
 146     {
 147         when( metadataRepository.getArtifactsByChecksum( TEST_REPO, TEST_CHECKSUM ) ).thenReturn(
 148             Arrays.asList( TEST_METADATA, createMetadata( "1.0" ) ) );
 149
 150         consumer.beginScan( config, new Date() );
 151         consumer.processFile( TEST_FILE );
 152         consumer.completeScan();
 153
 154         ArgumentCaptor<RepositoryProblemFacet> argument = ArgumentCaptor.forClass( RepositoryProblemFacet.class );
 155         verify( metadataRepository ).addMetadataFacet( eq( TEST_REPO ), argument.capture() );
 156         RepositoryProblemFacet problem = argument.getValue();
 157         assertProblem( problem );
 158     }
 159
 160     @Test
 161     public void testConsumerArtifactDuplicatedButSelfNotInMetadataRepository()
 162         throws Exception
 163     {
 164         when( metadataRepository.getArtifactsByChecksum( TEST_REPO, TEST_CHECKSUM ) ).thenReturn(
 165             Arrays.asList( createMetadata( "1.0" ) ) );
 166
 167         consumer.beginScan( config, new Date() );
 168         consumer.processFile( TEST_FILE );
 169         consumer.completeScan();
 170
 171         ArgumentCaptor<RepositoryProblemFacet> argument = ArgumentCaptor.forClass( RepositoryProblemFacet.class );
 172         verify( metadataRepository ).addMetadataFacet( eq( TEST_REPO ), argument.capture() );
 173         RepositoryProblemFacet problem = argument.getValue();
 174         assertProblem( problem );
 175     }
 176
 177     @Test
 178     public void testConsumerArtifactFileNotExist()
 179         throws Exception
 180     {
 181         consumer.beginScan( config, new Date() );
 182         try
 183         {
 184             consumer.processFile( "com/example/test/test-artifact/2.0/test-artifact-2.0.jar" );
 185             fail( "Should have failed to find file" );
 186         }
 187         catch ( ConsumerException e )
 188         {
 189             assertTrue( e.getCause() instanceof NoSuchFileException );
 190         }
 191         finally
 192         {
 193             consumer.completeScan();
 194         }
 195
 196         verify( metadataRepository, never() ).addMetadataFacet( eq( TEST_REPO ), Matchers.<MetadataFacet>anyObject() );
 197     }
 198
 199     @Test
 200     public void testConsumerArtifactNotAnArtifactPathNoResults()
 201         throws Exception
 202     {
 203         consumer.beginScan( config, new Date() );
 204         // No exception unnecessarily for something we can't report on
 205         consumer.processFile( "com/example/invalid-artifact.txt" );
 206         consumer.completeScan();
 207
 208         verify( metadataRepository, never() ).addMetadataFacet( eq( TEST_REPO ), Matchers.<MetadataFacet>anyObject() );
 209     }
 210
 211     @Test
 212     public void testConsumerArtifactNotAnArtifactPathResults()
 213         throws Exception
 214     {
 215         when( metadataRepository.getArtifactsByChecksum( eq( TEST_REPO ), anyString() ) ).thenReturn(
 216             Arrays.asList( TEST_METADATA, createMetadata( "1.0" ) ) );
 217
 218         // override, this feels a little overspecified though
 219         when( pathTranslator.getArtifactForPath( TEST_REPO, "com/example/invalid-artifact.txt" ) ).thenThrow(
 220             new IllegalArgumentException() );
 221
 222         consumer.beginScan( config, new Date() );
 223         // No exception unnecessarily for something we can't report on
 224         consumer.processFile( "com/example/invalid-artifact.txt" );
 225         consumer.completeScan();
 226
 227         verify( metadataRepository, never() ).addMetadataFacet( eq( TEST_REPO ), Matchers.<MetadataFacet>anyObject() );
 228     }
 229
 230     private static void assertProblem( RepositoryProblemFacet problem )
 231     {
 232         assertEquals( TEST_REPO, problem.getRepositoryId() );
 233         assertEquals( TEST_NAMESPACE, problem.getNamespace() );
 234         assertEquals( TEST_PROJECT, problem.getProject() );
 235         assertEquals( TEST_VERSION, problem.getVersion() );
 236         assertEquals( TEST_PROJECT + "-" + TEST_VERSION + ".jar", problem.getId() );
 237         assertNotNull( problem.getMessage() );
 238         assertEquals( "duplicate-artifact", problem.getProblem() );
 239     }
 240
 241     private static ArtifactMetadata createMetadata( String version )
 242     {
 243         ArtifactMetadata artifact = new ArtifactMetadata();
 244         artifact.setId( TEST_PROJECT + "-" + version + ".jar" );
 245         artifact.setNamespace( TEST_NAMESPACE );
 246         artifact.setProject( TEST_PROJECT );
 247         artifact.setProjectVersion( version );
 248         artifact.setVersion( version );
 249         artifact.setRepositoryId( TEST_REPO );
 250         return artifact;
 251     }
 252 }