One of the most overlooked aspects in automation is the quality of test data. Hardcoded test data, for example, names like “Santosh Adhikari” and reused emails like test@example.com, can lead to duplicate entry errors. To solve such issues, Ruby developers can pair Selenium with two powerful libraries: Faker and FactoryBot. While Faker helps developers to generate random but realistic data, FactoryBot offers a clean and well-structured way to manage it.

Interesting Right? Now let’s install the required gems in our system.

gem 'selenium-webdriver'
gem 'rspec'
gem 'faker'
gem 'factory_bot'

Now to update your gem files run following command:

bundle install

Now you’re all set to combine the power of dynamic test data for your test autmations.

Generating Realistic Test Data With Faker

The Faker gem generates data that mimics real-world information, such as Name, Email, Address, Phone Number, and credit card details.

Now, let’s examine a basic example of generating realistic test data using Faker.

require 'faker'

puts Faker::Name.name           # => "Ava Brooks"
puts Faker::Internet.email      # => "ava.brooks@example.com"
puts Faker::Address.city        # => "New York"

You can use different approaches to manage data, such as creating Enums, Models, et with Faker Data

Let’s go through following example:

module UserRole
  ADMIN = 'admin'
  USER = 'user'
  GUEST = 'guest'
  
  ALL = [ADMIN, USER, GUEST]
end

# Usage with Faker and FactoryBot:
FactoryBot.define do
  factory :user do
    name { Faker::Name.name }
    email { Faker::Internet.email }
    role { UserRole::ALL.sample }
  end
end

Organizing Test Data with FactoryBot

FactoryBot is usually tied to Rails apps, but it works just as well with plain Ruby. FactoryBot allows you to define blueprints/factories for your test data in a reusable, centralized manner.

Defining a Factory

# factories/user_factory.rb
require 'factory_bot'
require 'faker'

FactoryBot.define do
  factory :user do
    name { Faker::Name.name }
    email { Faker::Internet.email }
    password { 'SecurePass123!' }
    city { Faker::Address.city }
  end
end

To use the factory in your test:

include FactoryBot::Syntax::Methods

user = build(:user)

Now you can use the realistic values each time you run the test. user.name, user.email, etc, contain fresh data for your tests.

Let’s go through a real-world scenario

require 'selenium-webdriver'
require 'factory_bot'
require 'faker'

# --- Factory Definition ---
FactoryBot.define do
  factory :user do
    first_name { Faker::Name.first_name }
    last_name { Faker::Name.last_name }
    email { Faker::Internet.email }
    phone { Faker::PhoneNumber.cell_phone.delete("^0-9")[0..9] } # 10-digit number
    address { Faker::Address.full_address }
  end
end

# --- Test Suite ---
include FactoryBot::Syntax::Methods

describe 'DemoQA practice form' do
  before(:all) do
    FactoryBot.find_definitions
    @driver = Selenium::WebDriver.for :chrome
    @driver.manage.timeouts.implicit_wait = 10
    @driver.navigate.to 'https://demoqa.com/automation-practice-form'
    @driver.manage.window.maximize
  end

  it 'fills out form with realistic fake data' do
    user = build(:user)

    @driver.find_element(id: 'firstName').send_keys(user.first_name)
    @driver.find_element(id: 'lastName').send_keys(user.last_name)
    @driver.find_element(id: 'userEmail').send_keys(user.email)

    # Gender radio button
    @driver.find_element(xpath: "//label[text()='Male']").click

    @driver.find_element(id: 'userNumber').send_keys(user.phone)

    # Date of Birth 
    @driver.find_element(id: 'dateOfBirthInput').click
    @driver.find_element(css: '.react-datepicker__day--015').click rescue nil

    # Subjects - type and select
    subject_input = @driver.find_element(id: 'subjectsInput')
    subject_input.send_keys('Math')
    subject_input.send_keys(:enter)

    # Hobbies - click checkbox
    @driver.find_element(xpath: "//label[text()='Sports']").click

    # Address
    @driver.find_element(id: 'currentAddress').send_keys(user.address)

    @driver.execute_script('window.scrollBy(0, 300)')

    @driver.find_element(id: 'submit').click

    sleep 2 # View confirmation modal
  end

  after(:all) do
    @driver.quit
  end
