@newrelic/browser-agent 1.241.0 → 1.243.0

package/src/features/session_replay/aggregate/index.js

@@ -15,18 +15,47 @@ import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler'
 import { FEATURE_NAME } from '../constants'
 import { stringify } from '../../../common/util/stringify'
 import { getConfigurationValue, getInfo, getRuntime } from '../../../common/config/config'
-import { SESSION_EVENTS, MODE } from '../../../common/session/session-entity'
+import { SESSION_EVENTS, MODE, SESSION_EVENT_TYPES } from '../../../common/session/session-entity'
 import { AggregateBase } from '../../utils/aggregate-base'
 import { sharedChannel } from '../../../common/constants/shared-channel'
 import { obj as encodeObj } from '../../../common/url/encode'
 import { warn } from '../../../common/util/console'
 import { globalScope } from '../../../common/constants/runtime'
+import { SUPPORTABILITY_METRIC_CHANNEL } from '../../metrics/constants'
 
 // would be better to get this dynamically in some way
 export const RRWEB_VERSION = '2.0.0-alpha.8'
 
 export const AVG_COMPRESSION = 0.12
 
+export const RRWEB_EVENT_TYPES = {
+  DomContentLoaded: 0,
+  Load: 1,
+  FullSnapshot: 2,
+  IncrementalSnapshot: 3,
+  Meta: 4,
+  Custom: 5
+}
+
+const ABORT_REASONS = {
+  RESET: {
+    message: 'Session was reset',
+    sm: 'Reset'
+  },
+  IMPORT: {
+    message: 'Recorder failed to import',
+    sm: 'Import'
+  },
+  TOO_MANY: {
+    message: '429: Too Many Requests',
+    sm: 'Too-Many'
+  },
+  TOO_BIG: {
+    message: 'Payload was too large',
+    sm: 'Too-Big'
+  }
+}
+
 let recorder, gzipper, u8
 
 /** Vortex caps payload sizes at 1MB */
