@faststore/core 4.10.0-dev.0 → 4.10.0

package/test/sdk/deliveryPromise/provider.effect.test.tsx

@@ -0,0 +1,440 @@
+/**
+ * @vitest-environment jsdom
+ */
+import { act, render, waitFor } from '@testing-library/react'
+import type { Dispatch } from 'react'
+import { useEffect } from 'react'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import type { DeliveryPromiseReducerAction } from '../../../src/sdk/deliveryPromise/reducer'
+
+const { getPickupPoints, session } = vi.hoisted(() => ({
+  getPickupPoints: vi.fn(),
+  session: {
+    postalCode: '01310100' as string | null,
+    country: 'BRA' as string | null,
+    channel: '{"salesChannel":"1"}' as string | null,
+    geoCoordinates: { latitude: -23.5, longitude: -46.6 } as {
+      latitude: number
+      longitude: number
+    } | null,
+  },
+}))
+
+vi.mock('src/sdk/session', () => ({
+  useSession: () => session,
+}))
+
+vi.mock('../../../src/sdk/deliveryPromise/queries', () => ({
+  getPickupPoints,
+}))
+
+import {
+  DeliveryPromiseProvider,
+  useDeliveryPromiseContext,
+} from '../../../src/sdk/deliveryPromise/provider'
+import { deliveryPromiseStore } from '../../../src/sdk/deliveryPromise/useDeliveryPromise'
+
+// Mirrors the store → reducer subscription in useDeliveryPromise.
+// This suite does not cover that hook: if the hook stops syncing, these tests still pass.
+function StoreSync() {
+  const { dispatchDeliveryPromiseAction } = useDeliveryPromiseContext()
+
+  useEffect(() => {
+    return deliveryPromiseStore.subscribe((storeValue) => {
+      dispatchDeliveryPromiseAction({
+        type: 'updateDeliveryPromiseState',
+        payload: storeValue,
+      })
+    })
+  }, [dispatchDeliveryPromiseAction])
+
+  return null
+}
+
+function renderProvider(
+  onDispatch: (dispatch: Dispatch<DeliveryPromiseReducerAction>) => void,
+  onLoadingFlag?: (shouldUpdatePickupPoints: boolean) => void
+) {
+  return render(
+    <DeliveryPromiseProvider>
+      <StoreSync />
+      <DispatchBridge onDispatch={onDispatch} />
+      {onLoadingFlag ? <LoadingFlagProbe onFlag={onLoadingFlag} /> : null}
+    </DeliveryPromiseProvider>
+  )
+}
+
+function LoadingFlagProbe({
+  onFlag,
+}: {
+  onFlag: (shouldUpdatePickupPoints: boolean) => void
+}) {
+  const { shouldUpdatePickupPoints } = useDeliveryPromiseContext()
+
+  useEffect(() => {
+    onFlag(shouldUpdatePickupPoints)
+  }, [onFlag, shouldUpdatePickupPoints])
+
+  return null
+}
+
+function DispatchBridge({
+  onDispatch,
+}: {
+  onDispatch: (dispatch: Dispatch<DeliveryPromiseReducerAction>) => void
+}) {
+  const { dispatchDeliveryPromiseAction } = useDeliveryPromiseContext()
+
+  useEffect(() => {
+    onDispatch(dispatchDeliveryPromiseAction)
+  }, [dispatchDeliveryPromiseAction, onDispatch])
+
+  return null
+}
+
+function deferred<T>() {
+  let resolve: (value: T) => void = () => {}
+  let reject: (error: unknown) => void = () => {}
+  const promise = new Promise<T>((res, rej) => {
+    resolve = res
+    reject = rej
+  })
+
+  return { promise, resolve, reject }
+}
+
+describe('DeliveryPromiseProvider pickup fetch', () => {
+  let dispatch: Dispatch<DeliveryPromiseReducerAction> = () => {}
+  const captureDispatch = (next: Dispatch<DeliveryPromiseReducerAction>) => {
+    dispatch = next
+  }
+
+  beforeEach(() => {
+    getPickupPoints.mockReset()
+    session.postalCode = '01310100'
+    session.country = 'BRA'
+    session.channel = '{"salesChannel":"1"}'
+    session.geoCoordinates = { latitude: -23.5, longitude: -46.6 }
+    deliveryPromiseStore.set({
+      pickupPoints: [],
+      defaultPickupPoint: null,
+      globalPickupPoint: null,
+      shouldUpdatePickupPoints: false,
+      simulatePickupPoints: false,
+      pickupPointsSimulation: {
+        pickupPoints: [],
+        geoCoordinates: null,
+        postalCode: null,
+        country: null,
+      },
+    })
+  })
+
+  it('loads pickup points for the shopper channel', async () => {
+    getPickupPoints.mockResolvedValueOnce([
+      { id: 'vendemo_sp', name: 'VTEX SP' },
+    ])
+
+    renderProvider(captureDispatch)
+
+    await act(async () => {
+      dispatch({
+        type: 'onPostalCodeChange',
+        payload: {
+          simulatePickupPoints: false,
+          validatedSession: { postalCode: '01310100', country: 'BRA' },
+        },
+      })
+    })
+
+    await waitFor(() => {
+      expect(deliveryPromiseStore.read()?.pickupPoints).toEqual([
+        { id: 'vendemo_sp', name: 'VTEX SP' },
+      ])
+    })
+    expect(getPickupPoints).toHaveBeenCalledWith({
+      geoCoordinates: session.geoCoordinates,
+      postalCode: '01310100',
+      country: 'BRA',
+      channel: '{"salesChannel":"1"}',
+    })
+  })
+
+  it('keeps the newer response when the channel changes mid-request', async () => {
+    const first = deferred<Array<{ id: string; name: string }>>()
+    const second = deferred<Array<{ id: string; name: string }>>()
+    getPickupPoints
+      .mockImplementationOnce(() => first.promise)
+      .mockImplementationOnce(() => second.promise)
+
+    const view = renderProvider(captureDispatch)
+
+    await act(async () => {
+      dispatch({
+        type: 'onPostalCodeChange',
+        payload: {
+          simulatePickupPoints: false,
+          validatedSession: { postalCode: '01310100', country: 'BRA' },
+        },
+      })
+    })
+
+    session.channel = '{"salesChannel":"2"}'
+    view.rerender(
+      <DeliveryPromiseProvider>
+        <StoreSync />
+        <DispatchBridge onDispatch={captureDispatch} />
+      </DeliveryPromiseProvider>
+    )
+
+    await waitFor(() => {
+      expect(getPickupPoints).toHaveBeenCalledTimes(2)
+    })
+
+    await act(async () => {
+      second.resolve([{ id: 'vendemo_rio', name: 'VTEX Rio' }])
+    })
+    await act(async () => {
+      first.resolve([{ id: 'vendemo_stale', name: 'Stale' }])
+    })
+
+    await waitFor(() => {
+      expect(deliveryPromiseStore.read()?.pickupPoints).toEqual([
+        { id: 'vendemo_rio', name: 'VTEX Rio' },
+      ])
+    })
+    expect(getPickupPoints).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({ channel: '{"salesChannel":"2"}' })
+    )
+  })
+
+  it('drops a response that arrives after the postal code is cleared', async () => {
+    const pending = deferred<Array<{ id: string; name: string }>>()
+    getPickupPoints.mockImplementationOnce(() => pending.promise)
+
+    const view = renderProvider(captureDispatch)
+
+    await act(async () => {
+      dispatch({
+        type: 'onPostalCodeChange',
+        payload: {
+          simulatePickupPoints: false,
+          validatedSession: { postalCode: '01310100', country: 'BRA' },
+        },
+      })
+    })
+
+    await waitFor(() => {
+      expect(getPickupPoints).toHaveBeenCalledTimes(1)
+    })
+
+    session.postalCode = null
+    view.rerender(
+      <DeliveryPromiseProvider>
+        <StoreSync />
+        <DispatchBridge onDispatch={captureDispatch} />
+      </DeliveryPromiseProvider>
+    )
+
+    await act(async () => {
+      pending.resolve([{ id: 'vendemo_stale', name: 'Stale' }])
+    })
+
+    expect(deliveryPromiseStore.read()?.pickupPoints).toEqual([])
+  })
+
+  it('clears the loading flag after a failed request and retries on the next update', async () => {
+    getPickupPoints
+      .mockRejectedValueOnce(new Error('network'))
+      .mockResolvedValueOnce([{ id: 'vendemo_sp', name: 'VTEX SP' }])
+
+    let shouldUpdatePickupPoints = true
+    renderProvider(captureDispatch, (flag) => {
+      shouldUpdatePickupPoints = flag
+    })
+
+    await act(async () => {
+      dispatch({
+        type: 'onPostalCodeChange',
+        payload: {
+          simulatePickupPoints: false,
+          validatedSession: { postalCode: '01310100', country: 'BRA' },
+        },
+      })
+    })
+
+    await waitFor(() => {
+      expect(getPickupPoints).toHaveBeenCalledTimes(1)
+    })
+    await waitFor(() => {
+      expect(shouldUpdatePickupPoints).toBe(false)
+    })
+
+    await act(async () => {
+      dispatch({
+        type: 'onPostalCodeChange',
+        payload: {
+          simulatePickupPoints: false,
+          validatedSession: { postalCode: '01310100', country: 'BRA' },
+        },
+      })
+    })
+
+    await waitFor(() => {
+      expect(deliveryPromiseStore.read()?.pickupPoints).toEqual([
+        { id: 'vendemo_sp', name: 'VTEX SP' },
+      ])
+    })
+    expect(getPickupPoints).toHaveBeenCalledTimes(2)
+  })
+
+  it('stores a simulated postal code without replacing the session list', async () => {
+    getPickupPoints.mockResolvedValueOnce([
+      { id: 'vendemo_rio', name: 'VTEX Rio' },
+    ])
+
+    renderProvider(captureDispatch)
+
+    await act(async () => {
+      dispatch({
+        type: 'onPostalCodeChange',
+        payload: {
+          simulatePickupPoints: true,
+          validatedSession: {
+            postalCode: '22041080',
+            country: 'BRA',
+            geoCoordinates: { latitude: -22.95, longitude: -43.19 },
+          },
+        },
+      })
+    })
+
+    await waitFor(() => {
+      expect(
+        deliveryPromiseStore.read()?.pickupPointsSimulation?.pickupPoints
+      ).toEqual([{ id: 'vendemo_rio', name: 'VTEX Rio' }])
+    })
+    expect(getPickupPoints).toHaveBeenCalledWith(
+      expect.objectContaining({
+        postalCode: '22041080',
+        country: 'BRA',
+        geoCoordinates: { latitude: -22.95, longitude: -43.19 },
+      })
+    )
+    expect(deliveryPromiseStore.read()?.pickupPoints).toEqual([])
+  })
+
+  it('clears the simulated list when the next postal code fails', async () => {
+    getPickupPoints
+      .mockResolvedValueOnce([{ id: 'vendemo_sp', name: 'VTEX SP' }])
+      .mockRejectedValueOnce(new Error('network'))
+
+    renderProvider(captureDispatch)
+
+    await act(async () => {
+      dispatch({
+        type: 'onPostalCodeChange',
+        payload: {
+          simulatePickupPoints: true,
+          validatedSession: { postalCode: '01310100', country: 'BRA' },
+        },
+      })
+    })
+
+    await waitFor(() => {
+      expect(
+        deliveryPromiseStore.read()?.pickupPointsSimulation?.pickupPoints
+      ).toEqual([{ id: 'vendemo_sp', name: 'VTEX SP' }])
+    })
+
+    await act(async () => {
+      dispatch({
+        type: 'onPostalCodeChange',
+        payload: {
+          simulatePickupPoints: true,
+          validatedSession: { postalCode: '22041080', country: 'BRA' },
+        },
+      })
+    })
+
+    await waitFor(() => {
+      expect(
+        deliveryPromiseStore.read()?.pickupPointsSimulation?.pickupPoints
+      ).toEqual([])
+    })
+    expect(deliveryPromiseStore.read()?.pickupPoints).toEqual([])
+    expect(deliveryPromiseStore.read()?.shouldUpdatePickupPoints).toBe(false)
+  })
+
+  it('keeps the selected store when it is still in the new list', async () => {
+    const point = { id: 'vendemo_sp', name: 'VTEX SP' }
+    getPickupPoints.mockResolvedValueOnce([point])
+
+    renderProvider(captureDispatch)
+
+    await act(async () => {
+      dispatch({ type: 'changeGlobalPickupPoint', payload: point })
+      dispatch({
+        type: 'onPostalCodeChange',
+        payload: {
+          simulatePickupPoints: false,
+          validatedSession: { postalCode: '01310100', country: 'BRA' },
+        },
+      })
+    })
+
+    await waitFor(() => {
+      expect(deliveryPromiseStore.read()?.globalPickupPoint).toEqual(point)
+    })
+  })
+
+  it('clears the selected store when it is missing from the new list', async () => {
+    getPickupPoints.mockResolvedValueOnce([
+      { id: 'vendemo_rio', name: 'VTEX Rio' },
+    ])
+
+    renderProvider(captureDispatch)
+
+    await act(async () => {
+      dispatch({
+        type: 'changeGlobalPickupPoint',
+        payload: { id: 'vendemo_sp', name: 'VTEX SP' },
+      })
+      dispatch({
+        type: 'onPostalCodeChange',
+        payload: {
+          simulatePickupPoints: false,
+          validatedSession: { postalCode: '01310100', country: 'BRA' },
+        },
+      })
+    })
+
+    await waitFor(() => {
+      expect(deliveryPromiseStore.read()?.globalPickupPoint).toBeNull()
+    })
+  })
+
+  it('does not rewrite the list when the fetched points are unchanged', async () => {
+    const point = { id: 'vendemo_sp', name: 'VTEX SP' }
+    getPickupPoints.mockResolvedValueOnce([point])
+
+    renderProvider(captureDispatch)
+
+    await act(async () => {
+      dispatch({
+        type: 'updatePickupPoints',
+        payload: {
+          pickupPoints: [point],
+          shouldUpdatePickupPoints: true,
+        },
+      })
+    })
+
+    await waitFor(() => {
+      expect(getPickupPoints).toHaveBeenCalledTimes(1)
+    })
+    expect(deliveryPromiseStore.read()?.pickupPoints).toEqual([])
+  })
+})

