@faststore/core 4.4.1-dev.0 → 4.5.0-dev.1

package/test/components/quotes/MyAccountQuotesFilterSlider.test.tsx

@@ -0,0 +1,152 @@
+/**
+ * @vitest-environment jsdom
+ */
+
+import { fireEvent, render, screen } from '@testing-library/react'
+import React from 'react'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+vi.mock('@faststore/ui', async () => {
+  const actual =
+    await vi.importActual<typeof import('@faststore/ui')>('@faststore/ui')
+  return {
+    ...actual,
+    FilterSlider: ({
+      children,
+      applyBtnProps,
+      clearBtnProps,
+    }: React.PropsWithChildren<{
+      applyBtnProps?: { onClick?: () => void; children?: React.ReactNode }
+      clearBtnProps?: { onClick?: () => void; children?: React.ReactNode }
+    }>) => (
+      <div>
+        {children}
+        <button onClick={applyBtnProps?.onClick}>
+          {applyBtnProps?.children}
+        </button>
+        <button onClick={clearBtnProps?.onClick}>
+          {clearBtnProps?.children}
+        </button>
+      </div>
+    ),
+  }
+})
+
+import MyAccountQuotesFilterSlider from '../../../src/components/account/quotes/MyAccountListQuotes/MyAccountQuotesFilterSlider/MyAccountQuotesFilterSlider'
+import { getAllFacets } from '../../../src/components/account/quotes/MyAccountListQuotes/quoteFilters'
+
+const originalLocation = window.location
+
+function stubLocation(search = '') {
+  Object.defineProperty(window, 'location', {
+    configurable: true,
+    value: { ...originalLocation, search, href: '' },
+  })
+}
+
+function baseProps(overrides: Record<string, unknown> = {}) {
+  return {
+    facets: getAllFacets({
+      page: 1,
+      status: [],
+      createdAtFrom: '',
+      createdAtTo: '',
+      expiresAtFrom: '',
+      expiresAtTo: '',
+      label: '',
+    }),
+    testId: 'test-filter-slider',
+    dispatch: vi.fn(),
+    expanded: false,
+    selected: [],
+    title: 'Filters',
+    clearButtonLabel: 'Clear All',
+    applyButtonLabel: 'View Results',
+    ...overrides,
+  }
+}
+
+describe('MyAccountQuotesFilterSlider', () => {
+  beforeEach(() => {
+    stubLocation()
+  })
+
+  afterEach(() => {
+    vi.clearAllMocks()
+    Object.defineProperty(window, 'location', {
+      configurable: true,
+      value: originalLocation,
+    })
+  })
+
+  it('navigates with the selected status params on apply', () => {
+    render(
+      <MyAccountQuotesFilterSlider
+        {...(baseProps({
+          selected: [{ key: 'status', value: 'Draft' }],
+        }) as any)}
+      />
+    )
+
+    fireEvent.click(screen.getByText('View Results'))
+
+    expect(window.location.href).toBe('/pvt/account/quotes?status=Draft')
+  })
+
+  it('navigates with the created date range params on apply', () => {
+    render(<MyAccountQuotesFilterSlider {...(baseProps() as any)} />)
+
+    fireEvent.change(screen.getAllByLabelText('From')[0], {
+      target: { value: '2026-01-01' },
+    })
+    fireEvent.change(screen.getAllByLabelText('To')[0], {
+      target: { value: '2026-01-31' },
+    })
+
+    fireEvent.click(screen.getByText('View Results'))
+
+    expect(window.location.href).toBe(
+      '/pvt/account/quotes?createdAtFrom=2026-01-01&createdAtTo=2026-01-31'
+    )
+  })
+
+  it('preserves an existing label param when applying filters', () => {
+    stubLocation('?label=hello')
+
+    render(
+      <MyAccountQuotesFilterSlider
+        {...(baseProps({
+          selected: [{ key: 'status', value: 'Draft' }],
+        }) as any)}
+      />
+    )
+
+    fireEvent.click(screen.getByText('View Results'))
+
+    expect(window.location.href).toBe(
+      '/pvt/account/quotes?label=hello&status=Draft'
+    )
+  })
+
+  it('navigates with no query string when no filters are applied', () => {
+    render(<MyAccountQuotesFilterSlider {...(baseProps() as any)} />)
+
+    fireEvent.click(screen.getByText('View Results'))
+
+    expect(window.location.href).toBe('/pvt/account/quotes')
+  })
+
+  it('clears the created/expiry date refs and dispatches an empty facet selection on clear', () => {
+    const dispatch = vi.fn()
+    render(
+      <MyAccountQuotesFilterSlider {...(baseProps({ dispatch }) as any)} />
+    )
+
+    fireEvent.click(screen.getByText('Clear All'))
+
+    expect(dispatch).toHaveBeenCalledWith({
+      type: 'selectFacets',
+      payload: [],
+    })
+  })
+})