@@ -57,8 +86,6 @@ export class Aggregate extends AggregateBase {
     /** can shut off efforts to compress the data */
     this.shouldCompress = true
 
-    /** Payload metadata -- Should indicate that the payload being sent is the first of a session */
-    this.isFirstChunk = false
     /** Payload metadata -- Should indicate that the payload being sent has a full DOM snapshot. This can happen
      * -- When the recording library begins recording, it starts by taking a DOM snapshot
      * -- When visibility changes from "hidden" -> "visible", it must capture a full snapshot for the replay to work correctly across tabs
@@ -72,7 +99,7 @@ export class Aggregate extends AggregateBase {
     /** Payload metadata -- Should indicate when a replay blob started recording.  Resets each time a harvest occurs.
      * cycle timestamps are used as fallbacks if event timestamps cannot be used
      */
-    this.timestamp = { event: { first: undefined, last: undefined }, cycle: { first: undefined, last: undefined } }
+    this.cycleTimestamp = undefined
 
     /** A value which increments with every new mutation node reported. Resets after a harvest is sent */
     this.payloadBytesEstimation = 0
@@ -91,17 +118,26 @@ export class Aggregate extends AggregateBase {
     if (shouldSetup) {
       // The SessionEntity class can emit a message indicating the session was cleared and reset (expiry, inactivity). This feature must abort and never resume if that occurs.
       this.ee.on(SESSION_EVENTS.RESET, () => {
-        this.abort()
+        this.abort(ABORT_REASONS.RESET)
       })
 
       // The SessionEntity class can emit a message indicating the session was paused (visibility change). This feature must stop recording if that occurs.
       this.ee.on(SESSION_EVENTS.PAUSE, () => { this.stopRecording() })
       // The SessionEntity class can emit a message indicating the session was resumed (visibility change). This feature must start running again (if already running) if that occurs.
       this.ee.on(SESSION_EVENTS.RESUME, () => {
+        // if the mode changed on a different tab, it needs to update this instance to match
+        const { session } = getRuntime(this.agentIdentifier)
+        this.mode = session.state.sessionReplay
         if (!this.initialized || this.mode === MODE.OFF) return
         this.startRecording()
       })
 
+      this.ee.on(SESSION_EVENTS.UPDATE, (type, data) => {
+        if (!this.initialized || this.blocked || type !== SESSION_EVENT_TYPES.CROSS_TAB) return
+        if (this.mode !== MODE.OFF && data.sessionReplay === MODE.OFF) this.abort('Session Entity was set to OFF on another tab')
+        this.mode = data.sessionReplay
+      })
+
       // Bespoke logic for new endpoint.  This will change as downstream dependencies become solidified.
       this.scheduler = new HarvestScheduler('browser/blobs', {
         onFinished: this.onHarvestFinished.bind(this),
@@ -116,12 +152,13 @@ export class Aggregate extends AggregateBase {
         this.hasError = true
         this.errorNoticed = true
         // run once
-        if (this.mode === MODE.ERROR) {
+        if (this.mode === MODE.ERROR && globalScope?.document.visibilityState === 'visible') {
           this.mode = MODE.FULL
           // if the error was noticed AFTER the recorder was already imported....
           if (recorder && this.initialized) {
             this.stopRecording()
             this.startRecording()
+
             this.scheduler.startTimer(this.harvestTimeSeconds)
 
             this.syncWithSessionManager({ sessionReplay: this.mode })
@@ -176,7 +213,7 @@ export class Aggregate extends AggregateBase {
       // Do not change the webpackChunkName or it will break the webpack nrba-chunking plugin
       recorder = (await import(/* webpackChunkName: "recorder" */'rrweb')).record
     } catch (err) {
-      return this.abort()
+      return this.abort(ABORT_REASONS.IMPORT)
     }
 
     // FULL mode records AND reports from the beginning, while ERROR mode only records (but does not report).
@@ -198,8 +235,6 @@ export class Aggregate extends AggregateBase {
     }
     this.startRecording()
 
-    this.isFirstChunk = !!session.isNew
-
     this.syncWithSessionManager({ sessionReplay: this.mode })
   }
 
@@ -214,6 +249,8 @@ export class Aggregate extends AggregateBase {
       this.scheduler.opts.gzip = false
     }
     // TODO -- Gracefully handle the buffer for retries.
+    const { session } = getRuntime(this.agentIdentifier)
+    if (!session.state.sessionReplaySentFirstChunk) this.syncWithSessionManager({ sessionReplaySentFirstChunk: true })
     this.clearBuffer()
     return [payload]
   }
@@ -221,8 +258,28 @@ export class Aggregate extends AggregateBase {
   getHarvestContents () {
     const agentRuntime = getRuntime(this.agentIdentifier)
     const info = getInfo(this.agentIdentifier)
-    const firstTimestamp = this.timestamp.event.first || this.timestamp.cycle.first
-    const lastTimestamp = this.timestamp.event.last || this.timestamp.cycle.last
+
+    // do not let the last node be a meta node, since this NEEDS to precede a snapshot
+    // we will manually inject it later if we find a payload that is missing a meta node
+    const payloadEndsWithMeta = this.events[this.events.length - 1]?.type === RRWEB_EVENT_TYPES.Meta
+    if (payloadEndsWithMeta) {
+      this.lastMeta = this.events[this.events.length - 1]
+      this.events = this.events.slice(0, this.events.length - 1)
+      this.hasMeta = !!this.events.find(x => x.type === RRWEB_EVENT_TYPES.Meta)
+    }
+
+    // do not let the first node be a full snapshot node, since this NEEDS to be preceded by a meta node
+    // we will manually inject it if this happens
+    const payloadStartsWithFullSnapshot = this.events[0]?.type === RRWEB_EVENT_TYPES.FullSnapshot
+    if (payloadStartsWithFullSnapshot) {
+      this.hasMeta = true
+      this.events.unshift(this.lastMeta)
+    }
+
+    const firstEventTimestamp = this.events[0]?.timestamp
+    const lastEventTimestamp = this.events[this.events.length - 1]?.timestamp
+    const firstTimestamp = firstEventTimestamp || this.cycleTimestamp
+    const lastTimestamp = lastEventTimestamp || getRuntime(this.agentIdentifier).offset + globalScope.performance.now()
     return {
       qs: {
         browser_monitoring_key: info.licenseKey,
@@ -234,12 +291,13 @@ export class Aggregate extends AggregateBase {
           'replay.firstTimestamp': firstTimestamp,
           'replay.lastTimestamp': lastTimestamp,
           'replay.durationMs': lastTimestamp - firstTimestamp,
+          'replay.nodes': this.events.length,
           agentVersion: agentRuntime.version,
           session: agentRuntime.session.state.value,
           hasMeta: this.hasMeta,
           hasSnapshot: this.hasSnapshot,
           hasError: this.hasError,
-          isFirstChunk: this.isFirstChunk,
+          isFirstChunk: agentRuntime.session.state.sessionReplaySentFirstChunk === false,
           decompressedBytes: this.payloadBytesEstimation,
           'nr.rrweb.version': RRWEB_VERSION
         }, MAX_PAYLOAD_SIZE - this.payloadBytesEstimation).substring(1) // remove the leading '&'
@@ -251,7 +309,7 @@ export class Aggregate extends AggregateBase {
   onHarvestFinished (result) {
     // The mutual decision for now is to stop recording and clear buffers if ingest is experiencing 429 rate limiting
     if (result.status === 429) {
-      this.abort()
+      this.abort(ABORT_REASONS.TOO_MANY)
     }
 
     if (this.blocked) this.scheduler.stopTimer(true)
@@ -260,7 +318,6 @@ export class Aggregate extends AggregateBase {
   /** Clears the buffer (this.events), and resets all payload metadata properties */
   clearBuffer () {
     this.events = []
-    this.isFirstChunk = false
     this.hasSnapshot = false
     this.hasMeta = false
     this.hasError = false
@@ -272,7 +329,7 @@ export class Aggregate extends AggregateBase {
   startRecording () {
     if (!recorder) {
       warn('Recording library was never imported')
-      return this.abort()
+      return this.abort(ABORT_REASONS.IMPORT)
     }
     this.clearTimestamps()
     // set the fallbacks as early as possible
@@ -301,7 +358,7 @@ export class Aggregate extends AggregateBase {
 
   /** Store a payload in the buffer (this.events).  This should be the callback to the recording lib noticing a mutation */
   store (event, isCheckout) {
-    this.setTimestamps(event)
+    this.setTimestamps()
     if (this.blocked) return
     const eventBytes = stringify(event).length
     /** The estimated size of the payload after compression */
@@ -309,7 +366,7 @@ export class Aggregate extends AggregateBase {
     // Vortex will block payloads at a certain size, we might as well not send.
     if (payloadSize > MAX_PAYLOAD_SIZE) {
       this.clearBuffer()
-      return this.abort()
+      return this.abort(ABORT_REASONS.TOO_BIG)
     }
     // Checkout events are flags by the recording lib that indicate a fullsnapshot was taken every n ms. These are important
     // to help reconstruct the replay later and must be included.  While waiting and buffering for errors to come through,
@@ -320,19 +377,13 @@ export class Aggregate extends AggregateBase {
     }
 
     // meta event
-    if (event.type === 4) {
+    if (event.type === RRWEB_EVENT_TYPES.Meta) {
       this.hasMeta = true
       this.lastMeta = event
     }
     // snapshot event
-    if (event.type === 2) {
+    if (event.type === RRWEB_EVENT_TYPES.FullSnapshot) {
       this.hasSnapshot = true
-      // small chance that the meta event got separated from its matching snapshot across payload harvests
-      // it needs to precede the snapshot, so shove it in first.
-      if (!this.hasMeta) {
-        this.events.push(this.lastMeta)
-        this.hasMeta = true
-      }
     }
 
     this.events.push(event)
@@ -352,18 +403,13 @@ export class Aggregate extends AggregateBase {
     recorder.takeFullSnapshot()
   }
 
-  setTimestamps (event) {
+  setTimestamps () {
     // fallbacks if timestamps cannot be derived from rrweb events
-    this.timestamp.cycle.last = getRuntime(this.agentIdentifier).offset + globalScope.performance.now()
-    if (!this.timestamp.cycle.first) this.timestamp.cycle.first = this.timestamp.cycle.last
-    // timestamps based on rrweb events
-    if (!event || !event.timestamp) return
-    if (!this.timestamp.event.first) this.timestamp.event.first = event.timestamp
-    this.timestamp.event.last = event.timestamp
+    if (!this.cycleTimestamp) this.cycleTimestamp = getRuntime(this.agentIdentifier).offset + globalScope.performance.now()
   }
 
   clearTimestamps () {
-    this.timestamp = { event: { first: undefined, last: undefined }, cycle: { first: undefined, last: undefined } }
+    this.cycleTimestamp = undefined
   }
 
   /** Estimate the payload size */
@@ -373,7 +419,9 @@ export class Aggregate extends AggregateBase {
   }
 
   /** Abort the feature, once aborted it will not resume */
-  abort () {
+  abort (reason = {}) {
+    warn(`SR aborted -- ${reason.message}`)
+    this.ee.emit(SUPPORTABILITY_METRIC_CHANNEL, [`SessionReplay/Abort/${ABORT_REASONS[reason.sm]}`])
     this.blocked = true
     this.mode = MODE.OFF
     this.stopRecording()

package/src/features/utils/feature-base.js

@@ -1,4 +1,3 @@
-import { getRuntime } from '../../common/config/config'
 import { ee } from '../../common/event-emitter/contextual-ee'
 
 export class FeatureBase {
@@ -8,7 +7,7 @@ export class FeatureBase {
     /** @type {Aggregator} */
     this.aggregator = aggregator
     /** @type {ContextualEE} */
-    this.ee = ee.get(agentIdentifier, getRuntime(this.agentIdentifier).isolatedBacklog)
+    this.ee = ee.get(agentIdentifier)
     /** @type {string} */
     this.featureName = featureName
     /**

package/src/features/utils/instrument-base.js

@@ -108,6 +108,7 @@ export class InstrumentBase extends FeatureBase {
         warn(`Downloading and initializing ${this.featureName} failed...`, e)
         this.abortHandler?.() // undo any important alterations made to the page
         // not supported yet but nice to do: "abort" this agent's EE for this feature specifically
+        drain(this.agentIdentifier, this.featureName)
         loadedSuccessfully(false)
       }
     }

package/src/loaders/api/api.js

@@ -19,7 +19,7 @@ export const CUSTOM_ATTR_GROUP = 'CUSTOM/' // the subgroup items should be store
 export function setTopLevelCallers () {
   const nr = gosCDN()
   const funcs = [
-    'setErrorHandler', 'finished', 'addToTrace', 'inlineHit', 'addRelease',
+    'setErrorHandler', 'finished', 'addToTrace', 'addRelease',
     'addPageAction', 'setCurrentRouteName', 'setPageViewName', 'setCustomAttribute',
     'interaction', 'noticeError', 'setUserId', 'setApplicationVersion', 'start'
   ]
@@ -48,7 +48,6 @@ export function setAPI (agentIdentifier, forceDrain) {
     'setErrorHandler',
     'finished',
     'addToTrace',
-    'inlineHit',
     'addRelease'
   ]
 

package/src/loaders/api/apiAsync.js

@@ -1,22 +1,18 @@
 import { FEATURE_NAMES } from '../features/features'
-import { getConfiguration, getInfo, getRuntime } from '../../common/config/config'
+import { getRuntime } from '../../common/config/config'
 import { ee } from '../../common/event-emitter/contextual-ee'
 import { handle } from '../../common/event-emitter/handle'
 import { registerHandler } from '../../common/event-emitter/register-handler'
 import { single } from '../../common/util/invoke'
-import * as submitData from '../../common/util/submit-data'
-import { isBrowserScope } from '../../common/constants/runtime'
 import { CUSTOM_METRIC_CHANNEL } from '../../features/metrics/constants'
 
 export function setAPI (agentIdentifier) {
   var instanceEE = ee.get(agentIdentifier)
-  var cycle = 0
 
   var api = {
     finished: single(finished),
     setErrorHandler,
     addToTrace,
-    inlineHit,
     addRelease
   }
 
@@ -47,40 +43,6 @@ export function setAPI (agentIdentifier) {
     handle('bstApi', [report], undefined, FEATURE_NAMES.sessionTrace, instanceEE)
   }
 
-  // NREUM.inlineHit(requestName, queueTime, appTime, totalBackEndTime, domTime, frontEndTime)
-  //
-  // requestName - the 'web page' name or service name
-  // queueTime - the amount of time spent in the app tier queue
-  // appTime - the amount of time spent in the application code
-  // totalBackEndTime - the total roundtrip time of the remote service call
-  // domTime - the time spent processing the result of the service call (or user defined)
-  // frontEndTime - the time spent rendering the result of the service call (or user defined)
-  function inlineHit (t, requestName, queueTime, appTime, totalBackEndTime, domTime, frontEndTime) {
-    if (!isBrowserScope) return
-
-    requestName = window.encodeURIComponent(requestName)
-    cycle += 1
-
-    const agentInfo = getInfo(agentIdentifier)
-    if (!agentInfo.beacon) return
-
-    const agentInit = getConfiguration(agentIdentifier)
-    const scheme = agentInit.ssl === false ? 'http' : 'https'
-    const beacon = agentInit.proxy.beacon || agentInfo.beacon
-    let url = `${scheme}://${beacon}/1/${agentInfo.licenseKey}`
-
-    url += '?a=' + agentInfo.applicationID + '&'
-    url += 't=' + requestName + '&'
-    url += 'qt=' + ~~queueTime + '&'
-    url += 'ap=' + ~~appTime + '&'
-    url += 'be=' + ~~totalBackEndTime + '&'
-    url += 'dc=' + ~~domTime + '&'
-    url += 'fe=' + ~~frontEndTime + '&'
-    url += 'c=' + cycle
-
-    submitData.xhr({ url })
-  }
-
   function setErrorHandler (t, handler) {
     getRuntime(agentIdentifier).onerror = handler
   }

package/src/loaders/configure/configure.js

@@ -33,7 +33,7 @@ export function configure (agentIdentifier, opts = {}, loaderType, forceDrain) {
   if (!alreadySetOnce) {
     alreadySetOnce = true
     if (updatedInit.proxy.assets) {
-      redefinePublicPath(updatedInit.proxy.assets + '/') // much like the info.beacon & init.proxy.beacon, this input should not end in a slash, but one is needed for webpack concat
+      redefinePublicPath(updatedInit.proxy.assets)
       internalTrafficList.push(updatedInit.proxy.assets)
     }
     if (updatedInit.proxy.beacon) internalTrafficList.push(updatedInit.proxy.beacon)

package/src/loaders/configure/public-path.js

@@ -1,6 +1,9 @@
 // Set the default CDN or remote for fetching the assets; NPM shouldn't change this var.
 
-export const redefinePublicPath = (url) => {
-  // There's no URL validation here, so caller should check arg if need be.
-  __webpack_public_path__ = url // eslint-disable-line
+export const redefinePublicPath = (urlString) => {
+  const isOrigin = urlString.startsWith('http')
+  // Input is not expected to end in a slash, but webpack concats as-is, so one is inserted.
+  urlString += '/'
+  // If there's no existing HTTP scheme, the secure protocol is prepended by default.
+  __webpack_public_path__ = isOrigin ? urlString : 'https://' + urlString // eslint-disable-line
 }

package/src/common/aggregate/aggregator.test.js

@@ -1,107 +0,0 @@
-import { Aggregator } from './aggregator.js'
-
-let aggregator
-beforeEach(() => {
-  aggregator = new Aggregator({ agentIdentifier: 'blah' })
-})
-
-test('storing and getting buckets', () => {
-  let bucket = aggregator.store('abc', '123')
-  const expectedBucketPattern = { params: {}, metrics: { count: 1 } }
-  expect(bucket).toEqual(expectedBucketPattern)
-  expect(aggregator.get('abc', '123')).toEqual(expectedBucketPattern)
-
-  aggregator.store('abc', '456')
-  // check we can get all buckets under the same type
-  expect(aggregator.get('abc')).toEqual({ 123: expectedBucketPattern, 456: expectedBucketPattern })
-})
-
-describe('storing the same bucket again', () => {
-  test('increments the count', () => {
-    aggregator.store('abc', '123')
-    aggregator.store('abc', '123')
-    expect(aggregator.get('abc', '123')).toEqual({ params: {}, metrics: { count: 2 } })
-  })
-
-  test('does not overwrite params', () => {
-    aggregator.store('def', '123', { someParam: true })
-    aggregator.store('def', '123', { anotherParam: true })
-    expect(aggregator.get('def', '123')).toEqual({ params: { someParam: true }, metrics: { count: 2 } })
-  })
-
-  test('does not overwrite custom params either', () => {
-    aggregator.store('ghi', '123', undefined, undefined, { someCustomParam: true })
-    aggregator.store('ghi', '123', undefined, undefined, { someCustomParam: false })
-    expect(aggregator.get('ghi', '123')).toEqual({ params: {}, custom: { someCustomParam: true }, metrics: { count: 2 } })
-  })
-})
-
-describe('metrics are properly updated', () => {
-  test('when using store fn', () => {
-    const expectedBucketPattern = {
-      params: {},
-      metrics: {
-        count: 2,
-        met1: { t: 3, min: 1, max: 2, sos: 5, c: 2 },
-        met2: { t: 7, min: 3, max: 4, sos: 25, c: 2 }
-      }
-    }
-    aggregator.store('abc', '123', undefined, { met1: 1, met2: 3 })
-    aggregator.store('abc', '123', undefined, { met1: 2, met2: 4 })
-    expect(aggregator.get('abc', '123')).toEqual(expectedBucketPattern)
-  })
-
-  test('when using storeMetric fn', () => {
-    const expectedBucketPattern = {
-      params: {},
-      stats: { t: 6, min: 1, max: 3, sos: 14, c: 3 }
-    }
-    aggregator.storeMetric('abc', 'metric', undefined, 2)
-    aggregator.storeMetric('abc', 'metric', undefined, 1)
-    aggregator.storeMetric('abc', 'metric', undefined, 3)
-    expect(aggregator.get('abc', 'metric')).toEqual(expectedBucketPattern)
-  })
-})
-
-test('take fn gets and deletes correctly', () => {
-  aggregator.store('type1', 'a')
-  aggregator.store('type1', 'b')
-  aggregator.store('type2', 'a')
-  aggregator.store('type3', 'a')
-
-  expect(aggregator.take(['type0'])).toBeNull() // when type dne in aggregator
-  let obj = aggregator.take(['type1', 'type2'])
-  expect(obj.type1.length).toEqual(2)
-  expect(obj.type2.length).toEqual(1)
-  expect(aggregator.get('type1', 'a')).toBeUndefined() // should be gone now
-  expect(aggregator.get('type3', 'a')).toEqual(expect.any(Object))
-})
-
-test('merge fn combines metrics correctly', () => {
-  aggregator.store('abc', '123', undefined, { met1: 1, met2: 3 })
-  let bucket = aggregator.store('abc', '123', undefined, { met1: 2 })
-  const expectedMetrics = {
-    count: 2,
-    met1: { t: 3, min: 1, max: 2, sos: 5, c: 2 },
-    met2: { t: 3 }
-  }
-  expect(bucket.metrics).toEqual(expectedMetrics)
-
-  aggregator.merge('abc', '456', bucket.metrics)
-  expect(aggregator.get('abc', '456').metrics).toEqual(expectedMetrics)
-
-  aggregator.merge('abc', '123', {
-    count: 4,
-    met1: { t: 4, min: 0, max: 4, sos: 16, c: 2 },
-    met2: { t: 5 },
-    met3: { t: 6 },
-    met4: { t: 7, min: 3, max: 4, sos: 25, c: 2 }
-  })
-  expect(aggregator.get('abc', '123').metrics).toEqual({
-    count: 6,
-    met1: { t: 7, min: 0, max: 4, sos: 21, c: 4 },
-    met2: { t: 8, min: 3, max: 5, sos: 34, c: 2 },
-    met3: { t: 6 },
-    met4: { t: 7, min: 3, max: 4, sos: 25, c: 2 }
-  })
-})

package/src/common/config/state/configurable.test.js

@@ -1,73 +0,0 @@
-import { getModeledObject } from './configurable'
-
-test('if either params are not objects, function fails', () => {
-  let result = getModeledObject(123, {})
-  expect(result).toEqual(undefined)
-
-  result = getModeledObject({}, () => 'whatever')
-  expect(result).toEqual(undefined)
-})
-
-test('models are not mutated by function', () => {
-  const template = { dontchangethis: true }
-  getModeledObject({ dontchangethis: false, addthis: true }, template)
-  expect(template).toEqual({ dontchangethis: true })
-})
-
-const model = {
-  eat: true,
-  sleep: true,
-  rave: true,
-  repeat: {
-    eat: true,
-    sleep: true,
-    rave: true,
-    repeat: false
-  }
-}
-
-test('empty object does not change model output', () => {
-  expect(getModeledObject({}, model)).toEqual(model)
-})
-
-test('existing keys get their values changed', () => {
-  let obj = {
-    sleep: false,
-    repeat: {
-      eat: false
-    }
-  }
-  expect(getModeledObject(obj, model)).toEqual({
-    eat: true,
-    sleep: false,
-    rave: true,
-    repeat: {
-      eat: false, // should recurse
-      sleep: true,
-      rave: true,
-      repeat: false
-    }
-  })
-})
-
-test('existing keys can change types too, to/from object', () => {
-  // in other words, if replacement is not an object, it has no effect
-  let obj = {
-    rave: {},
-    repeat: 'just a sad lonely string now'
-  }
-  expect(getModeledObject(obj, model)).toEqual({
-    eat: true,
-    sleep: true,
-    rave: {},
-    repeat: 'just a sad lonely string now'
-  })
-})
-
-test('keys not in model are ignored', () => {
-  expect(getModeledObject({ game: 'allnight' }, model)).toEqual(model)
-})
-
-test('but if model is empty, then keys are not ignored', () => {
-  expect(getModeledObject({ game: 'allnight' }, {})).toEqual({ game: 'allnight' })
-})

package/src/common/config/state/info.test.js

@@ -1,31 +0,0 @@
-let isValid, getInfo, setInfo
-beforeEach(async () => {
-  jest.resetModules()
-  ;({ isValid, getInfo, setInfo } = await import('./info.js'))
-})
-
-test('set/getInfo should throw on an invalid agent id', () => {
-  // currently only checks if it's a truthy value
-  expect(() => setInfo(undefined, {})).toThrow('require an agent id')
-  expect(() => getInfo(undefined)).toThrow('require an agent id')
-  expect(() => setInfo('', {})).toThrow('require an agent id')
-  expect(() => getInfo('')).toThrow('require an agent id')
-})
-
-test('set/getInfo works correctly', () => {
-  expect(() => setInfo(123, { beacon: 'im here' })).not.toThrow() // notice setInfo accepts numbers
-  let cachedObj = getInfo('123')
-  expect(Object.keys(cachedObj).length).toBeGreaterThan(1)
-  expect(cachedObj.beacon).toEqual('im here')
-  expect(cachedObj.licenseKey).toEqual(undefined) // this should mirror default in info.js
-})
-
-test('isValid is correct', () => {
-  setInfo('ab', { errorBeacon: 'some value' })
-  setInfo('cd', { errorBeacon: 'some value', licenseKey: 'cereal box' })
-  expect(isValid('ab')).toBeFalsy()
-  expect(isValid('cd')).toBeFalsy()
-
-  setInfo('ef', { errorBeacon: 'some value', licenseKey: 'cereal box', applicationID: '25' })
-  expect(isValid('ef')).toBeTruthy()
-})

package/src/common/config/state/init.test.js

@@ -1,28 +0,0 @@
-let getConfiguration, setConfiguration, getConfigurationValue
-beforeEach(async () => {
-  jest.resetModules()
-  ;({ getConfiguration, setConfiguration, getConfigurationValue } = await import('./init.js'))
-})
-
-test('set/getConfiguration should throw on an invalid agent id', () => {
-  // currently only checks if it's a truthy value
-  expect(() => setConfiguration(undefined, {})).toThrow('require an agent id')
-  expect(() => getConfiguration(undefined)).toThrow('require an agent id')
-  expect(() => setConfiguration('', {})).toThrow('require an agent id')
-  expect(() => getConfiguration('')).toThrow('require an agent id')
-})
-
-test('set/getConfiguration works correctly', () => {
-  expect(() => setConfiguration(123, { jserrors: { enabled: false } })).not.toThrow() // notice setConfiguration accepts numbers
-  let cachedObj = getConfiguration('123')
-  expect(Object.keys(cachedObj).length).toBeGreaterThan(1)
-  expect(cachedObj.jserrors.enabled).toEqual(false)
-  expect(cachedObj.page_action.enabled).toEqual(true) // this should mirror default in init.js
-})
-
-test('getConfigurationValue parses path correctly', () => {
-  setConfiguration('ab', { page_action: { harvestTimeSeconds: 1000 } })
-  expect(getConfigurationValue('ab', '')).toBeUndefined()
-  expect(getConfigurationValue('ab', 'page_action')).toEqual({ enabled: true, harvestTimeSeconds: 1000, autoStart: true })
-  expect(getConfigurationValue('ab', 'page_action.harvestTimeSeconds')).toEqual(1000)
-})

package/src/common/config/state/loader-config.test.js

@@ -1,21 +0,0 @@
-let getLoaderConfig, setLoaderConfig
-beforeEach(async () => {
-  jest.resetModules()
-  ;({ getLoaderConfig, setLoaderConfig } = await import('./loader-config.js'))
-})
-
-test('set/getLoaderConfig should throw on an invalid agent id', () => {
-  // currently only checks if it's a truthy value
-  expect(() => setLoaderConfig(undefined, {})).toThrow('require an agent id')
-  expect(() => getLoaderConfig(undefined)).toThrow('require an agent id')
-  expect(() => setLoaderConfig('', {})).toThrow('require an agent id')
-  expect(() => getLoaderConfig('')).toThrow('require an agent id')
-})
-
-test('set/getLoaderConfig works correctly', () => {
-  expect(() => setLoaderConfig(123, { trustKey: 1 })).not.toThrow() // notice setLoaderConfig accepts numbers
-  let cachedObj = getLoaderConfig('123')
-  expect(Object.keys(cachedObj).length).toBeGreaterThan(1)
-  expect(cachedObj.trustKey).toEqual(1)
-  expect(cachedObj.xpid).toBeUndefined() // this should mirror default in loader-config.js
-})