Database Connectivity is the process of connecting an automation framework to a database so that test scripts can read, insert, update, or validate data stored in the database. In Selenium automation testing, database connectivity is commonly implemented using Java Database Connectivity (JDBC).
Database connectivity is especially useful when test data is stored in a relational database instead of being hard-coded inside automation scripts. A Selenium framework can retrieve usernames, product details, order information, customer records, expected results, or other test data directly from a database and use that information during test execution.
Database validation can also be used to verify whether an action performed through the web application has correctly updated the backend database. For example, after creating a new customer through a web application, an automation test can query the database and verify that the customer record was successfully created.
Course Resource: Selenium Training | Register for Course Demo
Database connectivity allows a Java application or automation framework to communicate with a database. Through a database connection, the framework can execute SQL queries and process the results returned by the database.
In Selenium automation, database connectivity is normally handled separately from browser automation. Selenium interacts with the user interface, while JDBC is responsible for communicating with the database.
TestNG Test
|
v
Selenium WebDriver
|
v
Web Application
|
v
Application Backend
|
v
Database
JDBC
|
+---- Connect to Database
+---- Execute SQL Query
+---- Read Result
+---- Validate Data
Modern applications store a large amount of information in databases. UI testing alone may not always be sufficient to verify whether the correct backend operation occurred.
Selenium itself does not provide database connectivity. Selenium WebDriver is designed primarily for browser automation. Java database connectivity is normally implemented using JDBC or a database-specific library.
| Technology | Purpose |
|---|---|
| Selenium WebDriver | Automates the browser and web application |
| Java | Programming language used for the automation framework |
| JDBC | Connects Java applications to databases |
| SQL | Queries and manipulates database data |
| TestNG | Manages test execution and assertions |
| Maven | Manages project dependencies and builds |
JDBC (Java Database Connectivity) is a standard Java API used to connect Java applications with databases.
JDBC provides interfaces and classes that allow Java programs to establish database connections, execute SQL statements, retrieve results, and manage database resources.
Java Automation Framework
|
v
JDBC
|
v
JDBC Driver
|
v
Database
A typical JDBC architecture consists of the Java application, JDBC API, database driver, and database server.
Automation Test
|
v
JDBC API
|
v
JDBC Driver
|
v
Database Server
|
v
Database
The JDBC driver acts as the communication layer between the Java application and the specific database.
| Database | Typical JDBC Driver | Common Usage |
|---|---|---|
| MySQL | MySQL Connector/J | Web applications and test environments |
| PostgreSQL | PostgreSQL JDBC Driver | Enterprise and web applications |
| Oracle | Oracle JDBC Driver | Enterprise applications |
| SQL Server | Microsoft JDBC Driver | Microsoft-based applications |
| H2 | H2 JDBC Driver | Testing and lightweight applications |
Start Test
|
v
Load Database Driver
|
v
Create Database Connection
|
v
Create Statement / PreparedStatement
|
v
Execute SQL Query
|
v
Receive ResultSet
|
v
Read Database Data
|
v
Compare with Expected Data
|
v
TestNG Assertion
|
v
Close Database Resources
|
v
End Test
The general process for JDBC database connectivity is:
The JDBC URL identifies the database server, port, database name, and sometimes additional connection properties.
String url = "jdbc:mysql://localhost:3306/testdb";
String username = "root";
String password = "password";
Connection connection =
DriverManager.getConnection(url, username, password);
The exact JDBC URL format depends on the database being used.
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
import java.sql.PreparedStatement;
import java.sql.SQLException;
A connection can be created using DriverManager.getConnection().
String url = "jdbc:mysql://localhost:3306/testdb";
String username = "root";
String password = "password";
Connection connection =
DriverManager.getConnection(url, username, password);
System.out.println("Database connected successfully");
if (connection != null && !connection.isClosed()) {
System.out.println("Connection is active");
}
Checking the connection can be useful during framework debugging.
A Statement object can be used to execute SQL statements.
Statement statement = connection.createStatement();
ResultSet resultSet =
statement.executeQuery("SELECT * FROM users");
For dynamic values, PreparedStatement is generally preferred because it provides parameter binding and helps avoid SQL injection risks.
The executeQuery() method is commonly used for SELECT statements.
String query = "SELECT * FROM users";
Statement statement = connection.createStatement();
ResultSet resultSet = statement.executeQuery(query);
ResultSet represents the data returned by a database SELECT query.
while (resultSet.next()) {
String username = resultSet.getString("username");
String email = resultSet.getString("email");
System.out.println(username);
System.out.println(email);
}
The next() method moves the cursor to the next row.
int id = resultSet.getInt("id");
String name = resultSet.getString("name");
double salary = resultSet.getDouble("salary");
boolean active = resultSet.getBoolean("active");
The getter method should correspond to the database column's data type.
ResultSet values can also be retrieved by column index.
String name = resultSet.getString(2);
int age = resultSet.getInt(3);
Column names are generally easier to maintain and understand than numeric indexes.
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
public class DatabaseExample {
public static void main(String[] args) {
String url = "jdbc:mysql://localhost:3306/testdb";
String username = "root";
String password = "password";
try {
Connection connection =
DriverManager.getConnection(url, username, password);
Statement statement = connection.createStatement();
ResultSet resultSet =
statement.executeQuery("SELECT * FROM users");
while (resultSet.next()) {
System.out.println(
resultSet.getString("username")
);
}
resultSet.close();
statement.close();
connection.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
Selenium and JDBC can be combined to validate complete application workflows.
TestNG
|
+---- Selenium WebDriver
| |
| v
| Web Application
|
+---- JDBC
|
v
Database
Both results
|
v
TestNG Assertion
Suppose a registration form creates a new user. Selenium can fill the form and submit it. JDBC can then query the database to verify that the user was actually stored.
Selenium
|
v
Fill Registration Form
|
v
Click Register
|
v
Application Saves User
|
v
JDBC Query
|
v
Database
|
v
Verify User Record
String expectedUsername = "john123";
driver.findElement(By.id("username"))
.sendKeys(expectedUsername);
driver.findElement(By.id("registerButton"))
.click();
String query =
"SELECT username FROM users WHERE username = ?";
PreparedStatement statement =
connection.prepareStatement(query);
statement.setString(1, expectedUsername);
ResultSet resultSet =
statement.executeQuery();
if (resultSet.next()) {
System.out.println("User exists in database");
}
PreparedStatement is used for parameterized SQL queries. It is generally preferred when query values come from test data or application input.
String query =
"SELECT * FROM users WHERE username = ?";
PreparedStatement statement =
connection.prepareStatement(query);
statement.setString(1, "john123");
ResultSet resultSet =
statement.executeQuery();
String query =
"SELECT * FROM users WHERE username = ? AND status = ?";
PreparedStatement statement =
connection.prepareStatement(query);
statement.setString(1, "john123");
statement.setString(2, "ACTIVE");
ResultSet resultSet =
statement.executeQuery();
Database connectivity can also be used to insert test data.
String query =
"INSERT INTO users (username, email) VALUES (?, ?)";
PreparedStatement statement =
connection.prepareStatement(query);
statement.setString(1, "john123");
statement.setString(2, "[email protected]");
int rows =
statement.executeUpdate();
System.out.println("Rows inserted: " + rows);
String query =
"UPDATE users SET status = ? WHERE username = ?";
PreparedStatement statement =
connection.prepareStatement(query);
statement.setString(1, "ACTIVE");
statement.setString(2, "john123");
int rows =
statement.executeUpdate();
System.out.println("Rows updated: " + rows);
String query =
"DELETE FROM users WHERE username = ?";
PreparedStatement statement =
connection.prepareStatement(query);
statement.setString(1, "john123");
int rows =
statement.executeUpdate();
System.out.println("Rows deleted: " + rows);
| Method | Typical Usage | Return Type |
|---|---|---|
| executeQuery() | SELECT | ResultSet |
| executeUpdate() | INSERT, UPDATE, DELETE | int |
| execute() | General SQL execution | boolean |
TestNG can be used to organize database validation tests and perform assertions on the retrieved database values.
import org.testng.Assert;
import org.testng.annotations.Test;
@Test
public void databaseValidationTest() {
String expectedUsername = "john123";
String actualUsername = "john123";
Assert.assertEquals(
actualUsername,
expectedUsername
);
}
String expectedStatus = "ACTIVE";
String actualStatus = resultSet.getString("status");
Assert.assertEquals(
actualStatus,
expectedStatus,
"Database status does not match"
);
Assertions convert database verification into a formal test result.
In a reusable automation framework, database connection logic should generally be placed in a utility class rather than duplicated across every test.
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
public class DatabaseUtils {
private static final String URL =
"jdbc:mysql://localhost:3306/testdb";
private static final String USERNAME = "root";
private static final String PASSWORD = "password";
public static Connection getConnection()
throws SQLException {
return DriverManager.getConnection(
URL,
USERNAME,
PASSWORD
);
}
}
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.PreparedStatement;
public class UserDatabaseTest {
public void verifyUser() throws Exception {
Connection connection =
DatabaseUtils.getConnection();
String query =
"SELECT username FROM users WHERE username = ?";
PreparedStatement statement =
connection.prepareStatement(query);
statement.setString(1, "john123");
ResultSet resultSet =
statement.executeQuery();
if (resultSet.next()) {
System.out.println(
resultSet.getString("username")
);
}
resultSet.close();
statement.close();
connection.close();
}
}
Java's try-with-resources statement is a useful way to automatically close JDBC resources.
String query =
"SELECT username FROM users WHERE username = ?";
try (Connection connection =
DatabaseUtils.getConnection();
PreparedStatement statement =
connection.prepareStatement(query)) {
statement.setString(1, "john123");
try (ResultSet resultSet =
statement.executeQuery()) {
while (resultSet.next()) {
System.out.println(
resultSet.getString("username")
);
}
}
}
Database connections, statements, and result sets consume resources. If they are not closed properly, long-running automation suites may experience connection leaks or resource exhaustion.
Database configuration should ideally be separated from test logic.
db.url=jdbc:mysql://localhost:3306/testdb
db.username=test_user
db.password=test_password
A configuration reader can load these values at runtime.
Properties properties = new Properties();
FileInputStream input =
new FileInputStream("config.properties");
properties.load(input);
String url =
properties.getProperty("db.url");
String username =
properties.getProperty("db.username");
String password =
properties.getProperty("db.password");
Connection connection =
DriverManager.getConnection(
url,
username,
password
);
Database usernames and passwords should not normally be committed as plain text into source control, especially when they provide access to shared environments.
Depending on the project, credentials can be supplied through environment variables, CI/CD secret stores, secure configuration systems, or other approved secret-management solutions.
Maven can manage JDBC driver dependencies for the automation project.
For example, a MySQL-based project can include the appropriate MySQL Connector/J dependency in pom.xml.
<dependency>
<groupId>com.mysql</groupId>
<artifactId>mysql-connector-j</artifactId>
<version>YOUR_VERSION</version>
</dependency>
The exact driver version should be selected according to the project's Java version, database version, and dependency-management requirements.
JDBC and TestNG Data Providers can be combined to create database-driven testing. A Data Provider can retrieve rows from a database and pass them to a test method.
@DataProvider(name = "users")
public Object[][] users() {
// Database query can be executed here.
return new Object[][] {
{"john123", "ACTIVE"},
{"david123", "ACTIVE"},
{"robert123", "INACTIVE"}
};
}
@Test(dataProvider = "users")
public void userTest(
String username,
String status) {
System.out.println(username);
System.out.println(status);
}
Database
|
v
SQL Query
|
v
JDBC
|
v
Data Provider
|
v
TestNG
|
v
Selenium WebDriver
|
v
Web Application
|
v
Validation
A database can contain user credentials or user status information required for login testing. The framework can retrieve appropriate test records and use them during UI automation.
Database
|
v
Username / User Status
|
v
Data Provider
|
v
Login Test
|
v
Selenium
|
v
Login Page
|
v
Assertion
Sensitive passwords should be handled through appropriate secure mechanisms rather than exposing them unnecessarily in logs or reports.
Registration testing is a common database validation scenario.
Enter Registration Data
|
v
Click Register
|
v
Application
|
v
Database INSERT
|
v
JDBC SELECT
|
v
Verify Record
|
v
TestNG Assertion
E-commerce applications often require database validation for products, customers, orders, payments, inventory, and shipping information.
| UI Action | Possible Database Validation |
|---|---|
| Add Product to Cart | Cart record |
| Place Order | Order record |
| Apply Discount | Discount/order amount |
| Complete Payment | Payment status |
| Cancel Order | Order status |
| Update Quantity | Inventory/cart quantity |
Database data can also be used to generate search test cases.
Database
|
v
Product Names
|
v
Data Provider
|
v
Selenium Search Test
|
v
Search Results
|
v
Database / UI Validation
Database validation can be used with both API and UI automation.
API Test
|
v
Application Backend
|
v
Database
|
v
JDBC Validation
UI Test
|
v
Web Application
|
v
Database
|
v
JDBC Validation
Database utilities should generally remain separate from Page Object classes. Page Objects should focus on UI interactions, while database utilities should handle database operations.
Test Class
|
+---- Page Object
| |
| v
| UI Interaction
|
+---- Database Utility
|
v
JDBC Query
|
v
Database
src
|-- test
| |-- java
| |-- tests
| | |-- LoginTest.java
| | |-- RegistrationTest.java
| | |-- OrderTest.java
| |
| |-- pages
| | |-- LoginPage.java
| | |-- RegistrationPage.java
| | |-- OrderPage.java
| |
| |-- database
| | |-- DatabaseUtils.java
| | |-- DatabaseQueries.java
| |
| |-- data
| | |-- TestDataProvider.java
| |
| |-- utilities
| |-- ConfigReader.java
| |-- DriverFactory.java
Frequently used SQL queries can be maintained in a dedicated utility class.
public class DatabaseQueries {
public static final String GET_USER =
"SELECT * FROM users WHERE username = ?";
public static final String GET_ORDER =
"SELECT * FROM orders WHERE order_id = ?";
public static final String GET_PRODUCT =
"SELECT * FROM products WHERE product_id = ?";
}
A database connection can be initialized before a group of tests when the test design requires a shared or controlled connection.
@BeforeMethod
public void setupDatabase() throws Exception {
connection = DatabaseUtils.getConnection();
}
@AfterMethod
public void closeDatabase() throws Exception {
if (connection != null) {
connection.close();
}
}
For parallel execution, shared connections should be avoided unless the design is explicitly thread-safe.
A connection can also be initialized at class level when appropriate.
@BeforeClass
public void setupDatabase() throws Exception {
connection = DatabaseUtils.getConnection();
}
@AfterClass
public void closeDatabase() throws Exception {
if (connection != null) {
connection.close();
}
}
Parallel Selenium tests require careful database design as well. Tests should avoid unintended conflicts when multiple threads access or modify the same database records.
Thread 1
|
+---- WebDriver 1
|
+---- Database Data 1
Thread 2
|
+---- WebDriver 2
|
+---- Database Data 2
Thread 3
|
+---- WebDriver 3
|
+---- Database Data 3
Test data should be isolated where necessary to prevent one test from changing the data required by another test.
A database transaction is a logical unit of database work. Transactions can be useful when test setup requires multiple related database operations.
connection.setAutoCommit(false);
try {
// INSERT
// UPDATE
// Additional database operations
connection.commit();
} catch (Exception e) {
connection.rollback();
throw e;
}
| Operation | Purpose |
|---|---|
| commit() | Permanently applies transaction changes |
| rollback() | Reverts uncommitted transaction changes |
| setAutoCommit(false) | Allows explicit transaction control |
Database connectivity can be used to prepare test data before a test begins.
@BeforeMethod
public void createTestData() throws Exception {
String query =
"INSERT INTO users (username, status) VALUES (?, ?)";
try (PreparedStatement statement =
connection.prepareStatement(query)) {
statement.setString(1, "testuser");
statement.setString(2, "ACTIVE");
statement.executeUpdate();
}
}
After a test completes, test-created records can sometimes be removed to keep the environment clean.
@AfterMethod
public void cleanupTestData() throws Exception {
String query =
"DELETE FROM users WHERE username = ?";
try (PreparedStatement statement =
connection.prepareStatement(query)) {
statement.setString(1, "testuser");
statement.executeUpdate();
}
}
Cleanup should be designed carefully so that it does not delete data belonging to other tests or users.
Database operations can fail because of incorrect credentials, network problems, unavailable servers, invalid SQL, timeouts, or database constraints.
try {
Connection connection =
DatabaseUtils.getConnection();
} catch (SQLException e) {
System.out.println(
"Database connection failed"
);
e.printStackTrace();
}
| Problem | Possible Cause |
|---|---|
| SQLException | General database operation failure |
| Connection failure | Incorrect URL, server, network, or credentials |
| SQL syntax error | Invalid SQL statement |
| Authentication error | Invalid database username/password |
| Timeout | Database server or network response delay |
| Constraint violation | Invalid INSERT or UPDATE operation |
| Feature | Selenium | JDBC |
|---|---|---|
| Main Purpose | Web browser automation | Database connectivity |
| Works With | Web application UI | Database |
| Typical Operations | Click, type, select, navigate | SELECT, INSERT, UPDATE, DELETE |
| Validation | UI behavior | Backend data |
| Common API | WebDriver | JDBC |
| Data Provider | Database Connectivity |
|---|---|
| Supplies data to tests | Communicates with database |
| Uses TestNG @DataProvider | Uses JDBC or database libraries |
| Can use data from many sources | Specifically interacts with database systems |
| Useful for repeated test execution | Useful for database read/write/validation |
TestNG
|
+-----------+-----------+
| |
v v
Data Provider Test Class
| |
v v
Test Data Page Objects
|
v
Selenium WebDriver
|
v
Web Application
|
v
Database
^
|
JDBC Utility
|
v
SQL Queries
|
v
Assertions
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.testng.Assert;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
public class RegistrationDatabaseTest {
WebDriver driver;
Connection connection;
@BeforeMethod
public void setup() throws Exception {
driver = new ChromeDriver();
driver.manage()
.window()
.maximize();
driver.get("https://example.com/register");
connection =
DatabaseUtils.getConnection();
}
@Test
public void verifyRegistrationInDatabase()
throws Exception {
String username = "testuser123";
String email = "[email protected]";
driver.findElement(By.id("username"))
.sendKeys(username);
driver.findElement(By.id("email"))
.sendKeys(email);
driver.findElement(By.id("registerButton"))
.click();
String query =
"SELECT username, email " +
"FROM users WHERE username = ?";
try (PreparedStatement statement =
connection.prepareStatement(query)) {
statement.setString(1, username);
try (ResultSet resultSet =
statement.executeQuery()) {
Assert.assertTrue(
resultSet.next(),
"User record was not found"
);
Assert.assertEquals(
resultSet.getString("username"),
username
);
Assert.assertEquals(
resultSet.getString("email"),
email
);
}
}
}
@AfterMethod
public void tearDown() throws Exception {
if (connection != null) {
connection.close();
}
if (driver != null) {
driver.quit();
}
}
}
Consider an e-commerce application where a user places an order.
Step 1:
Login through Selenium
|
v
Step 2:
Search Product
|
v
Step 3:
Add Product to Cart
|
v
Step 4:
Checkout
|
v
Step 5:
Place Order
|
v
Step 6:
Capture Order ID
|
v
Step 7:
JDBC Query
|
v
SELECT order_id, status
FROM orders
WHERE order_id = ?
|
v
Step 8:
Validate Database Record
|
v
Step 9:
TestNG Assertion
String query =
"SELECT status FROM orders WHERE order_id = ?";
PreparedStatement statement =
connection.prepareStatement(query);
statement.setString(1, orderId);
ResultSet resultSet =
statement.executeQuery();
Assert.assertTrue(resultSet.next());
String status =
resultSet.getString("status");
Assert.assertEquals(
status,
"CONFIRMED"
);
Database validation is useful when the UI only displays a limited amount of information. The test can verify backend fields that may not be directly visible in the UI.
| Application Layer | Validation |
|---|---|
| UI | Visible application behavior |
| API | Service response |
| Database | Persisted backend data |
Database validation can strengthen regression testing by verifying that previously working database operations continue to work after application changes.
Database-enabled Selenium tests can run inside CI/CD pipelines when the pipeline has access to the appropriate test environment and database.
Developer Commit
|
v
Git Repository
|
v
CI/CD Pipeline
|
v
Maven Build
|
v
TestNG
|
+---- Selenium
|
+---- JDBC
|
v
Test Database
|
v
Test Results
|
v
Report
Database validation failures should be visible in the automation report. Test reports can identify whether a failure occurred during UI interaction, SQL execution, or database validation.
Test Case
|
+---- UI Step
|
+---- Database Query
|
+---- Database Result
|
+---- Assertion
|
v
PASS / FAIL
|
v
Test Report
selenium-automation-framework
|
|-- pom.xml
|
|-- src
| |-- test
| |-- java
| |-- tests
| | |-- LoginTest.java
| | |-- RegistrationTest.java
| | |-- OrderTest.java
| |
| |-- pages
| | |-- LoginPage.java
| | |-- RegistrationPage.java
| | |-- OrderPage.java
| |
| |-- database
| | |-- DatabaseUtils.java
| | |-- DatabaseQueries.java
| |
| |-- data
| | |-- TestDataProvider.java
| |
| |-- utilities
| |-- ConfigReader.java
| |-- DriverFactory.java
|
|-- src
|-- test
|-- resources
|-- config.properties
JDBC stands for Java Database Connectivity and provides Java APIs for communicating with relational databases.
JDBC can be used to retrieve test data and validate backend database records during Selenium automation.
No. Selenium WebDriver handles browser automation. Database communication is normally implemented separately using JDBC or another database library.
A JDBC driver is software that enables Java applications to communicate with a specific database.
A connection can commonly be created using DriverManager.getConnection() with the database URL, username, and password.
ResultSet represents the rows returned by a SELECT query.
PreparedStatement represents a parameterized SQL statement and is commonly used when query values are supplied dynamically.
Statement executes SQL directly, while PreparedStatement supports parameterized SQL and is generally preferred for dynamic input values.
executeQuery() is commonly used for SELECT statements and returns a ResultSet.
executeUpdate() is commonly used for INSERT, UPDATE, and DELETE operations and returns the number of affected rows.
Connections consume database and application resources. Closing them helps prevent connection leaks and resource exhaustion.
Selenium can perform a UI action, JDBC can retrieve the corresponding backend record, and TestNG assertions can compare actual and expected values.
Yes. A Data Provider can retrieve records from a database and supply them to TestNG test methods.
Yes. Database utilities and Page Objects can be maintained separately while the test class coordinates both.
Database-driven testing is an approach where test data is retrieved dynamically from a database and supplied to test cases.
Credentials should be stored using secure configuration, environment variables, CI/CD secrets, or an approved secret-management solution instead of plain-text source-controlled files.
A transaction is a logical unit of database operations that can be committed or rolled back as a group.
Rollback reverses uncommitted database changes in a transaction.
Tests can interfere with each other. Test data isolation and controlled test design are important, especially during parallel execution.
Common mistakes include incorrect connection configuration, invalid SQL, unclosed resources, hard-coded credentials, unsafe shared data, and insufficient cleanup.
| Concept | Description |
|---|---|
| JDBC | Java API for database connectivity |
| DriverManager | Used to obtain database connections |
| Connection | Represents a database connection |
| Statement | Executes SQL statements |
| PreparedStatement | Executes parameterized SQL statements |
| ResultSet | Contains data returned by SELECT queries |
| executeQuery() | Commonly executes SELECT queries |
| executeUpdate() | Commonly executes INSERT, UPDATE, DELETE |
| commit() | Commits a transaction |
| rollback() | Rolls back uncommitted transaction changes |
| Selenium | Automates the web UI |
| TestNG | Manages tests and assertions |
Suppose a customer registers on an e-commerce application.
1. Launch Browser
|
v
2. Open Registration Page
|
v
3. Enter Customer Details
|
v
4. Submit Registration
|
v
5. Application Processes Request
|
v
6. Database INSERT
|
v
7. Capture Customer ID
|
v
8. Execute JDBC SELECT
|
v
9. Retrieve Customer Record
|
v
10. Compare Expected vs Actual
|
v
11. TestNG Assertion
|
v
12. Generate Test Report
TestNG
|
+------------+------------+
| |
v v
Test Classes Data Providers
| |
v v
Page Objects Test Data
|
v
Selenium WebDriver
|
v
Web Application
|
v
Backend
|
v
Database
^
|
JDBC Utility
|
v
SQL Queries
|
v
DB Validation
|
v
Assertions
|
v
Reporting
Database Connectivity is an important capability in advanced Selenium automation frameworks. Selenium WebDriver handles browser automation, while JDBC provides a mechanism for Java-based test frameworks to communicate with relational databases.
Database connectivity can be used to retrieve test data, create test data, update records, clean up test data, and validate backend information after UI actions.
A typical implementation uses Connection, PreparedStatement, ResultSet, SQL queries, TestNG assertions, and reusable database utility classes.
For enterprise-level automation frameworks, database connectivity can be combined with Selenium WebDriver, TestNG, Data Providers, Page Object Model, Maven, CI/CD, parallel execution, and reporting to create comprehensive end-to-end automation solutions.
Learn more about Selenium automation testing and related framework concepts:
Final Takeaway: Database Connectivity allows Selenium automation frameworks to go beyond UI validation by interacting with backend database systems. When JDBC, Selenium, TestNG, Data Providers, POM, and SQL are combined correctly, automation tests can validate complete application workflows from the user interface through the backend database.
