Creating Reusable Cucumber Step Definitions for DynamoDB Operations

When it comes to testing applications that interact with AWS DynamoDB, having reusable step definitions can greatly enhance your test suite’s efficiency and maintainability. This article will guide you through creating reusable Cucumber step definitions for DynamoDB operations.

Why Reusable Step Definitions?

Reusable step definitions promote DRY (Don’t Repeat Yourself) principles, making your test codebase cleaner and easier to maintain. They allow you to define common operations once and reuse them across multiple scenarios, reducing duplication and potential for errors.

Prerequisites

Before diving into the code, ensure you have the following setup:

An AWS account with DynamoDB permissions.
Node.js and npm installed.
The AWS SDK for JavaScript.
Cucumber.js for running your Cucumber tests.

Setting Up Your Project

First, set up a new Node.js project and install the necessary dependencies:

mkdir cucumber-dynamodb
cd cucumber-dynamodb
npm init -y
npm install cucumber aws-sdk

Configuring AWS SDK

Create a file aws-config.js to configure the AWS SDK:

const AWS = require('aws-sdk');

AWS.config.update({
  region: 'us-east-1', // Replace with your region
  accessKeyId: process.env.AWS_ACCESS_KEY_ID,
  secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY
});

module.exports = AWS;

Writing Step Definitions

Create a directory for your step definitions and add a file for DynamoDB operations:

mkdir -p features/step_definitions
touch features/step_definitions/dynamodbSteps.js

In dynamodbSteps.js, we’ll define step definitions for basic DynamoDB operations like creating a table, inserting an item, and querying items.

Creating a Table

const { Given } = require('cucumber');
const AWS = require('../../aws-config');
const dynamodb = new AWS.DynamoDB();

Given('a DynamoDB table named {string} with primary key {string}', async function (tableName, primaryKey) {
  const params = {
    TableName: tableName,
    KeySchema: [
      { AttributeName: primaryKey, KeyType: 'HASH' }
    ],
    AttributeDefinitions: [
      { AttributeName: primaryKey, AttributeType: 'S' }
    ],
    ProvisionedThroughput: {
      ReadCapacityUnits: 1,
      WriteCapacityUnits: 1
    }
  };

  await dynamodb.createTable(params).promise();
});

Inserting an Item

const { When } = require('cucumber');
const docClient = new AWS.DynamoDB.DocumentClient();

When('I insert an item into the {string} table with the following attributes:', async function (tableName, dataTable) {
  const data = dataTable.rowsHash();
  const params = {
    TableName: tableName,
    Item: data
  };

  await docClient.put(params).promise();
});

Querying Items

const { Then } = require('cucumber');
const assert = require('assert');

Then('I should have an item with {string} equal to {string} in the {string} table', async function (attributeName, attributeValue, tableName) {
  const params = {
    TableName: tableName,
    KeyConditionExpression: '#attr = :value',
    ExpressionAttributeNames: {
      '#attr': attributeName
    },
    ExpressionAttributeValues: {
      ':value': attributeValue
    }
  };

  const result = await docClient.query(params).promise();
  assert.strictEqual(result.Items.length, 1);
});

Writing Feature Files

Create a directory for your feature files and add a sample feature:

mkdir -p features
touch features/dynamodb.feature

In dynamodb.feature, define your scenarios:

Feature: DynamoDB operations

  Scenario: Creating and querying a DynamoDB table
    Given a DynamoDB table named "TestTable" with primary key "Id"
    When I insert an item into the "TestTable" table with the following attributes:
      | Id    | 123  |
      | Name  | Test |
    Then I should have an item with "Id" equal to "123" in the "TestTable" table

Running Your Tests

To run your tests, add a script to your package.json:

"scripts": {
  "test": "cucumber-js"
}

Now, execute the tests:

npm test

Conclusion

Creating reusable Cucumber step definitions for DynamoDB operations simplifies the process of writing and maintaining automated tests. By defining common operations in a single place, you ensure that your tests are DRY and easy to understand. With the provided examples, you can start building a robust test suite for your DynamoDB-related functionalities.

If you found this article helpful and are interested in integrating Cucumber Automation Framework with AWS DynamoDB, 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 DynamoDB Developer Documentation for more information.