npm - utneque - Versions diffs - 1.0.0 - Mend

utneque 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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',
+      },
+    })
+  },
+}