utneque 1.0.0

package/packages/browser/scripts/release.js

@@ -0,0 +1,121 @@
+#!/usr/bin/env ./node_modules/.bin/ts-node --script-mode --transpile-only --files
+/* eslint-disable no-undef */
+
+const ex = require('execa')
+const S3 = require('aws-sdk/clients/s3')
+const fs = require('fs-extra')
+const path = require('path')
+const mime = require('mime')
+const logUpdate = require('log-update')
+
+const bucket =
+  process.env.NODE_ENV == 'production'
+    ? process.env.PROD_BUCKET
+    : process.env.STAGE_BUCKET
+if (!bucket) throw new Error('Missing one of PROD_BUCKET or STAGE_BUCKET')
+
+const accessKeyId = process.env.AWS_ACCESS_KEY_ID
+if (!accessKeyId) throw new Error('Missing AWS_ACCESS_KEY_ID')
+const secretAccessKey = process.env.AWS_SECRET_ACCESS_KEY
+if (!secretAccessKey) throw new Error('Missing AWS_SECRET_ACCESS_KEY')
+const sessionToken = process.env.AWS_SESSION_TOKEN
+if (!sessionToken) throw new Error('Missing AWS_SESSION_TOKEN')
+
+const pathPrefix = process.env.PATH_PREFIX ?? 'browser/candidate'
+const pathVersion = process.env.PATH_VERSION
+if (!pathVersion) throw new Error('Missing PATH_VERSION')
+
+const getBranch = async () =>
+  (await ex('git', ['branch', '--show-current'])).stdout
+
+const getSha = async () =>
+  (await ex('git', ['rev-parse', '--short', 'HEAD'])).stdout
+
+async function getFiles(dir) {
+  const subdirs = await fs.readdir(dir)
+  const files = await Promise.all(
+    subdirs.map(async (subdir) => {
+      const res = path.resolve(dir, subdir)
+      return (await fs.stat(res)).isDirectory() ? getFiles(res) : [res]
+    })
+  )
+  return files.reduce((a, f) => a.concat(f, [])).map((f) => f.split(dir)[1])
+}
+
+async function upload() {
+  const s3 = new S3({
+    accessKeyId,
+    secretAccessKey,
+    sessionToken,
+    region: 'us-east-1',
+  })
+
+  const files = await getFiles(path.join(process.cwd(), './dist/umd'))
+  const total = files.length
+  let progress = 0
+
+  const uploads = files.map(async (f) => {
+    const filePath = path.join(process.cwd(), './dist/umd', f)
+
+    const options = {
+      Bucket: bucket,
+      Key: path.join(pathPrefix, pathVersion, f),
+      Body: await fs.readFile(filePath),
+      ContentType:
+        mime.getType(filePath.replace('.gz', '')) || 'application/javascript',
+      CacheControl: 'public,max-age=31536000,immutable',
+    }
+
+    if (filePath.includes('.gz')) {
+      options.ContentEncoding = 'gzip'
+    }
+
+    const output = await s3.putObject(options).promise()
+
+    if (pathPrefix === 'browser/release') {
+      // only build "v1-latest" when it's a "release" build
+      // put latest version with only 5 minutes caching
+      const majorVersion = pathVersion.split('.').reverse().pop()
+      await s3
+        .putObject({
+          ...options,
+          CacheControl: 'public,max-age=300,immutable',
+          Key: path.join(pathPrefix, `v${majorVersion}-latest`, f),
+        })
+        .promise()
+    }
+
+    progress++
+    logUpdate(`Progress: ${progress}/${total}`)
+
+    return output
+  })
+
+  await Promise.all(uploads)
+}
+
+async function release() {
+  console.log('Compiling Bundles')
+
+  const sha = await getSha()
+  let branch = process.env.GITHUB_REF_NAME ?? (await getBranch())
+
+  const meta = {
+    sha,
+    branch: `${branch}`,
+  }
+
+  console.table(meta)
+  const envVars = {
+    PATH_VERSION: pathVersion,
+    PATH_PREFIX: pathPrefix,
+  }
+  console.table(envVars)
+  console.log('Uploading Assets')
+  await upload(meta)
+}
+
+release().catch((err) => {
+  console.error(err)
+  process.exit(1)
+})

package/packages/browser/scripts/release.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+
+set -e
+
+function main() {
+    node scripts/release.js
+}
+
+main

package/packages/browser/scripts/run.sh