end

Using Faker and FactoryBot with Selenium in Ruby not only improves the quality of your automated tests but also boosts maintainability and test coverage. It simulates real-world data, so it helps to behave like it, helps avoid stale data issues, and reduces manual test data setup dramatically.

If you are still hardcoding test data in 2025, then it’s time to level up. Cheers.

Happy Testing

Happy Coding

While automating web applications, handling iFrames is a common challenge we have faced. An iframe, also known as inline Frame, is an HTML element that helps to embed another document within the desired page. Selenium interacts with the primary DOM by default, so we need to explicitly switch to the iframes before interacting with any iframe elements. Today, in this article, we will see how we can efficiently handle iframes in selenium ruby.

Prerequisites

• Installed Ruby on you computer system
• Installed Selenium WebDriver Gem
• And web browser drivers like geckodriver, chromedriver.

What is iFrames?

An iframe is a separate embedded document within a webpage. An iframe has its own DOM, different from the main web page. Since selenium cannot interact directly inside of an iframe element unless we switch the context to it first.

Now let’s discuss how we can work with different iframes easily on selenium ruby.

Steps to Handle iFrames in Selenium Ruby

Identify required Iframe

To work on any elements inside an iframe, we first have to locate them using different element locators such as CSS locator, xpath, name, id

Switch to the Iframe

Selenium provides its method, the switch_to.frame method, for switching between iframes.

driver.switch_to.frame(id: 'your_iframe_id')

Use replace id: 'your_iframe_id' with your locator

Performing Action within the Iframe

Once you switch to a new iframe, you can easily interact with the elements like you normally would, such as filling input text fields, clicking buttons, etc.

element = driver.find_element(:css, 'input[id="text"]')
element.send_keys('How to Handle iFrames in Selenium Ruby')

Switch back to the mainframe

After completing the task within the iframe, we may need to switch back to the main content to continue further actions in the web application. To switch back to the Main Content frame we use default_content method in selenium ruby.

driver.switch_to.default_content

Summary

Handling iframes in Selenium with Ruby requires proper context switching to interact with elements inside iframes. Using appropriate switch methods and handling exceptions such as StaleElementReferenceError, NoSuchFrameError, ElementNotInteractableError, etc., will ensure a smooth automation testing experience. With best practices, we can create robust and reliable selenium scripts for automation testing.

After all, Quality Matters!!!! Cheers!!!

Uploading a file using selenium in Ruby programming language is a common feature in Web Automation techniques, whether uploading an image on social media sites or attaching a document in a web form field. Today, in this blog post, we will explain how we can handle file uploads feature using Selenium WebDriver in Ruby with simple examples.

Understanding File Upload in Selenium

Unlike other elements like buttons, text, or TextArea fields, file input fields in HTML <input type="file"> don’t support direct interaction using the send_keys method for some security reasons. However, Selenium provides a way to upload files by sending the file path to the input field of the type file.

Let’s explore the Step-by-Step Guide to Upload a File using Selenium WebDriver and Ruby.

Setting up Selenium WebDriver Environment

First, we must set up Selenium WebDriver on our computer. To do this, let’s see the following example.

require 'selenium-webdriver'

# Initialize the driver
options = Selenium::WebDriver::Chrome::Options.new
options.add_argument('--start-maximized')
driver = Selenium::WebDriver.for :chrome, options: options

Note: Please make sure that you have Selenium-WebDriver Gem on you system to do the required 'selenium-webdriver'

Navigate to the Web Page with File Upload Option

driver.navigate.to 'https://www.yourwebsite.com/upload'

Please replace the given URL with the actual URL of the webpage where you want to upload the files. driver. navigates.to "URL_name" is used to open a website link in the web browser.

Locate the File Input Element

To interact with the file upload element of the webpage, we need to use the element locator such as ID, Name, Class, etc. You can also use XPath or CSS locator to locate the element.

file_input = driver.find_element(:id, 'file-upload')

