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 2026, 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.