package/test/sdk/deliveryPromise/provider.test.ts

@@ -0,0 +1,99 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+  isCurrentPickupRequest,
+  pickupLocationKey,
+  shouldRefreshPickupPoints,
+} from '../../../src/sdk/deliveryPromise/provider'
+
+describe('shouldRefreshPickupPoints', () => {
+  const channel = '{"salesChannel":"1"}'
+  const locationKey = pickupLocationKey(channel, 'BRA')
+
+  it('does not fetch without a postal code', () => {
+    expect(shouldRefreshPickupPoints(null, true, null, locationKey)).toBe(false)
+  })
+
+  it('fetches when the update flag is set', () => {
+    expect(shouldRefreshPickupPoints('01310100', true, null, locationKey)).toBe(
+      true
+    )
+  })
+
+  it('does not refetch the same channel and country after the flag is cleared', () => {
+    expect(
+      shouldRefreshPickupPoints('01310100', false, locationKey, locationKey)
+    ).toBe(false)
+  })
+
+  it('refetches when the shopper channel changes after the flag is cleared', () => {
+    const nextKey = pickupLocationKey('{"salesChannel":"2"}', 'BRA')
+
+    expect(
+      shouldRefreshPickupPoints('01310100', false, locationKey, nextKey)
+    ).toBe(true)
+  })
+
+  it('refetches when the country changes and the channel stays the same', () => {
+    const nextKey = pickupLocationKey(channel, 'USA')
+
+    expect(
+      shouldRefreshPickupPoints('01310100', false, locationKey, nextKey)
+    ).toBe(true)
+  })
+
+  it('does not refetch a location that just failed', () => {
+    const nextKey = pickupLocationKey('{"salesChannel":"2"}', 'BRA')
+
+    expect(
+      shouldRefreshPickupPoints(
+        '01310100',
+        false,
+        locationKey,
+        nextKey,
+        nextKey
+      )
+    ).toBe(false)
+  })
+
+  it('refetches a stored list before this page has fetched', () => {
+    expect(
+      shouldRefreshPickupPoints(
+        '01310100',
+        false,
+        null,
+        locationKey,
+        null,
+        true
+      )
+    ).toBe(true)
+  })
+
+  it('does not fetch an empty stored list before the shopper updates the postal code', () => {
+    expect(
+      shouldRefreshPickupPoints('01310100', false, null, locationKey)
+    ).toBe(false)
+  })
+
+  it('retries a failed location when the update flag is set again', () => {
+    expect(
+      shouldRefreshPickupPoints(
+        '01310100',
+        true,
+        locationKey,
+        locationKey,
+        locationKey
+      )
+    ).toBe(true)
+  })
+})
+
+describe('isCurrentPickupRequest', () => {
+  it('keeps the response that matches the latest request', () => {
+    expect(isCurrentPickupRequest(2, 2)).toBe(true)
+  })
+
+  it('drops a response after a newer request has started', () => {
+    expect(isCurrentPickupRequest(1, 2)).toBe(false)
+  })
+})

