cabloy 5.1.159 → 5.1.160

package/test-results/a-commerce-Commerce-theme--062fe--without-hydration-mismatch/error-context.md

@@ -0,0 +1,229 @@
+# 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: a-commerce.spec.ts >> Commerce theme: session cookie mirrors public local preference without hydration mismatch
+- Location: repo-e2e/specs/a-commerce.spec.ts:287:1
+
+# Error details
+
+```
+Error: expect(received).toBe(expected) // Object.is equality
+
+Expected: "false"
+Received: null
+
+Call Log:
+- Timeout 5000ms exceeded while waiting on the predicate
+```
+
+# Test source
+
+```ts
+  214 |   await expect(page.getByText('No addresses yet.')).toBeVisible();
+  215 | }
+  216 | 
+  217 | test(
+  218 |   'ATP-SSR-01: anonymous Commerce HTML is public and hydration completes',
+  219 |   { tag: ['@web', '@smoke'] },
+  220 |   async ({ page, request }) => {
+  221 |     const response = await request.get('/commerce');
+  222 |     expect(response.ok()).toBeTruthy();
+  223 |     expect(response.headers()['cache-control']).toBe('no-cache, no-store, must-revalidate');
+  224 |     const html = await response.text();
+  225 |     const normalizedHtml = html.toLowerCase();
+  226 |     expect(normalizedHtml).not.toContain('data-zova-hydrated');
+  227 | 
+  228 |     for (const marker of privateMarkers) {
+  229 |       expect(normalizedHtml).not.toContain(`"${marker}"`);
+  230 |     }
+  231 | 
+  232 |     const pageErrors = collectPageErrors(page);
+  233 |     const documentResponse = await page.goto('/commerce', { waitUntil: 'load' });
+  234 |     expect(documentResponse?.ok()).toBeTruthy();
+  235 |     await expect(page).toHaveURL(/\/commerce(?:\/|$)/);
+  236 |     await expect(page.locator('html')).toHaveAttribute('data-zova-hydrated', 'commerce');
+  237 |     await expect(page.getByRole('heading', { name: 'Commerce catalogue' })).toBeVisible();
+  238 |     await expect(page.getByText('Dashboard')).toHaveCount(0);
+  239 |     await expect(page.locator('body')).toBeVisible();
+  240 |     await expect(page).not.toHaveTitle(/error/i);
+  241 |     expect(pageErrors).toEqual([]);
+  242 |   },
+  243 | );
+  244 | 
+  245 | test(
+  246 |   'Commerce theme: public local preference mirrors session cookie without hydration mismatch',
+  247 |   { tag: ['@web', '@ssr', '@theme'] },
+  248 |   async ({ browser, request }, testInfo) => {
+  249 |     const customer = await registerCustomer(request, testInfo);
+  250 |     const context = await browser.newContext();
+  251 |     await context.addInitScript(() => localStorage.setItem('themedark', 'true'));
+  252 |     const page = await context.newPage();
+  253 |     const pageErrors = collectPageErrors(page);
+  254 |     const consoleErrors: string[] = [];
+  255 |     page.on('console', message => {
+  256 |       if (message.type() === 'error' || /hydration mismatch/i.test(message.text())) {
+  257 |         consoleErrors.push(message.text());
+  258 |       }
+  259 |     });
+  260 |     try {
+  261 |       await page.goto('/commerce', { waitUntil: 'load' });
+  262 |       await page.evaluate(() => localStorage.setItem('themedark', 'true'));
+  263 |       await page.reload({ waitUntil: 'load' });
+  264 |       await expect(page.locator('html')).toHaveAttribute('data-zova-hydrated', 'commerce');
+  265 |       await expect(page.locator('body')).toHaveAttribute('data-theme', 'dark');
+  266 |       expect((await context.cookies()).find(cookie => cookie.name === 'themedark')?.value).toBe(
+  267 |         'true',
+  268 |       );
+  269 | 
+  270 |       await login(
+  271 |         page,
+  272 |         '/commerce/commerce/member/address',
+  273 |         customer.username,
+  274 |         customer.password,
+  275 |         'commerce',
+  276 |       );
+  277 |       await expect(page.locator('html')).toHaveAttribute('data-zova-hydrated', 'commerce');
+  278 |       await expect(page.locator('body')).toHaveAttribute('data-theme', 'dark');
+  279 |       expect(pageErrors).toEqual([]);
+  280 |       expect(consoleErrors).toEqual([]);
+  281 |     } finally {
+  282 |       await context.close();
+  283 |     }
+  284 |   },
+  285 | );
+  286 | 
+  287 | test(
+  288 |   'Commerce theme: session cookie mirrors public local preference without hydration mismatch',
+  289 |   { tag: ['@web', '@ssr', '@theme'] },
+  290 |   async ({ browser, request }, testInfo) => {
+  291 |     const customer = await registerCustomer(request, testInfo);
+  292 |     const context = await browser.newContext();
+  293 |     const page = await context.newPage();
+  294 |     const pageErrors = collectPageErrors(page);
+  295 |     const consoleErrors = collectConsoleErrors(page);
+  296 |     try {
+  297 |       await login(
+  298 |         page,
+  299 |         '/commerce/commerce/member/address',
+  300 |         customer.username,
+  301 |         customer.password,
+  302 |         'commerce',
+  303 |       );
+  304 |       await context.addCookies([
+  305 |         {
+  306 |           name: 'themedark',
+  307 |           value: 'false',
+  308 |           url: new URL(page.url()).origin,
+  309 |         },
+  310 |       ]);
+  311 |       await page.reload({ waitUntil: 'load' });
+  312 |       await expect(page.locator('html')).toHaveAttribute('data-zova-hydrated', 'commerce');
+  313 |       await expect(page.locator('body')).toHaveAttribute('data-theme', 'light');
+> 314 |       await expect.poll(() => page.evaluate(() => localStorage.getItem('themedark'))).toBe('false');
+      |                                                                                       ^ Error: expect(received).toBe(expected) // Object.is equality
+  315 |       expect(pageErrors).toEqual([]);
+  316 |       expect(consoleErrors).toEqual([]);
+  317 | 
+  318 |       const publicContext = await browser.newContext();
+  319 |       await publicContext.addInitScript(() => localStorage.setItem('themedark', 'false'));
+  320 |       const publicPage = await publicContext.newPage();
+  321 |       const publicPageErrors = collectPageErrors(publicPage);
+  322 |       const publicConsoleErrors = collectConsoleErrors(publicPage);
+  323 |       try {
+  324 |         await publicPage.goto('/commerce', { waitUntil: 'load' });
+  325 |         await expect(publicPage.locator('html')).toHaveAttribute('data-zova-hydrated', 'commerce');
+  326 |         await expect(publicPage.locator('body')).toHaveAttribute('data-theme', 'light');
+  327 |         await expect
+  328 |           .poll(() => publicPage.evaluate(() => localStorage.getItem('themedark')))
+  329 |           .toBe('false');
+  330 |         expect(
+  331 |           (await publicContext.cookies()).find(cookie => cookie.name === 'themedark')?.value,
+  332 |         ).toBe('false');
+  333 |         expect(publicPageErrors).toEqual([]);
+  334 |         expect(publicConsoleErrors).toEqual([]);
+  335 |       } finally {
+  336 |         await publicContext.close();
+  337 |       }
+  338 |     } finally {
+  339 |       await context.close();
+  340 |     }
+  341 |   },
+  342 | );
+  343 | 
+  344 | test(
+  345 |   'Commerce theme: public auto preference mirrors resolved media value without hydration mismatch',
+  346 |   { tag: ['@web', '@ssr', '@theme'] },
+  347 |   async ({ browser }) => {
+  348 |     const context = await browser.newContext();
+  349 |     await context.addInitScript(() => localStorage.setItem('themedark', JSON.stringify('auto')));
+  350 |     const page = await context.newPage();
+  351 |     await page.emulateMedia({ colorScheme: 'dark' });
+  352 |     const pageErrors = collectPageErrors(page);
+  353 |     const consoleErrors = collectConsoleErrors(page);
+  354 |     try {
+  355 |       await page.goto('/commerce', { waitUntil: 'load' });
+  356 |       await expect(page.locator('html')).toHaveAttribute('data-zova-hydrated', 'commerce');
+  357 |       await expect(page.locator('body')).toHaveAttribute('data-theme', 'dark');
+  358 |       await expect
+  359 |         .poll(() => page.evaluate(() => localStorage.getItem('themedark')))
+  360 |         .toBe('"auto"');
+  361 |       expect((await context.cookies()).find(cookie => cookie.name === 'themedark')?.value).toBe(
+  362 |         'true',
+  363 |       );
+  364 |       expect(pageErrors).toEqual([]);
+  365 |       expect(consoleErrors).toEqual([]);
+  366 |     } finally {
+  367 |       await context.close();
+  368 |     }
+  369 |   },
+  370 | );
+  371 | 
+  372 | test(
+  373 |   'Commerce public SSR: theme cookie does not change SSR HTML',
+  374 |   { tag: ['@web', '@ssr', '@theme'] },
+  375 |   async ({ request }) => {
+  376 |     const responses = await Promise.all([
+  377 |       request.get('/commerce'),
+  378 |       request.get('/commerce', { headers: { Cookie: 'themedark=true' } }),
+  379 |       request.get('/commerce', { headers: { Cookie: 'themedark=false' } }),
+  380 |     ]);
+  381 |     const html = await Promise.all(responses.map(response => response.text()));
+  382 |     for (const [index, response] of responses.entries()) {
+  383 |       expect(response.status(), `public response ${index}`).toBe(200);
+  384 |       expect(response.headers()['cache-control'], `public response ${index}`).toBe(
+  385 |         'no-cache, no-store, must-revalidate',
+  386 |       );
+  387 |       expect(html[index].toLowerCase()).not.toContain('data-zova-hydrated');
+  388 |       expect(html[index]).toContain('data-ssr-theme-dark-false="light"');
+  389 |       expect(html[index]).toContain('data-ssr-theme-dark-true="dark"');
+  390 |       expect(html[index]).not.toContain('ssr_cookie_themedark');
+  391 |       expect(html[index]).toContain("window.matchMedia('(prefers-color-scheme: dark)')");
+  392 |       expect(html[index]).not.toMatch(/<body[^>]*data-theme="(?:dark|light)"/);
+  393 |     }
+  394 |   },
+  395 | );
+  396 | 
+  397 | test(
+  398 |   'Commerce session SSR: theme cookie selects raw server theme',
+  399 |   { tag: ['@web', '@ssr', '@theme'] },
+  400 |   async ({ browser, request }, testInfo) => {
+  401 |     const customer = await registerCustomer(request, testInfo);
+  402 |     const context = await browser.newContext();
+  403 |     const page = await context.newPage();
+  404 |     try {
+  405 |       await login(
+  406 |         page,
+  407 |         '/commerce/commerce/member/address',
+  408 |         customer.username,
+  409 |         customer.password,
+  410 |         'commerce',
+  411 |       );
+  412 |       const origin = new URL(page.url()).origin;
+  413 |       const authCookies = (await context.cookies()).filter(cookie => cookie.name !== 'themedark');
+  414 |       const getSessionHtml = async (value: string) => {
+```

