npm - utneque - Versions diffs - 1.0.0 - Mend

utneque 1.0.0

Files changed (431) hide show

package/packages/browser/src/browser/__tests__/integrations.integration.test.ts ADDED Viewed

@@ -0,0 +1,260 @@
+import { JSDOM } from 'jsdom'
+import { HtEventsBrowser } from '../..'
+import { LegacyDestination } from '../../plugins/ajs-destination'
+import { ClassicIntegrationBuilder } from '../../plugins/ajs-destination/types'
+import { ActionDestination } from '../../plugins/remote-loader'
+import unfetch from 'unfetch'
+import { cdnSettingsMinimal } from '../../test-helpers/fixtures/cdn-settings'
+import { Fake } from '../../test-helpers/fixtures/classic-destination'
+import { Plugin } from '../../core/plugin'
+import { createMockFetchImplementation } from '../../test-helpers/fixtures/create-fetch-method'
+const amplitudeWriteKey = 'foo'
+const writeKey = 'foo'
+jest.mock('unfetch')
+const mockFetchCdnSettings = (cdnSettings: any = {}) => {
+  return jest
+    .mocked(unfetch)
+    .mockImplementation(createMockFetchImplementation(cdnSettings))
+}
+jest.spyOn(console, 'warn').mockImplementation((...errMsgs) => {
+  if (errMsgs[0].includes('deprecate')) {
+    // get rid of deprecation wawrning spam
+    return
+  }
+  console.warn(
+    'Unexpected console.warn spam in your jest test - please stub out. ' +
+      JSON.stringify(errMsgs)
+  )
+})
+// We do not currently support remote integrations
+describe.skip('Integrations', () => {
+  beforeEach(async () => {
+    mockFetchCdnSettings()
+    const html = `
+    <!DOCTYPE html>
+      <head>
+        <script>'hi'</script>
+      </head>
+      <body>
+      </body>
+    </html>
+    `.trim()
+    const jsd = new JSDOM(html, {
+      runScripts: 'dangerously',
+      resources: 'usable',
+      url: 'https://localhost',
+    })
+    const windowSpy = jest.spyOn(global, 'window', 'get')
+    windowSpy.mockImplementation(
+      () => jsd.window as unknown as Window & typeof globalThis
+    )
+    const documentSpy = jest.spyOn(global, 'document', 'get')
+    documentSpy.mockImplementation(
+      () => jsd.window.document as unknown as Document
+    )
+  })
+  describe('addDestinationMiddleware', () => {
+    it('supports registering destination middlewares', async () => {
+      const [analytics] = await HtEventsBrowser.load({
+        writeKey,
+      })
+      const amplitude = new LegacyDestination(
+        'amplitude',
+        'latest',
+        writeKey,
+        {
+          apiKey: amplitudeWriteKey,
+        },
+        {}
+      )
+      await analytics.register(amplitude)
+      await amplitude.ready()
+      analytics
+        .addDestinationMiddleware('amplitude', ({ next, payload }) => {
+          payload.obj.properties!.hello = 'from the other side'
+          next(payload)
+        })
+        .catch((err) => {
+          throw err
+        })
+      const integrationMock = jest.spyOn(amplitude.integration!, 'track')
+      const ctx = await analytics.track('Hello!')
+      // does not modify the event
+      expect(ctx.event.properties).not.toEqual({
+        hello: 'from the other side',
+      })
+      const calledWith = integrationMock.mock.calls[0][0].properties()
+      // only impacted this destination
+      expect(calledWith).toEqual({
+        ...ctx.event.properties,
+        hello: 'from the other side',
+      })
+    })
+    it('supports registering action destination middlewares', async () => {
+      const testPlugin: Plugin = {
+        name: 'test',
+        type: 'destination',
+        version: '0.1.0',
+        load: () => Promise.resolve(),
+        isLoaded: () => true,
+      }
+      const [analytics] = await HtEventsBrowser.load({
+        writeKey,
+      })
+      const fullstory = new ActionDestination('fullstory', testPlugin)
+      await analytics.register(fullstory)
+      await fullstory.ready()
+      analytics
+        .addDestinationMiddleware('fullstory', ({ next, payload }) =>
+          next(payload)
+        )
+        .catch((err) => {
+          throw err
+        })
+      expect(analytics.queue.plugins).toContain(fullstory)
+    })
+  })
+  describe('Legacy / Classic Destinations', () => {
+    it('lists all legacy destinations', async () => {
+      const amplitude = new LegacyDestination(
+        'Amplitude',
+        'latest',
+        writeKey,
+        {
+          apiKey: amplitudeWriteKey,
+        },
+        {}
+      )
+      const ga = new LegacyDestination(
+        'Google-Analytics',
+        'latest',
+        writeKey,
+        {},
+        {}
+      )
+      const [analytics] = await HtEventsBrowser.load({
+        writeKey,
+        plugins: [amplitude, ga],
+      })
+      await analytics.ready()
+      expect(analytics.Integrations).toMatchInlineSnapshot(`
+      Object {
+        "Amplitude": [Function],
+        "Google-Analytics": [Function],
+      }
+    `)
+    })
+    it('catches destinations with dots in their names', async () => {
+      const amplitude = new LegacyDestination(
+        'Amplitude',
+        'latest',
+        writeKey,
+        {
+          apiKey: amplitudeWriteKey,
+        },
+        {}
+      )
+      const ga = new LegacyDestination(
+        'Google-Analytics',
+        'latest',
+        writeKey,
+        {},
+        {}
+      )
+      const customerIO = new LegacyDestination(
+        'Customer.io',
+        'latest',
+        writeKey,
+        {},
+        {}
+      )
+      const [analytics] = await HtEventsBrowser.load({
+        writeKey,
+        plugins: [amplitude, ga, customerIO],
+      })
+      await analytics.ready()
+      expect(analytics.Integrations).toMatchInlineSnapshot(`
+      Object {
+        "Amplitude": [Function],
+        "Customer.io": [Function],
+        "Google-Analytics": [Function],
+      }
+    `)
+    })
+    it('uses directly provided classic integrations without fetching them from cdn', async () => {
+      mockFetchCdnSettings({ integrations: cdnSettingsMinimal })
+      const intializeSpy = jest.spyOn(Fake.prototype, 'initialize')
+      const trackSpy = jest.spyOn(Fake.prototype, 'track')
+      const [analytics] = await HtEventsBrowser.load(
+        {
+          writeKey,
+          classicIntegrations: [Fake],
+        },
+        {
+          integrations: {
+            Fake: {},
+          },
+        }
+      )
+      await analytics.ready()
+      await analytics.track('test event')
+      expect(trackSpy).toHaveBeenCalledTimes(1)
+      expect(intializeSpy).toHaveBeenCalledTimes(1)
+    })
+    it('ignores directly provided classic integrations if settings for them are unavailable', async () => {
+      mockFetchCdnSettings({ integrations: {} })
+      const intializeSpy = jest.spyOn(Fake.prototype, 'initialize')
+      const trackSpy = jest.spyOn(Fake.prototype, 'track')
+      const [analytics] = await HtEventsBrowser.load({
+        writeKey,
+        classicIntegrations: [Fake as unknown as ClassicIntegrationBuilder],
+      })
+      await analytics.ready()
+      expect(intializeSpy).not.toHaveBeenCalled()
+      await analytics.track('test event')
+      expect(trackSpy).not.toHaveBeenCalled()
+    })
+  })
+})

