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

package/test/components/account/OrganizationDrawer.browser.test.tsx

@@ -0,0 +1,197 @@
+/**
+ * @vitest-environment jsdom
+ */
+
+import { fireEvent, render, screen } from '@testing-library/react'
+import type { ReactNode } from 'react'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+const mockFadeOut = vi.hoisted(() => vi.fn())
+const mockUseSession = vi.hoisted(() => vi.fn())
+const mockCloseDrawer = vi.hoisted(() => vi.fn())
+
+vi.mock('@faststore/ui', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('@faststore/ui')>()
+
+  return {
+    ...actual,
+    useFadeEffect: () => ({ fade: 'in', fadeOut: mockFadeOut }),
+    SlideOver: ({
+      children,
+      isOpen,
+      onTransitionEnd,
+    }: {
+      children: ReactNode
+      isOpen: boolean
+      onTransitionEnd?: () => void
+    }) =>
+      isOpen ? (
+        <div
+          data-testid="organization-drawer"
+          onTransitionEnd={onTransitionEnd}
+        >
+          {children}
+        </div>
+      ) : null,
+  }
+})
+
+vi.mock('src/sdk/session', () => ({ useSession: mockUseSession }))
+
+vi.mock(
+  '../../../src/components/account/Drawer/OrganizationDrawer/ContractSwitcher',
+  () => ({
+    ContractSwitcher: ({
+      onBack,
+      onClose,
+    }: {
+      onBack: () => void
+      onClose: () => void
+    }) => (
+      <div data-testid="contract-switcher">
+        <button type="button" onClick={onBack}>
+          Back to menu
+        </button>
+        <button type="button" onClick={onClose}>
+          Close switcher
+        </button>
+      </div>
+    ),
+  })
+)
+
+vi.mock(
+  '../../../src/components/account/Drawer/OrganizationDrawer/OrganizationDrawerBody',
+  () => ({
+    OrganizationDrawerBody: () => <nav data-fs-organization-drawer-body />,
+  })
+)
+
+import { OrganizationDrawer } from '../../../src/components/account/Drawer/OrganizationDrawer/OrganizationDrawer'
+
+describe('OrganizationDrawer', () => {
+  beforeEach(() => {
+    mockUseSession.mockReturnValue({
+      b2b: {
+        unitId: 'unit-1',
+        unitName: 'Stellar Global',
+        contractName: 'Acme Contract',
+        userName: 'Jane Buyer',
+        userEmail: 'jane@example.com',
+        organizationManager: true,
+      },
+      person: { givenName: 'Jane' },
+    })
+  })
+
+  afterEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('renders the menu view with contract details and manage footer', () => {
+    render(
+      <OrganizationDrawer
+        isOpen
+        closeDrawer={mockCloseDrawer}
+        isRepresentative={false}
+      />
+    )
+
+    expect(screen.getByText('Acme Contract')).toBeTruthy()
+    expect(screen.getByText('Stellar Global')).toBeTruthy()
+    expect(screen.getByText('Jane Buyer')).toBeTruthy()
+    expect(screen.getByRole('link', { name: /manage/i })).toBeTruthy()
+    expect(screen.getByRole('button', { name: /change/i })).toBeTruthy()
+  })
+
+  it('opens the contract switcher and returns to the menu on back', () => {
+    render(
+      <OrganizationDrawer
+        isOpen
+        closeDrawer={mockCloseDrawer}
+        isRepresentative={false}
+      />
+    )
+
+    fireEvent.click(screen.getByRole('button', { name: /change/i }))
+    expect(screen.getByTestId('contract-switcher')).toBeTruthy()
+
+    fireEvent.click(screen.getByRole('button', { name: /back to menu/i }))
+    expect(screen.queryByTestId('contract-switcher')).toBeNull()
+    expect(screen.getByRole('button', { name: /change/i })).toBeTruthy()
+  })
+
+  it('resets to the menu when the drawer closes', () => {
+    const { rerender } = render(
+      <OrganizationDrawer
+        isOpen
+        closeDrawer={mockCloseDrawer}
+        isRepresentative={false}
+      />
+    )
+
+    fireEvent.click(screen.getByRole('button', { name: /change/i }))
+    expect(screen.getByTestId('contract-switcher')).toBeTruthy()
+
+    rerender(
+      <OrganizationDrawer
+        isOpen={false}
+        closeDrawer={mockCloseDrawer}
+        isRepresentative={false}
+      />
+    )
+
+    rerender(
+      <OrganizationDrawer
+        isOpen
+        closeDrawer={mockCloseDrawer}
+        isRepresentative={false}
+      />
+    )
+
+    expect(screen.queryByTestId('contract-switcher')).toBeNull()
+    expect(screen.getByRole('button', { name: /change/i })).toBeTruthy()
+  })
+
+  it('falls back to person name when contract metadata is missing', () => {
+    mockUseSession.mockReturnValue({
+      b2b: {
+        unitId: 'unit-1',
+        userName: 'Jane Buyer',
+      },
+      person: { givenName: 'Jane' },
+    })
+
+    render(
+      <OrganizationDrawer
+        isOpen
+        closeDrawer={mockCloseDrawer}
+        isRepresentative={false}
+      />
+    )
+
+    expect(screen.getByRole('heading', { name: 'Jane', level: 1 })).toBeTruthy()
+  })
+
+  it('hides contract switching when the buyer has no organization unit', () => {
+    mockUseSession.mockReturnValue({
+      b2b: {
+        userName: 'Jane Buyer',
+      },
+      person: null,
+    })
+
+    render(
+      <OrganizationDrawer
+        isOpen
+        closeDrawer={mockCloseDrawer}
+        isRepresentative={false}
+      />
+    )
+
+    expect(screen.queryByRole('button', { name: /change/i })).toBeNull()
+    expect(
+      screen.getByRole('heading', { name: 'Organization', level: 1 })
+    ).toBeTruthy()
+  })
+})

