Query Parameters

Basic Filtering

// Filter by status
GET /api/orders?status=completed

// Filter by category
GET /api/products?category=laptop

// Filter by boolean
GET /api/users?is_active=true&verified=true

Multiple Filters

// Combine multiple conditions (AND)
GET /api/products?category=laptop&brand=dell&in_stock=true

// Price range
GET /api/products?price_min=10000000&price_max=20000000

// Date range
GET /api/orders?date_from=2025-01-01&date_to=2025-01-31

Complex Filtering

// Advanced filters với operators
GET /api/users?age[gte]=18&age[lte]=65
// age >= 18 AND age <= 65

GET /api/products?price[gt]=1000000&rating[gte]=4
// price > 1000000 AND rating >= 4

GET /api/posts?status[in]=published,draft
// status IN ('published', 'draft')

GET /api/users?name[like]=%nguyen%
// name LIKE '%nguyen%'

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

test('Basic filtering', async ({ request }) => {
  const response = await request.get('https://api.example.com/products', {
    params: {
      category: 'laptop',
      brand: 'dell',
      in_stock: true
    }
  });

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

  const products = await response.json();

  // Verify tất cả products đều match filters
  products.forEach(product => {
    expect(product.category).toBe('laptop');
    expect(product.brand).toBe('dell');
    expect(product.in_stock).toBe(true);
  });
});

test('Price range filtering', async ({ request }) => {
  const response = await request.get('https://api.example.com/products', {
    params: {
      price_min: 10000000,
      price_max: 20000000
    }
  });

  const products = await response.json();

  // Verify tất cả products trong price range
  products.forEach(product => {
    expect(product.price).toBeGreaterThanOrEqual(10000000);
    expect(product.price).toBeLessThanOrEqual(20000000);
  });
});

test('Date range filtering', async ({ request }) => {
  const response = await request.get('https://api.example.com/orders', {
    params: {
      date_from: '2025-01-01',
      date_to: '2025-01-31',
      status: 'completed'
    }
  });

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

  const orders = await response.json();
  expect(orders).toBeInstanceOf(Array);
});

Basic Sorting

// Sort by name (ascending - mặc định)
GET /api/users?sort=name

// Sort by created date (descending)
GET /api/posts?sort=-created_at
// Dấu "-" = descending

// Sort by multiple fields
GET /api/products?sort=category,price
// Sort by category first, then by price

Explicit Order Direction

// Style 1: Separate order parameter
GET /api/users?sort=name&order=asc
GET /api/users?sort=created_at&order=desc

// Style 2: orderBy và direction
GET /api/products?orderBy=price&direction=asc

// Style 3: sort object
GET /api/posts?sort[field]=created_at&sort[order]=desc

Multiple Sort Fields

// Comma-separated
GET /api/products?sort=category,-price,name
// Sort by: category ASC, price DESC, name ASC

// Array style
GET /api/users?sort[]=created_at:desc&sort[]=name:asc

// Object style
GET /api/posts?sort[0][field]=published_at&sort[0][order]=desc&sort[1][field]=title&sort[1][order]=asc

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

test('Basic sorting - ascending', async ({ request }) => {
  const response = await request.get('https://api.example.com/users', {
    params: {
      sort: 'name',
      order: 'asc'
    }
  });

  const users = await response.json();

  // Verify sorted correctly
  for (let i = 0; i < users.length - 1; i++) {
    expect(users[i].name <= users[i + 1].name).toBeTruthy();
  }
});

test('Sorting - descending by date', async ({ request }) => {
  const response = await request.get('https://api.example.com/posts', {
    params: {
      sort: 'created_at',
      order: 'desc'
    }
  });

  const posts = await response.json();

  // Verify newest first
  for (let i = 0; i < posts.length - 1; i++) {
    const date1 = new Date(posts[i].created_at);
    const date2 = new Date(posts[i + 1].created_at);
    expect(date1 >= date2).toBeTruthy();
  }
});

test('Multiple sort fields', async ({ request }) => {
  const response = await request.get('https://api.example.com/products', {
    params: {
      sort: 'category,-price'
      // Sort by category ASC, then price DESC
    }
  });

  const products = await response.json();
  expect(products.length).toBeGreaterThan(0);
});

test('Combine filter and sort', async ({ request }) => {
  const response = await request.get('https://api.example.com/products', {
    params: {
      category: 'laptop',
      in_stock: true,
      sort: 'price',
      order: 'asc'
    }
  });

  const products = await response.json();

  // Verify filtered
  products.forEach(p => {
    expect(p.category).toBe('laptop');
    expect(p.in_stock).toBe(true);
  });

  // Verify sorted
  for (let i = 0; i < products.length - 1; i++) {
    expect(products[i].price <= products[i + 1].price).toBeTruthy();
  }
});