package/test/components/quotes/MyAccountQuotesSelectedTags.test.tsx

@@ -0,0 +1,122 @@
+/**
+ * @vitest-environment jsdom
+ */
+
+import { fireEvent, render, screen } from '@testing-library/react'
+import { describe, expect, it, vi } from 'vitest'
+
+const mockUseSession = vi.hoisted(() => vi.fn())
+vi.mock('src/sdk/session', () => ({ useSession: mockUseSession }))
+
+import MyAccountQuotesSelectedTags from '../../../src/components/account/quotes/MyAccountListQuotes/MyAccountQuotesSelectedTags/MyAccountQuotesSelectedTags'
+import { formatFilterDate } from '../../../src/components/account/quotes/MyAccountListQuotes/quoteFilters'
+
+mockUseSession.mockReturnValue({ locale: 'en-US' })
+
+describe('MyAccountQuotesSelectedTags', () => {
+  it('renders nothing when there are no active filters', () => {
+    const { container } = render(
+      <MyAccountQuotesSelectedTags
+        filters={{}}
+        onClearAll={vi.fn()}
+        onRemoveFilter={vi.fn()}
+      />
+    )
+
+    expect(container.firstChild).toBeNull()
+  })
+
+  it('renders a range tag when both from and to dates are set', () => {
+    render(
+      <MyAccountQuotesSelectedTags
+        filters={{ createdAtFrom: '2026-01-01', createdAtTo: '2026-01-31' }}
+        onClearAll={vi.fn()}
+        onRemoveFilter={vi.fn()}
+      />
+    )
+
+    const expected = `Created: ${formatFilterDate('2026-01-01', 'en-US')} to ${formatFilterDate('2026-01-31', 'en-US')}`
+    expect(screen.getByText(expected)).toBeTruthy()
+  })
+
+  it('renders an open-ended "from" tag when only the start date is set', () => {
+    render(
+      <MyAccountQuotesSelectedTags
+        filters={{ expiresAtFrom: '2026-02-01' }}
+        onClearAll={vi.fn()}
+        onRemoveFilter={vi.fn()}
+      />
+    )
+
+    const expected = `Expires: from ${formatFilterDate('2026-02-01', 'en-US')}`
+    expect(screen.getByText(expected)).toBeTruthy()
+  })
+
+  it('renders an open-ended "to" tag when only the end date is set', () => {
+    render(
+      <MyAccountQuotesSelectedTags
+        filters={{ expiresAtTo: '2026-02-28' }}
+        onClearAll={vi.fn()}
+        onRemoveFilter={vi.fn()}
+      />
+    )
+
+    const expected = `Expires: to ${formatFilterDate('2026-02-28', 'en-US')}`
+    expect(screen.getByText(expected)).toBeTruthy()
+  })
+
+  it('renders one tag per selected status using its mapped label', () => {
+    render(
+      <MyAccountQuotesSelectedTags
+        filters={{ status: ['Draft', 'Approved'] }}
+        onClearAll={vi.fn()}
+        onRemoveFilter={vi.fn()}
+      />
+    )
+
+    expect(screen.getByText('Draft')).toBeTruthy()
+    expect(screen.getByText('Approved')).toBeTruthy()
+  })
+
+  it('falls back to the raw value for an unmapped status', () => {
+    render(
+      <MyAccountQuotesSelectedTags
+        filters={{ status: ['NotAStatus'] }}
+        onClearAll={vi.fn()}
+        onRemoveFilter={vi.fn()}
+      />
+    )
+
+    expect(screen.getByText('NotAStatus')).toBeTruthy()
+  })
+
+  it('calls onRemoveFilter with the right key/value when a tag is cleared', () => {
+    const onRemoveFilter = vi.fn()
+    render(
+      <MyAccountQuotesSelectedTags
+        filters={{ status: ['Draft'] }}
+        onClearAll={vi.fn()}
+        onRemoveFilter={onRemoveFilter}
+      />
+    )
+
+    fireEvent.click(screen.getByText('×'))
+
+    expect(onRemoveFilter).toHaveBeenCalledWith('status', 'Draft')
+  })
+
+  it('calls onClearAll when the Clear All button is clicked', () => {
+    const onClearAll = vi.fn()
+    render(
+      <MyAccountQuotesSelectedTags
+        filters={{ status: ['Draft'] }}
+        onClearAll={onClearAll}
+        onRemoveFilter={vi.fn()}
+      />
+    )
+
+    fireEvent.click(screen.getByText('Clear All'))
+
+    expect(onClearAll).toHaveBeenCalledTimes(1)
+  })
+})

