001package 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
022import org.apache.maven.model.Build;
023import org.apache.maven.model.Dependency;
024import org.apache.maven.model.Model;
025import org.apache.maven.model.Organization;
026import org.apache.maven.model.Repository;
027import org.apache.maven.model.Resource;
028import org.apache.maven.model.Scm;
029import org.apache.maven.model.building.DefaultModelBuildingRequest;
030import org.apache.maven.model.building.ModelBuildingRequest;
031import org.apache.maven.model.building.SimpleProblemCollector;
032import org.apache.maven.model.path.PathTranslator;
033import org.codehaus.plexus.PlexusTestCase;
034
035import java.io.File;
036import java.text.SimpleDateFormat;
037import java.util.Calendar;
038import java.util.Date;
039import java.util.Iterator;
040import java.util.List;
041import java.util.Properties;
042
043/**
044 * @author jdcasey
045 */
046public 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}