net.masterthought.cucumber.json.Feature Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of cucumber-reporting Show documentation
Provides pretty html reports for Cucumber. It works by generating html from the cucumber json file.
There is a newer version: 5.8.2
package net.masterthought.cucumber.json;

import java.util.ArrayList;
import java.util.List;

import net.masterthought.cucumber.ReportBuilder;
import net.masterthought.cucumber.util.Status;
import net.masterthought.cucumber.util.StatusCounter;
import net.masterthought.cucumber.util.Util;

import org.apache.commons.lang.StringEscapeUtils;
import org.apache.commons.lang.StringUtils;

import com.google.common.base.Joiner;
import com.google.common.base.Splitter;
import com.googlecode.totallylazy.Sequence;
import com.googlecode.totallylazy.Sequences;

public class Feature {

    private String name;
    private String uri;
    private String description;
    private String keyword;
    private Element[] elements;
    private Tag[] tags;
    private StepResults stepResults;
    private ScenarioResults scenarioResults;
    private String jsonFile = "";

    public Feature() {

    }

    public String getDeviceName(){
        String name = "";
        if(jsonFile.split("_").length>1)
          name = (jsonFile.split("_")[0]).substring(0,jsonFile.split("_")[0].length());
      return name;
    }

    public void setJsonFile(String json){
        this.jsonFile = json;
    }

    public Sequence getElements() {
        return Sequences.sequence(elements).realise();
    }

    public String getFileName() {
        List matches = new ArrayList();
        for (String line : Splitter.onPattern("/|\\\\").split(uri)) {
            String modified = line.replaceAll("\\)|\\(", "");
            modified = StringUtils.deleteWhitespace(modified).trim();
            matches.add(modified);
        }

        List sublist = matches.subList(1, matches.size());

        matches = (sublist.size() == 0) ? matches : sublist;
        String fileName = Joiner.on("-").join(matches); 

        //If we spect to have parallel executions, we add 
        if(ReportBuilder.isParallel() && jsonFile!=""){
            if(jsonFile.split("_").length >1)
                fileName = fileName + "-"+ (jsonFile.split("_")[0]).substring(0,jsonFile.split("_")[0].length());
        }
        fileName = fileName + ".html";
        return fileName;
    }

    public String getUri(){
        return this.uri;
    }

    public boolean hasTags() {
        return Util.itemExists(tags);
    }

    public boolean hasScenarios() {
        return !getElements().isEmpty();
    }

    public Sequence getTagList() {
        return getTags().map(Tag.functions.getName());
    }

    public Sequence getTags() {
        return Sequences.sequence(tags).realise();
    }

    public String getTagsList() {
        String result = "";
        if (Util.itemExists(tags)) {
            List str = getTagList().toList();
            List tagList = new ArrayList();
            for(String s : str) {
                String link = s.replace("@", "").trim() + ".html";
                String ref = "" + s + "";
                tagList.add(ref);
            }
            result = "" +   StringUtils.join(tagList.toArray(), ",")+ "";
        }
        return result;
    }

    public Status getStatus() {
        Sequence results = getElements().map(Element.Functions.status());
        return results.contains(Status.FAILED) ? Status.FAILED : Status.PASSED;
    }

    public String getName() {
        return Util.itemExists(name) ? getStatus().toHtmlClass()
                + "" + keyword + ": " + name
                + "" + Util.closeDiv() : "";
    }

    public String getRawName() {
        return Util.itemExists(name) ? StringEscapeUtils.escapeHtml(name) : "";
    }

    public String getRawStatus() {
        return getStatus().toString().toLowerCase();
    }

