//Snippets

import { test, expect } from '@playwright/test';

test('dashboard loads data', async ({ page }) => {
  await page.goto('/dashboard');

  // Wait for the main content to appear
  await expect(page.getByTestId('dashboard-grid')).toBeVisible();

  // Wait for a loading spinner to disappear
  await expect(page.getByTestId('spinner')).toBeHidden({ timeout: 10_000 });

  // Wait for an element and get its text
  const heading = page.getByRole('heading', { level: 1 });
  await expect(heading).toBeVisible();
  await expect(heading).toHaveText('My Dashboard');
});

// Click a button by its accessible name
await page.getByRole('button', { name: 'Submit' }).click();

// Click a link
await page.getByRole('link', { name: 'Sign in' }).click();

// Click a menu item
await page.getByRole('menuitem', { name: 'Delete account' }).click();

// Exact vs partial name match
await page.getByRole('button', { name: 'Save changes', exact: true }).click();

// Click a checkbox
await page.getByRole('checkbox', { name: 'Accept terms' }).check();

// Click inside a specific region
await page
  .getByRole('region', { name: 'Billing details' })
  .getByRole('button', { name: 'Edit' })
  .click();

import { test, expect } from '@playwright/test';

test('fill registration form', async ({ page }) => {
  await page.goto('/register');

  await page.getByLabel('Full name').fill('Alice Smith');
  await page.getByLabel('Email address').fill('alice@example.com');
  await page.getByLabel('Password').fill('SecurePass123!');
  await page.getByLabel('Confirm password').fill('SecurePass123!');

  // Select from a dropdown
  await page.getByLabel('Country').selectOption('GB');

  // Check a checkbox by its label
  await page.getByLabel('I agree to the terms').check();

  await page.getByRole('button', { name: 'Create account' }).click();
  await expect(page).toHaveURL(/\/welcome/);
});

// Exact match
await expect(page.getByTestId('status-badge')).toHaveText('Active');

// Partial match
await expect(page.getByTestId('notification')).toContainText('updated successfully');

// Regex match
await expect(page.getByTestId('invoice-number')).toHaveText(/INV-\d+/);

// Assert text on all matching elements
await expect(page.getByRole('listitem')).toHaveText(['Apple', 'Banana', 'Cherry']);

// Read text into a variable
const price = await page.getByTestId('total-price').textContent();
console.log(price?.trim()); // '£29.99'

import { test, expect } from '@playwright/test';

test('shows users from API', async ({ page }) => {
  // Intercept before navigating
  await page.route('**/api/users', async (route) => {
    await route.fulfill({
      status: 200,
      contentType: 'application/json',
      body: JSON.stringify([
        { id: '1', name: 'Alice', email: 'alice@example.com' },
      ]),
    });
  });

  await page.goto('/users');
  await expect(page.getByText('Alice')).toBeVisible();
});

test('handles server error gracefully', async ({ page }) => {
  await page.route('**/api/users', (route) =>
    route.fulfill({ status: 500, body: 'Internal Server Error' })
  );
  await page.goto('/users');
  await expect(page.getByTestId('error-message')).toBeVisible();
});

import { test, expect } from '@playwright/test';

