Can Playwright directly connect to databases?

No, Playwright doesn't have built-in database connectivity features. You need to integrate external Node.js database libraries like 'pg' for PostgreSQL, 'mysql2' for MySQL, or 'mongodb' for MongoDB.

Why should I use database connections in Playwright tests?

Database connections allow you to verify that data created through the UI is properly stored, test with different data sets, implement data-driven testing, automate data setup/teardown, and validate complex business logic.

How do I manage database connections in Playwright tests?

Use test hooks for connection management, ensure proper initialization and cleanup, consider connection pooling for better performance, and handle database transactions to maintain data consistency.

What databases are supported with Playwright?

Playwright can work with any database through appropriate Node.js libraries including PostgreSQL, MySQL, MongoDB, SQLite, and others. The examples in this guide cover PostgreSQL, MySQL, and MongoDB connections.

How do I handle test data isolation in Playwright database tests?

Create unique test data for each test, use factories for generating test data, implement proper cleanup strategies, and consider using database transactions to ensure data consistency across test runs.

Database Connection in Playwright: A Comprehensive Guide with Code Examples

Playwright has emerged as a powerful tool for browser automation and end-to-end testing, but many developers wonder how to implement database connections within their testing workflows. In this guide, we'll explore the various methods for establishing database connections in Playwright tests, along with practical code examples to help you integrate database interactions seamlessly into your testing strategy.

Understanding Playwright and Its Capabilities

Playwright is a modern automation library developed by Microsoft that enables reliable end-to-end testing for web applications. It supports multiple browsers (Chrome, Firefox, WebKit) and provides a high-level API for automating browser interactions. While Playwright excels at simulating user behavior in browsers, it's important to understand that it doesn't have built-in database connectivity features. This means that to interact with databases during testing, you'll need to leverage additional Node.js libraries and integrate them with your Playwright scripts.

Playwright's primary focus is on browser automation rather than server-side operations, which is why database connections require external libraries. However, this design choice actually provides flexibility, allowing you to choose the database connection method that best fits your specific needs and stack. By combining Playwright with appropriate database libraries, you can create comprehensive test suites that validate both frontend behavior and backend data integrity.

Why Database Connections Matter in Testing

Integrating database connections into your Playwright tests can significantly enhance the quality and reliability of your test suite. When tests interact with a database, you can:

Verify that data created through the UI is properly stored in the database
Test application behavior with different data sets and scenarios
Implement data-driven testing by pulling test data from database tables
Automate data setup and teardown processes for consistent test environments
Validate complex business logic that involves multiple database operations

Database connections enable you to perform end-to-end testing that goes beyond UI interactions alone. This approach, often called "data testing," ensures that your application not only looks correct but also functions correctly with real data. For example, you can verify that a user registration process properly saves user information to the database or that a search function retrieves the correct results based on database content.

Setting Up Your Environment for Database Connections

Before implementing database connections in Playwright, you'll need to prepare your development environment. The first step is to install the necessary Node.js packages for your specific database. For PostgreSQL, you would install the 'pg' package using npm:

npm install pg

For MySQL, you would use 'mysql2':

npm install mysql2

And for MongoDB, you would use 'mongodb':

npm install mongodb

Next, ensure you have your database credentials and connection details readily available. These typically include:

Host
Port
Database name
Username
Password
Connection pool settings (if applicable)

Establishing Database Connections in Playwright

Once your environment is set up, you can establish database connections within your Playwright tests. The key is to manage these connections properly, ensuring they're opened before tests run and closed after tests complete.

PostgreSQL Connection Example

Here's how to create a PostgreSQL connection in your Playwright test:

const { chromium } = require('playwright');
const { Client } = require('pg');

async function connectToPostgreSQL() {
  const client = new Client({
    host: 'localhost',
    port: 5432,
    database: 'testdb',
    user: 'testuser',
    password: 'testpassword'
  });

  await client.connect();
  return client;
}

