@faststore/core 4.8.1-dev.0 → 4.8.1-dev.2

package/test/components/account/orders/SummaryCard.browser.test.tsx

@@ -0,0 +1,59 @@
+/**
+ * @vitest-environment jsdom
+ */
+
+import { render, screen } from '@testing-library/react'
+import { describe, expect, it, vi } from 'vitest'
+
+import SummaryCard from '../../../../src/components/account/orders/OrderDetails/SummaryCard'
+
+vi.mock('next/router', () => ({
+  useRouter: () => ({ locale: 'en-US' }),
+}))
+
+describe('SummaryCard', () => {
+  it('renders localized totals, interest, and the final total', () => {
+    render(
+      <SummaryCard
+        totals={[
+          { id: 'Items', name: 'Items from OMS', value: 1_000 },
+          { id: 'FutureTotal', name: 'Future total from OMS', value: 100 },
+        ]}
+        currencyCode="USD"
+        transactions={[
+          {
+            isActive: true,
+            payments: [{ value: 1_200, referenceValue: 1_100 }],
+          },
+        ]}
+        labels={{
+          itemsTotalLabel: 'Products',
+          interestLabel: 'Financing',
+          totalLabel: 'Grand total',
+        }}
+      />
+    )
+
+    expect(screen.getByText('Products')).toBeTruthy()
+    expect(screen.getByText('Future total from OMS')).toBeTruthy()
+    expect(screen.getByText('Financing')).toBeTruthy()
+    expect(screen.getByText('Grand total')).toBeTruthy()
+  })
+
+  it('does not add interest for inactive transactions', () => {
+    render(
+      <SummaryCard
+        totals={[{ id: 'Items', name: 'Items from OMS', value: 1_000 }]}
+        currencyCode="USD"
+        transactions={[
+          {
+            isActive: false,
+            payments: [{ value: 1_200, referenceValue: 1_000 }],
+          },
+        ]}
+      />
+    )
+
+    expect(screen.queryByText('Interest')).toBeNull()
+  })
+})

package/test/components/account/orders/getDeliveryOptionLabel.test.ts

