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

   1 package org.apache.maven.archiva.indexer.lucene;
   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.commons.io.FileUtils;
  23 import org.apache.lucene.index.Term;
  24 import org.apache.lucene.queryParser.ParseException;
  25 import org.apache.lucene.queryParser.QueryParser;
  26 import org.apache.lucene.search.BooleanClause;
  27 import org.apache.lucene.search.BooleanQuery;
  28 import org.apache.lucene.search.MatchAllDocsQuery;
  29 import org.apache.lucene.search.Query;
  30 import org.apache.lucene.search.TermQuery;
  31 import org.apache.maven.archiva.indexer.RepositoryArtifactIndex;
  32 import org.apache.maven.archiva.indexer.RepositoryArtifactIndexFactory;
  33 import org.apache.maven.archiva.indexer.RepositoryIndexSearchException;
  34 import org.apache.maven.archiva.indexer.record.RepositoryIndexRecordFactory;
  35 import org.apache.maven.archiva.indexer.record.StandardIndexRecordFields;
  36 import org.apache.maven.artifact.Artifact;
  37 import org.apache.maven.artifact.factory.ArtifactFactory;
  38 import org.apache.maven.artifact.repository.ArtifactRepository;
  39 import org.apache.maven.artifact.repository.ArtifactRepositoryFactory;
  40 import org.apache.maven.artifact.repository.layout.ArtifactRepositoryLayout;
  41 import org.apache.maven.artifact.versioning.VersionRange;
  42 import org.codehaus.plexus.PlexusTestCase;
  43
  44 import java.io.File;
  45 import java.util.HashMap;
  46 import java.util.List;
  47 import java.util.Map;
  48
  49 /**
  50  * Test the Lucene implementation of the artifact index search.
  51  *
  52  * @author <a href="mailto:brett@apache.org">Brett Porter</a>
  53  * @todo would be nice to abstract some of the query away, but for now passing in a Lucene query directly is good enough
  54  */
  55 public class LuceneStandardArtifactIndexSearchTest
  56     extends PlexusTestCase
  57 {
  58     private RepositoryArtifactIndex index;
  59
  60     private ArtifactRepository repository;
  61
  62     private ArtifactFactory artifactFactory;
  63
  64     private File indexLocation;
  65
  66     private RepositoryIndexRecordFactory recordFactory;
  67
  68     private Map records = new HashMap();
  69
  70     protected void setUp()
  71         throws Exception
  72     {
  73         super.setUp();
  74
  75         recordFactory = (RepositoryIndexRecordFactory) lookup( RepositoryIndexRecordFactory.ROLE, "standard" );
  76
  77         artifactFactory = (ArtifactFactory) lookup( ArtifactFactory.ROLE );
  78
  79         ArtifactRepositoryFactory repositoryFactory =
  80             (ArtifactRepositoryFactory) lookup( ArtifactRepositoryFactory.ROLE );
  81
  82         ArtifactRepositoryLayout layout = (ArtifactRepositoryLayout) lookup( ArtifactRepositoryLayout.ROLE, "default" );
  83
  84         File file = getTestFile( "src/test/managed-repository" );
  85         repository =
  86             repositoryFactory.createArtifactRepository( "test", file.toURI().toURL().toString(), layout, null, null );
  87
  88         RepositoryArtifactIndexFactory factory =
  89             (RepositoryArtifactIndexFactory) lookup( RepositoryArtifactIndexFactory.ROLE, "lucene" );
  90
  91         indexLocation = getTestFile( "target/test-index" );
  92
  93         FileUtils.deleteDirectory( indexLocation );
  94
  95         index = factory.createStandardIndex( indexLocation );
  96
  97         records.put( "test-jar", recordFactory.createRecord( createArtifact( "test-jar" ) ) );
  98         records.put( "test-jar-jdk14",
  99                      recordFactory.createRecord( createArtifact( "test-jar", "1.0", "jar", "jdk14" ) ) );
 100         records.put( "test-jar-and-pom",
 101                      recordFactory.createRecord( createArtifact( "test-jar-and-pom", "1.0-alpha-1", "jar" ) ) );
 102         records.put( "test-jar-and-pom-jdk14", recordFactory.createRecord(
 103             createArtifact( "test-jar-and-pom", "1.0-alpha-1", "jar", "jdk14" ) ) );
 104         records.put( "test-child-pom",
 105                      recordFactory.createRecord( createArtifact( "test-child-pom", "1.0-20060728.121314-1", "jar" ) ) );
 106         records.put( "test-archetype", recordFactory.createRecord( createArtifact( "test-archetype" ) ) );
 107         records.put( "test-plugin", recordFactory.createRecord( createArtifact( "test-plugin" ) ) );
 108         records.put( "test-pom", recordFactory.createRecord( createArtifact( "test-pom", "1.0", "pom" ) ) );
 109         records.put( "parent-pom", recordFactory.createRecord( createArtifact( "parent-pom", "1", "pom" ) ) );
 110         records.put( "test-dll", recordFactory.createRecord( createArtifact( "test-dll", "1.0.1.34", "dll" ) ) );
 111
 112         index.indexRecords( records.values() );
 113     }
 114
 115     public void testExactMatchVersion()
 116         throws RepositoryIndexSearchException
 117     {
 118         Query query = createExactMatchQuery( StandardIndexRecordFields.VERSION_EXACT, "1.0" );
 119         List results = index.search( new LuceneQuery( query ) );
 120
 121         assertTrue( "Check result", results.contains( records.get( "test-jar" ) ) );
 122         assertTrue( "Check result", results.contains( records.get( "test-jar-jdk14" ) ) );
 123         assertTrue( "Check result", results.contains( records.get( "test-pom" ) ) );
 124         assertTrue( "Check result", results.contains( records.get( "test-plugin" ) ) );
 125         assertTrue( "Check result", results.contains( records.get( "test-archetype" ) ) );
 126         assertEquals( "Check results size", 5, results.size() );
 127
 128         query = createExactMatchQuery( StandardIndexRecordFields.VERSION_EXACT, "1.0-SNAPSHOT" );
 129         results = index.search( new LuceneQuery( query ) );
 130
 131         assertTrue( "Check results size", results.isEmpty() );
 132
 133         query = createExactMatchQuery( StandardIndexRecordFields.VERSION_EXACT, "1.0-snapshot" );
 134         results = index.search( new LuceneQuery( query ) );
 135
 136         assertTrue( "Check results size", results.isEmpty() );
 137
 138         query = createExactMatchQuery( StandardIndexRecordFields.VERSION_EXACT, "1.0-20060728.121314-1" );
 139         results = index.search( new LuceneQuery( query ) );
 140
 141         assertTrue( "Check result", results.contains( records.get( "test-child-pom" ) ) );
 142         assertEquals( "Check results size", 1, results.size() );
 143
 144         // test non-match fails
 145         query = createExactMatchQuery( StandardIndexRecordFields.VERSION_EXACT, "foo" );
 146         results = index.search( new LuceneQuery( query ) );
 147
 148         assertTrue( "Check results size", results.isEmpty() );
 149     }
 150
 151     public void testExactMatchBaseVersion()
 152         throws RepositoryIndexSearchException
 153     {
 154         Query query = createExactMatchQuery( StandardIndexRecordFields.BASE_VERSION_EXACT, "1.0" );
 155         List results = index.search( new LuceneQuery( query ) );
 156
 157         assertTrue( "Check result", results.contains( records.get( "test-jar" ) ) );
 158         assertTrue( "Check result", results.contains( records.get( "test-jar-jdk14" ) ) );
 159         assertTrue( "Check result", results.contains( records.get( "test-pom" ) ) );
 160         assertTrue( "Check result", results.contains( records.get( "test-plugin" ) ) );
 161         assertTrue( "Check result", results.contains( records.get( "test-archetype" ) ) );
 162         assertEquals( "Check results size", 5, results.size() );
 163
 164         query = createExactMatchQuery( StandardIndexRecordFields.BASE_VERSION_EXACT, "1.0-SNAPSHOT" );
 165         results = index.search( new LuceneQuery( query ) );
 166
 167         assertTrue( "Check result", results.contains( records.get( "test-child-pom" ) ) );
 168         assertEquals( "Check results size", 1, results.size() );
 169
 170         query = createExactMatchQuery( StandardIndexRecordFields.BASE_VERSION_EXACT, "1.0-snapshot" );
 171         results = index.search( new LuceneQuery( query ) );
 172
 173         assertTrue( "Check results size", results.isEmpty() );
 174
 175         query = createExactMatchQuery( StandardIndexRecordFields.BASE_VERSION_EXACT, "1.0-20060728.121314-1" );
 176         results = index.search( new LuceneQuery( query ) );
 177
 178         assertTrue( "Check results size", results.isEmpty() );
 179
 180         // test non-match fails
 181         query = createExactMatchQuery( StandardIndexRecordFields.BASE_VERSION_EXACT, "foo" );
 182         results = index.search( new LuceneQuery( query ) );
 183
 184         assertTrue( "Check results size", results.isEmpty() );
 185     }
 186
 187     public void testExactMatchGroupId()
 188         throws RepositoryIndexSearchException
 189     {
 190         Query query =
 191             createExactMatchQuery( StandardIndexRecordFields.GROUPID_EXACT, "org.apache.maven.archiva.record" );
 192         List results = index.search( new LuceneQuery( query ) );
 193
 194         assertEquals( "Check results size", 10, results.size() );
 195
 196         // test partial match fails
 197         query = createExactMatchQuery( StandardIndexRecordFields.GROUPID_EXACT, "org.apache.maven" );
 198         results = index.search( new LuceneQuery( query ) );
 199
 200         assertTrue( "Check results size", results.isEmpty() );
 201
 202         // test non-match fails
 203         query = createExactMatchQuery( StandardIndexRecordFields.GROUPID_EXACT, "foo" );
 204         results = index.search( new LuceneQuery( query ) );
 205
 206         assertTrue( "Check results size", results.isEmpty() );
 207     }
 208
 209     public void testExactMatchArtifactId()
 210         throws RepositoryIndexSearchException
 211     {
 212         Query query = createExactMatchQuery( StandardIndexRecordFields.ARTIFACTID_EXACT, "test-jar" );
 213         List results = index.search( new LuceneQuery( query ) );
 214
 215         assertTrue( "Check result", results.contains( records.get( "test-jar" ) ) );
 216         assertTrue( "Check result", results.contains( records.get( "test-jar-jdk14" ) ) );
 217         assertEquals( "Check results size", 2, results.size() );
 218
 219         // test partial match fails
 220         query = createExactMatchQuery( StandardIndexRecordFields.ARTIFACTID_EXACT, "test" );
 221         results = index.search( new LuceneQuery( query ) );
 222
 223         assertTrue( "Check results size", results.isEmpty() );
 224
 225         // test non-match fails
 226         query = createExactMatchQuery( StandardIndexRecordFields.ARTIFACTID_EXACT, "foo" );
 227         results = index.search( new LuceneQuery( query ) );
 228
 229         assertTrue( "Check results size", results.isEmpty() );
 230     }
 231
 232     public void testExactMatchType()
 233         throws RepositoryIndexSearchException
 234     {
 235         Query query = createExactMatchQuery( StandardIndexRecordFields.TYPE, "maven-plugin" );
 236         List results = index.search( new LuceneQuery( query ) );
 237
 238         assertTrue( "Check result", results.contains( records.get( "test-plugin" ) ) );
 239         assertEquals( "Check results size", 1, results.size() );
 240
 241         query = createExactMatchQuery( StandardIndexRecordFields.TYPE, "jar" );
 242         results = index.search( new LuceneQuery( query ) );
 243
 244         assertTrue( "Check result", results.contains( records.get( "test-jar" ) ) );
 245         assertTrue( "Check result", results.contains( records.get( "test-jar-jdk14" ) ) );
 246         assertTrue( "Check result", results.contains( records.get( "test-jar-and-pom" ) ) );
 247         assertTrue( "Check result", results.contains( records.get( "test-jar-and-pom-jdk14" ) ) );
 248         assertTrue( "Check result", results.contains( records.get( "test-child-pom" ) ) );
 249         assertEquals( "Check results size", 5, results.size() );
 250
 251         query = createExactMatchQuery( StandardIndexRecordFields.TYPE, "dll" );
 252         results = index.search( new LuceneQuery( query ) );
 253
 254         assertTrue( "Check result", results.contains( records.get( "test-dll" ) ) );
 255         assertEquals( "Check results size", 1, results.size() );
 256
 257         query = createExactMatchQuery( StandardIndexRecordFields.TYPE, "maven-archetype" );
 258         results = index.search( new LuceneQuery( query ) );
 259
 260         assertTrue( "Check result", results.contains( records.get( "test-archetype" ) ) );
 261         assertEquals( "Check results size", 1, results.size() );
 262
 263         // test non-match fails
 264         query = createExactMatchQuery( StandardIndexRecordFields.TYPE, "foo" );
 265         results = index.search( new LuceneQuery( query ) );
 266
 267         assertTrue( "Check results size", results.isEmpty() );
 268     }
 269
 270     public void testExactMatchPackaging()
 271         throws RepositoryIndexSearchException
 272     {
 273         Query query = createExactMatchQuery( StandardIndexRecordFields.PACKAGING, "maven-plugin" );
 274         List results = index.search( new LuceneQuery( query ) );
 275
 276         assertTrue( "Check result", results.contains( records.get( "test-plugin" ) ) );
 277         assertEquals( "Check results size", 1, results.size() );
 278
 279         query = createExactMatchQuery( StandardIndexRecordFields.PACKAGING, "jar" );
 280         results = index.search( new LuceneQuery( query ) );
 281
 282         assertTrue( "Check result", results.contains( records.get( "test-archetype" ) ) );
 283         assertTrue( "Check result", results.contains( records.get( "test-jar-and-pom" ) ) );
 284         assertTrue( "Check result", results.contains( records.get( "test-jar-and-pom-jdk14" ) ) );
 285         assertTrue( "Check result", results.contains( records.get( "test-child-pom" ) ) );
 286         assertEquals( "Check results size", 4, results.size() );
 287
 288         query = createExactMatchQuery( StandardIndexRecordFields.PACKAGING, "dll" );
 289         results = index.search( new LuceneQuery( query ) );
 290
 291         assertTrue( "Check results size", results.isEmpty() );
 292
 293         query = createExactMatchQuery( StandardIndexRecordFields.PACKAGING, "maven-archetype" );
 294         results = index.search( new LuceneQuery( query ) );
 295
 296         assertTrue( "Check results size", results.isEmpty() );
 297
 298         // test non-match fails
 299         query = createExactMatchQuery( StandardIndexRecordFields.PACKAGING, "foo" );
 300         results = index.search( new LuceneQuery( query ) );
 301
 302         assertTrue( "Check results size", results.isEmpty() );
 303     }
 304
 305     public void testExactMatchPluginPrefix()
 306         throws RepositoryIndexSearchException
 307     {
 308         Query query = createExactMatchQuery( StandardIndexRecordFields.PLUGIN_PREFIX, "test" );
 309         List results = index.search( new LuceneQuery( query ) );
 310
 311         assertTrue( "Check result", results.contains( records.get( "test-plugin" ) ) );
 312         assertEquals( "Check results size", 1, results.size() );
 313
 314         // test non-match fails
 315         query = createExactMatchQuery( StandardIndexRecordFields.PLUGIN_PREFIX, "foo" );
 316         results = index.search( new LuceneQuery( query ) );
 317
 318         assertTrue( "Check results size", results.isEmpty() );
 319     }
 320
 321     public void testExactMatchRepository()
 322         throws RepositoryIndexSearchException
 323     {
 324         Query query = createExactMatchQuery( StandardIndexRecordFields.REPOSITORY, "test" );
 325         List results = index.search( new LuceneQuery( query ) );
 326
 327         assertEquals( "Check results size", 10, results.size() );
 328
 329         // test non-match fails
 330         query = createExactMatchQuery( StandardIndexRecordFields.REPOSITORY, "foo" );
 331         results = index.search( new LuceneQuery( query ) );
 332
 333         assertTrue( "Check results size", results.isEmpty() );
 334     }
 335
 336     public void testExactMatchMd5()
 337         throws RepositoryIndexSearchException
 338     {
 339         Query query = createExactMatchQuery( StandardIndexRecordFields.MD5, "3a0adc365f849366cd8b633cad155cb7" );
 340         List results = index.search( new LuceneQuery( query ) );
 341
 342         assertTrue( "Check result", results.contains( records.get( "test-jar" ) ) );
 343         assertTrue( "Check result", results.contains( records.get( "test-jar-jdk14" ) ) );
 344         assertTrue( "Check result", results.contains( records.get( "test-jar-and-pom" ) ) );
 345         assertTrue( "Check result", results.contains( records.get( "test-jar-and-pom-jdk14" ) ) );
 346         assertTrue( "Check result", results.contains( records.get( "test-child-pom" ) ) );
 347         assertEquals( "Check results size", 5, results.size() );
 348
 349         // test non-match fails
 350         query = createExactMatchQuery( StandardIndexRecordFields.MD5, "foo" );
 351         results = index.search( new LuceneQuery( query ) );
 352
 353         assertTrue( "Check results size", results.isEmpty() );
 354     }
 355
 356     public void testExactMatchSha1()
 357         throws RepositoryIndexSearchException
 358     {
 359         Query query =
 360             createExactMatchQuery( StandardIndexRecordFields.SHA1, "c66f18bf192cb613fc2febb4da541a34133eedc2" );
 361         List results = index.search( new LuceneQuery( query ) );
 362
 363         assertTrue( "Check result", results.contains( records.get( "test-jar" ) ) );
 364         assertTrue( "Check result", results.contains( records.get( "test-jar-jdk14" ) ) );
 365         assertTrue( "Check result", results.contains( records.get( "test-jar-and-pom" ) ) );
 366         assertTrue( "Check result", results.contains( records.get( "test-jar-and-pom-jdk14" ) ) );
 367         assertTrue( "Check result", results.contains( records.get( "test-child-pom" ) ) );
 368         assertEquals( "Check results size", 5, results.size() );
 369
 370         // test non-match fails
 371         query = createExactMatchQuery( StandardIndexRecordFields.SHA1, "foo" );
 372         results = index.search( new LuceneQuery( query ) );
 373
 374         assertTrue( "Check results size", results.isEmpty() );
 375     }
 376
 377     public void testExactMatchInceptionYear()
 378         throws RepositoryIndexSearchException
 379     {
 380         Query query = createExactMatchQuery( StandardIndexRecordFields.INCEPTION_YEAR, "2005" );
 381         List results = index.search( new LuceneQuery( query ) );
 382
 383         assertTrue( "Check result", results.contains( records.get( "test-child-pom" ) ) );
 384         assertTrue( "Check result", results.contains( records.get( "test-pom" ) ) );
 385         assertTrue( "Check result", results.contains( records.get( "parent-pom" ) ) );
 386         assertEquals( "Check results size", 3, results.size() );
 387
 388         // test non-match fails
 389         query = createExactMatchQuery( StandardIndexRecordFields.INCEPTION_YEAR, "foo" );
 390         results = index.search( new LuceneQuery( query ) );
 391
 392         assertTrue( "Check results size", results.isEmpty() );
 393     }
 394
 395     public void testMatchFilename()
 396         throws RepositoryIndexSearchException, ParseException
 397     {
 398         Query query = createMatchQuery( StandardIndexRecordFields.FILENAME, "maven" );
 399         List results = index.search( new LuceneQuery( query ) );
 400
 401         assertEquals( "Check results size", 10, results.size() );
 402
 403         query = createMatchQuery( StandardIndexRecordFields.FILENAME, "plugin" );
 404         results = index.search( new LuceneQuery( query ) );
 405
 406         assertTrue( "Check result", results.contains( records.get( "test-plugin" ) ) );
 407         assertEquals( "Check results size", 1, results.size() );
 408
 409         query = createMatchQuery( StandardIndexRecordFields.FILENAME, "pLuGiN" );
 410         results = index.search( new LuceneQuery( query ) );
 411
 412         assertTrue( "Check results size", results.isEmpty() );
 413
 414         query = createMatchQuery( StandardIndexRecordFields.FILENAME, "test" );
 415         results = index.search( new LuceneQuery( query ) );
 416
 417         assertFalse( "Check result", results.contains( records.get( "parent-pom" ) ) );
 418         assertEquals( "Check results size", 9, results.size() );
 419
 420         // test non-match fails
 421         query = createMatchQuery( StandardIndexRecordFields.FILENAME, "foo" );
 422         results = index.search( new LuceneQuery( query ) );
 423
 424         assertTrue( "Check results size", results.isEmpty() );
 425     }
 426
 427     public void testMatchGroupId()
 428         throws RepositoryIndexSearchException, ParseException
 429     {
 430         Query query = createMatchQuery( StandardIndexRecordFields.GROUPID, "org.apache.maven.archiva.record" );
 431         List results = index.search( new LuceneQuery( query ) );
 432
 433         assertEquals( "Check results size", 10, results.size() );
 434
 435         query = createMatchQuery( StandardIndexRecordFields.GROUPID, "maven" );
 436         results = index.search( new LuceneQuery( query ) );
 437
 438         assertEquals( "Check results size", 10, results.size() );
 439
 440         query = createMatchQuery( StandardIndexRecordFields.GROUPID, "Maven" );
 441         results = index.search( new LuceneQuery( query ) );
 442
 443         assertEquals( "Check results size", 10, results.size() );
 444
 445         // test non-match fails
 446         query = createMatchQuery( StandardIndexRecordFields.GROUPID, "foo" );
 447         results = index.search( new LuceneQuery( query ) );
 448
 449         assertTrue( "Check results size", results.isEmpty() );
 450     }
 451
 452     public void testMatchArtifactId()
 453         throws RepositoryIndexSearchException, ParseException
 454     {
 455         Query query = createMatchQuery( StandardIndexRecordFields.ARTIFACTID, "plugin" );
 456         List results = index.search( new LuceneQuery( query ) );
 457
 458         assertTrue( "Check result", results.contains( records.get( "test-plugin" ) ) );
 459         assertEquals( "Check results size", 1, results.size() );
 460
 461         query = createMatchQuery( StandardIndexRecordFields.ARTIFACTID, "test" );
 462         results = index.search( new LuceneQuery( query ) );
 463
 464         assertFalse( "Check result", results.contains( records.get( "parent-pom" ) ) );
 465         assertEquals( "Check results size", 9, results.size() );
 466
 467         // test non-match fails
 468         query = createMatchQuery( StandardIndexRecordFields.ARTIFACTID, "maven" );
 469         results = index.search( new LuceneQuery( query ) );
 470
 471         assertTrue( "Check results size", results.isEmpty() );
 472     }
 473
 474     public void testMatchVersion()
 475         throws RepositoryIndexSearchException, ParseException
 476     {
 477         // If partial matches are desired, need to change the analyzer for versions to split on '.'
 478         Query query = createMatchQuery( StandardIndexRecordFields.VERSION, "1" );
 479         List results = index.search( new LuceneQuery( query ) );
 480
 481         assertTrue( "Check result", results.contains( records.get( "parent-pom" ) ) );
 482         assertTrue( "Check result", results.contains( records.get( "test-jar-and-pom" ) ) );
 483         assertTrue( "Check result", results.contains( records.get( "test-jar-and-pom-jdk14" ) ) );
 484         assertTrue( "Check result", results.contains( records.get( "test-child-pom" ) ) );
 485         assertEquals( "Check results size", 4, results.size() );
 486
 487         query = createMatchQuery( StandardIndexRecordFields.VERSION, "1.0" );
 488         results = index.search( new LuceneQuery( query ) );
 489
 490         assertTrue( "Check result", results.contains( records.get( "test-jar" ) ) );
 491         assertTrue( "Check result", results.contains( records.get( "test-jar-jdk14" ) ) );
 492         assertTrue( "Check result", results.contains( records.get( "test-plugin" ) ) );
 493         assertTrue( "Check result", results.contains( records.get( "test-pom" ) ) );
 494         assertTrue( "Check result", results.contains( records.get( "test-archetype" ) ) );
 495         assertTrue( "Check result", results.contains( records.get( "test-jar-and-pom" ) ) );
 496         assertTrue( "Check result", results.contains( records.get( "test-jar-and-pom-jdk14" ) ) );
 497         assertTrue( "Check result", results.contains( records.get( "test-child-pom" ) ) );
 498         assertEquals( "Check results size", 8, results.size() );
 499
 500         query = createMatchQuery( StandardIndexRecordFields.VERSION, "snapshot" );
 501         results = index.search( new LuceneQuery( query ) );
 502
 503         assertTrue( "Check results size", results.isEmpty() );
 504
 505         query = createMatchQuery( StandardIndexRecordFields.VERSION, "SNAPSHOT" );
 506         results = index.search( new LuceneQuery( query ) );
 507
 508         assertTrue( "Check results size", results.isEmpty() );
 509
 510         query = createMatchQuery( StandardIndexRecordFields.VERSION, "alpha" );
 511         results = index.search( new LuceneQuery( query ) );
 512
 513         assertTrue( "Check result", results.contains( records.get( "test-jar-and-pom" ) ) );
 514         assertTrue( "Check result", results.contains( records.get( "test-jar-and-pom-jdk14" ) ) );
 515         assertEquals( "Check results size", 2, results.size() );
 516
 517         query = createMatchQuery( StandardIndexRecordFields.VERSION, "1.0-alpha-1" );
 518         results = index.search( new LuceneQuery( query ) );
 519
 520         assertTrue( "Check result", results.contains( records.get( "test-jar-and-pom" ) ) );
 521         assertTrue( "Check result", results.contains( records.get( "test-jar-and-pom-jdk14" ) ) );
 522         assertEquals( "Check results size", 2, results.size() );
 523
 524         // test non-match fails
 525         query = createMatchQuery( StandardIndexRecordFields.VERSION, "foo" );
 526         results = index.search( new LuceneQuery( query ) );
 527
 528         assertTrue( "Check results size", results.isEmpty() );
 529     }
 530
 531     public void testMatchBaseVersion()
 532         throws RepositoryIndexSearchException, ParseException
 533     {
 534         // If partial matches are desired, need to change the analyzer for versions to split on '.'
 535         Query query = createMatchQuery( StandardIndexRecordFields.BASE_VERSION, "1" );
 536         List results = index.search( new LuceneQuery( query ) );
 537
 538         assertTrue( "Check result", results.contains( records.get( "parent-pom" ) ) );
 539         assertTrue( "Check result", results.contains( records.get( "test-jar-and-pom" ) ) );
 540         assertTrue( "Check result", results.contains( records.get( "test-jar-and-pom-jdk14" ) ) );
 541         assertEquals( "Check results size", 3, results.size() );
 542
 543         query = createMatchQuery( StandardIndexRecordFields.BASE_VERSION, "1.0" );
 544         results = index.search( new LuceneQuery( query ) );
 545
 546         assertTrue( "Check result", results.contains( records.get( "test-jar" ) ) );
 547         assertTrue( "Check result", results.contains( records.get( "test-jar-jdk14" ) ) );
 548         assertTrue( "Check result", results.contains( records.get( "test-plugin" ) ) );
 549         assertTrue( "Check result", results.contains( records.get( "test-pom" ) ) );
 550         assertTrue( "Check result", results.contains( records.get( "test-archetype" ) ) );
 551         assertTrue( "Check result", results.contains( records.get( "test-jar-and-pom" ) ) );
 552         assertTrue( "Check result", results.contains( records.get( "test-jar-and-pom-jdk14" ) ) );
 553         assertTrue( "Check result", results.contains( records.get( "test-child-pom" ) ) );
 554         assertEquals( "Check results size", 8, results.size() );
 555
 556         query = createMatchQuery( StandardIndexRecordFields.BASE_VERSION, "SNAPSHOT" );
 557         results = index.search( new LuceneQuery( query ) );
 558
 559         assertTrue( "Check result", results.contains( records.get( "test-child-pom" ) ) );
 560         assertEquals( "Check results size", 1, results.size() );
 561
 562         query = createMatchQuery( StandardIndexRecordFields.BASE_VERSION, "SnApShOt" );
 563         results = index.search( new LuceneQuery( query ) );
 564
 565         assertTrue( "Check results size", results.isEmpty() );
 566
 567         query = createMatchQuery( StandardIndexRecordFields.BASE_VERSION, "snapshot" );
 568         results = index.search( new LuceneQuery( query ) );
 569
 570         assertTrue( "Check results size", results.isEmpty() );
 571
 572         query = createMatchQuery( StandardIndexRecordFields.BASE_VERSION, "alpha" );
 573         results = index.search( new LuceneQuery( query ) );
 574
 575         assertTrue( "Check result", results.contains( records.get( "test-jar-and-pom" ) ) );
 576         assertTrue( "Check result", results.contains( records.get( "test-jar-and-pom-jdk14" ) ) );
 577         assertEquals( "Check results size", 2, results.size() );
 578
 579         query = createMatchQuery( StandardIndexRecordFields.BASE_VERSION, "1.0-alpha-1" );
 580         results = index.search( new LuceneQuery( query ) );
 581
 582         assertTrue( "Check result", results.contains( records.get( "test-jar-and-pom" ) ) );
 583         assertTrue( "Check result", results.contains( records.get( "test-jar-and-pom-jdk14" ) ) );
 584         assertEquals( "Check results size", 2, results.size() );
 585
 586         // test non-match fails
 587         query = createMatchQuery( StandardIndexRecordFields.BASE_VERSION, "foo" );
 588         results = index.search( new LuceneQuery( query ) );
 589
 590         assertTrue( "Check results size", results.isEmpty() );
 591     }
 592
 593     public void testMatchClassifier()
 594         throws RepositoryIndexSearchException, ParseException
 595     {
 596         BooleanQuery bQuery = new BooleanQuery();
 597         bQuery.add( new MatchAllDocsQuery(), BooleanClause.Occur.MUST );
 598         bQuery.add( createMatchQuery( StandardIndexRecordFields.CLASSIFIER, "jdk14" ), BooleanClause.Occur.MUST_NOT );
 599         List results = index.search( new LuceneQuery( bQuery ) );
 600
 601         assertFalse( "Check result", results.contains( records.get( "test-jar-jdk14" ) ) );
 602         assertFalse( "Check result", results.contains( records.get( "test-jar-and-pom-jdk14" ) ) );
 603         assertEquals( "Check results size", 8, results.size() );
 604
 605         // TODO: can we search for "anything with no classifier" ?
 606
 607         Query query = createMatchQuery( StandardIndexRecordFields.CLASSIFIER, "jdk14" );
 608         results = index.search( new LuceneQuery( query ) );
 609
 610         assertTrue( "Check result", results.contains( records.get( "test-jar-jdk14" ) ) );
 611         assertTrue( "Check result", results.contains( records.get( "test-jar-and-pom-jdk14" ) ) );
 612         assertEquals( "Check results size", 2, results.size() );
 613
 614         // test non-match fails
 615         query = createMatchQuery( StandardIndexRecordFields.CLASSIFIER, "foo" );
 616         results = index.search( new LuceneQuery( query ) );
 617
 618         assertTrue( "Check results size", results.isEmpty() );
 619     }
 620
 621     public void testMatchClass()
 622         throws RepositoryIndexSearchException, ParseException
 623     {
 624         Query query = createMatchQuery( StandardIndexRecordFields.CLASSES, "b.c.C" );
 625         List results = index.search( new LuceneQuery( query ) );
 626
 627         assertTrue( "Check result", results.contains( records.get( "test-child-pom" ) ) );
 628         assertTrue( "Check result", results.contains( records.get( "test-jar" ) ) );
 629         assertTrue( "Check result", results.contains( records.get( "test-jar-jdk14" ) ) );
 630         assertTrue( "Check result", results.contains( records.get( "test-jar-and-pom" ) ) );
 631         assertTrue( "Check result", results.contains( records.get( "test-jar-and-pom-jdk14" ) ) );
 632         assertEquals( "Check results size", 5, results.size() );
 633
 634         query = createMatchQuery( StandardIndexRecordFields.CLASSES, "C" );
 635         results = index.search( new LuceneQuery( query ) );
 636
 637         assertTrue( "Check result", results.contains( records.get( "test-child-pom" ) ) );
 638         assertTrue( "Check result", results.contains( records.get( "test-jar" ) ) );
 639         assertTrue( "Check result", results.contains( records.get( "test-jar-jdk14" ) ) );
 640         assertTrue( "Check result", results.contains( records.get( "test-jar-and-pom" ) ) );
 641         assertTrue( "Check result", results.contains( records.get( "test-jar-and-pom-jdk14" ) ) );
 642         assertEquals( "Check results size", 5, results.size() );
 643
 644         query = createMatchQuery( StandardIndexRecordFields.CLASSES, "MyMojo" );
 645         results = index.search( new LuceneQuery( query ) );
 646
 647         assertTrue( "Check result", results.contains( records.get( "test-plugin" ) ) );
 648         assertEquals( "Check results size", 1, results.size() );
 649
 650         query = createMatchQuery( StandardIndexRecordFields.CLASSES, "MYMOJO" );
 651         results = index.search( new LuceneQuery( query ) );
 652
 653         assertTrue( "Check result", results.contains( records.get( "test-plugin" ) ) );
 654         assertEquals( "Check results size", 1, results.size() );
 655
 656         query = createMatchQuery( StandardIndexRecordFields.CLASSES, "mymojo" );
 657         results = index.search( new LuceneQuery( query ) );
 658
 659         assertTrue( "Check result", results.contains( records.get( "test-plugin" ) ) );
 660         assertEquals( "Check results size", 1, results.size() );
 661
 662         // test non-match fails
 663         query = createMatchQuery( StandardIndexRecordFields.CLASSES, "foo" );
 664         results = index.search( new LuceneQuery( query ) );
 665
 666         assertTrue( "Check results size", results.isEmpty() );
 667     }
 668
 669     public void testMatchFiles()
 670         throws RepositoryIndexSearchException, ParseException
 671     {
 672         Query query = createMatchQuery( StandardIndexRecordFields.FILES, "MANIFEST.MF" );
 673         List results = index.search( new LuceneQuery( query ) );
 674
 675         assertFalse( "Check result", results.contains( records.get( "test-pom" ) ) );
 676         assertFalse( "Check result", results.contains( records.get( "parent-pom" ) ) );
 677         assertFalse( "Check result", results.contains( records.get( "test-dll" ) ) );
 678         assertEquals( "Check results size", 7, results.size() );
 679
 680         query = createMatchQuery( StandardIndexRecordFields.FILES, "META-INF" );
 681         results = index.search( new LuceneQuery( query ) );
 682
 683         assertFalse( "Check result", results.contains( records.get( "test-pom" ) ) );
 684         assertFalse( "Check result", results.contains( records.get( "parent-pom" ) ) );
 685         assertFalse( "Check result", results.contains( records.get( "test-dll" ) ) );
 686         assertEquals( "Check results size", 7, results.size() );
 687
 688         query = createMatchQuery( StandardIndexRecordFields.FILES, "plugin.xml" );
 689         results = index.search( new LuceneQuery( query ) );
 690
 691         assertTrue( "Check result", results.contains( records.get( "test-plugin" ) ) );
 692         assertEquals( "Check results size", 1, results.size() );
 693
 694         // test non-match fails
 695         query = createMatchQuery( StandardIndexRecordFields.FILES, "foo" );
 696         results = index.search( new LuceneQuery( query ) );
 697
 698         assertTrue( "Check results size", results.isEmpty() );
 699     }
 700
 701     public void testExactMatchDependency()
 702         throws RepositoryIndexSearchException
 703     {
 704         Query query =
 705             createExactMatchQuery( StandardIndexRecordFields.DEPENDENCIES, "org.apache.maven:maven-plugin-api:2.0" );
 706         List results = index.search( new LuceneQuery( query ) );
 707
 708         assertTrue( "Check result", results.contains( records.get( "test-plugin" ) ) );
 709         assertEquals( "Check results size", 1, results.size() );
 710
 711         // test non-match fails
 712         query = createExactMatchQuery( StandardIndexRecordFields.DEPENDENCIES, "foo" );
 713         results = index.search( new LuceneQuery( query ) );
 714
 715         assertTrue( "Check results size", results.isEmpty() );
 716     }
 717
 718     public void testMatchProjectName()
 719         throws RepositoryIndexSearchException, ParseException
 720     {
 721         Query query = createMatchQuery( StandardIndexRecordFields.PROJECT_NAME, "mojo" );
 722         List results = index.search( new LuceneQuery( query ) );
 723
 724         assertTrue( "Check result", results.contains( records.get( "test-plugin" ) ) );
 725         assertEquals( "Check results size", 1, results.size() );
 726
 727         query = createMatchQuery( StandardIndexRecordFields.PROJECT_NAME, "maven" );
 728         results = index.search( new LuceneQuery( query ) );
 729
 730         assertFalse( "Check result", results.contains( records.get( "parent-pom" ) ) );
 731         assertFalse( "Check result", results.contains( records.get( "test-child-pom" ) ) );
 732         assertEquals( "Check results size", 2, results.size() );
 733
 734         // test non-match fails
 735         query = createMatchQuery( StandardIndexRecordFields.PROJECT_NAME, "foo" );
 736         results = index.search( new LuceneQuery( query ) );
 737
 738         assertTrue( "Check results size", results.isEmpty() );
 739     }
 740
 741     public void testMatchProjectDescription()
 742         throws RepositoryIndexSearchException, ParseException
 743     {
 744         Query query = createMatchQuery( StandardIndexRecordFields.PROJECT_DESCRIPTION, "description" );
 745         List results = index.search( new LuceneQuery( query ) );
 746
 747         assertTrue( "Check result", results.contains( records.get( "test-child-pom" ) ) );
 748         assertTrue( "Check result", results.contains( records.get( "parent-pom" ) ) );
 749         assertTrue( "Check result", results.contains( records.get( "test-pom" ) ) );
 750         assertEquals( "Check results size", 3, results.size() );
 751
 752         // test non-match fails
 753         query = createMatchQuery( StandardIndexRecordFields.PROJECT_DESCRIPTION, "foo" );
 754         results = index.search( new LuceneQuery( query ) );
 755
 756         assertTrue( "Check results size", results.isEmpty() );
 757     }
 758
 759     private static Query createExactMatchQuery( String field, String value )
 760     {
 761         return new TermQuery( new Term( field, value ) );
 762     }
 763
 764     private static Query createMatchQuery( String field, String value )
 765         throws ParseException
 766     {
 767         return new QueryParser( field, LuceneRepositoryArtifactIndex.getAnalyzer() ).parse( value );
 768     }
 769
 770     private Artifact createArtifact( String artifactId )
 771     {
 772         return createArtifact( artifactId, "1.0", "jar", null );
 773     }
 774
 775     private Artifact createArtifact( String artifactId, String version, String type )
 776     {
 777         return createArtifact( artifactId, version, type, null );
 778     }
 779
 780     private Artifact createArtifact( String artifactId, String version, String type, String classifier )
 781     {
 782         Artifact artifact = artifactFactory.createDependencyArtifact( "org.apache.maven.archiva.record", artifactId,
 783                                                                       VersionRange.createFromVersion( version ), type,
 784                                                                       classifier, Artifact.SCOPE_RUNTIME );
 785         artifact.isSnapshot();
 786         artifact.setFile( new File( repository.getBasedir(), repository.pathOf( artifact ) ) );
 787         artifact.setRepository( repository );
 788         return artifact;
 789     }
 790 }