npm - utneque - Versions diffs - 1.0.0 - Mend

utneque 1.0.0

Files changed (431) hide show

package/packages/browser/src/browser/__tests__/standalone-analytics.test.ts ADDED Viewed

@@ -0,0 +1,303 @@
+import jsdom, { JSDOM } from 'jsdom'
+import { InitOptions, getGlobalAnalytics } from '../../'
+import { HtEventsBrowser, loadLegacySettings } from '../../browser'
+import { snippet } from '../../tester/__fixtures__/hightouch-snippet'
+import { install } from '../standalone-analytics'
+import unfetch from 'unfetch'
+import { PersistedPriorityQueue } from '../../lib/priority-queue/persisted'
+import { sleep } from '../../lib/sleep'
+import * as Factory from '../../test-helpers/factories'
+import { EventQueue } from '../../core/queue/event-queue'
+import { AnalyticsStandalone } from '../standalone-interface'
+import { getBufferedPageCtxFixture } from '../../test-helpers/fixtures'
+const track = jest.fn()
+const identify = jest.fn()
+const page = jest.fn()
+const setAnonymousId = jest.fn()
+const register = jest.fn()
+const addSourceMiddleware = jest.fn()
+const on = jest.fn()
+jest.mock('../../core/analytics', () => ({
+  Analytics: (_: unknown, options?: InitOptions): unknown => ({
+    track,
+    identify,
+    page,
+    setAnonymousId,
+    addSourceMiddleware,
+    register,
+    emit: jest.fn(),
+    on,
+    queue: new EventQueue(new PersistedPriorityQueue(1, 'event-queue') as any),
+    options,
+  }),
+}))
+const fetchSettings = Factory.createSuccess({ integrations: {} })
+jest.mock('unfetch', () => {
+  return jest.fn()
+})
+describe('standalone bundle', () => {
+  const hightouchDotCom = `foo`
+  beforeEach(async () => {
+    ;(window as any).htevents = undefined
+    const html = `
+    <!DOCTYPE html>
+      <head>
+        <script>
+          ${snippet(
+            hightouchDotCom,
+            true,
+            `
+            window.htevents.track('fruit basket', { fruits: ['🍌', '🍇'] })
+            window.htevents.identify('netto', { employer: 'hightouch' })
+            window.htevents.setAnonymousId('anonNetto')
+            window.htevents.on('initialize', () => ({ user: 'ariel' }))
+          `
+          )}
+        </script>
+      </head>
+      <body>
+      </body>
+    </html>
+    `.trim()
+    const virtualConsole = new jsdom.VirtualConsole()
+    const jsd = new JSDOM(html, {
+      runScripts: 'dangerously',
+      resources: 'usable',
+      url: 'https://hightouch.com',
+      virtualConsole,
+    })
+    const windowSpy = jest.spyOn(global, 'window', 'get')
+    const documentSpy = jest.spyOn(global, 'document', 'get')
+    jest.spyOn(console, 'warn').mockImplementationOnce(() => {})
+    jest.spyOn(console, 'error').mockImplementationOnce(() => {})
+    windowSpy.mockImplementation(() => {
+      return jsd.window as unknown as Window & typeof globalThis
+    })
+    documentSpy.mockImplementation(
+      () => jsd.window.document as unknown as Document
+    )
+  })
+  it('detects embedded write keys', async () => {
+    window.analyticsWriteKey = 'write_key_abc_123'
+    const fakeAjs = {
+      ready: async (cb: Function): Promise<void> => {
+        cb()
+      },
+    }
+    const spy = jest
+      .spyOn(HtEventsBrowser, 'standalone')
+      .mockResolvedValueOnce(fakeAjs as AnalyticsStandalone)
+    await install()
+    expect(spy).toHaveBeenCalledWith('write_key_abc_123', {})
+  })
+  it('derives the write key from scripts on the page', async () => {
+    const fakeAjs = {
+      ready: async (cb: Function): Promise<void> => {
+        cb()
+      },
+    }
+    const spy = jest
+      .spyOn(HtEventsBrowser, 'standalone')
+      .mockResolvedValueOnce(fakeAjs as AnalyticsStandalone)
+    await install()
+    expect(spy).toHaveBeenCalledWith(hightouchDotCom, {})
+  })
+  it('derives the CDN from scripts on the page', async () => {
+    jest
+      .mocked(unfetch)
+      // @ts-ignore ignore Response required fields
+      .mockImplementation((): Promise<Response> => fetchSettings)
+    await loadLegacySettings(hightouchDotCom)
+    expect(unfetch).toHaveBeenCalledWith(
+      'https://cdn.foo.com/v1/projects/foo/settings'
+    )
+  })
+  it('is capable of having the CDN overridden', async () => {
+    jest
+      .mocked(unfetch)
+      // @ts-ignore ignore Response required fields
+      .mockImplementation((): Promise<Response> => fetchSettings)
+    const mockCdn = 'http://my-overridden-cdn.com'
+    getGlobalAnalytics()!._cdn = mockCdn
+    await loadLegacySettings(hightouchDotCom)
+    expect(unfetch).toHaveBeenCalledWith(expect.stringContaining(mockCdn))
+  })
+  it('runs any buffered operations after load', async () => {
+    jest
+      .mocked(unfetch)
+      // @ts-ignore ignore Response required fields
+      .mockImplementation((): Promise<Response> => fetchSettings)
+    await install()
+    await sleep(0)
+    expect(track).toHaveBeenCalledWith(
+      'fruit basket',
+      {
+        fruits: ['🍌', '🍇'],
+      },
+      getBufferedPageCtxFixture()
+    )
+    expect(identify).toHaveBeenCalledWith(
+      'netto',
+      {
+        employer: 'hightouch',
+      },
+      getBufferedPageCtxFixture()
+    )
+    expect(page).toHaveBeenCalled()
+  })
+  it('adds buffered source middleware before other buffered operations', async () => {
+    jest
+      .mocked(unfetch)
+      // @ts-ignore ignore Response required fields
+      .mockImplementation((): Promise<Response> => fetchSettings)
+    const operations: string[] = []
+    addSourceMiddleware.mockImplementationOnce(() =>
+      operations.push('addSourceMiddleware')
+    )
+    page.mockImplementationOnce(() => operations.push('page'))
+    await install()
+    await sleep(0)
+    expect(addSourceMiddleware).toHaveBeenCalled()
+    expect(operations).toEqual([
+      // should run before page call in the snippet
+      'addSourceMiddleware',
+      'page',
+    ])
+  })
+  it('sets buffered anonymousId before loading destinations', async () => {
+    jest
+      .mocked(unfetch)
+      // @ts-ignore ignore Response required fields
+      .mockImplementation((): Promise<Response> => fetchSettings)
+    const operations: string[] = []
+    track.mockImplementationOnce(() => operations.push('track'))
+    setAnonymousId.mockImplementationOnce(() =>
+      operations.push('setAnonymousId')
+    )
+    register.mockImplementationOnce(() => operations.push('register'))
+    await install()
+    await sleep(0)
+    expect(setAnonymousId).toHaveBeenCalledWith('anonNetto')
+    expect(operations).toEqual([
+      // should run before any plugin is registered
+      'setAnonymousId',
+      // should run before any events are sent downstream
+      'register',
+      // should run after all plugins have been registered
+      'track',
+    ])
+  })
+  it('sets buffered event emitters before loading destinations', async () => {
+    jest
+      .mocked(unfetch)
+      .mockImplementation(() => fetchSettings as Promise<Response>)
+    const operations: string[] = []
+    track.mockImplementationOnce(() => operations.push('track'))
+    on.mockImplementationOnce(() => operations.push('on'))
+    register.mockImplementationOnce(() => operations.push('register'))
+    await install()
+    await sleep(0)
+    const initializeCalls = on.mock.calls.filter(
+      ([arg1]) => arg1 === 'initialize'
+    )
+    expect(initializeCalls.length).toBe(1)
+    expect(operations).toEqual([
+      // should run before any plugin is registered
+      'on',
+      // should run before any events are sent downstream
+      'register',
+      // should run after all plugins have been registered
+      'track',
+    ])
+  })
+  it('runs any buffered operations created after preFlush after load', async () => {
+    jest
+      .mocked(unfetch)
+      // @ts-ignore ignore Response required fields
+      .mockImplementation((): Promise<Response> => fetchSettings)
+    // register is called after flushPreBuffer in `loadAnalytics`
+    register.mockImplementationOnce(() =>
+      getGlobalAnalytics()?.track('race conditions', { foo: 'bar' })
+    )
+    await install()
+    await sleep(0)
+    expect(track).toHaveBeenCalledWith(
+      'fruit basket',
+      {
+        fruits: ['🍌', '🍇'],
+      },
+      getBufferedPageCtxFixture()
+    )
+    expect(track).toHaveBeenCalledWith(
+      'race conditions',
+      { foo: 'bar' },
+      getBufferedPageCtxFixture()
+    )
+    expect(identify).toHaveBeenCalledWith(
+      'netto',
+      {
+        employer: 'hightouch',
+      },
+      getBufferedPageCtxFixture()
+    )
+    expect(page).toHaveBeenCalled()
+  })
+})

