Testing Frameworks

Web Testing Frameworks

Selenium

Best for: Cross-browser testing, legacy applications

Supports multiple languages (Java, Python, JavaScript, C#)
Wide browser support including legacy browsers
Large community and extensive documentation
Steeper learning curve
Slower execution compared to modern frameworks

// Java Selenium example
WebDriver driver = new ChromeDriver();
driver.get("https://example.com");
WebElement element = driver.findElement(By.id("username"));
element.sendKeys("testuser");
driver.quit();

Cypress

Best for: Modern web applications, fast feedback

JavaScript/TypeScript native
Real-time reloads and debugging
Automatic waiting and retries
Network traffic control and stubbing
Excellent developer experience
Limited to JavaScript-based applications

// Cypress example
describe('Login', () => {
  it('should login successfully', () => {
    cy.visit('/login');
    cy.get('#username').type('testuser');
    cy.get('#password').type('password');
    cy.get('#login').click();
    cy.url().should('include', '/dashboard');
  });
});

Playwright

Best for: Modern web applications, cross-browser testing

Multi-language support (JavaScript, Python, Java, .NET)
Fast, reliable, and cross-browser
Auto-waiting for elements
Network interception and mocking
Parallel test execution
Headless and headed execution

// Playwright JavaScript example
const { chromium } = require('playwright');

(async () => {
  const browser = await chromium.launch();
  const page = await browser.newPage();
  await page.goto('https://example.com');
  await page.fill('#username', 'testuser');
  await page.click('#login');
  await browser.close();
})();

Puppeteer

Best for: Chrome/Chromium testing, scraping

Chrome DevTools Protocol integration
Headless browser automation
Fast execution
JavaScript/TypeScript native
Chrome/Chromium only

// Puppeteer example
const puppeteer = require('puppeteer');

(async () => {
  const browser = await puppeteer.launch();
  const page = await browser.newPage();
  await page.goto('https://example.com');
  await page.type('#username', 'testuser');
  await page.click('#login');
  await browser.close();
})();

JavaScript Testing Frameworks

Jest

Best for: React, Node.js, general JavaScript testing

Zero configuration setup
Built-in assertions and mocking
Snapshot testing
Parallel test execution
Code coverage reporting

// Jest example
describe('Calculator', () => {
  test('adds 1 + 2 to equal 3', () => {
    expect(add(1, 2)).toBe(3);
  });
  
  test('async operation', async () => {
    const result = await fetchData();
    expect(result).toEqual({ data: 'test' });
  });
});

Mocha

Best for: Flexible testing needs, Node.js

Flexible and extensible
Async testing support
Rich ecosystem of plugins
Requires assertion library (Chai, Expect)
Requires mocking library (Sinon)

// Mocha example with Chai
const { expect } = require('chai');
const sinon = require('sinon');

describe('UserService', () => {
  it('should return user data', async () => {
    const user = await userService.getUser(1);
    expect(user).to.have.property('id', 1);
  });
});

Vitest

Best for: Vite projects, fast modern testing

Vite-native, extremely fast
Jest-compatible API
ESM support out of the box
TypeScript support
Watch mode with HMR

// Vitest example
import { describe, it, expect } from 'vitest';

describe('Math', () => {
  it('should add numbers', () => {
    expect(add(1, 2)).toBe(3);
  });
});

Jasmine

Best for: Traditional JavaScript testing

Behavior-driven development
No external dependencies
Simple syntax
Good for legacy projects

// Jasmine example
describe('Calculator', () => {
  it('should add numbers', () => {
    const result = add(1, 2);
    expect(result).toBe(3);
  });
});

Python Testing Frameworks

pytest

Best for: Python applications, flexible testing

Simple and intuitive syntax
Powerful fixtures
Plugin ecosystem
Parallel test execution
Code coverage integration

# pytest example
def test_addition():
    assert add(1, 2) == 3

@pytest.fixture
def user_data():
    return {'id': 1, 'name': 'Test User'}

def test_user(user_data):
    assert user_data['name'] == 'Test User'

unittest

Best for: Standard library, traditional testing

Built into Python
xUnit-style testing
Test discovery
Mock library included

# unittest example
import unittest

class TestCalculator(unittest.TestCase):
    def test_addition(self):
        result = add(1, 2)
        self.assertEqual(result, 3)

nose2

Best for: Extending unittest

Extends unittest
Plugin system
Test discovery
Parallel execution

Java Testing Frameworks

JUnit

Best for: Java applications, standard testing

Industry standard
Annotations-based
Test runners
Parameterized tests
Integration with build tools

// JUnit 5 example
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

class CalculatorTest {
    @Test
    void testAddition() {
        assertEquals(3, add(1, 2));
    }
}

TestNG

Best for: Advanced testing needs

More features than JUnit
Parallel execution
Data-driven testing
XML configuration
Integration with Selenium

// TestNG example
import org.testng.annotations.Test;
import static org.testng.Assert.*;

public class CalculatorTest {
    @Test
    public void testAddition() {
        assertEquals(add(1, 2), 3);
    }
}

Mockito

Best for: Mocking in Java

Clean mocking API
Verification of interactions
Stubbing behavior
Integration with JUnit/TestNG

// Mockito example
import static org.mockito.Mockito.*;

List<String> mockList = mock(List.class);
when(mockList.get(0)).thenReturn("first");
assertEquals("first", mockList.get(0));
verify(mockList).get(0);

Mobile Testing Frameworks

Appium

Best for: Cross-platform mobile testing

Supports iOS and Android
Uses WebDriver protocol
Multiple language support
Native, hybrid, and mobile web apps

// Appium Java example
AppiumDriver driver = new AndroidDriver(new URL("http://localhost:4723/wd/hub"), capabilities);
driver.findElement(By.id("username")).sendKeys("testuser");
driver.quit();

Espresso

Best for: Android native testing

Android native
Fast and reliable
Synchronized with UI thread
Google-supported

// Espresso example
onView(withId(R.id.username))
    .perform(typeText("testuser"))
    .check(matches(withText("testuser")));

XCUITest

Best for: iOS native testing

Apple native
Swift/Objective-C
Fast execution
Xcode integration

// XCUITest example
let app = XCUIApplication()
app.textFields["username"].tap()
app.textFields["username"].typeText("testuser")

API Testing Frameworks

Postman

Best for: Manual and automated API testing

User-friendly interface
Collections and environments
Test scripts
CI/CD integration
Mock servers

// Postman test script
pm.test("Status code is 200", function () {
    pm.response.to.have.status(200);
});

pm.test("Response has data", function () {
    var jsonData = pm.response.json();
    pm.expect(jsonData.data).to.exist;
});

REST Assured

Best for: Java API testing

Fluent API
JSON/XML support
Authentication support
Integration with JUnit/TestNG

// REST Assured example
given()
    .header("Content-Type", "application/json")
    .body("{\"name\":\"test\"}")
.when()
    .post("/api/users")
.then()
    .statusCode(201)
    .body("name", equalTo("test"));

Supertest

Best for: Node.js API testing

Express integration
Chai assertions
Easy to use
Good for testing Express apps

// Supertest example
const request = require('supertest');
const app = require('./app');

describe('API', () => {
  it('should create user', async () => {
    const res = await request(app)
      .post('/api/users')
      .send({ name: 'test' })
      .expect(201);
    expect(res.body.name).toBe('test');
  });
});

Framework Selection Guidelines

Web Testing

Modern JavaScript apps: Cypress or Playwright
Cross-browser needs: Playwright or Selenium
Chrome-only: Puppeteer
Legacy apps: Selenium

Unit Testing

JavaScript: Jest or Vitest
Python: pytest
Java: JUnit 5
.NET: xUnit or NUnit

Mobile Testing

Cross-platform: Appium
Android only: Espresso
iOS only: XCUITest

API Testing

Java: REST Assured
Node.js: Supertest
Manual/Exploratory: Postman

test-frameworks