Skip to main content

Data-Driven Testing Using Database Integration in TestGrid Codeless

Overview

Modern test automation often requires validating application behavior against backend data or using dynamic test data stored in databases. TestGrid supports database-driven automation through custom scripts, allowing users to securely connect to databases, fetch data at runtime, and use it directly within automation test cases.

This document explains how to:

  • Establish a database connection
  • Fetch required data from the database
  • Use database values dynamically in automation test cases
  • Follow enterprise security and compliance best practices

Use Cases

Database integration in automation is useful when:

  • Test data must be fetched dynamically
  • UI data needs to be validated against backend records
  • OTPs, transaction IDs, or user details are stored in DB
  • End-to-end data consistency validation is required
  • Tests must avoid hardcoded values

Prerequisites

Before proceeding, ensure the following:

  • Active TestGrid account
  • Database credentials (host, port, DB name, username, password)
  • Network access from execution environment to database
  • JDBC driver added to the project dependencies

High-Level Flow

  1. Configure database connection details securely
  2. Establish database connection using JDBC
  3. Execute SQL query to fetch test data
  4. Store retrieved data in variables
  5. Use database data in automation steps
  6. Close database connection

 

Step 1: Add Required Dependencies and Import Statements

Add the required JDBC driver dependency to TG automation project using Add Maven Dependency.

<dependency>
     <groupId>mysql</groupId>
     <artifactId>mysql-connector-java</artifactId>
     <version>8.0.33</version>
</dependency>

You can replace the dependency based on your database type (PostgreSQL, Oracle, SQL Server, etc.).

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;

These imports are mandatory when using JDBC to connect and interact with databases in automation scripts.

More about Add dependencies and import statements: https://testgrid.io/docs/document/add-a-import-statements-and-custom-libraries-in-version-suites/

 

Step 2: Configure Database Connection

Store database credentials securely in globle variables and use it in your code:

String dbUrl = System.getenv("DB_URL");
String dbUser = System.getenv("DB_USERNAME");
String dbPassword = System.getenv("DB_PASSWORD");

This approach avoids hardcoding sensitive information.

More about global variables: https://testgrid.io/docs/document/using-global-variables-in-test-cases-and-functions/

 

Step 3: Establish Database Connection

Use JDBC to create a database connection:

Connection connection = DriverManager.getConnection(dbUrl, dbUser, dbPassword);
Step 4: Fetch Data from Database

Execute SQL queries to retrieve required test data:

String query = "SELECT username, password FROM test_users WHERE status='ACTIVE' LIMIT 1";
Statement statement = connection.createStatement();
ResultSet resultSet = statement.executeQuery(query);

String username = null;
String password = null;

if (resultSet.next()) {
username = resultSet.getString("username");
password = resultSet.getString("password");
}
Step 5: Use Database Data in Automation Test Case

Use the retrieved values directly in your automation steps:

driver.findElement(By.id("username_field")).sendKeys(username);
driver.findElement(By.id("password_field")).sendKeys(password);
driver.findElement(By.id("login_button")).click();

This ensures tests run with real and up-to-date data.

Step 7: Close Database Connection

Always close database resources after execution:

resultSet.close();
statement.close();
connection.close();

Error Handling

Wrap database operations in try-catch blocks:

try {
// DB operations
} catch (SQLException e) {
System.err.println("Database operation failed: " + e.getMessage());
}

This improves test stability.

reference code:

Statement statement = null;
        ResultSet resultSet = null;
        try {
            Class.forName("com.mysql.cj.jdbc.Driver");
            Connection connection = DriverManager.getConnection(var_DB_URL, var_USER, var_PASSWORD);
            System.out.println("✅ Connected to Database");
            statement = connection.createStatement();
            resultSet = statement.executeQuery("SELECT * FROM `users` WHERE id = 3");
            while (resultSet.next()) {
                var_userName = resultSet.getString("username");
                var_emailid = resultSet.getString("email");
                var_ageofuser = resultSet.getInt("age");
                System.out.println("Employee Name: " + var_userName + " " + var_emailid +" "+ var_ageofuser);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("🔒 DB resources closed");

More about Custom Expressions: https://testgrid.io/docs/document/using-custom-expressions-in-scriptless-test-cases-with-java-selenium-appium/

 

 

Custom Expression in Code Editor:

 

 

Test Case Execution Logs:

 

 

Security and Compliance Considerations

  • Never hardcode database credentials
  • Use environment variables or vault integrations
  • Apply least-privilege DB access
  • Mask sensitive data in logs
  • Aligns with SOC2, ISO, and enterprise security standards

 

Best Practices

  • Use read-only DB users for automation
  • Clean up test data after execution
  • Avoid complex queries in UI tests
  • Separate test data per environment
  • Monitor DB connectivity in CI/CD pipelines

 

Conclusion

By integrating database connectivity into TestGrid automation test cases, teams can create robust, data-driven, and enterprise-ready automation workflows. This approach eliminates hardcoded test data, improves validation accuracy, and enables full end-to-end testing across UI and backend layers.

Table of Contents