Building a CI/CD Pipeline for Cucumber Tests using AWS CodePipeline

Continuous Integration and Continuous Deployment (CI/CD) are essential practices in modern software development. They ensure that your code is continuously tested and deployed, providing quick feedback and improving software quality. In this blog post, we will explore how to build a CI/CD pipeline for Cucumber tests using AWS CodePipeline. We will use Java for the step definitions in our code examples.

What is AWS CodePipeline?

AWS CodePipeline is a fully managed continuous delivery service that helps automate your release pipelines for fast and reliable application and infrastructure updates. CodePipeline automates the build, test, and deploy phases of your release process every time there is a code change, based on the release model you define.

Prerequisites

Before we start, ensure you have the following:

An AWS account.
AWS CLI installed and configured.
Java and Maven installed.
A Cucumber project with tests written in Java.

Step 1: Setting Up Your Cucumber Project

Let’s start by setting up a simple Cucumber project. We will use Maven as our build tool.

1. Create a new Maven project or navigate to your existing project.

2. Add the following dependencies to your pom.xml:

<dependencies>
    <dependency>
        <groupId>io.cucumber</groupId>
        <artifactId>cucumber-java</artifactId>
        <version>6.10.4</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>io.cucumber</groupId>
        <artifactId>cucumber-junit</artifactId>
        <version>6.10.4</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.13.1</version>
        <scope>test</scope>
    </dependency>
</dependencies>

3. Create a feature file in src/test/resources/features. For example, example.feature:

Feature: Example feature

  Scenario: Example scenario
    Given I have a configured Cucumber project
    When I run the tests
    Then they should pass

4. Create a step definition in src/test/java/steps/ExampleSteps.java:

package steps;

import io.cucumber.java.en.Given;
import io.cucumber.java.en.Then;
import io.cucumber.java.en.When;

import static org.junit.Assert.assertTrue;

public class ExampleSteps {

    @Given("I have a configured Cucumber project")
    public void i_have_a_configured_Cucumber_project() {
        // Setup code if needed
    }

    @When("I run the tests")
    public void i_run_the_tests() {
        // Action code if needed
    }

    @Then("they should pass")
    public void they_should_pass() {
        assertTrue(true);
    }
}

5. Create a test runner in src/test/java/runner/TestRunner.java:

package runner;

import org.junit.runner.RunWith;
import io.cucumber.junit.Cucumber;
import io.cucumber.junit.CucumberOptions;

@RunWith(Cucumber.class)
@CucumberOptions(
        features = "src/test/resources/features",
        glue = "steps"
)
public class TestRunner {
}

Step 2: Setting Up AWS CodePipeline

Create an S3 Bucket

First, create an S3 bucket to store your build artifacts.

aws s3 mb s3://my-cucumber-pipeline-artifacts

Create an IAM Role

Create an IAM role that grants CodePipeline the necessary permissions. Go to the IAM console and create a new role with the following policy:

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "s3:*",
                "codebuild:*",
                "codedeploy:*",
                "codepipeline:*",
                "iam:PassRole"
            ],
            "Resource": "*"
        }
    ]
}

Create a CodeBuild Project

Create a CodeBuild project to build and test your Cucumber project.

Go to the CodeBuild console and create a new build project.
Configure the source to point to your code repository (e.g., GitHub).
Add the following buildspec.yml to the root of your repository:

version: 0.2

phases:
  install:
    runtime-versions:
      java: corretto11
    commands:
      - echo Installing dependencies...
      - mvn install
  build:
    commands:
      - echo Running Cucumber tests...
      - mvn test
artifacts:
  files:
    - target/**

Create a CodePipeline Pipeline

Go to the CodePipeline console and create a new pipeline.
Configure the source stage to point to your code repository.
Add a build stage and select the CodeBuild project you created.
Add a deploy stage if you have a deployment process.

Example CodePipeline Configuration

Here is an example configuration for your pipeline.yml:

version: "1.0"
resources:
  - name: CucumberPipeline
    type: AWS::CodePipeline::Pipeline
    properties:
      Name: CucumberPipeline
      RoleArn: arn:aws:iam::YOUR_ACCOUNT_ID:role/CucumberPipelineRole
      Stages:
        - Name: Source
          Actions:
            - Name: Source
              ActionTypeId:
                Category: Source
                Owner: AWS
                Provider: CodeCommit
                Version: "1"
              OutputArtifacts:
                - Name: SourceArtifact
              Configuration:
                RepositoryName: my-cucumber-repo
                BranchName: master
        - Name: Build
          Actions:
            - Name: Build
              ActionTypeId:
                Category: Build
                Owner: AWS
                Provider: CodeBuild
                Version: "1"
              InputArtifacts:
                - Name: SourceArtifact
              OutputArtifacts:
                - Name: BuildArtifact
              Configuration:
                ProjectName: my-cucumber-build
        - Name: Deploy
          Actions:
            - Name: Deploy
              ActionTypeId:
                Category: Deploy
                Owner: AWS
                Provider: CodeDeploy
                Version: "1"
              InputArtifacts:
                - Name: BuildArtifact
              Configuration:
                ApplicationName: my-application
                DeploymentGroupName: my-deployment-group

Step 3: Testing Your Pipeline

Once you have set up your pipeline, push a code change to your repository to trigger the pipeline. You can check the progress and logs in the AWS CodePipeline console. If everything is configured correctly, your Cucumber tests should run, and you should see the results in the CodeBuild logs.

Conclusion

Setting up a CI/CD pipeline for Cucumber tests using AWS CodePipeline automates the testing process, ensuring that your code is continuously validated. This helps catch issues early and improves the overall quality of your software. By integrating AWS CodePipeline, CodeBuild, and other AWS services, you can create a robust and scalable CI/CD pipeline tailored to your needs.

If you found this article helpful and are interested in integrating Cucumber Automation Framework with AWS CodePipeline, I suggest you check out some of the other articles I’ve written for this series:

If you’re looking for a deeper dive into some of the concepts and specifics discussed in my article, feel free to reach out to me directly or as always you can checkout the official AWS CodePipeline Developer Documentation for more information.