@keber/qa-framework 1.9.1 → 1.11.3

package/templates/automation-scaffold/fixtures/base.ts

@@ -0,0 +1,108 @@
+/**
+ * fixtures/base.ts
+ *
+ * Playwright test wrapper with TTL-aware session refresh.
+ * Import this file instead of `@playwright/test` when the app uses a
+ * server-side session that may expire during long runs.
+ */
+
+import { test as base, devices } from '@playwright/test';
+import { SESSION_TTL_MS } from '../playwright.config';
+import * as dotenv from 'dotenv';
+import * as fs from 'fs';
+import * as path from 'path';
+
+dotenv.config();
+
+const authTimestamps = new Map<string, number>();
+
+function stateFileForProject(storageState: unknown): string {
+  if (typeof storageState === 'string' && storageState) {
+    return path.resolve(__dirname, '..', storageState);
+  }
+  return path.resolve(__dirname, '../.auth/user-default.json');
+}
+
+function credentialsForState(stateFile: string): { email: string; password: string } {
+  if (stateFile.includes('user-2')) {
+    return {
+      email: process.env.QA_USER2_EMAIL ?? '',
+      password: process.env.QA_USER2_PASSWORD ?? '',
+    };
+  }
+
+  return {
+    email: process.env.QA_USER_EMAIL ?? '',
+    password: process.env.QA_USER_PASSWORD ?? '',
+  };
+}
+
+function lastAuthTime(stateFile: string): number {
+  if (!authTimestamps.has(stateFile)) {
+    try {
+      authTimestamps.set(stateFile, fs.statSync(stateFile).mtimeMs);
+    } catch {
+      authTimestamps.set(stateFile, 0);
+    }
+  }
+  return authTimestamps.get(stateFile) ?? 0;
+}
+
+async function reauth(browser: import('@playwright/test').Browser, stateFile: string): Promise<void> {
+  const { email, password } = credentialsForState(stateFile);
+  const baseURL = process.env.QA_BASE_URL ?? '';
+  const loginPath = process.env.QA_LOGIN_PATH ?? '/login';
+  const emailSelector = process.env.QA_LOGIN_EMAIL_SELECTOR ?? 'input[type="email"]';
+  const passwordSelector = process.env.QA_LOGIN_PASSWORD_SELECTOR ?? 'input[type="password"]';
+  const submitSelector = process.env.QA_LOGIN_SUBMIT_SELECTOR ?? 'button[type="submit"]';
+  const successSelector = process.env.QA_LOGIN_SUCCESS_SELECTOR ?? '.dashboard, .main-content, [data-testid="app-shell"]';
+
+  const context = await browser.newContext({ ...devices['Desktop Chrome'], baseURL });
+  const page = await context.newPage();
+
+  try {
+    await page.goto(loginPath, { waitUntil: 'load', timeout: 60_000 });
+    await page.locator(emailSelector).fill(email);
+    await page.locator(passwordSelector).fill(password);
+    await page.locator(submitSelector).click();
+    await page.waitForSelector(successSelector, { timeout: 30_000 });
+
+    const dir = path.dirname(stateFile);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+
+    await context.storageState({ path: stateFile });
+    authTimestamps.set(stateFile, Date.now());
+    console.log(`[session-refresh] storageState renewed: ${stateFile}`);
+  } finally {
+    await context.close();
+  }
+}
+
+export const test = base.extend<{ authStatePath: string }>({
+  authStatePath: async ({}, use, testInfo) => {
+    await use(stateFileForProject(testInfo.project.use.storageState));
+  },
+
+  context: async ({ browser }, use, testInfo) => {
+    const stateFile = stateFileForProject(testInfo.project.use.storageState);
+    if (Date.now() - lastAuthTime(stateFile) > SESSION_TTL_MS) {
+      await reauth(browser, stateFile).catch((error) => {
+        console.error(`[session-refresh] reauth failed: ${(error as Error).message}`);
+      });
+    }
+
+    const context = await browser.newContext({
+      ...devices['Desktop Chrome'],
+      storageState: stateFile,
+      baseURL: process.env.QA_BASE_URL,
+    });
+
+    await use(context);
+    await context.close();
+  },
+});
+
+export { expect } from '@playwright/test';
+export type { Page, Browser, BrowserContext } from '@playwright/test';

package/templates/automation-scaffold/global-setup.ts

@@ -30,6 +30,74 @@ import * as fs from 'fs';
 
 dotenv.config();
 