package/test/components/account/OrganizationDrawerFooter.browser.test.tsx

@@ -0,0 +1,54 @@
+/**
+ * @vitest-environment jsdom
+ */
+
+import { fireEvent, render, screen } from '@testing-library/react'
+import { describe, expect, it, vi } from 'vitest'
+
+import { OrganizationDrawerFooter } from '../../../src/components/account/Drawer/OrganizationDrawer/OrganizationDrawerFooter'
+
+describe('OrganizationDrawerFooter', () => {
+  it('renders org and user details with optional email', () => {
+    render(
+      <OrganizationDrawerFooter
+        orgName="Stellar Global"
+        userName="Jane Buyer"
+        userEmail="jane@example.com"
+      />
+    )
+
+    expect(screen.getByText('Stellar Global')).toBeTruthy()
+    expect(screen.getByText('Jane Buyer')).toBeTruthy()
+    expect(screen.getByText('jane@example.com')).toBeTruthy()
+  })
+
+  it('shows manage link for organization managers', () => {
+    render(
+      <OrganizationDrawerFooter
+        orgName="Stellar Global"
+        userName="Jane Buyer"
+        showManageLink
+        manageUrl="/pvt/organization-account/org-unit/unit-1"
+      />
+    )
+
+    expect(
+      screen.getByRole('link', { name: /manage/i }).getAttribute('href')
+    ).toBe('/pvt/organization-account/org-unit/unit-1')
+  })
+
+  it('calls onLogoutClick from the logout button', () => {
+    const onLogoutClick = vi.fn()
+
+    render(
+      <OrganizationDrawerFooter
+        orgName="Stellar Global"
+        userName="Jane Buyer"
+        onLogoutClick={onLogoutClick}
+      />
+    )
+
+    fireEvent.click(screen.getByRole('button', { name: /log out/i }))
+    expect(onLogoutClick).toHaveBeenCalledTimes(1)
+  })
+})

package/test/components/account/OrganizationDrawerHeader.browser.test.tsx

