API Response Body

Ví dụ với Playwright

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

test('Đọc response body', async ({ request }) => {
  const response = await request.get('https://api.example.com/users/1');

  // Kiểm tra status
  expect(response.status()).toBe(200);

  // Đọc body dạng JSON
  const body = await response.json();

  // Verify body data
  expect(body).toHaveProperty('id');
  expect(body).toHaveProperty('name');
  expect(body).toHaveProperty('email');

  console.log('Response body:', body);
});

test('Response không có body', async ({ request }) => {
  const response = await request.delete('https://api.example.com/users/1');

  // 204 No Content - không có body
  expect(response.status()).toBe(204);

  // Body rỗng
  const text = await response.text();
  expect(text).toBe('');
});

Success Response Examples

// 200 OK - GET user
{
  "id": 1,
  "name": "John Doe",
  "email": "john@example.com"
}

// 201 Created - POST new user
{
  "id": 10,
  "name": "New User",
  "email": "newuser@example.com",
  "created_at": "2025-01-15T10:30:00Z"
}

// 202 Accepted - Async job
{
  "job_id": "abc123",
  "status": "processing",
  "check_url": "/api/jobs/abc123"
}

// 204 No Content - DELETE
(empty body)

Test Status Codes với Playwright

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

test('Test various status codes', async ({ request }) => {
  // 200 OK
  const res200 = await request.get('https://api.example.com/users/1');
  expect(res200.status()).toBe(200);
  expect(res200.ok()).toBeTruthy();

  // 201 Created
  const res201 = await request.post('https://api.example.com/users', {
    data: { name: 'New User', email: 'new@example.com' }
  });
  expect(res201.status()).toBe(201);
  const created = await res201.json();
  expect(created).toHaveProperty('id');

  // 204 No Content
  const res204 = await request.delete('https://api.example.com/users/1');
  expect(res204.status()).toBe(204);
  expect(await res204.text()).toBe('');

  // 404 Not Found
  const res404 = await request.get('https://api.example.com/users/99999');
  expect(res404.status()).toBe(404);
  expect(res404.ok()).toBeFalsy();
  const error404 = await res404.json();
  expect(error404).toHaveProperty('error');

  // 422 Validation Error
  const res422 = await request.post('https://api.example.com/users', {
    data: { name: '', email: 'invalid-email' }
  });
  expect(res422.status()).toBe(422);
  const error422 = await res422.json();
  expect(error422.errors).toBeInstanceOf(Array);
});

Basic Parsing

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

test('Parse JSON response', async ({ request }) => {
  const response = await request.get('https://api.example.com/users/1');

  // Parse as JSON
  const user = await response.json();

  expect(user.id).toBe(1);
  expect(user.name).toBeDefined();
});

test('Parse text response', async ({ request }) => {
  const response = await request.get('https://api.example.com/health');

  // Parse as text
  const text = await response.text();

  expect(text).toBe('OK');
});

test('Handle binary response', async ({ request }) => {
  const response = await request.get('https://api.example.com/files/image.png');

  // Get as buffer
  const buffer = await response.body();

  expect(buffer.length).toBeGreaterThan(0);
  // PNG magic bytes
  expect(buffer[0]).toBe(0x89);
  expect(buffer[1]).toBe(0x50);  // 'P'
  expect(buffer[2]).toBe(0x4E);  // 'N'
  expect(buffer[3]).toBe(0x47);  // 'G'
});

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

test('Verify complete response structure', async ({ request }) => {
  const response = await request.get('https://api.example.com/users/1');
  const user = await response.json();

  // Check required fields exist
  expect(user).toHaveProperty('id');
  expect(user).toHaveProperty('name');
  expect(user).toHaveProperty('email');
  expect(user).toHaveProperty('created_at');

  // Check data types
  expect(typeof user.id).toBe('number');
  expect(typeof user.name).toBe('string');
  expect(typeof user.email).toBe('string');

  // Check format
  expect(user.email).toMatch(/^[^\s@]+@[^\s@]+\.[^\s@]+$/);
  expect(user.created_at).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/);

  // Check value ranges
  expect(user.id).toBeGreaterThan(0);
  expect(user.name.length).toBeGreaterThan(0);
});