package/test/components/quotes/MyAccountQuotesStatusSelector.test.tsx

@@ -0,0 +1,85 @@
+/**
+ * @vitest-environment jsdom
+ */
+
+import { fireEvent, render, screen } from '@testing-library/react'
+import { describe, expect, it, vi } from 'vitest'
+
+import MyAccountQuotesStatusSelector from '../../../src/components/account/quotes/MyAccountListQuotes/MyAccountQuotesStatusSelector/MyAccountQuotesStatusSelector'
+
+describe('MyAccountQuotesStatusSelector', () => {
+  it('renders a chip with the mapped label for each selected value', () => {
+    render(
+      <MyAccountQuotesStatusSelector value={['Draft']} onChange={vi.fn()} />
+    )
+
+    expect(screen.getByText('Draft')).toBeTruthy()
+  })
+
+  it('opens the dropdown when the trigger is clicked', () => {
+    const { container } = render(
+      <MyAccountQuotesStatusSelector value={[]} onChange={vi.fn()} />
+    )
+
+    expect(screen.queryByLabelText('Approved')).toBeNull()
+
+    fireEvent.click(
+      container.querySelector('[aria-controls="status-listbox"]')!
+    )
+
+    expect(screen.getByLabelText('Approved')).toBeTruthy()
+  })
+
+  it('calls onChange with the key added when a checkbox is checked', () => {
+    const onChange = vi.fn()
+    const { container } = render(
+      <MyAccountQuotesStatusSelector value={[]} onChange={onChange} />
+    )
+
+    fireEvent.click(
+      container.querySelector('[aria-controls="status-listbox"]')!
+    )
+    fireEvent.click(screen.getByLabelText('Draft'))
+
+    expect(onChange).toHaveBeenCalledWith(['Draft'])
+  })
+
+  it('calls onChange with the key removed when an already-selected checkbox is unchecked', () => {
+    const onChange = vi.fn()
+    const { container } = render(
+      <MyAccountQuotesStatusSelector value={['Draft']} onChange={onChange} />
+    )
+
+    fireEvent.click(
+      container.querySelector('[aria-controls="status-listbox"]')!
+    )
+    fireEvent.click(screen.getByLabelText('Draft'))
+
+    expect(onChange).toHaveBeenCalledWith([])
+  })
+
+  it('calls onChange with the key removed when a chip remove button is clicked', () => {
+    const onChange = vi.fn()
+    render(
+      <MyAccountQuotesStatusSelector
+        value={['Draft', 'Approved']}
+        onChange={onChange}
+      />
+    )
+
+    fireEvent.click(screen.getByLabelText('Remove Draft'))
+
+    expect(onChange).toHaveBeenCalledWith(['Approved'])
+  })
+
+  it('falls back to the raw key for a chip with no matching status entry', () => {
+    render(
+      <MyAccountQuotesStatusSelector
+        value={['NotAStatus']}
+        onChange={vi.fn()}
+      />
+    )
+
+    expect(screen.getByText('NotAStatus')).toBeTruthy()
+  })
+})