@@ -0,0 +1,129 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+  getDeliveryOptionKey,
+  getDeliveryOptionLabel,
+} from '../../../../src/components/account/orders/OrderDetails/getDeliveryOptionLabel'
+import { resolveOrderDeliveryLabels } from '../../../../src/components/account/orders/OrderDetails/orderDetailsLabels'
+
+const labels = resolveOrderDeliveryLabels({
+  deliveryChannelLabel: 'Entrega',
+  pickupChannelLabel: 'Retirada',
+  takeAwayChannelLabel: 'Levar',
+  businessDaysZeroTemplate: 'bd-0',
+  businessDaysOneTemplate: 'bd-1',
+  businessDaysOtherTemplate: 'bd-{count}',
+  daysZeroTemplate: 'd-0',
+  daysOneTemplate: 'd-1',
+  daysOtherTemplate: 'd-{count}',
+  hoursZeroTemplate: 'h-0',
+  hoursOneTemplate: 'h-1',
+  hoursOtherTemplate: 'h-{count}',
+  minutesZeroTemplate: 'm-0',
+  minutesOneTemplate: 'm-1',
+  minutesOtherTemplate: 'm-{count}',
+  toNeighborhoodTemplate: 'para {neighborhood}',
+})
+
+describe('getDeliveryOptionLabel', () => {
+  it.each([
+    ['0bd', 'bd-0'],
+    ['1bd', 'bd-1'],
+    ['5bd', 'bd-5'],
+    ['0d', 'd-0'],
+    ['1d', 'd-1'],
+    ['5d', 'd-5'],
+    ['0h', 'h-0'],
+    ['1h', 'h-1'],
+    ['5h', 'h-5'],
+    ['0m', 'm-0'],
+    ['1m', 'm-1'],
+    ['5m', 'm-5'],
+  ])('localizes shipping estimate %s', (shippingEstimate, expected) => {
+    expect(
+      getDeliveryOptionLabel({ deliveryChannel: '', shippingEstimate }, labels)
+    ).toBe(expected)
+  })
+
+  it.each([
+    ['delivery', 'Entrega'],
+    ['pickup', 'Retirada'],
+    ['pickup-in-point', 'Retirada'],
+    ['take-away', 'Levar'],
+  ])('localizes the %s channel', (deliveryChannel, expected) => {
+    expect(
+      getDeliveryOptionLabel(
+        { deliveryChannel, shippingEstimate: '1d' },
+        labels
+      )
+    ).toBe(`${expected} d-1`)
+  })
+
+  it('localizes the neighborhood connector while preserving its value', () => {
+    expect(
+      getDeliveryOptionLabel(
+        {
+          deliveryChannel: 'delivery',
+          shippingEstimate: '5bd',
+          address: { neighborhood: 'Botafogo' },
+        },
+        labels
+      )
+    ).toBe('Entrega bd-5 para Botafogo')
+  })
+
+  it('treats padded one-unit estimates the same way as the API parser', () => {
+    expect(
+      getDeliveryOptionLabel(
+        { deliveryChannel: '', shippingEstimate: '01bd' },
+        labels
+      )
+    ).toBe('bd-1')
+  })
+
+  it('builds a stable key from the same grouping fields as the API', () => {
+    expect(
+      getDeliveryOptionKey({
+        selectedSla: 'Normal',
+        deliveryChannel: 'delivery',
+        deliveryCompany: 'Correios',
+        seller: '1',
+        shippingEstimate: '5bd',
+        shippingEstimateDate: '2026-08-05T00:00:00Z',
+        address: { addressId: 'addr-1' },
+        deliveryWindow: {
+          startDateUtc: '2026-08-05T10:00:00Z',
+          endDateUtc: '2026-08-05T18:00:00Z',
+        },
+      })
+    ).toBe(
+      'Normal|delivery|Correios|1|5bd|2026-08-05T00:00:00Z|addr-1|2026-08-05T10:00:00Z|2026-08-05T18:00:00Z'
+    )
+  })
+
+  it('keeps a recognized channel localized when the estimate is unavailable', () => {
+    expect(
+      getDeliveryOptionLabel(
+        {
+          deliveryChannel: 'delivery',
+          shippingEstimate: 'someday',
+          friendlyDeliveryOptionName: 'Delivery someday',
+        },
+        labels
+      )
+    ).toBe('Entrega')
+  })
+
+  it('preserves the API fallback for unsupported raw values', () => {
+    expect(
+      getDeliveryOptionLabel(
+        {
+          deliveryChannel: 'future-channel',
+          shippingEstimate: 'someday',
+          friendlyDeliveryOptionName: 'Existing API label',
+        },
+        labels
+      )
+    ).toBe('Existing API label')
+  })
+})

package/test/components/account/orders/getOrderTotalLabel.test.ts

@@ -0,0 +1,35 @@
+import { describe, expect, it } from 'vitest'
+
+import { getOrderTotalLabel } from '../../../../src/components/account/orders/OrderDetails/SummaryCard/getOrderTotalLabel'
+import { resolveOrderSummaryLabels } from '../../../../src/components/account/orders/OrderDetails/orderDetailsLabels'
+
+const labels = resolveOrderSummaryLabels({
+  itemsTotalLabel: 'Produtos',
+  discountsTotalLabel: 'Descontos',
+  shippingTotalLabel: 'Frete',
+  taxTotalLabel: 'Impostos',
+  changeTotalLabel: 'Alterações',
+})
+
+describe('getOrderTotalLabel', () => {
+  it.each([
+    ['Items', 'Produtos'],
+    ['Discounts', 'Descontos'],
+    ['Shipping', 'Frete'],
+    ['Tax', 'Impostos'],
+    ['Change', 'Alterações'],
+  ])('localizes the documented OMS %s total', (id, expected) => {
+    expect(getOrderTotalLabel({ id, name: `${id} from OMS` }, labels)).toBe(
+      expected
+    )
+  })
+
+  it('falls back to the OMS name for an unknown total id', () => {
+    expect(
+      getOrderTotalLabel(
+        { id: 'FutureTotal', name: 'Future total from OMS' },
+        labels
+      )
+    ).toBe('Future total from OMS')
+  })
+})