test('loads products after clicking refresh', async ({ page }) => {
  await page.goto('/products');

  // Wait for a response triggered by an action
  const [response] = await Promise.all([
    page.waitForResponse('**/api/products'),
    page.getByRole('button', { name: 'Refresh' }).click(),
  ]);

  expect(response.status()).toBe(200);
  const data = await response.json();
  expect(data.items).toHaveLength(10);

  // Wait for a response matching a predicate
  const searchResponse = await Promise.all([
    page.waitForResponse((res) => res.url().includes('/search') && res.status() === 200),
    page.getByLabel('Search').fill('widget'),
  ]);

import { test, expect } from '@playwright/test';
import * as path from 'path';

test('upload a document', async ({ page }) => {
  await page.goto('/upload');

  // Upload via a visible file input
  await page.getByLabel('Upload document').setInputFiles(
    path.join(__dirname, 'fixtures/sample.pdf')
  );

  // Upload multiple files
  await page.locator('input[type="file"]').setInputFiles([
    'tests/fixtures/image-1.png',
    'tests/fixtures/image-2.png',
  ]);

  // Clear a file selection
  await page.locator('input[type="file"]').setInputFiles([]);

  await expect(page.getByTestId('upload-status')).toContainText('Ready to upload');
  await page.getByRole('button', { name: 'Submit' }).click();
  await expect(page.getByTestId('success-message')).toBeVisible();
});

// tests/global.setup.ts
import { chromium } from '@playwright/test';

async function globalSetup() {
  const browser = await chromium.launch();
  const context = await browser.newContext();
  const page = await context.newPage();

  await page.goto('/login');
  await page.getByLabel('Email').fill('user@example.com');
  await page.getByLabel('Password').fill('password123');
  await page.getByRole('button', { name: 'Log in' }).click();
  await page.waitForURL('**/dashboard');

  // Save auth state to disk
  await context.storageState({ path: 'tests/.auth/user.json' });
  await browser.close();
}

export default globalSetup;

// playwright.config.ts
// export default defineConfig({
//   globalSetup: './tests/global.setup.ts',
//   use: { storageState: 'tests/.auth/user.json' },
// });

// Exact URL match
await expect(page).toHaveURL('https://app.example.com/dashboard');

// Partial match (contains a substring)
await expect(page).toHaveURL(/\/dashboard/);

// After a form submission redirect
await page.getByRole('button', { name: 'Log in' }).click();
await expect(page).toHaveURL(/.*\/dashboard/, { timeout: 5000 });

// After clicking a link
await page.getByRole('link', { name: 'View profile' }).click();
await expect(page).toHaveURL(/\/users\/[a-z0-9-]+\/profile/);

// Exact count
await expect(page.getByTestId('product-card')).toHaveCount(12);

// No results
await expect(page.getByRole('row', { name: /invoice/ })).toHaveCount(0);

// Count manually
const items = page.getByRole('listitem');
const count = await items.count();
expect(count).toBeGreaterThan(0);

// Assert each item has text
for (let i = 0; i < count; i++) {
  await expect(items.nth(i)).not.toBeEmpty();
}

import { test, expect } from '@playwright/test';

test('opens report in a new tab', async ({ page, context }) => {
  await page.goto('/reports');

  // Wait for new page event triggered by the click
  const [newPage] = await Promise.all([
    context.waitForEvent('page'),
    page.getByRole('link', { name: 'Open report' }).click(),
  ]);

  await newPage.waitForLoadState('domcontentloaded');
  await expect(newPage).toHaveURL(/\/reports\/[0-9]+/);
  await expect(newPage.getByRole('heading', { level: 1 })).toBeVisible();

  await newPage.close();
  // Original page is still open
  await expect(page).toHaveURL(/\/reports/);
});

// Full page screenshot
await page.screenshot({ path: 'screenshots/full-page.png', fullPage: true });

// Viewport screenshot only
await page.screenshot({ path: 'screenshots/viewport.png' });

// Screenshot of a single element
await page.getByTestId('invoice-summary').screenshot({
  path: 'screenshots/invoice-summary.png',
});

// Return as a Buffer (for comparison or upload)
const buffer = await page.screenshot();
console.log('Screenshot size:', buffer.length, 'bytes');

// Screenshot on test failure (configure in playwright.config.ts)
// use: { screenshot: 'only-on-failure' }

import { test, expect } from '@playwright/test';

test('GET /api/users returns 200 and a users array', async ({ request }) => {
  const response = await request.get('/api/users', {
    headers: { Authorization: `Bearer ${process.env.API_TOKEN}` },
  });

  expect(response.status()).toBe(200);

  const body = await response.json();
  expect(body).toHaveProperty('users');
  expect(Array.isArray(body.users)).toBe(true);
  expect(body.users.length).toBeGreaterThan(0);

  // Assert shape of first item
  const [firstUser] = body.users;
  expect(firstUser).toMatchObject({
    id: expect.any(String),
    email: expect.stringContaining('@'),
  });
});

import { test, expect } from '@playwright/test';

test('dashboard displays all key widgets', async ({ page }) => {
  await page.goto('/dashboard');

  // These all run even if some fail
  await expect.soft(page.getByTestId('revenue-widget')).toBeVisible();
  await expect.soft(page.getByTestId('active-users-widget')).toBeVisible();
  await expect.soft(page.getByTestId('orders-widget')).toBeVisible();
  await expect.soft(page.getByTestId('conversion-rate')).toContainText('%');

  // Hard assertion at the end — fails the test if any soft assertion failed
  expect(test.info().errors).toHaveLength(0);
});

// tests/fixtures.ts
import { test as base, expect, type Page } from '@playwright/test';

type Fixtures = {
  authenticatedPage: Page;
};

export const test = base.extend<Fixtures>({
  authenticatedPage: async ({ page }, use) => {
    // Setup: log in before each test
    await page.goto('/login');
    await page.getByLabel('Email').fill('user@example.com');
    await page.getByLabel('Password').fill('password123');
    await page.getByRole('button', { name: 'Log in' }).click();
    await expect(page).toHaveURL(/dashboard/);

    // Hand the logged-in page to the test
    await use(page);

    // Teardown: runs after the test
    await page.evaluate(() => localStorage.clear());
  },
});

export { expect };

// Usage in a spec
// import { test, expect } from './fixtures';
// test('can view profile', async ({ authenticatedPage }) => { ... });

import { test, expect } from '@playwright/test';

test('landing page matches baseline', async ({ page }) => {
  await page.goto('/');
  await page.waitForLoadState('networkidle');

  // First run creates the snapshot; subsequent runs compare
  await expect(page).toHaveScreenshot('landing-page.png', {
    maxDiffPixelRatio: 0.02, // Allow up to 2% pixel difference
  });
});

test('card component matches baseline', async ({ page }) => {
  await page.goto('/components/card');
  await expect(page.getByTestId('feature-card')).toHaveScreenshot(
    'feature-card.png',
    { threshold: 0.1 }
  );
});

// Update snapshots: npx playwright test --update-snapshots

// Single element text
const heading = await page.getByRole('heading', { level: 1 }).textContent();
console.log(heading?.trim()); // 'Welcome to Dashboard'

// innerText (respects CSS visibility, normalises whitespace)
const price = await page.getByTestId('total-price').innerText();
console.log(price); // '£29.99'

// All matching element texts as an array
const labels = await page.getByRole('listitem').allTextContents();
console.log(labels); // ['Item 1', 'Item 2', 'Item 3']

// Assert after reading
const badge = await page.getByTestId('status').textContent();
expect(badge?.trim()).toBe('Active');

import { test, expect } from '@playwright/test';

test('edit item from hover menu', async ({ page }) => {
  await page.goto('/items');

  const row = page.getByTestId('item-row').first();

  // Hover to reveal the action buttons
  await row.hover();

  // Now click the Edit button that appeared on hover
  await page.getByTestId('row-action-edit').click();

  await expect(page.getByRole('dialog', { name: 'Edit item' })).toBeVisible();

  // Hover over a nav item to reveal a dropdown
  await page.getByRole('link', { name: 'Products' }).hover();
  await page.getByRole('menuitem', { name: 'All categories' }).click();
});

// playwright.config.ts
import { defineConfig, devices } from '@playwright/test';

export default defineConfig({
  testDir: './tests',
  fullyParallel: true,
  retries: process.env.CI ? 2 : 0,
  reporter: [['html', { open: 'never' }]],

  use: {
    baseURL: 'http://localhost:3000',
    trace: 'on-first-retry',
    screenshot: 'only-on-failure',
  },

  projects: [
    { name: 'Desktop Chrome', use: { ...devices['Desktop Chrome'] } },
    { name: 'Desktop Firefox', use: { ...devices['Desktop Firefox'] } },
    { name: 'Mobile Safari',  use: { ...devices['iPhone 14'] } },
    { name: 'Tablet',         use: { viewport: { width: 768, height: 1024 } } },
  ],
});

import { test, expect } from '@playwright/test';

test('page loads without console errors', async ({ page }) => {
  const errors: string[] = [];

  page.on('console', (msg) => {
    if (msg.type() === 'error') errors.push(msg.text());
  });

  page.on('pageerror', (err) => {
    errors.push(`Uncaught: ${err.message}`);
  });

  await page.goto('/dashboard');
  await page.getByRole('button', { name: 'Load data' }).click();
  await page.waitForLoadState('networkidle');

  expect(errors, `Console errors: ${errors.join(', ')}`).toHaveLength(0);
});

import { test, expect } from '@playwright/test';

const BLOCKED_DOMAINS = [
  'google-analytics.com',
  'googletagmanager.com',
  'doubleclick.net',
  'facebook.net',
  'hotjar.com',
  'segment.io',
];

test('checkout page loads without trackers', async ({ page }) => {
  await page.route('**/*', (route) => {
    const url = route.request().url();
    const isBlocked = BLOCKED_DOMAINS.some((d) => url.includes(d));
    if (isBlocked) {
      route.abort();
    } else {
      route.continue();
    }
  });

  await page.goto('/checkout');
  await expect(page.getByRole('heading', { name: 'Checkout' })).toBeVisible();
});

import { test, expect } from '@playwright/test';
import AxeBuilder from '@axe-core/playwright';

test('homepage has no critical accessibility violations', async ({ page }) => {
  await page.goto('/');

  const results = await new AxeBuilder({ page })
    .withTags(['wcag2a', 'wcag2aa']) // WCAG 2.1 AA
    .exclude('#legacy-widget')       // opt-out known third-party element
    .analyze();

  // Format violations for a readable failure message
  const violations = results.violations.map((v) => ({
    id: v.id,
    impact: v.impact,
    description: v.description,
    nodes: v.nodes.length,
  }));

  expect(violations, JSON.stringify(violations, null, 2)).toHaveLength(0);
});

import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.chrome.ChromeOptions;

public class BrowserFactory {
    public static WebDriver createChromeDriver() {
        ChromeOptions options = new ChromeOptions();
        options.addArguments("--disable-notifications");
        options.addArguments("--disable-popup-blocking");
        options.addArguments("--window-size=1280,720");
        // Uncomment for headless runs in CI
        // options.addArguments("--headless=new");
        // options.addArguments("--no-sandbox");
        // options.addArguments("--disable-dev-shm-usage");
        return new ChromeDriver(options);
    }
}

from selenium import webdriver
from selenium.webdriver.chrome.options import Options

def create_driver() -> webdriver.Chrome:
    options = Options()
    options.add_argument('--disable-notifications')
    options.add_argument('--window-size=1280,720')
    # Uncomment for headless CI runs
    # options.add_argument('--headless=new')
    # options.add_argument('--no-sandbox')
    # options.add_argument('--disable-dev-shm-usage')
    driver = webdriver.Chrome(options=options)
    driver.implicitly_wait(10)  # seconds
    return driver

# Usage with pytest
import pytest

@pytest.fixture
def driver():
    d = create_driver()
    yield d
    d.quit()

import org.openqa.selenium.By;
import org.openqa.selenium.WebElement;

// CSS selector — preferred for most cases
WebElement submitBtn = driver.findElement(By.cssSelector("[data-testid='submit-btn']"));
submitBtn.click();

// By ID
WebElement email = driver.findElement(By.id("email-input"));
email.sendKeys("user@example.com");

// By class name
WebElement card = driver.findElement(By.className("product-card"));

// XPath — use when CSS can't target by text
WebElement link = driver.findElement(By.xpath("//a[contains(text(),'Sign in')]"));
WebElement cell = driver.findElement(By.xpath("//td[text()='Active']/following-sibling::td"));

import java.util.List;
import org.openqa.selenium.By;
import org.openqa.selenium.WebElement;

// Get all table rows
List<WebElement> rows = driver.findElements(By.cssSelector("table tbody tr"));
System.out.println("Row count: " + rows.size());

// Assert count (using TestNG or JUnit)
assertEquals(10, rows.size());

// Read all cell values from column 0
for (WebElement row : rows) {
    String name = row.findElement(By.cssSelector("td:first-child")).getText();
    System.out.println(name);
}

// Find a row containing specific text
WebElement targetRow = rows.stream()
    .filter(r -> r.getText().contains("alice@example.com"))
    .findFirst()
    .orElseThrow();

import org.openqa.selenium.By;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;
import java.time.Duration;

WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));