package/test/sdk/deliveryPromise/queries.test.ts

@@ -0,0 +1,123 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const { config, request } = vi.hoisted(() => ({
+  config: { enabled: true },
+  request: vi.fn(),
+}))
+
+vi.mock('discovery.config', () => ({
+  get deliveryPromise() {
+    return { enabled: config.enabled }
+  },
+}))
+
+vi.mock('src/sdk/graphql/request', () => ({
+  request,
+}))
+
+import { getPickupPoints } from '../../../src/sdk/deliveryPromise/queries'
+
+describe('getPickupPoints', () => {
+  beforeEach(() => {
+    config.enabled = true
+    request.mockReset()
+  })
+
+  it('skips the request when delivery promise is disabled', async () => {
+    config.enabled = false
+
+    await expect(
+      getPickupPoints({
+        geoCoordinates: { latitude: -23.56, longitude: -46.65 },
+        postalCode: '01310100',
+        country: 'BRA',
+      })
+    ).resolves.toEqual([])
+    expect(request).not.toHaveBeenCalled()
+  })
+
+  it('skips the request when postal code and coordinates are both missing', async () => {
+    await expect(
+      getPickupPoints({
+        geoCoordinates: null,
+        postalCode: null,
+        country: 'BRA',
+      })
+    ).resolves.toEqual([])
+    expect(request).not.toHaveBeenCalled()
+  })
+
+  it('requests pickup points with postal code and country and no coordinates', async () => {
+    request.mockResolvedValue({
+      pickupPoints: {
+        pickupPointDistances: [
+          {
+            pickupId: 'vendemo_1',
+            pickupName: 'VTEX Rio',
+            isActive: true,
+            distance: 2.7,
+            address: {
+              street: 'Praia de Botafogo',
+              number: '300',
+              postalCode: '22250-040',
+              city: 'Rio de Janeiro',
+              state: 'RJ',
+            },
+          },
+          {
+            pickupId: 'inactive',
+            pickupName: 'Closed',
+            isActive: false,
+            distance: 1,
+            address: null,
+          },
+        ],
+      },
+    })
+
+    const channel = JSON.stringify({ salesChannel: '2', regionId: '' })
+    const points = await getPickupPoints({
+      geoCoordinates: null,
+      postalCode: '22041080',
+      country: 'BRA',
+      channel,
+    })
+
+    expect(request).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.objectContaining({
+        postalCode: '22041080',
+        country: 'BRA',
+        channel,
+        geoCoordinates: undefined,
+      })
+    )
+    expect(points).toEqual([
+      {
+        id: 'vendemo_1',
+        name: 'VTEX Rio',
+        totalItems: 2,
+        address: {
+          street: 'Praia de Botafogo',
+          number: '300',
+          postalCode: '22250-040',
+          city: 'Rio de Janeiro',
+          state: 'RJ',
+        },
+        distance: 2.7,
+      },
+    ])
+  })
+
+  it('returns an empty list when the request has no data', async () => {
+    request.mockResolvedValueOnce(null)
+
+    await expect(
+      getPickupPoints({
+        geoCoordinates: null,
+        postalCode: '01310100',
+        country: 'BRA',
+      })
+    ).resolves.toEqual([])
+  })
+})

