@newrelic/browser-agent 0.1.231 → 1.232.1

package/src/common/session/session-entity.test.js

@@ -0,0 +1,317 @@
+
+import { LocalMemory } from '../storage/local-memory'
+import { LocalStorage } from '../storage/local-storage'
+
+import { PREFIX } from './constants'
+import { SessionEntity } from './session-entity'
+
+const agentIdentifier = 'test_agent_identifier'
+const key = 'test_key'
+const value = 'test_value'
+
+jest.mock('../timer/timer')
+jest.mock('../timer/interaction-timer')
+jest.useFakeTimers()
+
+const mockBrowserScope = jest.fn().mockImplementation(() => true)
+jest.mock('../util/global-scope', () => ({
+  __esModule: true,
+  get isBrowserScope () {
+    return mockBrowserScope()
+  },
+  get globalScope () {
+    return global.window
+  }
+}))
+
+beforeEach(() => {
+  jest.restoreAllMocks()
+  mockBrowserScope.mockReturnValue(true)
+})
+
+describe('constructor', () => {
+  test('must use required fields', () => {
+    try {
+      expect(new SessionEntity({})).toThrow(new Error('Missing Required Fields'))
+    } catch (err) {}
+  })
+
+  test('top-level properties are set and exposed', () => {
+    const session = new SessionEntity({ agentIdentifier, key })
+    expect(session).toMatchObject({
+      agentIdentifier: expect.any(String),
+      key: expect.any(String),
+      value: expect.any(String),
+      expiresMs: expect.any(Number),
+      expiresAt: expect.any(Number),
+      expiresTimer: expect.any(Object),
+      inactiveMs: expect.any(Number),
+      inactiveAt: expect.any(Number),
+      inactiveTimer: expect.any(Object),
+      isNew: expect.any(Boolean),
+      sessionReplayActive: expect.any(Boolean),
+      sessionTraceActive: expect.any(Boolean),
+      storage: expect.any(Object)
+    })
+  })
+
+  test('can use sane defaults', () => {
+    const session = new SessionEntity({ agentIdentifier, key })
+    expect(session).toEqual(expect.objectContaining({
+      value: expect.any(String),
+      expiresAt: expect.any(Number),
+      inactiveAt: expect.any(Number),
+      sessionReplayActive: expect.any(Boolean),
+      sessionTraceActive: expect.any(Boolean)
+    }))
+  })
+
+  test('Workers are forced to use local memory', () => {
+    mockBrowserScope.mockReturnValueOnce(false)
+    const session = new SessionEntity({ agentIdentifier, key, storageAPI: new LocalStorage() })
+    expect(session.storage instanceof LocalMemory).toEqual(true)
+  })
+
+  test('expiresAt is the correct future timestamp - new session', () => {
+    const now = Date.now()
+    jest.setSystemTime(now)
+    const session = new SessionEntity({ agentIdentifier, key, expiresMs: 100 })
+    expect(session.expiresAt).toEqual(now + 100)
+  })
+
+  test('expiresAt is the correct future timestamp - existing session', () => {
+    const now = Date.now()
+    jest.setSystemTime(now)
+    const existingData = new LocalMemory({ [`${PREFIX}_${key}`]: { value, expiresAt: now + 5000, inactiveAt: Infinity } })
+    const session = new SessionEntity({ agentIdentifier, key, expiresMs: 100, storageAPI: existingData })
+    expect(session.expiresAt).toEqual(now + 5000)
+  })
+
+  test('expiresAt never expires if 0', () => {
+    const session = new SessionEntity({ agentIdentifier, key, expiresMs: 0 })
+    expect(session.expiresAt).toEqual(Infinity)
+  })
+
+  test('inactiveAt is the correct future timestamp - new session', () => {
+    const now = Date.now()
+    jest.setSystemTime(now)
+    const session = new SessionEntity({ agentIdentifier, key, inactiveMs: 100 })
+    expect(session.inactiveAt).toEqual(now + 100)
+  })
+
+  test('inactiveAt is the correct future timestamp - existing session', () => {
+    const now = Date.now()
+    jest.setSystemTime(now)
+    const existingData = new LocalMemory({ [`${PREFIX}_${key}`]: { value, inactiveAt: now + 5000, expiresAt: Infinity } })
+    const session = new SessionEntity({ agentIdentifier, key, inactiveMs: 100, storageAPI: existingData })
+    expect(session.inactiveAt).toEqual(now + 5000)
+  })
+
+  test('inactiveAt never expires if 0', () => {
+    const session = new SessionEntity({ agentIdentifier, key, inactiveMs: 0 })
+    expect(session.inactiveAt).toEqual(Infinity)
+  })
+
+  test('should handle isNew', () => {
+    const newSession = new SessionEntity({ agentIdentifier, key, expiresMs: 10 })
+    expect(newSession.isNew).toBeTruthy()
+
+    const storageAPI = new LocalMemory({ [`${PREFIX}_${key}`]: { value, expiresAt: Infinity, inactiveAt: Infinity } })
+    const existingSession = new SessionEntity({ agentIdentifier, key, expiresMs: 10, storageAPI })
+    expect(existingSession.isNew).toBeFalsy()
+  })
+
+  test('invalid stored values sets new defaults', () => {
+    // missing required fields
+    const storageAPI = new LocalMemory({ [`${PREFIX}_${key}`]: { invalid_fields: true } })
+    const session = new SessionEntity({ agentIdentifier, key, storageAPI })
+    expect(session).toEqual(expect.objectContaining({
+      value: expect.any(String),
+      expiresAt: expect.any(Number),
+      inactiveAt: expect.any(Number),
+      sessionReplayActive: expect.any(Boolean),
+      sessionTraceActive: expect.any(Boolean)
+    }))
+  })
+
+  test('expired expiresAt value in storage sets new defaults', () => {
+    const now = Date.now()
+    jest.setSystemTime(now)
+    const storageAPI = new LocalMemory({ [`${PREFIX}_${key}`]: { value, expiresAt: now - 100, inactiveAt: Infinity } })
+    const session = new SessionEntity({ agentIdentifier, key, storageAPI })
+    expect(session).toEqual(expect.objectContaining({
+      value: expect.any(String),
+      expiresAt: expect.any(Number),
+      inactiveAt: expect.any(Number),
+      sessionReplayActive: expect.any(Boolean),
+      sessionTraceActive: expect.any(Boolean)
+    }))
+  })
+
+  test('expired inactiveAt value in storage sets new defaults', () => {
+    const now = Date.now()
+    jest.setSystemTime(now)
+    const storageAPI = new LocalMemory({ [`${PREFIX}_${key}`]: { value, inactiveAt: now - 100, expiresAt: Infinity } })
+    const session = new SessionEntity({ agentIdentifier, key, storageAPI })
+    expect(session).toEqual(expect.objectContaining({
+      value: expect.any(String),
+      expiresAt: expect.any(Number),
+      inactiveAt: expect.any(Number),
+      sessionReplayActive: expect.any(Boolean),
+      sessionTraceActive: expect.any(Boolean)
+    }))
+  })
+})
+
+describe('reset()', () => {
+  test('should create new default values when resetting', () => {
+    const now = Date.now()
+    jest.setSystemTime(now)
+    const session = new SessionEntity({ agentIdentifier, key, expiresMs: 10 })
+    const sessionVal = session.value
+    expect(session.value).toBeTruthy()
+    session.reset()
+    expect(session.value).toBeTruthy()
+    expect(session.value).not.toEqual(sessionVal)
+  })
+
+  test('custom data should be wiped on reset', () => {
+    const now = Date.now()
+    jest.setSystemTime(now)
+    const session = new SessionEntity({ agentIdentifier, key, expiresMs: 10 })
+    session.syncCustomAttribute('test', 123)
+    expect(session.custom.test).toEqual(123)
+    expect(session.read().custom.test).toEqual(123)
+
+    // simulate a timer expiring
+    session.reset()
+    expect(session.custom?.test).toEqual(undefined)
+    expect(session.read()?.custom?.test).toEqual(undefined)
+  })
+})
+
+describe('read()', () => {
+  test('"new" sessions get data from read()', () => {
+    const newSession = new SessionEntity({ agentIdentifier, key, expiresMs: 10 })
+    expect(newSession.isNew).toBeTruthy()
+
+    expect(newSession.read()).toEqual(expect.objectContaining({
+      value: expect.any(String),
+      expiresAt: expect.any(Number),
+      inactiveAt: expect.any(Number),
+      sessionReplayActive: expect.any(Boolean),
+      sessionTraceActive: expect.any(Boolean)
+    }))
+  })
+
+  test('"pre-existing" sessions get data from read()', () => {
+    const storageAPI = new LocalMemory({ [`${PREFIX}_${key}`]: { value, expiresAt: Infinity, inactiveAt: Infinity } })
+    const session = new SessionEntity({ agentIdentifier, key, storageAPI })
+    expect(session.isNew).toBeFalsy()
+    expect(session.read()).toEqual(expect.objectContaining({
+      value,
+      expiresAt: Infinity,
+      inactiveAt: Infinity
+    }))
+  })
+})
+
+describe('write()', () => {
+  test('write() sets data to top-level wrapper', () => {
+    const session = new SessionEntity({ agentIdentifier, key })
+    expect(session.value).not.toEqual(value)
+    expect(session.expiresAt).not.toEqual(Infinity)
+    expect(session.inactiveAt).not.toEqual(Infinity)
+    session.write({ value, expiresAt: Infinity, inactiveAt: Infinity })
+    expect(session.value).toEqual(value)
+    expect(session.expiresAt).toEqual(Infinity)
+    expect(session.inactiveAt).toEqual(Infinity)
+  })
+
+  test('write() sets data that read() can access', () => {
+    const now = Date.now()
+    jest.setSystemTime(now)
+    const session = new SessionEntity({ agentIdentifier, key })
+    session.write({ value, expiresAt: now + 100, inactiveAt: now + 100 })
+    const read = session.read()
+    expect(read.value).toEqual(value)
+    expect(read.expiresAt).toEqual(now + 100)
+    expect(read.inactiveAt).toEqual(now + 100)
+  })
+
+  test('write() does not run with invalid data', () => {
+    const session = new SessionEntity({ agentIdentifier, key })
+    let out = session.write()
+    expect(out).toEqual(undefined)
+    out = session.write('string')
+    expect(out).toEqual(undefined)
+    out = session.write(123)
+    expect(out).toEqual(undefined)
+    out = session.write(true)
+    expect(out).toEqual(undefined)
+    out = session.write(false)
+    expect(out).toEqual(undefined)
+  })
+})
+
+describe('refresh()', () => {
+  test('refresh sets inactiveAt to future time', () => {
+    const now = Date.now()
+    jest.setSystemTime(now)
+    const session = new SessionEntity({ agentIdentifier, key, inactiveMs: 100 })
+    expect(session.inactiveAt).toEqual(now + 100)
+    jest.setSystemTime(now + 1000)
+    session.refresh()
+    expect(session.inactiveAt).toEqual(now + 100 + 1000)
+  })
+
+  test('refresh resets the entity if expiresTimer is invalid', () => {
+    const now = Date.now()
+    jest.setSystemTime(now)
+    const session = new SessionEntity({ agentIdentifier, key, value })
+    expect(session.value).toEqual(value)
+    session.write({ ...session.read(), expiresAt: now - 1 })
+    session.refresh()
+    expect(session.value).not.toEqual(value)
+  })
+
+  test('refresh resets the entity if inactiveTimer is invalid', () => {
+    const now = Date.now()
+    jest.setSystemTime(now)
+    const session = new SessionEntity({ agentIdentifier, key, value })
+    expect(session.value).toEqual(value)
+    session.write({ ...session.read(), inactiveAt: now - 1 })
+    session.refresh()
+    expect(session.value).not.toEqual(value)
+  })
+})
+
+describe('syncCustomAttribute()', () => {
+  test('Custom data can be managed by session entity', () => {
+    const session = new SessionEntity({ agentIdentifier, key })
+
+    // if custom has never been set, and a "delete" action is triggered, do nothing
+    session.syncCustomAttribute('test', null)
+    expect(session?.custom?.test).toEqual(undefined)
+
+    session.syncCustomAttribute('test', 1)
+    expect(session?.custom?.test).toEqual(1)
+
+    session.syncCustomAttribute('test', 'string')
+    expect(session?.custom?.test).toEqual('string')
+
+    session.syncCustomAttribute('test', false)
+    expect(session?.custom?.test).toEqual(false)
+
+    // null specifically deletes the object completely
+    session.syncCustomAttribute('test', null)
+    expect(session?.custom?.test).toEqual(undefined)
+  })
+
+  test('Only runs in browser scope', () => {
+    mockBrowserScope.mockReturnValue(false)
+    const session = new SessionEntity({ agentIdentifier, key })
+    session.syncCustomAttribute('test', 1)
+    expect(session.read().custom?.test).toEqual(undefined)
+  })
+})

