1   package org.apache.maven.model.interpolation;
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.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   * @author jdcasey
45   * @version $Id: AbstractModelInterpolatorTest.java 1028881 2010-10-29 19:05:52Z bentmann $
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          // just to make sure all the bases are covered...
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          // just to make sure all the bases are covered...
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          // This is the desired behaviour, however there are too many crappy poms in the repo and an issue with the
232          // timing of executing the interpolation
233 
234          try
235          {
236          new RegexBasedModelInterpolator().interpolate( model, context );
237          fail( "Should have failed to interpolate with invalid reference" );
238          }
239          catch ( ModelInterpolationException expected )
240          {
241          assertTrue( true );
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 }