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
24 import org.apache.maven.it.VerificationException;
25 import org.apache.maven.it.Verifier;
26 import org.apache.maven.it.util.ResourceExtractor;
27 import org.codehaus.plexus.util.ReaderFactory;
28 import org.custommonkey.xmlunit.Diff;
29 import org.custommonkey.xmlunit.XMLAssert;
30 import org.custommonkey.xmlunit.examples.RecursiveElementNameAndTextQualifier;
31
32 import java.io.File;
33 import java.io.FilenameFilter;
34 import java.io.IOException;
35 import java.io.Reader;
36 import java.util.ArrayList;
37 import java.util.Arrays;
38 import java.util.List;
39 import java.util.Properties;
40
41
42
43
44
45
46
47 public abstract class AbstractEarPluginIT
48 extends TestCase
49 {
50
51 protected final String FINAL_NAME_PREFIX = "maven-ear-plugin-test-";
52
53 protected final String FINAL_NAME_SUFFIX = "-99.0";
54
55
56
57
58 private File basedir;
59
60
61
62
63 protected File localRepositoryDir = new File( getBasedir().getAbsolutePath(), "target/test-classes/m2repo" );
64
65 protected File settingsFile = new File( getBasedir().getAbsolutePath(), "target/test-classes/settings.xml" );
66
67
68
69
70
71
72
73
74
75
76 protected File executeMojo( final String projectName, final Properties properties, boolean expectNoError )
77 throws Exception
78 {
79 System.out.println( " Building: " + projectName );
80
81 File testDir = getTestDir( projectName );
82 Verifier verifier = new Verifier( testDir.getAbsolutePath() );
83
84 verifier.getCliOptions().add( "-s \"" + settingsFile.getAbsolutePath() + "\"" );
85 verifier.getCliOptions().add( "-X" );
86 verifier.localRepo = localRepositoryDir.getAbsolutePath();
87
88
89 try
90 {
91 verifier.executeGoal( "package" );
92 }
93 catch ( VerificationException e )
94 {
95
96 if ( expectNoError || e.getMessage().indexOf( "Exit code was non-zero" ) == -1 )
97 {
98 throw e;
99 }
100 }
101
102
103 if ( expectNoError )
104 {
105 verifier.verifyErrorFreeLog();
106 }
107 verifier.resetStreams();
108 return testDir;
109 }
110
111
112
113
114
115
116
117
118
119 protected File executeMojo( final String projectName, final Properties properties )
120 throws Exception
121 {
122 return executeMojo( projectName, properties, true );
123 }
124
125
126
127
128
129
130
131
132
133
134
135
136 protected File doTestProject( final String projectName, final String[] expectedArtifacts,
137 final boolean[] artifactsDirectory, boolean testDeploymentDescriptors )
138 throws Exception
139 {
140 final File baseDir = executeMojo( projectName, new Properties() );
141 assertEarArchive( baseDir, projectName );
142 assertEarDirectory( baseDir, projectName );
143
144 assertArchiveContent( baseDir, projectName, expectedArtifacts, artifactsDirectory );
145
146 if ( testDeploymentDescriptors )
147 {
148 assertDeploymentDescriptors( baseDir, projectName );
149 }
150
151 return baseDir;
152
153 }
154
155
156
157
158
159
160
161
162
163
164
165 protected File doTestProject( final String projectName, final String[] expectedArtifacts,
166 final boolean[] artifactsDirectory )
167 throws Exception
168 {
169 return doTestProject( projectName, expectedArtifacts, artifactsDirectory, true );
170
171 }
172
173
174
175
176
177
178
179
180
181
182
183 protected File doTestProject( final String projectName, final String[] expectedArtifacts,
184 boolean testDeploymentDescriptors )
185 throws Exception
186 {
187 return doTestProject( projectName, expectedArtifacts, new boolean[expectedArtifacts.length] );
188 }
189
190
191
192
193
194
195
196
197
198
199 protected File doTestProject( final String projectName, final String[] expectedArtifacts )
200 throws Exception
201 {
202 return doTestProject( projectName, expectedArtifacts, true );
203 }
204
205 protected void assertEarArchive( final File baseDir, final String projectName )
206 {
207 assertTrue( "EAR archive does not exist", getEarArchive( baseDir, projectName ).exists() );
208 }
209
210 protected void assertEarDirectory( final File baseDir, final String projectName )
211 {
212 assertTrue( "EAR archive directory does not exist", getEarDirectory( baseDir, projectName ).exists() );
213 }
214
215 protected File getTargetDirectory( final File basedir )
216 {
217 return new File( basedir, "target" );
218 }
219
220 protected File getEarArchive( final File baseDir, final String projectName )
221 {
222 return new File( getTargetDirectory( baseDir ), buildFinalName( projectName ) + ".ear" );
223 }
224
225 protected File getEarDirectory( final File baseDir, final String projectName )
226 {
227 return new File( getTargetDirectory( baseDir ), buildFinalName( projectName ) );
228 }
229
230 protected String buildFinalName( final String projectName )
231 {
232 return FINAL_NAME_PREFIX + projectName + FINAL_NAME_SUFFIX;
233 }
234
235 protected void assertArchiveContent( final File baseDir, final String projectName, final String[] artifactNames,
236 final boolean[] artifactsDirectory )
237 {
238
239 assertEquals( "Wrong parameter, artifacts mismatch directory flags", artifactNames.length,
240 artifactsDirectory.length );
241
242 File dir = getEarDirectory( baseDir, projectName );
243
244
245 final List expectedDirectories = new ArrayList();
246 for ( int i = 0; i < artifactsDirectory.length; i++ )
247 {
248 if ( artifactsDirectory[i] )
249 {
250 expectedDirectories.add( new File( dir, artifactNames[i] ) );
251 }
252 }
253
254 final List actualFiles = buildArchiveContentFiles( dir, expectedDirectories );
255 assertEquals( "Artifacts mismatch " + actualFiles, artifactNames.length, actualFiles.size() );
256 for ( int i = 0; i < artifactNames.length; i++ )
257 {
258 String artifactName = artifactNames[i];
259 final boolean isDirectory = artifactsDirectory[i];
260 File expectedFile = new File( dir, artifactName );
261
262 assertEquals( "Artifact[" + artifactName + "] not in the right form (exploded/archive", isDirectory,
263 expectedFile.isDirectory() );
264 assertTrue( "Artifact[" + artifactName + "] not found in ear archive",
265 actualFiles.contains( expectedFile ) );
266
267 }
268 }
269
270 protected List buildArchiveContentFiles( final File baseDir, final List expectedDirectories )
271 {
272 final List result = new ArrayList();
273 addFiles( baseDir, result, expectedDirectories );
274
275 return result;
276 }
277
278 private void addFiles( final File directory, final List files, final List expectedDirectories )
279 {
280 File[] result = directory.listFiles( new FilenameFilter()
281 {
282 public boolean accept( File dir, String name )
283 {
284 if ( name.equals( "META-INF" ) )
285 {
286 return false;
287 }
288 else
289 {
290 return true;
291 }
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 Reader expected = null;
390 Reader actual = null;
391 try
392 {
393 expected = ReaderFactory.newXmlReader( expectedDeploymentDescriptor );
394 actual = ReaderFactory.newXmlReader( actualDeploymentDescriptor );
395
396
397
398 final Diff myDiff = new Diff( expected, actual );
399 myDiff.overrideElementQualifier( new RecursiveElementNameAndTextQualifier() );
400 XMLAssert.assertXMLEqual(
401 "Wrong deployment descriptor generated for[" + expectedDeploymentDescriptor.getName() + "]",
402 myDiff, true );
403 }
404 catch ( Exception e )
405 {
406 e.printStackTrace();
407 fail( "Could not assert deployment descriptor " + e.getMessage() );
408 }
409 finally
410 {
411 if ( expected != null )
412 {
413 expected.close();
414 }
415 if ( actual != null )
416 {
417 actual.close();
418 }
419 }
420 }
421 }
422 }
423
424 private File[] getDeploymentDescriptors( final File ddDirectory )
425 {
426 return ddDirectory.listFiles( new FilenameFilter()
427 {
428
429 public boolean accept( File dir, String name )
430 {
431 return !name.equalsIgnoreCase( "manifest.mf" );
432 }
433 } );
434 }
435 }