Make sure to replace the locator with your actual element locator to locate the element by Selenium WebDriver.

Upload file in Selenium WebDriver with Ruby

To upload the file, we have to pass the file location path with the send_keys method. To understand this, let’s check the following example.

file_path = '/path/to/your/file.txt' # Provide the absolute path of your file
file_input.send_keys(file_path)

Click the Submit Button

This is the final step to upload the file using Selenium WebDriver. Some websites do not need to press the upload button, and some may require clicking the submit/upload button to upload the files. Please implement this as per your task requirement.

By understanding the above example, we can easily upload the files using Selenium and Ruby. If you want to explore more possibilities, please go through the selenium documentation link given below.

Why Handling Multiple Browser Windows is Important in Web Automation Testing

Modern web applications frequently use pop-ups, new windows, or tabs for features like payment, gateways, user authentication, or displaying additional information. Without proper window handling, our automation script might fail to interact with the correct browser window or tab, leading to test failures.

Prerequisites Before Continuing This Article

Please make sure you have the following environment setup before proceeding:

• Installed Ruby on your system
• Selenium WebDriver gem is installed (To install: gem install selenium-webdriver)
• A browser driver like GeckoDriver or ChromeDriver compatible with your current browser version

Opening and Handling a New Browser Window

Let’s start with some basic examples. Suppose you have a web page with a link that opens a new tab or window when clicked. Let’s see how we can handle it step-by-step.

Initialize the Browser

require 'selenium-webdriver'

# Initialize the browser
driver = Selenium::WebDriver.for :chrome

This is the very first step. Without browser initialization, we cannot navigate to any websites to perform operations.

Navigate to the Website

driver.navigate.to 'https://example.com'

Store your Current Window Handle

Storing your current window handle is a very important part. After completing tasks in a new window, you may need to switch back to the original window. Keeping the default window handle ensures a smooth transition after you complete the task in new windows or tabs.

# Store the current window handle
default_window = driver.window_handle

Click the Element That Opens a New Window or Tab

# Click the link that opens a new window
driver.find_element(:link_text, 'Open New Window Element Locator').click

Get All Present Window Handles

In Ruby, Selenium window_handles is used to fetch all the present windows. With this, we can interact with desired windows when needed.

# Get all window handles
all_windows = driver.window_handles

Switching to The New Window

You can switch to any Windows as you need. switch_to method is used to switch to another browser window. Manipulate windows as per your need when more than two windows are present.

# Switch to the new window
new_window_handle = (all_windows - [default_window]).first
driver.switch_to.window(new_window_handle)

Perform Actions in the New Window

# Perform actions in the new window
driver.find_element(:id, 'new_window_element').click

Close the New Window After Actions are Completed

# Close the new window
driver.close

When we complete our task, then it’s not necessary to keep it open. Some windows close automatically when we perform our task. We can also verify this behavior by checking all the present window handles.

It’s Time to Switch Back to The Main Window

# Switch back to the main window
driver.switch_to.window(main_window)

Quit the Browser After Test Compelted

driver.quit

Let’s Review the Key Concepts

Managing Multiple Tabs with Selenium WebDriver

The Window Handles method returns an array of all the available browser tabs or windows. By comparing the current window handle with the list, you can identify new windows easily and perform tasks on it.

Working With Windows in Selenium

The switch_to.window(handle) method allows you to focus on a specific window to perform operations. After switching, any Selenium commands will interact with the new active browser window.

Ruby Automation

Using Ruby’s syntax is simple, and managing browser tabs becomes intuitive. The ability to store window handles and switch between them makes Ruby an excellent choice for Selenium.

Best Practices for Handling Windows

• Always store the default or main window handle
• Use dynamic waits instead of hard sleep to handle loading time efficiently
• Close unnecessary windows after tasks are completed. This prevents resource leakage and improves performance.

Conclusion

Handling a new browser window with Selenium WebDriver in Ruby is straightforward once you understand how to manage window handles. By Practicing techniques for managing multiple tabs with Selenium, working with multiple Windows or Tabs in Selenium, and Ruby automation for browser tab or Windows control, you can build robust automation scripts that handle complex web applications seamlessly.