(async () => {
  // Start browser
  const browser = await chromium.launch();
  const page = await browser.newPage();
  
  // Connect to database
  const dbClient = await connectToPostgreSQL();
  
  // Run a test
  await page.goto('https://example.com/login');
  await page.fill('#username', 'testuser');
  await page.fill('#password', 'testpass');
  await page.click('#login-btn');
  
  // Verify data in database
  const result = await dbClient.query('SELECT * FROM users WHERE username = $1', ['testuser']);
  console.log('User found:', result.rows);
  
  // Cleanup
  await dbClient.end();
  await browser.close();
})();

MySQL Connection Example

For MySQL, the process is similar but uses the mysql2 package:

const { firefox } = require('playwright');
const mysql = require('mysql2/promise');

async function connectToMySQL() {
  const connection = await mysql.createConnection({
    host: 'localhost',
    port: 3306,
    database: 'testdb',
    user: 'testuser',
    password: 'testpassword'
  });
  
  return connection;
}

(async () => {
  // Start browser
  const browser = await firefox.launch();
  const page = await browser.newPage();
  
  // Connect to database
  const dbConnection = await connectToMySQL();
  
  // Run a test
  await page.goto('https://example.com/products');
  await page.click('#add-to-cart');
  
  // Verify cart in database
  const [rows] = await dbConnection.execute(
    'SELECT * FROM cart_items WHERE user_id = ?', [1]
  );
  console.log('Cart items:', rows);
  
  // Cleanup
  await dbConnection.end();
  await browser.close();
})();

MongoDB Connection Example

MongoDB uses a different connection pattern:

const { webkit } = require('playwright');
const { MongoClient } = require('mongodb');

async function connectToMongoDB() {
  const uri = "mongodb://localhost:27017";
  const client = new MongoClient(uri);
  await client.connect();
  return client.db('testdb');
}

(async () => {
  // Start browser
  const browser = await webkit.launch();
  const page = await browser.newPage();
  
  // Connect to database
  const db = await connectToMongoDB();
  
  // Run a test
  await page.goto('https://example.com/profile');
  await page.fill('#bio', 'Test bio');
  await page.click('#save-profile');
  
  // Verify data in database
  const user = await db.collection('users').findOne({ username: 'testuser' });
  console.log('User profile:', user);
  
  // Cleanup
  await client.close();
  await browser.close();
})();

Implementing Database Operations in Playwright Tests

Once you've established a database connection, you can perform various operations to enhance your tests.

Reading Data

Reading data from the database is common for verifying UI behavior:

// In a test file
const { chromium } = require('playwright');
const { Client } = require('pg');

async function testUserDashboard() {
  const browser = await chromium.launch();
  const page = await browser.newPage();
  const dbClient = new Client(/* connection config */);
  await dbClient.connect();
  
  // Navigate to dashboard
  await page.goto('https://example.com/dashboard');
  
  // Get expected user data from database
  const { rows: userData } = await dbClient.query(
    'SELECT name, email, role FROM users WHERE id = $1', [1]
  );
  
  // Verify UI displays correct data
  await page.waitForSelector('#user-name');
  const nameElement = await page.$('#user-name');
  const displayedName = await nameElement.textContent();
  
  expect(displayedName).toBe(userData[0].name);
  
  // Cleanup
  await dbClient.end();
  await browser.close();
}

Creating Data

You might need to create test data before running UI tests:

async function setupTestEnvironment() {
  const dbClient = new Client(/* connection config */);
  await dbClient.connect();
  
  // Create test data
  await dbClient.query(`
    INSERT INTO products (name, price, category) 
    VALUES ('Test Product', 19.99, 'Electronics')
    ON CONFLICT (name) DO NOTHING
  `);
  
  // Now run UI test that interacts with this product
  const browser = await chromium.launch();
  const page = await browser.newPage();
  await page.goto('https://example.com/products');
  await page.click('text=Test Product');
  
  // Verify product details page
  await expect(page).toHaveURL(/\/product\/test-product/);
  
  // Cleanup
  await dbClient.query('DELETE FROM products WHERE name = $1', ['Test Product']);
  await dbClient.end();
  await browser.close();
}

Updating Data

Testing UI behavior after data updates:

