Test Automation Frameworks: Complete Guide

// playwright.config.js
const { defineConfig, devices } = require('@playwright/test');

module.exports = defineConfig({
  testDir: './tests',
  fullyParallel: true,
  forbidOnly: !!process.env.CI,
  retries: process.env.CI ? 2 : 0,
  workers: process.env.CI ? 1 : undefined,
  reporter: 'html',
  
  use: {
    baseURL: 'http://localhost:3000',
    trace: 'on-first-retry',
    screenshot: 'only-on-failure',
    video: 'retain-on-failure',
  },
  
  projects: [
    {
      name: 'chromium',
      use: { ...devices['Desktop Chrome'] },
    },
    {
      name: 'firefox',
      use: { ...devices['Desktop Firefox'] },
    },
    {
      name: 'webkit',
      use: { ...devices['Desktop Safari'] },
    },
    {
      name: 'Mobile Chrome',
      use: { ...devices['Pixel 5'] },
    },
  ],
  
  webServer: {
    command: 'npm run dev',
    url: 'http://localhost:3000',
    reuseExistingServer: !process.env.CI,
  },
});

// pages/LoginPage.js
class LoginPage {
  constructor(page) {
    this.page = page;
    this.usernameInput = page.locator('#username');
    this.passwordInput = page.locator('#password');
    this.loginButton = page.locator('button[type="submit"]');
    this.errorMessage = page.locator('.error-message');
  }

  async navigate() {
    await this.page.goto('/login');
  }

  async login(username, password) {
    await this.usernameInput.fill(username);
    await this.passwordInput.fill(password);
    await this.loginButton.click();
  }

  async loginWithEnter(username, password) {
    await this.usernameInput.fill(username);
    await this.passwordInput.fill(password);
    await this.passwordInput.press('Enter');
  }

  async getErrorMessage() {
    return this.errorMessage.textContent();
  }
}

// tests/login.spec.js
const { test, expect } = require('@playwright/test');
const LoginPage = require('../pages/LoginPage');

test.describe('Login', () => {
  let loginPage;

  test.beforeEach(async ({ page }) => {
    loginPage = new LoginPage(page);
    await loginPage.navigate();
  });

  test('successful login', async ({ page }) => {
    await loginPage.login('[email protected]', 'password123');
    
    await expect(page).toHaveURL('/dashboard');
    await expect(page.locator('.welcome')).toContainText('Welcome');
  });

  test('invalid credentials', async ({ page }) => {
    await loginPage.login('[email protected]', 'wrongpass');
    
    await expect(loginPage.errorMessage).toBeVisible();
    await expect(loginPage.errorMessage).toContainText('Invalid credentials');
  });

  test('empty fields validation', async ({ page }) => {
    await loginPage.loginButton.click();
    
    await expect(page.locator('text=Username is required')).toBeVisible();
  });
});

// tests/api.spec.js
const { test, expect } = require('@playwright/test');

test.describe('API Tests', () => {
  let apiContext;

  test.beforeEach(async ({ request }) => {
    apiContext = request;
  });

  test('GET - fetch users', async ({ request }) => {
    const response = await request.get('https://api.example.com/users');
    
    expect(response.status()).toBe(200);
    const data = await response.json();
    expect(data.users).toHaveLength(10);
  });

  test('POST - create user', async ({ request }) => {
    const newUser = {
      name: 'Test User',
      email: '[email protected]',
      role: 'admin'
    };
    
    const response = await request.post('https://api.example.com/users', {
      data: newUser
    });
    
    expect(response.status()).toBe(201);
    const created = await response.json();
    expect(created.name).toBe('Test User');
    expect(created.id).toBeDefined();
  });

  test('PUT - update user', async ({ request }) => {
    const update = { name: 'Updated Name' };
    
    const response = await request.put('https://api.example.com/users/1', {
      data: update
    });
    
    expect(response.status()).toBe(200);
  });

  test('DELETE - remove user', async ({ request }) => {
    const response = await request.delete('https://api.example.com/users/1');
    expect(response.status()).toBe(204);
  });

  test('authentication', async ({ request }) => {
    const loginResponse = await request.post('https://api.example.com/auth/login', {
      data: { username: 'admin', password: 'secret' }
    });
    
    const { token } = await loginResponse.json();
    
    const protectedRequest = await request.get('https://api.example.com/admin', {
      headers: { Authorization: `Bearer ${token}` }
    });
    
    expect(protectedRequest.status()).toBe(200);
  });
});

// cypress.config.js
const { defineConfig } = require('cypress');

module.exports = defineConfig({
  e2e: {
    baseUrl: 'http://localhost:3000',
    specPattern: 'cypress/e2e/**/*.cy.js',
    supportFile: 'cypress/support/e2e.js',
    
    viewportWidth: 1280,
    viewportHeight: 720,
    
    video: true,
    screenshotOnRunFailure: true,
    
    defaultCommandTimeout: 10000,
    requestTimeout: 15000,
    responseTimeout: 15000,
    
    setupNodeEvents(on, config) {
      // implement node event listeners here
    },
  },
  
  component: {
    devServer: {
      framework: 'react',
      bundler: 'webpack',
    },
  },
});