@@ -0,0 +1,8 @@
+#!/bin/sh
+
+# Allow the service to run without chamber (for ci, docker-compose, etc)
+if [ -z "$NO_CHAMBER" ];then
+  exec chamber exec analytics-next -- node dist/src/boot.js
+else
+  exec node dist/src/boot.js
+fi;

package/packages/browser/src/browser/__tests__/analytics-lazy-init.integration.test.ts

@@ -0,0 +1,51 @@
+import { sleep } from '@ht-sdks/events-sdk-js-core'
+import { getBufferedPageCtxFixture } from '../../test-helpers/fixtures'
+import unfetch from 'unfetch'
+import { HtEventsBrowser } from '..'
+import { Analytics } from '../../core/analytics'
+import { createSuccess } from '../../test-helpers/factories'
+
+jest.mock('unfetch')
+
+const mockFetchSettingsSuccessResponse = () => {
+  return jest
+    .mocked(unfetch)
+    .mockImplementation(() => createSuccess({ integrations: {} }))
+}
+
+describe('Lazy initialization', () => {
+  let trackSpy: jest.SpiedFunction<Analytics['track']>
+  let fetched: jest.MockedFn<typeof unfetch>
+  beforeEach(() => {
+    fetched = mockFetchSettingsSuccessResponse()
+    trackSpy = jest.spyOn(Analytics.prototype, 'track')
+  })
+
+  it('Should be able to delay initialization ', async () => {
+    const analytics = new HtEventsBrowser()
+    const track = analytics.track('foo')
+    await sleep(100)
+    expect(trackSpy).not.toBeCalled()
+    analytics.load({ writeKey: 'abc' })
+    await track
+    expect(trackSpy).toBeCalledWith('foo', getBufferedPageCtxFixture())
+  })
+
+  it('.load method return an analytics instance', async () => {
+    const analytics = new HtEventsBrowser().load({ writeKey: 'foo' })
+    expect(analytics instanceof HtEventsBrowser).toBeTruthy()
+  })
+
+  // Load already defaults to NOT fetching external settings from CDN
+  it.skip('should ignore subsequent .load calls', async () => {
+    const analytics = new HtEventsBrowser()
+    await analytics.load({ writeKey: 'my-write-key' })
+    await analytics.load({ writeKey: 'def' })
+    expect(fetched).toBeCalledTimes(1)
+    expect(fetched).toBeCalledWith(
+      expect.stringContaining(
+        'https://cdn.hightouch-events.com/v1/projects/my-write-key/settings'
+      )
+    )
+  })
+})

package/packages/browser/src/browser/__tests__/analytics-pre-init.integration.test.ts

