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

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

import com.atlassian.bamboo.configuration.ConfigurationException;
import com.atlassian.bamboo.configuration.DefaultElementParser;
import com.atlassian.bamboo.configuration.ElementContentElementParser;
import com.atlassian.bamboo.plugin.dotnet.tests.TestResultContentHandler;
import com.atlassian.bamboo.plugin.dotnet.tests.TestResultsParser;
import com.atlassian.bamboo.results.tests.TestResults;
import com.atlassian.bamboo.resultsummary.tests.TestCaseResultErrorImpl;
import com.atlassian.bamboo.resultsummary.tests.TestState;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Lists;
import net.jcip.annotations.NotThreadSafe;
import org.apache.commons.lang3.StringUtils;
import org.apache.log4j.Logger;
import org.jetbrains.annotations.NotNull;
import org.xml.sax.Attributes;
import org.xml.sax.InputSource;
import org.xml.sax.XMLReader;
import org.xml.sax.helpers.XMLReaderFactory;

import java.io.InputStream;
import java.util.List;

/**
 * Handles parsing NUnit report files.
 *
 * @author Ross Rowe
 */
@NotThreadSafe
public class NUnitXmlTestResultsParser extends TestResultContentHandler implements TestResultsParser
{

    /**
     * Handles parsing 'message' elements.
     *
     * @author Ross Rowe
     */
    public class MessageElementParser extends ElementContentElementParser
    {
        /**
         * Overriden to record error message details.
         */
        @Override
        public void endElement() throws ConfigurationException
        {
            super.endElement();
            if (getCurrentTestError() != null)
            {
                final StringBuilder builder = new StringBuilder();
                if (getCurrentTestError().getContent() != null)
                {
                    builder.append(getCurrentTestError().getContent());
                    builder.append(System.getProperty("line.separator"));
                }
                builder.append(getElementContent());
                setCurrentTestError(new TestCaseResultErrorImpl(builder.toString()));
            }
        }

    }

    /**
     * Handles parsing 'test-suite' elements.
     *
     * @author Ross Rowe
     */
    public class TestSuiteElementParser extends ElementContentElementParser
    {
        /**
         * Overriden to store the suite class name.
         */
        @Override
        public void startElement(Attributes attributes)
        {
            super.startElement(attributes);

            setSuiteClassName(attributes.getValue("name"));
        }
    }

    /**
     * Handles parsing 'test-case' elements.
     *
     * @author Ross Rowe
     */
    public class TestCaseElementParser extends ElementContentElementParser
    {
        /**
         * Overriden to store test case information.
         */
        @Override
        public void startElement(Attributes attributes)
        {
            super.startElement(attributes);

            final String testDuration = attributes.getValue("time");
            final String fqTestName = attributes.getValue("name");

            String className = attributes.getValue("classname");
            if (className == null && fqTestName.contains("."))
            {
                className = StringUtils.substringBeforeLast(fqTestName, ".");
            }

            final String testName = getTestName(fqTestName);

            final TestResults testResults = new TestResults(className != null ? className : getSuiteClassName(),
                                                            testName, testDuration);
            testResults.setState(getTestState(attributes));
            setCurrentTestResult(testResults);
        }

        /**
         * Overriden to add currentTestResult to either <code>failedTests</code>
         * or <code>successfulTests</code>.
         */
        @Override
        public void endElement() throws ConfigurationException
        {
            super.endElement();

            final TestResults testResults = getCurrentTestResult();

            if (testResults != null)
            {
                switch (testResults.getState())
                {
                    case FAILED:
                        failedTests.add(testResults);
                        break;

                    case SKIPPED:
                        inconclusiveTests.add(testResults);
                        break;

                    case SUCCESS:
                        passedTests.add(testResults);
                        break;
                }

                setCurrentTestResult(null);
            }
        }

        private TestState getTestState(Attributes attributes)
        {
            final boolean executed = Boolean.parseBoolean(attributes.getValue("executed"));
            final String result = attributes.getValue("result");
            final boolean success = Boolean.parseBoolean(attributes.getValue("success"));

            if (executed)
            {
                if (success || "Success".equalsIgnoreCase(result))
                {
                    return TestState.SUCCESS;
                }
                else
                {
                    return TestState.FAILED;
                }
            }
            else
            {
                return TestState.SKIPPED;
            }
        }
    }

    @VisibleForTesting
    @NotNull
    static String getTestName(final String fqTestName)
    {
        if (!fqTestName.contains("."))
        {
            return fqTestName;
        }

        final String fqNameWithoutParams = StringUtils.substringBefore(fqTestName, "(");

        return fqTestName.substring(fqNameWithoutParams.lastIndexOf(".") + 1);
    }

