@segment/analytics-browser-actions-facebook-conversions-api-web 1.11.1-staging-49cc16573.0 → 1.12.0

package/src/send/__tests__/hashing.test.ts

@@ -0,0 +1,123 @@
+import { sha256Hash } from '../functions'
+
+describe('SHA256 Hashing', () => {
+  describe('sha256Hash', () => {
+    it('should correctly hash an email address', async () => {
+      const input = 'test@example.com'
+      const expected = '973dfe463ec85785f5f95af5ba3906eedb2d931c24e69824a89ea65dba4e813b'
+
+      const result = await sha256Hash(input)
+
+      expect(result).toBe(expected)
+    })
+
+    it('should correctly hash a simple string', async () => {
+      const input = 'hello'
+      const expected = '2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824'
+
+      const result = await sha256Hash(input)
+
+      expect(result).toBe(expected)
+    })
+
+    it('should correctly hash a phone number (digits only)', async () => {
+      const input = '14155551234'
+      const expected = 'c6a349dfaaf5c3a368d3135014cc1bc7aebf18f654f313f9c1d0b018a897b209'
+
+      const result = await sha256Hash(input)
+
+      expect(result).toBe(expected)
+    })
+
+    it('should correctly hash a first name', async () => {
+      const input = 'john'
+      const expected = '96d9632f363564cc3032521409cf22a852f2032eec099ed5967c0d000cec607a'
+
+      const result = await sha256Hash(input)
+
+      expect(result).toBe(expected)
+    })
+
+    it('should correctly hash a last name', async () => {
+      const input = 'doe'
+      const expected = '799ef92a11af918e3fb741df42934f3b568ed2d93ac1df74f1b8d41a27932a6f'
+
+      const result = await sha256Hash(input)
+
+      expect(result).toBe(expected)
+    })
+
+    it('should correctly hash a gender value', async () => {
+      const input = 'm'
+      const expected = '62c66a7a5dd70c3146618063c344e531e6d4b59e379808443ce962b3abd63c5a'
+
+      const result = await sha256Hash(input)
+
+      expect(result).toBe(expected)
+    })
+
+    it('should correctly hash a city name (normalized)', async () => {
+      const input = 'newyork'
+      const expected = '350c754ba4d38897693aa077ef43072a859d23f613443133fecbbd90a3512ca5'
+
+      const result = await sha256Hash(input)
+
+      expect(result).toBe(expected)
+    })
+
+    it('should correctly hash a date of birth (YYYYMMDD format)', async () => {
+      const input = '19900115'
+      const expected = '4747c382bedef489a190a6797e6f4451907b86511bdd49cfa8f9d4c1a78d8bac'
+
+      const result = await sha256Hash(input)
+
+      expect(result).toBe(expected)
+    })
+
+    it('should correctly hash numeric strings', async () => {
+      const input = '1234567890'
+      const expected = 'c775e7b757ede630cd0aa1113bd102661ab38829ca52a6422ab782862f268646'
+
+      const result = await sha256Hash(input)
+
+      expect(result).toBe(expected)
+    })
+
+    it('should return a 64-character hex string', async () => {
+      const input = 'test'
+
+      const result = await sha256Hash(input)
+
+      expect(result).toHaveLength(64)
+      expect(result).toMatch(/^[a-f0-9]{64}$/)
+    })
+
+    it('should produce different hashes for different inputs', async () => {
+      const input1 = 'test1'
+      const input2 = 'test2'
+
+      const result1 = await sha256Hash(input1)
+      const result2 = await sha256Hash(input2)
+
+      expect(result1).not.toBe(result2)
+    })
+
+    it('should produce the same hash for the same input', async () => {
+      const input = 'consistent'
+
+      const result1 = await sha256Hash(input)
+      const result2 = await sha256Hash(input)
+
+      expect(result1).toBe(result2)
+    })
+
+    it('should handle empty string', async () => {
+      const input = ''
+      const expected = 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855'
+
+      const result = await sha256Hash(input)
+
+      expect(result).toBe(expected)
+    })
+  })
+})

package/src/send/__tests__/init.test.ts