What Is ChatGPT?

ChatGPT is an intelligent AI system that is capable of system analysis, forecasting activities, and even optimizing workflows. ChatGPT goes beyond basic AI by incorporating Natural Language programming (NLP) and deep learning models that process immense amounts of data, deliver sophisticated replies, and aid in the decision making process. Software testing, it can create testing scenarios, help uncover bugs, and offer practical suggestions that would otherwise be impossible from manual testing.

Why It Is Important to Use ChatGPT AI in Software Testing

Enhanced Test Automation Process

It uses automation technology to improve the efficiency and effectiveness of repetitive testing tasks such as regression testing. By relying on previous records, it can generate and run testing cases automatically, lessening the requirement for human involvement. This saves time without sacrificing precision and uniformity.

Intelligent Bug Detector

Pre-defined scenarios are the gold standard in traditional testing methods. ChatGPT, on the other hand, is more advanced and predictive because it analyzes existing data to “see” problems before they occur. This edge allows case classification that could be missed during normal testing procedures.

Optimised Test Coverage

Achieving comprehensive test coverage is a challenge. ChatGPT analyzes code changes, usage patterns, and historical bugs to prioritize critical areas, ensuring no feature goes untested.

Faster Release Cycle

With automated processes and intelligent analysis, ChatGPT accelerates the testing phase, enabling faster deployment without compromising quality. This agility is crucial in today’s competitive market.

Way to Implement ChatGPT in Your Testing Workflow

Integrate with Existing Tools

ChatGPT seamlessly integrates with popular CI/CD pipelines and testing frameworks. Whether you’re using Selenium, JUnit, or Jenkins, ChatGPT can enhance your current setup without a steep learning curve.

Train the AI Model

Feed ChatGPT with historical test data, code repositories, and user feedback. The more data it processes, the better it becomes at predicting issues and optimizing test cases.

Monitor and Adjust

AI models thrive on continuous learning. Regularly review ChatGPT’s insights, adjust parameters, and update data inputs to keep the system accurate and effective.

How to Use ChatGPT for Selenium Automation Testing in Ruby

When ChatGPT is integrated with Selenium, it can help improve the efficiency and accuracy of the testing scripts. Here’s a way to integrate and utilize ChatGPT AI efficiently:

Setup Ruby Environment

Make Sure you have Selenium WebDriver installed in your Ruby Environment

require 'selenium-webdriver'

To Integrate ChatGPT

Set up API access to integrate ChatGPT capabilities

require 'net/http'
require 'json'

uri = URI('https://api.openai.com/v1/chat/completions')
api_key = 'insert_api_key'

Enhance Test Scripts with AI

Use ChatGPT AI to generate and optimize your test cases.

headers = {
  'Content-Type' => 'application/json',
  'Authorization' => "Bearer #{api_key}"
}

body = {
  model: 'gpt-4',
  messages: [
    { role: 'system', content: 'Logging in' },
    { role: 'user', content: 'Generate Selenium test cases in Ruby for a login page.' }
  ]
}.to_json

response = Net::HTTP.post(uri, body, headers)
test_cases = JSON.parse(response.body)

puts test_cases['choices'][0]['message']['content']

Continuous Improvement

You need to regularly feed test results back into ChatGPT to improve its predictive accuracy and improve future test automation processes.

Key Benefits of Using ChatGPT in the Software Testing World

1. Increased Efficiency: Automates time-consuming tasks, freeing up testers for more strategic activities.
2. Improved Accuracy: Detects subtle bugs that manual testing might overlook.
3. Cost-Effective: Reduces the resources needed for extensive manual testing.
4. Scalable: Adapts to projects of any size, from small applications to large enterprise systems.

Let’s see how you can create and work with hashes in Ruby.

Creating Hashes in Ruby

In Ruby, you can create a hash using curly braces {} and specify key-value pairs:

# Creating a hash with initial values
person = {
  "name" => "San",
  "age" => 28,
  "occupation" => "QA Engineer"
}

# Creating an empty hash
empty_hash = {}

You can also use Hash.new constructor to create a hash with a default value