package/test-results/a-commerce-PayPal-browser--8672c-t-or-open-an-awaiting-order/error-context.md

@@ -0,0 +1,238 @@
+# 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: a-commerce.spec.ts >> PayPal browser cancel: customer can continue payment or open an awaiting order
+- Location: repo-e2e/specs/a-commerce.spec.ts:943:1
+
+# Error details
+
+```
+Error: expect(page).toHaveURL(expected) failed
+
+Expected pattern: /\/commerce\/commerce\/member\/address(?:\?|$)/
+Received string:  "http://127.0.0.1:7102/commerce/home/base/errorAccessDenied"
+Timeout: 5000ms
+
+Call log:
+  - Expect "toHaveURL" with timeout 5000ms
+    14 × locator resolved to <html lang="en-us" data-zova-hydrated="commerce">…</html>
+       - unexpected value "http://127.0.0.1:7102/commerce/home/base/errorAccessDenied"
+
+```
+
+```yaml
+- text: 403 Access denied.
+- button "Go Home"
+```
+
+# Test source
+
+```ts
+  89  |     await expect(passwordInput).toHaveValue(password);
+  90  |     await expect(page.getByPlaceholder('Please input captcha')).not.toHaveValue('');
+  91  |     const loginResponse = waitForApiResponse(page, 'POST', '/api/home/user/passport/login');
+  92  |     await page.getByRole('button', { name: 'Login', exact: true }).click();
+  93  |     const loginResponseValue = await loginResponse;
+  94  |     if (!loginResponseValue.ok()) {
+  95  |       throw new Error(
+  96  |         `login failed: ${loginResponseValue.status()} ${await loginResponseValue.text()}`,
+  97  |       );
+  98  |     }
+  99  |     await expect(page).not.toHaveURL(/\/login(?:\?|$)/);
+  100 |   }
+  101 | }
+  102 | 
+  103 | async function registerCustomer(
+  104 |   request: APIRequestContext,
+  105 |   testInfo: TestInfo,
+  106 | ): Promise<{ password: string; username: string }> {
+  107 |   const id = `${testInfo.workerIndex}-${testInfo.parallelIndex ?? testInfo.retry}-${Date.now()}`;
+  108 |   const username = `e2e-address-${id}`;
+  109 |   const password = 'address-e2e-password';
+  110 |   const captchaResponse = await request.post('/api/captcha/create', {
+  111 |     data: { scene: 'captcha-simple:simple' },
+  112 |   });
+  113 |   expect(captchaResponse.ok()).toBeTruthy();
+  114 |   const captcha = (await captchaResponse.json()).data;
+  115 |   expect(captcha?.id).toEqual(expect.any(String));
+  116 |   expect(captcha?.token).toEqual(expect.any(String));
+  117 | 
+  118 |   const baseURL = testInfo.project.use.baseURL;
+  119 |   if (!baseURL) throw new Error('commerce E2E base URL is unavailable');
+  120 |   const consumerUrl = new URL('/home/user/activation', baseURL).toString();
+  121 |   const registerResponse = await request.post('/api/home/user/passport/register', {
+  122 |     data: {
+  123 |       username,
+  124 |       email: `${username}@example.test`,
+  125 |       password,
+  126 |       passwordConfirm: password,
+  127 |       consumerUrl,
+  128 |       captcha: { id: captcha.id, token: captcha.token },
+  129 |     },
+  130 |   });
+  131 |   expect(registerResponse.ok()).toBeTruthy();
+  132 |   const registration = (await registerResponse.json()).data;
+  133 |   expect(registration?.jwt?.accessToken).toEqual(expect.any(String));
+  134 |   const activateResponse = await request.post(passportTestActivateCurrentPath, {
+  135 |     headers: { Authorization: `Bearer ${registration.jwt.accessToken}` },
+  136 |   });
+  137 |   expect(activateResponse.ok()).toBeTruthy();
+  138 |   return { username, password };
+  139 | }
+  140 | 
+  141 | function createAddressFixture(testInfo: TestInfo): IAddressFixture {
+  142 |   const id = `${testInfo.workerIndex}-${testInfo.parallelIndex ?? testInfo.retry}-${Date.now()}`;
+  143 |   return {
+  144 |     recipientName: `E2E Address ${id}`,
+  145 |     phone: '15555550123',
+  146 |     countryCode: 'US',
+  147 |     region: 'California',
+  148 |     city: `Original City ${id}`,
+  149 |     postalCode: '94105',
+  150 |     addressLine1: `1 Test Street ${id}`,
+  151 |     addressLine2: 'Suite E2E',
+  152 |     updatedCity: `Updated City ${id}`,
+  153 |   };
+  154 | }
+  155 | 
+  156 | function getAddressTextbox(page: Page, name: string): Locator {
+  157 |   return page.getByRole('group', { name, exact: true }).getByRole('textbox');
+  158 | }
+  159 | 
+  160 | async function fillAddressForm(page: Page, fixture: IAddressFixture) {
+  161 |   await getAddressTextbox(page, 'Recipient Name *').fill(fixture.recipientName);
+  162 |   await getAddressTextbox(page, 'Phone *').fill(fixture.phone);
+  163 |   await getAddressTextbox(page, 'Country Code *').fill(fixture.countryCode);
+  164 |   await getAddressTextbox(page, 'Region *').fill(fixture.region);
+  165 |   await getAddressTextbox(page, 'City *').fill(fixture.city);
+  166 |   await getAddressTextbox(page, 'Postal Code *').fill(fixture.postalCode);
+  167 |   await getAddressTextbox(page, 'Address Line 1 *').fill(fixture.addressLine1);
+  168 |   await getAddressTextbox(page, 'Address Line 2').fill(fixture.addressLine2);
+  169 | }
+  170 | 
+  171 | async function createAddressThroughCustomerPage(
+  172 |   browser: Browser,
+  173 |   request: APIRequestContext,
+  174 |   testInfo: TestInfo,
+  175 | ) {
+  176 |   const customer = await registerCustomer(request, testInfo);
+  177 |   const fixture = createAddressFixture(testInfo);
+  178 |   const context = await browser.newContext();
+  179 |   const page = await context.newPage();
+  180 |   const pageErrors = collectPageErrors(page);
+  181 | 
+  182 |   await login(
+  183 |     page,
+  184 |     '/commerce/commerce/member/address',
+  185 |     customer.username,
+  186 |     customer.password,
+  187 |     'commerce',
+  188 |   );
+> 189 |   await expect(page).toHaveURL(/\/commerce\/commerce\/member\/address(?:\?|$)/);
+      |                      ^ Error: expect(page).toHaveURL(expected) failed
+  190 |   await expect(page.getByRole('heading', { name: 'Addresses' })).toBeVisible();
+  191 |   await expect(page.getByText('No addresses yet.')).toBeVisible();
+  192 | 
+  193 |   await fillAddressForm(page, fixture);
+  194 |   const createResponse = waitForAddressResponse(page, 'POST', `${addressActionPath}/createMine`);
+  195 |   const mineResponse = waitForAddressMine(page);
+  196 |   await page.getByRole('button', { name: 'Save address', exact: true }).click();
+  197 |   await createResponse;
+  198 |   await mineResponse;
+  199 |   await expect(page.getByRole('heading', { name: fixture.recipientName })).toBeVisible();
+  200 | 
+  201 |   return { context, fixture, page, pageErrors };
+  202 | }
+  203 | 
+  204 | async function deleteAddressThroughCustomerPage(page: Page, fixture: IAddressFixture) {
+  205 |   const card = page
+  206 |     .locator('article')
+  207 |     .filter({ has: page.getByRole('heading', { name: fixture.recipientName }) });
+  208 |   const deleteResponse = waitForAddressResponse(page, 'DELETE', /\/deleteMine\/[^/]+$/);
+  209 |   const mineResponse = waitForAddressMine(page);
+  210 |   await card.getByRole('button', { name: 'Delete', exact: true }).click();
+  211 |   await deleteResponse;
+  212 |   await mineResponse;
+  213 |   await expect(page.getByRole('heading', { name: fixture.recipientName })).toHaveCount(0);
+  214 |   await expect(page.getByText('No addresses yet.')).toBeVisible();
+  215 | }
+  216 | 
+  217 | test(
+  218 |   'ATP-SSR-01: anonymous Commerce HTML is public and hydration completes',
+  219 |   { tag: ['@web', '@smoke'] },
+  220 |   async ({ page, request }) => {
+  221 |     const response = await request.get('/commerce');
+  222 |     expect(response.ok()).toBeTruthy();
+  223 |     expect(response.headers()['cache-control']).toBe('no-cache, no-store, must-revalidate');
+  224 |     const html = await response.text();
+  225 |     const normalizedHtml = html.toLowerCase();
+  226 |     expect(normalizedHtml).not.toContain('data-zova-hydrated');
+  227 | 
+  228 |     for (const marker of privateMarkers) {
+  229 |       expect(normalizedHtml).not.toContain(`"${marker}"`);
+  230 |     }
+  231 | 
+  232 |     const pageErrors = collectPageErrors(page);
+  233 |     const documentResponse = await page.goto('/commerce', { waitUntil: 'load' });
+  234 |     expect(documentResponse?.ok()).toBeTruthy();
+  235 |     await expect(page).toHaveURL(/\/commerce(?:\/|$)/);
+  236 |     await expect(page.locator('html')).toHaveAttribute('data-zova-hydrated', 'commerce');
+  237 |     await expect(page.getByRole('heading', { name: 'Commerce catalogue' })).toBeVisible();
+  238 |     await expect(page.getByText('Dashboard')).toHaveCount(0);
+  239 |     await expect(page.locator('body')).toBeVisible();
+  240 |     await expect(page).not.toHaveTitle(/error/i);
+  241 |     expect(pageErrors).toEqual([]);
+  242 |   },
+  243 | );
+  244 | 
+  245 | test(
+  246 |   'Commerce theme: public local preference mirrors session cookie without hydration mismatch',
+  247 |   { tag: ['@web', '@ssr', '@theme'] },
+  248 |   async ({ browser, request }, testInfo) => {
+  249 |     const customer = await registerCustomer(request, testInfo);
+  250 |     const context = await browser.newContext();
+  251 |     await context.addInitScript(() => localStorage.setItem('themedark', 'true'));
+  252 |     const page = await context.newPage();
+  253 |     const pageErrors = collectPageErrors(page);
+  254 |     const consoleErrors: string[] = [];
+  255 |     page.on('console', message => {
+  256 |       if (message.type() === 'error' || /hydration mismatch/i.test(message.text())) {
+  257 |         consoleErrors.push(message.text());
+  258 |       }
+  259 |     });
+  260 |     try {
+  261 |       await page.goto('/commerce', { waitUntil: 'load' });
+  262 |       await page.evaluate(() => localStorage.setItem('themedark', 'true'));
+  263 |       await page.reload({ waitUntil: 'load' });
+  264 |       await expect(page.locator('html')).toHaveAttribute('data-zova-hydrated', 'commerce');
+  265 |       await expect(page.locator('body')).toHaveAttribute('data-theme', 'dark');
+  266 |       expect((await context.cookies()).find(cookie => cookie.name === 'themedark')?.value).toBe(
+  267 |         'true',
+  268 |       );
+  269 | 
+  270 |       await login(
+  271 |         page,
+  272 |         '/commerce/commerce/member/address',
+  273 |         customer.username,
+  274 |         customer.password,
+  275 |         'commerce',
+  276 |       );
+  277 |       await expect(page.locator('html')).toHaveAttribute('data-zova-hydrated', 'commerce');
+  278 |       await expect(page.locator('body')).toHaveAttribute('data-theme', 'dark');
+  279 |       expect(pageErrors).toEqual([]);
+  280 |       expect(consoleErrors).toEqual([]);
+  281 |     } finally {
+  282 |       await context.close();
+  283 |     }
+  284 |   },
+  285 | );
+  286 | 
+  287 | test(
+  288 |   'Commerce theme: session cookie mirrors public local preference without hydration mismatch',
+  289 |   { tag: ['@web', '@ssr', '@theme'] },
+```