+function resolveVar(param: string | undefined, envKey: string, defaultValue: string): [string, string] {
+  if (param !== undefined) {
+    return [param, 'param'];
+  }
+  if (process.env[envKey] !== undefined) {
+    return [process.env[envKey]!, `env:${envKey}`];
+  }
+  return [defaultValue, 'default'];
+}
+
+function resolveAuthUsers(config: FullConfig): Set<'1' | '2'> {
+  const explicit = process.env.QA_AUTH_USER;
+  if (explicit) {
+    const resolved = new Set<'1' | '2'>();
+    for (const token of explicit.split(',').map((value) => value.trim())) {
+      if (token === '1' || token === '2') {
+        resolved.add(token);
+      }
+    }
+    if (resolved.size) {
+      return resolved;
+    }
+  }
+
+  const fromProjects = new Set<'1' | '2'>();
+  for (const project of config.projects) {
+    const storageState = (project.use as { storageState?: unknown } | undefined)?.storageState;
+    if (typeof storageState === 'string') {
+      if (storageState.includes('user-2')) {
+        fromProjects.add('2');
+      } else if (storageState.includes('user-1')) {
+        fromProjects.add('1');
+      }
+    }
+  }
+
+  if (fromProjects.size) {
+    return fromProjects;
+  }
+
+  return new Set(['1']);
+}
+
+async function dismissOnboardingFlow(page: import('@playwright/test').Page): Promise<void> {
+  // Override this with your app's onboarding dismissal logic.
+  // Use QA_DISMISS_ONBOARDING_LABELS (comma-separated button labels) to enable
+  // without modifying this file. Example: QA_DISMISS_ONBOARDING_LABELS=Skip,Got it
+  const raw = process.env.QA_DISMISS_ONBOARDING_LABELS ?? '';
+  const labels = raw.split(',').map((l: string) => l.trim()).filter(Boolean);
+  if (!labels.length) return;
+
+  for (let round = 0; round < 3; round++) {
+    let dismissed = false;
+    for (const label of labels) {
+      const button = page.getByRole('button', { name: label, exact: true }).first();
+      const visible = await button.isVisible({ timeout: 1_000 }).catch(() => false);
+      if (visible) {
+        await button.click({ timeout: 2_000 }).catch(() => {});
+        await page.waitForTimeout(250);
+        dismissed = true;
+      }
+    }
+    if (!dismissed) {
+      break;
+    }
+  }
+}
+
 /** Perform login and persist storageState to disk. */
 async function loginAs(params: {
   email:             string;
@@ -59,11 +127,33 @@ async function loginAs(params: {
   const page    = await context.newPage();
 
   try {
-    await page.goto(`${baseURL}${loginPath}`, { waitUntil: 'domcontentloaded' });
-    await page.locator(emailSelector).fill(email);
-    await page.locator(passwordSelector).fill(password);
-    await page.locator(submitSelector).click();
-    await page.waitForSelector(successSelector, { timeout: 15_000 });
+    const loginUrl = `${baseURL}${loginPath.startsWith('/') ? loginPath : `/${loginPath}`}`;
+    let signedIn = false;
+
+    for (let attempt = 1; attempt <= 3 && !signedIn; attempt++) {
+      await page.goto(loginUrl, { waitUntil: 'load', timeout: 60_000 });
+      await page.locator(emailSelector).fill(email);
+      await page.locator(passwordSelector).fill(password);
+      await page.locator(submitSelector).click();
+
+      const result = await Promise.race([
+        page.waitForSelector(successSelector, { timeout: 30_000 }).then(() => 'ok' as const),
+        page.locator('text=An unhandled error has occurred.').waitFor({ state: 'visible', timeout: 30_000 }).then(() => 'crash' as const),
+      ]).catch(() => 'timeout' as const);
+
+      if (result === 'ok') {
+        signedIn = true;
+      } else if (result === 'crash') {
+        await page.getByText('Reload').click({ timeout: 5_000 }).catch(() => {});
+        await page.waitForTimeout(2_000);
+      }
+    }
+
+    if (!signedIn) {
+      throw new Error('[qa-framework] Login did not reach the success selector after 3 attempts.');
+    }
+
+    await dismissOnboardingFlow(page);
 
     // Ensure .auth/ directory exists
     const dir = path.dirname(stateFile);
@@ -78,29 +168,29 @@ async function loginAs(params: {
 
 export default async function globalSetup(_config: FullConfig): Promise<void> {
   const baseURL  = process.env.QA_BASE_URL!;
-  const email    = process.env.QA_USER_EMAIL!;
-  const password = process.env.QA_USER_PASSWORD!;
+  const authUsers = resolveAuthUsers(_config);
 
-  // --- Default role login ---
-  await loginAs({
-    email,
-    password,
-    baseURL,
-    stateFile: '.auth/user-default.json',
-  });
-
-  // --- Additional roles (uncomment and adapt as needed) ---
-  // await loginAs({
-  //   email:     process.env.QA_ADMIN_EMAIL!,
-  //   password:  process.env.QA_ADMIN_PASSWORD!,
-  //   baseURL,
-  //   stateFile: '.auth/user-admin.json',
-  // });
-  //
-  // await loginAs({
-  //   email:     process.env.QA_READONLY_EMAIL!,
-  //   password:  process.env.QA_READONLY_PASSWORD!,
-  //   baseURL,
-  //   stateFile: '.auth/user-readonly.json',
-  // });
+  if (authUsers.has('1')) {
+    const [email, emailSource] = resolveVar(process.env.QA_USER_EMAIL, 'QA_USER_EMAIL', 'qa-user@example.com');
+    const [password, passwordSource] = resolveVar(process.env.QA_USER_PASSWORD, 'QA_USER_PASSWORD', 'CHANGE_ME');
+    console.log(`[global-setup] user-1 credentials from ${emailSource} / ${passwordSource}`);
+    await loginAs({
+      email,
+      password,
+      baseURL,
+      stateFile: '.auth/user-default.json',
+    });
+  }
+
+  if (authUsers.has('2') && process.env.QA_USER2_EMAIL && process.env.QA_USER2_PASSWORD) {
+    const [email, emailSource] = resolveVar(process.env.QA_USER2_EMAIL, 'QA_USER2_EMAIL', 'qa-user2@example.com');
+    const [password, passwordSource] = resolveVar(process.env.QA_USER2_PASSWORD, 'QA_USER2_PASSWORD', 'CHANGE_ME');
+    console.log(`[global-setup] user-2 credentials from ${emailSource} / ${passwordSource}`);
+    await loginAs({
+      email,
+      password,
+      baseURL,
+      stateFile: '.auth/user-2.json',
+    });
+  }
 }

package/templates/automation-scaffold/playwright.config.ts

@@ -2,6 +2,8 @@ import { defineConfig, devices } from '@playwright/test';
 import * as dotenv from 'dotenv';
 dotenv.config();
 
+export const SESSION_TTL_MS = Number(process.env.QA_SESSION_TTL_MS ?? 2 * 60 * 60 * 1000);
+
 // -------------------------------------------------------------------
 // Validate required environment variables at config load time
 // -------------------------------------------------------------------
@@ -92,6 +94,28 @@ export default defineConfig({
     },
   ],
 
+  // ------ Parallel 2-user variant ------
+  // Uncomment and replace the single chromium project above to run two parallel
+  // workers with separate credentials. Also set QA_USER2_EMAIL and
+  // QA_USER2_PASSWORD in .env.
+  //
+  // {
+  //   name: 'chromium-user1',
+  //   use: {
+  //     ...devices['Desktop Chrome'],
+  //     storageState: '.auth/user-1.json',
+  //   },
+  //   dependencies: ['setup'],
+  // },
+  // {
+  //   name: 'chromium-user2',
+  //   use: {
+  //     ...devices['Desktop Chrome'],
+  //     storageState: '.auth/user-2.json',
+  //   },
+  //   dependencies: ['setup'],
+  // },
+
   // ------ Output directories ------
   outputDir:         'test-results/',
   snapshotPathTemplate: '{testDir}/__snapshots__/{testFilePath}/{arg}{ext}',

package/templates/defect-report.md

@@ -6,7 +6,7 @@
 | Title | {{Short title (max 80 chars)}} |
 | Severity | Critical / High / Medium / Low |
 | Priority | P0 / P1 / P2 / P3 |
-| Status | Open / In Progress / Resolved / Closed |
+| Status | Open / In Progress / Disputed / Resolved / Closed |
 | Assigned to | {{Developer or "Unassigned"}} |
 | Module | {{Module name}} |
 | Submodule | {{Submodule name}} |

package/templates/integration-scaffold/.env.example

@@ -0,0 +1,40 @@
+# -----------------------------------------------------------------------
+# Integration test environment variables
+# -----------------------------------------------------------------------
+# Copy this file to .env and fill in real values.
+# NEVER commit .env to source control.
+# -----------------------------------------------------------------------
+
+# -----------------------------------------------------------------------
+# Application under test
+# -----------------------------------------------------------------------
+QA_BASE_URL=https://your-app.qa.example.com
+
+# -----------------------------------------------------------------------
+# Auth - choose one strategy
+# -----------------------------------------------------------------------
+
+# Strategy 1: Static bearer token (preferred for pure API services)
+# QA_API_TOKEN=your-api-token-here
+
+# Strategy 2: Browser login (for apps with cookie/session auth)
+# QA_USER_EMAIL=qa-user@example.com
+# QA_USER_PASSWORD=CHANGE_ME
+
+# -----------------------------------------------------------------------
+# Login form selectors (used only when QA_API_TOKEN is not set)
+# -----------------------------------------------------------------------
+# QA_LOGIN_PATH=/login
+# QA_LOGIN_EMAIL_SELECTOR=input[type="email"]
+# QA_LOGIN_PASSWORD_SELECTOR=input[type="password"]
+# QA_LOGIN_SUBMIT_SELECTOR=button[type="submit"]
+# QA_LOGIN_SUCCESS_SELECTOR=.dashboard
+
+# -----------------------------------------------------------------------
+# Azure DevOps integration (optional)
+# -----------------------------------------------------------------------
+# ADO_ORG=your-org
+# ADO_PROJECT=YourProject
+# ADO_PLAN_ID=00000
+# ADO_PAT=your-pat-here
+# SYSTEM_ACCESSTOKEN=   # Set automatically in Azure Pipelines

package/templates/integration-scaffold/README.md

@@ -0,0 +1,77 @@
+# API Integration Tests
+
+Playwright-based API test project for `qa/07-automation/integration/`.
+
+Tests run without a browser. All tests use Playwright's `APIRequestContext`
+to call HTTP endpoints directly. Auth state is established once by
+`global-setup.ts` and reused across the test run.
+
+## Requirements
+
+- Node.js 18+
+- `@playwright/test` (installed via `npm install` in this directory)
+
+## Setup
+
+```bash
+cd qa/07-automation/integration
+npm install
+cp .env.example .env
+# Edit .env and fill in QA_BASE_URL and auth credentials
+```
+
+Add the following to your root `.gitignore`:
+
+```
+qa/07-automation/integration/.env
+qa/07-automation/integration/.auth/
+qa/07-automation/integration/test-results/
+qa/07-automation/integration/playwright-report/
+```
+
+## Environment variables
+
+| Variable | Required | Description |
+|---|---|---|
+| `QA_BASE_URL` | Yes | Base URL of the API under test |
+| `QA_API_TOKEN` | One of | Static bearer token for token-based APIs |
+| `QA_USER_EMAIL` | One of | Email/username for browser-login APIs |
+| `QA_USER_PASSWORD` | One of | Password for browser-login APIs |
+
+See `.env.example` for all supported variables.
+
+## Running tests
+
+```bash
+# All tests
+npm test
+
+# CI mode (retries enabled)
+npm run test:ci
+
+# Open HTML report
+npm run report
+```
+
+## Writing tests
+
+Import from `@playwright/test` and use the `request` fixture:
+
+```typescript
+import { test, expect } from '@playwright/test';
+
+test('GET /users returns 200', async ({ request }) => {
+  const response = await request.get('/users');
+  expect(response.status()).toBe(200);
+});
+```
+
+For token-based APIs that require an `Authorization` header, pass it per request:
+
+```typescript
+const response = await request.get('/api/protected', {
+  headers: { Authorization: `Bearer ${process.env.QA_API_TOKEN}` },
+});
+```
+
+See `tests/example.spec.ts` for a starter test to replace.

package/templates/integration-scaffold/global-setup.ts

@@ -0,0 +1,99 @@
+/**
+ * global-setup.ts - Integration (API-only) project
+ *
+ * Runs once before all test files to establish auth state.
+ *
+ * Two strategies, tried in order:
+ *   1. Token-based: QA_API_TOKEN is set -> write a minimal storageState with the
+ *      token in localStorage so the `request` fixture picks it up automatically.
+ *   2. Browser login: QA_USER_EMAIL + QA_USER_PASSWORD are set -> launch Chromium,
+ *      perform the login flow, and save the resulting storageState to
+ *      .auth/api-session.json.
+ *
+ * Playwright's `storageState` mechanism handles cookies and localStorage for
+ * APIRequestContext automatically when `use.storageState` is configured.
+ * For token-only APIs that require an Authorization header, set the header
+ * directly in each test or extend the `request` fixture in fixtures/base.ts.
+ */
+
+import * as fs   from 'fs';
+import * as path from 'path';
+import { chromium } from '@playwright/test';
+import * as dotenv  from 'dotenv';
+
+dotenv.config();
+
+const AUTH_FILE = path.join(__dirname, '.auth', 'api-session.json');
+
+export default async function globalSetup(): Promise<void> {
+  fs.mkdirSync(path.dirname(AUTH_FILE), { recursive: true });
+
+  if (process.env.QA_API_TOKEN) {
+    await setupWithToken(process.env.QA_API_TOKEN, process.env.QA_BASE_URL!);
+    return;
+  }
+
+  await setupWithBrowserLogin();
+}
+
+/**
+ * Write a minimal storageState that carries the bearer token in localStorage.
+ * Replace the localStorage key/value format if your app uses a different scheme
+ * (e.g. a cookie, or a different localStorage key name).
+ */
+async function setupWithToken(token: string, baseURL: string): Promise<void> {
+  const origin = baseURL.replace(/\/$/, '');
+
+  const state = {
+    cookies: [],
+    origins: [
+      {
+        origin,
+        localStorage: [
+          { name: 'qa_api_token', value: token },
+        ],
+      },
+    ],
+  };
+
+  fs.writeFileSync(AUTH_FILE, JSON.stringify(state, null, 2), 'utf-8');
+  console.log('[integration-setup] Token-based auth written to api-session.json');
+}
+
+/**
+ * Perform a browser login and save the resulting cookies + localStorage to disk.
+ *
+ * Configure login form selectors via env vars (see .env.example) or update the
+ * defaults below to match your application's login page.
+ */
+async function setupWithBrowserLogin(): Promise<void> {
+  const baseURL          = process.env.QA_BASE_URL!.replace(/\/$/, '');
+  const email            = process.env.QA_USER_EMAIL!;
+  const password         = process.env.QA_USER_PASSWORD!;
+  const loginPath        = process.env.QA_LOGIN_PATH              ?? '/login';
+  const emailSelector    = process.env.QA_LOGIN_EMAIL_SELECTOR    ?? 'input[type="email"]';
+  const passwordSelector = process.env.QA_LOGIN_PASSWORD_SELECTOR ?? 'input[type="password"]';
+  const submitSelector   = process.env.QA_LOGIN_SUBMIT_SELECTOR   ?? 'button[type="submit"]';
+  const successSelector  = process.env.QA_LOGIN_SUCCESS_SELECTOR  ?? '.dashboard, .main-content, [data-testid="app-shell"]';
+
+  console.log('[integration-setup] Performing browser login...');
+
+  const browser = await chromium.launch();
+  const context = await browser.newContext();
+  const page    = await context.newPage();
+
+  try {
+    await page.goto(`${baseURL}${loginPath}`, { waitUntil: 'load', timeout: 60_000 });
+
+    await page.locator(emailSelector).waitFor({ state: 'visible', timeout: 30_000 });
+    await page.locator(emailSelector).fill(email);
+    await page.locator(passwordSelector).fill(password);
+    await page.locator(submitSelector).click();
+    await page.waitForSelector(successSelector, { timeout: 60_000 });
+
+    await context.storageState({ path: AUTH_FILE });
+    console.log(`[integration-setup] Auth saved: ${AUTH_FILE}`);
+  } finally {
+    await browser.close();
+  }
+}

package/templates/integration-scaffold/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "qa-integration-tests",
+  "version": "1.0.0",
+  "description": "API integration tests - no browser required",
+  "private": true,
+  "scripts": {
+    "test":    "playwright test",
+    "test:ci": "CI=true playwright test",
+    "report":  "playwright show-report"
+  },
+  "devDependencies": {
+    "@playwright/test": "^1.44.0",
+    "dotenv":           "^16.4.0"
+  }
+}

package/templates/integration-scaffold/playwright.config.ts

@@ -0,0 +1,78 @@
+/**
+ * playwright.config.ts - API integration test project (no browser)
+ *
+ * All tests use APIRequestContext directly. No browser projects are defined.
+ * Auth is handled by global-setup.ts, which writes .auth/api-session.json.
+ *
+ * Required env vars:
+ *   QA_BASE_URL     - Base URL of the API under test
+ *
+ * Auth (at least one of the following):
+ *   QA_API_TOKEN    - Bearer token (skips browser login in global-setup)
+ *   QA_USER_EMAIL + QA_USER_PASSWORD  - Credentials for browser-based login
+ */
+
+import { defineConfig } from '@playwright/test';
+import * as dotenv from 'dotenv';
+
+dotenv.config();
+
+const required = ['QA_BASE_URL'];
+for (const key of required) {
+  if (!process.env[key]) {
+    throw new Error(`[integration] Missing required env var: ${key}. Check your .env file.`);
+  }
+}
+
+const hasToken = !!process.env.QA_API_TOKEN;
+const hasCredentials = !!(process.env.QA_USER_EMAIL && process.env.QA_USER_PASSWORD);
+
+if (!hasToken && !hasCredentials) {
+  throw new Error(
+    '[integration] No auth configured. Set QA_API_TOKEN, or both QA_USER_EMAIL and QA_USER_PASSWORD.',
+  );
+}
+
+// Optional: Azure DevOps reporter configuration
+// To enable: set env vars ADO_ORG, ADO_PROJECT, ADO_PAT, ADO_PLAN_ID and CI=true,
+// then uncomment the reporter entry in the `reporter` array below.
+// Install:  npm install @alex_neo/playwright-azure-reporter --save-dev
+// const adoReporterConfig = {
+//   orgUrl:                  `https://dev.azure.com/${process.env.ADO_ORG}`,
+//   token:                   process.env.SYSTEM_ACCESSTOKEN ?? process.env.ADO_PAT,
+//   planId:                  Number(process.env.ADO_PLAN_ID),
+//   projectName:             process.env.ADO_PROJECT!,
+//   testRunTitle:            `[Auto API] ${new Date().toISOString().slice(0, 10)}`,
+//   publishTestResultsMode:  'testRun' as const,
+//   uploadAttachments:       false,
+//   isDisabled:              !process.env.CI,
+//   autoMarkTestCasesAsAutomated: {
+//     enabled:                    true,
+//     updateAutomatedTestName:    true,
+//     updateAutomatedTestStorage: true,
+//   },
+// };
+
+export default defineConfig({
+  testDir:       './tests',
+  fullyParallel: false,
+  workers:       1,
+  timeout:       30_000,
+  retries:       process.env.CI ? 1 : 0,
+
+  globalSetup:  './global-setup.ts',
+
+  reporter: [
+    ['list'],
+    ['html', { open: 'never', outputFolder: 'playwright-report' }],
+    // Uncomment for ADO:
+    // ['@alex_neo/playwright-azure-reporter', adoReporterConfig],
+  ],
+
+  use: {
+    baseURL:      process.env.QA_BASE_URL,
+    storageState: '.auth/api-session.json',
+  },
+
+  outputDir: 'test-results/',
+});

package/templates/integration-scaffold/tests/example.spec.ts

@@ -0,0 +1,43 @@
+/**
+ * example.spec.ts - API integration test example
+ *
+ * This file shows the basic pattern for API tests using Playwright's
+ * APIRequestContext. Replace this with your real tests.
+ *
+ * The `request` fixture is pre-configured with:
+ *   - baseURL from QA_BASE_URL
+ *   - storageState from .auth/api-session.json (set by global-setup.ts)
+ *
+ * For token-based APIs that require an Authorization header, add it
+ * explicitly per request or extend the fixture in a fixtures/base.ts file.
+ */
+
+import { test, expect } from '@playwright/test';
+
+// Replace with the actual health/status endpoint of your API.
+const HEALTH_ENDPOINT = '/health';
+
+test.describe('API smoke tests', () => {
+
+  test('GET health endpoint returns 200', async ({ request }) => {
+    const response = await request.get(HEALTH_ENDPOINT);
+
+    expect(response.status()).toBe(200);
+  });
+
+  // Example of a test with an Authorization header when QA_API_TOKEN is set.
+  // Uncomment and adapt when your API uses Bearer token auth.
+  //
+  // test('GET protected resource returns 200 with bearer token', async ({ request }) => {
+  //   const response = await request.get('/api/me', {
+  //     headers: {
+  //       Authorization: `Bearer ${process.env.QA_API_TOKEN}`,
+  //     },
+  //   });
+  //
+  //   expect(response.status()).toBe(200);
+  //   const body = await response.json();
+  //   expect(body).toHaveProperty('id');
+  // });
+
+});