cabloy 5.1.159 → 5.1.160

package/test-results/a-commerce-ATP-SPC-02-Cate-9f120-on-and-publication-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-02: Category renders semantic Admin relation and publication controls
+- Location: repo-e2e/specs/a-commerce.spec.ts:1532:1
+
+# Error details
+
+```
+Error: expect(locator).toBeVisible() failed
+
+Locator: getByRole('group', { name: 'Published' }).getByRole('combobox')
+Expected: visible
+Timeout: 5000ms
+Error: element(s) not found
+
+Call log:
+  - Expect "toBeVisible" with timeout 5000ms
+  - waiting for getByRole('group', { name: 'Published' }).getByRole('combobox')
+
+```
+
+```yaml
+- text: 403 Access denied.
+- button "Go Home"
+```
+
+# Test source
+
+```ts
+  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,
+  1561 |       });
+  1562 |       expect(parentCreateResponse.ok()).toBeTruthy();
+  1563 |       parentId = (await parentCreateResponse.json()).data;
+  1564 |       expectTableIdentity(parentId);
+  1565 | 
+  1566 |       await adminPage.goto(categoryCreatePath, { waitUntil: 'load' });
+  1567 |       const parentPublication = adminPage
+  1568 |         .getByRole('group', { name: 'Published' })
+  1569 |         .getByRole('combobox');
+> 1570 |       await expect(parentPublication).toBeVisible();
+       |                                       ^ Error: expect(locator).toBeVisible() failed
+  1571 |       await expect(parentPublication.locator('option')).toHaveText([
+  1572 |         '',
+  1573 |         'Unpublished',
+  1574 |         'Published',
+  1575 |       ]);
+  1576 |       await parentPublication.selectOption({ label: 'Unpublished' });
+  1577 |       await expect(parentPublication).toHaveValue('false');
+  1578 | 
+  1579 |       const parentPicker = adminPage
+  1580 |         .getByRole('group', { name: 'Parent category' })
+  1581 |         .getByRole('combobox');
+  1582 |       await expect(parentPicker).toBeVisible();
+  1583 |       await parentPicker.selectOption({ label: parentName });
+  1584 |       const parentValue = await parentPicker.inputValue();
+  1585 |       expect(parentValue).toBe(String(parentId));
+  1586 |       const childPublication = adminPage
+  1587 |         .getByRole('group', { name: 'Published' })
+  1588 |         .getByRole('combobox');
+  1589 |       await childPublication.selectOption({ label: 'Published' });
+  1590 |       await expect(childPublication).toHaveValue('true');
+  1591 | 
+  1592 |       const childCreateResponse = await adminPage.request.post(categoryActionPath, {
+  1593 |         data: { name: childName, parentId: parentValue, published: true },
+  1594 |         headers,
+  1595 |       });
+  1596 |       expect(childCreateResponse.ok()).toBeTruthy();
+  1597 |       childId = (await childCreateResponse.json()).data;
+  1598 |       expectTableIdentity(childId);
+  1599 | 
+  1600 |       await adminPage.goto(categoryListPath, { waitUntil: 'load' });
+  1601 |       const childRow = adminPage.getByRole('row', { name: new RegExp(childName) });
+  1602 |       await expect(childRow).toBeVisible();
+  1603 |       await expect(childRow.getByText(parentName, { exact: true })).toBeVisible();
+  1604 |       await expect(childRow.getByText('Published', { exact: true })).toBeVisible();
+  1605 | 
+  1606 |       await adminPage.goto(`${categoryListPath}/${parentId}/edit`, { waitUntil: 'load' });
+  1607 |       await expect(
+  1608 |         adminPage.getByRole('group', { name: 'Published' }).getByRole('combobox'),
+  1609 |       ).toHaveValue('false');
+  1610 | 
+  1611 |       await adminPage.goto(`${categoryListPath}/${childId}/edit`, { waitUntil: 'load' });
+  1612 |       await expect(
+  1613 |         adminPage.getByRole('group', { name: 'Published' }).getByRole('combobox'),
+  1614 |       ).toHaveValue('true');
+  1615 | 
+  1616 |       await adminPage.goto(`${categoryListPath}/${childId}`, { waitUntil: 'load' });
+  1617 |       await expect(
+  1618 |         adminPage.getByRole('group', { name: 'Parent category' }).getByRole('textbox'),
+  1619 |       ).toHaveValue(parentName);
+  1620 |       await expect(
+  1621 |         adminPage.getByRole('group', { name: 'Published' }).getByRole('textbox'),
+  1622 |       ).toHaveValue('Published');
+  1623 |       await expect(adminPage.getByRole('button', { name: 'Submit', exact: true })).toHaveCount(0);
+  1624 |       expect(adminPageErrors).toEqual([]);
+  1625 |     } finally {
+  1626 |       if (childId && headers) {
+  1627 |         const response = await adminPage.request.delete(`${categoryActionPath}/${childId}`, {
+  1628 |           headers,
+  1629 |         });
+  1630 |         expect(response.ok()).toBeTruthy();
+  1631 |       }
+  1632 |       if (parentId && headers) {
+  1633 |         const response = await adminPage.request.delete(`${categoryActionPath}/${parentId}`, {
+  1634 |           headers,
+  1635 |         });
+  1636 |         expect(response.ok()).toBeTruthy();
+  1637 |       }
+  1638 |       await adminContext.close().catch(() => {});
+  1639 |     }
+  1640 |   },
+  1641 | );
+  1642 | 
+  1643 | test(
+  1644 |   'ATP-SPC-02: Product renders semantic Admin relation and publication controls',
+  1645 |   { tag: ['@admin', '@flow', '@product'] },
+  1646 |   async ({ browser }, testInfo) => {
+  1647 |     test.setTimeout(60_000);
+  1648 |     const suffix = `${testInfo.workerIndex}-${testInfo.parallelIndex ?? testInfo.retry}-${Date.now()}`;
+  1649 |     const categoryName = `E2E Product Category ${suffix}`;
+  1650 |     const productTitle = `E2E Product ${suffix}`;
+  1651 |     const adminContext = await browser.newContext();
+  1652 |     const adminPage = await adminContext.newPage();
+  1653 |     const adminPageErrors = collectPageErrors(adminPage);
+  1654 |     const productCreatePath = '/commerce-admin/rest/resource/commerce-catalog%3Aproduct/create';
+  1655 |     const productListPath = '/commerce-admin/rest/resource/commerce-catalog%3Aproduct';
+  1656 |     const categoryActionPath = '/api/commerce/catalog/category';
+  1657 |     const productActionPath = '/api/commerce/catalog/product';
+  1658 |     let categoryId: number | string | undefined;
+  1659 |     let productId: number | string | undefined;
+  1660 |     let headers: { Authorization: string } | undefined;
+  1661 |     try {
+  1662 |       await adminPage.setViewportSize({ width: 1440, height: 900 });
+  1663 |       await login(adminPage, '/commerce-admin/', 'admin', '123456', 'commerceAdmin');
+  1664 |       const accessToken = (await adminContext.cookies()).find(
+  1665 |         cookie => cookie.name === 'token',
+  1666 |       )?.value;
+  1667 |       expect(accessToken).toBeTruthy();
+  1668 |       headers = { Authorization: `Bearer ${accessToken}` };
+  1669 | 
+  1670 |       const categoryResponse = await adminPage.request.post(categoryActionPath, {
+```