package/packages/browser/src/browser/__tests__/page-enrichment.integration.test.ts ADDED Viewed

@@ -0,0 +1,216 @@
+import unfetch from 'unfetch'
+import { Analytics, HtEventsBrowser } from '../..'
+import { PageContext } from '../../core/page'
+import {
+  cdnSettingsMinimal,
+  createMockFetchImplementation,
+} from '../../test-helpers/fixtures'
+jest.mock('unfetch')
+jest.mocked(unfetch).mockImplementation(createMockFetchImplementation())
+let ajs: Analytics
+beforeEach(async () => {
+  const [analytics] = await HtEventsBrowser.load({
+    writeKey: 'abc_123',
+    cdnSettings: { ...cdnSettingsMinimal },
+  })
+  ajs = analytics
+})
+describe('Page Enrichment', () => {
+  it('enriches page calls', async () => {
+    const ctx = await ajs.page('Checkout', {})
+    expect(ctx.event.properties).toMatchInlineSnapshot(`
+      Object {
+        "name": "Checkout",
+        "path": "/",
+        "referrer": "",
+        "search": "",
+        "title": "",
+        "url": "http://localhost/",
+      }
+    `)
+  })
+  it('enriches track events with the page context', async () => {
+    const ctx = await ajs.track('My event', {
+      banana: 'phone',
+    })
+    expect(ctx.event.context?.page).toMatchInlineSnapshot(`
+      Object {
+        "path": "/",
+        "referrer": "",
+        "search": "",
+        "title": "",
+        "url": "http://localhost/",
+      }
+    `)
+  })
+  describe('event.properties override behavior', () => {
+    it('special page properties in event.properties (url, referrer, etc) are copied to context.page', async () => {
+      const pageProps: PageContext & { [key: string]: unknown } = Object.freeze(
+        {
+          path: 'foo',
+          referrer: 'bar',
+          search: 'baz',
+          title: 'qux',
+          url: 'http://fake.com',
+          should_not_show_up: 'hello',
+        }
+      )
+      const ctx = await ajs.page('My Event', pageProps)
+      const page = ctx.event.context!.page
+      expect(page).toMatchInlineSnapshot(`
+        Object {
+          "path": "foo",
+          "referrer": "bar",
+          "search": "baz",
+          "title": "qux",
+          "url": "http://fake.com",
+        }
+      `)
+    })
+    it('special page properties in event.properties (url, referrer, etc) are not copied to context.page in non-page calls', async () => {
+      const eventProps = Object.freeze({
+        path: 'foo',
+        referrer: 'bar',
+        search: 'baz',
+        url: 'http://fake.com',
+        foo: 'hello',
+      })
+      const ctx = await ajs.track('My Event', eventProps)
+      expect(ctx.event.properties).toMatchInlineSnapshot(`
+        Object {
+          "foo": "hello",
+          "path": "foo",
+          "referrer": "bar",
+          "search": "baz",
+          "url": "http://fake.com",
+        }
+      `)
+      expect(ctx.event.context!.page).toMatchInlineSnapshot(`
+        Object {
+          "path": "/",
+          "referrer": "",
+          "search": "",
+          "title": "",
+          "url": "http://localhost/",
+        }
+      `)
+    })
+    it('page properties should override defaults in page calls', async () => {
+      const pageProps = Object.freeze({ path: 'override' })
+      const ctx = await ajs.page('My Event', pageProps)
+      const page = ctx.event.context!.page
+      expect(page).toMatchInlineSnapshot(`
+        Object {
+          "path": "override",
+          "referrer": "",
+          "search": "",
+          "title": "",
+          "url": "http://localhost/",
+        }
+      `)
+    })
+    it('undefined / null / empty string properties on event get overridden as usual', async () => {
+      const eventProps = Object.freeze({
+        referrer: '',
+        path: undefined,
+        title: null,
+      })
+      const ctx = await ajs.page('My Event', eventProps)
+      const page = ctx.event.context!.page
+      expect(page).toEqual(
+        expect.objectContaining({ referrer: '', path: undefined, title: null })
+      )
+    })
+  })
+  it('enriches page events with the page context', async () => {
+    const ctx = await ajs.page(
+      'My event',
+      { banana: 'phone' },
+      { page: { url: 'not-localhost' } }
+    )
+    expect(ctx.event.context?.page).toMatchInlineSnapshot(`
+          Object {
+            "path": "/",
+            "referrer": "",
+            "search": "",
+            "title": "",
+            "url": "not-localhost",
+          }
+      `)
+  })
+  it('enriches page events using properties', async () => {
+    const ctx = await ajs.page('My event', { banana: 'phone', referrer: 'foo' })
+    expect(ctx.event.context?.page).toMatchInlineSnapshot(`
+          Object {
+            "path": "/",
+            "referrer": "foo",
+            "search": "",
+            "title": "",
+            "url": "http://localhost/",
+          }
+      `)
+  })
+  it('in page events, event.name overrides event.properties.name', async () => {
+    const ctx = await ajs.page('My Event', undefined, undefined, {
+      name: 'some propery name',
+    })
+    expect(ctx.event.properties!.name).toBe('My Event')
+  })
+  it('in non-page events, event.name does not override event.properties.name', async () => {
+    const ctx = await ajs.track('My Event', {
+      name: 'some propery name',
+    })
+    expect(ctx.event.properties!.name).toBe('some propery name')
+  })
+  it('enriches identify events with the page context', async () => {
+    const ctx = await ajs.identify('Netto', {
+      banana: 'phone',
+    })
+    expect(ctx.event.context?.page).toMatchInlineSnapshot(`
+      Object {
+        "path": "/",
+        "referrer": "",
+        "search": "",
+        "title": "",
+        "url": "http://localhost/",
+      }
+    `)
+  })
+  it('page object is accessible in all plugins', async () => {
+    await ajs.addSourceMiddleware(({ payload, next }) => {
+      expect(payload.obj?.context?.page).toMatchInlineSnapshot(`
+        Object {
+          "path": "/",
+          "referrer": "",
+          "search": "",
+          "title": "",
+          "url": "http://localhost/",
+        }
+      `)
+      next(payload)
+    })
+    await ajs.track('My event', {
+      banana: 'phone',
+    })
+    expect.assertions(1)
+  })
+})