@@ -0,0 +1,55 @@
+/**
+ * @vitest-environment jsdom
+ */
+
+import { fireEvent, render, screen } from '@testing-library/react'
+import { describe, expect, it, vi } from 'vitest'
+
+import { OrganizationDrawerHeader } from '../../../src/components/account/Drawer/OrganizationDrawer/OrganizationDrawerHeader'
+
+describe('OrganizationDrawerHeader', () => {
+  it('renders contract name fallback initial and links when contractUrl is set', () => {
+    render(
+      <OrganizationDrawerHeader
+        contractName="Acme Corp"
+        contractUrl="/pvt/organization-account/org-unit/unit-1"
+        onCloseDrawer={vi.fn()}
+      />
+    )
+
+    expect(screen.getByText('Acme Corp')).toBeTruthy()
+    expect(screen.getByLabelText('Acme Corp').getAttribute('href')).toBe(
+      '/pvt/organization-account/org-unit/unit-1'
+    )
+    expect(screen.getByText('A')).toBeTruthy()
+  })
+
+  it('shows default star and Change action when configured', () => {
+    const onChangeContract = vi.fn()
+
+    render(
+      <OrganizationDrawerHeader
+        contractName="Acme Corp"
+        contractUrl={null}
+        isDefault
+        onChangeContract={onChangeContract}
+      />
+    )
+
+    fireEvent.click(screen.getByRole('button', { name: /change/i }))
+    expect(onChangeContract).toHaveBeenCalledTimes(1)
+  })
+
+  it('renders custom contract image and omits manage links without contractUrl', () => {
+    render(
+      <OrganizationDrawerHeader
+        contractName="Acme Corp"
+        contractUrl={null}
+        contractImage={<img alt="Logo" src="/logo.png" />}
+      />
+    )
+
+    expect(screen.getByAltText('Logo')).toBeTruthy()
+    expect(screen.queryByRole('link', { name: /acme corp/i })).toBeNull()
+  })
+})

package/test/components/account/doLogout.browser.test.ts

@@ -0,0 +1,102 @@
+/**
+ * @vitest-environment jsdom
+ */
+
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+const mockFetch = vi.hoisted(() => vi.fn())
+const mockAssign = vi.hoisted(() => vi.fn())
+const mockDel = vi.hoisted(() => vi.fn())
+const mockSetReloadAfterLogoutReturn = vi.hoisted(() => vi.fn())
+const mockGetStoreURL = vi.hoisted(() => vi.fn())
+const mockExpireCookieClient = vi.hoisted(() => vi.fn())
+
+vi.stubGlobal('fetch', mockFetch)
+vi.mock('idb-keyval', () => ({ del: mockDel }))
+vi.mock('src/sdk/localization/useLocalizationConfig', () => ({
+  getStoreURL: mockGetStoreURL,
+}))
+vi.mock(
+  '../../../src/components/account/Drawer/OrganizationDrawer/useReloadAfterLogoutReturn',
+  () => ({
+    setReloadAfterLogoutReturn: mockSetReloadAfterLogoutReturn,
+  })
+)
+vi.mock('src/utils/clearCookies', () => ({
+  expireCookieClient: mockExpireCookieClient,
+  getCookieDomains: () => ['.example.com'],
+  getCookiePaths: () => ['/'],
+  getVtexCookieNames: (names: string[]) =>
+    names.filter((name) => /vtex/i.test(name)),
+}))
+vi.mock('../../../discovery.config', () => ({
+  default: {
+    secureSubdomain: 'https://secure.example.com',
+    api: { storeId: 'teststore' },
+  },
+}))
+
+import { doLogout } from '../../../src/components/account/Drawer/OrganizationDrawer/OrganizationDrawer'
+
+describe('doLogout', () => {
+  beforeEach(() => {
+    mockFetch.mockResolvedValue({
+      json: async () => ({}),
+    })
+    mockGetStoreURL.mockReturnValue('https://store.example.com')
+    mockDel.mockResolvedValue(undefined)
+
+    Object.defineProperty(globalThis, 'indexedDB', {
+      configurable: true,
+      value: {
+        deleteDatabase: () => {
+          const request = {
+            onsuccess: null as (() => void) | null,
+            onerror: null,
+            onblocked: null,
+          }
+
+          queueMicrotask(() => request.onsuccess?.())
+
+          return request
+        },
+      },
+    })
+
+    Object.defineProperty(globalThis.window, 'location', {
+      configurable: true,
+      value: {
+        hostname: 'store.example.com',
+        protocol: 'https:',
+        pathname: '/',
+        assign: mockAssign,
+      },
+    })
+
+    document.cookie = 'VtexIdclientAutCookie_teststore=token; other=1'
+    sessionStorage.setItem('faststore_session_ready', '1')
+    sessionStorage.setItem('__fs_gallery_page_1', '1')
+  })
+
+  afterEach(() => {
+    vi.clearAllMocks()
+    sessionStorage.clear()
+    document.cookie = ''
+  })
+
+  it('clears client storage, calls logout API, and redirects to VTEX logout', async () => {
+    await doLogout()
+
+    expect(mockDel).toHaveBeenCalledWith('fs::session')
+    expect(sessionStorage.getItem('faststore_session_ready')).toBeNull()
+    expect(sessionStorage.getItem('__fs_gallery_page_1')).toBeNull()
+    expect(mockFetch).toHaveBeenCalledWith('/api/fs/logout', {
+      method: 'POST',
+      credentials: 'include',
+    })
+    expect(mockSetReloadAfterLogoutReturn).toHaveBeenCalledTimes(1)
+    expect(mockAssign).toHaveBeenCalledWith(
+      'https://secure.example.com/api/vtexid/pub/logout?scope=teststore&returnUrl=https://store.example.com'
+    )
+  })
+})

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'
+    )
+  })
+})

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

