001 package org.apache.maven.model.interpolation;
002
003 /*
004 * Licensed to the Apache Software Foundation (ASF) under one
005 * or more contributor license agreements. See the NOTICE file
006 * distributed with this work for additional information
007 * regarding copyright ownership. The ASF licenses this file
008 * to you under the Apache License, Version 2.0 (the
009 * "License"); you may not use this file except in compliance
010 * with the License. You may obtain a copy of the License at
011 *
012 * http://www.apache.org/licenses/LICENSE-2.0
013 *
014 * Unless required by applicable law or agreed to in writing,
015 * software distributed under the License is distributed on an
016 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
017 * KIND, either express or implied. See the License for the
018 * specific language governing permissions and limitations
019 * under the License.
020 */
021
022 import org.apache.maven.model.Build;
023 import org.apache.maven.model.Dependency;
024 import org.apache.maven.model.Model;
025 import org.apache.maven.model.Organization;
026 import org.apache.maven.model.Repository;
027 import org.apache.maven.model.Resource;
028 import org.apache.maven.model.Scm;
029 import org.apache.maven.model.building.DefaultModelBuildingRequest;
030 import org.apache.maven.model.building.ModelBuildingRequest;
031 import org.apache.maven.model.building.SimpleProblemCollector;
032 import org.apache.maven.model.path.PathTranslator;
033 import org.codehaus.plexus.PlexusTestCase;
034
035 import java.io.File;
036 import java.text.SimpleDateFormat;
037 import java.util.Calendar;
038 import java.util.Date;
039 import java.util.Iterator;
040 import java.util.List;
041 import java.util.Properties;
042
043 /**
044 * @author jdcasey
045 */
046 public abstract class AbstractModelInterpolatorTest
047 extends PlexusTestCase
048 {
049 private Properties context;
050
051 protected void setUp()
052 throws Exception
053 {
054 super.setUp();
055
056 context = new Properties();
057 context.put( "basedir", "myBasedir" );
058 context.put( "project.baseUri", "myBaseUri" );
059 }
060
061
062 protected void assertProblemFree( SimpleProblemCollector collector )
063 {
064 assertEquals( "Expected no errors", 0, collector.getErrors().size() );
065 assertEquals( "Expected no warnings", 0, collector.getWarnings().size() );
066 assertEquals( "Expected no fatals", 0, collector.getFatals().size() );
067 }
068
069 protected void assertColllectorState( int numFatals, int numErrors, int numWarnings,
070 SimpleProblemCollector collector )
071 {
072 assertEquals( "Errors", numErrors, collector.getErrors().size() );
073 assertEquals( "Warnings", numWarnings, collector.getWarnings().size() );
074 assertEquals( "Fatals", numFatals, collector.getFatals().size() );
075 }
076
077 private ModelBuildingRequest createModelBuildingRequest( Properties p )
078 {
079 ModelBuildingRequest config = new DefaultModelBuildingRequest();
080 if ( p != null )
081 {
082 config.setSystemProperties( p );
083 }
084 return config;
085 }
086
087 public void testDefaultBuildTimestampFormatShouldParseTimeIn24HourFormat()
088 {
089 Calendar cal = Calendar.getInstance();
090 cal.set( Calendar.HOUR, 12 );
091 cal.set( Calendar.AM_PM, Calendar.AM );
092
093 // just to make sure all the bases are covered...
094 cal.set( Calendar.HOUR_OF_DAY, 0 );
095 cal.set( Calendar.MINUTE, 16 );
096 cal.set( Calendar.YEAR, 1976 );
097 cal.set( Calendar.MONTH, Calendar.NOVEMBER );
098 cal.set( Calendar.DATE, 11 );
099
100 Date firstTestDate = cal.getTime();
101
102 cal.set( Calendar.HOUR, 11 );
103 cal.set( Calendar.AM_PM, Calendar.PM );
104
105 // just to make sure all the bases are covered...
106 cal.set( Calendar.HOUR_OF_DAY, 23 );
107
108 Date secondTestDate = cal.getTime();
109
110 SimpleDateFormat format =
111 new SimpleDateFormat( AbstractStringBasedModelInterpolator.DEFAULT_BUILD_TIMESTAMP_FORMAT );
112 assertEquals( "19761111-0016", format.format( firstTestDate ) );
113 assertEquals( "19761111-2316", format.format( secondTestDate ) );
114 }
115
116 public void testShouldNotThrowExceptionOnReferenceToNonExistentValue()
117 throws Exception
118 {
119 Model model = new Model();
120
121 Scm scm = new Scm();
122 scm.setConnection( "${test}/somepath" );
123
124 model.setScm( scm );
125
126 ModelInterpolator interpolator = createInterpolator();
127
128 final SimpleProblemCollector collector = new SimpleProblemCollector();
129 Model out =
130 interpolator.interpolateModel( model, new File( "." ), createModelBuildingRequest( context ), collector );
131
132 assertProblemFree( collector );
133 assertEquals( "${test}/somepath", out.getScm().getConnection() );
134 }
135
136 public void testShouldThrowExceptionOnRecursiveScmConnectionReference()
137 throws Exception
138 {
139 Model model = new Model();
140
141 Scm scm = new Scm();
142 scm.setConnection( "${project.scm.connection}/somepath" );
143
144 model.setScm( scm );
145
146 try
147 {
148 ModelInterpolator interpolator = createInterpolator();
149
150 final SimpleProblemCollector collector = new SimpleProblemCollector();
151 interpolator.interpolateModel( model, null, createModelBuildingRequest( context ), collector );
152 assertColllectorState( 0, 1, 0, collector );
153 }
154 catch ( Exception e )
155 {
156
157 }
158 }
159
160 public void testShouldNotThrowExceptionOnReferenceToValueContainingNakedExpression()
161 throws Exception
162 {
163 Model model = new Model();
164
165 Scm scm = new Scm();
166 scm.setConnection( "${test}/somepath" );
167
168 model.setScm( scm );
169
170 model.addProperty( "test", "test" );
171
172 ModelInterpolator interpolator = createInterpolator();
173
174 final SimpleProblemCollector collector = new SimpleProblemCollector();
175 Model out =
176 interpolator.interpolateModel( model, new File( "." ), createModelBuildingRequest( context ), collector );
177
178 assertProblemFree( collector );
179
180 assertEquals( "test/somepath", out.getScm().getConnection() );
181 }
182
183 public void testShouldInterpolateOrganizationNameCorrectly()
184 throws Exception
185 {
186 String orgName = "MyCo";
187
188 Model model = new Model();
189 model.setName( "${pom.organization.name} Tools" );
190
191 Organization org = new Organization();
192 org.setName( orgName );
193
194 model.setOrganization( org );
195
196 ModelInterpolator interpolator = createInterpolator();
197
198 Model out =
199 interpolator.interpolateModel( model, new File( "." ), createModelBuildingRequest( context ),
200 new SimpleProblemCollector() );
201
202 assertEquals( orgName + " Tools", out.getName() );
203 }
204
205 public void testShouldInterpolateDependencyVersionToSetSameAsProjectVersion()
206 throws Exception
207 {
208 Model model = new Model();
209 model.setVersion( "3.8.1" );
210
211 Dependency dep = new Dependency();
212 dep.setVersion( "${version}" );
213
214 model.addDependency( dep );
215
216 ModelInterpolator interpolator = createInterpolator();
217
218 final SimpleProblemCollector collector = new SimpleProblemCollector();
219 Model out =
220 interpolator.interpolateModel( model, new File( "." ), createModelBuildingRequest( context ), collector );
221 assertColllectorState(0, 0, 1, collector );
222
223 assertEquals( "3.8.1", ( out.getDependencies().get( 0 ) ).getVersion() );
224 }
225
226 public void testShouldNotInterpolateDependencyVersionWithInvalidReference()
227 throws Exception
228 {
229 Model model = new Model();
230 model.setVersion( "3.8.1" );
231
232 Dependency dep = new Dependency();
233 dep.setVersion( "${something}" );
234
235 model.addDependency( dep );
236
237 /*
238 // This is the desired behaviour, however there are too many crappy poms in the repo and an issue with the
239 // timing of executing the interpolation
240
241 try
242 {
243 new RegexBasedModelInterpolator().interpolate( model, context );
244 fail( "Should have failed to interpolate with invalid reference" );
245 }
246 catch ( ModelInterpolationException expected )
247 {
248 assertTrue( true );
249 }
250 */
251
252 ModelInterpolator interpolator = createInterpolator();
253
254 final SimpleProblemCollector collector = new SimpleProblemCollector();
255 Model out =
256 interpolator.interpolateModel( model, new File( "." ), createModelBuildingRequest( context ), collector );
257 assertProblemFree( collector );
258
259 assertEquals( "${something}", ( out.getDependencies().get( 0 ) ).getVersion() );
260 }
261
262 public void testTwoReferences()
263 throws Exception
264 {
265 Model model = new Model();
266 model.setVersion( "3.8.1" );
267 model.setArtifactId( "foo" );
268
269 Dependency dep = new Dependency();
270 dep.setVersion( "${artifactId}-${version}" );
271
272 model.addDependency( dep );
273
274 ModelInterpolator interpolator = createInterpolator();
275
276 final SimpleProblemCollector collector = new SimpleProblemCollector();
277 Model out =
278 interpolator.interpolateModel( model, new File( "." ), createModelBuildingRequest( context ), collector );
279 assertColllectorState( 0, 0, 2, collector );
280
281 assertEquals( "foo-3.8.1", ( out.getDependencies().get( 0 ) ).getVersion() );
282 }
283
284 public void testBasedir()
285 throws Exception
286 {
287 Model model = new Model();
288 model.setVersion( "3.8.1" );
289 model.setArtifactId( "foo" );
290
291 Repository repository = new Repository();
292
293 repository.setUrl( "file://localhost/${basedir}/temp-repo" );
294
295 model.addRepository( repository );
296
297 ModelInterpolator interpolator = createInterpolator();
298
299 final SimpleProblemCollector collector = new SimpleProblemCollector();
300 Model out = interpolator.interpolateModel( model, null, createModelBuildingRequest( context ), collector );
301 assertProblemFree( collector );
302
303 assertEquals( "file://localhost/myBasedir/temp-repo", ( out.getRepositories().get( 0 ) ).getUrl() );
304 }
305
306 public void testBaseUri()
307 throws Exception
308 {
309 Model model = new Model();
310 model.setVersion( "3.8.1" );
311 model.setArtifactId( "foo" );
312
313 Repository repository = new Repository();
314
315 repository.setUrl( "${project.baseUri}/temp-repo" );
316
317 model.addRepository( repository );
318
319 ModelInterpolator interpolator = createInterpolator();
320
321 final SimpleProblemCollector collector = new SimpleProblemCollector();
322 Model out = interpolator.interpolateModel( model, null, createModelBuildingRequest( context ), collector );
323 assertProblemFree( collector );
324
325 assertEquals( "myBaseUri/temp-repo", ( out.getRepositories().get( 0 ) ).getUrl() );
326 }
327
328 public void testEnvars()
329 throws Exception
330 {
331 Properties context = new Properties();
332
333 context.put( "env.HOME", "/path/to/home" );
334
335 Model model = new Model();
336
337 Properties modelProperties = new Properties();
338
339 modelProperties.setProperty( "outputDirectory", "${env.HOME}" );
340
341 model.setProperties( modelProperties );
342
343 ModelInterpolator interpolator = createInterpolator();
344
345 final SimpleProblemCollector collector = new SimpleProblemCollector();
346 Model out =
347 interpolator.interpolateModel( model, new File( "." ), createModelBuildingRequest( context ), collector );
348 assertProblemFree( collector );
349
350 assertEquals( "/path/to/home", out.getProperties().getProperty( "outputDirectory" ) );
351 }
352
353 public void testEnvarExpressionThatEvaluatesToNullReturnsTheLiteralString()
354 throws Exception
355 {
356 Model model = new Model();
357
358 Properties modelProperties = new Properties();
359
360 modelProperties.setProperty( "outputDirectory", "${env.DOES_NOT_EXIST}" );
361
362 model.setProperties( modelProperties );
363
364 ModelInterpolator interpolator = createInterpolator();
365
366 final SimpleProblemCollector collector = new SimpleProblemCollector();
367 Model out =
368 interpolator.interpolateModel( model, new File( "." ), createModelBuildingRequest( context ), collector );
369 assertProblemFree( collector );
370
371 assertEquals( out.getProperties().getProperty( "outputDirectory" ), "${env.DOES_NOT_EXIST}" );
372 }
373
374 public void testExpressionThatEvaluatesToNullReturnsTheLiteralString()
375 throws Exception
376 {
377 Model model = new Model();
378
379 Properties modelProperties = new Properties();
380
381 modelProperties.setProperty( "outputDirectory", "${DOES_NOT_EXIST}" );
382
383 model.setProperties( modelProperties );
384
385 ModelInterpolator interpolator = createInterpolator();
386
387 final SimpleProblemCollector collector = new SimpleProblemCollector();
388 Model out =
389 interpolator.interpolateModel( model, new File( "." ), createModelBuildingRequest( context ), collector );
390 assertProblemFree( collector );
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 }