@segment/analytics-browser-actions-google-analytics-4 1.0.0

package/src/__tests__/purchase.test.ts

@@ -0,0 +1,103 @@
+import { Subscription } from '@segment/browser-destination-runtime/types'
+import { Analytics, Context } from '@segment/analytics-next'
+import googleAnalytics4Web, { destination } from '../index'
+import { GA } from '../types'
+
+const subscriptions: Subscription[] = [
+  {
+    partnerAction: 'purchase',
+    name: 'Purchase',
+    enabled: true,
+    subscribe: 'type = "track"',
+    mapping: {
+      currency: {
+        '@path': '$.properties.currency'
+      },
+      value: {
+        '@path': '$.properties.value'
+      },
+      coupon: {
+        '@path': '$.properties.coupon'
+      },
+      transaction_id: {
+        '@path': '$.properties.transaction_id'
+      },
+      items: [
+        {
+          item_name: {
+            '@path': `$.properties.products.0.name`
+          },
+          item_id: {
+            '@path': `$.properties.products.0.product_id`
+          },
+          currency: {
+            '@path': `$.properties.products.0.currency`
+          },
+          price: {
+            '@path': `$.properties.products.0.price`
+          },
+          quantity: {
+            '@path': `$.properties.products.0.quantity`
+          }
+        }
+      ]
+    }
+  }
+]
+
+describe('GoogleAnalytics4Web.purchase', () => {
+  const settings = {
+    measurementID: 'test123'
+  }
+
+  let mockGA4: GA
+  let purchaseEvent: any
+  beforeEach(async () => {
+    jest.restoreAllMocks()
+
+    const [trackEventPlugin] = await googleAnalytics4Web({
+      ...settings,
+      subscriptions
+    })
+    purchaseEvent = trackEventPlugin
+
+    jest.spyOn(destination, 'initialize').mockImplementation(() => {
+      mockGA4 = {
+        gtag: jest.fn()
+      }
+      return Promise.resolve(mockGA4.gtag)
+    })
+    await trackEventPlugin.load(Context.system(), {} as Analytics)
+  })
+
+  test('GA4 purchase Event', async () => {
+    const context = new Context({
+      event: 'Purchase',
+      type: 'track',
+      properties: {
+        currency: 'USD',
+        value: 10,
+        transaction_id: 12321,
+        products: [
+          {
+            product_id: '12345',
+            name: 'Monopoly: 3rd Edition',
+            currency: 'USD'
+          }
+        ]
+      }
+    })
+    await purchaseEvent.track?.(context)
+
+    expect(mockGA4.gtag).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.stringContaining('purchase'),
+      expect.objectContaining({
+        currency: 'USD',
+        transaction_id: 12321,
+        items: [{ currency: 'USD', item_id: '12345', item_name: 'Monopoly: 3rd Edition' }],
+        value: 10
+      })
+    )
+  })
+})

package/src/__tests__/refund.test.ts

@@ -0,0 +1,103 @@
+import { Subscription } from '@segment/browser-destination-runtime/types'
+import { Analytics, Context } from '@segment/analytics-next'
+import googleAnalytics4Web, { destination } from '../index'
+import { GA } from '../types'
+
+const subscriptions: Subscription[] = [
+  {
+    partnerAction: 'refund',
+    name: 'refund',
+    enabled: true,
+    subscribe: 'type = "track"',
+    mapping: {
+      currency: {
+        '@path': '$.properties.currency'
+      },
+      value: {
+        '@path': '$.properties.value'
+      },
+      coupon: {
+        '@path': '$.properties.coupon'
+      },
+      transaction_id: {
+        '@path': '$.properties.transaction_id'
+      },
+      items: [
+        {
+          item_name: {
+            '@path': `$.properties.products.0.name`
+          },
+          item_id: {
+            '@path': `$.properties.products.0.product_id`
+          },
+          currency: {
+            '@path': `$.properties.products.0.currency`
+          },
+          price: {
+            '@path': `$.properties.products.0.price`
+          },
+          quantity: {
+            '@path': `$.properties.products.0.quantity`
+          }
+        }
+      ]
+    }
+  }
+]
+
+describe('GoogleAnalytics4Web.refund', () => {
+  const settings = {
+    measurementID: 'test123'
+  }
+
+  let mockGA4: GA
+  let refundEvent: any
+  beforeEach(async () => {
+    jest.restoreAllMocks()
+
+    const [trackEventPlugin] = await googleAnalytics4Web({
+      ...settings,
+      subscriptions
+    })
+    refundEvent = trackEventPlugin
+
+    jest.spyOn(destination, 'initialize').mockImplementation(() => {
+      mockGA4 = {
+        gtag: jest.fn()
+      }
+      return Promise.resolve(mockGA4.gtag)
+    })
+    await trackEventPlugin.load(Context.system(), {} as Analytics)
+  })
+
+  test('GA4 Refund Event', async () => {
+    const context = new Context({
+      event: 'Refund',
+      type: 'track',
+      properties: {
+        currency: 'USD',
+        value: 10,
+        transaction_id: 12321,
+        products: [
+          {
+            product_id: '12345',
+            name: 'Monopoly: 3rd Edition',
+            currency: 'USD'
+          }
+        ]
+      }
+    })
+    await refundEvent.track?.(context)
+
+    expect(mockGA4.gtag).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.stringContaining('refund'),
+      expect.objectContaining({
+        currency: 'USD',
+        transaction_id: 12321,
+        items: [{ currency: 'USD', item_id: '12345', item_name: 'Monopoly: 3rd Edition' }],
+        value: 10
+      })
+    )
+  })
+})

