Welcome to QA Notes

API (Application Programming Interface) is a contract that allows two applications to communicate. It defines the rules for how requests and responses are structured.

• Client sends a request to the server
• Server processes and sends back a response
• REST APIs use HTTP: GET, POST, PUT, DELETE

• GET: Retrieve data (read only, no body)
• POST: Create new data on server
• PUT: Full update of existing data
• PATCH: Partial update of existing data
• DELETE: Remove data from server

• 2xx Success: 200 OK, 201 Created, 204 No Content
• 3xx Redirect: 301 Moved Permanently, 304 Not Modified
• 4xx Client Error: 400 Bad Request, 401 Unauthorized, 403 Forbidden, 404 Not Found, 422 Unprocessable
• 5xx Server Error: 500 Internal Server Error, 503 Service Unavailable

Postman is the most popular GUI tool for API testing.

• Build requests with URL, method, headers, and body
• Write tests using JavaScript in the Tests tab
• Organize requests into Collections
• Use Environment Variables for different environments
• Run collections with Newman (CLI)

• Verify correct status code for valid requests
• Validate response body structure and data types
• Test with invalid / missing data (400 errors)
• Test authentication (401, 403)
• Test boundary values and null inputs
• Verify response time is within acceptable limits

• API Key: Simple token in headers or query params
• Bearer Token / JWT: Most common in modern APIs
• OAuth 2.0: For third-party authorization flows
• Basic Auth: Base64-encoded username:password

Most modern APIs return JSON. Key things to validate:

• Correct data types (string, number, boolean, array)
• Required fields are present
• No extra unexpected fields
• Correct nested structure and array lengths

• Measure response time under normal load
• Stress test with concurrent virtual users
• Tools: JMeter, k6, Gatling, Artillery
• Define SLA thresholds (e.g., <500ms for 95% of requests)

• Test APIs independently from the UI layer
• Use environment variables for base URLs and tokens
• Automate with Newman or CI/CD pipelines
• Include negative and edge case tests
• Validate response schema with tools like Pact or AJV

DevTools are built into Chrome, Firefox, and Edge. Open with F12 or Ctrl+Shift+I.

• Elements: Inspect and modify HTML/CSS live
• Console: View JavaScript errors and run commands
• Network: Monitor all HTTP requests and responses
• Sources: Debug JavaScript with breakpoints
• Application: Inspect cookies, localStorage, cache

• View all HTTP requests made by the page
• Inspect request headers, payload, and response body
• Filter by XHR/Fetch for API calls only
• Check status codes and response times
• Copy as cURL to replay directly in Postman

• Errors appear in red — always check them first
• Warnings appear in yellow — often important hints
• Run JavaScript commands interactively
• Filter by level: Error, Warning, Info, Log

• Right-click any element → Inspect to jump to it
• View and edit HTML structure in real-time
• Modify CSS styles on the fly for visual testing
• Find CSS selectors and data-testid attributes for automation

• View, add, edit, and delete cookies
• Inspect localStorage and sessionStorage values
• Test authentication scenarios by modifying tokens
• Clear all storage to simulate a fresh user session

• Toggle Device Toolbar with Ctrl+Shift+M
• Test on various preset screen sizes (iPhone, iPad, etc.)
• Simulate mobile touch events
• Throttle network speed to simulate slow connections
• Test in portrait and landscape orientations

• Developed by Microsoft — open source
• Supports Chromium, Firefox, and WebKit
• Works with TypeScript, JavaScript, Python, Java, C#
• Auto-waits for elements to be ready (no more sleep!)
• Built-in test runner: @playwright/test

npm init playwright@latest
npx playwright install
npx playwright test

The wizard creates project structure with config, example tests, and browser binaries.

page.getByRole('button', { name: 'Submit' })
page.getByText('Welcome, Arun')
page.getByLabel('Username')
page.getByPlaceholder('Enter email')
page.getByTestId('submit-button')
page.locator('#login-btn')

Prefer role and label locators — they are resilient and accessible.

await page.goto('https://example.com');
await page.getByLabel('Username').fill('admin');
await page.getByLabel('Password').fill('secret');
await page.getByRole('button', { name: 'Login' }).click();
await page.waitForURL('**/dashboard');

await expect(page).toHaveTitle('Dashboard');
await expect(page.getByText('Welcome')).toBeVisible();
await expect(page.getByRole('button')).toBeEnabled();
await expect(page.getByTestId('alert')).toHaveText('Success!');
await expect(page).toHaveURL(/dashboard/);

POM creates a class per page, separating locators and actions from test logic:

class LoginPage {
  constructor(private page: Page) {}
  usernameInput = this.page.getByLabel('Username');
  async login(user: string, pass: string) {
    await this.usernameInput.fill(user);
    await this.page.getByLabel('Password').fill(pass);
    await this.page.getByRole('button',{name:'Login'}).click();
  }
}

test.beforeEach(async ({ page }) => {
  await page.goto('https://example.com/login');
});