package/src/common/storage/first-party-cookies.js

@@ -0,0 +1,31 @@
+export class FirstPartyCookies {
+  constructor (domain) {
+    this.domain = domain
+  }
+
+  get (name) {
+    try {
+      var match = document.cookie.match(new RegExp('(^| )' + name + '=([^;]+)'))
+      if (match) return match[2]
+    } catch (err) {
+      return ''
+    }
+  }
+
+  set (key, value) {
+    try {
+      const cookie = `${key}=${value}; Domain=${domain}; Path=/`
+      document.cookie = cookie
+    } catch (err) {
+      return
+    }
+  }
+
+  remove (key) {
+    try {
+      return document.cookie = `${key}=; expires=Thu, 01 Jan 1970 00:00:00 UTC; Domain=${domain}; Path=/`
+    } catch (err) {
+      return
+    }
+  }
+}

package/src/common/storage/local-memory.js

@@ -0,0 +1,30 @@
+export class LocalMemory {
+  constructor (initialState = {}) {
+    this.state = initialState
+  }
+
+  get (key) {
+    try {
+      return this.state[key]
+    } catch (err) {
+      return ''
+    }
+  }
+
+  set (key, value) {
+    try {
+      if (value === undefined || value === null) return this.remove(key)
+      this.state[key] = value
+    } catch (err) {
+      return
+    }
+  }
+
+  remove (key) {
+    try {
+      delete this.state[key]
+    } catch (err) {
+      return
+    }
+  }
+}

