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

   1 package org.apache.archiva.repository.mock;
   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 org.apache.archiva.model.ArtifactReference;
  23 import org.apache.archiva.model.ProjectReference;
  24 import org.apache.archiva.model.VersionedReference;
  25 import org.apache.archiva.repository.ContentAccessException;
  26 import org.apache.archiva.repository.ContentNotFoundException;
  27 import org.apache.archiva.repository.ManagedRepositoryContent;
  28 import org.apache.archiva.repository.ItemDeleteStatus;
  29 import org.apache.archiva.repository.LayoutException;
  30 import org.apache.archiva.repository.ManagedRepository;
  31 import org.apache.archiva.repository.BaseRepositoryContentLayout;
  32 import org.apache.archiva.repository.ManagedRepositoryContentLayout;
  33 import org.apache.archiva.repository.content.Artifact;
  34 import org.apache.archiva.repository.content.BaseDataItemTypes;
  35 import org.apache.archiva.repository.content.ContentItem;
  36 import org.apache.archiva.repository.content.DataItem;
  37 import org.apache.archiva.repository.content.ItemNotFoundException;
  38 import org.apache.archiva.repository.content.ItemSelector;
  39 import org.apache.archiva.repository.content.Namespace;
  40 import org.apache.archiva.repository.content.Project;
  41 import org.apache.archiva.repository.content.Version;
  42 import org.apache.archiva.repository.content.base.ArchivaContentItem;
  43 import org.apache.archiva.repository.content.base.ArchivaDataItem;
  44 import org.apache.archiva.repository.content.base.ArchivaNamespace;
  45 import org.apache.archiva.repository.content.base.ArchivaProject;
  46 import org.apache.archiva.repository.content.base.ArchivaVersion;
  47 import org.apache.archiva.repository.storage.StorageAsset;
  48 import org.springframework.stereotype.Service;
  49
  50 import java.nio.file.Path;
  51 import java.util.List;
  52 import java.util.function.Consumer;
  53 import java.util.stream.Stream;
  54
  55 /**
  56  * @author Martin Stockhammer <martin_s@apache.org>
  57  */
  58 @Service("managedRepositoryContent#mock")
  59 public class ManagedRepositoryContentMock implements BaseRepositoryContentLayout, ManagedRepositoryContent
  60 {
  61     private ManagedRepository repository;
  62
  63     @Override
  64     public VersionedReference toVersion( String groupId, String artifactId, String version )
  65     {
  66         return null;
  67     }
  68
  69     @Override
  70     public VersionedReference toVersion( ArtifactReference artifactReference )
  71     {
  72         return null;
  73     }
  74
  75     @Override
  76     public void deleteAllItems( ItemSelector selector, Consumer<ItemDeleteStatus> consumer ) throws ContentAccessException, IllegalArgumentException
  77     {
  78
  79     }
  80
  81     @Override
  82     public <T extends ContentItem> T adaptItem( Class<T> clazz, ContentItem item ) throws LayoutException
  83     {
  84         if (clazz.isAssignableFrom( Version.class ))
  85         {
  86             if ( !item.hasCharacteristic( Version.class ) )
  87             {
  88                 item.setCharacteristic( Version.class, createVersionFromPath( item.getAsset() ) );
  89             }
  90             return (T) item.adapt( Version.class );
  91         } else if ( clazz.isAssignableFrom( Project.class )) {
  92             if ( !item.hasCharacteristic( Project.class ) )
  93             {
  94                 item.setCharacteristic( Project.class, createProjectFromPath( item.getAsset() ) );
  95             }
  96             return (T) item.adapt( Project.class );
  97         } else if ( clazz.isAssignableFrom( Namespace.class )) {
  98             if ( !item.hasCharacteristic( Namespace.class ) )
  99             {
 100                 item.setCharacteristic( Namespace.class, createNamespaceFromPath( item.getAsset() ) );
 101             }
 102             return (T) item.adapt( Namespace.class );
 103         }
 104         throw new LayoutException( "Could not convert item to class " + clazz);
 105     }
 106
 107     private Version createVersionFromPath( StorageAsset asset )
 108     {
 109         Project proj = createProjectFromPath( asset.getParent( ) );
 110         return ArchivaVersion.withRepository( this ).withAsset( asset )
 111             .withProject( proj ).withVersion( asset.getName( ) ).build();
 112     }
 113
 114     private Project createProjectFromPath( StorageAsset asset)  {
 115         Namespace ns = createNamespaceFromPath( asset );
 116         return ArchivaProject.withRepository( this ).withAsset( asset )
 117             .withNamespace( ns ).withId( asset.getName( ) ).build( );
 118     }
 119
 120     private Namespace createNamespaceFromPath( StorageAsset asset) {
 121         String namespace = asset.getPath( ).replace( "/", "." );
 122         return ArchivaNamespace.withRepository( this )
 123             .withAsset( asset ).withNamespace( namespace ).build();
 124     }
 125
 126
 127     @Override
 128     public void deleteItem( ContentItem item ) throws ItemNotFoundException, ContentAccessException
 129     {
 130
 131     }
 132
 133     @Override
 134     public ContentItem getItem( ItemSelector selector ) throws ContentAccessException, IllegalArgumentException
 135     {
 136         return null;
 137     }
 138
 139     @Override
 140     public Namespace getNamespace( ItemSelector namespaceSelector ) throws ContentAccessException, IllegalArgumentException
 141     {
 142         return null;
 143     }
 144
 145     @Override
 146     public Project getProject( ItemSelector projectSelector ) throws ContentAccessException, IllegalArgumentException
 147     {
 148         return null;
 149     }
 150
 151
 152     @Override
 153     public void deleteVersion( VersionedReference reference ) throws ContentNotFoundException, ContentAccessException
 154     {
 155
 156     }
 157
 158
 159     @Override
 160     public Version getVersion( ItemSelector versionCoordinates ) throws ContentAccessException, IllegalArgumentException
 161     {
 162         return null;
 163     }
 164
 165     @Override
 166     public void deleteArtifact( ArtifactReference artifactReference ) throws ContentNotFoundException, ContentAccessException
 167     {
 168
 169     }
 170
 171
 172     @Override
 173     public Artifact getArtifact( ItemSelector selector ) throws ContentAccessException
 174     {
 175         return null;
 176     }
 177
 178     @Override
 179     public List<? extends Artifact> getArtifacts( ItemSelector selector ) throws ContentAccessException
 180     {
 181         return null;
 182     }
 183
 184     @Override
 185     public Stream<? extends Artifact> newArtifactStream( ItemSelector selector ) throws ContentAccessException
 186     {
 187         return null;
 188     }
 189
 190     @Override
 191     public Stream<? extends ContentItem> newItemStream( ItemSelector selector, boolean parallel ) throws ContentAccessException, IllegalArgumentException
 192     {
 193         return null;
 194     }
 195
 196     @Override
 197     public List<? extends Project> getProjects( Namespace namespace ) throws ContentAccessException
 198     {
 199         return null;
 200     }
 201
 202     @Override
 203     public List<? extends Project> getProjects( ItemSelector selector ) throws ContentAccessException, IllegalArgumentException
 204     {
 205         return null;
 206     }
 207
 208     @Override
 209     public List<? extends Version> getVersions( Project project ) throws ContentAccessException
 210     {
 211         return null;
 212     }
 213
 214     @Override
 215     public List<? extends Version> getVersions( ItemSelector selector ) throws ContentAccessException, IllegalArgumentException
 216     {
 217         return null;
 218     }
 219
 220     @Override
 221     public List<String> getArtifactVersions( ItemSelector selector ) throws ContentAccessException, IllegalArgumentException
 222     {
 223         return null;
 224     }
 225
 226     @Override
 227     public List<? extends Artifact> getArtifacts( ContentItem item ) throws ContentAccessException
 228     {
 229         return null;
 230     }
 231
 232     @Override
 233     public Stream<? extends Artifact> newArtifactStream( ContentItem item ) throws ContentAccessException
 234     {
 235         return null;
 236     }
 237
 238     @Override
 239     public boolean hasContent( ItemSelector selector )
 240     {
 241         return false;
 242     }
 243
 244     @Override
 245     public ContentItem getParent( ContentItem item )
 246     {
 247         try
 248         {
 249             return toItem( item.getAsset( ).getParent( ) );
 250         }
 251         catch ( LayoutException e )
 252         {
 253             throw new RuntimeException( "Bad layout error " + e.getMessage( ) );
 254         }
 255     }
 256
 257     @Override
 258     public List<? extends ContentItem> getChildren( ContentItem item )
 259     {
 260         return null;
 261     }
 262
 263     @Override
 264     public <T extends ContentItem> T applyCharacteristic( Class<T> clazz, ContentItem item ) throws LayoutException
 265     {
 266         return null;
 267     }
 268
 269     @Override
 270     public <T extends ManagedRepositoryContentLayout> T getLayout( Class<T> clazz ) throws LayoutException
 271     {
 272         return null;
 273     }
 274
 275     @Override
 276     public <T extends ManagedRepositoryContentLayout> boolean supportsLayout( Class<T> clazz )
 277     {
 278         return false;
 279     }
 280
 281     @Override
 282     public void addArtifact( Path sourceFile, Artifact destination ) throws IllegalArgumentException
 283     {
 284
 285     }
 286
 287     @Override
 288     public DataItem getMetadataItem( Version version )
 289     {
 290         return ArchivaDataItem.withAsset( version.getAsset( ).resolve( "maven-metadata.xml" ) ).withId( "maven-metadata.xml" )
 291             .withDataType( BaseDataItemTypes.METADATA ).build();
 292     }
 293
 294     @Override
 295     public DataItem getMetadataItem( Project project )
 296     {
 297         return ArchivaDataItem.withAsset( project.getAsset( ).resolve( "maven-metadata.xml" ) ).withId( "maven-metadata.xml" )
 298             .withDataType( BaseDataItemTypes.METADATA ).build( );
 299     }
 300
 301
 302     @Override
 303     public ContentItem toItem( String path ) throws LayoutException
 304     {
 305         StorageAsset asset = repository.getAsset( "" ).resolve( path );
 306         return toItem( asset );
 307     }
 308
 309     @Override
 310     public ContentItem toItem( StorageAsset asset ) throws LayoutException
 311     {
 312         if (asset.isLeaf()) {
 313             return ArchivaDataItem.withAsset( asset ).withId( asset.getName() ).build();
 314         } else
 315         {
 316             return ArchivaContentItem.withRepository( this )
 317                 .withAsset( asset ).build( );
 318         }
 319     }
 320
 321
 322     @Override
 323     public void deleteGroupId( String groupId ) throws ContentNotFoundException, ContentAccessException
 324     {
 325
 326     }
 327
 328
 329     @Override
 330     public void deleteProject( String namespace, String projectId ) throws ContentNotFoundException, ContentAccessException
 331     {
 332
 333     }
 334
 335     @Override
 336     public void deleteProject( ProjectReference reference ) throws ContentNotFoundException, ContentAccessException
 337     {
 338
 339     }
 340
 341     @Override
 342     public String toPath( ContentItem item )
 343     {
 344         return null;
 345     }
 346
 347     @Override
 348     public String getId( )
 349     {
 350         return null;
 351     }
 352
 353     @Override
 354     public List<ArtifactReference> getRelatedArtifacts( VersionedReference reference ) throws ContentNotFoundException, LayoutException, ContentAccessException
 355     {
 356         return null;
 357     }
 358
 359     @Override
 360     public List<ArtifactReference> getArtifacts( VersionedReference reference ) throws ContentNotFoundException, LayoutException, ContentAccessException
 361     {
 362         return null;
 363     }
 364
 365     @Override
 366     public String getRepoRoot( )
 367     {
 368         return null;
 369     }
 370
 371     @Override
 372     public ManagedRepository getRepository( )
 373     {
 374         return repository;
 375     }
 376
 377     @Override
 378     public void setRepository( ManagedRepository repo )
 379     {
 380         this.repository = repo;
 381     }
 382
 383     @Override
 384     public StorageAsset toFile( VersionedReference reference )
 385     {
 386         return null;
 387     }
 388
 389     @Override
 390     public ArtifactReference toArtifactReference( String path ) throws LayoutException
 391     {
 392         return null;
 393     }
 394
 395     @Override
 396     public StorageAsset toFile( ArtifactReference reference )
 397     {
 398         return null;
 399     }
 400
 401     @Override
 402     public String toPath( ArtifactReference reference )
 403     {
 404         return null;
 405     }
 406
 407     @Override
 408     public String toPath( ItemSelector selector )
 409     {
 410         return null;
 411     }
 412
 413     @Override
 414     public ItemSelector toItemSelector( String path ) throws LayoutException
 415     {
 416         return null;
 417     }
 418
 419     @Override
 420     public ManagedRepositoryContent getGenericContent( )
 421     {
 422         return null;
 423     }
 424 }