// Wait until element is clickable
WebElement button = wait.until(
    ExpectedConditions.elementToBeClickable(By.cssSelector("[data-testid='submit']"))
);
button.click();

// Wait for URL to include a path segment
wait.until(ExpectedConditions.urlContains("/dashboard"));

// Wait for text to appear
wait.until(ExpectedConditions.textToBePresentInElementLocated(
    By.id("status-message"), "Saved successfully"
));

// Wait for element to disappear
wait.until(ExpectedConditions.invisibilityOfElementLocated(
    By.cssSelector(".loading-spinner")
));

from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

wait = WebDriverWait(driver, timeout=10)

# Wait until element is clickable
button = wait.until(EC.element_to_be_clickable((By.CSS_SELECTOR, "[data-testid='submit']")))
button.click()

# Wait for URL
wait.until(EC.url_contains('/dashboard'))

# Wait for text to appear
wait.until(EC.text_to_be_present_in_element((By.ID, 'status'), 'Saved'))

# Wait for element to disappear
wait.until(EC.invisibility_of_element_located((By.CSS_SELECTOR, '.spinner')))

# Wait for element to be present in DOM
element = wait.until(EC.presence_of_element_located((By.ID, 'results-container')))

import org.openqa.selenium.By;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.interactions.Actions;