async function testDataUpdate() {
  const dbClient = new Client(/* connection config */);
  await dbClient.connect();
  
  // Initial state
  await dbClient.query(
    'UPDATE users SET subscription_status = $1 WHERE id = $2',
    ['active', 1]
  );
  
  const browser = await chromium.launch();
  const page = await browser.newPage();
  
  // UI test with initial data
  await page.goto('https://example.com/profile');
  await expect(page.locator('#subscription-status')).toHaveText('Active');
  
  // Update data in database
  await dbClient.query(
    'UPDATE users SET subscription_status = $1 WHERE id = $2',
    ['expired', 1]
  );
  
  // Reload page to see updated data
  await page.reload();
  await expect(page.locator('#subscription-status')).toHaveText('Expired');
  
  // Cleanup
  await dbClient.end();
  await browser.close();
}

Deleting Data

Testing how the UI handles data deletion:

async function testDataDeletion() {
  const dbClient = new Client(/* connection config */);
  await dbClient.connect();
  
  // Create test data
  await dbClient.query(
    'INSERT INTO orders (id, user_id, status) VALUES ($1, $2, $3)',
    [999, 1, 'pending']
  );
  
  const browser = await chromium.launch();
  const page = await browser.newPage();
  
  // Verify UI shows the order
  await page.goto('https://example.com/orders');
  await expect(page.locator('text=Order #999')).toBeVisible();
  
  // Delete from database
  await dbClient.query('DELETE FROM orders WHERE id = $1', [999]);
  
  // Refresh UI and verify order is gone
  await page.reload();
  await expect(page.locator('text=Order #999')).toBeHidden();
  
  // Cleanup
  await dbClient.end();
  await browser.close();
}

Best Practices for Database Testing with Playwright

When working with database connections in Playwright tests, follow these best practices:

1. Use Test Hooks for Connection Management

Set up database connections in test hooks to ensure proper initialization and cleanup:

const { chromium } = require('playwright');
const { Client } = require('pg');
const { beforeAll, afterAll, test } = require('@playwright/test');

let dbClient;
let browser;

beforeAll(async () => {
  // Initialize database connection
  dbClient = new Client({
    host: 'localhost',
    port: 5432,
    database: 'testdb',
    user: 'testuser',
    password: 'testpassword'
  });
  await dbClient.connect();
  
  // Launch browser
  browser = await chromium.launch();
});

afterAll(async () => {
  // Clean up database
  await dbClient.end();
  
  // Close browser
  await browser.close();
});

test('user registration', async () => {
  const page = await browser.newPage();
  // Test code here
});

2. Isolate Test Data

Ensure each test runs with clean data or properly isolated data:

async function setupTestUser() {
  // Create unique user for this test
  const testUsername = `testuser_${Date.now()}`;
  await dbClient.query(
    'INSERT INTO users (username, email) VALUES ($1, $2)',
    [testUsername, `${testUsername}@example.com`]
  );
  
  return testUsername;
}

async function cleanupTestUser(username) {
  await dbClient.query('DELETE FROM users WHERE username = $1', [username]);
}

3. Use Connection Pooling

For better performance, especially with many tests:

const { Pool } = require('pg');
const pool = new Pool({
  host: 'localhost',
  port: 5432,
  database: 'testdb',
  user: 'testuser',
  password: 'testpassword',
  max: 10, // Maximum number of connections in the pool
  idleTimeoutMillis: 30000
});

// In test
const result = await pool.query('SELECT * FROM users WHERE id = $1', [1]);

4. Handle Database Transactions

For tests that need to ensure data consistency:

async function testWithTransaction() {
  const client = await dbClient.connect();
  
  try {
    await client.query('BEGIN');
    
    // Set up test data
    await client.query(
      'INSERT INTO test_table (value) VALUES ($1)',
      ['test_value']
    );
    
    // Run UI test
    const page = await browser.newPage();
    await page.goto('https://example.com');
    // ... test actions
    
    // Commit if test passes
    await client.query('COMMIT');
  } catch (error) {
    // Rollback on failure
    await client.query('ROLLBACK');
    throw error;
  } finally {
    client.release();
  }
}

Handling Test Data and Environment Management

Proper test data management is crucial when working with databases in your Playwright tests.

