Initial commit: API QA automation with Playwright

Author: OmonUrkinbaev

.github/workflows/tests.yml

@@ -0,0 +1,20 @@
+name: API Tests (Playwright)
+
+on:
+  push:
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: "20"
+          cache: "npm"
+
+      - run: npm ci
+      - run: npx playwright install --with-deps
+      - run: npm test

.gitignore

@@ -0,0 +1,5 @@
+node_modules/
+playwright-report/
+test-results/
+.env
+.DS_Store

package-lock.json

@@ -0,0 +1,19 @@
+{
+  "name": "api-playwright-qa",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "playwright test",
+    "test:ui": "playwright test --ui",
+    "report": "playwright show-report"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "type": "commonjs",
+  "devDependencies": {
+    "@playwright/test": "^1.57.0",
+    "typescript": "^5.9.3"
+  }
+}

package.json

@@ -0,0 +1,11 @@
+import { defineConfig } from "@playwright/test";
+
+export default defineConfig({
+  testDir: "./tests",
+  timeout: 30_000,
+  retries: process.env.CI ? 1 : 0,
+  use: {
+    baseURL: "https://dummyjson.com",
+  },
+  reporter: [["html", { open: "never" }], ["list"]],
+});

playwright.config.ts

@@ -0,0 +1,54 @@
+import { test, expect } from "@playwright/test";
+import { ApiClient } from "../utils/apiClient";
+
+test.describe("Auth API (DummyJSON)", () => {
+  test("GET /auth/me returns user profile when authorized (token)", async ({ request, baseURL }) => {
+    const api = new ApiClient(request, baseURL!);
+
+    // 1) Login to get token
+    const loginRes = await api.post("/auth/login", {
+      username: "emilys",
+      password: "emilyspass",
+      expiresInMins: 30,
+    });
+
+    expect(loginRes.status()).toBe(200);
+    await api.assertJson(loginRes);
+
+    const loginBody = await loginRes.json();
+    expect(loginBody).toHaveProperty("accessToken");
+    const token = loginBody.accessToken as string;
+    expect(token.length).toBeGreaterThan(10);
+
+    // 2) Call protected endpoint with Bearer token
+    const meRes = await api.get("/auth/me", {
+      Authorization: `Bearer ${token}`,
+    });
+
+    expect(meRes.status()).toBe(200);
+    await api.assertJson(meRes);
+
+    const meBody = await meRes.json();
+
+    // 3) Assertions that matter for QA (shape + consistency)
+    expect(meBody).toHaveProperty("id");
+    expect(meBody).toHaveProperty("username");
+    expect(typeof meBody.id).toBe("number");
+    expect(typeof meBody.username).toBe("string");
+
+    // Optional: confirm same username (if API returns it in login payload)
+    // DummyJSON обычно возвращает username в логине — если есть, проверим
+    if (loginBody.username) {
+      expect(meBody.username).toBe(loginBody.username);
+    }
+  });
+
+  test("GET /auth/me fails without token (negative)", async ({ request, baseURL }) => {
+    const api = new ApiClient(request, baseURL!);
+
+    const res = await api.get("/auth/me");
+    expect(res.ok()).toBeFalsy();
+    // обычно 401, но пусть будет устойчиво:
+    expect([400, 401, 403]).toContain(res.status());
+  });
+});

tests/auth.me.spec.ts

@@ -0,0 +1,36 @@
+import { test, expect } from "@playwright/test";
+import { ApiClient } from "../utils/apiClient";
+
+test.describe("Auth API (DummyJSON)", () => {
+  test("POST /auth/login returns accessToken and refreshToken for valid credentials", async ({ request, baseURL }) => {
+    const api = new ApiClient(request, baseURL!);
+
+    const res = await api.post("/auth/login", {
+      username: "emilys",
+      password: "emilyspass",
+      expiresInMins: 30,
+    });
+
+    expect(res.status()).toBe(200);
+    await api.assertJson(res);
+
+    const body = await res.json();
+    expect(body).toHaveProperty("accessToken");
+    expect(body).toHaveProperty("refreshToken");
+    expect(typeof body.accessToken).toBe("string");
+    expect(typeof body.refreshToken).toBe("string");
+    expect(body.accessToken.length).toBeGreaterThan(10);
+  });
+
+  test("POST /auth/login fails for invalid credentials (negative)", async ({ request, baseURL }) => {
+    const api = new ApiClient(request, baseURL!);
+
+    const res = await api.post("/auth/login", {
+      username: "wrong_user",
+      password: "wrong_pass",
+    });
+
+    // у разных API может быть 400/401 — главное что не OK
+    expect(res.ok()).toBeFalsy();
+  });
+});

tests/auth.spec.ts

@@ -0,0 +1,48 @@
+import { test, expect } from "@playwright/test";
+import { ApiClient } from "../utils/apiClient";
+import { expectProductShape } from "../utils/validators";
+
+test.describe("Products API (DummyJSON)", () => {
+  test("GET /products returns a non-empty products array", async ({ request, baseURL }) => {
+    const api = new ApiClient(request, baseURL!);
+
+    const res = await api.get("/products");
+    expect(res.status()).toBe(200);
+    await api.assertJson(res);
+
+    const body = await res.json();
+    expect(Array.isArray(body.products)).toBeTruthy();
+    expect(body.products.length).toBeGreaterThan(0);
+
+    expectProductShape(body.products[0]);
+  });
+
+  test("GET /products/:id returns correct product shape (data-driven)", async ({ request, baseURL }) => {
+    const api = new ApiClient(request, baseURL!);
+    const ids = [1, 2, 3, 4];
+
+    for (const id of ids) {
+      const res = await api.get(`/products/${id}`);
+      expect(res.status(), `id=${id}`).toBe(200);
+      await api.assertJson(res);
+
+      const body = await res.json();
+      expectProductShape(body);
+      expect(body.id).toBe(id);
+    }
+  });
+
+  test("GET /products/:id returns 404 or an error payload for invalid id (negative)", async ({ request, baseURL }) => {
+    const api = new ApiClient(request, baseURL!);
+
+    const res = await api.get("/products/999999");
+
+    // Делаем тест устойчивым: либо 404, либо res.ok=false, либо error/message в body
+    if (res.ok()) {
+      const body = await res.json();
+      expect(body).toHaveProperty("message");
+    } else {
+      expect([400, 404]).toContain(res.status());
+    }
+  });
+});

tests/products.spec.ts

@@ -0,0 +1,9 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "CommonJS",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true
+  }
+}

tsconfig.json

@@ -0,0 +1,21 @@
+import { APIRequestContext, expect } from "@playwright/test";
+
+export class ApiClient {
+  constructor(private request: APIRequestContext, private baseURL: string) {}
+
+  async get(path: string, headers?: Record<string, string>) {
+    const res = await this.request.get(this.baseURL + path, { headers });
+    return res;
+  }
+
+  async post(path: string, data: unknown, headers?: Record<string, string>) {
+    const res = await this.request.post(this.baseURL + path, { data, headers });
+    return res;
+  }
+
+  async assertJson(res: any) {
+    expect(res.ok()).toBeTruthy();
+    const contentType = res.headers()["content-type"] ?? "";
+    expect(contentType).toContain("application/json");
+  }
+}