Page-based Pagination

// Page và limit
GET /api/users?page=1&limit=20
GET /api/users?page=2&limit=20

// Page và per_page (Rails style)
GET /api/posts?page=3&per_page=50

// Page bắt đầu từ 0
GET /api/products?page=0&size=25

Offset-based Pagination

// Offset và limit
GET /api/users?offset=0&limit=20   // Records 1-20
GET /api/users?offset=20&limit=20  // Records 21-40
GET /api/users?offset=40&limit=20  // Records 41-60

// Skip và take
GET /api/products?skip=0&take=50

Cursor-based Pagination

// First page
GET /api/posts?limit=20

// Response includes cursor
{
  "data": [...],
  "next_cursor": "eyJpZCI6MTAwfQ=="
}

// Next page
GET /api/posts?limit=20&cursor=eyJpZCI6MTAwfQ==

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

test('Page-based pagination', async ({ request }) => {
  const limit = 20;

  // Page 1
  const page1 = await request.get('https://api.example.com/users', {
    params: { page: 1, limit }
  });
  const data1 = await page1.json();

  expect(data1.data.length).toBeLessThanOrEqual(limit);
  expect(data1.page).toBe(1);
  expect(data1.total).toBeGreaterThan(0);

  // Page 2
  const page2 = await request.get('https://api.example.com/users', {
    params: { page: 2, limit }
  });
  const data2 = await page2.json();

  // Verify khác nhau
  expect(data1.data[0].id).not.toBe(data2.data[0].id);
});

test('Offset-based pagination', async ({ request }) => {
  const limit = 10;

  // Get first 10
  const response1 = await request.get('https://api.example.com/products', {
    params: { offset: 0, limit }
  });
  const data1 = await response1.json();

  // Get next 10
  const response2 = await request.get('https://api.example.com/products', {
    params: { offset: 10, limit }
  });
  const data2 = await response2.json();

  expect(data1.length).toBe(limit);
  expect(data2.length).toBe(limit);

  // Verify không overlap
  expect(data1[data1.length - 1].id).not.toBe(data2[0].id);
});

test('Load all pages', async ({ request }) => {
  const limit = 20;
  let page = 1;
  let allUsers = [];

  while (true) {
    const response = await request.get('https://api.example.com/users', {
      params: { page, limit }
    });

    const data = await response.json();
    allUsers = allUsers.concat(data.data);

    console.log(`Loaded page ${page}, total users: ${allUsers.length}`);

    // Nếu không còn data hoặc đã đến trang cuối
    if (data.data.length < limit || !data.has_more) {
      break;
    }

    page++;
  }

  console.log(`Total users loaded: ${allUsers.length}`);
  expect(allUsers.length).toBeGreaterThan(0);
});

Pagination Response Format

// Standard pagination response
{
  "data": [...],
  "pagination": {
    "page": 2,
    "limit": 20,
    "total": 157,
    "total_pages": 8,
    "has_next": true,
    "has_prev": true
  }
}

// With links
{
  "data": [...],
  "links": {
    "first": "/api/users?page=1&limit=20",
    "prev": "/api/users?page=1&limit=20",
    "next": "/api/users?page=3&limit=20",
    "last": "/api/users?page=8&limit=20"
  },
  "meta": {
    "current_page": 2,
    "per_page": 20,
    "total": 157
  }
}

Basic Search

// Single query parameter
GET /api/users?q=john
GET /api/products?search=laptop
GET /api/posts?query=api+testing

Search trong fields cụ thể

// Search in specific fields
GET /api/users?search=nguyen&fields=name,email

// Separate parameters cho từng field
GET /api/users?name=nguyen&email=gmail.com

// Advanced search
GET /api/products?name[like]=%laptop%&description[like]=%gaming%

Full-text Search

// Simple full-text
GET /api/posts?q=api+testing+tutorial

// With search mode
GET /api/articles?q=playwright&mode=fulltext

// With relevance
GET /api/search?q=javascript&min_score=0.5

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

test('Basic search', async ({ request }) => {
  const response = await request.get('https://api.example.com/users', {
    params: {
      q: 'nguyen'
    }
  });

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

  const users = await response.json();

  // Verify kết quả chứa search term
  users.forEach(user => {
    const matchesName = user.name.toLowerCase().includes('nguyen');
    const matchesEmail = user.email.toLowerCase().includes('nguyen');
    expect(matchesName || matchesEmail).toBeTruthy();
  });
});