Actions actions = new Actions(driver);

// Hover to reveal a dropdown menu
WebElement navMenu = driver.findElement(By.cssSelector("[data-testid='products-menu']"));
actions.moveToElement(navMenu).perform();

// Hover then click a revealed sub-item
WebElement subItem = driver.findElement(By.cssSelector("[data-testid='submenu-electronics']"));
actions.moveToElement(navMenu)
       .moveToElement(subItem)
       .click()
       .perform();

// Hover to reveal tooltip
WebElement icon = driver.findElement(By.cssSelector("[data-testid='info-icon']"));
actions.moveToElement(icon).perform();
WebElement tooltip = driver.findElement(By.cssSelector("[role='tooltip']"));
assertTrue(tooltip.isDisplayed());

from selenium.webdriver.common.action_chains import ActionChains
from selenium.webdriver.common.by import By

source = driver.find_element(By.CSS_SELECTOR, "[data-testid='drag-item']")
target = driver.find_element(By.CSS_SELECTOR, "[data-testid='drop-zone']")

# Simple drag and drop
ActionChains(driver).drag_and_drop(source, target).perform()

# Step-by-step for more control
ActionChains(driver) \
    .click_and_hold(source) \
    .move_to_element(target) \
    .release() \
    .perform()

# Drag to an offset (x, y pixels from element)
ActionChains(driver) \
    .drag_and_drop_by_offset(source, 200, 0) \
    .perform()

