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