package/test/components/account/orders/listOrdersLabels.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+  defaultListOrdersLabels,
+  resolveListOrdersLabels,
+} from '../../../../src/components/account/orders/ListOrders/listOrdersLabels'
+
+describe('list orders labels', () => {
+  it('provides English defaults for filter group labels', () => {
+    expect(defaultListOrdersLabels.statusFilterLabel).toBe('Status')
+    expect(defaultListOrdersLabels.orderDateFilterLabel).toBe('Order Date')
+  })
+
+  it('resolves localized filter group labels', () => {
+    const labels = resolveListOrdersLabels({
+      statusFilterLabel: 'Situação',
+      orderDateFilterLabel: 'Data do pedido',
+    })
+
+    expect(labels.statusFilterLabel).toBe('Situação')
+    expect(labels.orderDateFilterLabel).toBe('Data do pedido')
+  })
+})

package/test/components/account/orders/orderDetailsLabels.test.ts

@@ -0,0 +1,13 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+  defaultOrderDeliveryLabels,
+  resolveOrderDeliveryLabels,
+} from '../../../../src/components/account/orders/OrderDetails/orderDetailsLabels'
+
+describe('order details labels', () => {
+  it('uses English delivery labels by default', () => {
+    expect(resolveOrderDeliveryLabels()).toEqual(defaultOrderDeliveryLabels)
+    expect(defaultOrderDeliveryLabels.eachLabel).toBe('Each')
+  })
+})

package/test/components/navigation/Navbar.browser.test.tsx