package/src/__tests__/removeFromCart.test.ts

@@ -0,0 +1,99 @@
+import { Subscription } from '@segment/browser-destination-runtime/types'
+import { Analytics, Context } from '@segment/analytics-next'
+import googleAnalytics4Web, { destination } from '../index'
+import { GA } from '../types'
+
+const subscriptions: Subscription[] = [
+  {
+    partnerAction: 'removeFromCart',
+    name: 'Remove from cart',
+    enabled: true,
+    subscribe: 'type = "track"',
+    mapping: {
+      currency: {
+        '@path': '$.properties.currency'
+      },
+      value: {
+        '@path': '$.properties.value'
+      },
+      coupon: {
+        '@path': '$.properties.coupon'
+      },
+      items: [
+        {
+          item_name: {
+            '@path': `$.properties.products.0.name`
+          },
+          item_id: {
+            '@path': `$.properties.products.0.product_id`
+          },
+          currency: {
+            '@path': `$.properties.products.0.currency`
+          },
+          price: {
+            '@path': `$.properties.products.0.price`
+          },
+          quantity: {
+            '@path': `$.properties.products.0.quantity`
+          }
+        }
+      ]
+    }
+  }
+]
+
+describe('GoogleAnalytics4Web.removeFromCart', () => {
+  const settings = {
+    measurementID: 'test123'
+  }
+
+  let mockGA4: GA
+  let removeFromCartEvent: any
+  beforeEach(async () => {
+    jest.restoreAllMocks()
+
+    const [trackEventPlugin] = await googleAnalytics4Web({
+      ...settings,
+      subscriptions
+    })
+    removeFromCartEvent = trackEventPlugin
+
+    jest.spyOn(destination, 'initialize').mockImplementation(() => {
+      mockGA4 = {
+        gtag: jest.fn()
+      }
+      return Promise.resolve(mockGA4.gtag)
+    })
+    await trackEventPlugin.load(Context.system(), {} as Analytics)
+  })
+
+  test('GA4 removeFromCart Event', async () => {
+    const context = new Context({
+      event: 'Remove from Cart',
+      type: 'track',
+      properties: {
+        currency: 'USD',
+        value: 10,
+        products: [
+          {
+            product_id: '12345',
+            name: 'Monopoly: 3rd Edition',
+            currency: 'USD'
+          }
+        ]
+      }
+    })
+
+    await removeFromCartEvent.track?.(context)
+
+    expect(mockGA4.gtag).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.stringContaining('remove_from_cart'),
+      expect.objectContaining({
+        currency: 'USD',
+        items: [{ currency: 'USD', item_id: '12345', item_name: 'Monopoly: 3rd Edition' }],
+        value: 10
+      })
+    )
+  })
+})

package/src/__tests__/search.test.ts