@@ -0,0 +1,578 @@
+import { send } from '../functions'
+
+describe('Facebook Conversions API Web - Init with User Data', () => {
+  let mockFbq
+  let mockAnalytics
+  let mockClientParamBuilder
+
+  beforeEach(() => {
+    mockFbq = jest.fn()
+    mockAnalytics = {
+      storage: {
+        get: jest.fn(),
+        set: jest.fn()
+      }
+    }
+
+    mockClientParamBuilder = undefined
+  })
+
+  afterEach(() => {
+    jest.restoreAllMocks()
+  })
+
+  const defaultSettings = {
+    pixelId: 'test-pixel-123',
+    ldu: 'Disabled'
+  }
+
+  describe('init call with user data formatting', () => {
+    it('should format userData with email', async () => {
+      mockAnalytics.storage.get.mockReturnValue('0')
+
+      const payload = {
+        event_config: {
+          event_name: 'Purchase',
+          show_fields: false
+        },
+        content_ids: ['product-123'],
+        value: 99.99,
+        userData: {
+          em: 'TEST@EXAMPLE.COM'
+        }
+      }
+
+      await send(mockFbq, mockClientParamBuilder, payload, defaultSettings, mockAnalytics)
+
+      // Email should be normalized (lowercase, trimmed) and hashed with SHA256
+      // 'test@example.com' -> '973dfe463ec85785f5f95af5ba3906eedb2d931c24e69824a89ea65dba4e813b'
+      expect(mockFbq).toHaveBeenCalledWith('init', 'test-pixel-123', {
+        em: '973dfe463ec85785f5f95af5ba3906eedb2d931c24e69824a89ea65dba4e813b'
+      })
+      // Should have stored user data
+      expect(mockAnalytics.storage.set).toHaveBeenCalledWith(
+        'fb_user_data',
+        expect.stringContaining('973dfe463ec85785f5f95af5ba3906eedb2d931c24e69824a89ea65dba4e813b')
+      )
+    })
+
+    it('should format userData with phone number', async () => {
+      mockAnalytics.storage.get.mockReturnValue('0')
+
+      const payload = {
+        event_config: {
+          event_name: 'Purchase',
+          show_fields: false
+        },
+        content_ids: ['product-123'],
+        value: 99.99,
+        userData: {
+          ph: '(555) 123-4567'
+        }
+      }
+
+      await send(mockFbq, mockClientParamBuilder, payload, defaultSettings, mockAnalytics)
+
+      // Phone should be cleaned of non-numeric characters then hashed
+      // '5551234567' -> '3c95277da5fd0da6a1a44ee3fdf56d20af6c6d242695a40e18e6e90dc3c5872c'
+      expect(mockFbq).toHaveBeenCalledWith('init', 'test-pixel-123', {
+        ph: '3c95277da5fd0da6a1a44ee3fdf56d20af6c6d242695a40e18e6e90dc3c5872c'
+      })
+    })
+
+    it('should format userData with first and last name', async () => {
+      mockAnalytics.storage.get.mockReturnValue('0')
+
+      const payload = {
+        event_config: {
+          event_name: 'Purchase',
+          show_fields: false
+        },
+        content_ids: ['product-123'],
+        value: 99.99,
+        userData: {
+          fn: ' JOHN ',
+          ln: ' DOE '
+        }
+      }
+
+      await send(mockFbq, mockClientParamBuilder, payload, defaultSettings, mockAnalytics)
+
+      // Names should be lowercased and trimmed, then hashed
+      // 'john' -> '96d9632f363564cc3032521409cf22a852f2032eec099ed5967c0d000cec607a'
+      // 'doe' -> '799ef92a11af918e3fb741df42934f3b568ed2d93ac1df74f1b8d41a27932a6f'
+      expect(mockFbq).toHaveBeenCalledWith(
+        'init',
+        'test-pixel-123',
+        {
+          fn: '96d9632f363564cc3032521409cf22a852f2032eec099ed5967c0d000cec607a',
+          ln: '799ef92a11af918e3fb741df42934f3b568ed2d93ac1df74f1b8d41a27932a6f'
+        }
+      )
+    })
+
+    it('should format userData with gender', async () => {
+      mockAnalytics.storage.get.mockReturnValue('0')
+
+      const payload = {
+        event_config: {
+          event_name: 'Purchase',
+          show_fields: false
+        },
+        content_ids: ['product-123'],
+        value: 99.99,
+        userData: {
+          ge: 'm'
+        }
+      }
+
+      await send(mockFbq, mockClientParamBuilder, payload, defaultSettings, mockAnalytics)
+
+      // 'm' -> '62c66a7a5dd70c3146618063c344e531e6d4b59e379808443ce962b3abd63c5a'
+      expect(mockFbq).toHaveBeenCalledWith('init', 'test-pixel-123', {
+        ge: '62c66a7a5dd70c3146618063c344e531e6d4b59e379808443ce962b3abd63c5a'
+      })
+    })
+
+    it('should format userData with date of birth', async () => {
+      mockAnalytics.storage.get.mockReturnValue('0')
+
+      const payload = {
+        event_config: {
+          event_name: 'Purchase',
+          show_fields: false
+        },
+        content_ids: ['product-123'],
+        value: 99.99,
+        userData: {
+          db: '1990-05-15T00:00:00.000Z'
+        }
+      }
+
+      await send(mockFbq, mockClientParamBuilder, payload, defaultSettings, mockAnalytics)
+
+      // Date should be formatted as YYYYMMDD then hashed
+      // '19900515' -> '53058fbd6731774c37a6d838c09d25b337fa7b9b5007f82cc934d857d2596e0c'
+      expect(mockFbq).toHaveBeenCalledWith('init', 'test-pixel-123', {
+        db: '53058fbd6731774c37a6d838c09d25b337fa7b9b5007f82cc934d857d2596e0c'
+      })
+    })
+
+    it('should format userData with city', async () => {
+      mockAnalytics.storage.get.mockReturnValue('0')
+
+      const payload = {
+        event_config: {
+          event_name: 'Purchase',
+          show_fields: false
+        },
+        content_ids: ['product-123'],
+        value: 99.99,
+        userData: {
+          ct: ' New York '
+        }
+      }
+
+      await send(mockFbq, mockClientParamBuilder, payload, defaultSettings, mockAnalytics)
+
+      // City should be lowercased with spaces removed, then hashed
+      // 'newyork' -> '350c754ba4d38897693aa077ef43072a859d23f613443133fecbbd90a3512ca5'
+      expect(mockFbq).toHaveBeenCalledWith('init', 'test-pixel-123', {
+        ct: '350c754ba4d38897693aa077ef43072a859d23f613443133fecbbd90a3512ca5'
+      })
+    })
+
+    it('should format userData with US state - full name to code', async () => {
+      mockAnalytics.storage.get.mockReturnValue('0')
+
+      const payload = {
+        event_config: {
+          event_name: 'Purchase',
+          show_fields: false
+        },
+        content_ids: ['product-123'],
+        value: 99.99,
+        userData: {
+          st: 'California'
+        }
+      }
+
+      await send(mockFbq, mockClientParamBuilder, payload, defaultSettings, mockAnalytics)
+
+      // State should be converted to 2-letter code, then hashed
+      // 'ca' -> '6959097001d10501ac7d54c0bdb8db61420f658f2922cc26e46d536119a31126'
+      expect(mockFbq).toHaveBeenCalledWith('init', 'test-pixel-123', {
+        st: '6959097001d10501ac7d54c0bdb8db61420f658f2922cc26e46d536119a31126'
+      })
+    })
+
+    it('should format userData with US state - already 2-letter code', async () => {
+      mockAnalytics.storage.get.mockReturnValue('0')
+
+      const payload = {
+        event_config: {
+          event_name: 'Purchase',
+          show_fields: false
+        },
+        content_ids: ['product-123'],
+        value: 99.99,
+        userData: {
+          st: 'NY'
+        }
+      }
+
+      await send(mockFbq, mockClientParamBuilder, payload, defaultSettings, mockAnalytics)
+
+      // State code should be lowercased, then hashed
+      // 'ny' -> '1b06e2003f8420d6fa42badd8f77ec0f706b976b7a48b13c567dc5a559681683'
+      expect(mockFbq).toHaveBeenCalledWith('init', 'test-pixel-123', {
+        st: '1b06e2003f8420d6fa42badd8f77ec0f706b976b7a48b13c567dc5a559681683'
+      })
+    })
+
+    it('should format userData with country - full name to code', async () => {
+      mockAnalytics.storage.get.mockReturnValue('0')
+
+      const payload = {
+        event_config: {
+          event_name: 'Purchase',
+          show_fields: false
+        },
+        content_ids: ['product-123'],
+        value: 99.99,
+        userData: {
+          country: 'United States'
+        }
+      }
+
+      await send(mockFbq, mockClientParamBuilder, payload, defaultSettings, mockAnalytics)
+
+      // Country should be converted to 2-letter code, then hashed
+      // 'us' -> '79adb2a2fce5c6ba215fe5f27f532d4e7edbac4b6a5e09e1ef3a08084a904621'
+      expect(mockFbq).toHaveBeenCalledWith('init', 'test-pixel-123', {
+        country: '79adb2a2fce5c6ba215fe5f27f532d4e7edbac4b6a5e09e1ef3a08084a904621'
+      })
+    })
+
+    it('should format userData with country - already 2-letter code', async () => {
+      mockAnalytics.storage.get.mockReturnValue('0')
+
+      const payload = {
+        event_config: {
+          event_name: 'Purchase',
+          show_fields: false
+        },
+        content_ids: ['product-123'],
+        value: 99.99,
+        userData: {
+          country: 'GB'
+        }
+      }
+
+      await send(mockFbq, mockClientParamBuilder, payload, defaultSettings, mockAnalytics)
+
+      // Country code should be lowercased, then hashed
+      // 'gb' -> '0b407281768f0e833afef47ed464b6571d01ca4d53c12ce5c51d1462f4ad6677'
+      expect(mockFbq).toHaveBeenCalledWith('init', 'test-pixel-123', {
+        country: '0b407281768f0e833afef47ed464b6571d01ca4d53c12ce5c51d1462f4ad6677'
+      })
+    })
+
+    it('should format userData with zip code', async () => {
+      mockAnalytics.storage.get.mockReturnValue('0')
+
+      const payload = {
+        event_config: {
+          event_name: 'Purchase',
+          show_fields: false
+        },
+        content_ids: ['product-123'],
+        value: 99.99,
+        userData: {
+          zp: ' 94102 '
+        }
+      }
+
+      await send(mockFbq, mockClientParamBuilder, payload, defaultSettings, mockAnalytics)
+
+      // Zip should be trimmed, then hashed
+      // '94102' -> '8137c19c8f35f6b6a1cce99753226e1c7211eaaebd68528b789f973b0be95e31'
+      expect(mockFbq).toHaveBeenCalledWith('init', 'test-pixel-123', {
+        zp: '8137c19c8f35f6b6a1cce99753226e1c7211eaaebd68528b789f973b0be95e31'
+      })
+    })
+
+    it('should format userData with external_id', async () => {
+      mockAnalytics.storage.get.mockReturnValue('0')
+
+      const payload = {
+        event_config: {
+          event_name: 'Purchase',
+          show_fields: false
+        },
+        content_ids: ['product-123'],
+        value: 99.99,
+        userData: {
+          external_id: ' user-123 '
+        }
+      }
+
+      await send(mockFbq, mockClientParamBuilder, payload, defaultSettings, mockAnalytics)
+
+      // External ID should be trimmed, then hashed
+      // 'user-123' -> 'fcdec6df4d44dbc637c7c5b58efface52a7f8a88535423430255be0bb89bedd8'
+      expect(mockFbq).toHaveBeenCalledWith('init', 'test-pixel-123', {
+        external_id: 'fcdec6df4d44dbc637c7c5b58efface52a7f8a88535423430255be0bb89bedd8'
+      })
+    })
+
+    it('should format userData with fbp and fbc cookies', async () => {
+      mockAnalytics.storage.get.mockReturnValue('0')
+
+      const payload = {
+        event_config: {
+          event_name: 'Purchase',
+          show_fields: false
+        },
+        content_ids: ['product-123'],
+        value: 99.99,
+        userData: {
+          fbp: ' fb.1.1234567890.1234567890 ',
+          fbc: ' fb.1.1234567890.AbCdEf123 '
+        }
+      }
+
+      await send(mockFbq, mockClientParamBuilder, payload, defaultSettings, mockAnalytics)
+
+      // FBP and FBC should be trimmed but NOT hashed
+      expect(mockFbq).toHaveBeenCalledWith(
+        'init',
+        'test-pixel-123',
+        {
+          fbp: 'fb.1.1234567890.1234567890',
+          fbc: 'fb.1.1234567890.AbCdEf123'
+        }
+      )
+    })
+
+    it('should format userData with all fields combined', async () => {
+      mockAnalytics.storage.get.mockReturnValue('0')
+
+      const payload = {
+        event_config: {
+          event_name: 'Purchase',
+          show_fields: false
+        },
+        content_ids: ['product-123'],
+        value: 99.99,
+        userData: {
+          external_id: 'user-123',
+          em: 'test@example.com',
+          ph: '5551234567',
+          fn: 'John',
+          ln: 'Doe',
+          ge: 'm',
+          db: '1990-05-15T00:00:00.000Z',
+          ct: 'San Francisco',
+          st: 'California',
+          zp: '94102',
+          country: 'United States',
+          fbp: 'fb.1.1234567890.1234567890',
+          fbc: 'fb.1.1234567890.AbCdEf123'
+        }
+      }
+
+      await send(mockFbq, mockClientParamBuilder, payload, defaultSettings, mockAnalytics)
+
+      // All PII fields should be normalized and hashed; fbc/fbp should NOT be hashed
+      expect(mockFbq).toHaveBeenCalledWith(
+        'init',
+        'test-pixel-123',
+        {
+          external_id: 'fcdec6df4d44dbc637c7c5b58efface52a7f8a88535423430255be0bb89bedd8',
+          em: '973dfe463ec85785f5f95af5ba3906eedb2d931c24e69824a89ea65dba4e813b',
+          ph: '3c95277da5fd0da6a1a44ee3fdf56d20af6c6d242695a40e18e6e90dc3c5872c',
+          fn: '96d9632f363564cc3032521409cf22a852f2032eec099ed5967c0d000cec607a',
+          ln: '799ef92a11af918e3fb741df42934f3b568ed2d93ac1df74f1b8d41a27932a6f',
+          ge: '62c66a7a5dd70c3146618063c344e531e6d4b59e379808443ce962b3abd63c5a',
+          db: '53058fbd6731774c37a6d838c09d25b337fa7b9b5007f82cc934d857d2596e0c',
+          ct: '1a6bd4d9d79dc0a79b53795c70d3349fa9e38968a3fbefbfe8783efb1d2b6aac',
+          st: '6959097001d10501ac7d54c0bdb8db61420f658f2922cc26e46d536119a31126',
+          zp: '8137c19c8f35f6b6a1cce99753226e1c7211eaaebd68528b789f973b0be95e31',
+          country: '79adb2a2fce5c6ba215fe5f27f532d4e7edbac4b6a5e09e1ef3a08084a904621',
+          fbp: 'fb.1.1234567890.1234567890',
+          fbc: 'fb.1.1234567890.AbCdEf123'
+        }
+      )
+    })
+
+    it('should skip invalid gender values', async () => {
+      mockAnalytics.storage.get.mockReturnValue('0')
+
+      const payload = {
+        event_config: {
+          event_name: 'Purchase',
+          show_fields: false
+        },
+        content_ids: ['product-123'],
+        value: 99.99,
+        userData: {
+          ge: 'invalid'
+        }
+      }
+
+      await send(mockFbq, mockClientParamBuilder, payload, defaultSettings, mockAnalytics)
+
+      // Should not call init if only invalid gender is provided
+      const initCalls = (mockFbq).mock.calls.filter((call) => call[0] === 'init')
+      expect(initCalls.length).toBe(0)
+    })
+
+    it('should skip invalid date of birth', async () => {
+      mockAnalytics.storage.get.mockReturnValue('0')
+
+      const payload = {
+        event_config: {
+          event_name: 'Purchase',
+          show_fields: false
+        },
+        content_ids: ['product-123'],
+        value: 99.99,
+        userData: {
+          db: 'invalid-date'
+        }
+      }
+
+      await send(mockFbq, mockClientParamBuilder, payload, defaultSettings, mockAnalytics)
+
+      // Should not call init if only invalid date is provided
+      const initCalls = (mockFbq).mock.calls.filter((call) => call[0] === 'init')
+      expect(initCalls.length).toBe(0)
+    })
+  })
+
+  describe('init call limits', () => {
+    it('should not send userData init when init count is at max', async () => {
+      mockAnalytics.storage.get.mockReturnValue('2')
+
+      const payload = {
+        event_config: {
+          event_name: 'Purchase',
+          show_fields: false
+        },
+        content_ids: ['product-123'],
+        value: 99.99,
+        userData: {
+          em: 'test@example.com'
+        }
+      }
+
+      await send(mockFbq, mockClientParamBuilder, payload, defaultSettings, mockAnalytics)
+
+      // Should not call init with user data when count is at max
+      const initCalls = (mockFbq).mock.calls.filter((call) => call[0] === 'init')
+      expect(initCalls.length).toBe(0)
+    })
+
+    it('should only call init twice across multiple track events', async () => {
+      // Start with init count at 0
+      let currentInitCount = 0
+      mockAnalytics.storage.get.mockImplementation((key) => {
+        if (key === 'fb_pixel_init_count') {
+          return currentInitCount.toString()
+        }
+        return null
+      })
+      mockAnalytics.storage.set.mockImplementation((key, value) => {
+        if (key === 'fb_pixel_init_count') {
+          currentInitCount = parseInt(value, 10)
+        }
+      })
+
+      const payload = {
+        event_config: {
+          event_name: 'Purchase',
+          show_fields: false
+        },
+        content_ids: ['product-123'],
+        value: 99.99,
+        userData: {
+          em: 'test@example.com'
+        }
+      }
+
+      // First track event - init should be called (count: 0 -> 1)
+      await send(mockFbq, mockClientParamBuilder, payload, defaultSettings, mockAnalytics)
+
+      let initCalls = (mockFbq).mock.calls.filter((call) => call[0] === 'init')
+      expect(initCalls.length).toBe(1)
+      expect(currentInitCount).toBe(1)
+
+      // Second track event - init should be called again (count: 1 -> 2)
+      await send(mockFbq, mockClientParamBuilder, payload, defaultSettings, mockAnalytics)
+
+      initCalls = (mockFbq).mock.calls.filter((call) => call[0] === 'init')
+      expect(initCalls.length).toBe(2)
+      expect(currentInitCount).toBe(2)
+
+      // Third track event - init should NOT be called (count stays at 2)
+      await send(mockFbq, mockClientParamBuilder, payload, defaultSettings, mockAnalytics)
+
+      initCalls = (mockFbq).mock.calls.filter((call) => call[0] === 'init')
+      expect(initCalls.length).toBe(2) // Still only 2 init calls
+      expect(currentInitCount).toBe(2) // Count remains at max
+
+      // Fourth track event - init should still NOT be called
+      await send(mockFbq, mockClientParamBuilder, payload, defaultSettings, mockAnalytics)
+
+      initCalls = (mockFbq).mock.calls.filter((call) => call[0] === 'init')
+      expect(initCalls.length).toBe(2) // Still only 2 init calls
+      expect(currentInitCount).toBe(2)
+
+      // Verify user data storage was still updated on all calls
+      const userDataSetCalls = (mockAnalytics.storage.set).mock.calls.filter((call) => call[0] === 'fb_user_data')
+      expect(userDataSetCalls.length).toBe(4) // User data stored on all 4 track events
+    })
+
+    it('should allow init to fire when count is reset to 0 (simulating new page load)', async () => {
+      const payload = {
+        event_config: {
+          event_name: 'Purchase',
+          show_fields: false
+        },
+        content_ids: ['product-123'],
+        value: 99.99,
+        userData: {
+          em: 'test@example.com'
+        }
+      }
+
+      // === Previous Page Load Scenario ===
+      // Init count at max from previous events
+      mockAnalytics.storage.get.mockReturnValue('2')
+
+      await send(mockFbq, mockClientParamBuilder, payload, defaultSettings, mockAnalytics)
+
+      let initCalls = (mockFbq).mock.calls.filter((call) => call[0] === 'init')
+      expect(initCalls.length).toBe(0) // Init blocked when count at max
+
+      // === New Page Load Scenario ===
+      // On a new page load, the application would reset the init count to 0
+      // (In production, this happens when the page reloads and the pixel script re-initializes)
+      mockAnalytics.storage.get.mockReturnValue('0')
+      mockFbq.mockClear() // Simulate fresh page context
+
+      // First track event on new page
+      await send(mockFbq, mockClientParamBuilder, payload, defaultSettings, mockAnalytics)
+
+      initCalls = (mockFbq).mock.calls.filter((call) => call[0] === 'init')
+      expect(initCalls.length).toBe(1) // Init fires when count is reset
+      expect(mockFbq).toHaveBeenCalledWith('init', 'test-pixel-123', expect.objectContaining({
+        em: expect.any(String)
+      }))
+
+      // Verify init count was incremented in storage
+      expect(mockAnalytics.storage.set).toHaveBeenCalledWith('fb_pixel_init_count', '1')
+    })
+  })
+})