cabloy 5.1.159 → 5.1.160

package/test-results/a-commerce-ATP-ADDR-01-aut-11dea-ss-through-Web-self-service/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-ADDR-01: authenticated customer manages Address through Web self-service
+- Location: repo-e2e/specs/a-commerce.spec.ts:556: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-ATP-SPC-01-Coup-ef380-mantic-Admin-field-controls/error-context.md

@@ -0,0 +1,240 @@
+# 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-01: Coupon Template renders semantic Admin field controls
+- Location: repo-e2e/specs/a-commerce.spec.ts:1443:1
+
+# Error details
+
+```
+Error: expect(page).toHaveURL(expected) failed
+
+Expected pattern: /\/commerce-admin\/rest\/resource\/commerce-promotion(?:%3A|:|%253A)couponTemplate\/create(?:[/?#]|$)/
+Received string:  "http://127.0.0.1:7102/commerce-admin/home/base/errorAccessDenied"
+Timeout: 5000ms
+
+Call log:
+  - Expect "toHaveURL" with timeout 5000ms
+    2 × locator resolved to <html lang="en-us">…</html>
+      - unexpected value "http://127.0.0.1:7102/commerce-admin/home/base/errorAccessDenied"
+    12 × locator resolved to <html lang="en-us" data-zova-hydrated="commerceAdmin">…</html>
+       - unexpected value "http://127.0.0.1:7102/commerce-admin/home/base/errorAccessDenied"
+
+```
+
+```yaml
+- text: 403 Access denied.
+- button "Go Home"
+```
+
+# Test source
+
+```ts
+  1360 |       await expect(page.getByText('refunded · $45.99')).toBeVisible();
+  1361 |       await expect(page.getByText('1 × $45.99 = $45.99')).toBeVisible();
+  1362 |       await expect(page.getByRole('heading', { name: 'Shipment' })).toHaveCount(0);
+  1363 |       await expect(page.getByRole('alert')).toHaveCount(0);
+  1364 |       expect(pageErrors).toEqual([]);
+  1365 |     } finally {
+  1366 |       await context.close().catch(() => {});
+  1367 |     }
+  1368 |   },
+  1369 | );
+  1370 | 
+  1371 | test(
+  1372 |   'ATP-SPC-05: systemAdmin inspects readonly Address Resource without mutation controls',
+  1373 |   { tag: ['@admin', '@flow', '@address'] },
+  1374 |   async ({ browser, request }, testInfo) => {
+  1375 |     test.setTimeout(60_000);
+  1376 |     const customer = await createAddressThroughCustomerPage(browser, request, testInfo);
+  1377 |     const adminContext = await browser.newContext();
+  1378 |     const adminPage = await adminContext.newPage();
+  1379 |     const adminPageErrors = collectPageErrors(adminPage);
+  1380 |     const addressMutationMethods: string[] = [];
+  1381 |     adminPage.on('request', request => {
+  1382 |       const url = new URL(request.url());
+  1383 |       if (
+  1384 |         url.pathname.startsWith(addressActionPath) &&
+  1385 |         ['POST', 'PATCH', 'PUT', 'DELETE'].includes(request.method())
+  1386 |       ) {
+  1387 |         addressMutationMethods.push(request.method());
+  1388 |       }
+  1389 |     });
+  1390 | 
+  1391 |     try {
+  1392 |       await adminPage.setViewportSize({ width: 1440, height: 900 });
+  1393 |       await login(adminPage, '/commerce-admin/', 'admin', '123456', 'commerceAdmin');
+  1394 |       await adminPage.goto('/commerce-admin/rest/resource/commerce-member%3Aaddress', {
+  1395 |         waitUntil: 'load',
+  1396 |       });
+  1397 |       await expect(adminPage).toHaveURL(addressResourceUrl);
+  1398 |       const fixtureRow = adminPage.getByRole('row', { name: customer.fixture.recipientName });
+  1399 |       await expect(fixtureRow).toBeVisible();
+  1400 |       await expect(fixtureRow).toContainText(customer.fixture.recipientName);
+  1401 |       await expect(fixtureRow).toContainText(customer.fixture.phone);
+  1402 |       await expect(fixtureRow).toContainText(customer.fixture.countryCode);
+  1403 |       await expect(fixtureRow).toContainText(customer.fixture.city);
+  1404 |       await expect(fixtureRow).not.toContainText(customer.fixture.region);
+  1405 |       await expect(fixtureRow).not.toContainText(customer.fixture.postalCode);
+  1406 |       await expect(fixtureRow).not.toContainText(customer.fixture.addressLine1);
+  1407 |       await expect(fixtureRow).not.toContainText(customer.fixture.addressLine2);
+  1408 |       await expect(adminPage.getByRole('button', { name: 'Create', exact: true })).toHaveCount(0);
+  1409 |       await expect(
+  1410 |         adminPage.locator('a[href*="/rest/resource/"]').filter({ hasText: 'Create' }),
+  1411 |       ).toHaveCount(0);
+  1412 | 
+  1413 |       const addressId = await fixtureRow.getByRole('cell').first().textContent();
+  1414 |       expect(addressId).toMatch(/^\d+$/);
+  1415 |       await expect(fixtureRow.getByRole('link', { name: addressId! })).toHaveCount(1);
+  1416 |       await adminPage.goto(`/commerce-admin/rest/resource/commerce-member%3Aaddress/${addressId}`, {
+  1417 |         waitUntil: 'load',
+  1418 |       });
+  1419 |       await expect(adminPage).toHaveURL(
+  1420 |         /\/commerce-admin\/rest\/resource\/commerce-member(?:%3A|:|%253A)address\/\d+(?:[/?#]|$)/,
+  1421 |       );
+  1422 |       await expect(
+  1423 |         adminPage.getByRole('group', { name: 'Address Line 1 *' }).getByRole('textbox'),
+  1424 |       ).toHaveValue(customer.fixture.addressLine1);
+  1425 |       await expect(
+  1426 |         adminPage.getByRole('group', { name: 'City *' }).getByRole('textbox'),
+  1427 |       ).toHaveValue(customer.fixture.city);
+  1428 |       await expect(adminPage.getByRole('button', { name: 'Back', exact: true })).toBeVisible();
+  1429 |       await expect(adminPage.getByRole('button', { name: 'Submit', exact: true })).toHaveCount(0);
+  1430 |       expect(addressMutationMethods).toEqual([]);
+  1431 |       expect(adminPageErrors).toEqual([]);
+  1432 | 
+  1433 |       await deleteAddressThroughCustomerPage(customer.page, customer.fixture);
+  1434 |       await expect(customer.page.getByRole('alert')).toHaveCount(0);
+  1435 |       expect(customer.pageErrors).toEqual([]);
+  1436 |     } finally {
+  1437 |       await adminContext.close().catch(() => {});
+  1438 |       await customer.context.close().catch(() => {});
+  1439 |     }
+  1440 |   },
+  1441 | );
+  1442 | 
+  1443 | test(
+  1444 |   'ATP-SPC-01: Coupon Template renders semantic Admin field controls',
+  1445 |   { tag: ['@admin', '@flow', '@fia'] },
+  1446 |   async ({ browser }) => {
+  1447 |     test.setTimeout(60_000);
+  1448 |     const adminContext = await browser.newContext();
+  1449 |     const adminPage = await adminContext.newPage();
+  1450 |     const adminPageErrors = collectPageErrors(adminPage);
+  1451 |     try {
+  1452 |       await adminPage.setViewportSize({ width: 1440, height: 900 });
+  1453 |       await login(adminPage, '/commerce-admin/', 'admin', '123456', 'commerceAdmin');
+  1454 |       await adminPage.goto(
+  1455 |         '/commerce-admin/rest/resource/commerce-promotion%3AcouponTemplate/create',
+  1456 |         {
+  1457 |           waitUntil: 'load',
+  1458 |         },
+  1459 |       );
+> 1460 |       await expect(adminPage).toHaveURL(
+       |                               ^ Error: expect(page).toHaveURL(expected) failed
+  1461 |         /\/commerce-admin\/rest\/resource\/commerce-promotion(?:%3A|:|%253A)couponTemplate\/create(?:[/?#]|$)/,
+  1462 |       );
+  1463 | 
+  1464 |       for (const groupName of [
+  1465 |         'Basic Information',
+  1466 |         'Discount Policy',
+  1467 |         'Validity Window',
+  1468 |         'Usage Limits',
+  1469 |       ]) {
+  1470 |         await expect(adminPage.getByRole('group', { name: groupName })).toBeVisible();
+  1471 |       }
+  1472 | 
+  1473 |       const state = adminPage
+  1474 |         .getByRole('group', { name: 'Template State *' })
+  1475 |         .getByRole('combobox');
+  1476 |       await expect(state).toBeVisible();
+  1477 |       await state.selectOption({ label: 'Active' });
+  1478 |       await expect(state).toHaveValue('active');
+  1479 | 
+  1480 |       const discountInput = adminPage
+  1481 |         .getByRole('group', { name: 'Fixed Discount *' })
+  1482 |         .getByRole('textbox');
+  1483 |       const minSpendInput = adminPage
+  1484 |         .getByRole('group', { name: 'Minimum Spend *' })
+  1485 |         .getByRole('textbox');
+  1486 |       await discountInput.fill('12.34');
+  1487 |       await minSpendInput.fill('45.67');
+  1488 |       await expect(discountInput).toHaveValue('12.34');
+  1489 |       await expect(minSpendInput).toHaveValue('45.67');
+  1490 |       await expect(
+  1491 |         adminPage.getByRole('group', { name: 'Valid From *' }).locator('input[type="date"]'),
+  1492 |       ).toBeVisible();
+  1493 |       await expect(
+  1494 |         adminPage.getByRole('group', { name: 'Valid Until *' }).locator('input[type="date"]'),
+  1495 |       ).toBeVisible();
+  1496 | 
+  1497 |       await adminPage
+  1498 |         .getByRole('group', { name: 'Name *' })
+  1499 |         .getByRole('textbox')
+  1500 |         .fill('E2E Coupon Template');
+  1501 |       await adminPage.getByRole('group', { name: 'Currency *' }).getByRole('textbox').fill('USD');
+  1502 |       await adminPage
+  1503 |         .getByRole('group', { name: 'Valid From *' })
+  1504 |         .getByRole('textbox')
+  1505 |         .fill('2026-08-04');
+  1506 |       await adminPage
+  1507 |         .getByRole('group', { name: 'Valid Until *' })
+  1508 |         .getByRole('textbox')
+  1509 |         .fill('2026-12-31');
+  1510 |       await adminPage
+  1511 |         .getByRole('group', { name: 'Total Issue Limit' })
+  1512 |         .getByRole('textbox')
+  1513 |         .fill('10');
+  1514 |       await adminPage
+  1515 |         .getByRole('group', { name: 'Total Usage Limit' })
+  1516 |         .getByRole('textbox')
+  1517 |         .fill('10');
+  1518 |       await adminPage
+  1519 |         .getByRole('group', { name: 'Per-customer Issue Limit' })
+  1520 |         .getByRole('textbox')
+  1521 |         .fill('1');
+  1522 | 
+  1523 |       await expect(adminPage.getByRole('button', { name: 'Submit', exact: true })).toBeVisible();
+  1524 |       await expect(adminPage.getByRole('button', { name: 'Back', exact: true })).toBeVisible();
+  1525 |       expect(adminPageErrors).toEqual([]);
+  1526 |     } finally {
+  1527 |       await adminContext.close().catch(() => {});
+  1528 |     }
+  1529 |   },
+  1530 | );
+  1531 | 
+  1532 | test(
+  1533 |   'ATP-SPC-02: Category renders semantic Admin relation and publication controls',
+  1534 |   { tag: ['@admin', '@flow', '@category'] },
+  1535 |   async ({ browser }, testInfo) => {
+  1536 |     test.setTimeout(60_000);
+  1537 |     const suffix = `${testInfo.workerIndex}-${testInfo.parallelIndex ?? testInfo.retry}-${Date.now()}`;
+  1538 |     const parentName = `E2E Category Parent ${suffix}`;
+  1539 |     const childName = `E2E Category Child ${suffix}`;
+  1540 |     const adminContext = await browser.newContext();
+  1541 |     const adminPage = await adminContext.newPage();
+  1542 |     const adminPageErrors = collectPageErrors(adminPage);
+  1543 |     const categoryCreatePath = '/commerce-admin/rest/resource/commerce-catalog%3Acategory/create';
+  1544 |     const categoryListPath = '/commerce-admin/rest/resource/commerce-catalog%3Acategory';
+  1545 |     const categoryActionPath = '/api/commerce/catalog/category';
+  1546 |     let parentId: number | string | undefined;
+  1547 |     let childId: number | string | undefined;
+  1548 |     let headers: { Authorization: string } | undefined;
+  1549 |     try {
+  1550 |       await adminPage.setViewportSize({ width: 1440, height: 900 });
+  1551 |       await login(adminPage, '/commerce-admin/', 'admin', '123456', 'commerceAdmin');
+  1552 |       const accessToken = (await adminContext.cookies()).find(
+  1553 |         cookie => cookie.name === 'token',
+  1554 |       )?.value;
+  1555 |       expect(accessToken).toBeTruthy();
+  1556 |       headers = { Authorization: `Bearer ${accessToken}` };
+  1557 | 
+  1558 |       const parentCreateResponse = await adminPage.request.post(categoryActionPath, {
+  1559 |         data: { name: parentName, published: false },
+  1560 |         headers,
+```