package/test-results/a-commerce-ATP-SPC-02-Prod-5f92a-on-and-publication-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-02: Product renders semantic Admin relation and publication controls
+- Location: repo-e2e/specs/a-commerce.spec.ts:1643:1
+
+# Error details
+
+```
+Error: expect(locator).toBeVisible() failed
+
+Locator: getByRole('group', { name: 'Category' }).getByRole('combobox')
+Expected: visible
+Timeout: 5000ms
+Error: element(s) not found
+
+Call log:
+  - Expect "toBeVisible" with timeout 5000ms
+  - waiting for getByRole('group', { name: 'Category' }).getByRole('combobox')
+
+```
+
+```yaml
+- text: 403 Access denied.
+- button "Go Home"
+```
+
+# Test source
+
+```ts
+  1582 |       await expect(parentPicker).toBeVisible();
+  1583 |       await parentPicker.selectOption({ label: parentName });
+  1584 |       const parentValue = await parentPicker.inputValue();
+  1585 |       expect(parentValue).toBe(String(parentId));
+  1586 |       const childPublication = adminPage
+  1587 |         .getByRole('group', { name: 'Published' })
+  1588 |         .getByRole('combobox');
+  1589 |       await childPublication.selectOption({ label: 'Published' });
+  1590 |       await expect(childPublication).toHaveValue('true');
+  1591 | 
+  1592 |       const childCreateResponse = await adminPage.request.post(categoryActionPath, {
+  1593 |         data: { name: childName, parentId: parentValue, published: true },
+  1594 |         headers,
+  1595 |       });
+  1596 |       expect(childCreateResponse.ok()).toBeTruthy();
+  1597 |       childId = (await childCreateResponse.json()).data;
+  1598 |       expectTableIdentity(childId);
+  1599 | 
+  1600 |       await adminPage.goto(categoryListPath, { waitUntil: 'load' });
+  1601 |       const childRow = adminPage.getByRole('row', { name: new RegExp(childName) });
+  1602 |       await expect(childRow).toBeVisible();
+  1603 |       await expect(childRow.getByText(parentName, { exact: true })).toBeVisible();
+  1604 |       await expect(childRow.getByText('Published', { exact: true })).toBeVisible();
+  1605 | 
+  1606 |       await adminPage.goto(`${categoryListPath}/${parentId}/edit`, { waitUntil: 'load' });
+  1607 |       await expect(
+  1608 |         adminPage.getByRole('group', { name: 'Published' }).getByRole('combobox'),
+  1609 |       ).toHaveValue('false');
+  1610 | 
+  1611 |       await adminPage.goto(`${categoryListPath}/${childId}/edit`, { waitUntil: 'load' });
+  1612 |       await expect(
+  1613 |         adminPage.getByRole('group', { name: 'Published' }).getByRole('combobox'),
+  1614 |       ).toHaveValue('true');
+  1615 | 
+  1616 |       await adminPage.goto(`${categoryListPath}/${childId}`, { waitUntil: 'load' });
+  1617 |       await expect(
+  1618 |         adminPage.getByRole('group', { name: 'Parent category' }).getByRole('textbox'),
+  1619 |       ).toHaveValue(parentName);
+  1620 |       await expect(
+  1621 |         adminPage.getByRole('group', { name: 'Published' }).getByRole('textbox'),
+  1622 |       ).toHaveValue('Published');
+  1623 |       await expect(adminPage.getByRole('button', { name: 'Submit', exact: true })).toHaveCount(0);
+  1624 |       expect(adminPageErrors).toEqual([]);
+  1625 |     } finally {
+  1626 |       if (childId && headers) {
+  1627 |         const response = await adminPage.request.delete(`${categoryActionPath}/${childId}`, {
+  1628 |           headers,
+  1629 |         });
+  1630 |         expect(response.ok()).toBeTruthy();
+  1631 |       }
+  1632 |       if (parentId && headers) {
+  1633 |         const response = await adminPage.request.delete(`${categoryActionPath}/${parentId}`, {
+  1634 |           headers,
+  1635 |         });
+  1636 |         expect(response.ok()).toBeTruthy();
+  1637 |       }
+  1638 |       await adminContext.close().catch(() => {});
+  1639 |     }
+  1640 |   },
+  1641 | );
+  1642 | 
+  1643 | test(
+  1644 |   'ATP-SPC-02: Product renders semantic Admin relation and publication controls',
+  1645 |   { tag: ['@admin', '@flow', '@product'] },
+  1646 |   async ({ browser }, testInfo) => {
+  1647 |     test.setTimeout(60_000);
+  1648 |     const suffix = `${testInfo.workerIndex}-${testInfo.parallelIndex ?? testInfo.retry}-${Date.now()}`;
+  1649 |     const categoryName = `E2E Product Category ${suffix}`;
+  1650 |     const productTitle = `E2E Product ${suffix}`;
+  1651 |     const adminContext = await browser.newContext();
+  1652 |     const adminPage = await adminContext.newPage();
+  1653 |     const adminPageErrors = collectPageErrors(adminPage);
+  1654 |     const productCreatePath = '/commerce-admin/rest/resource/commerce-catalog%3Aproduct/create';
+  1655 |     const productListPath = '/commerce-admin/rest/resource/commerce-catalog%3Aproduct';
+  1656 |     const categoryActionPath = '/api/commerce/catalog/category';
+  1657 |     const productActionPath = '/api/commerce/catalog/product';
+  1658 |     let categoryId: number | string | undefined;
+  1659 |     let productId: number | string | undefined;
+  1660 |     let headers: { Authorization: string } | undefined;
+  1661 |     try {
+  1662 |       await adminPage.setViewportSize({ width: 1440, height: 900 });
+  1663 |       await login(adminPage, '/commerce-admin/', 'admin', '123456', 'commerceAdmin');
+  1664 |       const accessToken = (await adminContext.cookies()).find(
+  1665 |         cookie => cookie.name === 'token',
+  1666 |       )?.value;
+  1667 |       expect(accessToken).toBeTruthy();
+  1668 |       headers = { Authorization: `Bearer ${accessToken}` };
+  1669 | 
+  1670 |       const categoryResponse = await adminPage.request.post(categoryActionPath, {
+  1671 |         data: { name: categoryName, published: true },
+  1672 |         headers,
+  1673 |       });
+  1674 |       expect(categoryResponse.ok()).toBeTruthy();
+  1675 |       categoryId = (await categoryResponse.json()).data;
+  1676 |       expectTableIdentity(categoryId);
+  1677 | 
+  1678 |       await adminPage.goto(productCreatePath, { waitUntil: 'load' });
+  1679 |       const categoryPicker = adminPage
+  1680 |         .getByRole('group', { name: 'Category' })
+  1681 |         .getByRole('combobox');
+> 1682 |       await expect(categoryPicker).toBeVisible();
+       |                                    ^ Error: expect(locator).toBeVisible() failed
+  1683 |       await categoryPicker.selectOption({ label: categoryName });
+  1684 |       await expect(categoryPicker).toHaveValue(String(categoryId));
+  1685 |       const publication = adminPage.getByRole('group', { name: 'Published' }).getByRole('combobox');
+  1686 |       await expect(publication).toBeVisible();
+  1687 |       await publication.selectOption({ label: 'Unpublished' });
+  1688 |       await expect(publication).toHaveValue('false');
+  1689 | 
+  1690 |       const productResponse = await adminPage.request.post(productActionPath, {
+  1691 |         data: { categoryId, title: productTitle, published: false },
+  1692 |         headers,
+  1693 |       });
+  1694 |       expect(productResponse.ok()).toBeTruthy();
+  1695 |       productId = (await productResponse.json()).data;
+  1696 |       expectTableIdentity(productId);
+  1697 | 
+  1698 |       await adminPage.goto(productListPath, { waitUntil: 'load' });
+  1699 |       const productRow = adminPage.getByRole('row', { name: new RegExp(productTitle) });
+  1700 |       await expect(productRow).toBeVisible();
+  1701 |       await expect(productRow.getByText(categoryName, { exact: true })).toBeVisible();
+  1702 |       await expect(productRow.getByText('Unpublished', { exact: true })).toBeVisible();
+  1703 | 
+  1704 |       await adminPage.goto(`${productListPath}/${productId}`, { waitUntil: 'load' });
+  1705 |       await expect(
+  1706 |         adminPage.getByRole('group', { name: 'Category' }).getByRole('textbox'),
+  1707 |       ).toHaveValue(categoryName);
+  1708 |       await expect(
+  1709 |         adminPage.getByRole('group', { name: 'Published' }).getByRole('textbox'),
+  1710 |       ).toHaveValue('Unpublished');
+  1711 |       await expect(adminPage.getByRole('button', { name: 'Submit', exact: true })).toHaveCount(0);
+  1712 |       expect(adminPageErrors).toEqual([]);
+  1713 |     } finally {
+  1714 |       if (productId && headers) {
+  1715 |         const response = await adminPage.request.delete(`${productActionPath}/${productId}`, {
+  1716 |           headers,
+  1717 |         });
+  1718 |         expect(response.ok()).toBeTruthy();
+  1719 |       }
+  1720 |       if (categoryId && headers) {
+  1721 |         const response = await adminPage.request.delete(`${categoryActionPath}/${categoryId}`, {
+  1722 |           headers,
+  1723 |         });
+  1724 |         expect(response.ok()).toBeTruthy();
+  1725 |       }
+  1726 |       await adminContext.close().catch(() => {});
+  1727 |     }
+  1728 |   },
+  1729 | );
+  1730 | 
+  1731 | test(
+  1732 |   'ATP-SPC-02: SKU renders semantic Admin currency and lifecycle controls',
+  1733 |   { tag: ['@admin', '@flow', '@sku'] },
+  1734 |   async ({ browser }, testInfo) => {
+  1735 |     test.setTimeout(60_000);
+  1736 |     const suffix = `${testInfo.workerIndex}-${testInfo.parallelIndex ?? testInfo.retry}-${Date.now()}`;
+  1737 |     const categoryName = `E2E SKU Category ${suffix}`;
+  1738 |     const productTitle = `E2E SKU Product ${suffix}`;
+  1739 |     const skuCode = `E2E-SKU-${suffix}`;
+  1740 |     const stockActionPath = '/api/commerce/trade/stockBalance/adjustStock';
+  1741 |     const adminContext = await browser.newContext();
+  1742 |     const adminPage = await adminContext.newPage();
+  1743 |     const adminPageErrors = collectPageErrors(adminPage);
+  1744 |     const skuCreatePath = '/commerce-admin/rest/resource/commerce-catalog%3Asku/create';
+  1745 |     const skuListPath = '/commerce-admin/rest/resource/commerce-catalog%3Asku';
+  1746 |     const categoryActionPath = '/api/commerce/catalog/category';
+  1747 |     const productActionPath = '/api/commerce/catalog/product';
+  1748 |     const skuActionPath = '/api/commerce/catalog/sku';
+  1749 |     let categoryId: number | string | undefined;
+  1750 |     let productId: number | string | undefined;
+  1751 |     let skuId: number | string | undefined;
+  1752 |     let headers: { Authorization: string } | undefined;
+  1753 |     try {
+  1754 |       await adminPage.setViewportSize({ width: 1440, height: 900 });
+  1755 |       await login(adminPage, '/commerce-admin/', 'admin', '123456', 'commerceAdmin');
+  1756 |       const accessToken = (await adminContext.cookies()).find(
+  1757 |         cookie => cookie.name === 'token',
+  1758 |       )?.value;
+  1759 |       expect(accessToken).toBeTruthy();
+  1760 |       headers = { Authorization: `Bearer ${accessToken}` };
+  1761 | 
+  1762 |       const categoryResponse = await adminPage.request.post(categoryActionPath, {
+  1763 |         data: { name: categoryName, published: true },
+  1764 |         headers,
+  1765 |       });
+  1766 |       expect(categoryResponse.ok()).toBeTruthy();
+  1767 |       categoryId = (await categoryResponse.json()).data;
+  1768 |       expectTableIdentity(categoryId);
+  1769 | 
+  1770 |       const productResponse = await adminPage.request.post(productActionPath, {
+  1771 |         data: { categoryId, title: productTitle, published: true },
+  1772 |         headers,
+  1773 |       });
+  1774 |       expect(productResponse.ok()).toBeTruthy();
+  1775 |       productId = (await productResponse.json()).data;
+  1776 |       expectTableIdentity(productId);
+  1777 | 
+  1778 |       await adminPage.goto(skuCreatePath, { waitUntil: 'load' });
+  1779 |       const productField = adminPage.getByRole('group', { name: 'Product' });
+  1780 |       await expect(productField).toBeVisible();
+  1781 |       const productPicker = productField.getByRole('combobox');
+  1782 |       await expect(productPicker).toBeVisible();
+```