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

   1 package org.apache.maven.repository.reporting;
   2
   3 /*
   4  * Copyright 2005-2006 The Apache Software Foundation.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  *      http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  */
  18
  19 import org.apache.maven.artifact.Artifact;
  20 import org.apache.maven.artifact.DefaultArtifact;
  21 import org.apache.maven.artifact.handler.ArtifactHandler;
  22 import org.apache.maven.artifact.handler.DefaultArtifactHandler;
  23 import org.apache.maven.artifact.repository.metadata.ArtifactRepositoryMetadata;
  24 import org.apache.maven.artifact.repository.metadata.GroupRepositoryMetadata;
  25 import org.apache.maven.artifact.repository.metadata.RepositoryMetadata;
  26 import org.apache.maven.artifact.repository.metadata.SnapshotArtifactRepositoryMetadata;
  27 import org.apache.maven.artifact.versioning.VersionRange;
  28
  29 import java.io.File;
  30 import java.util.Iterator;
  31
  32 /**
  33  * This class tests the ChecksumArtifactReporter.
  34  * It extends the AbstractChecksumArtifactReporterTest class.
  35  */
  36 public class ChecksumArtifactReporterTest
  37     extends AbstractChecksumArtifactReporterTest
  38 {
  39     private ArtifactReportProcessor artifactReportProcessor;
  40
  41     private ArtifactReporter reporter = new MockArtifactReporter();
  42
  43     private MetadataReportProcessor metadataReportProcessor;
  44
  45     public ChecksumArtifactReporterTest()
  46     {
  47
  48     }
  49
  50     public void setUp()
  51         throws Exception
  52     {
  53         super.setUp();
  54         artifactReportProcessor = (ArtifactReportProcessor) lookup( ArtifactReportProcessor.ROLE, "checksum" );
  55         metadataReportProcessor = (MetadataReportProcessor) lookup( MetadataReportProcessor.ROLE, "checksum-metadata" );
  56     }
  57
  58     public void tearDown()
  59         throws Exception
  60     {
  61         super.tearDown();
  62     }
  63
  64     /**
  65      * Test creation of artifact with checksum files.
  66      */
  67     public void testCreateChecksumFile()
  68     {
  69         assertTrue( createChecksumFile( "VALID" ) );
  70         assertTrue( createChecksumFile( "INVALID" ) );
  71     }
  72
  73     /**
  74      * Test creation of metadata file together with its checksums.
  75      */
  76     public void testCreateMetadataFile()
  77     {
  78         assertTrue( createMetadataFile( "VALID" ) );
  79         assertTrue( createMetadataFile( "INVALID" ) );
  80     }
  81
  82     /**
  83      * Test the ChecksumArtifactReporter when the checksum files are valid.
  84      */
  85     public void testChecksumArtifactReporterSuccess()
  86     {
  87         try
  88         {
  89             ArtifactHandler handler = new DefaultArtifactHandler( "jar" );
  90             VersionRange version = VersionRange.createFromVersion( "1.0" );
  91             Artifact artifact =
  92                 new DefaultArtifact( "checksumTest", "validArtifact", version, "compile", "jar", "", handler );
  93
  94             artifactReportProcessor.processArtifact( null, artifact, reporter, repository );
  95             assertTrue( reporter.getSuccesses() == 2 );
  96             //System.out.println( "1 - SUCCESS ---> " + reporter.getSuccesses() );
  97
  98         }
  99         catch ( Exception e )
 100         {
 101             e.printStackTrace();
 102         }
 103     }
 104
 105     /**
 106      * Test the ChecksumArtifactReporter when the checksum files are invalid.
 107      */
 108     public void testChecksumArtifactReporterFailed()
 109     {
 110
 111         try
 112         {
 113             ArtifactHandler handler = new DefaultArtifactHandler( "jar" );
 114             VersionRange version = VersionRange.createFromVersion( "1.0" );
 115             Artifact artifact =
 116                 new DefaultArtifact( "checksumTest", "invalidArtifact", version, "compile", "jar", "", handler );
 117
 118             artifactReportProcessor.processArtifact( null, artifact, reporter, repository );
 119             assertTrue( reporter.getFailures() == 2 );
 120             //System.out.println( "2 - FAILURES ---> " + reporter.getFailures() );
 121         }
 122         catch ( Exception e )
 123         {
 124             e.printStackTrace();
 125         }
 126     }
 127
 128     /**
 129      * Test the valid checksum of a metadata file.
 130      * The reporter should report 2 success validation.
 131      */
 132     public void testChecksumMetadataReporterSuccess()
 133     {
 134
 135         try
 136         {
 137             ArtifactHandler handler = new DefaultArtifactHandler( "jar" );
 138             VersionRange version = VersionRange.createFromVersion( "1.0" );
 139             Artifact artifact =
 140                 new DefaultArtifact( "checksumTest", "validArtifact", version, "compile", "jar", "", handler );
 141
 142             //Version level metadata
 143             RepositoryMetadata metadata = new SnapshotArtifactRepositoryMetadata( artifact );
 144             metadataReportProcessor.processMetadata( metadata, repository, reporter );
 145
 146             //Artifact level metadata
 147             metadata = new ArtifactRepositoryMetadata( artifact );
 148             metadataReportProcessor.processMetadata( metadata, repository, reporter );
 149
 150             //Group level metadata
 151             metadata = new GroupRepositoryMetadata( "checksumTest" );
 152             metadataReportProcessor.processMetadata( metadata, repository, reporter );
 153
 154             Iterator iter = reporter.getRepositoryMetadataSuccessIterator();
 155             //System.out.println( "3 - META SUCCESS ---> " + iter.hasNext() );
 156             assertTrue( "check if there is a success", iter.hasNext() );
 157
 158         }
 159         catch ( Exception e )
 160         {
 161             e.printStackTrace();
 162         }
 163     }
 164
 165     /**
 166      * Test the corrupted checksum of a metadata file.
 167      * The reporter must report 2 failures.
 168      */
 169     public void testChecksumMetadataReporterFailure()
 170     {
 171
 172         try
 173         {
 174             ArtifactHandler handler = new DefaultArtifactHandler( "jar" );
 175             VersionRange version = VersionRange.createFromVersion( "1.0" );
 176             Artifact artifact =
 177                 new DefaultArtifact( "checksumTest", "invalidArtifact", version, "compile", "jar", "", handler );
 178
 179             RepositoryMetadata metadata = new SnapshotArtifactRepositoryMetadata( artifact );
 180             metadataReportProcessor.processMetadata( metadata, repository, reporter );
 181
 182             //System.out.println("reporter.getFailures() ---> " + reporter.getFailures());
 183
 184             Iterator iter = reporter.getRepositoryMetadataFailureIterator();
 185             //System.out.println( "4 - META FAILURE ---> " + iter.hasNext() );
 186             assertTrue( "check if there is a failure", iter.hasNext() );
 187
 188         }
 189         catch ( Exception e )
 190         {
 191             e.printStackTrace();
 192         }
 193     }
 194
 195     /**
 196      * Test the checksum of an artifact located in a remote location.
 197      */
 198     /*   public void testChecksumArtifactRemote()
 199     {
 200         ArtifactHandler handler = new DefaultArtifactHandler( remoteArtifactType );
 201         VersionRange version = VersionRange.createFromVersion( remoteArtifactVersion );
 202         Artifact artifact = new DefaultArtifact( remoteArtifactGroup, remoteArtifactId, version, remoteArtifactScope,
 203                                                  remoteArtifactType, "", handler );
 204         ArtifactRepository repository = new DefaultArtifactRepository( remoteRepoId, remoteRepoUrl,
 205                                                                        new DefaultRepositoryLayout() );
 206
 207         artifactReportProcessor.processArtifact( null, artifact, reporter, repository );
 208         if ( reporter.getFailures() == 2 )
 209             assertTrue( reporter.getFailures() == 2 );
 210
 211         if ( reporter.getSuccesses() == 2 )
 212             assertTrue( reporter.getSuccesses() == 2 );
 213
 214     }
 215     */
 216
 217     /**
 218      * Test the checksum of a metadata file located in a remote location.
 219      */
 220     /*   public void testChecksumMetadataRemote()
 221     {
 222
 223         try
 224         {
 225             ArtifactHandler handler = new DefaultArtifactHandler( remoteArtifactType );
 226             VersionRange version = VersionRange.createFromVersion( remoteArtifactVersion );
 227             Artifact artifact = new DefaultArtifact( remoteArtifactGroup, remoteArtifactId, version,
 228                                                      remoteArtifactScope, remoteArtifactType, "", handler );
 229             ArtifactRepository repository = new DefaultArtifactRepository( remoteRepoId, remoteRepoUrl,
 230                                                                            new DefaultRepositoryLayout() );
 231
 232             RepositoryMetadata metadata = new SnapshotArtifactRepositoryMetadata( artifact );
 233
 234             metadataReportProcessor.processMetadata( metadata, repository, reporter );
 235             Iterator iter = reporter.getRepositoryMetadataFailureIterator();
 236             if ( iter.hasNext() )
 237                 assertTrue( "check if there is a failure", iter.hasNext() );
 238
 239             iter = reporter.getRepositoryMetadataSuccessIterator();
 240             if ( iter.hasNext() )
 241                 assertTrue( "check if there is a success", iter.hasNext() );
 242
 243         }
 244         catch ( Exception e )
 245         {
 246             e.printStackTrace();
 247         }
 248     }
 249     */
 250
 251     /**
 252      * Test deletion of the test directories created.
 253      */
 254     public void testDeleteChecksumFiles()
 255     {
 256         assertTrue( deleteChecksumFiles( "jar" ) );
 257     }
 258
 259     /**
 260      * Test deletion of the test directories created.
 261      */
 262     public void testDeleteTestDirectory()
 263     {
 264         assertTrue( deleteTestDirectory( new File( repository.getBasedir() + "checksumTest" ) ) );
 265     }
 266
 267     /**
 268      * Test the conditional when the checksum files of the artifact & metadata do not exist.
 269      */
 270     public void testChecksumFilesDoNotExist()
 271     {
 272         createChecksumFile( "VALID" );
 273         createMetadataFile( "VALID" );
 274         boolean b = deleteChecksumFiles( "jar" );
 275
 276         try
 277         {
 278             ArtifactHandler handler = new DefaultArtifactHandler( "jar" );
 279             VersionRange version = VersionRange.createFromVersion( "1.0" );
 280             Artifact artifact =
 281                 new DefaultArtifact( "checksumTest", "validArtifact", version, "compile", "jar", "", handler );
 282
 283             artifactReportProcessor.processArtifact( null, artifact, reporter, repository );
 284             //System.out.println( "5 - ART FAILURE ---> " + reporter.getFailures() );
 285             assertTrue( reporter.getFailures() == 2 );
 286
 287             RepositoryMetadata metadata = new SnapshotArtifactRepositoryMetadata( artifact );
 288             metadataReportProcessor.processMetadata( metadata, repository, reporter );
 289
 290             Iterator iter = reporter.getRepositoryMetadataFailureIterator();
 291             //System.out.println( "5 - META FAILURE ---> " + iter.hasNext() );
 292             assertTrue( "check if there is a failure", iter.hasNext() );
 293
 294         }
 295         catch ( Exception e )
 296         {
 297             e.printStackTrace();
 298         }
 299
 300         b = deleteTestDirectory( new File( repository.getBasedir() + "checksumTest" ) );
 301     }
 302 }