import org.openqa.selenium.By;
import org.openqa.selenium.support.ui.Select;

Select dropdown = new Select(driver.findElement(By.id("country-select")));

// Select by visible text
dropdown.selectByVisibleText("United Kingdom");

// Select by value attribute
dropdown.selectByValue("gb");

// Select by index (0-based)
dropdown.selectByIndex(2);

// Read the selected value
String selected = dropdown.getFirstSelectedOption().getText();
System.out.println("Selected: " + selected);

// Multi-select: get all selected options
List<WebElement> selectedOptions = dropdown.getAllSelectedOptions();
assertEquals(1, selectedOptions.size());

import org.openqa.selenium.By;
import org.openqa.selenium.WebElement;

// Switch into the iframe by element
WebElement frame = driver.findElement(By.cssSelector("iframe[data-testid='payment-frame']"));
driver.switchTo().frame(frame);

// Interact with elements inside the iframe
driver.findElement(By.id("card-number")).sendKeys("4111111111111111");
driver.findElement(By.id("card-expiry")).sendKeys("12/26");
driver.findElement(By.id("card-cvc")).sendKeys("123");

// Switch back to the main document
driver.switchTo().defaultContent();

// Back in the main page
driver.findElement(By.cssSelector("[data-testid='place-order-btn']")).click();

// Save the original window handle
String originalWindow = driver.getWindowHandle();

// Click a link that opens a new window/tab
driver.findElement(By.cssSelector("[data-testid='open-report-link']")).click();