Environment-Specific Configuration

Create environment-specific configuration files:

// config/database.js
module.exports = {
  development: {
    host: 'localhost',
    port: 5432,
    database: 'testdb_dev',
    user: 'devuser',
    password: 'devpassword'
  },
  test: {
    host: 'localhost',
    port: 5432,
    database: 'testdb_test',
    user: 'testuser',
    password: 'testpassword'
  },
  production: {
    host: 'prod-db.example.com',
    port: 5432,
    database: 'live_db',
    user: 'appuser',
    password: process.env.DB_PASSWORD
  }
};

Using Test Data Factories

Create factories for generating test data:

// factories/userFactory.js
const { nanoid } = require('nanoid');

function createUser(overrides = {}) {
  return {
    username: `user_${nanoid()}`,
    email: `user_${nanoid()}@example.com`,
    password: 'password123',
    is_active: true,
    ...overrides
  };
}

async function createTestUser(dbClient, overrides = {}) {
  const userData = createUser(overrides);
  await dbClient.query(
    'INSERT INTO users (username, email, password, is_active) VALUES ($1, $2, $3, $4)',
    [userData.username, userData.email, userData.password, userData.is_active]
  );
  
  return userData;
}

module.exports = { createTestUser };

Data Cleanup Strategies

Implement proper cleanup to prevent test pollution:

async function cleanupTestData(dbClient) {
  // Clean up test users
  await dbClient.query(`
    DELETE FROM users 
    WHERE username LIKE 'test_%' OR username LIKE 'user_%'
  `);
  
  // Clean up test orders
  await dbClient.query(`
    DELETE FROM orders 
    WHERE reference_id LIKE 'test_%'
  `);
  
  // Clean up test products
  await dbClient.query(`
    DELETE FROM products 
    WHERE name LIKE 'Test Product %'
  `);
}

Advanced Techniques

For more complex testing scenarios, consider these advanced techniques:

Parallel Testing with Database Connections

When running tests in parallel, manage database connections carefully:

const { chromium, defineConfig } = require('@playwright/test');
const { Pool } = require('pg');

const dbPool = new Pool({
  host: 'localhost',
  port: 5432,
  database: 'testdb_parallel',
  user: 'testuser',
  password: 'testpassword',
  max: 20 // Match with test workers
});

module.exports = defineConfig({
  workers: 5,
  use: {
    baseURL: 'https://example.com',
  },
  globalSetup: require('./global-setup'),
});

// global-setup.js
module.exports = async () => {
  // Create test schema
  const client = await dbPool.connect();
  await client.query(`
    CREATE SCHEMA IF NOT EXISTS test_schema;
    SET search_path TO test_schema, public;
  `);
  client.release();
  
  // Return cleanup function
  return async () => {
    // Drop test schema
    const client = await dbPool.connect();
    await client.query('DROP SCHEMA IF EXISTS test_schema CASCADE');
    client.release();
  };
};

Mocking Database Responses

For unit testing components that use database data, consider mocking:

Frequently Asked Questions

Can Playwright directly connect to databases?
No, Playwright doesn't have built-in database connectivity features. You need to integrate external Node.js database libraries like 'pg' for PostgreSQL, 'mysql2' for MySQL, or 'mongodb' for MongoDB.
Why should I use database connections in Playwright tests?
Database connections allow you to verify that data created through the UI is properly stored, test with different data sets, implement data-driven testing, automate data setup/teardown, and validate complex business logic.
How do I manage database connections in Playwright tests?
Use test hooks for connection management, ensure proper initialization and cleanup, consider connection pooling for better performance, and handle database transactions to maintain data consistency.
What databases are supported with Playwright?
Playwright can work with any database through appropriate Node.js libraries including PostgreSQL, MySQL, MongoDB, SQLite, and others. The examples in this guide cover PostgreSQL, MySQL, and MongoDB connections.
How do I handle test data isolation in Playwright database tests?
Create unique test data for each test, use factories for generating test data, implement proper cleanup strategies, and consider using database transactions to ensure data consistency across test runs.

Tuesday, July 21, 2026

Playwright Database Testing Guide