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

   1 package org.apache.archiva.metadata.repository.memory;
   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 java.util.Collection;
  23 import java.util.Collections;
  24 import java.util.HashMap;
  25 import java.util.LinkedHashSet;
  26 import java.util.List;
  27 import java.util.Map;
  28 import java.util.Set;
  29
  30 import org.apache.archiva.metadata.model.ArtifactMetadata;
  31 import org.apache.archiva.metadata.model.ProjectMetadata;
  32 import org.apache.archiva.metadata.model.ProjectVersionMetadata;
  33 import org.apache.archiva.metadata.model.ProjectVersionReference;
  34 import org.apache.archiva.metadata.repository.MetadataResolver;
  35
  36 public class TestMetadataResolver
  37     implements MetadataResolver
  38 {
  39     private Map<String, ProjectVersionMetadata> projectVersions = new HashMap<String, ProjectVersionMetadata>();
  40
  41     private Map<String, List<ArtifactMetadata>> artifacts = new HashMap<String, List<ArtifactMetadata>>();
  42
  43     private Map<String, List<ProjectVersionReference>> references =
  44         new HashMap<String, List<ProjectVersionReference>>();
  45
  46     private List<String> namespaces;
  47
  48     private Map<String, Collection<String>> projectsInNamespace = new HashMap<String, Collection<String>>();
  49
  50     private Map<String, Collection<String>> versionsInProject = new HashMap<String, Collection<String>>();
  51
  52     public ProjectMetadata getProject( String repoId, String namespace, String projectId )
  53     {
  54         ProjectMetadata metadata = new ProjectMetadata();
  55         metadata.setNamespace( namespace );
  56         metadata.setId( projectId );
  57         return metadata;
  58     }
  59
  60     public ProjectVersionMetadata getProjectVersion( String repoId, String namespace, String projectId,
  61                                                      String projectVersion )
  62     {
  63         return projectVersions.get( createMapKey( repoId, namespace, projectId, projectVersion ) );
  64     }
  65
  66     public Collection<String> getArtifactVersions( String repoId, String namespace, String projectId,
  67                                                    String projectVersion )
  68     {
  69         throw new UnsupportedOperationException();
  70     }
  71
  72     public Collection<ProjectVersionReference> getProjectReferences( String repoId, String namespace, String projectId,
  73                                                                      String projectVersion )
  74     {
  75         return references.get( createMapKey( repoId, namespace, projectId, projectVersion ) );
  76     }
  77
  78     public Collection<String> getRootNamespaces( String repoId )
  79     {
  80         return getNamespaces( null );
  81     }
  82
  83     private Collection<String> getNamespaces( String baseNamespace )
  84     {
  85         Set<String> namespaces = new LinkedHashSet<String>();
  86         int fromIndex = baseNamespace != null ? baseNamespace.length() + 1 : 0;
  87         for ( String namespace : this.namespaces )
  88         {
  89             if ( baseNamespace == null || namespace.startsWith( baseNamespace + "." ) )
  90             {
  91                 int i = namespace.indexOf( '.', fromIndex );
  92                 if ( i >= 0 )
  93                 {
  94                     namespaces.add( namespace.substring( fromIndex, i ) );
  95                 }
  96                 else
  97                 {
  98                     namespaces.add( namespace.substring( fromIndex ) );
  99                 }
 100             }
 101         }
 102         return namespaces;
 103     }
 104
 105     public Collection<String> getNamespaces( String repoId, String namespace )
 106     {
 107         return getNamespaces( namespace );
 108     }
 109
 110     public Collection<String> getProjects( String repoId, String namespace )
 111     {
 112         Collection<String> list = projectsInNamespace.get( namespace );
 113         return list != null ? list : Collections.<String>emptyList();
 114     }
 115
 116     public Collection<String> getProjectVersions( String repoId, String namespace, String projectId )
 117     {
 118         Collection<String> list = versionsInProject.get( namespace + ":" + projectId );
 119         return list != null ? list : Collections.<String>emptyList();
 120     }
 121
 122     public Collection<ArtifactMetadata> getArtifacts( String repoId, String namespace, String projectId,
 123                                                       String projectVersion )
 124     {
 125         List<ArtifactMetadata> artifacts =
 126             this.artifacts.get( createMapKey( repoId, namespace, projectId, projectVersion ) );
 127         return ( artifacts != null ? artifacts : Collections.<ArtifactMetadata>emptyList() );
 128     }
 129
 130     public void setProjectVersion( String repoId, String namespace, String projectId,
 131                                    ProjectVersionMetadata versionMetadata )
 132     {
 133         projectVersions.put( createMapKey( repoId, namespace, projectId, versionMetadata.getId() ), versionMetadata );
 134
 135         Collection<String> projects = projectsInNamespace.get( namespace );
 136         if ( projects == null )
 137         {
 138             projects = new LinkedHashSet<String>();
 139             projectsInNamespace.put( namespace, projects );
 140         }
 141         projects.add( projectId );
 142
 143         String key = namespace + ":" + projectId;
 144         Collection<String> versions = versionsInProject.get( key );
 145         if ( versions == null )
 146         {
 147             versions = new LinkedHashSet<String>();
 148             versionsInProject.put( key, versions );
 149         }
 150         versions.add( versionMetadata.getId() );
 151     }
 152
 153     public void setArtifacts( String repoId, String namespace, String projectId, String projectVersion,
 154                               List<ArtifactMetadata> artifacts )
 155     {
 156         this.artifacts.put( createMapKey( repoId, namespace, projectId, projectVersion ), artifacts );
 157     }
 158
 159     private String createMapKey( String repoId, String namespace, String projectId, String projectVersion )
 160     {
 161         return repoId + ":" + namespace + ":" + projectId + ":" + projectVersion;
 162     }
 163
 164     public void setProjectReferences( String repoId, String namespace, String projectId, String projectVersion,
 165                                       List<ProjectVersionReference> references )
 166     {
 167         this.references.put( createMapKey( repoId, namespace, projectId, projectVersion ), references );
 168     }
 169
 170     public void setNamespaces( List<String> namespaces )
 171     {
 172         this.namespaces = namespaces;
 173     }
 174 }