test.afterAll(async () => {
  // cleanup after all tests in this file
});

const response = await request.get('/api/users');
expect(response.status()).toBe(200);
const body = await response.json();
expect(body.users).toHaveLength(10);

Configure in playwright.config.ts:

use: {
  screenshot: 'only-on-failure',
  video: 'retain-on-failure',
  trace: 'on-first-retry'
}

View traces: npx playwright show-trace trace.zip

• Tests run headless by default in CI environments
• Integrate with GitHub Actions, Azure DevOps, Jenkins
• Generate HTML reports: npx playwright show-report
• Retry flaky tests with retries: 2 in config
• Parallel execution across workers for speed

• Catch errors at compile time, not at runtime
• Better IntelliSense and autocomplete in VS Code
• Self-documenting code — types explain what parameters mean
• Easier refactoring across large codebases
• Native language for Playwright

const name: string = 'Arun';
const age: number = 30;
const isActive: boolean = true;
const scores: number[] = [95, 87, 92];
const status: 'pass' | 'fail' = 'pass';
let data: string | null = null;

interface User {
  id: number;
  name: string;
  email: string;
  role?: string; // optional field
}

type TestStatus = 'pass' | 'fail' | 'skip';

function login(username: string, password: string): boolean {
  return username === 'admin' && password === 'secret';
}

const fetchUser = async (id: number): Promise<User> => {
  return await api.get(`/users/${id}`);
};

class LoginPage {
  readonly page: Page;
  readonly username: Locator;
  readonly password: Locator;

  constructor(page: Page) {
    this.page = page;
    this.username = page.getByLabel('Username');
    this.password = page.getByLabel('Password');
  }
  async login(u: string, p: string): Promise<void> {
    await this.username.fill(u);
    await this.password.fill(p);
    await this.page.getByRole('button',{name:'Login'}).click();
  }
}

function getFirst<T>(arr: T[]): T {
  return arr[0];
}
// TypeScript infers T = number:
const first = getFirst([1, 2, 3]); // type: number

• Generate test cases from requirements in seconds
• Write Playwright / Postman scripts faster
• Explain errors and suggest fixes
• Create diverse test data and edge cases
• Review and improve bug reports
• Summarize test run results

Good prompts get better results. For QA tasks, be specific about:

• The feature being tested (context)
• The format you want (table, numbered list, code)
• The technology stack (Playwright, Postman, etc.)
• Both positive and negative test scenarios
• Example: "Generate 10 test cases for a login page including positive, negative, and boundary cases. Return as a markdown table."

Example prompt:
"Write test cases for a login form with username and password. Include positive, negative, and boundary tests. Format as a table with columns: ID, Title, Steps, Expected Result."

ChatGPT will generate a comprehensive test suite in seconds.

Claude excels at understanding long context and generating detailed QA artifacts:

• Analyzing requirements documents for testability
• Writing detailed, well-structured bug reports
• Generating complete Playwright test scripts
• Reviewing existing test coverage and suggesting gaps

• Install GitHub Copilot extension in VS Code
• Inline code suggestions as you type test scripts
• Chat with Copilot about your test code
• Auto-complete Page Object methods and assertions
• Generate entire test files from a comment description

Microsoft Copilot is AI assistance integrated across Microsoft products — Teams, Word, Excel, Outlook, and VS Code.

• Powered by large language models and Microsoft's infrastructure
• Context-aware within your apps and documents
• GitHub Copilot specifically for coding tasks in VS Code

• Install the GitHub Copilot extension from VS Code marketplace
• Get inline code suggestions as you type
• Open Copilot Chat panel for QA questions
• Generate complete test files from comment descriptions
• Ask "Explain this test" or "Fix this assertion"

• Summarize long bug discussion threads instantly
• Draft QA status update messages
• Create meeting notes from testing sessions
• Generate action items from test review meetings

Claude (claude.ai) is developed by Anthropic with a focus on being helpful, harmless, and honest. It handles very long documents well.

• Analyze long requirement or specification documents
• Generate comprehensive test plans
• Review and critique existing test strategies
• Write detailed test reports and summaries

Share your requirements document with Claude and ask it to create a comprehensive test plan including scope, approach, test scenarios, risks, and exit criteria.

Claude can process the full document and produce a structured, professional test plan in seconds.

Paste your HTML or describe the UI, then ask Claude to write a Playwright test. Claude understands Playwright's API deeply and writes realistic, working test scripts.

MCP (Model Context Protocol) is an open standard developed by Anthropic for connecting AI assistants to external tools, databases, and APIs in a standardized way.

• Allows AI to interact with real systems (browsers, databases, APIs)
• Standardized protocol — works across different AI models
• Used in Claude, VS Code Copilot, and other AI tools

• Connect AI directly to your test management tools (Jira, TestRail)
• Automate test case creation from requirement tickets
• Link AI to CI/CD pipelines for intelligent failure analysis
• Real-time defect tracking with AI assistance
• Browser automation via Playwright MCP server