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

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

@@ -0,0 +1,87 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+const mockFetch = vi.hoisted(() => vi.fn())
+
+vi.mock('isomorphic-unfetch', () => ({ __esModule: true, default: mockFetch }))
+
+vi.mock('src/sdk/localization/useLocalizationConfig', () => ({
+  getStoreURL: () => 'https://b2bfaststore.vtexfaststore.com',
+}))
+
+vi.mock('src/utils/utilities', () => ({
+  sanitizeHost: (origin: string) => origin.replace(/^https?:\/\//, ''),
+}))
+
+import {
+  isRefreshTokenSuccessful,
+  refreshTokenRequest,
+} from '../../../src/sdk/account/refreshToken'
+
+describe('refreshTokenRequest (node)', () => {
+  beforeEach(() => {
+    mockFetch.mockResolvedValue({
+      status: 200,
+      json: async () => ({ status: 'success', refreshAfter: '123' }),
+    })
+  })
+
+  afterEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('posts to the store origin with Host header on the server', async () => {
+    const result = await refreshTokenRequest()
+
+    expect(result).toEqual({ status: 'success', refreshAfter: '123' })
+    expect(mockFetch).toHaveBeenCalledTimes(1)
+
+    const [url, init] = mockFetch.mock.calls[0]
+    expect(url).toBe(
+      'https://b2bfaststore.vtexfaststore.com/api/vtexid/refreshtoken/webstore'
+    )
+    expect(init.method).toBe('POST')
+    expect(init.credentials).toBe('include')
+    expect(init.headers).toMatchObject({
+      'content-type': 'application/json',
+      Host: 'b2bfaststore.vtexfaststore.com',
+    })
+    expect(JSON.parse(init.body as string)).toEqual({})
+  })
+
+  it('retries when the response is not 200 and returns undefined after failures', async () => {
+    mockFetch
+      .mockResolvedValueOnce({ status: 500, json: async () => ({}) })
+      .mockResolvedValueOnce({ status: 500, json: async () => ({}) })
+      .mockResolvedValueOnce({ status: 500, json: async () => ({}) })
+
+    const result = await refreshTokenRequest()
+
+    expect(result).toBeUndefined()
+    expect(mockFetch).toHaveBeenCalledTimes(3)
+  })
+
+  it('retries after network errors and succeeds on a later attempt', async () => {
+    mockFetch
+      .mockRejectedValueOnce(new Error('network'))
+      .mockResolvedValueOnce({
+        status: 200,
+        json: async () => ({ status: 'success' }),
+      })
+
+    const result = await refreshTokenRequest()
+
+    expect(result).toEqual({ status: 'success' })
+    expect(mockFetch).toHaveBeenCalledTimes(2)
+  })
+})
+
+describe('isRefreshTokenSuccessful', () => {
+  it('returns true when status is success (case-insensitive)', () => {
+    expect(isRefreshTokenSuccessful({ status: 'Success' })).toBe(true)
+  })
+
+  it('returns false when status is missing or not success', () => {
+    expect(isRefreshTokenSuccessful(undefined)).toBe(false)
+    expect(isRefreshTokenSuccessful({ status: 'failed' })).toBe(false)
+  })
+})

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

@@ -0,0 +1,124 @@
+/**
+ * @vitest-environment jsdom
+ */
+
+import { renderHook } from '@testing-library/react'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+const mockUseSession = vi.hoisted(() => vi.fn())
+const mockUseQuery = vi.hoisted(() => vi.fn())
+
+vi.mock('@generated', () => ({ gql: (query: unknown) => query }))
+vi.mock('src/sdk/session', () => ({ useSession: mockUseSession }))
+vi.mock('src/sdk/graphql/useQuery', () => ({ useQuery: mockUseQuery }))
+
+import { useAvailableContracts } from '../../../src/sdk/account/useAvailableContracts'
+
+const contracts = [
+  { id: 'a', corporateName: 'Corp A', isActive: true },
+  { id: 'b', corporateName: 'Corp B', isActive: false },
+]
+
+describe('useAvailableContracts', () => {
+  afterEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('skips the query when the hook is disabled', () => {
+    mockUseSession.mockReturnValue({ b2b: { unitId: 'unit-1' } })
+    mockUseQuery.mockReturnValue({
+      data: undefined,
+      error: null,
+      isValidating: false,
+    })
+
+    const { result } = renderHook(() => useAvailableContracts(false))
+
+    expect(result.current.contracts).toEqual([])
+    expect(result.current.loading).toBe(false)
+    expect(mockUseQuery).toHaveBeenCalledWith(
+      expect.anything(),
+      { orgUnitId: 'unit-1' },
+      expect.objectContaining({ doNotRun: true })
+    )
+  })
+
+  it('skips the query when orgUnitId is missing', () => {
+    mockUseSession.mockReturnValue({ b2b: { unitId: '' } })
+    mockUseQuery.mockReturnValue({
+      data: undefined,
+      error: null,
+      isValidating: false,
+    })
+
+    const { result } = renderHook(() => useAvailableContracts(true))
+
+    expect(result.current.contracts).toEqual([])
+    expect(mockUseQuery).toHaveBeenCalledWith(
+      expect.anything(),
+      { orgUnitId: '' },
+      expect.objectContaining({ doNotRun: true })
+    )
+  })
+
+  it('returns loading while fetching contracts for the current org unit', () => {
+    mockUseSession.mockReturnValue({ b2b: { unitId: 'unit-1' } })
+    mockUseQuery.mockReturnValue({
+      data: undefined,
+      error: null,
+      isValidating: false,
+    })
+
+    const { result } = renderHook(() => useAvailableContracts(true))
+
+    expect(result.current.loading).toBe(true)
+    expect(result.current.contracts).toEqual([])
+    expect(mockUseQuery).toHaveBeenCalledWith(
+      expect.anything(),
+      { orgUnitId: 'unit-1' },
+      expect.objectContaining({ doNotRun: false, dedupingInterval: 0 })
+    )
+  })
+
+  it('returns contracts when the query succeeds', () => {
+    mockUseSession.mockReturnValue({ b2b: { unitId: 'unit-1' } })
+    mockUseQuery.mockReturnValue({
+      data: { availableContracts: contracts },
+      error: null,
+      isValidating: false,
+    })
+
+    const { result } = renderHook(() => useAvailableContracts(true))
+
+    expect(result.current.contracts).toEqual(contracts)
+    expect(result.current.error).toBeNull()
+    expect(result.current.loading).toBe(false)
+  })
+
+  it('returns query errors without loading', () => {
+    mockUseSession.mockReturnValue({ b2b: { unitId: 'unit-1' } })
+    mockUseQuery.mockReturnValue({
+      data: undefined,
+      error: new Error('boom'),
+      isValidating: false,
+    })
+
+    const { result } = renderHook(() => useAvailableContracts(true))
+
+    expect(result.current.error).toBeInstanceOf(Error)
+    expect(result.current.loading).toBe(false)
+  })
+
+  it('keeps loading while the query is validating', () => {
+    mockUseSession.mockReturnValue({ b2b: { unitId: 'unit-1' } })
+    mockUseQuery.mockReturnValue({
+      data: { availableContracts: contracts },
+      error: null,
+      isValidating: true,
+    })
+
+    const { result } = renderHook(() => useAvailableContracts(true))
+
+    expect(result.current.loading).toBe(true)
+  })
+})

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

@@ -0,0 +1,111 @@
+/**
+ * @vitest-environment jsdom
+ */
+
+import { act, renderHook, waitFor } from '@testing-library/react'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+const mockReload = vi.hoisted(() => vi.fn())
+const mockClearPersistedSessionState = vi.hoisted(() => vi.fn())
+
+vi.mock('src/sdk/account/clearPersistedSessionState', () => ({
+  clearPersistedSessionState: mockClearPersistedSessionState,
+}))
+
+import * as changeContractTokenModule from '../../../src/sdk/account/changeContractToken'
+import { useSwitchContract } from '../../../src/sdk/account/useSwitchContract'
+
+describe('useSwitchContract', () => {
+  beforeEach(() => {
+    mockClearPersistedSessionState.mockResolvedValue(undefined)
+    mockReload.mockReset()
+    Object.defineProperty(globalThis.window, 'location', {
+      configurable: true,
+      value: { ...globalThis.window.location, reload: mockReload },
+    })
+    vi.spyOn(
+      changeContractTokenModule,
+      'changeContractToken'
+    ).mockResolvedValue(false)
+  })
+
+  afterEach(() => {
+    vi.clearAllMocks()
+    vi.restoreAllMocks()
+  })
+
+  it('does not clear session or reload when switch-properties returns false', async () => {
+    const { result } = renderHook(() => useSwitchContract())
+
+    let ok: boolean | undefined
+    await act(async () => {
+      ok = await result.current.switchContract('contract-2')
+    })
+
+    expect(ok).toBe(false)
+    expect(mockClearPersistedSessionState).not.toHaveBeenCalled()
+    expect(mockReload).not.toHaveBeenCalled()
+    expect(result.current.enabled).toBe(true)
+
+    await waitFor(() => expect(result.current.error).toBeInstanceOf(Error))
+  })
+
+  it('clears persisted session and reloads after a successful switch (REQ-06)', async () => {
+    vi.spyOn(
+      changeContractTokenModule,
+      'changeContractToken'
+    ).mockResolvedValueOnce(true)
+
+    const { result } = renderHook(() => useSwitchContract())
+
+    let ok: boolean | undefined
+    await act(async () => {
+      ok = await result.current.switchContract('contract-2')
+    })
+
+    expect(ok).toBe(true)
+    expect(mockClearPersistedSessionState).toHaveBeenCalledTimes(1)
+    expect(mockReload).toHaveBeenCalledTimes(1)
+    expect(result.current.error).toBeNull()
+  })
+
+  it('surfaces an error when switch-properties fails', async () => {
+    vi.spyOn(
+      changeContractTokenModule,
+      'changeContractToken'
+    ).mockRejectedValueOnce(new Error('switch failed'))
+
+    const { result } = renderHook(() => useSwitchContract())
+
+    let ok: boolean | undefined
+    await act(async () => {
+      ok = await result.current.switchContract('contract-2')
+    })
+
+    expect(ok).toBe(false)
+    expect(mockClearPersistedSessionState).not.toHaveBeenCalled()
+    expect(mockReload).not.toHaveBeenCalled()
+
+    await waitFor(() => expect(result.current.error).toBeInstanceOf(Error))
+  })
+
+  it('normalizes non-Error failures from switch-properties', async () => {
+    vi.spyOn(
+      changeContractTokenModule,
+      'changeContractToken'
+    ).mockRejectedValueOnce('unexpected')
+
+    const { result } = renderHook(() => useSwitchContract())
+
+    let ok: boolean | undefined
+    await act(async () => {
+      ok = await result.current.switchContract('contract-2')
+    })
+
+    expect(ok).toBe(false)
+
+    await waitFor(() =>
+      expect(result.current.error?.message).toBe('Failed to switch contract')
+    )
+  })
+})

package/test/sdk/analytics/useStartRecommendationSession.test.ts

@@ -0,0 +1,69 @@
+/**
+ * @vitest-environment jsdom
+ */
+
+import { renderHook, waitFor } from '@testing-library/react'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+vi.mock('@faststore/core/api', () => ({
+  gql: (s: string) => ({ __meta__: {}, query: s }),
+}))
+
+const runStartRecommendationSession = vi.hoisted(() => vi.fn())
+const useLazyQueryMock = vi.hoisted(() => vi.fn())
+vi.mock('src/sdk/graphql/useLazyQuery', () => ({
+  useLazyQuery: useLazyQueryMock,
+}))
+
+const getCookie = vi.hoisted(() => vi.fn())
+vi.mock('src/utils/getCookie', () => ({ getCookie }))
+
+const storeConfigMock = vi.hoisted(() => ({
+  experimental: { enableRecommendations: true },
+}))
+vi.mock('discovery.config', () => ({ default: storeConfigMock }))
+
+import { useStartRecommendationSession } from 'src/sdk/analytics/hooks/useStartRecommendationSession'
+
+beforeEach(() => {
+  useLazyQueryMock.mockReturnValue([runStartRecommendationSession, {}])
+  runStartRecommendationSession.mockResolvedValue(true)
+  storeConfigMock.experimental.enableRecommendations = true
+})
+
+afterEach(() => {
+  vi.clearAllMocks()
+})
+
+describe('useStartRecommendationSession', () => {
+  it('does not start a session when the session cookie already exists', async () => {
+    getCookie.mockReturnValue('already-started')
+
+    renderHook(() => useStartRecommendationSession())
+
+    await waitFor(() => {
+      expect(runStartRecommendationSession).not.toHaveBeenCalled()
+    })
+  })
+
+  it('starts a session when no session cookie is present', async () => {
+    getCookie.mockReturnValue(undefined)
+
+    renderHook(() => useStartRecommendationSession())
+
+    await waitFor(() => {
+      expect(runStartRecommendationSession).toHaveBeenCalled()
+    })
+  })
+
+  it('does not start a session when recommendations are disabled', async () => {
+    storeConfigMock.experimental.enableRecommendations = false
+    getCookie.mockReturnValue(undefined)
+
+    renderHook(() => useStartRecommendationSession())
+
+    await waitFor(() => {
+      expect(runStartRecommendationSession).not.toHaveBeenCalled()
+    })
+  })
+})

package/test/sdk/analytics/utils.test.ts

@@ -0,0 +1,23 @@
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+const mockGetCookie = vi.hoisted(() => vi.fn())
+vi.mock('src/utils/getCookie', () => ({ getCookie: mockGetCookie }))
+
+import { getUserIdFromCookie } from 'src/sdk/analytics/utils'
+
+afterEach(() => {
+  vi.clearAllMocks()
+  vi.unstubAllGlobals()
+})
+
+describe('getUserIdFromCookie', () => {
+  it('returns the cookie value when present', () => {
+    mockGetCookie.mockReturnValue('user-123')
+    expect(getUserIdFromCookie()).toBe('user-123')
+  })
+
+  it('falls back to an empty string when the cookie is missing', () => {
+    mockGetCookie.mockReturnValue(undefined)
+    expect(getUserIdFromCookie()).toBe('')
+  })
+})

package/test/server/index.test.ts

@@ -78,10 +78,12 @@ const QUERIES = [
   'userDetails',
   'accountProfile',
   'validateUser',
+  'availableContracts',
   'isOrganizationMember',
   'pickupPoints',
   'orderEntryOperation',
   'orderFormItems',
+  'recommendations',
 ]
 
 const OPTIONAL_GENERATED_QUERIES = new Set(['accountName'])
@@ -94,6 +96,7 @@ const MUTATIONS = [
   'processOrderAuthorization',
   'uploadFileToOrderEntry',
   'startOrderEntryOperation',
+  'startRecommendationSession',
 ]
 
 describe('FastStore GraphQL Layer', () => {

package/test/utils/retry.test.ts

@@ -0,0 +1,59 @@
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+import { retry } from 'src/utils/retry'
+
+afterEach(() => {
+  vi.clearAllMocks()
+})
+
+describe('retry', () => {
+  it('resolves immediately when the value is already available', async () => {
+    const fn = vi.fn(() => 'ready')
+
+    await expect(retry(fn)).resolves.toBe('ready')
+    expect(fn).toHaveBeenCalledTimes(1)
+  })
+
+  it('retries until a truthy value is returned', async () => {
+    const fn = vi
+      .fn<() => string>()
+      .mockReturnValueOnce('')
+      .mockReturnValueOnce('')
+      .mockReturnValue('later')
+
+    await expect(retry(fn, { attempts: 5, delayMs: 1 })).resolves.toBe('later')
+    expect(fn).toHaveBeenCalledTimes(3)
+  })
+
+  it('gives up after exhausting the retry budget', async () => {
+    const fn = vi.fn(() => '')
+
+    await expect(retry(fn, { attempts: 2, delayMs: 1 })).resolves.toBe('')
+    // initial call + 2 retries
+    expect(fn).toHaveBeenCalledTimes(3)
+  })
+
+  it('honours a custom `until` predicate', async () => {
+    const fn = vi
+      .fn<() => number | undefined>()
+      .mockReturnValueOnce(undefined)
+      .mockReturnValue(0)
+
+    await expect(
+      retry(fn, { attempts: 5, delayMs: 1, until: (v) => v !== undefined })
+    ).resolves.toBe(0)
+    expect(fn).toHaveBeenCalledTimes(2)
+  })
+
+  it('stops retrying once the signal is aborted', async () => {
+    const controller = new AbortController()
+    const fn = vi.fn(() => '')
+    controller.abort()
+
+    await expect(
+      retry(fn, { attempts: 5, delayMs: 1, signal: controller.signal })
+    ).resolves.toBe('')
+    // Only the initial call runs; the loop never starts because it is aborted.
+    expect(fn).toHaveBeenCalledTimes(1)
+  })
+})