1 package org.apache.maven.model.interpolation;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 import org.apache.maven.model.Build;
23 import org.apache.maven.model.Dependency;
24 import org.apache.maven.model.Model;
25 import org.apache.maven.model.Organization;
26 import org.apache.maven.model.Repository;
27 import org.apache.maven.model.Resource;
28 import org.apache.maven.model.Scm;
29 import org.apache.maven.model.building.DefaultModelBuildingRequest;
30 import org.apache.maven.model.building.ModelBuildingRequest;
31 import org.apache.maven.model.building.SimpleProblemCollector;
32 import org.apache.maven.model.path.PathTranslator;
33 import org.codehaus.plexus.PlexusTestCase;
34
35 import java.io.File;
36 import java.text.SimpleDateFormat;
37 import java.util.Calendar;
38 import java.util.Date;
39 import java.util.Iterator;
40 import java.util.List;
41 import java.util.Properties;
42
43
44
45
46
47 public abstract class AbstractModelInterpolatorTest
48 extends PlexusTestCase
49 {
50 private Properties context;
51
52 protected void setUp()
53 throws Exception
54 {
55 super.setUp();
56
57 context = new Properties();
58 context.put( "basedir", "myBasedir" );
59 context.put( "project.baseUri", "myBaseUri" );
60 }
61
62
63 protected void assertProblemFree(SimpleProblemCollector collector){
64
65 assertEquals( "Expected no errors", 0, collector.getErrors().size() );
66 assertEquals( "Expected no warnings", 0, collector.getWarnings().size() );
67 assertEquals( "Expected no fatals", 0, collector.getFatals().size() );
68 }
69 protected void assertColllectorState(int numFatals, int numErrors, int numWarnings, SimpleProblemCollector collector){
70 assertEquals( "Errors", numErrors, collector.getErrors().size() );
71 assertEquals( "Warnings", numWarnings, collector.getWarnings().size() );
72 assertEquals( "Fatals", numFatals, collector.getFatals().size() );
73 }
74
75 private ModelBuildingRequest createModelBuildingRequest(Properties p) {
76 ModelBuildingRequest config = new DefaultModelBuildingRequest();
77 if (p!= null) config.setSystemProperties( p);
78 return config;
79 }
80
81 public void testDefaultBuildTimestampFormatShouldParseTimeIn24HourFormat()
82 {
83 Calendar cal = Calendar.getInstance();
84 cal.set( Calendar.HOUR, 12 );
85 cal.set( Calendar.AM_PM, Calendar.AM );
86
87
88 cal.set( Calendar.HOUR_OF_DAY, 0 );
89 cal.set( Calendar.MINUTE, 16 );
90 cal.set( Calendar.YEAR, 1976 );
91 cal.set( Calendar.MONTH, Calendar.NOVEMBER );
92 cal.set( Calendar.DATE, 11 );
93
94 Date firstTestDate = cal.getTime();
95
96 cal.set( Calendar.HOUR, 11 );
97 cal.set( Calendar.AM_PM, Calendar.PM );
98
99
100 cal.set( Calendar.HOUR_OF_DAY, 23 );
101
102 Date secondTestDate = cal.getTime();
103
104 SimpleDateFormat format = new SimpleDateFormat( AbstractStringBasedModelInterpolator.DEFAULT_BUILD_TIMESTAMP_FORMAT );
105 assertEquals( "19761111-0016", format.format( firstTestDate ) );
106 assertEquals( "19761111-2316", format.format( secondTestDate ) );
107 }
108
109 public void testShouldNotThrowExceptionOnReferenceToNonExistentValue()
110 throws Exception
111 {
112 Model model = new Model();
113
114 Scm scm = new Scm();
115 scm.setConnection( "${test}/somepath" );
116
117 model.setScm( scm );
118
119 ModelInterpolator interpolator = createInterpolator();
120
121 final SimpleProblemCollector collector = new SimpleProblemCollector();
122 Model out = interpolator.interpolateModel( model, new File("."), createModelBuildingRequest(context),
123 collector );
124
125 assertProblemFree( collector );
126 assertEquals( "${test}/somepath", out.getScm().getConnection() );
127 }
128
129 public void testShouldThrowExceptionOnRecursiveScmConnectionReference()
130 throws Exception
131 {
132 Model model = new Model();
133
134 Scm scm = new Scm();
135 scm.setConnection( "${project.scm.connection}/somepath" );
136
137 model.setScm( scm );
138
139 try
140 {
141 ModelInterpolator interpolator = createInterpolator();
142
143 final SimpleProblemCollector collector = new SimpleProblemCollector();
144 interpolator.interpolateModel( model, null, createModelBuildingRequest(context), collector );
145 assertColllectorState( 0, 1, 0, collector );
146 }
147 catch ( Exception e )
148 {
149
150 }
151 }
152
153 public void testShouldNotThrowExceptionOnReferenceToValueContainingNakedExpression()
154 throws Exception
155 {
156 Model model = new Model();
157
158 Scm scm = new Scm();
159 scm.setConnection( "${test}/somepath" );
160
161 model.setScm( scm );
162
163 model.addProperty( "test", "test" );
164
165 ModelInterpolator interpolator = createInterpolator();
166
167 final SimpleProblemCollector collector = new SimpleProblemCollector();
168 Model out = interpolator.interpolateModel( model, new File("."), createModelBuildingRequest(context),
169 collector );
170
171 assertProblemFree( collector );
172
173
174 assertEquals( "test/somepath", out.getScm().getConnection() );
175 }
176
177 public void testShouldInterpolateOrganizationNameCorrectly()
178 throws Exception
179 {
180 String orgName = "MyCo";
181
182 Model model = new Model();
183 model.setName( "${pom.organization.name} Tools" );
184
185 Organization org = new Organization();
186 org.setName( orgName );
187
188 model.setOrganization( org );
189
190 ModelInterpolator interpolator = createInterpolator();
191
192 Model out = interpolator.interpolateModel( model, new File("."), createModelBuildingRequest(context), new SimpleProblemCollector() );
193
194 assertEquals( orgName + " Tools", out.getName() );
195 }
196
197 public void testShouldInterpolateDependencyVersionToSetSameAsProjectVersion()
198 throws Exception
199 {
200 Model model = new Model();
201 model.setVersion( "3.8.1" );
202
203 Dependency dep = new Dependency();
204 dep.setVersion( "${version}" );
205
206 model.addDependency( dep );
207
208 ModelInterpolator interpolator = createInterpolator();
209
210 final SimpleProblemCollector collector = new SimpleProblemCollector();
211 Model out = interpolator.interpolateModel( model, new File("."), createModelBuildingRequest(context),
212 collector );
213 assertColllectorState(0, 0, 1, collector );
214
215
216 assertEquals( "3.8.1", ( out.getDependencies().get( 0 ) ).getVersion() );
217 }
218
219 public void testShouldNotInterpolateDependencyVersionWithInvalidReference()
220 throws Exception
221 {
222 Model model = new Model();
223 model.setVersion( "3.8.1" );
224
225 Dependency dep = new Dependency();
226 dep.setVersion( "${something}" );
227
228 model.addDependency( dep );
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245 ModelInterpolator interpolator = createInterpolator();
246
247 final SimpleProblemCollector collector = new SimpleProblemCollector();
248 Model out = interpolator.interpolateModel( model, new File("."), createModelBuildingRequest(context),
249 collector );
250 assertProblemFree( collector );
251
252
253 assertEquals( "${something}", ( out.getDependencies().get( 0 ) ).getVersion() );
254 }
255
256 public void testTwoReferences()
257 throws Exception
258 {
259 Model model = new Model();
260 model.setVersion( "3.8.1" );
261 model.setArtifactId( "foo" );
262
263 Dependency dep = new Dependency();
264 dep.setVersion( "${artifactId}-${version}" );
265
266 model.addDependency( dep );
267
268 ModelInterpolator interpolator = createInterpolator();
269
270 final SimpleProblemCollector collector = new SimpleProblemCollector();
271 Model out = interpolator.interpolateModel( model, new File("."), createModelBuildingRequest(context),
272 collector );
273 assertColllectorState( 0, 0, 2, collector );
274
275 assertEquals( "foo-3.8.1", ( out.getDependencies().get( 0 ) ).getVersion() );
276
277 }
278
279 public void testBasedir()
280 throws Exception
281 {
282 Model model = new Model();
283 model.setVersion( "3.8.1" );
284 model.setArtifactId( "foo" );
285
286 Repository repository = new Repository();
287
288 repository.setUrl( "file://localhost/${basedir}/temp-repo" );
289
290 model.addRepository( repository );
291
292 ModelInterpolator interpolator = createInterpolator();
293
294 final SimpleProblemCollector collector = new SimpleProblemCollector();
295 Model out = interpolator.interpolateModel( model, null, createModelBuildingRequest(context), collector );
296 assertProblemFree( collector );
297
298
299 assertEquals( "file://localhost/myBasedir/temp-repo", ( out.getRepositories().get( 0 ) ).getUrl() );
300 }
301
302 public void testBaseUri()
303 throws Exception
304 {
305 Model model = new Model();
306 model.setVersion( "3.8.1" );
307 model.setArtifactId( "foo" );
308
309 Repository repository = new Repository();
310
311 repository.setUrl( "${project.baseUri}/temp-repo" );
312
313 model.addRepository( repository );
314
315 ModelInterpolator interpolator = createInterpolator();
316
317 final SimpleProblemCollector collector = new SimpleProblemCollector();
318 Model out = interpolator.interpolateModel( model, null, createModelBuildingRequest(context), collector );
319 assertProblemFree( collector );
320
321
322 assertEquals( "myBaseUri/temp-repo", ( out.getRepositories().get( 0 ) ).getUrl() );
323 }
324
325 public void testEnvars()
326 throws Exception
327 {
328 Properties context = new Properties();
329
330 context.put( "env.HOME", "/path/to/home" );
331
332 Model model = new Model();
333
334 Properties modelProperties = new Properties();
335
336 modelProperties.setProperty( "outputDirectory", "${env.HOME}" );
337
338 model.setProperties( modelProperties );
339
340 ModelInterpolator interpolator = createInterpolator();
341
342 final SimpleProblemCollector collector = new SimpleProblemCollector();
343 Model out = interpolator.interpolateModel( model, new File("."), createModelBuildingRequest(context),
344 collector );
345 assertProblemFree( collector );
346
347
348 assertEquals( "/path/to/home", out.getProperties().getProperty( "outputDirectory" ) );
349 }
350
351 public void testEnvarExpressionThatEvaluatesToNullReturnsTheLiteralString()
352 throws Exception
353 {
354 Model model = new Model();
355
356 Properties modelProperties = new Properties();
357
358 modelProperties.setProperty( "outputDirectory", "${env.DOES_NOT_EXIST}" );
359
360 model.setProperties( modelProperties );
361
362 ModelInterpolator interpolator = createInterpolator();
363
364 final SimpleProblemCollector collector = new SimpleProblemCollector();
365 Model out = interpolator.interpolateModel( model, new File("."), createModelBuildingRequest(context),
366 collector );
367 assertProblemFree( collector );
368
369
370 assertEquals( out.getProperties().getProperty( "outputDirectory" ), "${env.DOES_NOT_EXIST}" );
371 }
372
373 public void testExpressionThatEvaluatesToNullReturnsTheLiteralString()
374 throws Exception
375 {
376 Model model = new Model();
377
378 Properties modelProperties = new Properties();
379
380 modelProperties.setProperty( "outputDirectory", "${DOES_NOT_EXIST}" );
381
382 model.setProperties( modelProperties );
383
384 ModelInterpolator interpolator = createInterpolator();
385
386 final SimpleProblemCollector collector = new SimpleProblemCollector();
387 Model out = interpolator.interpolateModel( model, new File("."), createModelBuildingRequest(context),
388 collector );
389 assertProblemFree( collector );
390
391
392 assertEquals( out.getProperties().getProperty( "outputDirectory" ), "${DOES_NOT_EXIST}" );
393 }
394
395 public void testShouldInterpolateSourceDirectoryReferencedFromResourceDirectoryCorrectly()
396 throws Exception
397 {
398 Model model = new Model();
399
400 Build build = new Build();
401 build.setSourceDirectory( "correct" );
402
403 Resource res = new Resource();
404 res.setDirectory( "${project.build.sourceDirectory}" );
405
406 build.addResource( res );
407
408 Resource res2 = new Resource();
409 res2.setDirectory( "${pom.build.sourceDirectory}" );
410
411 build.addResource( res2 );
412
413 Resource res3 = new Resource();
414 res3.setDirectory( "${build.sourceDirectory}" );
415
416 build.addResource( res3 );
417
418 model.setBuild( build );
419
420 ModelInterpolator interpolator = createInterpolator();
421
422 final SimpleProblemCollector collector = new SimpleProblemCollector();
423 Model out = interpolator.interpolateModel( model, null, createModelBuildingRequest(context), collector );
424 assertColllectorState( 0, 0, 2, collector );
425
426
427 List<Resource> outResources = out.getBuild().getResources();
428 Iterator<Resource> resIt = outResources.iterator();
429
430 assertEquals( build.getSourceDirectory(), resIt.next().getDirectory() );
431 assertEquals( build.getSourceDirectory(), resIt.next().getDirectory() );
432 assertEquals( build.getSourceDirectory(), resIt.next().getDirectory() );
433 }
434
435 public void testShouldInterpolateUnprefixedBasedirExpression()
436 throws Exception
437 {
438 File basedir = new File( "/test/path" );
439 Model model = new Model();
440 Dependency dep = new Dependency();
441 dep.setSystemPath( "${basedir}/artifact.jar" );
442
443 model.addDependency( dep );
444
445 ModelInterpolator interpolator = createInterpolator();
446
447 final SimpleProblemCollector collector = new SimpleProblemCollector();
448 Model result = interpolator.interpolateModel( model, basedir, createModelBuildingRequest(context), collector );
449 assertProblemFree( collector );
450
451
452 List<Dependency> rDeps = result.getDependencies();
453 assertNotNull( rDeps );
454 assertEquals( 1, rDeps.size() );
455 assertEquals( new File( basedir, "artifact.jar" ).getAbsolutePath(),
456 new File( rDeps.get( 0 ).getSystemPath() ).getAbsolutePath() );
457 }
458
459 protected abstract ModelInterpolator createInterpolator( PathTranslator translator )
460 throws Exception;
461
462 protected abstract ModelInterpolator createInterpolator()
463 throws Exception;
464
465
466 }