utneque 1.0.0

package/packages/browser/src/browser/__tests__/anon-id-and-reset.integration.test.ts

@@ -0,0 +1,73 @@
+import unfetch from 'unfetch'
+import { HtEventsBrowser } from '..'
+import {
+  clearAjsBrowserStorage,
+  getAnonId,
+} from '../../test-helpers/browser-storage'
+import { createSuccess } from '../../test-helpers/factories'
+
+jest.mock('unfetch')
+const helpers = {
+  mockFetchSettingsSuccessResponse: () => {
+    return jest
+      .mocked(unfetch)
+      .mockImplementation(() => createSuccess({ integrations: {} }))
+  },
+  loadAnalytics() {
+    return HtEventsBrowser.load({ writeKey: 'foo' })
+  },
+}
+
+beforeEach(() => {
+  helpers.mockFetchSettingsSuccessResponse()
+})
+
+describe('anonymousId', () => {
+  describe('setting implicitly', () => {
+    it('is set if an event like track is called during pre-init period', async () => {
+      const analytics = helpers.loadAnalytics()
+      const ctx = await analytics.track('foo')
+      const id = getAnonId()
+      expect(id).toBeDefined()
+      expect(ctx.event.anonymousId).toBe(id)
+    })
+
+    it('sets the global anonymousId to the anonymousId set by the most recent event', async () => {
+      const analytics = helpers.loadAnalytics()
+      const trackCtx = await analytics.track(
+        'add to cart',
+        {},
+        { anonymousId: 'foo' }
+      )
+      expect(getAnonId()).toBe('foo')
+      expect(trackCtx.event.anonymousId).toBe('foo')
+      const idCtx = await analytics.identify('john')
+      expect(getAnonId()).toBe('foo')
+      expect(idCtx.event.anonymousId).toBe('foo')
+    })
+  })
+
+  describe('reset', () => {
+    beforeEach(() => {
+      clearAjsBrowserStorage()
+    })
+
+    it('clears anonId if reset is called during pre-init period', async () => {
+      const analytics = helpers.loadAnalytics()
+      const track = analytics.track('foo')
+      const reset = analytics.reset()
+      await Promise.all([track, reset])
+      expect(getAnonId()).toBeFalsy()
+    })
+
+    it('clears anonId if reset is called after initialization is complete', async () => {
+      const [analytics] = await helpers.loadAnalytics()
+      const track = analytics.track('foo')
+      expect(typeof getAnonId()).toBe('string')
+      analytics.reset()
+      expect(getAnonId()).toBeFalsy()
+      await track
+      expect(getAnonId()).toBeFalsy()
+    })
+  })
+})

package/packages/browser/src/browser/__tests__/cdn.test.ts

@@ -0,0 +1,53 @@
+import { HtEventsBrowser, getGlobalAnalytics } from '../..'
+import unfetch from 'unfetch'
+import { createSuccess } from '../../test-helpers/factories'
+import { setGlobalCDNUrl } from '../../lib/parse-cdn'
+
+jest.mock('unfetch', () => {
+  return jest.fn()
+})
+
+const writeKey = 'foo'
+
+beforeEach(() => {
+  setGlobalCDNUrl(undefined as any)
+})
+
+jest
+  .mocked(unfetch)
+  .mockImplementation(() => createSuccess({ integrations: {} }))
+
+it('supports overriding the CDN', async () => {
+  const mockCdn = 'https://cdn.foobar.com'
+
+  await HtEventsBrowser.load({
+    writeKey,
+    cdnURL: mockCdn,
+  })
+  // by default, cdn settings are NOT fetched from the server
+  expect(unfetch).not.toBeCalledWith(expect.stringContaining(mockCdn))
+})
+
+it('should not use the default CDN if not overridden', async () => {
+  await HtEventsBrowser.load({
+    writeKey,
+  })
+  // by default, cdn settings are NOT fetched from the server
+  expect(unfetch).not.toBeCalledWith(
+    expect.stringContaining('https://cdn.hightouch-events.com')
+  )
+})
+
+it('if CDN is overridden, sets the overridden CDN global variable', async () => {
+  const mockCdn = 'https://cdn.foo.com'
+
+  ;(window as any).htevents = {}
+
+  await HtEventsBrowser.load({
+    writeKey,
+    cdnURL: mockCdn,
+  })
+  // despite by default not calling cdn for settings,
+  // still can set the cdn setting via settings
+  expect(getGlobalAnalytics()?._cdn).toBe(mockCdn)
+})