@@ -0,0 +1,440 @@
+import { HtEventsBrowser } from '../..'
+import unfetch from 'unfetch'
+import { Analytics } from '../../core/analytics'
+import { Context } from '../../core/context'
+import * as Factory from '../../test-helpers/factories'
+import { sleep } from '../../lib/sleep'
+import { setGlobalCDNUrl } from '../../lib/parse-cdn'
+import { User } from '../../core/user'
+import { getBufferedPageCtxFixture } from '../../test-helpers/fixtures'
+
+jest.mock('unfetch')
+
+const mockFetchSettingsSuccessResponse = () => {
+  jest
+    .mocked(unfetch)
+    .mockImplementation(() => Factory.createSuccess({ integrations: {} }))
+}
+
+const mockFetchSettingsErrorResponse = (response?: Partial<Response>) => {
+  jest.mocked(unfetch).mockImplementation(() => Factory.createError(response))
+}
+
+const writeKey = 'foo'
+
+const errMsg = 'errMsg'
+
+jest.spyOn(console, 'error').mockImplementation(() => {}) // silence console spam
+
+describe('Pre-initialization', () => {
+  const trackSpy = jest.spyOn(Analytics.prototype, 'track')
+  const identifySpy = jest.spyOn(Analytics.prototype, 'identify')
+  const onSpy = jest.spyOn(Analytics.prototype, 'on')
+  const getOnSpyCalls = (event: string) =>
+    onSpy.mock.calls.filter(([arg1]) => arg1 === event)
+
+  const readySpy = jest.spyOn(Analytics.prototype, 'ready')
+  const browserLoadSpy = jest.spyOn(HtEventsBrowser, 'load')
+  const consoleErrorSpy = jest.spyOn(console, 'error')
+
+  beforeEach(() => {
+    setGlobalCDNUrl(undefined as any)
+    mockFetchSettingsSuccessResponse()
+    ;(window as any).htevents = undefined
+  })
+
+  describe('Smoke', () => {
+    test('load should instantiate an object that resolves into an Analytics object', async () => {
+      const ajsBrowser = HtEventsBrowser.load({ writeKey })
+      expect(ajsBrowser).toBeInstanceOf<typeof HtEventsBrowser>(HtEventsBrowser)
+      expect(ajsBrowser.instance).toBeUndefined()
+      const [ajs, ctx] = await ajsBrowser
+      expect(ajsBrowser.instance).toBeInstanceOf<typeof Analytics>(Analytics)
+      expect(ajsBrowser.ctx).toBeInstanceOf<typeof Context>(Context)
+      expect(ajs).toBeInstanceOf<typeof Analytics>(Analytics)
+      expect(ctx).toBeInstanceOf<typeof Context>(Context)
+    })
+
+    test('If a user sends a single pre-initialized track event, that event gets flushed', async () => {
+      const ajsBrowser = HtEventsBrowser.load({ writeKey })
+      const trackCtxPromise = ajsBrowser.track('foo', { name: 'john' })
+      const result = await trackCtxPromise
+      expect(result).toBeInstanceOf(Context)
+      expect(trackSpy).toBeCalledWith(
+        'foo',
+        { name: 'john' },
+        getBufferedPageCtxFixture()
+      )
+      expect(trackSpy).toBeCalledTimes(1)
+    })
+
+    test('"return types should not change over the lifecycle for async methods', async () => {
+      const ajsBrowser = HtEventsBrowser.load({ writeKey })
+
+      const trackCtxPromise1 = ajsBrowser.track('foo', { name: 'john' })
+      expect(trackCtxPromise1).toBeInstanceOf(Promise)
+      await ajsBrowser
+
+      // loaded
+      const trackCtxPromise2 = ajsBrowser.track('foo', { name: 'john' })
+      expect(trackCtxPromise2).toBeInstanceOf(Promise)
+
+      expect(await trackCtxPromise1).toBeInstanceOf(Context)
+      expect(await trackCtxPromise2).toBeInstanceOf(Context)
+    })
+
+    test('return types should not change over lifecycle for sync methods', async () => {
+      const ajsBrowser = HtEventsBrowser.load({ writeKey })
+      const user = ajsBrowser.user()
+      expect(user).toBeInstanceOf(Promise)
+      await ajsBrowser
+
+      // loaded
+      const user2 = ajsBrowser.user()
+      expect(user2).toBeInstanceOf(Promise)
+
+      expect(await user).toBeInstanceOf(User)
+      expect(await user2).toBeInstanceOf(User)
+    })
+
+    test('version should return version', async () => {
+      const ajsBrowser = HtEventsBrowser.load({ writeKey })
+      expect(typeof ajsBrowser.VERSION).toBe('string')
+    })
+
+    test('If a user sends multiple events, all of those event gets flushed', async () => {
+      const ajsBrowser = HtEventsBrowser.load({ writeKey })
+      const trackCtxPromise = ajsBrowser.track('foo', { name: 'john' })
+      const trackCtxPromise2 = ajsBrowser.track('bar', { age: 123 })
+      const identifyCtxPromise = ajsBrowser.identify('hello')
+
+      await Promise.all([trackCtxPromise, trackCtxPromise2, identifyCtxPromise])
+
+      expect(trackSpy).toBeCalledWith(
+        'foo',
+        { name: 'john' },
+        getBufferedPageCtxFixture()
+      )
+      expect(trackSpy).toBeCalledWith(
+        'bar',
+        { age: 123 },
+        getBufferedPageCtxFixture()
+      )
+      expect(trackSpy).toBeCalledTimes(2)
+
+      expect(identifySpy).toBeCalledWith('hello', getBufferedPageCtxFixture())
+      expect(identifySpy).toBeCalledTimes(1)
+    })
+
+    // by default, we do not fetch settings from cdn
+    test.skip('should not throw on initialization failures', async () => {
+      mockFetchSettingsErrorResponse()
+      const ajs = HtEventsBrowser.load({ writeKey })
+      await sleep(100)
+      expect(ajs.instance).toBeUndefined()
+      void ajs.track('foo')
+    })
+
+    // by default, we do not fetch settings from cdn
+    test.skip('should log errors if network error', async () => {
+      const err = {
+        status: 403,
+        statusText: 'Forbidden',
+        json: undefined,
+      }
+      mockFetchSettingsErrorResponse(err)
+      const consoleSpy = jest
+        .spyOn(console, 'error')
+        .mockImplementationOnce(() => {})
+      HtEventsBrowser.load({ writeKey: 'abc' })
+      await sleep(500)
+      expect(consoleSpy).toBeCalled()
+    })
+  })
+
+  describe('Promise API', () => {
+    describe('.then', () => {
+      test('.then should be called on success', () => {
+        const ajsBrowser = HtEventsBrowser.load({ writeKey: 'abc' })
+        const newPromise = ajsBrowser.then(([analytics, context]) => {
+          expect(analytics).toBeInstanceOf<typeof Analytics>(Analytics)
+          expect(context).toBeInstanceOf<typeof Context>(Context)
+        })
+        expect(newPromise).toBeInstanceOf<typeof Promise>(Promise)
+        return newPromise
+      })
+
+      it('.then should pass to the next .then', async () => {
+        const ajsBrowser = HtEventsBrowser.load({ writeKey: 'abc' })
+        const obj = ajsBrowser.then(() => ({ foo: 123 } as const))
+        expect(obj).toBeInstanceOf(Promise)
+        await obj.then((el) => expect(el.foo).toBe(123))
+      })
+    })
+
+    describe('.catch', () => {
+      it('should be capable of handling errors if using promise syntax', async () => {
+        browserLoadSpy.mockImplementationOnce((): any => Promise.reject(errMsg))
+
+        await expect(() =>
+          HtEventsBrowser.load({ writeKey: 'abc' })
+        ).rejects.toEqual(errMsg)
+      })
+    })
+
+    describe('.finally', () => {
+      test('success', async () => {
+        const ajsBrowser = HtEventsBrowser.load({ writeKey: 'abc' })
+        const thenCb = jest.fn()
+        const finallyCb = jest.fn()
+        const catchCb = jest.fn()
+        await ajsBrowser.then(thenCb).catch(catchCb).finally(finallyCb)
+        expect(catchCb).not.toBeCalled()
+        expect(finallyCb).toBeCalledTimes(1)
+        expect(thenCb).toBeCalledTimes(1)
+      })
+      test('rejection', async () => {
+        browserLoadSpy.mockImplementationOnce((): any => Promise.reject(errMsg))
+        const ajsBrowser = HtEventsBrowser.load({ writeKey: 'abc' })
+        const onFinallyCb = jest.fn()
+        await ajsBrowser
+          .catch((reason) => {
+            expect(reason).toBe(errMsg)
+          })
+          .finally(() => {
+            onFinallyCb()
+          })
+        expect(onFinallyCb).toBeCalledTimes(1)
+        expect.assertions(2)
+      })
+    })
+  })
+
+  describe('Load failures', () => {
+    test('rejected promise should work as expected for buffered analytics instances', async () => {
+      trackSpy.mockImplementationOnce(() => Promise.reject(errMsg))
+      const ajsBrowser = HtEventsBrowser.load({ writeKey })
+      try {
+        await ajsBrowser.track('foo', { name: 'john' })
+      } catch (err) {
+        expect(err).toBe(errMsg)
+      }
+      expect.assertions(1)
+    })
+
+    test('rejected promise should work as expected for initialized analytics instances', async () => {
+      trackSpy.mockImplementationOnce(() => Promise.reject(errMsg))
+      const [analytics] = await HtEventsBrowser.load({ writeKey })
+      try {
+        await analytics.track('foo', { name: 'john' })
+      } catch (err) {
+        expect(err).toBe(errMsg)
+      }
+      expect.assertions(1)
+    })
+  })
+
+  describe('Snippet / standalone', () => {
+    test('If a snippet user sends multiple events, all of those event gets flushed', async () => {
+      const onTrackCb = jest.fn()
+      const onTrack = ['on', 'track', onTrackCb]
+      const track = ['track', 'foo']
+      const track2 = ['track', 'bar']
+      const identify = ['identify']
+
+      ;(window as any).htevents = [onTrack, track, track2, identify]
+
+      await HtEventsBrowser.standalone(writeKey)
+
+      await sleep(100) // the snippet does not return a promise (pre-initialization) ... it sometimes has a callback as the third argument.
+      expect(trackSpy).toBeCalledWith('foo', getBufferedPageCtxFixture())
+      expect(trackSpy).toBeCalledWith('bar', getBufferedPageCtxFixture())
+      expect(trackSpy).toBeCalledTimes(2)
+
+      expect(identifySpy).toBeCalledTimes(1)
+
+      expect(getOnSpyCalls('track').length).toBe(1)
+      expect(onTrackCb).toBeCalledTimes(2) // gets called once for each track event
+      expect(onTrackCb).toBeCalledWith('foo', {}, undefined)
+      expect(onTrackCb).toBeCalledWith('bar', {}, undefined)
+    })
+    test('If a snippet user has an event "fail", it will not create a promise rejection or effect other method calls', async () => {
+      identifySpy.mockImplementationOnce(() => {
+        return Promise.reject('identity rejection')
+      })
+      consoleErrorSpy.mockImplementationOnce(() => null)
+
+      const onTrackCb = jest.fn()
+      const onTrack = ['on', 'track', onTrackCb]
+      const track = ['track', 'foo']
+      const track2 = ['track', 'bar']
+      const identify = ['identify']
+
+      ;(window as any).htevents = [identify, onTrack, track, track2]
+
+      await HtEventsBrowser.standalone(writeKey)
+
+      await sleep(100) // the snippet does not return a promise (pre-initialization) ... it sometimes has a callback as the third argument.
+      expect(trackSpy).toBeCalledWith('foo', getBufferedPageCtxFixture())
+      expect(trackSpy).toBeCalledWith('bar', getBufferedPageCtxFixture())
+      expect(trackSpy).toBeCalledTimes(2)
+
+      expect(identifySpy).toBeCalledWith(getBufferedPageCtxFixture())
+      expect(identifySpy).toBeCalledTimes(1)
+      expect(consoleErrorSpy).toBeCalledTimes(1)
+
+      expect(consoleErrorSpy).toBeCalledWith('identity rejection')
+
+      expect(getOnSpyCalls('track').length).toBe(1)
+
+      expect(onTrackCb).toBeCalledTimes(2) // gets called once for each track event
+      expect(onTrackCb).toBeCalledWith('foo', {}, undefined)
+      expect(onTrackCb).toBeCalledWith('bar', {}, undefined)
+    })
+    test('events can be buffered under a custom window key', async () => {
+      const onTrackCb = jest.fn()
+      const onTrack = ['on', 'track', onTrackCb]
+      const track = ['track', 'foo']
+      const track2 = ['track', 'bar']
+      const identify = ['identify']
+
+      ;(window as any).hightouch = [onTrack, track, track2, identify]
+
+      await HtEventsBrowser.standalone(writeKey, {
+        globalAnalyticsKey: 'hightouch',
+      })
+
+      await sleep(100) // the snippet does not return a promise (pre-initialization) ... it sometimes has a callback as the third argument.
+      expect(trackSpy).toBeCalledWith('foo', getBufferedPageCtxFixture())
+      expect(trackSpy).toBeCalledWith('bar', getBufferedPageCtxFixture())
+      expect(trackSpy).toBeCalledTimes(2)
+
+      expect(identifySpy).toBeCalledTimes(1)
+
+      expect(getOnSpyCalls('track').length).toBe(1)
+      expect(onTrackCb).toBeCalledTimes(2) // gets called once for each track event
+      expect(onTrackCb).toBeCalledWith('foo', {}, undefined)
+      expect(onTrackCb).toBeCalledWith('bar', {}, undefined)
+    })
+  })
+
+  describe('Emitter methods', () => {
+    test('If, before initialization, .on("track") is called, the .on method should be called after analytics load', async () => {
+      const ajsBrowser = HtEventsBrowser.load({ writeKey })
+      const args = ['track', jest.fn()] as const
+      ajsBrowser.on(...args)
+      expect(onSpy).not.toHaveBeenCalledWith(...args)
+
+      await ajsBrowser
+      expect(onSpy).toBeCalledWith(...args)
+      expect(getOnSpyCalls('track').length).toBe(1)
+    })
+
+    test('If, before initialization .on("track") is called and then .track is called, the callback method should be called after analytics loads', async () => {
+      const onFnCb = jest.fn()
+      const analytics = HtEventsBrowser.load({ writeKey })
+      analytics.on('track', onFnCb)
+      const trackCtxPromise = analytics.track('foo', { name: 123 })
+
+      expect(onFnCb).not.toHaveBeenCalled()
+
+      await Promise.all([analytics, trackCtxPromise])
+
+      expect(onSpy).toBeCalledWith('track', onFnCb)
+      expect(getOnSpyCalls('track').length).toBe(1)
+
+      expect(onFnCb).toHaveBeenCalledWith('foo', { name: 123 }, undefined)
+      expect(onFnCb).toBeCalledTimes(1)
+    })
+
+    test('If, before initialization, .ready is called, the callback method should be called after analytics loads', async () => {
+      const onReadyCb = jest.fn()
+      const analytics = HtEventsBrowser.load({ writeKey })
+      const onReadyPromise = analytics.ready(onReadyCb)
+      expect(onReadyCb).not.toHaveBeenCalled()
+      await onReadyPromise
+      expect(readySpy).toHaveBeenCalledTimes(1)
+      expect(onReadyCb).toHaveBeenCalledTimes(1)
+      expect(readySpy).toHaveBeenCalledWith(expect.any(Function))
+    })
+
+    test('Should work with "on" events if a track event is called after load is complete', async () => {
+      const onTrackCb = jest.fn()
+      const ajsBrowser = HtEventsBrowser.load({ writeKey })
+      ajsBrowser.on('track', onTrackCb)
+      await ajsBrowser
+      await ajsBrowser.track('foo', { name: 123 })
+
+      expect(onTrackCb).toHaveBeenCalledTimes(1)
+      expect(onTrackCb).toHaveBeenCalledWith('foo', { name: 123 }, undefined)
+    })
+    test('"on, off, once" should return ajsBrowser', () => {
+      const analytics = HtEventsBrowser.load({ writeKey })
+      expect(
+        [
+          analytics.on('track', jest.fn),
+          analytics.off('track', jest.fn),
+          analytics.once('track', jest.fn),
+        ].map((el) => el instanceof HtEventsBrowser)
+      ).toEqual([true, true, true])
+    })
+
+    test('"emitted" events should be chainable', async () => {
+      const onTrackCb = jest.fn()
+      const onIdentifyCb = jest.fn()
+      const ajsBrowser = HtEventsBrowser.load({ writeKey })
+      const identifyResult = ajsBrowser.identify('bar')
+      const result = ajsBrowser
+        .on('track', onTrackCb)
+        .on('identify', onIdentifyCb)
+        .once('group', jest.fn)
+        .off('alias', jest.fn)
+
+      expect(result instanceof HtEventsBrowser).toBeTruthy()
+      await ajsBrowser.track('foo', { name: 123 })
+      expect(onTrackCb).toHaveBeenCalledTimes(1)
+      expect(onTrackCb).toHaveBeenCalledWith('foo', { name: 123 }, undefined)
+
+      await identifyResult
+      expect(onIdentifyCb).toHaveBeenCalledTimes(1)
+      expect(onIdentifyCb).toHaveBeenCalledWith('bar', {}, undefined)
+    })
+
+    test('the "this" value of "emitted" event callbacks should be Analytics', async () => {
+      const ajsBrowser = HtEventsBrowser.load({ writeKey })
+      ajsBrowser.on('track', function onTrackCb(this: any) {
+        expect(this).toBeInstanceOf(Analytics)
+      })
+      ajsBrowser.once('group', function trackOnceCb(this: any) {
+        expect(this).toBeInstanceOf(Analytics)
+      })
+
+      await Promise.all([
+        ajsBrowser.track('foo', { name: 123 }),
+        ajsBrowser.group('foo'),
+      ])
+    })
+
+    test('"return types should not change over the lifecycle for chainable methods', async () => {
+      const ajsBrowser = HtEventsBrowser.load({ writeKey })
+
+      const result1 = ajsBrowser.on('track', jest.fn)
+      expect(result1).toBeInstanceOf(HtEventsBrowser)
+      await result1
+      // loaded
+      const result2 = ajsBrowser.on('track', jest.fn)
+      expect(result2).toBeInstanceOf(HtEventsBrowser)
+    })
+  })
+
+  describe('Multi-instance', () => {
+    it('should not throw an error', async () => {
+      const ajsBrowser1 = HtEventsBrowser.load({ writeKey: 'foo' })
+      const ajsBrowser2 = HtEventsBrowser.load({ writeKey: 'abc' })
+      expect(ajsBrowser1).toBeInstanceOf(HtEventsBrowser)
+      expect(ajsBrowser2).toBeInstanceOf(HtEventsBrowser)
+      await ajsBrowser1
+      await ajsBrowser2
+    })
+  })
+})