ykq-playwright-ci 0.1.0

package/src/flows/doctor-pc/login.flow.ts

@@ -0,0 +1,28 @@
+import type { Page } from '@playwright/test';
+import { appEnv, hasDoctorCredentials } from '../../utils/env';
+import { LoginPage } from '../../pages/doctor-pc/login.page';
+
+export class LoginFlow {
+  private readonly loginPage: LoginPage;
+
+  constructor(page: Page) {
+    this.loginPage = new LoginPage(page);
+  }
+
+  async assertLoginPageLoads(): Promise<void> {
+    await this.loginPage.goto();
+    await this.loginPage.assertLoaded();
+  }
+
+  async loginWithConfiguredCredentials(): Promise<void> {
+    if (!hasDoctorCredentials()) {
+      throw new Error('DOCTOR_USERNAME and DOCTOR_PASSWORD are required for automated UI login.');
+    }
+
+    await this.loginPage.loginWithPassword(
+      appEnv.doctorUsername!,
+      appEnv.doctorPassword!,
+      appEnv.doctorOtp
+    );
+  }
+}

package/src/flows/doctor-pc/medicine.flow.ts

@@ -0,0 +1,11 @@
+import { DrugDialogPage } from '../../pages/doctor-pc/drug-dialog.page';
+
+export class MedicineFlow {
+  constructor(private readonly drugDialogPage: DrugDialogPage) {}
+
+  async searchAndSelectDrug(drugName: string): Promise<void> {
+    await this.drugDialogPage.assertVisible();
+    await this.drugDialogPage.search(drugName);
+    await this.drugDialogPage.selectDrug(drugName);
+  }
+}

package/src/flows/doctor-pc/prescription.flow.ts

@@ -0,0 +1,19 @@
+import { DrugDialogPage } from '../../pages/doctor-pc/drug-dialog.page';
+import { PrescriptionPage } from '../../pages/doctor-pc/prescription.page';
+
+export class PrescriptionFlow {
+  constructor(
+    private readonly prescriptionPage: PrescriptionPage,
+    private readonly drugDialogPage: DrugDialogPage
+  ) {}
+
+  async addDiagnosisAndDrug(diagnosis: string, drugName: string): Promise<void> {
+    await this.prescriptionPage.addDiagnosis(diagnosis);
+    await this.drugDialogPage.search(drugName);
+    await this.drugDialogPage.selectDrug(drugName);
+  }
+
+  async submitPrescription(): Promise<void> {
+    await this.prescriptionPage.submit();
+  }
+}

package/src/mocks/routes/prescription.routes.ts

@@ -0,0 +1,25 @@
+import type { Page } from '@playwright/test';
+
+export interface PrescriptionFailureOptions {
+  url?: string | RegExp;
+  status?: number;
+  body?: Record<string, unknown>;
+}
+
+export async function mockPrescriptionSubmitFailure(
+  page: Page,
+  options: PrescriptionFailureOptions = {}
+): Promise<void> {
+  await page.route(options.url ?? /prescription.*submit|submit.*prescription/i, async (route) => {
+    await route.fulfill({
+      status: options.status ?? 500,
+      contentType: 'application/json',
+      body: JSON.stringify(
+        options.body ?? {
+          code: 'E_PRESCRIPTION_SUBMIT_FAILED',
+          message: 'mock prescription submit failure'
+        }
+      )
+    });
+  });
+}

package/src/mocks/websocket/.gitkeep

@@ -0,0 +1 @@
+

package/src/pages/doctor-pc/chat.page.ts

@@ -0,0 +1,26 @@
+import type { Page } from '@playwright/test';
+import { expect } from '@playwright/test';
+import { byTestId, visibleFirst } from '../../utils/selectors';
+
+export class ChatPage {
+  constructor(private readonly page: Page) {}
+
+  async assertVisible(): Promise<void> {
+    await expect(
+      this.page.locator(byTestId('chat-panel')).or(this.page.getByText(/聊天|问诊记录/i)).first()
+    ).toBeVisible();
+  }
+
+  async sendTextMessage(message: string): Promise<void> {
+    const input = visibleFirst(
+      this.page.locator(byTestId('chat-input')),
+      this.page.getByRole('textbox', { name: /消息|输入/i })
+    );
+    await input.fill(message);
+
+    await visibleFirst(
+      this.page.locator(byTestId('chat-send-button')),
+      this.page.getByRole('button', { name: /发送/i })
+    ).click();
+  }
+}

package/src/pages/doctor-pc/drug-dialog.page.ts

@@ -0,0 +1,28 @@
+import type { Page } from '@playwright/test';
+import { expect } from '@playwright/test';
+import { byTestId, visibleFirst } from '../../utils/selectors';
+
+export class DrugDialogPage {
+  constructor(private readonly page: Page) {}
+
+  async assertVisible(): Promise<void> {
+    await expect(
+      this.page.locator(byTestId('drug-dialog')).or(this.page.getByText(/药品|搜索药品/i)).first()
+    ).toBeVisible();
+  }
+
+  async search(keyword: string): Promise<void> {
+    const input = visibleFirst(
+      this.page.locator(byTestId('drug-search-input')),
+      this.page.getByRole('textbox', { name: /药品|搜索/i })
+    );
+    await input.fill(keyword);
+  }
+
+  async selectDrug(drugName: string): Promise<void> {
+    await visibleFirst(
+      this.page.locator(byTestId(`drug-row-${drugName}`)),
+      this.page.getByText(drugName)
+    ).click();
+  }
+}