package/packages/browser/src/browser/__tests__/csp-detection.test.ts

@@ -0,0 +1,140 @@
+import jsdom, { JSDOM } from 'jsdom'
+import unfetch from 'unfetch'
+import { LegacySettings } from '..'
+import { pWhile } from '../../lib/p-while'
+import { snippet } from '../../tester/__fixtures__/hightouch-snippet'
+import * as Factory from '../../test-helpers/factories'
+
+const cdnResponse: LegacySettings = {
+  integrations: {
+    Zapier: {
+      type: 'server',
+    },
+    'Amazon S3': {},
+    Amplitude: {
+      type: 'browser',
+    },
+    Hightouchio: {
+      type: 'browser',
+    },
+    Iterable: {
+      type: 'browser',
+      name: 'Iterable',
+    },
+  },
+}
+
+const fetchSettings = Factory.createSuccess(cdnResponse)
+
+jest.mock('unfetch', () => {
+  return jest.fn()
+})
+
+describe('CSP Detection', () => {
+  const writeKey = `foo`
+
+  let jsd: JSDOM
+  let windowSpy: jest.SpyInstance
+  let documentSpy: jest.SpyInstance
+
+  const getClassic = (): HTMLScriptElement | undefined =>
+    Array.from(document.scripts).find((s) =>
+      s.getAttribute('src')?.includes('classic')
+    )
+
+  beforeEach(() => {
+    jest.restoreAllMocks()
+    jest.resetAllMocks()
+
+    jest.spyOn(console, 'warn').mockImplementationOnce(() => {})
+
+    jest
+      .mocked(unfetch)
+      // @ts-ignore ignore Response required fields
+      .mockImplementation((): Promise<Response> => fetchSettings)
+
+    const html = `
+    <!DOCTYPE html>
+      <head>
+        <script>
+          ${snippet(writeKey, true)}
+        </script>
+      </head>
+      <body>
+      </body>
+    </html>
+    `.trim()
+
+    const virtualConsole = new jsdom.VirtualConsole()
+    jsd = new JSDOM(html, {
+      runScripts: 'dangerously',
+      resources: 'usable',
+      url: 'https://hightouch.com',
+      virtualConsole,
+    })
+
+    windowSpy = jest.spyOn(global, 'window', 'get')
+    documentSpy = jest.spyOn(global, 'document', 'get')
+
+    jest.spyOn(console, 'warn').mockImplementationOnce(() => {})
+
+    windowSpy.mockImplementation(() => {
+      return jsd.window as unknown as Window & typeof globalThis
+    })
+
+    documentSpy.mockImplementation(
+      () => jsd.window.document as unknown as Document
+    )
+  })
+
+  // No longer reverts to ajs classic
+  it.skip('reverts to ajs classic in case of CSP errors', async () => {
+    jest.spyOn(console, 'error').mockImplementationOnce(() => {})
+
+    const handlers: Record<string, EventListener[]> = {}
+    jest
+      .spyOn(global.document, 'addEventListener')
+      .mockImplementationOnce((e, handler) => {
+        handlers[e] = (handlers[e] || []).concat(handler as EventListener)
+      })
+
+    await import('../standalone')
+
+    handlers['securitypolicyviolation'].forEach((handler) => {
+      handler({
+        // @ts-ignore
+        blockedURI: 'cdn.hightouch-events.com',
+      })
+    })
+
+    await pWhile(
+      () => getClassic() === undefined,
+      () => {}
+    )
+
+    expect(getClassic()).toMatchInlineSnapshot(`
+      <script
+        src="https://cdn.foo.com/analytics.js/v1/foo/analytics.classic.js"
+        status="loading"
+        type="text/javascript"
+      />
+    `)
+  })
+
+  it('does not revert to classic when CSP error is report only', async () => {
+    await import('../standalone')
+    const ogScripts = Array.from(document.scripts)
+
+    const warnSpy = jest.spyOn(console, 'warn')
+    const cspSpy = jest.fn()
+    document.addEventListener('securitypolicyviolation', cspSpy)
+
+    const event = new window.Event('securitypolicyviolation') as any
+    event.disposition = 'report'
+    event.blockedURI = 'cdn.hightouch-events.com'
+    document.dispatchEvent(event)
+    expect(cspSpy).toBeCalled()
+    expect(warnSpy).not.toHaveBeenCalled()
+    expect(Array.from(document.scripts)).toEqual(ogScripts)
+  })
+})