@@ -0,0 +1,64 @@
+import { Subscription } from '@segment/browser-destination-runtime/types'
+import { Analytics, Context } from '@segment/analytics-next'
+import googleAnalytics4Web, { destination } from '../index'
+import { GA } from '../types'
+
+const subscriptions: Subscription[] = [
+  {
+    partnerAction: 'search',
+    name: 'search',
+    enabled: true,
+    subscribe: 'type = "track"',
+    mapping: {
+      search_term: {
+        '@path': '$.properties.search_term'
+      }
+    }
+  }
+]
+
+describe('GoogleAnalytics4Web.search', () => {
+  const settings = {
+    measurementID: 'test123'
+  }
+
+  let mockGA4: GA
+  let searchEvent: any
+  beforeEach(async () => {
+    jest.restoreAllMocks()
+
+    const [trackEventPlugin] = await googleAnalytics4Web({
+      ...settings,
+      subscriptions
+    })
+    searchEvent = trackEventPlugin
+
+    jest.spyOn(destination, 'initialize').mockImplementation(() => {
+      mockGA4 = {
+        gtag: jest.fn()
+      }
+      return Promise.resolve(mockGA4.gtag)
+    })
+    await trackEventPlugin.load(Context.system(), {} as Analytics)
+  })
+
+  test('GA4 search Event', async () => {
+    const context = new Context({
+      event: 'search',
+      type: 'track',
+      properties: {
+        search_term: 'Monopoly: 3rd Edition'
+      }
+    })
+
+    await searchEvent.track?.(context)
+
+    expect(mockGA4.gtag).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.stringContaining('search'),
+      expect.objectContaining({
+        search_term: 'Monopoly: 3rd Edition'
+      })
+    )
+  })
+})

package/src/__tests__/selectItem.test.ts

@@ -0,0 +1,96 @@
+import { Subscription } from '@segment/browser-destination-runtime/types'
+import { Analytics, Context } from '@segment/analytics-next'
+import googleAnalytics4Web, { destination } from '../index'
+import { GA } from '../types'
+
+const subscriptions: Subscription[] = [
+  {
+    partnerAction: 'selectItem',
+    name: 'Select Item',
+    enabled: true,
+    subscribe: 'type = "track"',
+    mapping: {
+      item_list_id: {
+        '@path': '$.properties.item_list_id'
+      },
+      item_list_name: {
+        '@path': '$.properties.item_list_name'
+      },
+      items: [
+        {
+          item_name: {
+            '@path': `$.properties.products.0.name`
+          },
+          item_id: {
+            '@path': `$.properties.products.0.product_id`
+          },
+          currency: {
+            '@path': `$.properties.products.0.currency`
+          },
+          price: {
+            '@path': `$.properties.products.0.price`
+          },
+          quantity: {
+            '@path': `$.properties.products.0.quantity`
+          }
+        }
+      ]
+    }
+  }
+]
+
+describe('GoogleAnalytics4Web.selectItem', () => {
+  const settings = {
+    measurementID: 'test123'
+  }
+
+  let mockGA4: GA
+  let selectItemEvent: any
+  beforeEach(async () => {
+    jest.restoreAllMocks()
+
+    const [trackEventPlugin] = await googleAnalytics4Web({
+      ...settings,
+      subscriptions
+    })
+    selectItemEvent = trackEventPlugin
+
+    jest.spyOn(destination, 'initialize').mockImplementation(() => {
+      mockGA4 = {
+        gtag: jest.fn()
+      }
+      return Promise.resolve(mockGA4.gtag)
+    })
+    await trackEventPlugin.load(Context.system(), {} as Analytics)
+  })
+
+  test('GA4 selectItem Event', async () => {
+    const context = new Context({
+      event: 'Select Item',
+      type: 'track',
+      properties: {
+        item_list_id: 12321,
+        item_list_name: 'Monopoly: 3rd Edition',
+        products: [
+          {
+            product_id: '12345',
+            name: 'Monopoly: 3rd Edition',
+            currency: 'USD'
+          }
+        ]
+      }
+    })
+
+    await selectItemEvent.track?.(context)
+
+    expect(mockGA4.gtag).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.stringContaining('select_item'),
+      expect.objectContaining({
+        item_list_id: 12321,
+        item_list_name: 'Monopoly: 3rd Edition',
+        items: [{ currency: 'USD', item_id: '12345', item_name: 'Monopoly: 3rd Edition' }]
+      })
+    )
+  })
+})

package/src/__tests__/selectPromotion.test.ts

