1   package org.apache.maven.project.injection;
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.DependencyManagement;
25  import org.apache.maven.model.Exclusion;
26  import org.apache.maven.model.Model;
27  import org.apache.maven.model.Plugin;
28  import org.apache.maven.model.PluginManagement;
29  
30  import java.util.List;
31  import java.util.Map;
32  
33  import junit.framework.TestCase;
34  
35  /**
36   * @author jdcasey
37   */
38  public class DefaultModelDefaultsInjectorTest
39      extends TestCase
40  {
41      public void testShouldConstructWithNoParams()
42      {
43          new DefaultModelDefaultsInjector();
44      }
45  
46      public void testShouldMergePluginManagementVersionIntoPlugin()
47      {
48          String groupId = "org.apache.maven.plugins";
49          String artifactId = "maven-test-plugin";
50  
51          Model model = new Model();
52          Build build = new Build();
53          Plugin targetPlugin = new Plugin();
54          targetPlugin.setGroupId( groupId );
55          targetPlugin.setArtifactId( artifactId );
56  
57          build.addPlugin( targetPlugin );
58  
59          PluginManagement pMgmt = new PluginManagement();
60          Plugin managedPlugin = new Plugin();
61          managedPlugin.setGroupId( groupId );
62          managedPlugin.setArtifactId( artifactId );
63          managedPlugin.setVersion( "10.0.0" );
64  
65          pMgmt.addPlugin( managedPlugin );
66          build.setPluginManagement( pMgmt );
67          model.setBuild( build );
68  
69          new DefaultModelDefaultsInjector().injectDefaults( model );
70  
71          Map pMap = model.getBuild().getPluginsAsMap();
72          Plugin result = (Plugin) pMap.get( groupId + ":" + artifactId );
73  
74          assertNotNull( result );
75          assertEquals( managedPlugin.getVersion(), result.getVersion() );
76      }
77  
78      public void testShouldKeepPluginVersionOverPluginManagementVersion()
79      {
80          String groupId = "org.apache.maven.plugins";
81          String artifactId = "maven-test-plugin";
82  
83          Model model = new Model();
84          Build build = new Build();
85          Plugin targetPlugin = new Plugin();
86          targetPlugin.setGroupId( groupId );
87          targetPlugin.setArtifactId( artifactId );
88          targetPlugin.setVersion( "9.0.0" );
89  
90          build.addPlugin( targetPlugin );
91  
92          PluginManagement pMgmt = new PluginManagement();
93          Plugin managedPlugin = new Plugin();
94          managedPlugin.setGroupId( groupId );
95          managedPlugin.setArtifactId( artifactId );
96          managedPlugin.setVersion( "10.0.0" );
97  
98          pMgmt.addPlugin( managedPlugin );
99          build.setPluginManagement( pMgmt );
100         model.setBuild( build );
101 
102         new DefaultModelDefaultsInjector().injectDefaults( model );
103 
104         Map pMap = model.getBuild().getPluginsAsMap();
105         Plugin result = (Plugin) pMap.get( groupId + ":" + artifactId );
106 
107         assertNotNull( result );
108         assertEquals( targetPlugin.getVersion(), result.getVersion() );
109     }
110 
111     public void testShouldMergeManagedDependencyOfTypeEJBToDependencyList()
112     {
113         Model model = new Model();
114 
115         Dependency managedDep = new Dependency();
116 
117         managedDep.setGroupId( "group" );
118         managedDep.setArtifactId( "artifact" );
119         managedDep.setVersion( "1.0" );
120         managedDep.setType( "ejb" );
121 
122         DependencyManagement depMgmt = new DependencyManagement();
123 
124         depMgmt.addDependency( managedDep );
125 
126         model.setDependencyManagement( depMgmt );
127 
128         Dependency dep = new Dependency();
129 
130         dep.setGroupId( "group" );
131         dep.setArtifactId( "artifact" );
132 
133         // looks like groupId:artifactId:type is the minimum for identification, where
134         // type is defaulted to "jar".
135         dep.setType( "ejb" );
136 
137         model.addDependency( dep );
138 
139         new DefaultModelDefaultsInjector().injectDefaults( model );
140 
141         List resultingDeps = model.getDependencies();
142 
143         assertEquals( 1, resultingDeps.size() );
144 
145         Dependency result = (Dependency) resultingDeps.get( 0 );
146 
147         assertEquals( "1.0", result.getVersion() );
148     }
149 
150     public void testShouldSucceedInMergingDependencyWithDependency()
151     {
152         Model model = new Model();
153 
154         Dependency dep = new Dependency();
155         dep.setGroupId( "myGroup" );
156         dep.setArtifactId( "myArtifact" );
157 
158         model.addDependency( dep );
159 
160         Dependency def = new Dependency();
161         def.setGroupId( dep.getGroupId() );
162         def.setArtifactId( dep.getArtifactId() );
163         def.setVersion( "1.0.1" );
164         def.setScope( "scope" );
165 
166         DependencyManagement depMgmt = new DependencyManagement();
167 
168         depMgmt.addDependency( def );
169 
170         model.setDependencyManagement( depMgmt );
171 
172         new DefaultModelDefaultsInjector().injectDefaults( model );
173 
174         List deps = model.getDependencies();
175         assertEquals( 1, deps.size() );
176 
177         Dependency result = (Dependency) deps.get( 0 );
178         assertEquals( def.getVersion(), result.getVersion() );
179     }
180 
181     public void testShouldMergeDependencyExclusionsFromDefaultsToDependency()
182     {
183         Model model = new Model();
184 
185         Dependency dep = new Dependency();
186         dep.setGroupId( "myGroup" );
187         dep.setArtifactId( "myArtifact" );
188 
189         model.addDependency( dep );
190 
191         Dependency def = new Dependency();
192         def.setGroupId( dep.getGroupId() );
193         def.setArtifactId( dep.getArtifactId() );
194         def.setVersion( "1.0.1" );
195         def.setScope( "scope" );
196 
197         Exclusion exc = new Exclusion();
198         exc.setArtifactId( "mydep" );
199         exc.setGroupId( "mygrp" );
200 
201         def.addExclusion( exc );
202 
203         DependencyManagement depMgmt = new DependencyManagement();
204 
205         depMgmt.addDependency( def );
206 
207         model.setDependencyManagement( depMgmt );
208 
209         new DefaultModelDefaultsInjector().injectDefaults( model );
210 
211         List deps = model.getDependencies();
212         assertEquals( 1, deps.size() );
213 
214         Dependency result = (Dependency) deps.get( 0 );
215         assertEquals( def.getVersion(), result.getVersion() );
216 
217         List resultExclusions = result.getExclusions();
218         assertNotNull( resultExclusions );
219         assertEquals( 1, resultExclusions.size() );
220 
221         Exclusion resultExclusion = (Exclusion) resultExclusions.get( 0 );
222         assertEquals( "mydep", resultExclusion.getArtifactId() );
223         assertEquals( "mygrp", resultExclusion.getGroupId() );
224     }
225 
226     public void testShouldMergeDefaultUrlAndArtifactWhenDependencyDoesntSupplyVersion()
227     {
228         Model model = new Model();
229 
230         Dependency dep = new Dependency();
231         dep.setGroupId( "myGroup" );
232         dep.setArtifactId( "myArtifact" );
233 
234         model.addDependency( dep );
235 
236         Dependency def = new Dependency();
237         def.setGroupId( dep.getGroupId() );
238         def.setArtifactId( dep.getArtifactId() );
239         def.setVersion( "1.0.1" );
240 
241         DependencyManagement depMgmt = new DependencyManagement();
242 
243         depMgmt.addDependency( def );
244 
245         model.setDependencyManagement( depMgmt );
246 
247         new DefaultModelDefaultsInjector().injectDefaults( model );
248 
249         List deps = model.getDependencies();
250         assertEquals( 1, deps.size() );
251 
252         Dependency result = (Dependency) deps.get( 0 );
253         assertEquals( def.getVersion(), result.getVersion() );
254     }
255 
256     public void testShouldNotMergeDefaultUrlOrArtifactWhenDependencySuppliesVersion()
257     {
258         Model model = new Model();
259 
260         Dependency dep = new Dependency();
261         dep.setGroupId( "myGroup" );
262         dep.setArtifactId( "myArtifact" );
263         dep.setVersion( "1.0.1" );
264 
265         model.addDependency( dep );
266 
267         Dependency def = new Dependency();
268         def.setGroupId( dep.getGroupId() );
269         def.setArtifactId( dep.getArtifactId() );
270 
271         DependencyManagement depMgmt = new DependencyManagement();
272 
273         depMgmt.addDependency( def );
274 
275         model.setDependencyManagement( depMgmt );
276 
277         new DefaultModelDefaultsInjector().injectDefaults( model );
278 
279         List deps = model.getDependencies();
280         assertEquals( 1, deps.size() );
281 
282         Dependency result = (Dependency) deps.get( 0 );
283         assertEquals( dep.getVersion(), result.getVersion() );
284     }
285 
286     public void testShouldMergeDefaultPropertiesWhenDependencyDoesntSupplyProperties()
287     {
288         Model model = new Model();
289 
290         Dependency dep = new Dependency();
291         dep.setGroupId( "myGroup" );
292         dep.setArtifactId( "myArtifact" );
293         dep.setVersion( "1.0.1" );
294 
295         model.addDependency( dep );
296 
297         Dependency def = new Dependency();
298         def.setGroupId( dep.getGroupId() );
299         def.setArtifactId( dep.getArtifactId() );
300 
301         DependencyManagement depMgmt = new DependencyManagement();
302 
303         depMgmt.addDependency( def );
304 
305         model.setDependencyManagement( depMgmt );
306 
307         new DefaultModelDefaultsInjector().injectDefaults( model );
308 
309         List deps = model.getDependencies();
310         assertEquals( 1, deps.size() );
311     }
312 
313     public void testShouldNotMergeDefaultPropertiesWhenDependencySuppliesProperties()
314     {
315         Model model = new Model();
316 
317         Dependency dep = new Dependency();
318         dep.setGroupId( "myGroup" );
319         dep.setArtifactId( "myArtifact" );
320         dep.setVersion( "1.0.1" );
321 
322         model.addDependency( dep );
323 
324         Dependency def = new Dependency();
325         def.setGroupId( dep.getGroupId() );
326         def.setArtifactId( dep.getArtifactId() );
327 
328         DependencyManagement depMgmt = new DependencyManagement();
329 
330         depMgmt.addDependency( def );
331 
332         model.setDependencyManagement( depMgmt );
333 
334         new DefaultModelDefaultsInjector().injectDefaults( model );
335 
336         List deps = model.getDependencies();
337         assertEquals( 1, deps.size() );
338     }
339 
340     public void testShouldMergeDefaultScopeWhenDependencyDoesntSupplyScope()
341     {
342         Model model = new Model();
343 
344         Dependency dep = new Dependency();
345         dep.setGroupId( "myGroup" );
346         dep.setArtifactId( "myArtifact" );
347         dep.setVersion( "1.0.1" );
348         dep.setScope( "scope" );
349 
350         model.addDependency( dep );
351 
352         Dependency def = new Dependency();
353         def.setGroupId( dep.getGroupId() );
354         def.setArtifactId( dep.getArtifactId() );
355 
356         DependencyManagement depMgmt = new DependencyManagement();
357 
358         depMgmt.addDependency( def );
359 
360         model.setDependencyManagement( depMgmt );
361 
362         new DefaultModelDefaultsInjector().injectDefaults( model );
363 
364         List deps = model.getDependencies();
365         assertEquals( 1, deps.size() );
366 
367         Dependency result = (Dependency) deps.get( 0 );
368 
369         assertEquals( "scope", result.getScope() );
370     }
371 
372     public void testShouldNotMergeDefaultScopeWhenDependencySuppliesScope()
373     {
374         Model model = new Model();
375 
376         Dependency dep = new Dependency();
377         dep.setGroupId( "myGroup" );
378         dep.setArtifactId( "myArtifact" );
379         dep.setVersion( "1.0.1" );
380         dep.setScope( "scope" );
381 
382         model.addDependency( dep );
383 
384         Dependency def = new Dependency();
385         def.setGroupId( dep.getGroupId() );
386         def.setArtifactId( dep.getArtifactId() );
387         def.setScope( "default" );
388 
389         DependencyManagement depMgmt = new DependencyManagement();
390 
391         depMgmt.addDependency( def );
392 
393         model.setDependencyManagement( depMgmt );
394 
395         new DefaultModelDefaultsInjector().injectDefaults( model );
396 
397         List deps = model.getDependencies();
398         assertEquals( 1, deps.size() );
399 
400         Dependency result = (Dependency) deps.get( 0 );
401         assertEquals( "scope", result.getScope() );
402     }
403 
404     public void testShouldRejectDependencyWhereNoVersionIsFoundAfterDefaultsInjection()
405     {
406         Model model = new Model();
407 
408         Dependency dep = new Dependency();
409         dep.setGroupId( "myGroup" );
410         dep.setArtifactId( "myArtifact" );
411 
412         model.addDependency( dep );
413 
414         Dependency def = new Dependency();
415         def.setGroupId( dep.getGroupId() );
416         def.setArtifactId( dep.getArtifactId() );
417 
418         DependencyManagement depMgmt = new DependencyManagement();
419 
420         depMgmt.addDependency( def );
421 
422         model.setDependencyManagement( depMgmt );
423 
424 //        try
425 //        {
426         new DefaultModelDefaultsInjector().injectDefaults( model );
427         Dependency dependency = (Dependency) model.getDependencies().get( 0 );
428         assertNull( "check version is null", dependency.getVersion() );
429 //            fail("Should fail to validate dependency without a version.");
430 //        }
431 //        catch ( IllegalStateException e )
432 //        {
433 //            // should throw when it detects a missing version in the test dependency.
434 //        }
435     }
436 
437 }