test('Verify array response', async ({ request }) => {
  const response = await request.get('https://api.example.com/users');
  const result = await response.json();

  // Verify pagination structure
  expect(result).toHaveProperty('data');
  expect(result).toHaveProperty('pagination');

  // Verify data array
  expect(Array.isArray(result.data)).toBeTruthy();

  // Verify each item
  for (const user of result.data) {
    expect(user).toHaveProperty('id');
    expect(user).toHaveProperty('name');
    expect(typeof user.id).toBe('number');
  }

  // Verify pagination
  expect(result.pagination).toMatchObject({
    page: expect.any(Number),
    per_page: expect.any(Number),
    total: expect.any(Number)
  });
});

test('Handle optional fields', async ({ request }) => {
  const response = await request.get('https://api.example.com/users/1');
  const user = await response.json();

  // Required fields
  expect(user.id).toBeDefined();
  expect(user.name).toBeDefined();

  // Optional fields - check if exists before asserting
  if (user.phone) {
    expect(user.phone).toMatch(/^\+?[\d\s-]+$/);
  }

  if (user.address) {
    expect(user.address).toHaveProperty('city');
    expect(user.address).toHaveProperty('country');
  }

  // Or use optional chaining
  expect(user.profile?.bio ?? '').toBeDefined();
});

test('Compare response với expected data', async ({ request }) => {
  // Create user
  const createRes = await request.post('https://api.example.com/users', {
    data: {
      name: 'John Doe',
      email: 'john@example.com'
    }
  });

  const created = await createRes.json();

  // Verify response matches input
  expect(created).toMatchObject({
    name: 'John Doe',
    email: 'john@example.com'
  });

  // Verify server-generated fields
  expect(created.id).toBeDefined();
  expect(created.created_at).toBeDefined();
});

test('Snapshot testing', async ({ request }) => {
  const response = await request.get('https://api.example.com/config');
  const config = await response.json();

  // Compare với snapshot (cần setup)
  expect(config).toMatchSnapshot();
});

test('Extract và reuse data', async ({ request }) => {
  // Step 1: Create user
  const createRes = await request.post('https://api.example.com/users', {
    data: { name: 'Test User', email: 'test@example.com' }
  });
  const { id: userId } = await createRes.json();

  // Step 2: Create order for user
  const orderRes = await request.post('https://api.example.com/orders', {
    data: {
      user_id: userId,  // Reuse userId
      items: [{ product_id: 1, quantity: 2 }]
    }
  });
  const { id: orderId } = await orderRes.json();

  // Step 3: Get order details
  const getRes = await request.get(`https://api.example.com/orders/${orderId}`);
  const order = await getRes.json();

  expect(order.user_id).toBe(userId);
  expect(order.items.length).toBe(1);
});

Complete Error Handling Example

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

async function parseResponse(response) {
  const contentType = response.headers()['content-type'] || '';

  // Empty body check
  const text = await response.text();
  if (!text) {
    return { empty: true, status: response.status() };
  }

  // JSON response
  if (contentType.includes('application/json')) {
    try {
      return JSON.parse(text);
    } catch (e) {
      return { parseError: true, raw: text };
    }
  }

  // Non-JSON response
  return { raw: text, contentType };
}

test('Robust response handling', async ({ request }) => {
  const response = await request.get('https://api.example.com/users/1');
  const result = await parseResponse(response);

  if (result.empty) {
    console.log('Empty response with status:', result.status);
    return;
  }

  if (result.parseError) {
    console.log('Failed to parse JSON:', result.raw);
    return;
  }

  if (result.raw) {
    console.log('Non-JSON response:', result.raw);
    return;
  }

  // Valid JSON response
  expect(result).toHaveProperty('id');
  expect(result).toHaveProperty('name');
});