# Creating a hash with a default value
grades = Hash.new(0)  # Default value is 0

Accessing hash values

You can access the values in hash using keys, as follows

puts person["name"]        # Outputs: San
puts person["age"]         # Outputs: 28
puts person["occupation"]  # Outputs: QA Engineer

Modifying hash values

Also, you can modify hash values using keys

person["age"] = 31       # Changing the value of the "age" key
person["occupation"] = "Developer"  # Changing the value of the "occupation" key

Iterating Over Hashes:

You can iterate over the keys and values in a hash using various methods like each, each_key, and each_value:

person.each do |key, value|
  puts "#{key}: #{value}"
end

Symbols as Keys in Ruby Hash

In Ruby, it’s common to use symbols as keys in hashes, especially when the keys are not expected to change:

person = {
  name: "Alice",
  age: 25,
  occupation: "Designer"
}

Conclusion

There are many methods to play with Hashes in Ruby, some of which are keys, values, merge, delete, has_key?, and more. You can refer to the Ruby documentation for a comprehensive list of hash methods: Ruby Hash Documentation

Remember that hashes are unordered collections, which means the order of key-value pairs is not guaranteed to be the same as when they were inserted.

Ruby is a high-level programming language that supports various paradigms. The majority of OOP languages, like Ruby, have a subclassing mechanism that helps us to create new classes whose behavior is based on, you are probably already familiar with these terms if you have programmed or learned programming languages like C++, or Java.

What’s the Big Idea?

Imagine you’re baking a cake. You have a basic cake recipe that includes different ingredients like flour, sugar, eggs, and butter. Now, let’s say you want to make different types of cakes – a chocolate cake, a vanilla cake, and a strawberry cake. You wouldn’t rewrite the entire recipe for each cake, right? Instead, you’d start with the basic recipe and tweak it to add specific flavors.

This is where inheritance comes into play in programming. In Ruby, classes can inherit characteristics and behaviours from other classes. This means you can create a new class based on an existing one, inherit its properties and methods, and then customise or add new features to suit your needs.

Class Act: The Parent and Child Relationship

In Ruby, the class that provides the blueprint for another class is called the parent class or superclass, and the class that inherits from the parent is called the child class or subclass.

Going back to our cake, the basic cake recipe is our parent class. The chocolate, vanilla, and strawberry cakes are child classes that inherit from the parent. They keep the core ingredients and preparation steps, but they might also add their unique identities, like extra cocoa for the chocolate cake.

Syntax Simplified

Let’s see how this works in Ruby code:

class Cake
  def prepare
    # Basic preparation steps common to all cakes
  end
end

class ChocolateCake < Cake
  def prepare
    super  # Call the prepare method from the parent class
    # Additional steps for making a chocolate cake
  end
end

In above example, ChocolateCake is a child class of Cake. The prepare method in ChocolateCake first calls the prepare method of the parent class using the super keyword. This way, you ensure that the basic preparation steps are taken care of, and you can focus on the specifics of making a chocolate cake.

Benefits of Inheritance in Ruby

• Code Reusability: Inheritance allows you to write code once in a parent class and reuse it in multiple child classes. Inheritence reduces redundancy and makes your codebase easier to maintain.
• Hierarchy and Organisation: Inheritance helps organise classes in a clear hierarchy, making it easier to understand the relationships between different classes and easy to reuse.
• Customisation: Child classes can customise or extend the behaviour of the parent class while keeping the shared features intact.

Wrap Up

Inheritance is like passing down characteristics from one generation to the next generation. It enables reusability of code, clarity, and customisation. Just like our cake example, where each cake inherits the basics and adds its unique flavour, Ruby classes can inherit attributes and behaviours while allowing you to create specialised versions.

So, the next time you’re writing Ruby code and if you find yourself duplicating similar features, think about inheritance. It might just be the secret ingredient to making your code more efficient, organized, and deliciously maintainable! You can explore more using Ruby Documentation.

Here’s a general guideline on how to run basic API request using Ruby language

To Run Basic API Request Using Watir / Ruby, Start by installing the necessary gems for both Watir and required other libraries. You can also use bundler to manage your gem dependencies.

