@faststore/core 4.10.1 → 4.10.2-dev.0

package/test/pages/pvt/account/cards/index.test.ts

@@ -2,7 +2,7 @@ import { describe, expect, it, vi } from 'vitest'
 
 const mockExecute = vi.hoisted(() => vi.fn())
 const mockGetB2BSessionClaims = vi.hoisted(() => vi.fn())
-const mockGetIsRepresentative = vi.hoisted(() => vi.fn(() => true))
+const mockGetIsB2BBuyer = vi.hoisted(() => vi.fn(() => true))
 const mockGetMyAccountRedirect = vi.hoisted(() =>
   vi.fn(() => ({ isFaststoreMyAccountEnabled: true, redirect: undefined }))
 )
@@ -30,8 +30,8 @@ vi.mock('src/components/cms/GlobalSections', () => ({
 vi.mock('src/sdk/account/getB2BSessionClaims', () => ({
   getB2BSessionClaims: mockGetB2BSessionClaims,
 }))
-vi.mock('src/sdk/account/getIsRepresentative', () => ({
-  getIsRepresentative: mockGetIsRepresentative,
+vi.mock('src/sdk/account/getIsB2BBuyer', () => ({
+  getIsB2BBuyer: mockGetIsB2BBuyer,
 }))
 vi.mock('src/utils/myAccountRedirect', () => ({
   getMyAccountRedirect: mockGetMyAccountRedirect,

package/test/sdk/account/getIsB2BBuyer.test.ts

@@ -0,0 +1,52 @@
+import { describe, expect, it } from 'vitest'
+import { getIsB2BBuyer } from '../../../src/sdk/account/getIsB2BBuyer'
+
+const ACCOUNT = 'storeaccount'
+
+const makeJwt = (payload: Record<string, unknown>) =>
+  `header.${Buffer.from(JSON.stringify(payload)).toString('base64')}.signature`
+
+const withToken = (payload: Record<string, unknown>) => ({
+  headers: { cookie: `VtexIdclientAutCookie_${ACCOUNT}=${makeJwt(payload)}` },
+  account: ACCOUNT,
+})
+
+describe('getIsB2BBuyer', () => {
+  it('is true when the token has a unit and a contract', () => {
+    expect(
+      getIsB2BBuyer(withToken({ unitId: 'unit-1', customerId: 'contract-1' }))
+    ).toBe(true)
+  })
+
+  it('does not depend on the isRepresentative claim', () => {
+    expect(
+      getIsB2BBuyer(
+        withToken({
+          unitId: 'unit-1',
+          customerId: 'contract-1',
+          isRepresentative: false,
+        })
+      )
+    ).toBe(true)
+    expect(getIsB2BBuyer(withToken({ isRepresentative: true }))).toBe(false)
+  })
+
+  it.each([
+    ['without a unit', { customerId: 'contract-1' }],
+    ['without a contract', { unitId: 'unit-1' }],
+    ['with blank claims', { unitId: ' ', customerId: '' }],
+    ['with non-string claims', { unitId: 1, customerId: true }],
+  ])('is false %s', (_label, payload) => {
+    expect(getIsB2BBuyer(withToken(payload))).toBe(false)
+  })
+
+  it('is false without an auth cookie or with a malformed one', () => {
+    expect(getIsB2BBuyer({ headers: {}, account: ACCOUNT })).toBe(false)
+    expect(
+      getIsB2BBuyer({
+        headers: { cookie: `VtexIdclientAutCookie_${ACCOUNT}=not-a-jwt` },
+        account: ACCOUNT,
+      })
+    ).toBe(false)
+  })
+})

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

@@ -14,7 +14,7 @@ describe('refreshTokenRequest (browser)', () => {
   beforeEach(() => {
     mockFetch.mockResolvedValue({
       status: 200,
-      json: async () => ({ status: 'success' }),
+      json: async () => ({ authStatus: 'Success' }),
     })
   })
 
@@ -31,4 +31,13 @@ describe('refreshTokenRequest (browser)', () => {
     expect(url).toBe('/api/vtexid/refreshtoken/webstore')
     expect(init.headers).toEqual({ 'content-type': 'application/json' })
   })
+
+  it('uses the relative Authenticator route for B2B sessions', async () => {
+    await refreshTokenRequest({ isB2B: true })
+
+    expect(mockFetch).toHaveBeenCalledTimes(1)
+    expect(mockFetch.mock.calls[0][0]).toBe(
+      '/api/authenticator/v1/refreshtoken/webstore'
+    )
+  })
 })

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

@@ -13,15 +13,29 @@ vi.mock('src/utils/utilities', () => ({
 }))
 
 import {
+  REFRESH_AFTER_FALLBACK_SECONDS,
+  getNextRefreshAfter,
+  getRefreshAfterSeconds,
+  isB2BSession,
   isRefreshTokenSuccessful,
   refreshTokenRequest,
 } from '../../../src/sdk/account/refreshToken'
 
-describe('refreshTokenRequest (node)', () => {
+const AUTHENTICATOR_URL =
+  'https://b2bfaststore.vtexfaststore.com/api/authenticator/v1/refreshtoken/webstore'
+const LEGACY_URL =
+  'https://b2bfaststore.vtexfaststore.com/api/vtexid/refreshtoken/webstore'
+
+const authenticatorSuccess = {
+  authStatus: 'Success',
+  refreshAfter: 1792717383,
+}
+
+describe('refreshTokenRequest (node, B2B session)', () => {
   beforeEach(() => {
     mockFetch.mockResolvedValue({
       status: 200,
-      json: async () => ({ status: 'success', refreshAfter: '123' }),
+      json: async () => authenticatorSuccess,
     })
   })
 
@@ -29,16 +43,14 @@ describe('refreshTokenRequest (node)', () => {
     vi.clearAllMocks()
   })
 
-  it('posts to the store origin with Host header on the server', async () => {
-    const result = await refreshTokenRequest()
+  it('posts to the Authenticator route on the store origin with Host header on the server', async () => {
+    const result = await refreshTokenRequest({ isB2B: true })
 
-    expect(result).toEqual({ status: 'success', refreshAfter: '123' })
+    expect(result).toEqual(authenticatorSuccess)
     expect(mockFetch).toHaveBeenCalledTimes(1)
 
     const [url, init] = mockFetch.mock.calls[0]
-    expect(url).toBe(
-      'https://b2bfaststore.vtexfaststore.com/api/vtexid/refreshtoken/webstore'
-    )
+    expect(url).toBe(AUTHENTICATOR_URL)
     expect(init.method).toBe('POST')
     expect(init.credentials).toBe('include')
     expect(init.headers).toMatchObject({
@@ -48,13 +60,35 @@ describe('refreshTokenRequest (node)', () => {
     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 () => ({}) })
+  it('does not fall back to the legacy route when the Authenticator fails', async () => {
+    mockFetch.mockResolvedValue({ status: 401, json: async () => ({}) })
 
-    const result = await refreshTokenRequest()
+    const result = await refreshTokenRequest({ isB2B: true })
+
+    expect(result).toBeUndefined()
+    expect(mockFetch).toHaveBeenCalledTimes(3)
+    expect(
+      mockFetch.mock.calls.every(([url]) => url === AUTHENTICATOR_URL)
+    ).toBe(true)
+  })
+
+  it('returns the Authenticator answer as is when it does not report success', async () => {
+    mockFetch.mockResolvedValue({
+      status: 200,
+      json: async () => ({ authStatus: 'WrongCredentials' }),
+    })
+
+    const result = await refreshTokenRequest({ isB2B: true })
+
+    expect(result).toEqual({ authStatus: 'WrongCredentials' })
+    expect(isRefreshTokenSuccessful(result)).toBe(false)
+    expect(mockFetch).toHaveBeenCalledTimes(1)
+  })
+
+  it('retries non-200 answers on the Authenticator route only', async () => {
+    mockFetch.mockResolvedValue({ status: 500, json: async () => ({}) })
+
+    const result = await refreshTokenRequest({ isB2B: true })
 
     expect(result).toBeUndefined()
     expect(mockFetch).toHaveBeenCalledTimes(3)
@@ -65,23 +99,121 @@ describe('refreshTokenRequest (node)', () => {
       .mockRejectedValueOnce(new Error('network'))
       .mockResolvedValueOnce({
         status: 200,
-        json: async () => ({ status: 'success' }),
+        json: async () => authenticatorSuccess,
       })
 
-    const result = await refreshTokenRequest()
+    const result = await refreshTokenRequest({ isB2B: true })
 
-    expect(result).toEqual({ status: 'success' })
+    expect(result).toEqual(authenticatorSuccess)
     expect(mockFetch).toHaveBeenCalledTimes(2)
+    expect(mockFetch.mock.calls[1][0]).toBe(AUTHENTICATOR_URL)
+  })
+})
+
+describe('refreshTokenRequest (node, non-B2B session)', () => {
+  beforeEach(() => {
+    mockFetch.mockResolvedValue({
+      status: 200,
+      json: async () => ({ status: 'Success', refreshAfter: '123' }),
+    })
+  })
+
+  afterEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('only calls the legacy route, as VTEX ID recommends outside B2B', async () => {
+    const result = await refreshTokenRequest()
+
+    expect(result).toEqual({ status: 'Success', refreshAfter: '123' })
+    expect(mockFetch.mock.calls.map(([url]) => url)).toEqual([LEGACY_URL])
+  })
+
+  it('retries 5xx on the legacy route only', async () => {
+    mockFetch.mockResolvedValue({ status: 500, json: async () => ({}) })
+
+    const result = await refreshTokenRequest({ isB2B: false })
+
+    expect(result).toBeUndefined()
+    expect(mockFetch).toHaveBeenCalledTimes(3)
+    expect(mockFetch.mock.calls.every(([url]) => url === LEGACY_URL)).toBe(true)
+  })
+})
+
+describe('isB2BSession', () => {
+  it('is true when the session has both a unit and a contract', () => {
+    expect(
+      isB2BSession({ b2b: { unitId: 'unit-1', customerId: 'contract-1' } })
+    ).toBe(true)
+  })
+
+  it.each([
+    ['no b2b', { b2b: null }],
+    ['an empty unitId', { b2b: { unitId: '', customerId: 'contract-1' } }],
+    ['an empty customerId', { b2b: { unitId: 'unit-1', customerId: '' } }],
+    ['no ids', { b2b: {} }],
+  ])('is false with %s', (_, session) => {
+    // `b2b` exists for every isRepresentative token, which can be true
+    // outside B2B, so the ids decide.
+    expect(isB2BSession(session)).toBe(false)
+  })
+
+  it('is false without a session', () => {
+    expect(isB2BSession(null)).toBe(false)
+    expect(isB2BSession(undefined)).toBe(false)
   })
 })
 
 describe('isRefreshTokenSuccessful', () => {
-  it('returns true when status is success (case-insensitive)', () => {
+  it('accepts the legacy status field (case-insensitive)', () => {
     expect(isRefreshTokenSuccessful({ status: 'Success' })).toBe(true)
   })
 
+  it('accepts the Authenticator authStatus field', () => {
+    expect(isRefreshTokenSuccessful({ authStatus: 'Success' })).toBe(true)
+  })
+
   it('returns false when status is missing or not success', () => {
     expect(isRefreshTokenSuccessful(undefined)).toBe(false)
     expect(isRefreshTokenSuccessful({ status: 'failed' })).toBe(false)
+    expect(isRefreshTokenSuccessful({ authStatus: 'failed' })).toBe(false)
+  })
+})
+
+describe('getRefreshAfterSeconds', () => {
+  it('keeps epoch seconds from the Authenticator', () => {
+    expect(getRefreshAfterSeconds({ refreshAfter: 1792717383 })).toBe(
+      '1792717383'
+    )
+    expect(getRefreshAfterSeconds({ refreshAfter: '1792717383' })).toBe(
+      '1792717383'
+    )
+  })
+
+  it('converts the legacy ISO date to epoch seconds', () => {
+    expect(
+      getRefreshAfterSeconds({ refreshAfter: '2026-10-20T05:36:52+00:00' })
+    ).toBe(String(Date.UTC(2026, 9, 20, 5, 36, 52) / 1000))
+  })
+
+  it('returns null when the value is missing or unparseable', () => {
+    expect(getRefreshAfterSeconds(undefined)).toBeNull()
+    expect(getRefreshAfterSeconds({})).toBeNull()
+    expect(getRefreshAfterSeconds({ refreshAfter: '' })).toBeNull()
+    expect(getRefreshAfterSeconds({ refreshAfter: 'soon' })).toBeNull()
+  })
+})
+
+describe('getNextRefreshAfter', () => {
+  it('uses the refreshAfter from the response', () => {
+    expect(getNextRefreshAfter({ refreshAfter: 1792717383 }, 100)).toBe(
+      '1792717383'
+    )
+  })
+
+  it('falls back to a short delay from now when the response has none', () => {
+    expect(getNextRefreshAfter({ authStatus: 'Success' }, 100)).toBe(
+      String(100 + REFRESH_AFTER_FALLBACK_SECONDS)
+    )
   })
 })

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

@@ -0,0 +1,72 @@
+import { renderHook, waitFor } from '@testing-library/react'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+const mockRefreshTokenRequest = vi.hoisted(() => vi.fn())
+const mockLogoutAndClearSession = vi.hoisted(() => vi.fn())
+
+vi.mock('../../../src/sdk/account/refreshToken', async (importOriginal) => ({
+  ...(await importOriginal<
+    typeof import('../../../src/sdk/account/refreshToken')
+  >()),
+  refreshTokenRequest: mockRefreshTokenRequest,
+  isRefreshTokenSuccessful: () => false,
+}))
+
+vi.mock('../../../src/sdk/session', () => ({
+  logoutAndClearSession: mockLogoutAndClearSession,
+  sessionStore: { read: () => null, readInitial: () => ({}) },
+}))
+
+import { useRefreshToken } from '../../../src/sdk/account/useRefreshToken'
+
+const originalLocation = window.location
+
+function stubHostname(hostname: string) {
+  // jsdom forbids assigning to `window.location` directly, so we redefine the
+  // descriptor with a minimal stub that exposes the hostname we want to test.
+  Object.defineProperty(window, 'location', {
+    configurable: true,
+    value: { ...originalLocation, hostname },
+  })
+}
+
+describe('useRefreshToken', () => {
+  beforeEach(() => {
+    mockRefreshTokenRequest.mockResolvedValue({ status: 'error' })
+    mockLogoutAndClearSession.mockResolvedValue(undefined)
+  })
+
+  afterEach(() => {
+    vi.clearAllMocks()
+    Object.defineProperty(window, 'location', {
+      configurable: true,
+      value: originalLocation,
+    })
+  })
+
+  it.each(['localhost', 'brandless-abc123.preview.vtex.app'])(
+    'shows the 403 view without refreshing or logging out on %s',
+    async (hostname) => {
+      stubHostname(hostname)
+
+      const { result } = renderHook(() => useRefreshToken(true))
+
+      await waitFor(() => expect(result.current.shouldShow403).toBe(true))
+      expect(mockRefreshTokenRequest).not.toHaveBeenCalled()
+      expect(mockLogoutAndClearSession).not.toHaveBeenCalled()
+    }
+  )
+
+  it.each(['brandless.vtex.app', 'brandless.fast.store'])(
+    'refreshes the token and logs out when it fails on %s',
+    async (hostname) => {
+      stubHostname(hostname)
+
+      const { result } = renderHook(() => useRefreshToken(true))
+
+      await waitFor(() => expect(result.current.shouldShow403).toBe(true))
+      expect(mockRefreshTokenRequest).toHaveBeenCalledTimes(1)
+      expect(mockLogoutAndClearSession).toHaveBeenCalledTimes(1)
+    }
+  )
+})

package/test/sdk/product/usePageProductsQuery.browser.test.ts

@@ -0,0 +1,260 @@
+/**
+ * @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())
+const mockUseLocalizedVariables = vi.hoisted(() => vi.fn())
+
+vi.mock('@generated', () => ({ gql: (query: unknown) => query }))
+vi.mock('discovery.config', () => ({
+  default: { deliveryPromise: { enabled: false } },
+}))
+vi.mock('@faststore/sdk', () => ({
+  useSearch: () => ({
+    state: { sort: 'score_desc', term: '', selectedFacets: [] },
+    itemsPerPage: 12,
+  }),
+}))
+vi.mock('src/sdk/session', () => ({ useSession: mockUseSession }))
+vi.mock('src/sdk/graphql/useQuery', () => ({ useQuery: mockUseQuery }))
+vi.mock('src/sdk/product/useLocalizedVariables', () => ({
+  useLocalizedVariables: mockUseLocalizedVariables,
+}))
+
+import {
+  hashContractScope,
+  useCreateUseGalleryPage,
+} from '../../../src/sdk/product/usePageProductsQuery'
+
+const serverManyProductsVariables = {
+  first: 12,
+  after: '0',
+  sort: 'score_desc' as const,
+  term: '',
+  selectedFacets: [
+    { key: 'category-1', value: 'computers---tablets' },
+    { key: 'channel', value: '{"salesChannel":"1"}' },
+    { key: 'locale', value: 'en-CA' },
+  ],
+  sponsoredCount: 3,
+}
+
+type GalleryProps = NonNullable<Parameters<typeof useCreateUseGalleryPage>[0]>
+
+const initialPages = {
+  search: { products: { pageInfo: { totalCount: 2 }, edges: [] } },
+} as unknown as GalleryProps['initialPages']
+
+const renderFirstGalleryPage = () => {
+  const { result: created } = renderHook(() =>
+    useCreateUseGalleryPage({ initialPages, serverManyProductsVariables })
+  )
+
+  return renderHook(() => created.current.useGalleryPage(0))
+}
+
+describe('useCreateUseGalleryPage', () => {
+  afterEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('reuses the SSG first page for anonymous shoppers', () => {
+    mockUseSession.mockReturnValue({
+      postalCode: null,
+      b2b: null,
+      isValidating: false,
+    })
+    mockUseLocalizedVariables.mockReturnValue(serverManyProductsVariables)
+    mockUseQuery.mockReturnValue({ data: null })
+
+    const { result } = renderFirstGalleryPage()
+
+    expect(mockUseQuery).toHaveBeenCalledWith(
+      expect.anything(),
+      serverManyProductsVariables,
+      expect.objectContaining({ doNotRun: true })
+    )
+    expect(result.current.data).toBe(initialPages)
+  })
+
+  it('re-fetches the first page for B2B buyers so the contract assortment applies', () => {
+    mockUseSession.mockReturnValue({
+      postalCode: null,
+      b2b: { customerId: 'contract-137' },
+      isValidating: false,
+    })
+    mockUseLocalizedVariables.mockReturnValue(serverManyProductsVariables)
+    mockUseQuery.mockReturnValue({ data: null })
+
+    renderFirstGalleryPage()
+
+    expect(mockUseQuery).toHaveBeenCalledWith(
+      expect.anything(),
+      {
+        ...serverManyProductsVariables,
+        _contract: hashContractScope('contract-137'),
+      },
+      expect.objectContaining({ doNotRun: false })
+    )
+  })
+
+  it('still re-fetches for B2B buyers whose customerId resolves to an empty string', () => {
+    // `buildB2bSession` in @faststore/api can resolve `customerId` to `''`
+    // (see validateSessionHelpers.ts) even for a representative with an
+    // active contract. The fix must not depend on the value being truthy —
+    // only on the `b2b` session existing — or it silently falls back to the
+    // anonymous behavior (reusing the unfiltered SSG page).
+    mockUseSession.mockReturnValue({
+      postalCode: null,
+      b2b: { customerId: '' },
+      isValidating: false,
+    })
+    mockUseLocalizedVariables.mockReturnValue(serverManyProductsVariables)
+    mockUseQuery.mockReturnValue({ data: null })
+
+    renderFirstGalleryPage()
+
+    expect(mockUseQuery).toHaveBeenCalledWith(
+      expect.anything(),
+      { ...serverManyProductsVariables, _contract: hashContractScope('b2b') },
+      expect.objectContaining({ doNotRun: false })
+    )
+  })
+
+  it('hashes the contract scope to a stable value', () => {
+    // Golden value: catches a change to the hash itself, which the other
+    // tests miss because they derive their expectations from it.
+    expect(hashContractScope('contract-137')).toBe('185k3l4sd4t')
+  })
+
+  it('keeps the raw contract id out of the query variables', () => {
+    mockUseSession.mockReturnValue({
+      postalCode: null,
+      b2b: { customerId: 'contract-137', unitId: 'unit-42' },
+      isValidating: false,
+    })
+    mockUseLocalizedVariables.mockReturnValue(serverManyProductsVariables)
+    mockUseQuery.mockReturnValue({ data: null })
+
+    renderFirstGalleryPage()
+
+    // The variables go in the GET URL, so they must not carry the raw ids.
+    const variables = JSON.stringify(mockUseQuery.mock.calls.at(-1)?.[1])
+    expect(variables).not.toContain('contract-137')
+    expect(variables).not.toContain('unit-42')
+    expect(hashContractScope('contract-a')).not.toBe(
+      hashContractScope('contract-b')
+    )
+  })
+
+  it('tells B2B buyers apart by organizational unit when customerId is empty', () => {
+    mockUseSession.mockReturnValue({
+      postalCode: null,
+      b2b: { customerId: '', unitId: 'unit-42' },
+      isValidating: false,
+    })
+    mockUseLocalizedVariables.mockReturnValue(serverManyProductsVariables)
+    mockUseQuery.mockReturnValue({ data: null })
+
+    renderFirstGalleryPage()
+
+    expect(mockUseQuery).toHaveBeenCalledWith(
+      expect.anything(),
+      {
+        ...serverManyProductsVariables,
+        _contract: hashContractScope('unit-42'),
+      },
+      expect.objectContaining({ doNotRun: false })
+    )
+  })
+
+  it('re-fetches the first page when the buyer switches contract', () => {
+    const contractPage = {
+      search: { products: { pageInfo: { totalCount: 1 }, edges: [] } },
+    }
+
+    mockUseSession.mockReturnValue({
+      postalCode: null,
+      b2b: { customerId: 'contract-a' },
+      isValidating: false,
+    })
+    mockUseLocalizedVariables.mockReturnValue(serverManyProductsVariables)
+    mockUseQuery.mockReturnValue({ data: contractPage })
+
+    const { result: created } = renderHook(() =>
+      useCreateUseGalleryPage({ initialPages, serverManyProductsVariables })
+    )
+    const { rerender } = renderHook(() => created.current.useGalleryPage(0))
+
+    mockUseSession.mockReturnValue({
+      postalCode: null,
+      b2b: { customerId: 'contract-b' },
+      isValidating: false,
+    })
+    rerender()
+
+    expect(mockUseQuery).toHaveBeenLastCalledWith(
+      expect.anything(),
+      {
+        ...serverManyProductsVariables,
+        _contract: hashContractScope('contract-b'),
+      },
+      expect.objectContaining({ doNotRun: false })
+    )
+  })
+
+  it('stops scoping the first page once the B2B session ends', () => {
+    const contractPage = {
+      search: { products: { pageInfo: { totalCount: 1 }, edges: [] } },
+    }
+
+    mockUseSession.mockReturnValue({
+      postalCode: null,
+      b2b: { customerId: 'contract-a' },
+      isValidating: false,
+    })
+    mockUseLocalizedVariables.mockReturnValue(serverManyProductsVariables)
+    mockUseQuery.mockReturnValue({ data: contractPage })
+
+    const { result: created } = renderHook(() =>
+      useCreateUseGalleryPage({ initialPages, serverManyProductsVariables })
+    )
+    const { rerender } = renderHook(() => created.current.useGalleryPage(0))
+
+    mockUseSession.mockReturnValue({
+      postalCode: null,
+      b2b: null,
+      isValidating: false,
+    })
+    rerender()
+
+    expect(mockUseQuery).toHaveBeenLastCalledWith(
+      expect.anything(),
+      serverManyProductsVariables,
+      expect.objectContaining({ doNotRun: false })
+    )
+  })
+
+  it('ignores the postal code while deliveryPromise is disabled', () => {
+    mockUseSession.mockReturnValue({
+      postalCode: '01310-100',
+      b2b: null,
+      isValidating: false,
+    })
+    mockUseLocalizedVariables.mockReturnValue(serverManyProductsVariables)
+    mockUseQuery.mockReturnValue({ data: null })
+
+    const { result } = renderFirstGalleryPage()
+
+    expect(mockUseQuery).toHaveBeenCalledWith(
+      expect.anything(),
+      serverManyProductsVariables,
+      expect.objectContaining({ doNotRun: true })
+    )
+    expect(result.current.data).toBe(initialPages)
+  })
+})