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