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

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

@@ -18,17 +18,50 @@ vi.mock('src/sdk/graphql/useLazyQuery', () => ({
 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'
+import {
+  resetStartRecommendationSessionLock,
+  useStartRecommendationSession,
+} from 'src/sdk/analytics/hooks/useStartRecommendationSession'
+
+const enabledPageProps = {
+  sections: [
+    {
+      name: 'RecommendationShelf',
+      data: { enableRecommendations: true },
+    },
+  ],
+}
+
+const multipleEnabledShelvesPageProps = {
+  sections: [
+    {
+      name: 'RecommendationShelf',
+      data: { enableRecommendations: true, campaignVrn: 'vrn:a' },
+    },
+    {
+      name: 'RecommendationShelf',
+      data: { enableRecommendations: true, campaignVrn: 'vrn:b' },
+    },
+    {
+      name: 'ProductShelf',
+      data: {},
+    },
+  ],
+}
+
+const disabledPageProps = {
+  sections: [
+    {
+      name: 'RecommendationShelf',
+      data: { enableRecommendations: false },
+    },
+  ],
+}
 
 beforeEach(() => {
+  resetStartRecommendationSessionLock()
   useLazyQueryMock.mockReturnValue([runStartRecommendationSession, {}])
   runStartRecommendationSession.mockResolvedValue(true)
-  storeConfigMock.experimental.enableRecommendations = true
 })
 
 afterEach(() => {
@@ -36,34 +69,76 @@ afterEach(() => {
 })
 
 describe('useStartRecommendationSession', () => {
+  it('does not start a session when no RecommendationShelf is enabled in CMS', async () => {
+    getCookie.mockReturnValue(undefined)
+
+    renderHook(() => useStartRecommendationSession(disabledPageProps))
+
+    await waitFor(() => {
+      expect(runStartRecommendationSession).not.toHaveBeenCalled()
+    })
+  })
+
+  it('does not start a session when page props are missing', async () => {
+    getCookie.mockReturnValue(undefined)
+
+    renderHook(() => useStartRecommendationSession())
+
+    await waitFor(() => {
+      expect(runStartRecommendationSession).not.toHaveBeenCalled()
+    })
+  })
+
   it('does not start a session when the session cookie already exists', async () => {
     getCookie.mockReturnValue('already-started')
 
-    renderHook(() => useStartRecommendationSession())
+    renderHook(() => useStartRecommendationSession(enabledPageProps))
 
     await waitFor(() => {
       expect(runStartRecommendationSession).not.toHaveBeenCalled()
     })
   })
 
-  it('starts a session when no session cookie is present', async () => {
+  it('starts a session when CMS enableRecommendations is true and no session cookie is present', async () => {
     getCookie.mockReturnValue(undefined)
 
-    renderHook(() => useStartRecommendationSession())
+    renderHook(() => useStartRecommendationSession(enabledPageProps))
 
     await waitFor(() => {
-      expect(runStartRecommendationSession).toHaveBeenCalled()
+      expect(runStartRecommendationSession).toHaveBeenCalledTimes(1)
     })
   })
 
-  it('does not start a session when recommendations are disabled', async () => {
-    storeConfigMock.experimental.enableRecommendations = false
+  it('starts a session only once when the page has multiple enabled RecommendationShelves', async () => {
     getCookie.mockReturnValue(undefined)
 
-    renderHook(() => useStartRecommendationSession())
+    const { rerender } = renderHook(
+      ({ pageProps }) => useStartRecommendationSession(pageProps),
+      { initialProps: { pageProps: multipleEnabledShelvesPageProps } }
+    )
+
+    // Simulate Layout re-renders caused by multiple shelves updating.
+    rerender({ pageProps: multipleEnabledShelvesPageProps })
+    rerender({ pageProps: multipleEnabledShelvesPageProps })
 
     await waitFor(() => {
-      expect(runStartRecommendationSession).not.toHaveBeenCalled()
+      expect(runStartRecommendationSession).toHaveBeenCalledTimes(1)
+    })
+  })
+
+  it('does not start a second session when the hook mounts again without a cookie', async () => {
+    getCookie.mockReturnValue(undefined)
+
+    renderHook(() => useStartRecommendationSession(enabledPageProps))
+
+    await waitFor(() => {
+      expect(runStartRecommendationSession).toHaveBeenCalledTimes(1)
+    })
+
+    renderHook(() => useStartRecommendationSession(enabledPageProps))
+
+    await waitFor(() => {
+      expect(runStartRecommendationSession).toHaveBeenCalledTimes(1)
     })
   })
 })

package/test/sdk/localization/useBindingSelector.test.tsx

@@ -1,4 +1,4 @@
-import { describe, expect, it } from 'vitest'
+import { afterEach, describe, expect, it, vi } from 'vitest'
 
 import {
   buildLanguageOptions,
@@ -6,7 +6,47 @@ import {
   isValidUrl,
   resolveBinding,
 } from '../../../src/sdk/localization/bindingSelector'
+import type { LocalizedProductLocale } from '../../../src/sdk/localization/LocalizedProductContext'
 import type { Locale } from '../../../src/sdk/localization/types'
+import {
+  getSkuIdFromPdpPath,
+  persistOtherLocales,
+  recoverOtherLocales,
+} from '../../../src/sdk/localization/useBindingSelector'
+
+/** In-memory Storage stub matching the subset used by the helpers. */
+function createFakeStorage() {
+  const map = new Map<string, string>()
+
+  return {
+    getItem: (key: string) => (map.has(key) ? (map.get(key) as string) : null),
+    setItem: (key: string, value: string) => {
+      map.set(key, value)
+    },
+    removeItem: (key: string) => {
+      map.delete(key)
+    },
+    clear: () => map.clear(),
+  }
+}
+
+/**
+ * Stubs a browser-like global scope with the given pathname and storage.
+ *
+ * The production helpers guard on `typeof window` but read `globalThis.location`
+ * / `globalThis.sessionStorage` (which coincide with `window` in a real browser).
+ * Under the node test environment those are distinct, so we stub all three: the
+ * `window` keeps the guard passing while `location`/`sessionStorage` back the reads.
+ * Pass an existing `sessionStorage` to simulate navigation while storage persists.
+ */
+function stubWindow(pathname: string, sessionStorage = createFakeStorage()) {
+  const location = { pathname }
+  vi.stubGlobal('window', { location, sessionStorage })
+  vi.stubGlobal('location', location)
+  vi.stubGlobal('sessionStorage', sessionStorage)
+
+  return sessionStorage
+}
 
 // Test data that mirrors what the hook would receive from discovery.config
 const mockLocales: Record<string, Locale> = {
@@ -216,4 +256,107 @@ describe('useBindingSelector integration scenarios', () => {
       expect(newCurrencies[0]).toBe('EUR')
     })
   })
+
+  describe('getSkuIdFromPdpPath', () => {
+    afterEach(() => {
+      vi.unstubAllGlobals()
+    })
+
+    it('extracts the SKU id from a locale-prefixed PDP path', () => {
+      expect(
+        getSkuIdFromPdpPath(
+          '/en-CA/adidas-mens-performance-polo-blast-blue-65/p'
+        )
+      ).toBe('65')
+    })
+
+    it('extracts the SKU id from a default-locale (root) PDP path', () => {
+      expect(
+        getSkuIdFromPdpPath('/adidas-mens-performance-polo-blast-blue-65/p')
+      ).toBe('65')
+    })
+
+    it('extracts the SKU id from a custom-path binding PDP', () => {
+      expect(getSkuIdFromPdpPath('/europe/it/some-product-slug-12/p')).toBe(
+        '12'
+      )
+    })
+
+    it('handles a trailing slash after /p', () => {
+      expect(getSkuIdFromPdpPath('/pt-BR/some-slug-9/p/')).toBe('9')
+    })
+
+    it('returns null for non-PDP paths', () => {
+      expect(getSkuIdFromPdpPath('/en-CA')).toBeNull()
+      expect(getSkuIdFromPdpPath('/en-CA/office')).toBeNull()
+      expect(getSkuIdFromPdpPath('/')).toBeNull()
+    })
+
+    it('returns null when the slug has no numeric id', () => {
+      expect(getSkuIdFromPdpPath('/en-CA/no-numeric-id/p')).toBeNull()
+    })
+  })
+
+  describe('persist / recover otherLocales (sessionStorage)', () => {
+    afterEach(() => {
+      vi.unstubAllGlobals()
+    })
+
+    const otherLocales: LocalizedProductLocale[] = [
+      { locale: 'en-US', slug: 'adidas-mens-performance-polo-blast-blue-65' },
+      {
+        locale: 'pt-BR',
+        slug: 'adidas-polo-performance-masculina-azul-blast-65',
+      },
+      {
+        locale: 'fr-CA',
+        slug: 'adidas-polo-performance-homme-bleu-blast-ca-65',
+      },
+    ]
+
+    it('round-trips the map for the SKU referenced by the current path', () => {
+      // Persisted while on a working PDP (SKU 65).
+      const storage = stubWindow(
+        '/adidas-mens-performance-polo-blast-blue-65/p'
+      )
+      persistOtherLocales(otherLocales)
+
+      // Later, on a 404 for en-CA (same SKU 65, default-locale slug in the URL).
+      stubWindow('/en-CA/adidas-mens-performance-polo-blast-blue-65/p', storage)
+
+      expect(recoverOtherLocales()).toEqual(otherLocales)
+    })
+
+    it('returns null when the current path references a different SKU', () => {
+      const storage = stubWindow(
+        '/adidas-mens-performance-polo-blast-blue-65/p'
+      )
+      persistOtherLocales(otherLocales)
+
+      stubWindow('/en-CA/some-other-product-99/p', storage)
+
+      expect(recoverOtherLocales()).toBeNull()
+    })
+
+    it('returns null when the current path is not a PDP', () => {
+      const storage = stubWindow(
+        '/adidas-mens-performance-polo-blast-blue-65/p'
+      )
+      persistOtherLocales(otherLocales)
+
+      stubWindow('/en-CA', storage)
+
+      expect(recoverOtherLocales()).toBeNull()
+    })
+
+    it('does not persist when otherLocales is empty', () => {
+      const storage = stubWindow(
+        '/adidas-mens-performance-polo-blast-blue-65/p'
+      )
+      persistOtherLocales([])
+
+      expect(recoverOtherLocales()).toBeNull()
+      expect(storage.getItem('fs:otherLocales:65')).toBeNull()
+    })
+  })
 })