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 Version getVersion( ItemSelector versionCoordinates ) throws ContentAccessException, IllegalArgumentException
 154     {
 155         return null;
 156     }
 157
 158     @Override
 159     public void deleteArtifact( ArtifactReference artifactReference ) throws ContentNotFoundException, ContentAccessException
 160     {
 161
 162     }
 163
 164
 165     @Override
 166     public Artifact getArtifact( ItemSelector selector ) throws ContentAccessException
 167     {
 168         return null;
 169     }
 170
 171     @Override
 172     public List<? extends Artifact> getArtifacts( ItemSelector selector ) throws ContentAccessException
 173     {
 174         return null;
 175     }
 176
 177     @Override
 178     public Stream<? extends Artifact> newArtifactStream( ItemSelector selector ) throws ContentAccessException
 179     {
 180         return null;
 181     }
 182
 183     @Override
 184     public Stream<? extends ContentItem> newItemStream( ItemSelector selector, boolean parallel ) throws ContentAccessException, IllegalArgumentException
 185     {
 186         return null;
 187     }
 188
 189     @Override
 190     public List<? extends Project> getProjects( Namespace namespace ) throws ContentAccessException
 191     {
 192         return null;
 193     }
 194
 195     @Override
 196     public List<? extends Project> getProjects( ItemSelector selector ) throws ContentAccessException, IllegalArgumentException
 197     {
 198         return null;
 199     }
 200
 201     @Override
 202     public List<? extends Version> getVersions( Project project ) throws ContentAccessException
 203     {
 204         return null;
 205     }
 206
 207     @Override
 208     public List<? extends Version> getVersions( ItemSelector selector ) throws ContentAccessException, IllegalArgumentException
 209     {
 210         return null;
 211     }
 212
 213     @Override
 214     public List<String> getArtifactVersions( ItemSelector selector ) throws ContentAccessException, IllegalArgumentException
 215     {
 216         return null;
 217     }
 218
 219     @Override
 220     public List<? extends Artifact> getArtifacts( ContentItem item ) throws ContentAccessException
 221     {
 222         return null;
 223     }
 224
 225     @Override
 226     public Stream<? extends Artifact> newArtifactStream( ContentItem item ) throws ContentAccessException
 227     {
 228         return null;
 229     }
 230
 231     @Override
 232     public boolean hasContent( ItemSelector selector )
 233     {
 234         return false;
 235     }
 236
 237     @Override
 238     public ContentItem getParent( ContentItem item )
 239     {
 240         try
 241         {
 242             return toItem( item.getAsset( ).getParent( ) );
 243         }
 244         catch ( LayoutException e )
 245         {
 246             throw new RuntimeException( "Bad layout error " + e.getMessage( ) );
 247         }
 248     }
 249
 250     @Override
 251     public List<? extends ContentItem> getChildren( ContentItem item )
 252     {
 253         return null;
 254     }
 255
 256     @Override
 257     public <T extends ContentItem> T applyCharacteristic( Class<T> clazz, ContentItem item ) throws LayoutException
 258     {
 259         return null;
 260     }
 261
 262     @Override
 263     public <T extends ManagedRepositoryContentLayout> T getLayout( Class<T> clazz ) throws LayoutException
 264     {
 265         return null;
 266     }
 267
 268     @Override
 269     public <T extends ManagedRepositoryContentLayout> boolean supportsLayout( Class<T> clazz )
 270     {
 271         return false;
 272     }
 273
 274     @Override
 275     public void addArtifact( Path sourceFile, Artifact destination ) throws IllegalArgumentException
 276     {
 277
 278     }
 279
 280     @Override
 281     public DataItem getMetadataItem( Version version )
 282     {
 283         return ArchivaDataItem.withAsset( version.getAsset( ).resolve( "maven-metadata.xml" ) ).withId( "maven-metadata.xml" )
 284             .withDataType( BaseDataItemTypes.METADATA ).build();
 285     }
 286
 287     @Override
 288     public DataItem getMetadataItem( Project project )
 289     {
 290         return ArchivaDataItem.withAsset( project.getAsset( ).resolve( "maven-metadata.xml" ) ).withId( "maven-metadata.xml" )
 291             .withDataType( BaseDataItemTypes.METADATA ).build( );
 292     }
 293
 294
 295     @Override
 296     public ContentItem toItem( String path ) throws LayoutException
 297     {
 298         StorageAsset asset = repository.getAsset( "" ).resolve( path );
 299         return toItem( asset );
 300     }
 301
 302     @Override
 303     public ContentItem toItem( StorageAsset asset ) throws LayoutException
 304     {
 305         if (asset.isLeaf()) {
 306             return ArchivaDataItem.withAsset( asset ).withId( asset.getName() ).build();
 307         } else
 308         {
 309             return ArchivaContentItem.withRepository( this )
 310                 .withAsset( asset ).build( );
 311         }
 312     }
 313
 314
 315     @Override
 316     public void deleteGroupId( String groupId ) throws ContentNotFoundException, ContentAccessException
 317     {
 318
 319     }
 320
 321
 322     @Override
 323     public void deleteProject( String namespace, String projectId ) throws ContentNotFoundException, ContentAccessException
 324     {
 325
 326     }
 327
 328     @Override
 329     public void deleteProject( ProjectReference reference ) throws ContentNotFoundException, ContentAccessException
 330     {
 331
 332     }
 333
 334     @Override
 335     public String toPath( ContentItem item )
 336     {
 337         return null;
 338     }
 339
 340     @Override
 341     public String getId( )
 342     {
 343         return null;
 344     }
 345
 346     @Override
 347     public List<ArtifactReference> getRelatedArtifacts( VersionedReference reference ) throws ContentNotFoundException, LayoutException, ContentAccessException
 348     {
 349         return null;
 350     }
 351
 352     @Override
 353     public List<ArtifactReference> getArtifacts( VersionedReference reference ) throws ContentNotFoundException, LayoutException, ContentAccessException
 354     {
 355         return null;
 356     }
 357
 358     @Override
 359     public String getRepoRoot( )
 360     {
 361         return null;
 362     }
 363
 364     @Override
 365     public ManagedRepository getRepository( )
 366     {
 367         return repository;
 368     }
 369
 370     @Override
 371     public void setRepository( ManagedRepository repo )
 372     {
 373         this.repository = repo;
 374     }
 375
 376     @Override
 377     public StorageAsset toFile( VersionedReference reference )
 378     {
 379         return null;
 380     }
 381
 382     @Override
 383     public ArtifactReference toArtifactReference( String path ) throws LayoutException
 384     {
 385         return null;
 386     }
 387
 388     @Override
 389     public String toPath( ArtifactReference reference )
 390     {
 391         return null;
 392     }
 393
 394     @Override
 395     public String toPath( ItemSelector selector )
 396     {
 397         return null;
 398     }
 399
 400     @Override
 401     public ItemSelector toItemSelector( String path ) throws LayoutException
 402     {
 403         return null;
 404     }
 405
 406     @Override
 407     public ManagedRepositoryContent getGenericContent( )
 408     {
 409         return null;
 410     }
 411 }