cabloy 5.1.141 → 5.1.142

package/e2e/specs/{a-commerce/commerce.spec.ts → a-commerce.spec.ts}

@@ -153,15 +153,19 @@ function createAddressFixture(testInfo: TestInfo): IAddressFixture {
   };
 }
 
+function getAddressTextbox(page: Page, name: string): Locator {
+  return page.getByRole('group', { name, exact: true }).getByRole('textbox');
+}
+
 async function fillAddressForm(page: Page, fixture: IAddressFixture) {
-  await page.getByPlaceholder('Recipient name').fill(fixture.recipientName);
-  await page.getByPlaceholder('Phone').fill(fixture.phone);
-  await page.getByPlaceholder('Country code').fill(fixture.countryCode);
-  await page.getByPlaceholder('Region').fill(fixture.region);
-  await page.getByPlaceholder('City').fill(fixture.city);
-  await page.getByPlaceholder('Postal code').fill(fixture.postalCode);
-  await page.getByPlaceholder('Address line 1').fill(fixture.addressLine1);
-  await page.getByPlaceholder('Address line 2').fill(fixture.addressLine2);
+  await getAddressTextbox(page, 'Recipient Name *').fill(fixture.recipientName);
+  await getAddressTextbox(page, 'Phone *').fill(fixture.phone);
+  await getAddressTextbox(page, 'Country Code *').fill(fixture.countryCode);
+  await getAddressTextbox(page, 'Region *').fill(fixture.region);
+  await getAddressTextbox(page, 'City *').fill(fixture.city);
+  await getAddressTextbox(page, 'Postal Code *').fill(fixture.postalCode);
+  await getAddressTextbox(page, 'Address Line 1 *').fill(fixture.addressLine1);
+  await getAddressTextbox(page, 'Address Line 2').fill(fixture.addressLine2);
 }
 
 async function createAddressThroughCustomerPage(
@@ -593,8 +597,9 @@ test(
         .filter({ has: page.getByRole('heading', { name: fixture.recipientName }) });
       await card.getByRole('button', { name: 'Edit', exact: true }).click();
       await expect(page.getByRole('heading', { name: 'Add address' })).toHaveCount(0);
-      await expect(page.getByPlaceholder('City')).toHaveValue(fixture.city);
-      await page.getByPlaceholder('City').fill(fixture.updatedCity);
+      const cityTextbox = getAddressTextbox(page, 'City *');
+      await expect(cityTextbox).toHaveValue(fixture.city);
+      await cityTextbox.fill(fixture.updatedCity);
 
       const updateResponse = waitForAddressResponse(page, 'PATCH', /\/updateMine\/[^/]+$/);
       const mineResponse = waitForAddressMine(page);
@@ -707,7 +712,7 @@ test(
       const orderHtml = await orderResponse.text();
       expect(orderHtml.toLowerCase()).not.toContain('data-zova-hydrated');
       expect(orderHtml).toContain(`Order #${checkout.orderId}`);
-      expect(orderHtml).toContain('paid · $45.99');
+      expect(orderHtml).toContain('Paid · $45.99');
       expect(orderHtml).toContain('USD');
       expect(orderHtml).toContain(fixture.recipientName);
       expect(orderHtml).toContain(fixture.addressLine1);
@@ -1194,11 +1199,12 @@ test(
       await page.getByPlaceholder('Reason for refund').fill('E2E refund request');
       await page.getByRole('button', { name: 'Request refund', exact: true }).click();
       expect((await requestResponse).ok()).toBeTruthy();
-      await expect(page.getByText('refund_requested · $45.99')).toBeVisible();
+      await expect(page.getByText('Refund requested · $45.99')).toBeVisible();
 
       const adminContext = await browser.newContext();
       const adminPage = await adminContext.newPage();
       const adminPageErrors = collectPageErrors(adminPage);
+      const adminConsoleErrors = collectConsoleErrors(adminPage);
       try {
         await adminPage.setViewportSize({ width: 1440, height: 900 });
         await login(adminPage, '/commerce-admin/', 'admin', '123456', 'commerceAdmin');
@@ -1211,28 +1217,87 @@ test(
         );
         const orderRow = await getAdminOrderRow(adminPage, checkout.orderId);
         await expect(orderRow).toBeVisible();
-        await orderRow.getByPlaceholder('Decision reason').fill('E2E approval');
-        await orderRow.getByRole('checkbox').check();
+        await expect(
+          orderRow.getByRole('button', { name: 'Review refund', exact: true }),
+        ).toBeVisible();
+        await expect(
+          orderRow.getByRole('button', { name: 'Approve refund', exact: true }),
+        ).toHaveCount(0);
+        await expect(
+          orderRow.getByRole('button', { name: 'Reject refund', exact: true }),
+        ).toHaveCount(0);
+        await orderRow.getByRole('button', { name: 'Review refund', exact: true }).click();
+        const refundDecisionTitle = adminPage.getByRole('heading', { name: 'Refund decision' });
+        await expect(refundDecisionTitle).toBeVisible();
+        await adminPage.getByPlaceholder('Decision reason').fill('E2E approval');
+        await adminPage.locator('input[name="decisionConfirmed"]').check();
         const approveResponse = waitForApiResponse(
           adminPage,
           'POST',
           `/api/commerce/trade/order/${checkout.orderId}/approveRefund`,
         );
-        await orderRow.getByRole('button', { name: 'Approve refund', exact: true }).click();
+        await adminPage.getByRole('button', { name: 'Approve refund', exact: true }).click();
         expect((await approveResponse).ok()).toBeTruthy();
+        await expect(refundDecisionTitle).toHaveCount(0);
         await expect(orderRow).toContainText('Refund approved');
+        await expect(
+          orderRow.getByRole('button', { name: 'Execute refund', exact: true }),
+        ).toHaveCount(1);
+        await expect(
+          orderRow.getByRole('button', { name: 'Inspect refund recovery', exact: true }),
+        ).toHaveCount(0);
+        await expect(orderRow.getByRole('checkbox')).toHaveCount(0);
+        await orderRow.getByRole('button', { name: 'Execute refund', exact: true }).click();
+        const refundExecutionTitle = adminPage.getByRole('heading', { name: 'Refund execution' });
+        await expect(refundExecutionTitle).toBeVisible();
+        const refundExecutionDialog = adminPage
+          .locator('div.card')
+          .filter({ has: refundExecutionTitle });
+        const executionButton = refundExecutionDialog.getByRole('button', {
+          name: 'Execute refund',
+          exact: true,
+        });
+        await expect(executionButton).toBeDisabled();
+        const unavailableRecoveryResponse = waitForApiResponse(
+          adminPage,
+          'GET',
+          `/api/commerce/trade/order/${checkout.orderId}/refundRecovery`,
+        );
+        await refundExecutionDialog
+          .getByRole('button', { name: 'Inspect refund recovery', exact: true })
+          .click();
+        expect((await unavailableRecoveryResponse).status()).toBe(404);
+        await expect(
+          refundExecutionDialog.getByText(
+            'Refund recovery is not available yet. Execute the refund first to create a provider refund submission.',
+          ),
+        ).toBeVisible();
+        await expect(refundExecutionDialog.getByText(/Provider operation:/)).toHaveCount(0);
+        await expect(refundExecutionDialog.getByPlaceholder('Recovery reason')).toHaveCount(0);
+        await expect(
+          refundExecutionDialog.getByRole('button', {
+            name: 'Reconcile provider refund',
+            exact: true,
+          }),
+        ).toHaveCount(0);
+        await expect(
+          refundExecutionDialog.getByRole('button', { name: 'Retry refund', exact: true }),
+        ).toHaveCount(0);
+        expect(
+          adminConsoleErrors.filter(error =>
+            /refund recovery is not available|AxiosError/i.test(error),
+          ),
+        ).toEqual([]);
+        await refundExecutionDialog.locator('input[name="executionConfirmed"]').check();
         const executeResponse = waitForApiResponse(
           adminPage,
           'POST',
           `/api/commerce/trade/order/${checkout.orderId}/executeRefund`,
         );
-        await orderRow.getByRole('button', { name: 'Execute refund', exact: true }).click();
+        await executionButton.click();
         const executeResponseValue = await executeResponse;
         expect(executeResponseValue.ok()).toBeTruthy();
         const executeResult = (await executeResponseValue.json()).data;
-        const authorization = executeResponseValue.request().headers()['authorization'];
-        expect(authorization).toMatch(/^Bearer /);
-        const authHeaders = { Authorization: authorization };
         expectTableIdentity(executeResult.refundAttemptId);
         expectTableIdentity(executeResult.refundOperationId);
         expect([
@@ -1240,11 +1305,39 @@ test(
           executeResult.refundState,
           executeResult.refundAttemptState,
         ]).toEqual(['refund_approved', 'approved', 'created']);
-        const completeRefundResponse = await adminPage.request.post(
+        await expect(refundExecutionTitle).toHaveCount(0);
+        await orderRow.getByRole('button', { name: 'Execute refund', exact: true }).click();
+        await expect(refundExecutionTitle).toBeVisible();
+        const recoveryResponse = waitForApiResponse(
+          adminPage,
+          'GET',
+          `/api/commerce/trade/order/${checkout.orderId}/refundRecovery`,
+        );
+        await adminPage
+          .getByRole('button', { name: 'Inspect refund recovery', exact: true })
+          .click();
+        expect((await recoveryResponse).ok()).toBeTruthy();
+        await expect(adminPage.getByText(/Provider operation:/)).toBeVisible();
+        await expect(
+          adminPage.getByText(
+            'A provider refund identifier is available. Wait for the verified provider webhook; do not resubmit or reconcile by querying.',
+          ),
+        ).toBeVisible();
+        await expect(
+          refundExecutionDialog.getByRole('button', {
+            name: 'Reconcile provider refund',
+            exact: true,
+          }),
+        ).toHaveCount(0);
+        const completeRefundResponse = waitForApiResponse(
+          adminPage,
+          'POST',
           `/api/pay/mock/payment-session/refund-operation/${executeResult.refundOperationId}/complete`,
-          { headers: authHeaders, data: { outcome: 'succeeded' } },
         );
-        expect(completeRefundResponse.ok()).toBeTruthy();
+        await refundExecutionDialog
+          .getByRole('button', { name: 'Complete mock refund', exact: true })
+          .click();
+        expect((await completeRefundResponse).ok()).toBeTruthy();
         await expect
           .poll(
             async () => {
@@ -1787,8 +1880,9 @@ const product = '${suffix}';
 
 ==highlighted text==
 
-| Feature | Value |
-| --- | --- |
+
+| Feature  | Value   |
+| -------- | ------- |
 | Material | Durable |`;
     const adminContext = await browser.newContext();
     const adminPage = await adminContext.newPage();
@@ -1839,19 +1933,67 @@ const product = '${suffix}';
       expect(adminConsoleErrors).toEqual([]);
       const editor = adminPage.locator('[contenteditable="true"]');
       await expect(editor).toBeVisible();
+      const toolbar = adminPage.getByRole('toolbar', { name: 'Markdown toolbar' });
+      await expect(toolbar).toBeVisible();
+      const undoButton = toolbar.getByRole('button', { name: 'Undo' });
+      await expect(toolbar.getByRole('combobox', { name: 'Code block language' })).toHaveCount(0);
+      const codeBlockToolbar = adminPage.getByRole('toolbar', { name: 'Code block language' });
+      await expect(codeBlockToolbar).toBeHidden();
+      await expect(toolbar.getByRole('button', { name: 'Bold' })).toHaveAttribute('type', 'button');
+      await expect(undoButton).toBeEnabled();
+      const insertTableButton = toolbar.getByRole('button', { name: 'Insert table' });
+      await expect(insertTableButton).toHaveAttribute('type', 'button');
+      await expect(insertTableButton).toHaveAttribute('aria-haspopup', 'grid');
+      await expect(insertTableButton).toHaveAttribute('aria-expanded', 'false');
+      await insertTableButton.click();
+      const tablePickerDialog = adminPage.locator('#markdown-table-size-picker');
+      const tablePicker = tablePickerDialog.locator('[role="grid"]');
+      await expect(tablePickerDialog).toBeVisible();
+      await expect(tablePicker).toHaveCount(1);
+      await expect(insertTableButton).toHaveAttribute('aria-expanded', 'true');
+      await expect(editor.locator('table')).toHaveCount(1);
+      const tablePickerCell = tablePicker.locator('[data-table-picker-cell="2-3"]');
+      await tablePickerCell.hover();
+      await expect(tablePickerDialog.locator('[aria-live="polite"]')).toHaveText(
+        'Selected table size: 2 × 3',
+      );
+      await expect(tablePicker.locator('[aria-selected="true"]')).toHaveCount(6);
+      await expect(tablePicker.locator('[aria-selected="false"]').first()).toBeVisible();
+      await tablePickerCell.click();
+      await expect(tablePickerDialog).toHaveCount(0);
+      await expect(insertTableButton).toHaveAttribute('aria-expanded', 'false');
+      await expect(editor.locator('table')).toHaveCount(2);
+      await expect(editor.locator('table').last().locator('th')).toHaveCount(3);
+      await expect(editor.locator('table').last().locator('td')).toHaveCount(3);
       const editorSurface = editor.locator('..');
+      await editor.locator('h1').click();
       await expect(editorSurface).not.toHaveClass(/\bprose\b/);
       const editorSurfaceClass = await editorSurface.getAttribute('class');
       expect(editorSurfaceClass?.trim()).toBeTruthy();
-      await editorSurface.click({ position: { x: 20, y: 280 } });
       await expect(editor).toBeFocused();
       await expect(editor.locator('h1')).toHaveText(`Product content ${suffix}`);
       await expect(editor.locator('ul:not([data-type="taskList"])')).toHaveCount(1);
       await expect(editor.locator('blockquote')).toHaveText('Product quote');
-      await expect(editor.locator('pre code')).toHaveText(`const product = '${suffix}';`);
+      const codeBlock = editor.locator('pre code');
+      const codeBlockLanguage = codeBlockToolbar.getByRole('combobox', {
+        name: 'Code block language',
+      });
+      await expect(codeBlockToolbar).toBeHidden();
+      await expect(codeBlock).toHaveClass(/\blanguage-ts\b/);
+      await expect(codeBlock).toHaveText(`const product = '${suffix}';`);
+      await expect(codeBlock.locator('span[class*="hljs-"]')).not.toHaveCount(0);
+      await codeBlock.click();
+      await expect(codeBlockToolbar).toBeVisible();
+      await expect(codeBlockLanguage).toBeEnabled();
+      await expect(codeBlockLanguage).toHaveValue('typescript');
+      await codeBlockLanguage.selectOption('python');
+      await expect(codeBlock).toHaveClass(/\blanguage-python\b/);
+      await expect(codeBlock.locator('span[class*="hljs-"]')).not.toHaveCount(0);
+      await editor.locator('h1').click();
+      await expect(codeBlockToolbar).toBeHidden();
       await expect(editor.locator('mark')).toHaveText('highlighted text');
-      await expect(editor.locator('table th')).toHaveCount(2);
-      await expect(editor.locator('table td')).toHaveCount(2);
+      await expect(editor.locator('table th')).toHaveCount(5);
+      await expect(editor.locator('table td')).toHaveCount(5);
       await expect(editor.locator('h1')).toHaveCSS('font-weight', '700');
       await expect(editor.locator('ul:not([data-type="taskList"])')).toHaveCSS(
         'list-style-type',
@@ -1864,15 +2006,75 @@ const product = '${suffix}';
       await expect(editor.locator('blockquote')).toHaveCSS('border-left-width', '4px');
       await expect(editor.locator('pre')).toHaveCSS('overflow-x', 'auto');
       await expect(editor.locator('table th').first()).toHaveCSS('font-weight', '600');
-      await adminPage.getByRole('button', { name: 'Submit', exact: true }).click();
+      await editor.locator('h1').selectText();
+      const boldButton = toolbar.getByRole('button', { name: 'Bold' });
+      await boldButton.click();
+      await expect(boldButton).toHaveAttribute('aria-pressed', 'true');
+      await undoButton.click();
+      await expect(boldButton).toHaveAttribute('aria-pressed', 'false');
+      await expect(toolbar.getByRole('button', { name: 'Redo' })).toBeEnabled();
+
+      const tableToolbar = adminPage.getByRole('toolbar', { name: 'Table toolbar' });
+      const insertedTable = editor.locator('table').last();
+      await editor.locator('h1').click();
+      await expect(tableToolbar).toBeHidden();
+      await insertedTable.locator('td').first().click();
+      expect(adminPageErrors).toEqual([]);
+      expect(adminConsoleErrors).toEqual([]);
+      await expect(tableToolbar).toBeVisible();
+      expect(adminPageErrors).toEqual([]);
+      expect(adminConsoleErrors).toEqual([]);
+      await expect(tableToolbar.getByRole('button', { name: 'Add row before' })).toHaveAttribute(
+        'type',
+        'button',
+      );
+      await tableToolbar.getByRole('button', { name: 'Add row before' }).click();
+      await expect(insertedTable.locator('td')).toHaveCount(6);
+      expect(adminPageErrors).toEqual([]);
+      await tableToolbar.getByRole('button', { name: 'Delete row' }).click();
+      await expect(insertedTable.locator('td')).toHaveCount(3);
+      expect(adminPageErrors).toEqual([]);
+      await tableToolbar.getByRole('button', { name: 'Add row after' }).click();
+      await expect(insertedTable.locator('td')).toHaveCount(6);
+      expect(adminPageErrors).toEqual([]);
+      await tableToolbar.getByRole('button', { name: 'Delete row' }).click();
+      await expect(insertedTable.locator('td')).toHaveCount(3);
+      expect(adminPageErrors).toEqual([]);
+      await tableToolbar.getByRole('button', { name: 'Add column before' }).click();
+      await expect(insertedTable.locator('th')).toHaveCount(4);
+      await expect(insertedTable.locator('td')).toHaveCount(4);
+      expect(adminPageErrors).toEqual([]);
+      await tableToolbar.getByRole('button', { name: 'Delete column' }).click();
+      await expect(insertedTable.locator('th')).toHaveCount(3);
+      await expect(insertedTable.locator('td')).toHaveCount(3);
+      expect(adminPageErrors).toEqual([]);
+      await tableToolbar.getByRole('button', { name: 'Add column after' }).click();
+      await expect(insertedTable.locator('th')).toHaveCount(4);
+      await expect(insertedTable.locator('td')).toHaveCount(4);
+      expect(adminPageErrors).toEqual([]);
+      await tableToolbar.getByRole('button', { name: 'Delete column' }).click();
+      await expect(insertedTable.locator('th')).toHaveCount(3);
+      await expect(insertedTable.locator('td')).toHaveCount(3);
+      expect(adminPageErrors).toEqual([]);
+      await tableToolbar.getByRole('button', { name: 'Delete table' }).click();
+      await expect(editor.locator('table')).toHaveCount(1);
+      await expect(tableToolbar).toBeHidden();
+      expect(adminPageErrors).toEqual([]);
 
+      const productUpdate = waitForApiResponse(
+        adminPage,
+        'PATCH',
+        `${productActionPath}/${productId}`,
+      );
+      await adminPage.getByRole('button', { name: 'Submit', exact: true }).click();
+      await productUpdate;
       const productResponseAfterUpdate = await adminPage.request.get(
         `${productActionPath}/${productId}`,
         { headers },
       );
       expect(productResponseAfterUpdate.ok()).toBeTruthy();
       expect((await productResponseAfterUpdate.json()).productContentForm.descriptionMarkdown).toBe(
-        markdown,
+        markdown.replace('```ts', '```python'),
       );
       expect(adminPageErrors).toEqual([]);
     } finally {
@@ -1893,6 +2095,135 @@ const product = '${suffix}';
   },
 );
 
+test(
+  'ATP-SPC-02: Product Content link toolbar edits Markdown',
+  { tag: ['@admin', '@flow', '@product'] },
+  async ({ browser }, testInfo) => {
+    test.setTimeout(180_000);
+    const suffix = `${testInfo.workerIndex}-${testInfo.parallelIndex ?? testInfo.retry}-${Date.now()}`;
+    const categoryName = `E2E Product Link Category ${suffix}`;
+    const productTitle = `E2E Product Link ${suffix}`;
+    const markdown = `# Product content ${suffix}\n\nA product description.`;
+    const adminContext = await browser.newContext();
+    const adminPage = await adminContext.newPage();
+    const adminPageErrors = collectPageErrors(adminPage);
+    const adminConsoleErrors = collectConsoleErrors(adminPage);
+    const productListPath = '/commerce-admin/rest/resource/commerce-catalog%3Aproduct';
+    const categoryActionPath = '/api/commerce/catalog/category';
+    const productActionPath = '/api/commerce/catalog/product';
+    let categoryId: number | string | undefined;
+    let productId: number | string | undefined;
+    let headers: { Authorization: string } | undefined;
+    try {
+      await adminPage.setViewportSize({ width: 1440, height: 900 });
+      await login(adminPage, '/commerce-admin/', 'admin', '123456', 'commerceAdmin');
+      const accessToken = (await adminContext.cookies()).find(
+        cookie => cookie.name === 'token',
+      )?.value;
+      expect(accessToken).toBeTruthy();
+      headers = { Authorization: `Bearer ${accessToken}` };
+
+      const categoryResponse = await adminPage.request.post(categoryActionPath, {
+        data: { name: categoryName, published: false },
+        headers,
+      });
+      expect(categoryResponse.ok()).toBeTruthy();
+      categoryId = (await categoryResponse.json()).data;
+      expectTableIdentity(categoryId);
+
+      const productResponse = await adminPage.request.post(productActionPath, {
+        data: {
+          categoryId,
+          title: productTitle,
+          published: false,
+          productContentForm: { descriptionMarkdown: markdown },
+        },
+        headers,
+      });
+      expect(productResponse.ok()).toBeTruthy();
+      productId = (await productResponse.json()).data;
+      expectTableIdentity(productId);
+
+      await adminPage.goto(`${productListPath}/${productId}/edit`, { waitUntil: 'load' });
+      await expect(adminPage.locator('html')).toHaveAttribute(
+        'data-zova-hydrated',
+        'commerceAdmin',
+      );
+      const editor = adminPage.locator('[contenteditable="true"]');
+      await expect(editor).toBeVisible();
+      const toolbar = adminPage.getByRole('toolbar', { name: 'Markdown toolbar' });
+      await expect(toolbar).toBeVisible();
+      const linkButton = toolbar.getByRole('button', { name: 'Link' });
+      await expect(linkButton).toHaveAttribute('type', 'button');
+      await expect(linkButton).toBeDisabled();
+
+      await editor.locator('h1').selectText();
+      await expect(linkButton).toBeEnabled();
+      await linkButton.click();
+      const linkPrompt = adminPage.locator('.fixed.inset-0.z-50');
+      await expect(linkPrompt).toBeVisible();
+      const linkInput = linkPrompt.locator('input[type="text"]');
+      await linkInput.fill('https://example.com/docs');
+      await linkInput.press('Enter');
+      await expect(editor.locator('h1 a[href="https://example.com/docs"]')).toHaveText(
+        `Product content ${suffix}`,
+      );
+      await expect(linkButton).toHaveAttribute('aria-pressed', 'true');
+      await editor.press('ArrowLeft');
+      await expect(linkButton).toHaveAttribute('aria-pressed', 'true');
+
+      await linkButton.click();
+      await expect(linkPrompt).toBeVisible();
+      await expect(linkInput).toHaveValue('https://example.com/docs');
+      await linkInput.fill('https://example.com/updated');
+      await linkPrompt.getByRole('button', { name: 'OK' }).click();
+      await expect(editor.locator('h1 a[href="https://example.com/updated"]')).toHaveText(
+        `Product content ${suffix}`,
+      );
+
+      await linkButton.click();
+      await expect(linkPrompt).toBeVisible();
+      await linkPrompt.getByRole('button', { name: 'Cancel' }).click();
+      await expect(editor.locator('h1 a[href="https://example.com/updated"]')).toHaveText(
+        `Product content ${suffix}`,
+      );
+
+      await editor.locator('h1').selectText();
+      await expect(linkButton).toHaveAttribute('aria-pressed', 'true');
+      await linkButton.click();
+      await expect(linkPrompt).toBeVisible();
+      await linkInput.fill('');
+      await linkInput.press('Enter');
+      await expect(editor.locator('h1 a')).toHaveCount(0);
+      await adminPage.getByRole('button', { name: 'Submit', exact: true }).click();
+      const productResponseAfterLinkRemoval = await adminPage.request.get(
+        `${productActionPath}/${productId}`,
+        { headers },
+      );
+      expect(productResponseAfterLinkRemoval.ok()).toBeTruthy();
+      expect(
+        (await productResponseAfterLinkRemoval.json()).productContentForm.descriptionMarkdown,
+      ).not.toContain('https://example.com/updated');
+      expect(adminPageErrors).toEqual([]);
+      expect(adminConsoleErrors).toEqual([]);
+    } finally {
+      if (productId && headers) {
+        const response = await adminPage.request.delete(`${productActionPath}/${productId}`, {
+          headers,
+        });
+        expect(response.ok()).toBeTruthy();
+      }
+      if (categoryId && headers) {
+        const response = await adminPage.request.delete(`${categoryActionPath}/${categoryId}`, {
+          headers,
+        });
+        expect(response.ok()).toBeTruthy();
+      }
+      await adminContext.close().catch(() => {});
+    }
+  },
+);
+
 test(
   'ATP-SPC-02: SKU renders semantic Admin currency and lifecycle controls',
   { tag: ['@admin', '@flow', '@sku'] },

package/e2e/specs/{cabloy-basic/account.spec.ts → account.spec.ts}

@@ -17,7 +17,7 @@ const accountProfileApiPath = '/api/home/user/account/profile';
 const imageUploadApiPath = '/api/image/upload';
 const avatarFixturePath = path.resolve(
   import.meta.dirname,
-  '../../../zova/src/suite/a-home/modules/home-base/assets/img/avatar_user.png',
+  '../../zova/src/suite/a-home/modules/home-base/assets/img/avatar_user.png',
 );
 
 function waitForApiResponse(page: Page, method: string, path: string) {
@@ -168,7 +168,6 @@ test(
     await page.getByPlaceholder('Your email address').fill('unknown-reset@example.test');
     const captcha = page.getByPlaceholder('Please input captcha');
     await expect(captcha).toHaveValue(/\S+/);
-    await captcha.fill(await captcha.inputValue());
     const requestResponse = waitForApiResponse(
       page,
       'POST',

package/oxlint.config.ts

@@ -3,6 +3,9 @@ import { defineConfig } from 'oxlint';
 
 export default defineConfig(
   oxcLintConfigVue({
+    rules: {
+      '@stylistic/jsx-curly-newline': 'off',
+    },
     ignorePatterns: [
       // root original
       '**/.claude',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cabloy",
-  "version": "5.1.141",
+  "version": "5.1.142",
   "gitHead": "2c5c19284bab738e492856189acb6fad74b8a7b7",
   "description": "A Node.js fullstack framework",
   "keywords": [
@@ -43,14 +43,8 @@
     "build:zova:commerce": "pnpm --dir zova run build:ssr:cabloyCommerceBatch",
     "build:zova:commerce:web": "pnpm --dir zova run build:ssr:cabloyCommerce && pnpm --dir zova run build:rest:cabloyCommerce",
     "build:zova:commerce:admin": "pnpm --dir zova run build:ssr:cabloyCommerceAdmin && pnpm --dir zova run build:rest:cabloyCommerceAdmin",
-    "test:e2e:basic": "playwright test --config e2e/config/playwright.basic.config.ts",
-    "test:e2e:basic:web": "playwright test --config e2e/config/playwright.basic.config.ts --grep @web",
-    "test:e2e:basic:admin": "playwright test --config e2e/config/playwright.basic.config.ts --grep @admin",
-    "test:e2e:basic:clean": "node e2e/scripts/testE2eClean.ts basic",
-    "test:e2e:commerce": "playwright test --config e2e/config/playwright.commerce.config.ts",
-    "test:e2e:commerce:web": "playwright test --config e2e/config/playwright.commerce.config.ts --grep @web",
-    "test:e2e:commerce:admin": "playwright test --config e2e/config/playwright.commerce.config.ts --grep @admin",
-    "test:e2e:commerce:clean": "node e2e/scripts/testE2eClean.ts commerce",
+    "test:e2e": "node e2e/scripts/runE2e.ts --clean",
+    "test:e2e:fast": "node e2e/scripts/runE2e.ts --fast",
     "start": "cd vona && npm run start",
     "start:one": "cd vona && npm run start:one",
     "test": "cd vona && npm run test",