@@ -0,0 +1,183 @@
+/**
+ * @vitest-environment jsdom
+ */
+
+import '@testing-library/jest-dom/vitest'
+import { render, screen } from '@testing-library/react'
+import { forwardRef } from 'react'
+import { describe, expect, it, vi } from 'vitest'
+
+const mockUseSession = vi.hoisted(() => vi.fn())
+const mockUseScreenResize = vi.hoisted(() => vi.fn())
+const mockNavbarAccountArea = vi.hoisted(() => vi.fn())
+const mockStoreConfig = vi.hoisted(() => ({
+  experimental: { enableFaststoreMyAccount: false },
+  localization: { enabled: false },
+}))
+
+vi.mock('next/dynamic', () => ({
+  default: () => () => null,
+}))
+
+vi.mock('@faststore/ui', () => ({
+  Icon: () => null,
+  Skeleton: () => null,
+  useScrollDirection: () => 'up',
+  useUI: () => ({ openNavbar: vi.fn(), navbar: false }),
+}))
+
+vi.mock('discovery.config', () => ({ default: mockStoreConfig }))
+
+vi.mock('src/components/account/Drawer/OrganizationSignInButton', () => ({
+  OrganizationSignInButton: () => null,
+}))
+
+vi.mock('src/components/cart/CartToggle', () => ({
+  default: () => <div data-testid="cart-toggle" />,
+}))
+
+vi.mock('src/components/search/SearchInput', () => ({
+  default: forwardRef(function SearchInputStub(_props, _ref) {
+    return <div data-testid="search-input" />
+  }),
+}))
+
+vi.mock('src/components/ui/Link', () => ({
+  default: ({ children }: { children?: React.ReactNode }) => (
+    <a href="/">{children}</a>
+  ),
+}))
+
+vi.mock('src/components/ui/LocalizationButton', () => ({
+  default: () => <div data-testid="localization-button" />,
+}))
+
+vi.mock('src/components/ui/Logo', () => ({
+  default: () => <div data-testid="logo" />,
+}))
+
+vi.mock('../../../src/components/navigation/Navbar/NavbarAccountArea', () => ({
+  NavbarAccountArea: (props: Record<string, unknown>) => {
+    mockNavbarAccountArea(props)
+    return <div data-testid="navbar-account-area" />
+  },
+}))
+
+vi.mock('src/sdk/overrides/OverrideContext', () => ({
+  useOverrideComponents: () => ({
+    Navbar: {
+      Component: ({ children }: React.PropsWithChildren) => (
+        <div data-testid="navbar-wrapper">{children}</div>
+      ),
+      props: {},
+    },
+    NavbarHeader: {
+      Component: ({ children }: React.PropsWithChildren) => (
+        <header>{children}</header>
+      ),
+      props: {},
+    },
+    NavbarRow: {
+      Component: ({ children }: React.PropsWithChildren) => (
+        <div>{children}</div>
+      ),
+      props: {},
+    },
+    NavbarButtons: {
+      Component: ({ children }: React.PropsWithChildren) => (
+        <div>{children}</div>
+      ),
+      props: {},
+    },
+    IconButton: {
+      Component: (props: Record<string, unknown>) => <button {...props} />,
+      props: { 'aria-label': 'menu' },
+    },
+    _experimentalButtonSignIn: { Component: () => null },
+  }),
+}))
+
+vi.mock('src/sdk/session', () => ({ useSession: mockUseSession }))
+
+vi.mock('src/sdk/ui/useScreenResize', () => ({
+  default: mockUseScreenResize,
+}))
+
+import Navbar from '../../../src/components/navigation/Navbar/Navbar'
+
+const baseProps = {
+  logo: {
+    src: '/logo.png',
+    alt: 'Logo',
+    link: { url: '/', title: 'Home' },
+  },
+  searchInput: { sort: 'score_desc' },
+  cart: { alt: 'cart', icon: 'ShoppingCart' },
+  signIn: {
+    button: {
+      icon: { alt: 'account', icon: 'User' },
+      label: 'Sign in',
+      myAccountLabel: 'My Account',
+    },
+  },
+  region: { icon: 'MapPin', label: 'Region', shouldDisplayRegion: false },
+  links: [],
+  home: { label: 'Home' },
+  menu: { icon: { icon: 'List', alt: 'Menu' } },
+}
+
+describe('Navbar', () => {
+  it('renders the account area (desktop) and forwards isSignInResolved=false before the session validates', () => {
+    mockUseScreenResize.mockReturnValue({ isDesktop: true })
+    mockUseSession.mockReturnValue({
+      b2b: {},
+      isSessionReady: false,
+      hasValidated: false,
+    })
+
+    render(<Navbar {...baseProps} />)
+
+    expect(screen.getByTestId('navbar-account-area')).toBeTruthy()
+    expect(mockNavbarAccountArea).toHaveBeenCalledWith(
+      expect.objectContaining({
+        isSignInResolved: false,
+        skeletonAttr: 'data-fs-navbar-signin-skeleton',
+      })
+    )
+  })
+
+  it('forwards isSignInResolved=true and isOrganizationEnabled for a resolved B2B representative session', () => {
+    mockStoreConfig.experimental.enableFaststoreMyAccount = true
+    mockUseScreenResize.mockReturnValue({ isDesktop: true })
+    mockUseSession.mockReturnValue({
+      b2b: { isRepresentative: true },
+      isSessionReady: true,
+      hasValidated: true,
+    })
+
+    render(<Navbar {...baseProps} />)
+
+    expect(mockNavbarAccountArea).toHaveBeenCalledWith(
+      expect.objectContaining({
+        isSignInResolved: true,
+        isOrganizationEnabled: true,
+        isRepresentative: true,
+      })
+    )
+
+    mockStoreConfig.experimental.enableFaststoreMyAccount = false
+  })
+
+  it('does not render the account area on mobile', () => {
+    mockUseScreenResize.mockReturnValue({ isDesktop: false })
+    mockUseSession.mockReturnValue({
+      b2b: {},
+      isSessionReady: true,
+      hasValidated: true,
+    })
+
+    render(<Navbar {...baseProps} />)
+
+    expect(screen.queryByTestId('navbar-account-area')).toBeNull()
+  })
+})

