1 package org.apache.maven.plugin.ear.it;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 import junit.framework.TestCase;
23 import org.apache.maven.it.VerificationException;
24 import org.apache.maven.it.Verifier;
25 import org.apache.maven.it.util.ResourceExtractor;
26 import org.apache.maven.plugin.ear.util.ResourceEntityResolver;
27 import org.custommonkey.xmlunit.Diff;
28 import org.custommonkey.xmlunit.XMLAssert;
29 import org.custommonkey.xmlunit.examples.RecursiveElementNameAndTextQualifier;
30 import org.xml.sax.helpers.DefaultHandler;
31
32 import javax.xml.parsers.DocumentBuilder;
33 import javax.xml.parsers.DocumentBuilderFactory;
34 import java.io.File;
35 import java.io.FilenameFilter;
36 import java.io.IOException;
37 import java.util.ArrayList;
38 import java.util.Arrays;
39 import java.util.HashMap;
40 import java.util.List;
41 import java.util.Map;
42 import java.util.Properties;
43
44
45
46
47
48
49
50 public abstract class AbstractEarPluginIT
51 extends TestCase
52 {
53
54 protected final String FINAL_NAME_PREFIX = "maven-ear-plugin-test-";
55
56 protected final String FINAL_NAME_SUFFIX = "-99.0";
57
58
59
60
61 private File basedir;
62
63
64
65
66 protected File localRepositoryDir = new File( getBasedir().getAbsolutePath(), "target/test-classes/m2repo" );
67
68 protected File settingsFile = new File( getBasedir().getAbsolutePath(), "target/test-classes/settings.xml" );
69
70
71
72
73
74
75
76
77
78
79 @SuppressWarnings( "unchecked" )
80 protected File executeMojo( final String projectName, final Properties properties, boolean expectNoError )
81 throws Exception
82 {
83 System.out.println( " Building: " + projectName );
84
85 File testDir = getTestDir( projectName );
86 Verifier verifier = new Verifier( testDir.getAbsolutePath() );
87
88 String localRepo = System.getProperty( "localRepositoryPath" );
89 verifier.setLocalRepo( localRepo );
90
91 verifier.getCliOptions().add( "-s \"" + settingsFile.getAbsolutePath() + "\"" );
92 verifier.getCliOptions().add( "-X" );
93 verifier.localRepo = localRepo;
94
95
96 try
97 {
98 verifier.executeGoal( "package" );
99 }
100 catch ( VerificationException e )
101 {
102
103 if ( expectNoError || e.getMessage().indexOf( "Exit code was non-zero" ) == -1 )
104 {
105 throw e;
106 }
107 }
108
109
110 if ( expectNoError )
111 {
112 verifier.verifyErrorFreeLog();
113 }
114 verifier.resetStreams();
115 return testDir;
116 }
117
118
119
120
121
122
123
124
125
126 protected File executeMojo( final String projectName, final Properties properties )
127 throws Exception
128 {
129 return executeMojo( projectName, properties, true );
130 }
131
132
133
134
135
136
137
138
139
140
141
142
143 protected File doTestProject( final String projectName, final String[] expectedArtifacts,
144 final boolean[] artifactsDirectory, boolean testDeploymentDescriptors )
145 throws Exception
146 {
147 final File baseDir = executeMojo( projectName, new Properties() );
148 assertEarArchive( baseDir, projectName );
149 assertEarDirectory( baseDir, projectName );
150
151 assertArchiveContent( baseDir, projectName, expectedArtifacts, artifactsDirectory );
152
153 if ( testDeploymentDescriptors )
154 {
155 assertDeploymentDescriptors( baseDir, projectName );
156 }
157
158 return baseDir;
159
160 }
161
162
163
164
165
166
167
168
169
170
171
172 protected File doTestProject( final String projectName, final String[] expectedArtifacts,
173 final boolean[] artifactsDirectory )
174 throws Exception
175 {
176 return doTestProject( projectName, expectedArtifacts, artifactsDirectory, true );
177
178 }
179
180
181
182
183
184
185
186
187
188
189
190 protected File doTestProject( final String projectName, final String[] expectedArtifacts,
191 boolean testDeploymentDescriptors )
192 throws Exception
193 {
194 return doTestProject( projectName, expectedArtifacts, new boolean[expectedArtifacts.length] );
195 }
196
197
198
199
200
201
202
203
204
205
206 protected File doTestProject( final String projectName, final String[] expectedArtifacts )
207 throws Exception
208 {
209 return doTestProject( projectName, expectedArtifacts, true );
210 }
211
212 protected void assertEarArchive( final File baseDir, final String projectName )
213 {
214 assertTrue( "EAR archive does not exist", getEarArchive( baseDir, projectName ).exists() );
215 }
216
217 protected void assertEarDirectory( final File baseDir, final String projectName )
218 {
219 assertTrue( "EAR archive directory does not exist", getEarDirectory( baseDir, projectName ).exists() );
220 }
221
222 protected File getTargetDirectory( final File basedir )
223 {
224 return new File( basedir, "target" );
225 }
226
227 protected File getEarArchive( final File baseDir, final String projectName )
228 {
229 return new File( getTargetDirectory( baseDir ), buildFinalName( projectName ) + ".ear" );
230 }
231
232 protected File getEarDirectory( final File baseDir, final String projectName )
233 {
234 return new File( getTargetDirectory( baseDir ), buildFinalName( projectName ) );
235 }
236
237 protected String buildFinalName( final String projectName )
238 {
239 return FINAL_NAME_PREFIX + projectName + FINAL_NAME_SUFFIX;
240 }
241
242 protected void assertArchiveContent( final File baseDir, final String projectName, final String[] artifactNames,
243 final boolean[] artifactsDirectory )
244 {
245
246 assertEquals( "Wrong parameter, artifacts mismatch directory flags", artifactNames.length,
247 artifactsDirectory.length );
248
249 File dir = getEarDirectory( baseDir, projectName );
250
251
252 final List<File> expectedDirectories = new ArrayList<File>();
253 for ( int i = 0; i < artifactsDirectory.length; i++ )
254 {
255 if ( artifactsDirectory[i] )
256 {
257 expectedDirectories.add( new File( dir, artifactNames[i] ) );
258 }
259 }
260
261 final List<File> actualFiles = buildArchiveContentFiles( dir, expectedDirectories );
262 assertEquals( "Artifacts mismatch " + actualFiles, artifactNames.length, actualFiles.size() );
263 for ( int i = 0; i < artifactNames.length; i++ )
264 {
265 String artifactName = artifactNames[i];
266 final boolean isDirectory = artifactsDirectory[i];
267 File expectedFile = new File( dir, artifactName );
268
269 assertEquals( "Artifact[" + artifactName + "] not in the right form (exploded/archive", isDirectory,
270 expectedFile.isDirectory() );
271 assertTrue( "Artifact[" + artifactName + "] not found in ear archive",
272 actualFiles.contains( expectedFile ) );
273
274 }
275 }
276
277 protected List<File> buildArchiveContentFiles( final File baseDir, final List<File> expectedDirectories )
278 {
279 final List<File> result = new ArrayList<File>();
280 addFiles( baseDir, result, expectedDirectories );
281
282 return result;
283 }
284
285 private void addFiles( final File directory, final List<File> files, final List<File> expectedDirectories )
286 {
287 File[] result = directory.listFiles( new FilenameFilter()
288 {
289 public boolean accept( File dir, String name )
290 {
291 return !name.equals( "META-INF" );
292 }
293
294 } );
295
296
297
298
299
300
301
302 for ( int i = 0; i < result.length; i++ )
303 {
304 File file = result[i];
305 if ( file.isFile() )
306 {
307 files.add( file );
308 }
309 else if ( expectedDirectories.contains( file ) )
310 {
311 files.add( file );
312 }
313 else
314 {
315 addFiles( file, files, expectedDirectories );
316 }
317 }
318 }
319
320 protected File getBasedir()
321 {
322 if ( basedir != null )
323 {
324 return basedir;
325 }
326
327 final String basedirString = System.getProperty( "basedir" );
328 if ( basedirString == null )
329 {
330 basedir = new File( "" );
331 }
332 else
333 {
334 basedir = new File( basedirString );
335 }
336 return basedir;
337 }
338
339 protected File getTestDir( String projectName )
340 throws IOException
341 {
342 return ResourceExtractor.simpleExtractResources( getClass(), "/projects/" + projectName );
343 }
344
345
346
347
348
349
350
351
352
353
354
355
356
357 protected void assertDeploymentDescriptors( final File baseDir, final String projectName )
358 throws IOException
359 {
360 final File earDirectory = getEarDirectory( baseDir, projectName );
361 final File[] actualDeploymentDescriptors = getDeploymentDescriptors( new File( earDirectory, "META-INF" ) );
362 final File[] expectedDeploymentDescriptors =
363 getDeploymentDescriptors( new File( baseDir, "expected-META-INF" ) );
364
365 if ( expectedDeploymentDescriptors == null )
366 {
367 assertNull( "No deployment descriptor was expected", actualDeploymentDescriptors );
368 }
369 else
370 {
371 assertNotNull( "Missing deployment descriptor", actualDeploymentDescriptors );
372
373
374 assertEquals( "Number of Deployment descriptor(s) mismatch", expectedDeploymentDescriptors.length,
375 actualDeploymentDescriptors.length );
376
377
378 Arrays.sort( expectedDeploymentDescriptors );
379 Arrays.sort( actualDeploymentDescriptors );
380
381 for ( int i = 0; i < expectedDeploymentDescriptors.length; i++ )
382 {
383 File expectedDeploymentDescriptor = expectedDeploymentDescriptors[i];
384 File actualDeploymentDescriptor = actualDeploymentDescriptors[i];
385
386 assertEquals( "File name mismatch", expectedDeploymentDescriptor.getName(),
387 actualDeploymentDescriptor.getName() );
388
389 try
390 {
391 DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
392 dbf.setValidating( true );
393 DocumentBuilder docBuilder = dbf.newDocumentBuilder();
394 docBuilder.setEntityResolver( new ResourceEntityResolver() );
395 docBuilder.setErrorHandler( new DefaultHandler() );
396
397
398
399 final Diff myDiff = new Diff( docBuilder.parse( expectedDeploymentDescriptor ),
400 docBuilder.parse( actualDeploymentDescriptor ) );
401 myDiff.overrideElementQualifier( new RecursiveElementNameAndTextQualifier() );
402 XMLAssert.assertXMLEqual(
403 "Wrong deployment descriptor generated for[" + expectedDeploymentDescriptor.getName() + "]",
404 myDiff, true );
405 }
406 catch ( Exception e )
407 {
408 e.printStackTrace();
409 fail( "Could not assert deployment descriptor " + e.getMessage() );
410 }
411 }
412 }
413 }
414
415 private File[] getDeploymentDescriptors( final File ddDirectory )
416 {
417 return ddDirectory.listFiles( new FilenameFilter()
418 {
419 public boolean accept( File dir, String name )
420 {
421 return !name.equalsIgnoreCase( "manifest.mf" );
422 }
423 } );
424 }
425 }