npm - cabloy - Versions diffs - 5.1.152 → 5.1.153 - Mend

cabloy 5.1.152 → 5.1.153

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (42) hide show

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

@@ -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(() => {
+```