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

   1 package org.apache.archiva.rss.processor;
   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 com.sun.syndication.feed.synd.SyndEntry;
  23 import com.sun.syndication.feed.synd.SyndFeed;
  24 import junit.framework.TestCase;
  25 import org.apache.archiva.metadata.model.ArtifactMetadata;
  26 import org.apache.archiva.metadata.model.MetadataFacet;
  27 import org.apache.archiva.metadata.model.ProjectMetadata;
  28 import org.apache.archiva.metadata.model.ProjectVersionMetadata;
  29 import org.apache.archiva.metadata.model.ProjectVersionReference;
  30 import org.apache.archiva.metadata.repository.MetadataRepository;
  31 import org.apache.archiva.metadata.repository.MetadataRepositoryException;
  32 import org.apache.archiva.metadata.repository.MetadataResolutionException;
  33 import org.apache.archiva.rss.RssFeedGenerator;
  34 import org.apache.archiva.test.utils.ArchivaBlockJUnit4ClassRunner;
  35 import org.junit.Before;
  36 import org.junit.Test;
  37 import org.junit.runner.RunWith;
  38
  39 import java.util.ArrayList;
  40 import java.util.Calendar;
  41 import java.util.Collection;
  42 import java.util.Date;
  43 import java.util.HashMap;
  44 import java.util.List;
  45 import java.util.Map;
  46 import java.util.TimeZone;
  47
  48 @RunWith (ArchivaBlockJUnit4ClassRunner.class)
  49 public class NewArtifactsRssFeedProcessorTest
  50     extends TestCase
  51 {
  52     private static final String TEST_REPO = "test-repo";
  53
  54     private NewArtifactsRssFeedProcessor newArtifactsProcessor;
  55
  56     private MetadataRepositoryMock metadataRepository;
  57
  58     @Before
  59     public void setUp()
  60         throws Exception
  61     {
  62         super.setUp();
  63
  64         newArtifactsProcessor = new NewArtifactsRssFeedProcessor();
  65         newArtifactsProcessor.setGenerator( new RssFeedGenerator() );
  66
  67         metadataRepository = new MetadataRepositoryMock();
  68     }
  69
  70     @SuppressWarnings ("unchecked")
  71     @Test
  72     public void testProcess()
  73         throws Exception
  74     {
  75         List<ArtifactMetadata> newArtifacts = new ArrayList<ArtifactMetadata>();
  76         Date whenGathered = Calendar.getInstance().getTime();
  77
  78         newArtifacts.add( createArtifact( "artifact-one", "1.0", whenGathered ) );
  79         newArtifacts.add( createArtifact( "artifact-one", "1.1", whenGathered ) );
  80         newArtifacts.add( createArtifact( "artifact-one", "2.0", whenGathered ) );
  81         newArtifacts.add( createArtifact( "artifact-two", "1.0.1", whenGathered ) );
  82         newArtifacts.add( createArtifact( "artifact-two", "1.0.2", whenGathered ) );
  83         newArtifacts.add( createArtifact( "artifact-two", "1.0.3-SNAPSHOT", whenGathered ) );
  84         newArtifacts.add( createArtifact( "artifact-three", "2.0-SNAPSHOT", whenGathered ) );
  85         newArtifacts.add( createArtifact( "artifact-four", "1.1-beta-2", whenGathered ) );
  86
  87         metadataRepository.setArtifactsByDateRange( newArtifacts );
  88
  89         Map<String, String> reqParams = new HashMap<String, String>();
  90         reqParams.put( RssFeedProcessor.KEY_REPO_ID, TEST_REPO );
  91
  92         SyndFeed feed = newArtifactsProcessor.process( reqParams, metadataRepository );
  93
  94         // check that the date used in the call is close to the one passed (5 seconds difference at most)
  95         Calendar cal = Calendar.getInstance( TimeZone.getTimeZone( "GMT" ) );
  96         cal.add( Calendar.DATE, -30 );
  97         assertTrue( ( metadataRepository.getFrom().getTime() - cal.getTimeInMillis() ) < 1000 * 5 );
  98         assertEquals( null, metadataRepository.getTo() );
  99         assertEquals( TEST_REPO, metadataRepository.getRepoId() );
 100
 101         assertTrue( feed.getTitle().equals( "New Artifacts in Repository 'test-repo'" ) );
 102         assertTrue(
 103             feed.getDescription().equals( "New artifacts found in repository 'test-repo' during repository scan." ) );
 104         assertTrue( feed.getLanguage().equals( "en-us" ) );
 105         assertTrue( feed.getPublishedDate().equals( whenGathered ) );
 106
 107         List<SyndEntry> entries = feed.getEntries();
 108         assertEquals( entries.size(), 1 );
 109         assertTrue(
 110             entries.get( 0 ).getTitle().equals( "New Artifacts in Repository 'test-repo' as of " + whenGathered ) );
 111         assertTrue( entries.get( 0 ).getPublishedDate().equals( whenGathered ) );
 112     }
 113
 114     private ArtifactMetadata createArtifact( String artifactId, String version, Date whenGathered )
 115     {
 116         ArtifactMetadata artifact = new ArtifactMetadata();
 117         artifact.setNamespace( "org.apache.archiva" );
 118         artifact.setId( artifactId + "-" + version + ".jar" );
 119         artifact.setRepositoryId( TEST_REPO );
 120         artifact.setWhenGathered( whenGathered );
 121         artifact.setProject( artifactId );
 122         artifact.setProjectVersion( version );
 123         artifact.setVersion( version );
 124         return artifact;
 125     }
 126
 127     // TODO: replace with mockito
 128     private class MetadataRepositoryMock
 129         implements MetadataRepository
 130     {
 131         private Date from, to;
 132
 133         private String repoId;
 134
 135         private List<ArtifactMetadata> artifactsByDateRange;
 136
 137         public List<ArtifactMetadata> getArtifactsByDateRange( String repoId, Date from, Date to )
 138         {
 139             setRepoId( repoId );
 140             setFrom( from );
 141             setTo( to );
 142             return artifactsByDateRange;
 143         }
 144
 145         public void removeArtifact( String repositoryId, String namespace, String project, String version,
 146                                     MetadataFacet metadataFacet )
 147             throws MetadataRepositoryException
 148         {
 149             throw new UnsupportedOperationException();
 150         }
 151
 152         public void addMetadataFacet( String arg0, MetadataFacet arg1 )
 153         {
 154             throw new UnsupportedOperationException();
 155         }
 156
 157         public void removeArtifact( String arg0, String arg1, String arg2, String arg3, String arg4 )
 158         {
 159             throw new UnsupportedOperationException();
 160         }
 161
 162         public void removeRepository( String arg0 )
 163         {
 164             throw new UnsupportedOperationException();
 165         }
 166
 167         public List<ArtifactMetadata> getArtifactsByChecksum( String arg0, String arg1 )
 168         {
 169             throw new UnsupportedOperationException();
 170         }
 171
 172         public MetadataFacet getMetadataFacet( String arg0, String arg1, String arg2 )
 173         {
 174             throw new UnsupportedOperationException();
 175         }
 176
 177         public List<String> getMetadataFacets( String arg0, String arg1 )
 178         {
 179             throw new UnsupportedOperationException();
 180         }
 181
 182         public Collection<String> getRepositories()
 183         {
 184             throw new UnsupportedOperationException();
 185         }
 186
 187         public void removeMetadataFacet( String arg0, String arg1, String arg2 )
 188         {
 189             throw new UnsupportedOperationException();
 190         }
 191
 192         public void removeMetadataFacets( String arg0, String arg1 )
 193         {
 194             throw new UnsupportedOperationException();
 195         }
 196
 197         public void updateArtifact( String arg0, String arg1, String arg2, String arg3, ArtifactMetadata arg4 )
 198         {
 199             throw new UnsupportedOperationException();
 200         }
 201
 202         public void updateNamespace( String arg0, String arg1 )
 203         {
 204             throw new UnsupportedOperationException();
 205         }
 206
 207         public void updateProject( String arg0, ProjectMetadata arg1 )
 208         {
 209             throw new UnsupportedOperationException();
 210         }
 211
 212         public void updateProjectVersion( String arg0, String arg1, String arg2, ProjectVersionMetadata arg3 )
 213         {
 214             throw new UnsupportedOperationException();
 215         }
 216
 217         public Collection<String> getArtifactVersions( String arg0, String arg1, String arg2, String arg3 )
 218         {
 219             throw new UnsupportedOperationException();
 220         }
 221
 222         public Collection<ArtifactMetadata> getArtifacts( String arg0, String arg1, String arg2, String arg3 )
 223         {
 224             throw new UnsupportedOperationException();
 225         }
 226
 227         public void save()
 228         {
 229             throw new UnsupportedOperationException();
 230         }
 231
 232         public void close()
 233         {
 234             throw new UnsupportedOperationException();
 235         }
 236
 237         public boolean hasMetadataFacet( String repositoryId, String facetId )
 238             throws MetadataRepositoryException
 239         {
 240             return false;
 241         }
 242
 243         public void revert()
 244         {
 245             throw new UnsupportedOperationException();
 246         }
 247
 248         public boolean canObtainAccess( Class<?> aClass )
 249         {
 250             return false;
 251         }
 252
 253         public Object obtainAccess( Class<?> aClass )
 254         {
 255             throw new UnsupportedOperationException();
 256         }
 257
 258         public Collection<String> getNamespaces( String arg0, String arg1 )
 259         {
 260             throw new UnsupportedOperationException();
 261         }
 262
 263         public ProjectMetadata getProject( String arg0, String arg1, String arg2 )
 264         {
 265             throw new UnsupportedOperationException();
 266         }
 267
 268         public Collection<ProjectVersionReference> getProjectReferences( String arg0, String arg1, String arg2,
 269                                                                          String arg3 )
 270         {
 271             throw new UnsupportedOperationException();
 272         }
 273
 274         public ProjectVersionMetadata getProjectVersion( String arg0, String arg1, String arg2, String arg3 )
 275             throws MetadataResolutionException
 276         {
 277             throw new UnsupportedOperationException();
 278         }
 279
 280         public Collection<String> getProjectVersions( String arg0, String arg1, String arg2 )
 281         {
 282             throw new UnsupportedOperationException();
 283         }
 284
 285         public Collection<String> getProjects( String arg0, String arg1 )
 286         {
 287             throw new UnsupportedOperationException();
 288         }
 289
 290         public Collection<String> getRootNamespaces( String arg0 )
 291         {
 292             throw new UnsupportedOperationException();
 293         }
 294
 295         public void removeProject( String repositoryId, String namespace, String projectId )
 296             throws MetadataRepositoryException
 297         {
 298             throw new UnsupportedOperationException();
 299         }
 300
 301         public void setFrom( Date from )
 302         {
 303             this.from = from;
 304         }
 305
 306         public Date getFrom()
 307         {
 308             return from;
 309         }
 310
 311         public void setTo( Date to )
 312         {
 313             this.to = to;
 314         }
 315
 316         public Date getTo()
 317         {
 318             return to;
 319         }
 320
 321         public void setRepoId( String repoId )
 322         {
 323             this.repoId = repoId;
 324         }
 325
 326         public String getRepoId()
 327         {
 328             return repoId;
 329         }
 330
 331         public void setArtifactsByDateRange( List<ArtifactMetadata> artifactsByDateRange )
 332         {
 333             this.artifactsByDateRange = artifactsByDateRange;
 334         }
 335
 336         public List<ArtifactMetadata> getArtifacts( String repositoryId )
 337         {
 338             return artifactsByDateRange;
 339         }
 340
 341         public void removeArtifact( ArtifactMetadata artifactMetadata, String baseVersion )
 342             throws MetadataRepositoryException
 343         {
 344
 345         }
 346
 347         public void removeNamespace( String repositoryId, String namespace )
 348             throws MetadataRepositoryException
 349         {
 350
 351         }
 352
 353         public void removeProjectVersion( String repoId, String namespace, String projectId, String projectVersion )
 354             throws MetadataRepositoryException
 355         {
 356
 357         }
 358     }
 359 }