    public String getDescription() {
        String result = "";
        if (Util.itemExists(description)) {
            String content = description.replaceFirst("As an", "As an");
            content = content.replaceFirst("I want to", "I want to");
            content = content.replaceFirst("So that", "So that");
            content = content.replaceAll("\n", "
");
            result = "" + content + "";
        }
        return result;
    }

    public int getNumberOfScenarios() {
        int result = 0;
        if (elements != null) {
            List elementList = new ArrayList();
            for (Element element : elements) {
                if (!element.isBackground()) {
                    elementList.add(element);
                }
            }
            result = elementList.size();
        }
        return result;
    }

    public int getNumberOfSteps() {
        return stepResults.getNumberOfSteps();
    }

    public int getNumberOfPasses() {
        return stepResults.getNumberOfPasses();
    }

    public int getNumberOfFailures() {
        return stepResults.getNumberOfFailures();
    }

    public int getNumberOfPending() {
        return stepResults.getNumberOfPending();
    }

    public int getNumberOfSkipped() {
        return stepResults.getNumberOfSkipped();
    }

    public int getNumberOfMissing() {
        return stepResults.getNumberOfMissing();
    }

    public int getNumberOfUndefined() {
        return stepResults.getNumberOfUndefined();
    }

    public String getDurationOfSteps() {
        return stepResults.getTotalDurationAsString();
    }

    public int getNumberOfScenariosPassed() {
        return scenarioResults.getNumberOfScenariosPassed();
    }

    public int getNumberOfScenariosFailed() {
        return scenarioResults.getNumberOfScenariosFailed();
    }

    public void processSteps() {
        List allSteps = new ArrayList();
        StatusCounter stepsCounter = new StatusCounter();
        List passedScenarios = new ArrayList();
        List failedScenarios = new ArrayList();
        long totalDuration = 0L;

        if (elements != null) {
            for (Element element : elements) {
                calculateScenarioStats(passedScenarios, failedScenarios, element);
                if (element.hasSteps()) {
                    Sequence steps = element.getSteps();
                    for (Step step : steps) {
                        allSteps.add(step);
                        stepsCounter.incrementFor(step.getStatus());
                        totalDuration += step.getDuration();
                    }
                }
            }
        }
        scenarioResults = new ScenarioResults(passedScenarios, failedScenarios);
        stepResults = new StepResults(allSteps, stepsCounter, totalDuration);
    }

    private void calculateScenarioStats(List passedScenarios, List failedScenarios, Element element) {
        if (!element.isBackground()) {
            if (element.getStatus() == Status.PASSED) {
                passedScenarios.add(element);
            } else if (element.getStatus() == Status.FAILED) {
                failedScenarios.add(element);
            }
        }
    }

    class StepResults {
        List allSteps;
        private StatusCounter statusCounter;
        long totalDuration;

        public StepResults(List allSteps, StatusCounter statusCounter, long totalDuration) {
            this.allSteps = allSteps;
            this.statusCounter = statusCounter;
            this.totalDuration = totalDuration;
        }

        public int getNumberOfSteps() {
            return allSteps.size();
        }

        public int getNumberOfPasses() {
            return statusCounter.getValueFor(Status.PASSED);
        }

        public int getNumberOfFailures() {
            return statusCounter.getValueFor(Status.FAILED);
        }

        public int getNumberOfUndefined() {
            return statusCounter.getValueFor(Status.UNDEFINED);
        }

        public int getNumberOfPending() {
            return statusCounter.getValueFor(Status.PENDING);
        }

        public int getNumberOfSkipped() {
            return statusCounter.getValueFor(Status.SKIPPED);
        }

        public int getNumberOfMissing() {
            return statusCounter.getValueFor(Status.MISSING);
        }

        public long getTotalDuration() {
            return totalDuration;
        }

        public String getTotalDurationAsString() {
            return Util.formatDuration(totalDuration);
        }
    }

    class ScenarioResults {
        List passedScenarios;
        List failedScenarios;

        ScenarioResults(List passedScenarios, List failedScenarios) {
            this.passedScenarios = passedScenarios;
            this.failedScenarios = failedScenarios;
        }

        public int getNumberOfScenariosPassed() {
            return passedScenarios.size();
        }

        public int getNumberOfScenariosFailed() {
            return failedScenarios.size();
        }

    }


}