@@ -0,0 +1,111 @@
+import { Subscription } from '@segment/browser-destination-runtime/types'
+import { Analytics, Context } from '@segment/analytics-next'
+import googleAnalytics4Web, { destination } from '../index'
+import { GA } from '../types'
+
+const subscriptions: Subscription[] = [
+  {
+    partnerAction: 'selectPromotion',
+    name: 'Select Promotion',
+    enabled: true,
+    subscribe: 'type = "track"',
+    mapping: {
+      creative_name: {
+        '@path': '$.properties.creative_name'
+      },
+      creative_slot: {
+        '@path': '$.properties.creative_slot'
+      },
+      location_id: {
+        '@path': '$.properties.location_id'
+      },
+      promotion_id: {
+        '@path': '$.properties.promotion_id'
+      },
+      promotion_name: {
+        '@path': '$.properties.promotion_name'
+      },
+      items: [
+        {
+          item_name: {
+            '@path': `$.properties.products.0.name`
+          },
+          item_id: {
+            '@path': `$.properties.products.0.product_id`
+          },
+          currency: {
+            '@path': `$.properties.products.0.currency`
+          },
+          price: {
+            '@path': `$.properties.products.0.price`
+          },
+          quantity: {
+            '@path': `$.properties.products.0.quantity`
+          }
+        }
+      ]
+    }
+  }
+]
+
+describe('GoogleAnalytics4Web.selectPromotion', () => {
+  const settings = {
+    measurementID: 'test123'
+  }
+
+  let mockGA4: GA
+  let selectPromotionEvent: any
+  beforeEach(async () => {
+    jest.restoreAllMocks()
+
+    const [trackEventPlugin] = await googleAnalytics4Web({
+      ...settings,
+      subscriptions
+    })
+    selectPromotionEvent = trackEventPlugin
+
+    jest.spyOn(destination, 'initialize').mockImplementation(() => {
+      mockGA4 = {
+        gtag: jest.fn()
+      }
+      return Promise.resolve(mockGA4.gtag)
+    })
+    await trackEventPlugin.load(Context.system(), {} as Analytics)
+  })
+
+  test('GA4 selectPromotion Event', async () => {
+    const context = new Context({
+      event: 'Select Promotion',
+      type: 'track',
+      properties: {
+        creative_name: 'summer_banner2',
+        creative_slot: 'featured_app_1',
+        location_id: 'ChIJIQBpAG2ahYAR_6128GcTUEo',
+        promotion_id: 'P_12345',
+        promotion_name: 'Summer Sale',
+        products: [
+          {
+            product_id: '12345',
+            name: 'Monopoly: 3rd Edition',
+            currency: 'USD'
+          }
+        ]
+      }
+    })
+
+    await selectPromotionEvent.track?.(context)
+
+    expect(mockGA4.gtag).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.stringContaining('select_promotion'),
+      expect.objectContaining({
+        creative_name: 'summer_banner2',
+        creative_slot: 'featured_app_1',
+        location_id: 'ChIJIQBpAG2ahYAR_6128GcTUEo',
+        promotion_id: 'P_12345',
+        promotion_name: 'Summer Sale',
+        items: [{ currency: 'USD', item_id: '12345', item_name: 'Monopoly: 3rd Edition' }]
+      })
+    )
+  })
+})

package/src/__tests__/signUp.test.ts

@@ -0,0 +1,62 @@
+import { Subscription } from '@segment/browser-destination-runtime/types'
+import { Analytics, Context } from '@segment/analytics-next'
+import googleAnalytics4Web, { destination } from '../index'
+import { GA } from '../types'
+
+const subscriptions: Subscription[] = [
+  {
+    partnerAction: 'signUp',
+    name: 'signUp',
+    enabled: true,
+    subscribe: 'type = "track"',
+    mapping: {
+      method: {
+        '@path': '$.properties.method'
+      }
+    }
+  }
+]
+
+describe('GoogleAnalytics4Web.signUp', () => {
+  const settings = {
+    measurementID: 'test123'
+  }
+
+  let mockGA4: GA
+  let signUpEvent: any
+  beforeEach(async () => {
+    jest.restoreAllMocks()
+
+    const [trackEventPlugin] = await googleAnalytics4Web({
+      ...settings,
+      subscriptions
+    })
+    signUpEvent = trackEventPlugin
+
+    jest.spyOn(destination, 'initialize').mockImplementation(() => {
+      mockGA4 = {
+        gtag: jest.fn()
+      }
+      return Promise.resolve(mockGA4.gtag)
+    })
+    await trackEventPlugin.load(Context.system(), {} as Analytics)
+  })
+
+  test('GA4 signUp Event', async () => {
+    const context = new Context({
+      event: 'signUp',
+      type: 'track',
+      properties: {
+        method: 'Google'
+      }
+    })
+
+    await signUpEvent.track?.(context)
+
+    expect(mockGA4.gtag).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.stringContaining('sign_up'),
+      expect.objectContaining({ method: 'Google' })
+    )
+  })
+})