// Wait for the new window and switch to it
for (String handle : driver.getWindowHandles()) {
    if (!handle.equals(originalWindow)) {
        driver.switchTo().window(handle);
        break;
    }
}

// Interact with the new window
assertTrue(driver.getTitle().contains("Report"));

// Close the new window and switch back
driver.close();
driver.switchTo().window(originalWindow);
assertTrue(driver.getTitle().contains("Dashboard"));

import org.openqa.selenium.OutputType;
import org.openqa.selenium.TakesScreenshot;
import org.openqa.selenium.WebElement;
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;

// Full page screenshot
byte[] screenshot = ((TakesScreenshot) driver).getScreenshotAs(OutputType.BYTES);
Files.write(Paths.get("screenshots/failure.png"), screenshot);

// Element-level screenshot (Selenium 4+)
WebElement card = driver.findElement(By.cssSelector("[data-testid='summary-card']"));
File elementShot = card.getScreenshotAs(OutputType.FILE);
Files.copy(elementShot.toPath(), Paths.get("screenshots/summary-card.png"));

// BasePage.java
import org.openqa.selenium.*;
import org.openqa.selenium.support.ui.*;
import java.time.Duration;

public abstract class BasePage {
    protected final WebDriver driver;
    protected final WebDriverWait wait;

    protected BasePage(WebDriver driver) {
        this.driver = driver;
        this.wait = new WebDriverWait(driver, Duration.ofSeconds(10));
    }

    protected WebElement waitForClickable(By locator) {
        return wait.until(ExpectedConditions.elementToBeClickable(locator));
    }
}

// LoginPage.java
public class LoginPage extends BasePage {
    private final By emailField   = By.cssSelector("[data-testid='email']");
    private final By passwordField = By.cssSelector("[data-testid='password']");
    private final By submitButton  = By.cssSelector("[data-testid='submit']");
    private final By errorMessage  = By.cssSelector("[data-testid='error-msg']");

    public LoginPage(WebDriver driver) {
        super(driver);
        driver.get("/login");
    }

    public DashboardPage loginAs(String email, String password) {
        waitForClickable(emailField).sendKeys(email);
        driver.findElement(passwordField).sendKeys(password);
        waitForClickable(submitButton).click();
        return new DashboardPage(driver);
    }

    public String getErrorMessage() {
        return wait.until(ExpectedConditions.visibilityOfElementLocated(errorMessage)).getText();
    }
}

from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

def test_dashboard_assertions(driver):
    driver.get('https://app.example.com/dashboard')
    wait = WebDriverWait(driver, 10)

    # Element is visible
    header = wait.until(EC.visibility_of_element_located((By.TAG_NAME, 'h1')))
    assert header.is_displayed()

    # Text content
    assert header.text == 'Dashboard'

    # Attribute value
    logo = driver.find_element(By.CSS_SELECTOR, 'img.logo')
    assert 'qa-codes' in logo.get_attribute('alt')

    # Element count
    cards = driver.find_elements(By.CSS_SELECTOR, '[data-testid="stat-card"]')
    assert len(cards) == 4

    # URL check
    assert '/dashboard' in driver.current_url

    # Element NOT present
    error_els = driver.find_elements(By.CSS_SELECTOR, '.error-banner')
    assert len(error_els) == 0, 'Unexpected error banner visible'

cy.request({
  method: 'GET',
  url: '/api/users',
  headers: { Authorization: `Bearer ${Cypress.env('apiToken')}` },
}).then((response) => {
  expect(response.status).to.equal(200);
  expect(response.headers['content-type']).to.include('application/json');
  expect(response.body).to.have.property('users');
  expect(response.body.users).to.be.an('array').with.length.greaterThan(0);

  const firstUser = response.body.users[0];
  expect(firstUser).to.include.keys('id', 'email', 'role');
  expect(firstUser.email).to.match(/.+@.+\..+/);
});

cy.request({
  method: 'POST',
  url: '/api/products',
  headers: { Authorization: `Bearer ${Cypress.env('apiToken')}` },
  body: {
    name: 'Widget Pro',
    price: 29.99,
    sku: 'WGT-001',
    inStock: true,
  },
}).then((response) => {
  expect(response.status).to.equal(201);
  expect(response.body.id).to.be.a('string');
  expect(response.body.name).to.equal('Widget Pro');
  expect(response.body.price).to.equal(29.99);

  // Store the created ID for later test steps
  cy.wrap(response.body.id).as('newProductId');
});