package/src/common/storage/local-memory.test.js

@@ -0,0 +1,19 @@
+import { LocalMemory } from './local-memory'
+
+test('Local-memory', () => {
+  const LM = new LocalMemory({ test: 1 })
+  expect(LM.state).toEqual({ test: 1 })
+  expect(LM.get('test')).toEqual(1)
+
+  LM.set('test', 2)
+  expect(LM.get('test')).toEqual(2)
+
+  LM.set('test')
+  expect(LM.get('test')).toEqual(undefined)
+
+  LM.set('test', 2)
+  expect(LM.get('test')).toEqual(2)
+
+  LM.remove('test')
+  expect(LM.get('test')).toEqual(undefined)
+})

package/src/common/storage/local-storage.js

@@ -0,0 +1,28 @@
+export class LocalStorage {
+  get (key) {
+    try {
+      // localStorage strangely type-casts non-existing data to "null"...
+      // Cast it back to undefined if it doesnt exist
+      return localStorage.getItem(key) || undefined
+    } catch (err) {
+      return ''
+    }
+  }
+
+  set (key, value) {
+    try {
+      if (value === undefined || value === null) return this.remove(key)
+      return localStorage.setItem(key, value)
+    } catch (err) {
+      return
+    }
+  }
+
+  remove (key) {
+    try {
+      localStorage.removeItem(key)
+    } catch (err) {
+      return
+    }
+  }
+}