test('Search with filters', async ({ request }) => {
  const response = await request.get('https://api.example.com/products', {
    params: {
      search: 'laptop',
      category: 'electronics',
      price_max: 20000000,
      in_stock: true
    }
  });

  const products = await response.json();

  // Verify search + filters
  products.forEach(product => {
    expect(product.name.toLowerCase()).toContain('laptop');
    expect(product.category).toBe('electronics');
    expect(product.price).toBeLessThanOrEqual(20000000);
    expect(product.in_stock).toBe(true);
  });
});

test('Search with pagination and sorting', async ({ request }) => {
  const response = await request.get('https://api.example.com/posts', {
    params: {
      q: 'api testing',
      page: 1,
      limit: 20,
      sort: 'relevance',  // Hoặc 'created_at', 'title'
      order: 'desc'
    }
  });

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

  const data = await response.json();
  expect(data.results).toBeInstanceOf(Array);
  expect(data.results.length).toBeLessThanOrEqual(20);
});

Search với Special Characters

// Search có spaces
GET /api/posts?q=api+testing
GET /api/posts?q=api%20testing

// Search có quotes
GET /api/search?q="exact phrase"
GET /api/search?q=%22exact%20phrase%22

// Search có special characters
GET /api/users?email=user%40example.com  // @ được encode
GET /api/search?q=C%23+programming       // # được encode

Select specific fields

// Only return id, name, email
GET /api/users?fields=id,name,email

// Exclude password and token
GET /api/users?exclude=password,token

// Include related data
GET /api/posts?include=author,comments

Nested field selection

// Select fields from related objects
GET /api/posts?fields=title,content&include=author&author_fields=name,email

// Sparse fieldsets (JSON:API style)
GET /api/articles?fields[articles]=title,body&fields[people]=name

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

test('Select specific fields', async ({ request }) => {
  const response = await request.get('https://api.example.com/users', {
    params: {
      fields: 'id,name,email'
    }
  });

  const users = await response.json();

  // Verify chỉ có fields đã chọn
  users.forEach(user => {
    expect(user).toHaveProperty('id');
    expect(user).toHaveProperty('name');
    expect(user).toHaveProperty('email');

    // Không có fields khác
    expect(user).not.toHaveProperty('password');
    expect(user).not.toHaveProperty('created_at');
  });
});

test('Include related data', async ({ request }) => {
  const response = await request.get('https://api.example.com/posts/1', {
    params: {
      include: 'author,comments'
    }
  });

  const post = await response.json();

  expect(post).toHaveProperty('id');
  expect(post).toHaveProperty('title');
  expect(post).toHaveProperty('author');      // Included
  expect(post).toHaveProperty('comments');    // Included
  expect(post.author).toHaveProperty('name');
  expect(post.comments).toBeInstanceOf(Array);
});

Date Range Parameters

// From and to
GET /api/orders?date_from=2025-01-01&date_to=2025-01-31

// Start and end
GET /api/logs?start_date=2025-01-01&end_date=2025-12-31

// After and before
GET /api/posts?created_after=2025-01-01&created_before=2025-02-01

// Specific field
GET /api/orders?created_at[gte]=2025-01-01&created_at[lte]=2025-01-31

Date Formats

// ISO 8601 date (recommended)
?date=2025-01-15

// ISO 8601 datetime
?created_at=2025-01-15T10:30:00Z

// Unix timestamp
?timestamp=1736935800

// Relative dates
?date=today
?date=yesterday
?date=last_7_days
?date=this_month

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

test('Date range filtering', async ({ request }) => {
  const response = await request.get('https://api.example.com/orders', {
    params: {
      date_from: '2025-01-01',
      date_to: '2025-01-31'
    }
  });

  const orders = await response.json();

  // Verify tất cả orders trong date range
  orders.forEach(order => {
    const orderDate = new Date(order.created_at);
    expect(orderDate >= new Date('2025-01-01')).toBeTruthy();
    expect(orderDate <= new Date('2025-01-31')).toBeTruthy();
  });
});

test('Get last 7 days data', async ({ request }) => {
  const today = new Date();
  const last7Days = new Date();
  last7Days.setDate(today.getDate() - 7);

  const response = await request.get('https://api.example.com/analytics', {
    params: {
      start_date: last7Days.toISOString().split('T')[0],
      end_date: today.toISOString().split('T')[0]
    }
  });

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

test('Filter by datetime with timezone', async ({ request }) => {
  const response = await request.get('https://api.example.com/events', {
    params: {
      start: '2025-01-15T00:00:00Z',
      end: '2025-01-15T23:59:59Z'
    }
  });

  const events = await response.json();
  expect(events).toBeInstanceOf(Array);
});