import { test, expect } from '@playwright/test';

test('POST /api/products creates a product', async ({ request }) => {
  const response = await request.post('/api/products', {
    data: {
      name: 'Widget Pro',
      price: 29.99,
      sku: 'WGT-001',
    },
    headers: { Authorization: `Bearer ${process.env.API_TOKEN}` },
  });

  expect(response.status()).toBe(201);

  const product = await response.json();
  expect(product.id).toBeTruthy();
  expect(product.name).toBe('Widget Pro');
  expect(product.price).toBe(29.99);

  // Clean up: delete the created resource
  await request.delete(`/api/products/${product.id}`, {
    headers: { Authorization: `Bearer ${process.env.API_TOKEN}` },
  });
});

import { test, expect } from '@playwright/test';

test('CRUD lifecycle for a user', async ({ request }) => {
  const headers = { Authorization: `Bearer ${process.env.API_TOKEN}` };
  const email = `test+${Date.now()}@example.com`;

  // Create
  const created = await request.post('/api/users', {
    data: { name: 'Test User', email, role: 'viewer' },
    headers,
  });
  expect(created.status()).toBe(201);
  const { id } = await created.json();

  // Read
  const fetched = await request.get(`/api/users/${id}`, { headers });
  expect(fetched.status()).toBe(200);
  expect((await fetched.json()).email).toBe(email);

  // Update
  const updated = await request.patch(`/api/users/${id}`, {
    data: { role: 'admin' },
    headers,
  });
  expect(updated.status()).toBe(200);
  expect((await updated.json()).role).toBe('admin');

  // Delete
  const deleted = await request.delete(`/api/users/${id}`, { headers });
  expect(deleted.status()).toBe(204);

  // Verify gone
  const gone = await request.get(`/api/users/${id}`, { headers });
  expect(gone.status()).toBe(404);
});

import { test, expect } from '@playwright/test';

test('auth flow: login then access /me', async ({ request }) => {
  // Step 1: get a token
  const loginRes = await request.post('/api/auth/login', {
    data: { email: 'user@example.com', password: 'password123' },
  });
  expect(loginRes.status()).toBe(200);
  const { token } = await loginRes.json();
  expect(token).toBeTruthy();

  // Step 2: call a protected endpoint
  const meRes = await request.get('/api/me', {
    headers: { Authorization: `Bearer ${token}` },
  });
  expect(meRes.status()).toBe(200);
  const me = await meRes.json();
  expect(me.email).toBe('user@example.com');

  // Step 3: verify expired token is rejected
  const expiredRes = await request.get('/api/me', {
    headers: { Authorization: 'Bearer expired.token.here' },
  });
  expect(expiredRes.status()).toBe(401);
});

import { z } from 'zod';
import { test, expect } from '@playwright/test';

const UserSchema = z.object({
  id: z.string().uuid(),
  name: z.string().min(1),
  email: z.string().email(),
  role: z.enum(['admin', 'viewer', 'editor']),
  createdAt: z.string().datetime(),
});

const UsersResponseSchema = z.object({
  users: z.array(UserSchema),
  total: z.number().int().nonneg(),
  page: z.number().int().positive(),
});

test('GET /api/users response matches schema', async ({ request }) => {
  const res = await request.get('/api/users');
  expect(res.status()).toBe(200);

  const body = await res.json();
  const result = UsersResponseSchema.safeParse(body);
  expect(
    result.success,
    `Schema mismatch: ${JSON.stringify(result.error?.issues)}`
  ).toBe(true);
});

import { test, expect } from '@playwright/test';
import * as fs from 'fs';
import * as path from 'path';