package/test/components/quotes/quoteFilters.test.ts

@@ -0,0 +1,185 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+  getSelectedFacets,
+  getAllFacets,
+  hasActiveFilters,
+  countActiveFilters,
+  formatFilterDate,
+} from '../../../src/components/account/quotes/MyAccountListQuotes/quoteFilters'
+import {
+  quoteStatusMap,
+  type QuoteStatusKey,
+} from '../../../src/utils/quoteStatus'
+
+const emptyFilters = {
+  page: 1,
+  status: [],
+  createdAtFrom: '',
+  createdAtTo: '',
+  expiresAtFrom: '',
+  expiresAtTo: '',
+  label: '',
+}
+
+describe('quoteStatusMap', () => {
+  it('has entries for all 9 statuses', () => {
+    expect(Object.keys(quoteStatusMap)).toHaveLength(9)
+  })
+
+  it('all keys are PascalCase', () => {
+    Object.keys(quoteStatusMap).forEach((key) => {
+      expect(key[0]).toBe(key[0].toUpperCase())
+      expect(key).toBe(key[0].toUpperCase() + key.slice(1))
+    })
+  })
+
+  it('all entries have a non-empty label', () => {
+    Object.values(quoteStatusMap).forEach((entry) => {
+      expect(entry.label).toBeTruthy()
+    })
+  })
+
+  it('all entries have a valid variant', () => {
+    const validVariants = ['neutral', 'warning', 'info', 'success', 'danger']
+    Object.values(quoteStatusMap).forEach((entry) => {
+      expect(validVariants).toContain(entry.variant)
+    })
+  })
+})
+
+describe('getSelectedFacets', () => {
+  it('returns empty array when no status selected', () => {
+    expect(getSelectedFacets(emptyFilters)).toEqual([])
+  })
+
+  it('returns one facet per status, preserving PascalCase', () => {
+    const filters = { ...emptyFilters, status: ['InReview', 'Approved'] }
+    const facets = getSelectedFacets(filters)
+    expect(facets).toEqual([
+      { key: 'status', value: 'InReview' },
+      { key: 'status', value: 'Approved' },
+    ])
+  })
+
+  it('does NOT lowercase the status values', () => {
+    const filters = { ...emptyFilters, status: ['ConvertedToOrder'] }
+    const facets = getSelectedFacets(filters)
+    expect(facets[0].value).toBe('ConvertedToOrder')
+    expect(facets[0].value).not.toBe('convertedtoorder')
+  })
+})
+
+describe('getAllFacets', () => {
+  it('returns 3 facets: status, createdAt, expiresAt', () => {
+    const facets = getAllFacets(emptyFilters)
+    expect(facets).toHaveLength(3)
+    expect(facets[0].key).toBe('status')
+    expect(facets[1].key).toBe('createdAt')
+    expect(facets[2].key).toBe('expiresAt')
+  })
+
+  it('status facet values match quoteStatusMap keys (PascalCase)', () => {
+    const facets = getAllFacets(emptyFilters)
+    const statusFacet = facets[0]
+    if (statusFacet.__typename !== 'StoreFacetBoolean') throw new Error()
+
+    const expectedKeys = Object.keys(quoteStatusMap) as QuoteStatusKey[]
+    statusFacet.values.forEach((v, i) => {
+      expect(v.value).toBe(expectedKeys[i])
+      expect(v.label).toBe(quoteStatusMap[expectedKeys[i]].label)
+    })
+  })
+
+  it('range facets carry the date filters', () => {
+    const filters = {
+      ...emptyFilters,
+      createdAtFrom: '2024-01-01',
+      createdAtTo: '2024-12-31',
+    }
+    const facets = getAllFacets(filters)
+    const createdAt = facets[1]
+    if (createdAt.__typename !== 'StoreFacetRange') throw new Error()
+    expect(createdAt.from).toBe('2024-01-01')
+    expect(createdAt.to).toBe('2024-12-31')
+  })
+})
+
+describe('hasActiveFilters', () => {
+  it('returns false for empty filters', () => {
+    expect(hasActiveFilters(emptyFilters)).toBe(false)
+  })
+
+  it('returns true when status is selected', () => {
+    expect(hasActiveFilters({ ...emptyFilters, status: ['Draft'] })).toBe(true)
+  })
+
+  it('returns true when label is set', () => {
+    expect(hasActiveFilters({ ...emptyFilters, label: 'quote-123' })).toBe(true)
+  })
+
+  it('returns true when any date filter is set', () => {
+    expect(
+      hasActiveFilters({ ...emptyFilters, createdAtFrom: '2024-01-01' })
+    ).toBe(true)
+  })
+})
+
+describe('countActiveFilters', () => {
+  it('returns 0 for empty filters', () => {
+    expect(countActiveFilters(emptyFilters)).toBe(0)
+  })
+
+  it('counts status as one regardless of how many statuses', () => {
+    expect(
+      countActiveFilters({ ...emptyFilters, status: ['Draft', 'Approved'] })
+    ).toBe(1)
+  })
+
+  it('counts createdAt range as one', () => {
+    expect(
+      countActiveFilters({
+        ...emptyFilters,
+        createdAtFrom: '2024-01-01',
+        createdAtTo: '2024-12-31',
+      })
+    ).toBe(1)
+  })
+
+  it('counts all three groups independently', () => {
+    expect(
+      countActiveFilters({
+        ...emptyFilters,
+        status: ['Draft'],
+        createdAtFrom: '2024-01-01',
+        expiresAtTo: '2025-01-01',
+      })
+    ).toBe(3)
+  })
+})
+
+describe('formatFilterDate', () => {
+  it('formats a valid YYYY-MM-DD date', () => {
+    const result = formatFilterDate('2024-03-15', 'en-US')
+    expect(result).toMatch(/03.+15.+2024|2024.+03.+15/)
+  })
+
+  it('returns the original string for empty input', () => {
+    expect(formatFilterDate('', 'en-US')).toBe('')
+  })
+
+  it('returns the original string for invalid format', () => {
+    expect(formatFilterDate('not-a-date', 'en-US')).toBe('not-a-date')
+    expect(formatFilterDate('2024/03/15', 'en-US')).toBe('2024/03/15')
+  })
+
+  it('returns the original string for zero month/day', () => {
+    expect(formatFilterDate('2024-00-15', 'en-US')).toBe('2024-00-15')
+    expect(formatFilterDate('2024-03-00', 'en-US')).toBe('2024-03-00')
+  })
+
+  it('returns the original string for dates that roll over (e.g. Feb 31)', () => {
+    expect(formatFilterDate('2024-02-31', 'en-US')).toBe('2024-02-31')
+    expect(formatFilterDate('2024-04-31', 'en-US')).toBe('2024-04-31')
+  })
+})