package/src/common/storage/local-storage.test.js

@@ -0,0 +1,17 @@
+import { LocalStorage } from './local-storage'
+
+test('Local-memory', () => {
+  const LS = new LocalStorage()
+
+  LS.set('test', 1)
+  expect(LS.get('test')).toEqual('1')
+
+  LS.set('test')
+  expect(LS.get('test')).toEqual(undefined)
+
+  LS.set('test', 2)
+  expect(LS.get('test')).toEqual('2')
+
+  LS.remove('test')
+  expect(LS.get('test')).toEqual(undefined)
+})

package/src/common/timer/interaction-timer.js

@@ -0,0 +1,75 @@
+import { Timer } from './timer'
+import { subscribeToVisibilityChange } from '../window/page-visibility'
+import { debounce } from '../util/invoke'
+import { isBrowserScope } from '../util/global-scope'
+
+export class InteractionTimer extends Timer {
+  constructor (opts, ms) {
+    super(opts, ms)
+    this.onRefresh = opts.onRefresh
+    this.onPause = opts.onPause
+
+    // used by pause/resume
+    this.remainingMs = undefined
+
+    if (!opts.refreshEvents) opts.refreshEvents = ['click', 'keydown', 'scroll']
+
+    // the abort controller is used to "reset" the event listeners and prevent them from duplicating when new sessions are created
+    try {
+      this.abortController = new AbortController()
+    } catch (e) {
+      // this try-catch can be removed when IE11 is completely unsupported & gone
+    }
+
+    if (isBrowserScope && opts.ee) {
+      if (opts.ee) {
+        const debouncedRefresh = debounce(this.refresh.bind(this), 500, { leading: true })
+        opts.ee.on('fn-end', (evts) => {
+          if (opts.refreshEvents.includes(evts?.[0]?.type)) {
+            debouncedRefresh()
+          }
+        })
+      }
+
+      // watch for the vis state changing.  If the page is hidden, the local inactivity timer should be paused
+      // if the page is brought BACK to visibility and the timer hasnt "naturally" expired, refresh the timer...
+      // this is to support the concept that other tabs could be experiencing activity.  The thought would be that
+      // "backgrounded" tabs would pause, while "closed" tabs that "reopen" will just instantiate a new SessionEntity class if restored
+      // which will do a "hard" check of the timestamps.
+
+      // NOTE -- this does not account for 2 browser windows open side by side, blurring/focusing between them
+      // IF DEEMED necessary, more event handling would be needed to account for this.
+      subscribeToVisibilityChange((state) => {
+        if (state === 'hidden') this.pause()
+        // vis change --> visible is treated like a new interaction with the page
+        else this.refresh()
+      }, false, false, this.abortController?.signal)
+    }
+  }
+
+  abort () {
+    this.clear()
+    this.abortController?.abort()
+  }
+
+  pause () {
+    this.onPause?.()
+    clearTimeout(this.timer)
+    this.remainingMs = this.initialMs - (Date.now() - this.startTimestamp)
+  }
+
+  refresh (cb, ms) {
+    this.clear()
+    this.timer = this.create(cb, ms)
+    this.startTimestamp = Date.now()
+    this.remainingMs = undefined
+    this.onRefresh?.()
+  }
+
+  // NOT CURRENTLY UTILIZED BY ANYTHING
+  // resume () {
+  //   if (!this.remainingMs || !this.isValid()) return
+  //   this.timer = this.create(this.cb, this.remainingMs)
+  //   this.remainingMs = undefined
+  // }
+}

