cabloy 5.1.151 → 5.1.153

package/repo-e2e/specs/cabloy-basic.spec.ts

@@ -414,7 +414,7 @@ test(
 );
 
 test(
-  'ATP-BASIC-SUMMARY-01: Training Student summary renders Markdown HTML in a dialog',
+  'ATP-BASIC-SUMMARY-01: Training Student summary dialog renders query states and Markdown HTML',
   { tag: ['@admin', '@flow'] },
   async ({ page }) => {
     const pageErrors = collectPageErrors(page);
@@ -466,25 +466,74 @@ test(
       await page.getByRole('button', { name: 'Search', exact: true }).click();
       await searchResponse;
 
-      const row = page.locator('tr').filter({ hasText: studentName });
-      await expect(row).toHaveCount(1);
-      const summaryResponse = page.waitForResponse(response => {
-        const url = new URL(response.url());
-        return (
-          response.request().method() === 'GET' &&
-          response.ok() &&
-          url.pathname === `/api/training/student/summary/${studentId}` &&
-          !response.request().headers()['x-vona-openapi-schema']
-        );
-      });
-      await row.getByRole('button', { name: 'Summary', exact: true }).click();
-      await summaryResponse;
-
-      const description = page.locator('.student-summary-description');
-      await expect(description).toBeVisible();
-      await expect(description.locator('h2')).toHaveText('Summary heading');
-      await expect(description).toContainText(`Summary paragraph ${studentName}`);
-      expect(pageErrors).toEqual([]);
+      const summaryPath = `/api/training/student/summary/${studentId}`;
+      let summaryMode: 'failure' | 'success' = 'failure';
+      let releaseSummaryRequest: (() => void) | undefined;
+      let summaryRequest: Promise<void> | undefined;
+      let releaseSummaryResponse: (() => void) | undefined;
+      let summaryResponseRelease: Promise<void> | undefined;
+      const summaryHandler = async (route: Route) => {
+        releaseSummaryRequest?.();
+        if (summaryMode === 'failure') {
+          await route.fulfill({
+            status: 500,
+            contentType: 'application/json',
+            body: JSON.stringify({ code: 500, message: 'Summary temporarily unavailable' }),
+          });
+          return;
+        }
+        const response = await route.fetch();
+        await summaryResponseRelease;
+        await route.fulfill({ response });
+      };
+      const summaryRouteUrl = (url: URL) => url.pathname === summaryPath;
+      await page.route(summaryRouteUrl, summaryHandler);
+      try {
+        let row = page.locator('tr').filter({ hasText: studentName });
+        await expect(row).toHaveCount(1);
+        await row.getByRole('button', { name: 'Summary', exact: true }).click();
+
+        const dialog = page.getByRole('dialog');
+        await expect(dialog).toBeVisible();
+        await expect(dialog.locator('.alert.alert-error')).toHaveCount(1);
+        await expect(dialog.locator('.student-summary-description')).toHaveCount(0);
+        await page.keyboard.press('Escape');
+        await expect(dialog).toHaveCount(0);
+
+        summaryMode = 'success';
+        summaryRequest = new Promise(resolve => {
+          releaseSummaryRequest = resolve;
+        });
+        summaryResponseRelease = new Promise(resolve => {
+          releaseSummaryResponse = resolve;
+        });
+        const listResponse = await page.goto('/admin/rest/resource/training-student%3Astudent', {
+          waitUntil: 'load',
+        });
+        expect(listResponse?.ok()).toBeTruthy();
+        await expect(page.locator('html')).toHaveAttribute('data-zova-hydrated', 'admin');
+        await page.getByLabel('Student Name').fill(studentName);
+        const nextSearchResponse = waitForStudentSelect(page);
+        await page.getByRole('button', { name: 'Search', exact: true }).click();
+        await nextSearchResponse;
+
+        row = page.locator('tr').filter({ hasText: studentName });
+        await expect(row).toHaveCount(1);
+        await row.getByRole('button', { name: 'Summary', exact: true }).click();
+        await summaryRequest;
+        await expect(dialog).toHaveCount(0, { timeout: 250 });
+        releaseSummaryResponse?.();
+
+        const description = dialog.locator('.student-summary-description');
+        await expect(dialog).toBeVisible();
+        await expect(description).toBeVisible();
+        await expect(description.locator('h2')).toHaveText('Summary heading');
+        await expect(description).toContainText(`Summary paragraph ${studentName}`);
+        expect(pageErrors).toEqual([]);
+      } finally {
+        releaseSummaryResponse?.();
+        await page.unroute(summaryRouteUrl, summaryHandler);
+      }
     } finally {
       try {
         if (studentId !== undefined) {

package/test-results/.last-run.json

@@ -1,4 +1,6 @@
 {
-  "status": "passed",
-  "failedTests": []
+  "status": "failed",
+  "failedTests": [
+    "0d2518050eca8cd1231a-03158dd238416d7c8c3e"
+  ]
 }

package/test-results/cabloy-basic-ATP-BASIC-SUM-58d8a-ry-states-and-Markdown-HTML/error-context.md

@@ -0,0 +1,195 @@
+# Instructions
+
+- Following Playwright test failed.
+- Explain why, be concise, respect Playwright best practices.
+- Provide a snippet of code with the fix, if possible.
+
+# Test info
+
+- Name: cabloy-basic.spec.ts >> ATP-BASIC-SUMMARY-01: Training Student summary dialog renders query states and Markdown HTML
+- Location: repo-e2e/specs/cabloy-basic.spec.ts:416:1
+
+# Error details
+
+```
+Error: expect(page).not.toHaveURL(expected) failed
+
+Expected pattern: not /\/admin\/login(?:\?|$)/
+Received string: "http://127.0.0.1:7102/admin/login"
+Timeout: 5000ms
+
+Call log:
+  - Expect "not toHaveURL" with timeout 5000ms
+    14 × locator resolved to <html lang="en-us" data-zova-hydrated="admin">…</html>
+       - unexpected value "http://127.0.0.1:7102/admin/login"
+
+```
+
+```yaml
+- heading "Zova" [level=1]
+- heading "Less is more, while more is less" [level=5]
+- heading "Login" [level=2]
+- textbox:
+  - /placeholder: Your Username
+  - text: admin
+- textbox:
+  - /placeholder: Your Password
+  - text: "123456"
+- textbox:
+  - /placeholder: Please input captcha
+  - text: TrAs
+- img
+- button "Login"
+- button "Create account"
+- button "Forgot password?"
+- text: OR
+- button "Sign in with GitHub"
+- dialog:
+  - heading "Cabloy Basic" [level=3]
+  - paragraph: "select `aAuthProvider`.`id` from `aAuthProvider` where `providerName` = 'auth-simple:simple' and `clientName` = 'default' and `aAuthProvider`.`iid` = 1 - no such table: aAuthProvider"
+  - button "Close"
+```
+
+# Test source
+
+```ts
+  1   | import type { Locator, Page, Route } from '@playwright/test';
+  2   | 
+  3   | import { expect, test } from '@playwright/test';
+  4   | 
+  5   | const studentResourceUrl =
+  6   |   /\/admin\/rest\/resource\/training-student(?:%3A|:|%253A)student(?:[/?#]|$)/;
+  7   | 
+  8   | interface IFieldGeometry {
+  9   |   container: {
+  10  |     display: string;
+  11  |     flexWrap: string;
+  12  |     left: number;
+  13  |     right: number;
+  14  |   };
+  15  |   field: {
+  16  |     top: number;
+  17  |     left: number;
+  18  |     right: number;
+  19  |     bottom: number;
+  20  |   };
+  21  | }
+  22  | 
+  23  | function collectPageErrors(page: Page) {
+  24  |   const errors: Error[] = [];
+  25  |   page.on('pageerror', error => {
+  26  |     errors.push(error);
+  27  |   });
+  28  |   return errors;
+  29  | }
+  30  | 
+  31  | async function loginAsAdmin(page: Page) {
+  32  |   await page.goto('/admin/', { waitUntil: 'load' });
+  33  |   if (page.url().includes('/admin/login')) {
+  34  |     await page.getByPlaceholder('Your Username').fill('admin');
+  35  |     await page.getByPlaceholder('Your Password').fill('123456');
+  36  |     await expect(page.getByPlaceholder('Please input captcha')).not.toHaveValue('');
+  37  |     await page.getByRole('button', { name: 'Login', exact: true }).click();
+> 38  |     await expect(page).not.toHaveURL(/\/admin\/login(?:\?|$)/);
+      |                            ^ Error: expect(page).not.toHaveURL(expected) failed
+  39  |   }
+  40  | 
+  41  |   await expect(page.locator('html')).toHaveAttribute('data-zova-hydrated', 'admin');
+  42  |   const dashboardResponse = await page.goto('/admin/', { waitUntil: 'load' });
+  43  |   await expect(page.locator('html')).toHaveAttribute('data-zova-hydrated', 'admin');
+  44  |   return dashboardResponse;
+  45  | }
+  46  | 
+  47  | function waitForStudentSelect(page: Page) {
+  48  |   return page.waitForResponse(response => {
+  49  |     const url = new URL(response.url());
+  50  |     return (
+  51  |       response.request().method() === 'GET' &&
+  52  |       response.ok() &&
+  53  |       url.pathname === '/api/training/student' &&
+  54  |       !response.request().headers()['x-vona-openapi-schema']
+  55  |     );
+  56  |   });
+  57  | }
+  58  | 
+  59  | function installStudentCreateResponseCapture(page: Page) {
+  60  |   let studentId: string | number | undefined;
+  61  |   const handler = async (route: Route) => {
+  62  |     const request = route.request();
+  63  |     const url = new URL(request.url());
+  64  |     if (
+  65  |       request.method() !== 'POST' ||
+  66  |       url.pathname !== '/api/training/student' ||
+  67  |       request.headers()['x-vona-openapi-schema']
+  68  |     ) {
+  69  |       await route.continue();
+  70  |       return;
+  71  |     }
+  72  |     const response = await route.fetch();
+  73  |     const payload = await response.json();
+  74  |     if (response.ok() && ['string', 'number'].includes(typeof payload.data)) {
+  75  |       studentId = payload.data;
+  76  |     }
+  77  |     await route.fulfill({ response });
+  78  |   };
+  79  |   return {
+  80  |     async install() {
+  81  |       await page.route('**/api/training/student', handler);
+  82  |     },
+  83  |     async uninstall() {
+  84  |       await page.unroute('**/api/training/student', handler);
+  85  |     },
+  86  |     get studentId() {
+  87  |       return studentId;
+  88  |     },
+  89  |   };
+  90  | }
+  91  | 
+  92  | async function getFieldGeometry(locator: Locator): Promise<IFieldGeometry> {
+  93  |   return locator.evaluate(element => {
+  94  |     const field = element.closest('label')?.parentElement;
+  95  |     const container = field?.parentElement;
+  96  |     if (!field || !container) throw new Error('Could not resolve the filter field layout');
+  97  | 
+  98  |     const fieldRect = field.getBoundingClientRect();
+  99  |     const containerRect = container.getBoundingClientRect();
+  100 |     const containerStyle = getComputedStyle(container);
+  101 |     return {
+  102 |       container: {
+  103 |         display: containerStyle.display,
+  104 |         flexWrap: containerStyle.flexWrap,
+  105 |         left: containerRect.left,
+  106 |         right: containerRect.right,
+  107 |       },
+  108 |       field: {
+  109 |         top: fieldRect.top,
+  110 |         left: fieldRect.left,
+  111 |         right: fieldRect.right,
+  112 |         bottom: fieldRect.bottom,
+  113 |       },
+  114 |     };
+  115 |   });
+  116 | }
+  117 | 
+  118 | async function getFlowGeometry(name: Locator, level: Locator, createdAtStart: Locator) {
+  119 |   return Promise.all([
+  120 |     getFieldGeometry(name),
+  121 |     getFieldGeometry(level),
+  122 |     getFieldGeometry(createdAtStart),
+  123 |   ]);
+  124 | }
+  125 | 
+  126 | function assertVisualOrder(geometry: IFieldGeometry[]) {
+  127 |   for (let index = 1; index < geometry.length; index++) {
+  128 |     const previous = geometry[index - 1].field;
+  129 |     const current = geometry[index].field;
+  130 |     expect(
+  131 |       current.top > previous.top + 2 ||
+  132 |         (Math.abs(current.top - previous.top) <= 2 && current.left > previous.left),
+  133 |     ).toBeTruthy();
+  134 |   }
+  135 | }
+  136 | 
+  137 | async function getDocumentHorizontalOverflow(page: Page) {
+  138 |   return page.evaluate(() => {
+```