    public class ErrorElementParser extends ElementContentElementParser
    {
        /**
         * Overriden to store error details.
         */
        @Override
        public void endElement() throws ConfigurationException
        {
            super.endElement();

            TestCaseResultErrorImpl error = new TestCaseResultErrorImpl(getElementContent());
            if (getCurrentTestResult() != null)
            {
                getCurrentTestResult().addError(error);
            }
            else
            {
                TestResults errorTestResult = new TestResults(getSuiteClassName(), "unknownTestCase", "0.0");
                errorTestResult.addError(error);
                failedTests.add(errorTestResult);
            }
        }

    }

    /**
     * Handles parsing 'failure' elements'
     *
     * @author Ross Rowe
     */
    public class FailureElementParser extends ElementContentElementParser
    {
        private String message;

        @Override
        public void startElement(Attributes attributes)
        {
            super.startElement(attributes);
            message = attributes.getValue("message");
            setCurrentTestError(new TestCaseResultErrorImpl(message));
        }

        @Override
        public void endElement() throws ConfigurationException
        {
            super.endElement();

            if (getCurrentTestResult() != null)
            {
                getCurrentTestResult().addError(getCurrentTestError());
                getCurrentTestResult().setState(TestState.FAILED);
                setCurrentTestError(null);
            }
        }
    }

    /**
     * Constructs a NantXmlTestResultsParser instance.
     */
    public NUnitXmlTestResultsParser()
    {
        registerElementParser("categories", new DefaultElementParser());
        registerElementParser("category", new DefaultElementParser());
        registerElementParser("test-results", new DefaultElementParser());
        registerElementParser("environment", new DefaultElementParser());
        registerElementParser("culture-info", new DefaultElementParser());
        registerElementParser("results", new DefaultElementParser());
        registerElementParser("reason", new DefaultElementParser());
        registerElementParser("message", new MessageElementParser());
        registerElementParser("test-suite", new TestSuiteElementParser());
        registerElementParser("stack-trace", new DefaultElementParser());
        registerElementParser("test-case", new TestCaseElementParser());
        registerElementParser("error", new ErrorElementParser());
        registerElementParser("failure", new FailureElementParser());
    }

    public int getNumberOfErrors() {
        return failedTests.size();
    }

    @Override
    public ImmutableList<TestResults> getSuccessfulTests()
    {
        return ImmutableList.copyOf(passedTests);
    }

    @Override
    public ImmutableList<TestResults> getFailedTests()
    {
        return ImmutableList.copyOf(failedTests);
    }

    @Override
    public ImmutableList<TestResults> getInconclusiveTests()
    {
        return ImmutableList.copyOf(inconclusiveTests);
    }

    public String getSystemOut() {
        return systemOut;
    }

    public String getSystemErr() {
        return errorOut;
    }

    /**
     * @param inputStream
     */
    @Override
    public void parse(InputStream inputStream)
    {
        failedTests = Lists.newArrayList();
        passedTests = Lists.newArrayList();
        inconclusiveTests = Lists.newArrayList();
        try
        {
            //final XMLReader reader = SecureXmlParserFactory.newXmlReader();
            XMLReader reader = XMLReaderFactory.createXMLReader(DEFAULT_PARSER);
            reader.setContentHandler(this);
            reader.parse(new InputSource(inputStream));
        }
        catch (Exception e)
        {
            log.error("Failed to parse xml test results. File was null.", e);
        }
    }

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

    private String suiteClassName;

    private TestResults currentTestResult;

    private TestCaseResultErrorImpl currentTestError;

    private List<TestResults> failedTests;
    private List<TestResults> passedTests;
    private List<TestResults> inconclusiveTests;

    private String systemOut;

    private String errorOut;

    public TestResults getCurrentTestResult() {
        return currentTestResult;
    }

    public String getSuiteClassName()
    {
        return suiteClassName;
    }

    public void setCurrentTestResult(TestResults currentTestResult) {
        this.currentTestResult = currentTestResult;
    }

    public void setSuiteClassName(String suiteClassName) {
        this.suiteClassName = suiteClassName;
    }

    public String getErrorOut() {
        return errorOut;
    }

    public void setErrorOut(String errorOut) {
        this.errorOut = errorOut;
    }

    public void setSystemOut(String systemOut) {
        this.systemOut = systemOut;
    }

    public TestCaseResultErrorImpl getCurrentTestError() {
        return currentTestError;
    }

    public void setCurrentTestError(TestCaseResultErrorImpl currentTestError) {
		this.currentTestError = currentTestError;
	}

}