package/packages/browser/src/browser/__tests__/standalone-errors.test.ts ADDED Viewed

@@ -0,0 +1,136 @@
+import jsdom, { JSDOM } from 'jsdom'
+import { HtEventsBrowser, LegacySettings } from '..'
+import { snippet } from '../../tester/__fixtures__/hightouch-snippet'
+import { pWhile } from '../../lib/p-while'
+import unfetch from 'unfetch'
+import { RemoteMetrics } from '../../core/stats/remote-metrics'
+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('standalone bundle', () => {
+  const hightouchDotCom = `foo`
+  let jsd: JSDOM
+  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(hightouchDotCom, 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,
+    })
+    const windowSpy = jest.spyOn(global, 'window', 'get')
+    const 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
+    )
+  })
+  it('catches initialization errors and reports them', async () => {
+    window.analyticsWriteKey = 'write_key_abc_123'
+    const errorMessages: string[] = []
+    const metrics: { metric: string; tags: string[] }[] = []
+    jest.spyOn(console, 'error').mockImplementationOnce((...args) => {
+      errorMessages.push(args.join(','))
+    })
+    jest
+      .spyOn(RemoteMetrics.prototype, 'increment')
+      .mockImplementationOnce((metric, tags) => {
+        metrics.push({
+          metric,
+          tags,
+        })
+      })
+    jest
+      .spyOn(HtEventsBrowser, 'standalone')
+      .mockRejectedValueOnce(new Error('Ohhh nooo'))
+    await import('../standalone')
+    await pWhile(
+      () => errorMessages.length === 0,
+      () => {}
+    )
+    expect(metrics).toMatchInlineSnapshot(`Array []`)
+    // Uncomment when re-enabling RemoteMetrics -- see standalone.ts and loadAnalytics usage of RemoteMetrics
+    // expect(metrics).toMatchInlineSnapshot(`
+    //   Array [
+    //     Object {
+    //       "metric": "analytics_js.invoke.error",
+    //       "tags": Array [
+    //         "type:initialization",
+    //         "message:Ohhh nooo",
+    //         "name:Error",
+    //         "wk:write_key_abc_123",
+    //       ],
+    //     },
+    //   ]
+    // `)
+    expect(errorMessages).toMatchInlineSnapshot(`
+      Array [
+        "[analytics.js],Failed to load Analytics.js,Error: Ohhh nooo",
+      ]
+    `)
+  })
+})

