View Javadoc
1   package org.apache.maven.surefire.its;
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.surefire.its.fixture.Settings;
23  import org.apache.maven.surefire.its.fixture.SurefireJUnit4IntegrationTestCase;
24  import org.apache.maven.surefire.its.fixture.SurefireLauncher;
25  import org.junit.Test;
26  
27  import static org.apache.maven.surefire.its.fixture.TestFramework.*;
28  import static org.apache.maven.surefire.its.fixture.Configuration.*;
29  import static org.hamcrest.core.AnyOf.anyOf;
30  import static org.hamcrest.core.Is.is;
31  import static org.junit.Assume.assumeThat;
32  
33  /**
34   * Test project using multiple method patterns, including wildcards in class and method names.
35   */
36  public abstract class AbstractTestMultipleMethodPatterns
37      extends SurefireJUnit4IntegrationTestCase
38  {
39      private static final String CSV_DELIMITER_SHORT = ",";
40      private static final String CSV_DELIMITER_LONG = ", ";
41      private static final String NOT_DELIMITER = "!";
42  
43      protected abstract Settings getSettings();
44  
45      protected abstract SurefireLauncher unpack();
46  
47      protected SurefireLauncher prepare( String tests )
48      {
49          SurefireLauncher launcher = unpack().addGoal( "-P " + getSettings().profile() );
50          String[] includedExcluded = splitIncludesExcludes( tests );
51          switch ( getSettings().getConfiguration() ) {
52              case TEST:
53                  launcher.setTestToRun( tests );
54                  break;
55              case INCLUDES:
56                  launcher.sysProp( "included", tests );
57                  break;
58              case INCLUDES_EXCLUDES:
59                  launcher.sysProp( "included", includedExcluded[0] );
60                  launcher.sysProp( "excluded", includedExcluded[1] );
61                  break;
62              default:
63                  throw new IllegalArgumentException( "Unsupported configuration " + getSettings().getConfiguration() );
64          }
65          return launcher;
66      }
67  
68      private static String[] splitIncludesExcludes( String patterns )
69      {
70          String included = "";
71          String excluded = "";
72          for ( String pattern : patterns.split( CSV_DELIMITER_SHORT ) )
73          {
74              pattern = pattern.trim();
75              if ( pattern.startsWith( NOT_DELIMITER ) )
76              {
77                  excluded += pattern.substring( NOT_DELIMITER.length() ).trim();
78                  excluded += CSV_DELIMITER_LONG;
79              }
80              else
81              {
82                  included += pattern;
83                  included += CSV_DELIMITER_LONG;
84              }
85          }
86          return new String[]{ trimEndComma( included ), trimEndComma( excluded ) };
87      }
88  
89      private static String trimEndComma( String pattern )
90      {
91          pattern = pattern.trim();
92          return pattern.endsWith( CSV_DELIMITER_LONG )
93              ? pattern.substring( 0, pattern.length() - CSV_DELIMITER_LONG.length() ) : pattern;
94      }
95  
96      @Test
97      public void simpleNameTest()
98          throws Exception
99      {
100         prepare( "TestTwo" )
101             .executeTest()
102             .verifyErrorFree( 2 )
103             .verifyErrorFreeLog()
104             .verifyTextInLog( "jiras.surefire745.TestTwo#testSuccessOne" )
105             .verifyTextInLog( "jiras.surefire745.TestTwo#testSuccessTwo" );
106     }
107 
108     @Test
109     public void simpleNameTestAsParallel()
110         throws Exception
111     {
112         assumeThat( getSettings().getFramework(), anyOf( is( JUNIT47 ), is( TestNG ) ) );
113         prepare( "TestTwo" )
114             .parallel( "classes" )
115             .useUnlimitedThreads()
116             .executeTest()
117             .verifyErrorFree( 2 )
118             .verifyErrorFreeLog()
119             .verifyTextInLog( "jiras.surefire745.TestTwo#testSuccessOne" )
120             .verifyTextInLog( "jiras.surefire745.TestTwo#testSuccessTwo" );
121     }
122 
123     @Test
124     public void simpleNameTestWithJavaExt()
125         throws Exception
126     {
127         prepare( "TestTwo.java" )
128             .executeTest()
129             .verifyErrorFree( 2 )
130             .verifyErrorFreeLog()
131             .verifyTextInLog( "jiras.surefire745.TestTwo#testSuccessOne" )
132             .verifyTextInLog( "jiras.surefire745.TestTwo#testSuccessTwo" );
133     }
134 
135     @Test
136     public void simpleNameTestWithWildcardPkg()
137         throws Exception
138     {
139         prepare( "**/TestTwo" )
140             .executeTest()
141             .verifyErrorFree( 2 )
142             .verifyErrorFreeLog()
143             .verifyTextInLog( "jiras.surefire745.TestTwo#testSuccessOne" )
144             .verifyTextInLog( "jiras.surefire745.TestTwo#testSuccessTwo" );
145     }
146 
147     @Test
148     public void simpleNameTestWithJavaExtWildcardPkg()
149         throws Exception
150     {
151         prepare( "**/TestTwo.java" )
152             .executeTest()
153             .verifyErrorFree( 2 )
154             .verifyErrorFreeLog()
155             .verifyTextInLog( "jiras.surefire745.TestTwo#testSuccessOne" )
156             .verifyTextInLog( "jiras.surefire745.TestTwo#testSuccessTwo" );
157     }
158 
159     @Test
160     public void fullyQualifiedTest()
161         throws Exception
162     {
163         prepare( "jiras/surefire745/TestTwo.java" )
164             .executeTest()
165             .verifyErrorFree( 2 )
166             .verifyErrorFreeLog()
167             .verifyTextInLog( "jiras.surefire745.TestTwo#testSuccessOne" )
168             .verifyTextInLog( "jiras.surefire745.TestTwo#testSuccessTwo" );
169     }
170 
171     @Test
172     public void shouldMatchSimpleClassNameAndMethod()
173         throws Exception
174     {
175         assumeThat( getSettings().getConfiguration(), is( TEST ) );
176         prepare( "BasicTest#testSuccessTwo" )
177             .executeTest()
178             .verifyErrorFree( 1 )
179             .verifyErrorFreeLog()
180             .verifyTextInLog( "jiras.surefire745.BasicTest#testSuccessTwo" );
181     }
182 
183     /**
184      * This method name was shorten because it cause 261 character long path on Windows with Jenkins Pipeline.
185      */
186     @Test
187     public void matchSimpleClassAndMethodWithJavaExt()
188     {
189         assumeThat( getSettings().getConfiguration(), is( TEST ) );
190         prepare( "BasicTest.java#testSuccessTwo" )
191             .executeTest()
192             .verifyErrorFree( 1 )
193             .verifyErrorFreeLog()
194             .verifyTextInLog( "jiras.surefire745.BasicTest#testSuccessTwo" );
195     }
196 
197     /**
198      * This method name was shorten because it cause 261 character long path on Windows with Jenkins Pipeline.
199      */
200     @Test
201     public void matchSimpleClassAndMethodWithWildcardPkg()
202     {
203         assumeThat( getSettings().getConfiguration(), is( TEST ) );
204         prepare( "**/BasicTest#testSuccessTwo" )
205             .executeTest()
206             .verifyErrorFree( 1 )
207             .verifyErrorFreeLog()
208             .verifyTextInLog( "jiras.surefire745.BasicTest#testSuccessTwo" );
209     }
210 
211     /**
212      * This method name was shorten because it cause 261 character long path on Windows with Jenkins Pipeline.
213      */
214     @Test
215     public void matchSimpleClassAndMethodWithJavaExtWildcardPkg()
216     {
217         assumeThat( getSettings().getConfiguration(), is( TEST ) );
218         prepare( "**/BasicTest.java#testSuccessTwo" )
219             .executeTest()
220             .verifyErrorFree( 1 )
221             .verifyErrorFreeLog()
222             .verifyTextInLog( "jiras.surefire745.BasicTest#testSuccessTwo" );
223     }
224 
225     @Test
226     public void shouldMatchWildcardPackageAndClassAndMethod()
227         throws Exception
228     {
229         assumeThat( getSettings().getConfiguration(), is( TEST ) );
230         prepare( "jiras/**/BasicTest#testSuccessTwo" )
231             .executeTest()
232             .verifyErrorFree( 1 )
233             .verifyErrorFreeLog()
234             .verifyTextInLog( "jiras.surefire745.BasicTest#testSuccessTwo" );
235     }
236 
237     @Test
238     public void regexClass()
239         throws Exception
240     {
241         prepare( "%regex[.*.TestTwo.*]" )
242             .executeTest()
243             .verifyErrorFree( 2 )
244             .verifyErrorFreeLog()
245             .verifyTextInLog( "jiras.surefire745.TestTwo#testSuccessOne" )
246             .verifyTextInLog( "jiras.surefire745.TestTwo#testSuccessTwo" );
247     }
248 
249     @Test
250     public void testSuccessTwo()
251         throws Exception
252     {
253         assumeThat( getSettings().getConfiguration(), is( TEST ) );
254         prepare( "#testSuccessTwo" )
255             .maven().debugLogging()
256             .executeTest()
257             .verifyErrorFree( 5 )
258             .verifyErrorFreeLog();
259     }
260 
261     @Test
262     public void testRegexSuccessTwo()
263         throws Exception
264     {
265         assumeThat( getSettings().getConfiguration(), is( TEST ) );
266         prepare( "%regex[#testSuccessTwo]" )
267             .executeTest()
268             .verifyErrorFree( 5 )
269             .verifyErrorFreeLog();
270     }
271 
272     @Test
273     public void regexClassAndMethod()
274         throws Exception
275     {
276         assumeThat( getSettings().getConfiguration(), is( TEST ) );
277         prepare( "%regex[.*.BasicTest.*#testSuccessTwo]" )
278             .executeTest()
279             .verifyErrorFree( 1 )
280             .verifyErrorFreeLog()
281             .verifyTextInLog( "jiras.surefire745.BasicTest#testSuccessTwo" );
282     }
283 
284     @Test
285     public void shouldMatchExactClassAndMethodWildcard()
286         throws Exception
287     {
288         assumeThat( getSettings().getConfiguration(), is( TEST ) );
289         prepare( "BasicTest#test*One" )
290             .executeTest()
291             .verifyErrorFree( 1 )
292             .verifyErrorFreeLog()
293             .verifyTextInLog( "jiras.surefire745.BasicTest#testSuccessOne" );
294     }
295 
296     @Test
297     public void shouldMatchExactClassAndMethodsWildcard()
298         throws Exception
299     {
300         assumeThat( getSettings().getConfiguration(), is( TEST ) );
301         prepare( "BasicTest#testSuccess*" )
302             .executeTest()
303             .verifyErrorFree( 2 )
304             .verifyErrorFreeLog()
305             .verifyTextInLog( "jiras.surefire745.BasicTest#testSuccessOne" )
306             .verifyTextInLog( "jiras.surefire745.BasicTest#testSuccessTwo" );
307     }
308 
309     @Test
310     public void shouldMatchExactClassAndMethodCharacters()
311         throws Exception
312     {
313         assumeThat( getSettings().getConfiguration(), is( TEST ) );
314         prepare( "BasicTest#test???????One" )
315             .executeTest()
316             .verifyErrorFree( 1 )
317             .verifyErrorFreeLog()
318             .verifyTextInLog( "jiras.surefire745.BasicTest#testSuccessOne" );
319     }
320 
321     @Test
322     public void shouldMatchExactClassAndMethodsPostfix()
323         throws Exception
324     {
325         assumeThat( getSettings().getConfiguration(), is( TEST ) );
326         prepare( "TestFive#testSuccess???" )
327             .executeTest()
328             .verifyErrorFree( 2 )
329             .verifyErrorFreeLog()
330             .verifyTextInLog( "jiras.surefire745.TestFive#testSuccessOne" )
331             .verifyTextInLog( "jiras.surefire745.TestFive#testSuccessTwo" );
332     }
333 
334     @Test
335     public void shouldMatchExactClassAndMethodPostfix()
336         throws Exception
337     {
338         assumeThat( getSettings().getConfiguration(), is( TEST ) );
339         prepare( "TestFive#testSuccess?????" )
340             .executeTest()
341             .verifyErrorFree( 1 )
342             .verifyErrorFreeLog()
343             .verifyTextInLog( "jiras.surefire745.TestFive#testSuccessThree" );
344     }
345 
346     @Test
347     public void shouldMatchExactClassAndMultipleMethods()
348         throws Exception
349     {
350         assumeThat( getSettings().getConfiguration(), is( TEST ) );
351         prepare( "TestFive#testSuccessOne+testSuccessThree" )
352             .executeTest()
353             .verifyErrorFree( 2 )
354             .verifyErrorFreeLog()
355             .verifyTextInLog( "jiras.surefire745.TestFive#testSuccessOne" )
356             .verifyTextInLog( "jiras.surefire745.TestFive#testSuccessThree" );
357     }
358 
359     @Test
360     public void shouldMatchMultiplePatterns()
361         throws Exception
362     {
363         assumeThat( getSettings().getConfiguration(), is( TEST ) );
364         String test = "jiras/surefire745/BasicTest#testSuccessOne+testSuccessTwo"//2
365             + ',' + "jiras/**/TestTwo"//2
366             + ',' + "jiras/surefire745/TestThree#testSuccess*"//2
367             + ',' + "TestFour#testSuccess???"//2
368             + ',' + "jiras/surefire745/*Five#test*One";//1
369 
370         prepare( test )
371             .executeTest()
372             .verifyErrorFree( 9 )
373             .verifyErrorFreeLog();
374     }
375 
376     @Test
377     public void shouldMatchMultiplePatternsAsParallel()
378         throws Exception
379     {
380         assumeThat( getSettings().getFramework(), anyOf( is( JUNIT47 ), is( TestNG ) ) );
381         assumeThat( getSettings().getConfiguration(), is( TEST ) );
382         String test = "jiras/surefire745/BasicTest#testSuccessOne+testSuccessTwo"//2
383             + ',' + "jiras/**/TestTwo"//2
384             + ',' + "jiras/surefire745/TestThree#testSuccess*"//2
385             + ',' + "TestFour#testSuccess???"//2
386             + ',' + "jiras/surefire745/*Five#test*One";//1
387 
388         prepare( test )
389             .parallel( "classes" )
390             .useUnlimitedThreads()
391             .executeTest()
392             .verifyErrorFree( 9 )
393             .verifyErrorFreeLog();
394     }
395 
396     @Test
397     public void shouldMatchMultiplePatternsComplex()
398         throws Exception
399     {
400         assumeThat( getSettings().getConfiguration(), is( TEST ) );
401         String test = "**/BasicTest#testSuccessOne+testSuccessTwo"//2
402             + ',' + "jiras/**/TestTwo"//2
403             + ',' + "?????/surefire745/TestThree#testSuccess*"//2
404             + ',' + "jiras/surefire745/TestFour.java#testSuccess???"//2
405             + ',' + "jiras/surefire745/*Five#test*One";//1
406 
407         prepare( test )
408             .executeTest()
409             .verifyErrorFree( 9 )
410             .verifyErrorFreeLog();
411     }
412 
413     @Test
414     public void shouldMatchMultiplePatternsComplexAsParallel()
415         throws Exception
416     {
417         assumeThat( getSettings().getFramework(), anyOf( is( JUNIT47 ), is( TestNG ) ) );
418         assumeThat( getSettings().getConfiguration(), is( TEST ) );
419         String test = "**/BasicTest#testSuccessOne+testSuccessTwo"//2
420             + ',' + "jiras/**/TestTwo"//2
421             + ',' + "?????/surefire745/TestThree#testSuccess*"//2
422             + ',' + "jiras/surefire745/TestFour.java#testSuccess???"//2
423             + ',' + "jiras/surefire745/*Five#test*One";//1
424 
425         prepare( test )
426             .parallel( "classes" )
427             .useUnlimitedThreads()
428             .executeTest()
429             .verifyErrorFree( 9 )
430             .verifyErrorFreeLog();
431     }
432 
433     @Test
434     public void shouldNotRunExcludedClasses()
435     {
436         prepare( "!BasicTest, !**/TestTwo, !**/TestThree.java" )
437             .executeTest()
438             .verifyErrorFree( 6 )
439             .verifyErrorFreeLog();
440     }
441 
442     @Test
443     public void shouldNotRunExcludedClassesIfIncluded()
444     {
445         prepare( "TestF*.java, !**/TestFour.java" )
446             .executeTest()
447             .verifyErrorFree( 3 )
448             .verifyErrorFreeLog();
449     }
450 
451     @Test
452     public void shouldNotRunExcludedMethods()
453     {
454         assumeThat( getSettings().getConfiguration(), is( TEST ) );
455         prepare( "!#*Fail*, !%regex[#.*One], !#testSuccessThree" )
456             .executeTest()
457             .verifyErrorFree( 5 )
458             .verifyErrorFreeLog();
459     }
460 
461     @Test
462     public void shouldNotRunExcludedClassesAndMethods()
463     {
464         assumeThat( getSettings().getConfiguration(), is( TEST ) );
465         prepare( "!#*Fail*, !TestFour#testSuccessTwo" )
466             .executeTest()
467             .verifyErrorFree( 11 )
468             .verifyErrorFreeLog();
469     }
470 
471     @Test
472     public void negativeTest()
473     {
474         assumeThat( getSettings().getConfiguration(), anyOf( is( INCLUDES ), is( INCLUDES_EXCLUDES ),
475                                                              is( INCLUDES_FILE ), is( INCLUDES_EXCLUDES_FILE ) ) );
476         String pattern = "TestFive#testSuccessOne+testSuccessThree";
477         prepare( pattern )
478             .failNever()
479             .executeTest()
480             .verifyTextInLog( "Method filter prohibited in includes|excludes|includesFile|excludesFile parameter: "
481                                   + pattern );
482     }
483 }