test('upload CSV file via API', async ({ request }) => {
  const fileBuffer = fs.readFileSync(
    path.resolve(__dirname, 'fixtures/test-data.csv')
  );

  const response = await request.post('/api/imports', {
    multipart: {
      file: {
        name: 'test-data.csv',
        mimeType: 'text/csv',
        buffer: fileBuffer,
      },
      type: 'users',
      dryRun: 'false',
    },
    headers: { Authorization: `Bearer ${process.env.API_TOKEN}` },
  });

  expect(response.status()).toBe(202);
  const { jobId } = await response.json();
  expect(jobId).toBeTruthy();
});

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

// GET request with assertions
@Test
public void getUsers_returns200WithUsersList() {
    given()
        .baseUri("https://api.example.com")
        .header("Authorization", "Bearer " + System.getenv("API_TOKEN"))
    .when()
        .get("/api/users")
    .then()
        .statusCode(200)
        .contentType(ContentType.JSON)
        .body("users", not(empty()))
        .body("users[0].email", containsString("@"));
}

// POST request with body
@Test
public void createProduct_returns201WithId() {
    String body = "{\"name\":\"Widget Pro\",\"price\":29.99}";

    given()
        .baseUri("https://api.example.com")
        .header("Authorization", "Bearer " + System.getenv("API_TOKEN"))
        .contentType(ContentType.JSON)
        .body(body)
    .when()
        .post("/api/products")
    .then()
        .statusCode(201)
        .body("id", notNullValue());
}

import { test, expect } from '@playwright/test';

test('GraphQL — query users list', async ({ request }) => {
  const response = await request.post('/graphql', {
    data: {
      query: `
        query GetUsers($limit: Int!) {
          users(limit: $limit) {
            id
            name
            email
            role
          }
        }
      `,
      variables: { limit: 10 },
    },
    headers: {
      'Authorization': `Bearer ${process.env.API_TOKEN}`,
      'Content-Type': 'application/json',
    },
  });

  expect(response.status()).toBe(200);
  const { data, errors } = await response.json();

  expect(errors).toBeUndefined();
  expect(data.users).toHaveLength(10);
  expect(data.users[0]).toMatchObject({
    id: expect.any(String),
    email: expect.stringContaining('@'),
  });
});

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

@Test
public void createOrder_thenFetchById() {
    // Step 1 — create a resource and extract its ID
    String orderId =
        given()
            .baseUri("https://api.example.com")
            .header("Authorization", "Bearer " + System.getenv("API_TOKEN"))
            .contentType("application/json")
            .body("{\"product\":\"Widget\",\"qty\":2}")
        .when()
            .post("/api/orders")
        .then()
            .statusCode(201)
            .extract().path("id");  // JsonPath extraction

    // Step 2 — use the extracted value in a follow-up request
    given()
        .baseUri("https://api.example.com")
        .header("Authorization", "Bearer " + System.getenv("API_TOKEN"))
    .when()
        .get("/api/orders/" + orderId)
    .then()
        .statusCode(200)
        .body("id", equalTo(orderId))
        .body("status", equalTo("pending"));
}

// ── Login request — Tests tab ───────────────────────────────────────────────
// POST {{baseUrl}}/auth/login
// Body: { "email": "{{userEmail}}", "password": "{{userPassword}}" }

const res = pm.response.json();

if (pm.response.code === 200 && res.token) {
    pm.collectionVariables.set('authToken', res.token);
    pm.collectionVariables.set('tokenExpiry', Date.now() + 3600 * 1000);
    console.log('Token stored, expires in 1 hour');
} else {
    pm.test('Login succeeded', () => pm.expect(pm.response.code).to.equal(200));
}

// ── Pre-request script on the collection (auto-refresh) ─────────────────────
const expiry = pm.collectionVariables.get('tokenExpiry');
const isExpired = !expiry || Date.now() > Number(expiry);

if (isExpired) {
    pm.sendRequest({
        url: pm.collectionVariables.get('baseUrl') + '/auth/login',
        method: 'POST',
        header: { 'Content-Type': 'application/json' },
        body: {
            mode: 'raw',
            raw: JSON.stringify({
                email: pm.collectionVariables.get('userEmail'),
                password: pm.collectionVariables.get('userPassword'),
            }),
        },
    }, (err, res) => {
        if (!err) pm.collectionVariables.set('authToken', res.json().token);
    });
}

// ── Every authenticated request — Authorization header ──────────────────────
// Type: Bearer Token → Token: {{authToken}}