Cucumber - Expressions

Cucumber: Expressions Explained

Cucumber Expressions provide a flexible and readable way to define step definitions in your test automation framework. They allow you to write test steps in natural language while mapping them to underlying code. With Cucumber Expressions, you can easily parameterize and match user input in a concise manner.

What are Cucumber Expressions?

Cucumber Expressions are patterns used to match steps in a feature file to their corresponding step definitions in code. They are designed to be simpler and more readable than regular expressions, making it easier for non-technical stakeholders to understand.

Basic Syntax:

• {int}: Matches integers (e.g., 42).
• {float}: Matches decimal numbers (e.g., 3.14).
• {word}: Matches a single word without spaces.
• {string}: Matches a quoted string (e.g., "hello").
• {}: Matches custom parameter types.

Example:

                  Feature: Shopping Cart Management

                    Scenario: Add items to the cart
                      Given I have an empty shopping cart
                      When I add 2 apples to the cart
                      Then the cart should contain 2 apples
                

The step definition for When I add 2 apples to the cart could look like this:

                  @When("I add {int} {word} to the cart")
                  public void addItemsToCart(int quantity, String item) {
                      cart.addItem(item, quantity);
                  }
                

Advanced Features

Custom Parameter Types:

Cucumber allows you to define custom parameter types to handle more complex data. For example, you can match specific patterns like dates or custom objects.

Example:

                  ParameterType("date", "\d{4}-\d{2}-\d{2}", Date.class, (String s) -> new SimpleDateFormat("yyyy-MM-dd").parse(s));

                  @Given("the order date is {date}")
                  public void setOrderDate(Date date) {
                      order.setDate(date);
                  }
                

Alternative Text:

Cucumber Expressions support alternative text using parentheses, enabling you to handle variations in wording.

Example:

                  @Given("the user (logs in|signs in) to the application")
                  public void userLogsIn() {
                      user.authenticate();
                  }
                

Real-World Scenario:

Consider an e-commerce platform where users can perform various actions like adding items to a cart, removing items, and checking out. Using Cucumber Expressions, you can streamline test steps to handle dynamic inputs and reuse step definitions.

Feature File:

                  Scenario: Remove items from the cart
                    Given the cart contains 3 apples
                    When I remove 1 apple
                    Then the cart should contain 2 apples
                

Step Definition:

                  @When("I remove {int} {word}")
                  public void removeItemsFromCart(int quantity, String item) {
                      cart.removeItem(item, quantity);
                  }
                

Benefits of Cucumber Expressions

• Improves readability and collaboration between technical and non-technical team members.
• Supports dynamic parameterization for flexible test cases.
• Reduces duplication by enabling reusable step definitions.
• Facilitates custom matching for complex input patterns.