package/test/sdk/account/changeContractToken.browser.test.ts

@@ -0,0 +1,157 @@
+/**
+ * @vitest-environment jsdom
+ */
+
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+vi.mock('discovery.config', () => ({
+  default: {
+    api: { storeId: 'b2bfaststoredev' },
+  },
+}))
+
+const mockFetch = vi.hoisted(() => vi.fn())
+vi.mock('isomorphic-unfetch', () => ({ __esModule: true, default: mockFetch }))
+
+import {
+  ContractSwitchError,
+  applyVtexAuthCookieFromSwitchResponse,
+  changeContractToken,
+  isContractSwitchEnabled,
+} from '../../../src/sdk/account/changeContractToken'
+
+const successPayload = {
+  authStatus: 'Success',
+  expiresIn: 86_399,
+  authCookie: {
+    Name: 'VtexIdclientAutCookie_b2bfaststoredev',
+    Value: 'new-contract-token',
+  },
+  accountAuthCookie: null,
+}
+
+describe('changeContractToken', () => {
+  beforeEach(() => {
+    document.cookie = ''
+    mockFetch.mockResolvedValue({
+      ok: true,
+      status: 200,
+      json: async () => successPayload,
+    })
+  })
+
+  afterEach(() => {
+    document.cookie = ''
+    vi.clearAllMocks()
+  })
+
+  it('is enabled', () => {
+    expect(isContractSwitchEnabled).toBe(true)
+  })
+
+  it('rejects when contractId is missing', async () => {
+    await expect(changeContractToken('')).rejects.toThrow(ContractSwitchError)
+  })
+
+  it('posts to switch-properties with the contract customerId', async () => {
+    const contractId = '69b5d80e-8f61-44e0-a5cb-db54c326699c'
+
+    await expect(changeContractToken(contractId)).resolves.toBe(true)
+
+    expect(mockFetch).toHaveBeenCalledTimes(1)
+    const [url, init] = mockFetch.mock.calls[0]
+    expect(url).toBe(
+      '/api/authenticator/storefront/credential/switch-properties?an=b2bfaststoredev'
+    )
+    expect(init.method).toBe('POST')
+    expect(init.credentials).toBe('include')
+    expect(init.signal).toBeDefined()
+    expect(JSON.parse(init.body as string)).toEqual({
+      properties: { customerId: contractId },
+    })
+  })
+
+  it('applies the auth cookie returned by switch-properties', async () => {
+    await changeContractToken('contract-1')
+
+    expect(document.cookie).toContain(
+      'VtexIdclientAutCookie_b2bfaststoredev=new-contract-token'
+    )
+  })
+
+  it('throws when the switch request fails', async () => {
+    mockFetch.mockResolvedValueOnce({ ok: false, status: 401 })
+
+    await expect(changeContractToken('contract-1')).rejects.toThrow(
+      /Failed to switch contract \(401\)/
+    )
+  })
+
+  it('throws when the switch request times out', async () => {
+    const timeoutError = new Error('The operation was aborted')
+    timeoutError.name = 'TimeoutError'
+    mockFetch.mockRejectedValueOnce(timeoutError)
+
+    await expect(changeContractToken('contract-1')).rejects.toThrow(
+      /Contract switch timed out/
+    )
+  })
+
+  it('throws when authStatus is not success', async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      json: async () => ({ ...successPayload, authStatus: 'Failed' }),
+    })
+
+    await expect(changeContractToken('contract-1')).rejects.toThrow(
+      /Contract switch was not successful/
+    )
+  })
+
+  it('throws when authCookie is missing from a successful response', async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      json: async () => ({
+        authStatus: 'Success',
+        authCookie: null,
+      }),
+    })
+
+    await expect(changeContractToken('contract-1')).rejects.toThrow(
+      /no auth cookie was returned/
+    )
+  })
+})
+
+describe('applyVtexAuthCookieFromSwitchResponse', () => {
+  beforeEach(() => {
+    document.cookie = ''
+  })
+
+  afterEach(() => {
+    document.cookie = ''
+  })
+
+  it('sets auth and account auth cookies when present', () => {
+    applyVtexAuthCookieFromSwitchResponse({
+      expiresIn: 3600,
+      authCookie: {
+        Name: 'VtexIdclientAutCookie_b2bfaststoredev',
+        Value: 'store-token',
+      },
+      accountAuthCookie: {
+        Name: 'VtexIdclientAutCookie_account',
+        Value: 'account-token',
+      },
+    })
+
+    expect(document.cookie).toContain(
+      'VtexIdclientAutCookie_b2bfaststoredev=store-token'
+    )
+    expect(document.cookie).toContain(
+      'VtexIdclientAutCookie_account=account-token'
+    )
+  })
+})