package org.apache.maven.plugin.failsafe;

 /*

  * Licensed to the Apache Software Foundation (ASF) under one

  * or more contributor license agreements.  See the NOTICE file

  * distributed with this work for additional information

  * regarding copyright ownership.  The ASF licenses this file

  * to you under the Apache License, Version 2.0 (the

  * "License"); you may not use this file except in compliance

  * with the License.  You may obtain a copy of the License at

  *

  *     http://www.apache.org/licenses/LICENSE-2.0

  *

  * Unless required by applicable law or agreed to in writing,

  * software distributed under the License is distributed on an

  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

  * KIND, either express or implied.  See the License for the

  * specific language governing permissions and limitations

  * under the License.

  */

 import java.io.File;

 import java.io.FileInputStream;

 import java.io.FileOutputStream;

 import java.io.IOException;

 import java.util.List;

 import org.apache.maven.plugin.MojoExecutionException;

 import org.apache.maven.plugin.MojoFailureException;

 import org.apache.maven.plugin.surefire.AbstractSurefireMojo;

 import org.apache.maven.plugin.surefire.booterclient.ChecksumCalculator;

 import org.apache.maven.plugins.annotations.LifecyclePhase;

 import org.apache.maven.plugins.annotations.Mojo;

 import org.apache.maven.plugins.annotations.Parameter;

 import org.apache.maven.plugins.annotations.ResolutionScope;

 import org.apache.maven.shared.utils.ReaderFactory;

 import org.apache.maven.shared.utils.StringUtils;

 import org.apache.maven.surefire.suite.RunResult;

 import org.apache.maven.surefire.util.NestedCheckedException;

 import static org.apache.maven.shared.utils.io.IOUtil.close;

 /**

  * Run integration tests using Surefire.

  *

  * @author Jason van Zyl

  * @author Stephen Connolly

  * @noinspection JavaDoc,

  */

 @Mojo( name = "integration-test", requiresProject = true, requiresDependencyResolution = ResolutionScope.TEST,

        defaultPhase = LifecyclePhase.INTEGRATION_TEST, threadSafe = true )

 public class IntegrationTestMojo

     extends AbstractSurefireMojo

 {

     private static final String FAILSAFE_IN_PROGRESS_CONTEXT_KEY = "failsafe-in-progress";

     /**

      * Set this to "true" to skip running integration tests, but still compile them. Its use is NOT RECOMMENDED, but

      * quite convenient on occasion.

      *

      * @since 2.4.3-alpha-2

      */

     @Parameter( property = "skipITs" )

     private boolean skipITs;

     /**

      * Base directory where all reports are written to.

      */

     @Parameter( defaultValue = "${project.build.directory}/failsafe-reports" )

     private File reportsDirectory;

     /**

      * Specify this parameter to run individual tests by file name, overriding the <code>includes/excludes</code>

      * parameters. Each pattern you specify here will be used to create an include pattern formatted like

      * <code>**&#47;${test}.java</code>, so you can just type "-Dit.test=MyTest" to run a single test called

      * "foo/MyTest.java".<br/>

      * This parameter overrides the <code>includes/excludes</code> parameters, and the TestNG <code>suiteXmlFiles</code>

      * parameter.

      * <p/>

      * since 2.7.3 You can execute a limited number of method in the test with adding #myMethod or #my*ethod. Si type

      * "-Dtest=MyTest#myMethod" <b>supported for junit 4.x and testNg</b>

      */

     @Parameter( property = "it.test" )

     private String test;

     /**

      * The summary file to write integration test results to.

      */

     @Parameter( defaultValue = "${project.build.directory}/failsafe-reports/failsafe-summary.xml", required = true )

     private File summaryFile;

     /**

      * Option to print summary of test suites or just print the test cases that have errors.

      */

     @Parameter( property = "failsafe.printSummary", defaultValue = "true" )

     private boolean printSummary;

     /**

      * Selects the formatting for the test report to be generated. Can be set as "brief" or "plain".

      * Only applies to the output format of the output files  (target/surefire-reports/testName.txt)

      */

     @Parameter( property = "failsafe.reportFormat", defaultValue = "brief" )

     private String reportFormat;

     /**

      * Option to generate a file test report or just output the test report to the console.

      */

     @Parameter( property = "failsafe.useFile", defaultValue = "true" )

     private boolean useFile;

     /**

      * Set this to "true" to cause a failure if the none of the tests specified in -Dtest=... are run. Defaults to

      * "true".

      *

      * @since 2.12

      */

     @Parameter( property = "it.failIfNoSpecifiedTests" )

     private Boolean failIfNoSpecifiedTests;

     /**

      * Attach a debugger to the forked JVM. If set to "true", the process will suspend and wait for a debugger to attach

      * on port 5005. If set to some other string, that string will be appended to the argLine, allowing you to configure

      * arbitrary debuggability options (without overwriting the other options specified through the <code>argLine</code>

      * parameter).

      *

      * @since 2.4

      */

     @Parameter( property = "maven.failsafe.debug" )

     private String debugForkedProcess;

     /**

      * Kill the forked test process after a certain number of seconds. If set to 0, wait forever for the process, never

      * timing out.

      *

      * @since 2.4

      */

     @Parameter( property = "failsafe.timeout" )

     private int forkedProcessTimeoutInSeconds;

     /**

      * A list of <include> elements specifying the tests (by pattern) that should be included in testing. When not

      * specified and when the <code>test</code> parameter is not specified, the default includes will be <code><br/>

      * &lt;includes><br/>

      * &nbsp;&lt;include>**&#47;IT*.java&lt;/include><br/>

      * &nbsp;&lt;include>**&#47;*IT.java&lt;/include><br/>

      * &nbsp;&lt;include>**&#47;*ITCase.java&lt;/include><br/>

      * &lt;/includes><br/>

      * </code>

      * <p/>

      * Each include item may also contain a comma-separated sublist of items, which will be treated as multiple

      * &nbsp;&lt;include> entries.<br/>

      * <p/>

      * This parameter is ignored if the TestNG <code>suiteXmlFiles</code> parameter is specified.

      */

     @Parameter

     private List<String> includes;

     /**

      * Option to pass dependencies to the system's classloader instead of using an isolated class loader when forking.

      * Prevents problems with JDKs which implement the service provider lookup mechanism by using the system's

      * classloader.

      *

      * @since 2.3

      */

     @Parameter( property = "failsafe.useSystemClassLoader", defaultValue = "true" )

     private boolean useSystemClassLoader;

     /**

      * By default, Surefire forks your tests using a manifest-only JAR; set this parameter to "false" to force it to

      * launch your tests with a plain old Java classpath. (See

      * http://maven.apache.org/plugins/maven-surefire-plugin/examples/class-loading.html for a more detailed explanation

      * of manifest-only JARs and their benefits.)

      * <p/>

      * Beware, setting this to "false" may cause your tests to fail on Windows if your classpath is too long.

      *

      * @since 2.4.3

      */

     @Parameter( property = "failsafe.useManifestOnlyJar", defaultValue = "true" )

     private boolean useManifestOnlyJar;

     /**

      * The character encoding scheme to be applied.

      */

     @Parameter( property = "encoding", defaultValue = "${project.reporting.outputEncoding}" )

     private String encoding;

     protected void handleSummary( RunResult summary, NestedCheckedException firstForkException )

         throws MojoExecutionException, MojoFailureException

     {

         writeSummary( summary, firstForkException );

     }

     @SuppressWarnings( "unchecked" )

     private void writeSummary( RunResult summary, NestedCheckedException firstForkException )

         throws MojoExecutionException

     {

         File summaryFile = getSummaryFile();

         if ( !summaryFile.getParentFile().isDirectory() )

         {

             //noinspection ResultOfMethodCallIgnored

             summaryFile.getParentFile().mkdirs();

         }

         FileOutputStream fout = null;

         FileInputStream fin = null;

         try

         {

             Object token = getPluginContext().get( FAILSAFE_IN_PROGRESS_CONTEXT_KEY );

             summary.writeSummary( summaryFile, token != null, getEncodingOrDefault() );

         }

         catch ( IOException e )

         {

             throw new MojoExecutionException( e.getMessage(), e );

         }

         finally

         {

             close( fin );

             close( fout );

         }

         getPluginContext().put( FAILSAFE_IN_PROGRESS_CONTEXT_KEY, FAILSAFE_IN_PROGRESS_CONTEXT_KEY );

     }

     private String getEncodingOrDefault()

     {

         if ( StringUtils.isEmpty( encoding ) )

         {

             getLog().warn( "File encoding has not been set, using platform encoding " + ReaderFactory.FILE_ENCODING +

                                ", i.e. build is platform dependent!" );

             return ReaderFactory.FILE_ENCODING;

         }

         else

         {

             return encoding;

         }

     }

     @SuppressWarnings( "deprecation" )

     protected boolean isSkipExecution()

     {

         return isSkip() || isSkipTests() || isSkipITs() || isSkipExec();

     }

     protected String getPluginName()

     {

         return "failsafe";

     }

     protected String[] getDefaultIncludes()

     {

         return new String[]{ "**/IT*.java", "**/*IT.java", "**/*ITCase.java" };

     }

     public boolean isSkipTests()

     {

         return skipTests;

     }

     public void setSkipTests( boolean skipTests )

     {

         this.skipTests = skipTests;

     }

     public boolean isSkipITs()

     {

         return skipITs;

     }

     public void setSkipITs( boolean skipITs )

     {

         this.skipITs = skipITs;

     }

     @SuppressWarnings( "deprecation" )

     @Deprecated

     public boolean isSkipExec()

     {

         return skipExec;

     }

     @SuppressWarnings( "deprecation" )

     @Deprecated

     public void setSkipExec( boolean skipExec )

     {

         this.skipExec = skipExec;

     }

     public boolean isSkip()

     {

         return skip;

     }

     public void setSkip( boolean skip )

     {

         this.skip = skip;

     }

     public File getBasedir()

     {

         return basedir;

     }

     public void setBasedir( File basedir )

     {

         this.basedir = basedir;

     }

     public File getTestClassesDirectory()

     {

         return testClassesDirectory;

     }

     public void setTestClassesDirectory( File testClassesDirectory )

     {

         this.testClassesDirectory = testClassesDirectory;

     }

     public File getClassesDirectory()

     {

         return classesDirectory;

     }

     public void setClassesDirectory( File classesDirectory )

     {

         this.classesDirectory = classesDirectory;

     }

     public File getReportsDirectory()

     {

         return reportsDirectory;

     }

     public void setReportsDirectory( File reportsDirectory )

     {

         this.reportsDirectory = reportsDirectory;

     }

     public String getTest()

     {

         if ( StringUtils.isBlank( test ) )

         {

             return null;

         }

         int index = test.indexOf( '#' );

         if ( index >= 0 )

         {

             return test.substring( 0, index );

         }

         return test;

     }

     public void setTest( String test )

     {

         this.test = test;

     }

     /**

      * @since 2.7.3

      */

     public String getTestMethod()

     {

         if ( StringUtils.isBlank( test ) )

         {

             return null;

         }

         int index = this.test.indexOf( '#' );

         if ( index >= 0 )

         {

             return this.test.substring( index + 1, this.test.length() );

         }

         return null;

     }

     public File getSummaryFile()

     {

         return summaryFile;

     }

     public void setSummaryFile( File summaryFile )

     {

         this.summaryFile = summaryFile;

     }

     public boolean isPrintSummary()

     {

         return printSummary;

     }

     public void setPrintSummary( boolean printSummary )

     {

         this.printSummary = printSummary;

     }

     public String getReportFormat()

     {

         return reportFormat;

     }

     public void setReportFormat( String reportFormat )

     {

         this.reportFormat = reportFormat;

     }

     public boolean isUseFile()

     {

         return useFile;

     }

     public void setUseFile( boolean useFile )

     {

         this.useFile = useFile;

     }

     public String getDebugForkedProcess()

     {

         return debugForkedProcess;

     }

     public void setDebugForkedProcess( String debugForkedProcess )

     {

         this.debugForkedProcess = debugForkedProcess;

     }

     public int getForkedProcessTimeoutInSeconds()

     {

         return forkedProcessTimeoutInSeconds;

     }

     public void setForkedProcessTimeoutInSeconds( int forkedProcessTimeoutInSeconds )

     {

         this.forkedProcessTimeoutInSeconds = forkedProcessTimeoutInSeconds;

     }

     public boolean isUseSystemClassLoader()

     {

         return useSystemClassLoader;

     }

     public void setUseSystemClassLoader( boolean useSystemClassLoader )

     {

         this.useSystemClassLoader = useSystemClassLoader;

     }

     public boolean isUseManifestOnlyJar()

     {

         return useManifestOnlyJar;

     }

     public void setUseManifestOnlyJar( boolean useManifestOnlyJar )

     {

         this.useManifestOnlyJar = useManifestOnlyJar;

     }

     // the following will be refactored out once the common code is all in one place

     public boolean isTestFailureIgnore()

     {

         return true; // ignore

     }

     public void setTestFailureIgnore( boolean testFailureIgnore )

     {

         // ignore

     }

     protected void addPluginSpecificChecksumItems( ChecksumCalculator checksum )

     {

         checksum.add( skipITs );

         checksum.add( summaryFile );

     }

     public Boolean getFailIfNoSpecifiedTests()

     {

         return failIfNoSpecifiedTests;

     }

     public void setFailIfNoSpecifiedTests( Boolean failIfNoSpecifiedTests )

     {

         this.failIfNoSpecifiedTests = failIfNoSpecifiedTests;

     }

     @Override

     public List<String> getIncludes()

     {

         return includes;

     }

     @Override

     public void setIncludes( List<String> includes )

     {

         this.includes = includes;

     }

 }