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