package/src/common/timer/interaction-timer.test.js

@@ -0,0 +1,167 @@
+import { InteractionTimer } from './interaction-timer'
+
+jest.useFakeTimers()
+
+let now
+
+beforeEach(() => {
+  now = Date.now()
+  jest.setSystemTime(now)
+})
+
+afterEach(() => {
+  jest.clearAllMocks()
+})
+
+describe('constructor', () => {
+  test('appropriate properties are set with valid values -- no refresh', () => {
+    const timer = new InteractionTimer({ onEnd: jest.fn() }, 100)
+    const requiredKeys = ['onEnd', 'initialMs', 'startTimestamp', 'timer']
+    expect(requiredKeys.every(rk => !!timer[rk])).toBeTruthy()
+  })
+
+  test('appropriate properties are set with valid values -- with refresh', () => {
+    const timer = new InteractionTimer({ onEnd: jest.fn() }, 100)
+    const requiredKeys = ['onEnd', 'refresh', 'initialMs', 'startTimestamp', 'timer']
+    expect(requiredKeys.every(rk => !!timer[rk])).toBeTruthy()
+  })
+
+  test('required keys are enforced', () => {
+    try {
+      new InteractionTimer({}, 100)
+    } catch (e) {
+      expect(e).toEqual(new Error('onEnd handler is required'))
+    }
+
+    try {
+      new InteractionTimer({ onEnd: jest.fn() })
+    } catch (e) {
+      expect(e).toEqual(new Error('ms duration is required'))
+    }
+  })
+
+  test('refresh type timers set event listeners', () => {
+    // eslint-disable-next-line
+    let ee = { on: jest.fn().mockImplementation((evt, cb) => { cb([{ type: 'click' }]) }) }
+    let it = new InteractionTimer({ onEnd: jest.fn(), onRefresh: jest.fn(), ee }, 100)
+    // scroll, keypress, click
+    expect(ee.on).toHaveBeenCalledTimes(1)
+    expect(it.onRefresh).toHaveBeenCalledTimes(1)
+
+    // eslint-disable-next-line
+     ee = { on: jest.fn().mockImplementation((evt, cb) => { cb([{ type: 'scroll' }]) }) }
+    it = new InteractionTimer({ onEnd: jest.fn(), onRefresh: jest.fn(), ee }, 100)
+    // scroll, keypress, click
+    expect(ee.on).toHaveBeenCalledTimes(1)
+    expect(it.onRefresh).toHaveBeenCalledTimes(1)
+
+    // eslint-disable-next-line
+     ee = { on: jest.fn().mockImplementation((evt, cb) => { cb([{ type: 'keydown' }]) }) }
+    it = new InteractionTimer({ onEnd: jest.fn(), onRefresh: jest.fn(), ee }, 100)
+    // scroll, keypress, click
+    expect(ee.on).toHaveBeenCalledTimes(1)
+    expect(it.onRefresh).toHaveBeenCalledTimes(1)
+
+    const aelSpy = jest.spyOn(document, 'addEventListener')
+    // eslint-disable-next-line
+    ee = { on: jest.fn().mockImplementation((evt, cb) => { cb([{ type: 'keydown' }]) }) }
+    it = new InteractionTimer({ onEnd: jest.fn(), onRefresh: jest.fn(), ee }, 100)
+    // visibility change
+    expect(aelSpy).toHaveBeenCalledTimes(1)
+  })
+})
+
+describe('create()', () => {
+  test('Create sets a timeout that can execute a cb', () => {
+    const timer = new InteractionTimer({ onEnd: jest.fn() }, 100)
+    expect(timer.timer).toBeTruthy()
+    expect(timer.onEnd).toHaveBeenCalledTimes(0)
+    jest.runOnlyPendingTimers()
+    expect(timer.onEnd).toHaveBeenCalledTimes(1)
+  })
+
+  test('Create can fallback to use defaults', () => {
+    let called = 0
+    const timer1 = new InteractionTimer({ onEnd: jest.fn() }, 100)
+    timer1.create()
+
+    const timer2 = new InteractionTimer({ onEnd: jest.fn() }, 100)
+    timer2.create(timer2.onEnd)
+
+    const timer3 = new InteractionTimer({ onEnd: jest.fn() }, 100)
+    timer3.create(undefined, 100)
+
+    jest.runAllTimers(200)
+
+    expect(timer1.onEnd).toHaveBeenCalledTimes(1)
+    expect(timer2.onEnd).toHaveBeenCalledTimes(1)
+    expect(timer3.onEnd).toHaveBeenCalledTimes(1)
+  })
+})
+
+describe('refresh()', () => {
+  test('refresh prevents the callback from firing', () => {
+    const timer = new InteractionTimer({ onEnd: jest.fn(), onRefresh: jest.fn() }, 100)
+    expect(timer.onEnd).toHaveBeenCalledTimes(0)
+    jest.advanceTimersByTime(75)
+    expect(timer.onEnd).toHaveBeenCalledTimes(0)
+    timer.refresh()
+    jest.advanceTimersByTime(75)
+    expect(timer.onEnd).toHaveBeenCalledTimes(0)
+    jest.advanceTimersByTime(100)
+    expect(timer.onEnd).toHaveBeenCalledTimes(1)
+  })
+
+  test('refresh executes a callback for consumers', () => {
+    const timer = new InteractionTimer({ onEnd: jest.fn(), onRefresh: jest.fn() }, 100)
+    timer.refresh()
+    expect(timer.onRefresh).toHaveBeenCalledTimes(1)
+  })
+})
+
+describe('pause()', () => {
+  test('pause prevents the callback from firing', () => {
+    const timer = new InteractionTimer({ onEnd: jest.fn() }, 100)
+    expect(timer.onEnd).toHaveBeenCalledTimes(0)
+    timer.pause()
+    jest.advanceTimersByTime(150)
+    expect(timer.onEnd).toHaveBeenCalledTimes(0)
+  })
+
+  test('pause sets remainingMs timestamp', () => {
+    const timer = new InteractionTimer({ onEnd: jest.fn() }, 100)
+    expect(timer.remainingMs).toEqual(undefined)
+    timer.pause()
+    expect(timer.remainingMs).toEqual(timer.initialMs - (now - timer.startTimestamp))
+  })
+})
+
+describe('clear()', () => {
+  test('clear prevents the callback from firing and deletes the pointer', () => {
+    const timer = new InteractionTimer({ onEnd: jest.fn() }, 100)
+    expect(timer.onEnd).toHaveBeenCalledTimes(0)
+    timer.clear()
+    jest.advanceTimersByTime(150)
+    expect(timer.onEnd).toHaveBeenCalledTimes(0)
+    expect(timer.timer).toEqual(null)
+  })
+})
+
+describe('end()', () => {
+  test('end clears the callback and calls the onEnd callback', () => {
+    const timer = new InteractionTimer({ onEnd: jest.fn() }, 100)
+    expect(timer.onEnd).toHaveBeenCalledTimes(0)
+    timer.end()
+    expect(timer.onEnd).toHaveBeenCalledTimes(1)
+    expect(timer.timer).toEqual(null)
+  })
+})
+
+describe('isValid', () => {
+  test('isValid validates timeStamps', () => {
+    const timer = new InteractionTimer({ onEnd: jest.fn() }, 100)
+    expect(timer.isValid()).toEqual(true)
+    timer.startTimestamp -= 100
+    expect(timer.isValid()).toEqual(false)
+  })
+})