package/test/sdk/deliveryPromise/reducer.test.ts

@@ -0,0 +1,46 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+  deliveryPromiseReducer,
+  initializeDeliveryPromiseState,
+} from '../../../src/sdk/deliveryPromise/reducer'
+
+describe('deliveryPromiseReducer onPostalCodeChange', () => {
+  it('stores the simulated postal code and country', () => {
+    const next = deliveryPromiseReducer(initializeDeliveryPromiseState(), {
+      type: 'onPostalCodeChange',
+      payload: {
+        simulatePickupPoints: true,
+        validatedSession: {
+          postalCode: '22041080',
+          country: 'BRA',
+          geoCoordinates: { latitude: -22.95, longitude: -43.19 },
+        },
+      },
+    })
+
+    expect(next.simulatePickupPoints).toBe(true)
+    expect(next.shouldUpdatePickupPoints).toBe(true)
+    expect(next.pickupPointsSimulation).toMatchObject({
+      postalCode: '22041080',
+      country: 'BRA',
+      geoCoordinates: { latitude: -22.95, longitude: -43.19 },
+    })
+  })
+
+  it('stores null when the validated session omits the location', () => {
+    const next = deliveryPromiseReducer(initializeDeliveryPromiseState(), {
+      type: 'onPostalCodeChange',
+      payload: {
+        simulatePickupPoints: true,
+        validatedSession: {},
+      },
+    })
+
+    expect(next.pickupPointsSimulation).toMatchObject({
+      postalCode: null,
+      country: null,
+      geoCoordinates: null,
+    })
+  })
+})