// cypress/e2e/login.cy.js
describe('Login Flow', () => {
  beforeEach(() => {
    cy.visit('/login');
  });

  it('should login successfully', () => {
    cy.get('[data-testid="username"]').type('[email protected]');
    cy.get('[data-testid="password"]').type('password123');
    cy.get('[data-testid="login-button"]').click();
    
    cy.url().should('include', '/dashboard');
    cy.contains('.welcome', 'Welcome');
  });

  it('should show error for invalid credentials', () => {
    cy.get('[data-testid="username"]').type('[email protected]');
    cy.get('[data-testid="password"]').type('wrongpass');
    cy.get('[data-testid="login-button"]').click();
    
    cy.get('.error-message')
      .should('be.visible')
      .and('contain', 'Invalid credentials');
  });

  it('should handle API errors gracefully', () => {
    cy.intercept('POST', '/api/login', {
      statusCode: 500,
      body: { error: 'Server error' }
    });
    
    cy.get('[data-testid="username"]').type('[email protected]');
    cy.get('[data-testid="password"]').type('password123');
    cy.get('[data-testid="login-button"]').click();
    
    cy.contains('Something went wrong').should('be.visible');
  });
});

// Custom commands
Cypress.Commands.add('login', (username, password) => {
  cy.session([username, password], () => {
    cy.visit('/login');
    cy.get('[data-testid="username"]').type(username);
    cy.get('[data-testid="password"]').type(password);
    cy.get('[data-testid="login-button"]').click();
    cy.url().should('include', '/dashboard');
  });
});

// Usage
it('test with custom login', () => {
  cy.login('[email protected]', 'admin123');
});

import io.restassured.RestAssured.*;
import io.restassured.matcher.RestAssuredMatchers.*;
import io.restassured.specification.RequestSpecification;
import org.junit.jupiter.api.*;

import static io.restassured.RestAssured.*;
import static org.hamcrest.Matchers.*;

public class ApiTest {
    
    @BeforeAll
    public void setup() {
        baseURI = "https://api.example.com";
        basePath = "/v1";
    }
    
    @Test
    public void getUsersTest() {
        given()
            .param("page", 1)
            .param("limit", 10)
        .when()
            .get("/users")
        .then()
            .statusCode(200)
            .body("users", hasSize(10))
            .body("users[0].id", notNullValue())
            .body("users[0].name", notNullValue());
    }
    
    @Test
    public void createUserTest() {
        User newUser = new User("Test User", "[email protected]");
        
        given()
            .contentType("application/json")
            .body(newUser)
        .when()
            .post("/users")
        .then()
            .statusCode(201)
            .body("id", notNullValue())
            .body("name", equalTo("Test User"))
            .body("createdAt", notNullValue());
    }
    
    @Test
    public void updateUserTest() {
        Map<String, Object> updates = Map.of(
            "name", "Updated Name",
            "email", "[email protected]"
        );
        
        given()
            .contentType("application/json")
            .body(updates)
        .when()
            .put("/users/1")
        .then()
            .statusCode(200)
            .body("name", equalTo("Updated Name"));
    }
    
    @Test
    public void deleteUserTest() {
        when()
            .delete("/users/1")
        .then()
            .statusCode(204);
    }
    
    @Test
    public void authenticationTest() {
        // Login and get token
        String token = given()
            .contentType("application/json")
            .body(Map.of("username", "admin", "password", "secret"))
        .when()
            .post("/auth/login")
        .then()
            .statusCode(200)
            .extract()
            .path("token");
        
        // Use token for protected endpoint
        given()
            .header("Authorization", "Bearer " + token)
        .when()
            .get("/admin/dashboard")
        .then()
            .statusCode(200);
    }
}

// test-data/factories.js
class UserFactory {
  static build(overrides = {}) {
    return {
      id: faker.string.uuid(),
      name: faker.person.fullName(),
      email: faker.internet.email(),
      role: 'user',
      createdAt: new Date().toISOString(),
      ...overrides
    };
  }

  static buildMany(count, overrides = {}) {
    return Array.from({ length: count }, () => this.build(overrides));
  }

  static buildAdmin(overrides = {}) {
    return this.build({ role: 'admin', ...overrides });
  }
}

class OrderFactory {
  static build(overrides = {}) {
    return {
      id: faker.string.uuid(),
      userId: faker.string.uuid(),
      items: ItemFactory.buildMany(faker.number.int({ min: 1, max: 5 })),
      total: faker.number.float({ min: 10, max: 1000 }),
      status: 'pending',
      ...overrides
    };
  }
}

// Usage in tests
const user = UserFactory.buildAdmin({ name: 'Custom Name' });
const orders = OrderFactory.buildMany(10, { status: 'completed' });

// fixtures/test-fixtures.js
const testFixtures = {
  user: {
    valid: {
      email: '[email protected]',
      password: 'TestPassword123!',
      name: 'Test User'
    },
    invalid: {
      email: 'invalid-email',
      password: 'short'
    }
  },
  
  products: [
    { id: 1, name: 'Product A', price: 29.99 },
    { id: 2, name: 'Product B', price: 49.99 }
  ]
};

module.exports = testFixtures;

// Usage
const { user } = testFixtures;
// or destructure
const { products } = testFixtures;

# .github/workflows/test.yml
name: Tests

on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    
    strategy:
      matrix:
        containers: [1, 2, 3, 4]
    
    steps:
      - uses: actions/checkout@v4
      
      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'
          cache: 'npm'
      
      - name: Install dependencies
        run: npm ci
      
      - name: Install Playwright browsers
        run: npx playwright install --with-deps
      
      - name: Run tests
        run: npx playwright test --parallel
        env:
          CI: true
      
      - name: Upload artifacts
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: playwright-report-${{ matrix.containers }}
          path: playwright-report/