package/packages/browser/src/browser/__tests__/standalone.test.ts ADDED Viewed

@@ -0,0 +1,97 @@
+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'
+import { getGlobalAnalytics } from '../..'
+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('standalone bundle', () => {
+  const hightouchDotCom = `foo`
+  let jsd: JSDOM
+  let windowSpy: jest.SpyInstance
+  let documentSpy: jest.SpyInstance
+  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(hightouchDotCom, 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
+    )
+  })
+  it('loads AJS on execution', async () => {
+    await import('../standalone')
+    await pWhile(
+      () => getGlobalAnalytics()?.initialized !== true,
+      () => {}
+    )
+    expect(getGlobalAnalytics()).not.toBeUndefined()
+    expect(getGlobalAnalytics()?.initialized).toBe(true)
+  })
+})

package/packages/browser/src/browser/__tests__/typedef-tests/analytics-browser.ts ADDED Viewed

@@ -0,0 +1,150 @@
+import { HtEventsBrowser, Analytics, Context, User, Group } from '../../..'
+import { assertNotAny, assertIs } from '../../../test-helpers/type-assertions'
+/**
+ * These are general typescript definition tests;
+ * They aren't meant to be run by anything but the typescript compiler.
+ */
+export default {
+  'HtEventsBrowser should return the correct type': () => {
+    const result = HtEventsBrowser.load({ writeKey: 'abc' })
+    assertNotAny(result)
+    assertIs<HtEventsBrowser>(result)
+  },
+  'HtEventsBrowser should return the correct type if awaited on.': async () => {
+    const [analytics, context] = await HtEventsBrowser.load({
+      writeKey: 'foo',
+    })
+    assertNotAny(analytics)
+    assertIs<Analytics>(analytics)
+    assertNotAny(context)
+    assertIs<Context>(context)
+  },
+  'Promise API should work': () => {
+    void HtEventsBrowser.load({ writeKey: 'foo' })
+      .then(([analytics, context]) => {
+        assertNotAny(analytics)
+        assertIs<Analytics>(analytics)
+        assertNotAny(context)
+        assertIs<Context>(context)
+      })
+      .then(() => {
+        return 'a String!' as const
+      })
+      .then((str) => {
+        assertNotAny(str)
+        assertIs<'a String!'>(str)
+      })
+  },
+  'If catch is before "then" in the middleware chain, .then should take into account the catch clause':
+    () => {
+      void HtEventsBrowser.load({ writeKey: 'foo' })
+        .catch((err: string) => {
+          assertIs<string>(err)
+          return 123
+        })
+        .then((response) => {
+          assertNotAny(response)
+          assertIs<number | [Analytics, Context]>(response)
+        })
+    },
+  'Group should have the correct type': () => {
+    const ajs = HtEventsBrowser.load({ writeKey: 'foo' })
+    {
+      const grpResult = ajs.group()
+      assertIs<Promise<Group>>(grpResult)
+    }
+    {
+      const grpResult = ajs.group('foo')
+      assertIs<Promise<Context>>(grpResult)
+    }
+  },
+  'User should have the correct type': () => {
+    const ajs = HtEventsBrowser.load({ writeKey: 'foo' })
+    {
+      const grpResult = ajs.user()
+      assertIs<Promise<User>>(grpResult)
+    }
+  },
+  'Identify should work with spread objects ': () => {
+    const user = {
+      name: 'john',
+      id: 'abc123',
+    }
+    const { id, ...traits } = user
+    void HtEventsBrowser.load({ writeKey: 'foo' }).identify('foo', traits)
+  },
+  'Track should work with spread objects': () => {
+    const user = {
+      name: 'john',
+      id: 'abc123',
+    }
+    const { id, ...traits } = user
+    void HtEventsBrowser.load({ writeKey: 'foo' }).track('foo', traits)
+  },
+  'Identify should work with generic objects ': () => {
+    const user = {
+      name: 'john',
+      id: 'abc123',
+    }
+    void HtEventsBrowser.load({ writeKey: 'foo' }).identify('foo', user)
+  },
+  'Context should have a key allowing arbitrary properties': async () => {
+    const [_, ctx] = await HtEventsBrowser.load({ writeKey: 'foo' })
+    const properties = ctx.event.properties!
+    properties.category.baz = 'hello'
+  },
+  'Track should allow undefined properties': () => {
+    type User = {
+      name?: string
+      thing: 123
+    }
+    void HtEventsBrowser.load({ writeKey: 'foo' }).track('foo', {} as User)
+  },
+  'Lazy instantiation should be supported': () => {
+    const analytics = new HtEventsBrowser()
+    assertNotAny(analytics)
+    assertIs<HtEventsBrowser>(analytics)
+    analytics.load({ writeKey: 'foo' })
+    void analytics.track('foo')
+  },
+  '.load should return this': () => {
+    const analytics = new HtEventsBrowser().load({ writeKey: 'foo' })
+    assertNotAny(analytics)
+    assertIs<HtEventsBrowser>(analytics)
+  },
+  'Should accept traits': () => {
+    const analytics = {} as HtEventsBrowser
+    class Foo {
+      name = 'hello'
+      toJSON() {
+        return this.name
+      }
+    }
+    void analytics.identify('foo', new Foo())
+    void analytics.identify('foo', { address: null })
+    // @ts-expect-error - Type 'string' has no properties in common with type
+    void analytics.identify('foo', { address: 'hello' })
+    // @ts-expect-error - Type 'never[]' is not assignable to type
+    void analytics.identify('foo', { id: [] })
+  },
+  'Should accept optional ExtraContext': () => {
+    const analytics = {} as HtEventsBrowser
+    void analytics.track('foo', undefined, { context: {} })
+    void analytics.track('foo', undefined, { context: { active: true } })
+    void analytics.track('foo', undefined, {
+      context: {
+        // @ts-expect-error Type 'string' is not assignable to type 'boolean | null | undefined'.ts(2322)
+        active: 'hello',
+      },
+    })
+  },
+}