package/packages/browser/src/browser/__tests__/inspector.integration.test.ts

@@ -0,0 +1,121 @@
+import { createSuccess } from '../../test-helpers/factories'
+import { HtEventsBrowser } from '../..'
+
+import unfetch from 'unfetch'
+jest.mock('unfetch')
+jest
+  .mocked(unfetch)
+  .mockImplementation(() => createSuccess({ integrations: {} }))
+
+const writeKey = 'foo'
+
+describe('Inspector', () => {
+  beforeEach(() => {
+    Object.assign(((window as any)['__HIGHTOUCH_INSPECTOR__'] ??= {}), {
+      attach: jest.fn(),
+    })
+  })
+
+  it('attaches to inspector', async () => {
+    const [analytics] = await HtEventsBrowser.load({
+      writeKey,
+    })
+
+    expect(
+      ((window as any)['__HIGHTOUCH_INSPECTOR__'] as any).attach
+    ).toHaveBeenCalledWith(analytics)
+  })
+
+  it('emits essential message lifecycle events', async () => {
+    const [analytics] = await HtEventsBrowser.load({
+      writeKey,
+    })
+
+    const triggeredFn = jest.fn()
+    const enrichedFn = jest.fn()
+    const deliveredFn = jest.fn()
+
+    analytics.on('dispatch_start', triggeredFn)
+    analytics.queue.on('message_enriched', enrichedFn)
+    analytics.queue.on('message_delivered', deliveredFn)
+
+    const deliveryPromise = analytics.track('Test event').catch(() => {})
+
+    expect(triggeredFn).toHaveBeenCalledTimes(1)
+
+    expect(triggeredFn).toHaveBeenCalledWith(
+      expect.objectContaining({
+        id: expect.any(String),
+        event: expect.objectContaining({
+          event: 'Test event',
+          type: 'track',
+        }),
+      })
+    )
+
+    await deliveryPromise
+
+    expect(enrichedFn).toHaveBeenCalledTimes(2) // will be called once for every before or enrichment plugin.
+    expect(deliveredFn).toHaveBeenCalledTimes(1)
+  })
+
+  it('emits message enrichment events with enricher information', async () => {
+    const [analytics] = await HtEventsBrowser.load({
+      writeKey,
+    })
+
+    const enrichedFn = jest.fn()
+
+    analytics.queue.on('message_enriched', enrichedFn)
+
+    await analytics.register({
+      name: 'Test plugin',
+      version: '1.0.0',
+      type: 'before',
+      isLoaded: () => true,
+      load: () => Promise.resolve(),
+      track: (ctx) => ctx,
+    })
+
+    const ctx = await analytics.track('Test event').catch(() => {})
+
+    expect(enrichedFn).toHaveBeenLastCalledWith(
+      ctx,
+      expect.objectContaining({
+        name: 'Test plugin',
+        type: 'before',
+      })
+    )
+  })
+
+  it('emits expected events if before plugin throws error ', async () => {
+    const [analytics] = await HtEventsBrowser.load(
+      {
+        writeKey,
+      },
+      { retryQueue: false }
+    )
+
+    const failedFn = jest.fn()
+    const deliveredFn = jest.fn()
+
+    analytics.queue.on('delivery_failure', failedFn)
+    analytics.queue.on('message_delivered', deliveredFn)
+
+    await analytics.register({
+      name: 'Faulty Plugin',
+      version: '1.0.0',
+      type: 'before',
+      isLoaded: () => true,
+      load: () => Promise.resolve(),
+      track: () => {
+        throw new Error()
+      },
+    })
+
+    await analytics.track('Faulty event')
+
+    expect(failedFn).toHaveBeenCalledTimes(1)
+    expect(deliveredFn).not.toHaveBeenCalled()
+  })
+})