/src/main/java/com/atlassian/bamboo/plugin/dotnet/tests/nunit/NUnitRunnerTaskType.java

package com.atlassian.bamboo.plugin.dotnet.tests.nunit;



import com.atlassian.bamboo.build.logger.interceptors.ErrorMemorisingInterceptor;

import com.atlassian.bamboo.build.test.TestCollationService;

import com.atlassian.bamboo.configuration.ConfigurationMap;

import com.atlassian.bamboo.process.CommandlineStringUtils;

import com.atlassian.bamboo.process.EnvironmentVariableAccessor;

import com.atlassian.bamboo.process.ExternalProcessBuilder;

import com.atlassian.bamboo.process.ProcessService;

import com.atlassian.bamboo.task.TaskContext;

import com.atlassian.bamboo.task.TaskException;

import com.atlassian.bamboo.task.TaskResult;

import com.atlassian.bamboo.task.TaskResultBuilder;

import com.atlassian.bamboo.task.TaskType;

import com.atlassian.bamboo.v2.build.agent.capability.Capability;

import com.atlassian.bamboo.v2.build.agent.capability.CapabilityContext;

import com.atlassian.bamboo.v2.build.agent.capability.CapabilityDefaultsHelper;

import com.atlassian.utils.process.ExternalProcess;

import com.google.common.base.Preconditions;

import com.google.common.collect.Lists;

import org.apache.commons.lang3.StringUtils;

import org.apache.log4j.Logger;

import org.jetbrains.annotations.NotNull;



import java.io.File;

import java.util.List;

import java.util.Map;



/**

 * Executes and parses test results from NUnit test runs executed via the command line.

 */

public class NUnitRunnerTaskType implements TaskType

{

    private static final Logger log = Logger.getLogger(NUnitRunnerTaskType.class);

    // ------------------------------------------------------------------------------------------------------- Constants



    public static final String NUNIT_CAPABILITY_PREFIX = CapabilityDefaultsHelper.CAPABILITY_BUILDER_PREFIX + ".nunit";



    public static final String LABEL = "label";

    public static final String TEST_FILES = "nunitTestFiles";

    public static final String RESULTS_FILE = "nunitResultsFile";

    public static final String TESTS_TO_RUN = "run"; // eg. /run:NUnit.Tests.AssertionTests,NUnit.Tests.ConstraintTests

    public static final String INCLUDED_TEST_CATEGORIES = "include"; // eg. /include:TheseTests,AndTheseTests

    public static final String EXCLUDED_TEST_CATEGORIES = "exclude"; // eg. /exclude:BrokenTests

    public static final String COMMAND_OPTIONS = "commandLineOptions";

    public static final String ENVIRONMENT = "environmentVariables";



    // ------------------------------------------------------------------------------------------------- Type Properties

    // ---------------------------------------------------------------------------------------------------- Dependencies



    private final ProcessService processService;

    private final TestCollationService testCollationService;

    private final CapabilityContext capabilityContext;

    private final EnvironmentVariableAccessor environmentVariableAccessor;



    // ---------------------------------------------------------------------------------------------------- Constructors



    public NUnitRunnerTaskType(final ProcessService processService, final TestCollationService testCollationService, final CapabilityContext capabilityContext, final EnvironmentVariableAccessor environmentVariableAccessor)

    {

        this.processService = processService;

        this.testCollationService = testCollationService;

        this.capabilityContext = capabilityContext;

        this.environmentVariableAccessor = environmentVariableAccessor;

    }



    // ----------------------------------------------------------------------------------------------- Interface Methods



    @Override

    @NotNull

    public TaskResult execute(@NotNull TaskContext taskContext) throws TaskException

    {

        final ErrorMemorisingInterceptor errorLines = ErrorMemorisingInterceptor.newInterceptor();

        taskContext.getBuildLogger().getInterceptorStack().add(errorLines);

        try

        {

            final ConfigurationMap configuration = taskContext.getConfigurationMap();



            final String testFiles = configuration.get(TEST_FILES);

            Preconditions.checkNotNull(testFiles, "One or more test files must be specified");



            final String resultsFile = configuration.get(RESULTS_FILE);

            Preconditions.checkNotNull(resultsFile, "Results File Name");



            final String label = configuration.get(LABEL);

            Preconditions.checkNotNull(label, "You must select an NUnit Runner before this task can execute.");



            final Capability capability = capabilityContext.getCapabilitySet().getCapability(NUnitRunnerTaskType.NUNIT_CAPABILITY_PREFIX + "." + label);

            Preconditions.checkNotNull(capability, "Capability");



            final File nunitConsoleExe = new File(capability.getValue());

            Preconditions.checkArgument(nunitConsoleExe.exists(), "NUnit Console Executable not found");



            // Note: Under the Windows operating system, options may be prefixed by either a forward slash or a hyphen.

            // Under Linux, a hyphen must be used. Options that take values may use an equal sign, a colon or a space

            // to separate the option from its value.

            final List<String> command = Lists.newArrayList(nunitConsoleExe.getAbsolutePath());



            final String testsToRun = configuration.get(TESTS_TO_RUN);

            if (StringUtils.isNotBlank(testsToRun))

            {

                command.add("-run=" + testsToRun);

            }



            command.add(testFiles);

            command.add("-xml=" + resultsFile);



            final String includedCategories = configuration.get(INCLUDED_TEST_CATEGORIES);

            if (StringUtils.isNotBlank(includedCategories))

            {

                command.add("-include=" + includedCategories);

            }



            final String excludedCategories = configuration.get(EXCLUDED_TEST_CATEGORIES);

            if (StringUtils.isNotBlank(excludedCategories))

            {

                command.add("-exclude=" + excludedCategories);

            }



            final String environment = configuration.get(ENVIRONMENT);



            final Map<String, String> env = environmentVariableAccessor.splitEnvironmentAssignments(environment);



            command.addAll(CommandlineStringUtils.tokeniseCommandline(configuration.get(COMMAND_OPTIONS)));



            final ExternalProcess externalProcess = processService.executeExternalProcess(taskContext,

                                                                                  new ExternalProcessBuilder()

                                                                                          .env(env)

                                                                                          .command(command)

                                                                                          .workingDirectory(taskContext.getWorkingDirectory()));



            testCollationService.collateTestResults(taskContext, resultsFile, new NUnitTestReportCollector());



            return TaskResultBuilder.newBuilder(taskContext)

                    .checkTestFailures()

                    .checkReturnCode(externalProcess)

                    .build();

        }

        finally

        {

            taskContext.getBuildContext().getBuildResult().addBuildErrors(errorLines.getErrorStringList());

        }

    }



    // -------------------------------------------------------------------------------------------------- Action Methods

    // -------------------------------------------------------------------------------------------------- Public Methods

    // -------------------------------------------------------------------------------------- Basic Accessors / Mutators

}