package/test/components/navigation/NavbarAccountArea.browser.test.tsx

@@ -0,0 +1,115 @@
+/**
+ * @vitest-environment jsdom
+ */
+
+import '@testing-library/jest-dom/vitest'
+import { render, screen } from '@testing-library/react'
+import { describe, expect, it, vi } from 'vitest'
+
+vi.mock(
+  '../../../src/components/account/Drawer/OrganizationSignInButton',
+  () => ({
+    OrganizationSignInButton: ({
+      icon,
+      isRepresentative,
+    }: {
+      icon: { alt: string; icon: string }
+      isRepresentative?: boolean
+    }) => (
+      <button
+        type="button"
+        data-testid="organization-signin"
+        data-icon={icon.alt}
+      >
+        {isRepresentative ? 'Representative' : 'Not representative'}
+      </button>
+    ),
+  })
+)
+
+import { NavbarAccountArea } from '../../../src/components/navigation/Navbar/NavbarAccountArea'
+
+const signInButton = {
+  icon: { alt: 'account', icon: 'User' },
+  label: 'Sign in',
+  myAccountLabel: 'My Account',
+}
+
+const ButtonSignInStub = {
+  Component: ({ label }: { label: string }) => (
+    <button type="button" data-testid="storefront-signin">
+      {label}
+    </button>
+  ),
+  props: undefined,
+}
+
+describe('NavbarAccountArea', () => {
+  it('renders the loading skeleton with the Navbar attribute while sign-in is not resolved', () => {
+    const { container } = render(
+      <NavbarAccountArea
+        isSignInResolved={false}
+        isOrganizationEnabled={false}
+        signInButton={signInButton}
+        ButtonSignIn={ButtonSignInStub}
+        skeletonAttr="data-fs-navbar-signin-skeleton"
+      />
+    )
+
+    expect(
+      container.querySelector('[data-fs-navbar-signin-skeleton]')
+    ).toBeTruthy()
+    expect(
+      container.querySelector('[data-fs-navbar-slider-signin-skeleton]')
+    ).toBeNull()
+  })
+
+  it('renders the loading skeleton with the NavbarSlider attribute while sign-in is not resolved', () => {
+    const { container } = render(
+      <NavbarAccountArea
+        isSignInResolved={false}
+        isOrganizationEnabled={false}
+        signInButton={signInButton}
+        ButtonSignIn={ButtonSignInStub}
+        skeletonAttr="data-fs-navbar-slider-signin-skeleton"
+      />
+    )
+
+    expect(
+      container.querySelector('[data-fs-navbar-slider-signin-skeleton]')
+    ).toBeTruthy()
+  })
+
+  it('renders the OrganizationSignInButton when the organization area is enabled', () => {
+    render(
+      <NavbarAccountArea
+        isSignInResolved
+        isOrganizationEnabled
+        isRepresentative
+        signInButton={signInButton}
+        ButtonSignIn={ButtonSignInStub}
+        skeletonAttr="data-fs-navbar-signin-skeleton"
+      />
+    )
+
+    expect(screen.getByTestId('organization-signin')).toHaveTextContent(
+      'Representative'
+    )
+    expect(screen.queryByTestId('storefront-signin')).toBeNull()
+  })
+
+  it('renders the storefront ButtonSignIn override when the organization area is not enabled', () => {
+    render(
+      <NavbarAccountArea
+        isSignInResolved
+        isOrganizationEnabled={false}
+        signInButton={signInButton}
+        ButtonSignIn={ButtonSignInStub}
+        skeletonAttr="data-fs-navbar-signin-skeleton"
+      />
+    )
+
+    expect(screen.getByTestId('storefront-signin')).toHaveTextContent('Sign in')
+    expect(screen.queryByTestId('organization-signin')).toBeNull()
+  })
+})