Installing Required Ruby Gems

First Install following gems using Terminal or command line

gem install watir
gem install httparty   # or gem install rest-client

Import Libraries

Before Writing any script, you need to import require libraries you’ll be using

require 'watir'
require 'httparty'    # or require 'rest-client'

Initialise Watir

Setup Watir to interact with browser.

browser = Watir::Browser.new(:chrome)  # Or :firefox, :safari, etc.

Make API Calls

You can use chosen library (RestClient or HTTParty) to make API calls. Let’s see simple example to understand it.

Call API with HTTParty

response = HTTParty.get('https://api.example.com/testdata')
puts response.code      # HTTP status code
puts response.body      # Response body

And here’s an example of RestClient

response = RestClient.get('https://api.example.com/testdata')
puts response.code      # HTTP status code
puts response.body      # Response body

Clean Up

After making API calls successfully, don’t forgot to close the browser if you no longer need it.

browser.close

Now lets see some proper example to manage all these professionally in OOP approach (POST Request using Ruby)

Create common utils for post request (You can create separate ruby file for this) : Here you can modify post body as per your requirements. This method will prevent you from writing same code multiple times.

def post_request(url, query_param = {}, headers = {}, body = {}, redirects = true)
	log("API Request URL: #{url}")
	response = HTTParty.post(url, query: query_param, headers: headers, body: body, follow_redirects: redirects)
	log("Response: #{response}")
	response
end

Create separate method in your test script file to manage your code. This will help you to write clean and manageable code.

def post_create_user(query_param = {})
  api_url = "Your API Here"
  response = post_request(api_url, query_param, nil, nil)
  response
end

Now Create test method to utilise above logics and perform some assertions.

def check_create_user
	test_data = 	{
		table_name: 'users',
		user_name: 'testautomationlabs',
		password: 'iloveautomation',
		user_role: 'admin',
		user_bio: 'Hello World, This is my awesome bio'
	}
	response = post_create_user(test_data)
	# Assert the status code
	expected_status_code = 200
	if response.code == expected_status_code
		puts "API call successful: Status code is #{expected_status_code}"
	else
		puts "API call failed: Expected status code #{expected_status_code}, but got #{response.code}"
	end
end

Hello readers, today in this article we will learn about Handling a new browser window or tab in Watir. Watir stands for Web Application Testing in Ruby. Using the window class, you can handle new browser tabs or windows that open during the test. The window class allows us to switch between different browser windows or tabs. Let’s see how you can handle new browser tabs in Watir Ruby.

Handling a new browser window in Ruby.

Handling a new browser window in Ruby is not so hard, During the test when you click a link or perform an action that opens a new browser tab or window, you have to switch to that new tab to interact with its elements or contents. For that first, you need to save the identifiers of new open windows and then switch to the new tab.

require 'watir'

# Initialize the browser
browser = Watir::Browser.new :chrome

# Open a webpage
browser.goto 'https://www.example.com'

# Click a link that opens a new tab/window
browser.link(id: 'link_element_id').click

# Store the handles of all open windows/tabs
original_window = browser.window

# Switch to the new tab/window
new_window = browser.window(title: 'New Tab web page title')
new_window.use

# Perform actions in the new tab/window
# ...

# Switch back to the original tab/window
original_window.use

# Close the browser
browser.close

Switching Between Tabs

To switch to the new browser tab or window you can use use method

# Switch to a specific window/tab by its title
browser.window(title: 'New Tab web page title').use

# Switch back to the original window/tab
original_window.use

Handling Multiple Tabs

If you have multiple new tabs in your web browser and you want to switch between them based on their order, you can simply use windows method.

# Get an array of all open windows/tabs
all_windows = browser.windows

# Switch to the first window
all_windows[0].use

# Switch to the second window
all_windows[1].use

Closing a Browser Tab

To close the browser tab/window you can use close method.

# Close the current tab/window
browser.window.use.close