package/packages/browser/src/browser/__tests__/query-string.integration.test.ts ADDED Viewed

@@ -0,0 +1,116 @@
+import { JSDOM } from 'jsdom'
+import { Analytics } from '../../core/analytics'
+// @ts-ignore loadLegacySettings mocked dependency is accused as unused
+import { HtEventsBrowser } from '..'
+import { setGlobalCDNUrl } from '../../lib/parse-cdn'
+import { TEST_WRITEKEY } from '../../test-helpers/test-writekeys'
+const writeKey = TEST_WRITEKEY
+describe('queryString', () => {
+  let jsd: JSDOM
+  beforeEach(async () => {
+    jest.restoreAllMocks()
+    jest.resetAllMocks()
+    const html = `
+    <!DOCTYPE html>
+      <head>
+        <script>'hi'</script>
+      </head>
+      <body>
+      </body>
+    </html>
+    `.trim()
+    jsd = new JSDOM(html, {
+      runScripts: 'dangerously',
+      resources: 'usable',
+      url: 'https://localhost',
+    })
+    const windowSpy = jest.spyOn(global, 'window', 'get')
+    windowSpy.mockImplementation(
+      () => jsd.window as unknown as Window & typeof globalThis
+    )
+    setGlobalCDNUrl(undefined as any)
+  })
+  it('applies query string logic before analytics is finished initializing', async () => {
+    let analyticsInitializedBeforeQs: boolean | undefined
+    const originalQueryString = Analytics.prototype.queryString
+    const mockQueryString = jest
+      .fn()
+      .mockImplementation(async function (this: Analytics, ...args) {
+        // simulate network latency when retrieving the bundle
+        await new Promise((r) => setTimeout(r, 500))
+        return originalQueryString.apply(this, args).then((result) => {
+          // ensure analytics has not finished initializing before querystring completes
+          analyticsInitializedBeforeQs = this.initialized
+          return result
+        })
+      })
+    Analytics.prototype.queryString = mockQueryString
+    jsd.reconfigure({
+      url: 'https://localhost/?ajs_aid=123',
+    })
+    const [analytics] = await HtEventsBrowser.load({ writeKey })
+    expect(mockQueryString).toHaveBeenCalledWith('?ajs_aid=123')
+    expect(analyticsInitializedBeforeQs).toBe(false)
+    // check that calls made immediately after analytics is loaded use correct anonymousId
+    const pageContext = await analytics.page()
+    expect(pageContext.event.anonymousId).toBe('123')
+    expect(analytics.user().anonymousId()).toBe('123')
+  })
+  it('applies query string logic if window.location.search is present', async () => {
+    const mockQueryString = jest
+      .spyOn(Analytics.prototype, 'queryString')
+      .mockImplementation(() => Promise.resolve([]))
+    jsd.reconfigure({
+      url: 'https://localhost/?ajs_id=123',
+    })
+    await HtEventsBrowser.load({ writeKey })
+    expect(mockQueryString).toHaveBeenCalledWith('?ajs_id=123')
+  })
+  it('applies query string logic if window.location.hash is present', async () => {
+    const mockQueryString = jest
+      .spyOn(Analytics.prototype, 'queryString')
+      .mockImplementation(() => Promise.resolve([]))
+    jsd.reconfigure({
+      url: 'https://localhost/#/?ajs_id=123',
+    })
+    await HtEventsBrowser.load({ writeKey })
+    expect(mockQueryString).toHaveBeenCalledWith('?ajs_id=123')
+    jsd.reconfigure({
+      url: 'https://localhost/#about?ajs_id=123',
+    })
+    await HtEventsBrowser.load({ writeKey })
+    expect(mockQueryString).toHaveBeenCalledWith('?ajs_id=123')
+  })
+  it('applies query string logic if window.location.hash is present in different formats', async () => {
+    jest.mock('../../core/analytics')
+    const mockQueryString = jest
+      .fn()
+      .mockImplementation(() => Promise.resolve())
+    Analytics.prototype.queryString = mockQueryString
+    jsd.reconfigure({
+      url: 'https://localhost/#about?ajs_id=123',
+    })
+    await HtEventsBrowser.load({ writeKey })
+    expect(mockQueryString).toHaveBeenCalledWith('?ajs_id=123')
+  })
+})