cabloy 5.1.159 → 5.1.160

package/test-results/a-commerce-ATP-SPC-05-syst-fb406-e-without-mutation-controls/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 >> ATP-SPC-05: systemAdmin inspects readonly Address Resource without mutation controls
+- Location: repo-e2e/specs/a-commerce.spec.ts:1371: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'] },
+```

package/test-results/a-commerce-Commerce-sessio-4e963-ie-selects-raw-server-theme/error-context.md

@@ -0,0 +1,226 @@
+# 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 session SSR: theme cookie selects raw server theme
+- Location: repo-e2e/specs/a-commerce.spec.ts:397:1
+
+# Error details
+
+```
+Error: expect(received).toBe(expected) // Object.is equality
+
+Expected: "private, no-store"
+Received: "no-cache, no-store, must-revalidate"
+```
+
+# Test source
+
+```ts
+  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) => {
+  415 |         const sessionContext = await browser.newContext();
+  416 |         try {
+  417 |           await sessionContext.addCookies([
+  418 |             ...authCookies.map(({ domain, path, ...cookie }) => ({ ...cookie, url: origin })),
+  419 |             { name: 'themedark', value, url: origin },
+  420 |           ]);
+  421 |           const response = await sessionContext.request.get('/commerce/commerce/member/address');
+  422 |           return { response, html: await response.text() };
+  423 |         } finally {
+  424 |           await sessionContext.close();
+  425 |         }
+  426 |       };
+  427 |       for (const [value, theme] of [
+  428 |         ['true', 'dark'],
+  429 |         ['false', 'light'],
+  430 |       ] as const) {
+  431 |         const { response, html } = await getSessionHtml(value);
+  432 |         expect(response.status()).toBe(200);
+> 433 |         expect(response.headers()['cache-control']).toBe('private, no-store');
+      |                                                     ^ Error: expect(received).toBe(expected) // Object.is equality
+  434 |         expect(html).toContain(`data-theme="${theme}"`);
+  435 |         expect(html).not.toContain('data-ssr-theme-dark-false');
+  436 |         expect(html).not.toContain('data-ssr-theme-dark-true');
+  437 |         expect(html).not.toContain("window.matchMedia('(prefers-color-scheme: dark)')");
+  438 |         expect(html).toContain('Addresses');
+  439 |       }
+  440 |     } finally {
+  441 |       await context.close();
+  442 |     }
+  443 |   },
+  444 | );
+  445 | 
+  446 | test(
+  447 |   'Commerce catalogue: public sellable inventory renders after hydration',
+  448 |   { tag: ['@web', '@flow'] },
+  449 |   async ({ page }) => {
+  450 |     const pageErrors = collectPageErrors(page);
+  451 |     const response = await page.goto('/commerce', { waitUntil: 'load' });
+  452 |     expect(response?.ok()).toBeTruthy();
+  453 |     await expect(page.locator('html')).toHaveAttribute('data-zova-hydrated', 'commerce');
+  454 |     await expect(page.getByRole('heading', { name: 'Commerce catalogue' })).toBeVisible();
+  455 |     await expect(page.getByRole('link', { name: 'Wireless Headphones' })).toBeVisible();
+  456 |     await expect(page.getByText('24 available')).toBeVisible();
+  457 |     await page.getByRole('link', { name: 'Wireless Headphones' }).click();
+  458 |     await expect(page).toHaveURL(/\/commerce\/product\/\d+(?:\/|$)/);
+  459 |     await expect(page.getByRole('heading', { name: 'Wireless Headphones' })).toBeVisible();
+  460 |     await expect(page.getByText('HPH-BLK')).toBeVisible();
+  461 |     expect(pageErrors).toEqual([]);
+  462 |   },
+  463 | );
+  464 | 
+  465 | test(
+  466 |   'Commerce catalogue: localized Product navigation preserves locale',
+  467 |   { tag: ['@web', '@flow'] },
+  468 |   async ({ page, request }) => {
+  469 |     const localizedPath = '/commerce/zh-cn';
+  470 |     const response = await request.get(localizedPath);
+  471 |     expect(response.ok()).toBeTruthy();
+  472 |     const html = await response.text();
+  473 |     expect(html.toLowerCase()).not.toContain('data-zova-hydrated');
+  474 |     expect(html).toContain('商品目录');
+  475 |     expect(html).toContain('当前价格和库存以结算时确认为准。');
+  476 | 
+  477 |     const pageErrors = collectPageErrors(page);
+  478 |     const documentResponse = await page.goto(localizedPath, { waitUntil: 'load' });
+  479 |     expect(documentResponse?.ok()).toBeTruthy();
+  480 |     await expect(page).toHaveURL(/\/commerce\/zh-cn(?:\/|$)/);
+  481 |     await expect(page.locator('html')).toHaveAttribute('data-zova-hydrated', 'commerce');
+  482 |     await expect(page.getByRole('heading', { name: '商品目录' })).toBeVisible();
+  483 |     await expect(page.getByText('当前价格和库存以结算时确认为准。')).toBeVisible();
+  484 |     await expect(page.getByText('库存 24 件')).toBeVisible();
+  485 | 
+  486 |     const productLink = page.getByRole('link', { name: 'Wireless Headphones' });
+  487 |     await expect(productLink).toHaveAttribute('href', /\/commerce\/zh-cn\/product\/\d+$/);
+  488 |     const productPath = await productLink.getAttribute('href');
+  489 |     const productResponse = await request.get(productPath!);
+  490 |     expect(productResponse.ok()).toBeTruthy();
+  491 |     expect((await productResponse.text()).toLowerCase()).not.toContain('data-zova-hydrated');
+  492 |     await productLink.click();
+  493 |     await expect(page).toHaveURL(/\/commerce\/zh-cn\/product\/\d+(?:\/|$)/);
+  494 |     await expect(page.getByRole('heading', { name: 'Wireless Headphones' })).toBeVisible();
+  495 |     await expect(page.getByText('HPH-BLK')).toBeVisible();
+  496 |     await expect(page.getByText('库存 24 件')).toBeVisible();
+  497 |     await expect(page.getByRole('link', { name: '购物车' })).toHaveAttribute(
+  498 |       'href',
+  499 |       '/commerce/commerce/trade/cart',
+  500 |     );
+  501 |     expect(pageErrors).toEqual([]);
+  502 |   },
+  503 | );
+  504 | 
+  505 | test(
+  506 |   'Commerce Product: Cart badge keeps SSR initial render neutral',
+  507 |   { tag: ['@web', '@cart'] },
+  508 |   async ({ page, request }) => {
+  509 |     const productPath = '/commerce/product/1';
+  510 |     const productResponse = await request.get(productPath);
+  511 |     expect(productResponse.ok()).toBeTruthy();
+  512 |     const productHtml = await productResponse.text();
+  513 |     expect(productHtml.toLowerCase()).not.toContain('data-zova-hydrated');
+  514 |     expect(productHtml).toContain('>Cart<!----></a>');
+  515 | 
+  516 |     const pageErrors = collectPageErrors(page);
+  517 |     const documentResponse = await page.goto(productPath, { waitUntil: 'load' });
+  518 |     expect(documentResponse?.ok()).toBeTruthy();
+  519 |     await expect(page.locator('html')).toHaveAttribute('data-zova-hydrated', 'commerce');
+  520 |     await expect(page).toHaveURL(productPath);
+  521 |     await expect(page.getByRole('heading', { name: 'Wireless Headphones' })).toBeVisible();
+  522 | 
+  523 |     const cartLink = page.locator('a[href="/commerce/commerce/trade/cart"]');
+  524 |     await expect(cartLink).toHaveCount(1);
+  525 |     await expect(cartLink.locator('.badge')).toHaveCount(0);
+  526 |     expect(pageErrors).toEqual([]);
+  527 |   },
+  528 | );
+  529 | 
+  530 | test(
+  531 |   'Commerce Address: session SSR protects an anonymous document request',
+  532 |   { tag: ['@web', '@cart'] },
+  533 |   async ({ page, request }) => {
+```