Remember that the above code snippets are only for example and might need to be adapted to your specific use case and website structure. Also, Watir provides different attributes to locate browser windows, for example, by title, URL, and index, so you can choose any of these based on your testing needs. If you are interested in exploring more on Browser Window in Ruby Watir, you can simply read the documentation provided by Watir.

Adding Allure reports to Cucumber in a Java project requires a few steps. Allure is a simple and powerful reporting tool that can enhance the visualization of your Cucumber test results. Here’s how you can integrate Allure with Cucumber in a Java project:

Prerequisites

Before we jump into the integration process, ensure you have the following in place:

1. A Java project with Cucumber tests is already set up.
2. Dependencies for both Cucumber and Allure added to your project (as mentioned in the guide).

Allure framework installation steps:

Start by adding required dependencies like allure-cucumber-jvm etc…

Maven:

<properties>
    <aspectj.version>1.8.10</aspectj.version>
</properties>
<dependencies>
    <dependency>
        <groupId>io.qameta.allure</groupId>
        <artifactId>allure-cucumber4-jvm</artifactId>
        <version>LATEST_VERSION</version>
    </dependency>
</dependencies>
<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-surefire-plugin</artifactId>
            <version>2.20</version>
            <configuration>
                <argLine>
                    -javaagent:"${settings.localRepository}/org/aspectj/aspectjweaver/${aspectj.version}/aspectjweaver-${aspectj.version}.jar"
                    -Dcucumber.options="--plugin io.qameta.allure.cucumber4jvm.AllureCucumber4Jvm"
                </argLine>
            </configuration>
            <dependencies>
                <dependency>
                    <groupId>org.aspectj</groupId>
                    <artifactId>aspectjweaver</artifactId>
                    <version>${aspectj.version}</version>
                </dependency>
            </dependencies>
        </plugin>
    </plugins>
</build>

Gradle

// Gradle
implementation 'io.qameta.allure:allure-cucumber5-jvm:2.17.3' // Latest version

Then execute mvn clean test the goal. After tests are executed allure JSON files will be
placed in allure-results the directory by default.

Features

This adapter provides runtime integration allowing the conversion of Gherkin DSL features into basic Allure features

Display Name

Titles for tests and suites are extracted at runtime from .feature files

Description

Feature’s description appears on every scenario

Steps

All scenario steps are automatically translated into allure steps

Adding Attachments

You can simply add an attachment in Java code by annotating the method with @Attachment that returns either a String or byte[],

import io.qameta.allure.Attachment;
...
@Attachment
public String performedActions(ActionSequence actionSequence) {
    return actionSequence.toString();
}
@Attachment(value = "Page screenshot", type = "image/png")
public byte[] saveScreenshot(byte[] screenShot) {
    return screenShot;
}

Or you can also add Allure helper methods for this

import io.qameta.allure.Allure;
...
Allure.addAttachment("My attachment", "My attachment content");
Path content = Paths.get("path-to-my-attachment-contnet");
try (InputStream is = Files.newInputStream(content)) {
    Allure.addAttachment("My attachment", is);
}

Sample code to Configure Cucumber to Generate Allure reports. This process involves specifying the Allure plugin and the location for generating JSON reports.

import io.cucumber.junit.Cucumber;
import io.cucumber.junit.CucumberOptions;
import org.junit.runner.RunWith;
@RunWith(Cucumber.class)
@CucumberOptions(
    plugin = {
        "io.qameta.allure.cucumber5jvm.AllureCucumber5Jvm",
        "json:target/cucumber-report/cucumber.json" // JSON report location
    },
    features = "src/test/resources/features",
    glue = "your.step.definitions.package"
)
public class CucumberTestRunner {
}

Generating and Viewing Allure Report with Cucumber Java:

To Generate the Allure Report you can use the following commands

Generate the Allure Report in JSON format

allure generate target/cucumber-report

To open the generated report in the default web browser

allure open

Conclusion

Combining Allure reports with Cucumber Java tests elevates your testing and reporting experience to new heights. By following the steps outlined in this guide, you can create beautiful and insightful test reports that improve performance, minimize errors, and provide valuable insights into your test suite’s performance Embrace and leverage the power of Allure your Cucumber test report moves to the next level.