package/src/pages/doctor-pc/home.page.ts

@@ -0,0 +1,30 @@
+import type { Page } from '@playwright/test';
+import { expect } from '@playwright/test';
+import { appEnv, doctorURL } from '../../utils/env';
+import { visibleFirst } from '../../utils/selectors';
+import { waitForAppReady } from '../../utils/waiters';
+
+export class HomePage {
+  constructor(private readonly page: Page) {}
+
+  async goto(): Promise<void> {
+    await this.page.goto(doctorURL(appEnv.doctorPublicPath));
+    await waitForAppReady(this.page);
+  }
+
+  async assertLoaded(): Promise<void> {
+    await expect(this.page.locator('body')).toBeVisible();
+    await expect(this.page.locator('body')).not.toHaveText('');
+  }
+
+  async openPrescriptionTab(): Promise<void> {
+    const prescriptionTab = visibleFirst(
+      this.page.getByRole('tab', { name: /处方|开方/i }),
+      this.page.getByRole('button', { name: /处方|开方/i }),
+      this.page.getByText(/处方|开方/i)
+    );
+
+    await prescriptionTab.click();
+    await waitForAppReady(this.page);
+  }
+}

package/src/pages/doctor-pc/login.page.ts

@@ -0,0 +1,35 @@
+import type { Page } from '@playwright/test';
+import { expect } from '@playwright/test';
+import { appEnv, doctorURL } from '../../utils/env';
+import { waitForAppReady } from '../../utils/waiters';
+
+export class LoginPage {
+  constructor(private readonly page: Page) {}
+
+  async goto(): Promise<void> {
+    await this.page.goto(doctorURL(appEnv.doctorLoginPath));
+    await waitForAppReady(this.page);
+  }
+
+  async assertLoaded(): Promise<void> {
+    await expect(this.page.locator('body')).toBeVisible();
+    await expect(this.page.locator('body')).not.toHaveText('');
+  }
+
+  async loginWithPassword(username: string, password: string, otp?: string): Promise<void> {
+    await this.goto();
+
+    await this.page
+      .getByRole('textbox', { name: /账号|用户名|手机号|手机|工号/i })
+      .first()
+      .fill(username);
+    await this.page.getByLabel(/密码/i).first().fill(password);
+
+    if (otp) {
+      await this.page.getByRole('textbox', { name: /验证码|动态码/i }).first().fill(otp);
+    }
+
+    await this.page.getByRole('button', { name: /登录|登入|提交/i }).first().click();
+    await waitForAppReady(this.page);
+  }
+}

package/src/pages/doctor-pc/prescription.page.ts

@@ -0,0 +1,29 @@
+import type { Page } from '@playwright/test';
+import { expect } from '@playwright/test';
+import { byTestId, visibleFirst } from '../../utils/selectors';
+
+export class PrescriptionPage {
+  constructor(private readonly page: Page) {}
+
+  async assertVisible(): Promise<void> {
+    await expect(
+      this.page.locator(byTestId('prescription-panel')).or(this.page.getByText(/处方|开方/i)).first()
+    ).toBeVisible();
+  }
+
+  async submit(): Promise<void> {
+    await visibleFirst(
+      this.page.locator(byTestId('prescription-submit-button')),
+      this.page.getByRole('button', { name: /提交处方|提交|保存/i })
+    ).click();
+  }
+
+  async addDiagnosis(keyword: string): Promise<void> {
+    const input = visibleFirst(
+      this.page.locator(byTestId('diagnosis-search-input')),
+      this.page.getByRole('textbox', { name: /诊断/i })
+    );
+    await input.fill(keyword);
+    await this.page.getByText(keyword).first().click();
+  }
+}

package/src/pages/doctor-pc/worklist.page.ts

@@ -0,0 +1,21 @@
+import type { Locator, Page } from '@playwright/test';
+import { expect } from '@playwright/test';
+import { byTestId } from '../../utils/selectors';
+
+export class WorklistPage {
+  constructor(private readonly page: Page) {}
+
+  inquiryCard(inquiryId: string): Locator {
+    return this.page.locator(byTestId(`inquiry-card-${inquiryId}`));
+  }
+
+  async assertVisible(): Promise<void> {
+    await expect(
+      this.page.locator(byTestId('doctor-worklist')).or(this.page.getByText(/问诊中|待接诊/i)).first()
+    ).toBeVisible();
+  }
+
+  async openInquiry(inquiryId: string): Promise<void> {
+    await this.inquiryCard(inquiryId).click();
+  }
+}

package/src/pages/shared/.gitkeep

@@ -0,0 +1 @@
+

package/src/utils/env.ts