@@ -0,0 +1,41 @@
+/**
+ * @vitest-environment jsdom
+ */
+
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+const mockDel = vi.hoisted(() => vi.fn())
+
+vi.mock('idb-keyval', () => ({
+  del: mockDel,
+}))
+
+import { SESSION_READY_KEY } from '../../../src/sdk/session/storageKeys'
+import {
+  STORAGE_KEY_CACHE_BUST_LAST_VALUE,
+  STORAGE_KEY_PERSON_ID,
+} from '../../../src/utils/cookieCacheBusting'
+import { clearPersistedSessionState } from '../../../src/sdk/account/clearPersistedSessionState'
+
+describe('clearPersistedSessionState', () => {
+  beforeEach(() => {
+    mockDel.mockResolvedValue(undefined)
+    sessionStorage.setItem(SESSION_READY_KEY, '1')
+    sessionStorage.setItem(STORAGE_KEY_PERSON_ID, 'person-1')
+    sessionStorage.setItem(STORAGE_KEY_CACHE_BUST_LAST_VALUE, 'abc')
+  })
+
+  afterEach(() => {
+    vi.clearAllMocks()
+    sessionStorage.clear()
+  })
+
+  it('clears IndexedDB session and sessionStorage keys', async () => {
+    await clearPersistedSessionState()
+
+    expect(mockDel).toHaveBeenCalledWith('fs::session')
+    expect(sessionStorage.getItem(SESSION_READY_KEY)).toBeNull()
+    expect(sessionStorage.getItem(STORAGE_KEY_PERSON_ID)).toBeNull()
+    expect(sessionStorage.getItem(STORAGE_KEY_CACHE_BUST_LAST_VALUE)).toBeNull()
+  })
+})

package/test/sdk/account/clearPersistedSessionState.test.ts

@@ -0,0 +1,20 @@
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+const mockDel = vi.hoisted(() => vi.fn())
+
+vi.mock('idb-keyval', () => ({ del: mockDel }))
+
+import { clearPersistedSessionState } from '../../../src/sdk/account/clearPersistedSessionState'
+
+describe('clearPersistedSessionState (node)', () => {
+  afterEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('clears IndexedDB session when sessionStorage is unavailable', async () => {
+    mockDel.mockResolvedValue(undefined)
+
+    await expect(clearPersistedSessionState()).resolves.toBeUndefined()
+    expect(mockDel).toHaveBeenCalledWith('fs::session')
+  })
+})

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

@@ -0,0 +1,34 @@
+/**
+ * @vitest-environment jsdom
+ */
+
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+const mockFetch = vi.hoisted(() => vi.fn())
+
+vi.mock('isomorphic-unfetch', () => ({ __esModule: true, default: mockFetch }))
+
+import { refreshTokenRequest } from '../../../src/sdk/account/refreshToken'
+
+describe('refreshTokenRequest (browser)', () => {
+  beforeEach(() => {
+    mockFetch.mockResolvedValue({
+      status: 200,
+      json: async () => ({ status: 'success' }),
+    })
+  })
+
+  afterEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('uses a relative URL and omits Host header in the browser', async () => {
+    await refreshTokenRequest()
+
+    expect(mockFetch).toHaveBeenCalledTimes(1)
+
+    const [url, init] = mockFetch.mock.calls[0]
+    expect(url).toBe('/api/vtexid/refreshtoken/webstore')
+    expect(init.headers).toEqual({ 'content-type': 'application/json' })
+  })
+})