A few months ago I wanted to generate a modern html report from my Cucumber json reports using GO. I tried to find something good for me already ready to use, but I couldn't. So I created Gocure.

Gocure is a library written in pure GO that offers the ability to generate html reports from Cucumber json reports.

After the first version, I decided to make something to help me to embed files into json reports, because this cannot be done with Cucumber in GO. So, in this new version of Gocure, it is also possible to embed any files in Cucumber json reports.

Another problem I faced was: OK! Gocure is very good, but only GO projects can use it. So I decided to create a Docker image to help everyone using Cucumber in any language to use Gocure. So if you are using Cocumber, but not in GO, you can simply start a Docker container and call a REST API or use a website to embed files in Cucumber reports or generate beautiful html reports.

Import in your project

If your project is in GO, you simple import Gocure to your project and start using all Gocure functionalities.

package main

import (
    "fmt"

    "gitlab.com/rodrigoodhin/gocure/embedded"
    "gitlab.com/rodrigoodhin/gocure/models"
    "gitlab.com/rodrigoodhin/gocure/pkg/gocure"
    "gitlab.com/rodrigoodhin/gocure/report/html"
)

func main() {

    // Set embedded options
    emb := gocure.Embedded{
        Config: embedded.Data{
            InputJsonPath:  "./example/report.json",
            OutputJsonPath: "./example/newReport.json",
            Files: []string{
                "./example/video.mp4",
                "./example/text.txt",
                "https://i.ibb.co/LpRkTqf/gocure-small.png",
            },
            FeatureIndex: 0,
            ScenarioIndex: 0,
            StepIndex: 2,
        },
    }

    err := emb.AddToFeature()
    if err != nil {
        fmt.Printf("error adding files to feature: %v", err)
    }

    err = emb.AddToScenario()
    if err != nil {
        fmt.Printf("error adding files to scenario: %v", err)
    }

    err = emb.AddToStep()
    if err != nil {
        fmt.Printf("error adding files to step: %v", err)
    }

    // Set html options
    html := gocure.HTML{
        Config: html.Data{
            InputJsonPath:     "./example/newReport.json",
            OutputHtmlFolder:  "./example/",
            ShowEmbeddedFiles: true,
            Metadata: models.Metadata{
                AppVersion:      "0.8.7",
                TestEnvironment: "development",
                Browser:         "Google Chrome",
                Platform:        "Linux",
                Parallel:        "Scenarios",
                Executed:        "Remote",
            },
        },
    }

    // Generate HTML report
    err = html.Generate()
    if err != nil {
        fmt.Printf("error generatig html report: %v", err)
    }

}

Check out the oficial documentation for more information about of how to import Gocure in your GO project.

Execute the binary

If you simple want to execute the binary, you can go to the release page in gitlab, download the binary for your system version and execute.

./gocure -j /path/to/json/file.json

Options:

Common tags:

Tags for html option:

Tags for embedded option:

Releases
Check out the oficial documentation for more information about of how to execute Gocure binary.

Docker container

If you are using Cucumber in another language than GO or you simple don't want to import Gocure to your project, you can start a Docker container.

To start a Docker container, follows this steps:

Create a file called docker-compose.yml with this code:

version: '3'
services:
  gocure:
    container_name: gocure
    image: rodrigoodhin/gocure
    volumes:
      - "$PWD/data:/data"
      - "/Users:/Users"
    ports:
      - "8087:80"
      - "7087:7087"
    networks:
      - my_network
networks:
  my_network:

Then execute the command below to start your Docker container:

docker-compose up -d

REST API

You can use Gocure REST API, running the binary or starting a Gocure Docker container.

If you need to use GOcure, but do not use GO and still want to integrate Gocure to your project, you can use call the Gocure REST API.

If you start a Docker container like shown above, you can go to http://localhost:7087/swagger/ to check the REST API documentation.

The REST API will be available at http://localhost:7087/.

Check out the oficial documentation for more informations about the REST API.

Website

Last but not least, after you start the Docker container, as shown above, you can use Gocure by visiting the website at http://localhost:8087/. On this website you can use all the features of Gocure in a simple way.

Check out the oficial documentation for more information of how to use the Gocure Website.

If you encounter any errors, go to Gocure repository and open an issue.

If you have any suggestions, feel free to comment.

I hope you Enjoy this tool!

After March 11, 2022, GOCURE becomes a Third-Party Official Tools of Cucumber