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