@@ -0,0 +1,78 @@
+import path from 'node:path';
+import dotenv from 'dotenv';
+
+dotenv.config();
+
+export interface AppEnv {
+  testEnv: string;
+  doctorBaseURL?: string;
+  doctorPublicPath: string;
+  doctorLoginPath: string;
+  storageStatePath: string;
+  apiBaseURL?: string;
+  testDataApiURL?: string;
+  doctorUsername?: string;
+  doctorPassword?: string;
+  doctorOtp?: string;
+  buildSha: string;
+  ci: boolean;
+}
+
+function optional(name: string): string | undefined {
+  const value = process.env[name]?.trim();
+  return value ? value : undefined;
+}
+
+function normalizePathOrURL(value: string): string {
+  if (/^https?:\/\//i.test(value)) {
+    return value;
+  }
+
+  return value.startsWith('/') ? value : `/${value}`;
+}
+
+function trimTrailingSlash(value?: string): string | undefined {
+  return value?.replace(/\/+$/, '');
+}
+
+export function resolveAppEnv(): AppEnv {
+  return {
+    testEnv: optional('TEST_ENV') ?? 'test',
+    doctorBaseURL: trimTrailingSlash(optional('DOCTOR_BASE_URL')),
+    doctorPublicPath: normalizePathOrURL(optional('DOCTOR_PUBLIC_PATH') ?? '/'),
+    doctorLoginPath: normalizePathOrURL(optional('DOCTOR_LOGIN_PATH') ?? '/login'),
+    storageStatePath:
+      optional('DOCTOR_STORAGE_STATE') ??
+      path.join(process.cwd(), 'playwright/.auth/doctor.json'),
+    apiBaseURL: trimTrailingSlash(optional('API_BASE_URL')),
+    testDataApiURL: trimTrailingSlash(optional('TEST_DATA_API_URL')),
+    doctorUsername: optional('DOCTOR_USERNAME'),
+    doctorPassword: optional('DOCTOR_PASSWORD'),
+    doctorOtp: optional('DOCTOR_OTP'),
+    buildSha: optional('BUILD_SHA') ?? 'local',
+    ci: Boolean(process.env.CI)
+  };
+}
+
+export const appEnv = resolveAppEnv();
+
+export function hasDoctorBaseURL(): boolean {
+  return Boolean(appEnv.doctorBaseURL);
+}
+
+export function hasDoctorCredentials(): boolean {
+  return Boolean(appEnv.doctorUsername && appEnv.doctorPassword);
+}
+
+export function doctorURL(pathOrURL: string): string {
+  if (/^https?:\/\//i.test(pathOrURL)) {
+    return pathOrURL;
+  }
+
+  if (!appEnv.doctorBaseURL) {
+    throw new Error('DOCTOR_BASE_URL is required for doctor PC UI tests.');
+  }
+
+  const normalizedPath = pathOrURL.replace(/^\/+/, '');
+  return new URL(normalizedPath, `${appEnv.doctorBaseURL}/`).toString();
+}

package/src/utils/evidence.ts

@@ -0,0 +1,34 @@
+import type { TestInfo } from '@playwright/test';
+import { appEnv } from './env';
+
+export interface CaseMetadata {
+  caseId: string;
+  sourceId?: string;
+  evidenceId: string;
+  priority: 'Smoke' | 'P0' | 'P1' | 'P2';
+}
+
+export function annotateCase(testInfo: TestInfo, metadata: CaseMetadata): void {
+  testInfo.annotations.push(
+    { type: 'case-id', description: metadata.caseId },
+    { type: 'evidence-id', description: metadata.evidenceId },
+    { type: 'priority', description: metadata.priority },
+    { type: 'env', description: appEnv.testEnv },
+    { type: 'build', description: appEnv.buildSha }
+  );
+
+  if (metadata.sourceId) {
+    testInfo.annotations.push({ type: 'source-id', description: metadata.sourceId });
+  }
+}
+
+export async function attachJson(
+  testInfo: TestInfo,
+  name: string,
+  value: unknown
+): Promise<void> {
+  await testInfo.attach(name, {
+    body: JSON.stringify(value, null, 2),
+    contentType: 'application/json'
+  });
+}

package/src/utils/selectors.ts

@@ -0,0 +1,9 @@
+import type { Locator } from '@playwright/test';
+
+export function byTestId(testId: string): string {
+  return `[data-testid="${testId.replace(/"/g, '\\"')}"]`;
+}
+
+export function visibleFirst(first: Locator, ...rest: Locator[]): Locator {
+  return rest.reduce((current, next) => current.or(next), first).first();
+}

package/src/utils/waiters.ts

@@ -0,0 +1,11 @@
+import type { Page } from '@playwright/test';
+
+export async function waitForAppReady(page: Page): Promise<void> {
+  await page.waitForLoadState('domcontentloaded');
+
+  try {
+    await page.waitForLoadState('networkidle', { timeout: 3_000 });
+  } catch {
+    // Long-polling and websocket pages may never become fully idle.
+  }
+}

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "CommonJS",
+    "moduleResolution": "Node",
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "skipLibCheck": true,
+    "types": ["node", "@playwright/test"]
+  },
+  "include": ["playwright.config.ts", "src/**/*.ts", "cases/**/*.ts"]
+}