@newrelic/browser-agent 1.233.0 → 1.234.0

package/dist/cjs/cdn/experimental.js

@@ -0,0 +1,27 @@
+"use strict";
+
+var _agent = require("../loaders/agent");
+var _instrument = require("../features/page_view_event/instrument");
+var _instrument2 = require("../features/page_view_timing/instrument");
+var _instrument3 = require("../features/metrics/instrument");
+var _instrument4 = require("../features/jserrors/instrument");
+var _instrument5 = require("../features/ajax/instrument");
+var _instrument6 = require("../features/session_trace/instrument");
+var _instrument7 = require("../features/session_replay/instrument");
+var _instrument8 = require("../features/spa/instrument");
+var _instrument9 = require("../features/page_action/instrument");
+/*
+ * Copyright 2023 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @file Creates an "EXPERIMENTAL" agent loader bundle composed of the core agent and all available feature modules, including experimental features.
+ *
+ * NOTE: This loader is ONLY used for internal testing. The code contained within is likely under development and dormant. It will not download to instrumented pages or record any data.
+ * It is not production ready, and is not intended to be imported or implemented in any build of the browser agent
+ */
+
+new _agent.Agent({
+  features: [_instrument5.Instrument, _instrument.Instrument, _instrument2.Instrument, _instrument6.Instrument, _instrument7.Instrument, _instrument3.Instrument, _instrument9.Instrument, _instrument4.Instrument, _instrument8.Instrument],
+  loaderType: 'experimental'
+});

package/dist/cjs/common/config/state/init.js

@@ -68,7 +68,7 @@ const model = () => {
     },
     session_replay: {
       // feature settings
-      enabled: true,
+      enabled: false,
       harvestTimeSeconds: 60,
       sampleRate: 0.1,
       errorSampleRate: 0.1,

package/dist/cjs/common/constants/env.cdn.js

@@ -12,7 +12,7 @@ exports.VERSION = exports.DIST_METHOD = exports.BUILD_ENV = void 0;
 /**
  * Exposes the version of the agent
  */
-const VERSION = "1.233.0";
+const VERSION = "1.234.0";
 
 /**
  * Exposes the build type of the agent

package/dist/cjs/common/constants/env.npm.js

@@ -12,7 +12,7 @@ exports.VERSION = exports.DIST_METHOD = exports.BUILD_ENV = void 0;
 /**
  * Exposes the version of the agent
  */
-const VERSION = "1.233.0";
+const VERSION = "1.234.0";
 
 /**
  * Exposes the build type of the agent

package/dist/cjs/common/event-emitter/contextual-ee.test.js

@@ -93,7 +93,7 @@ describe('event-emitter context', () => {
   });
 });
 describe('event-emitter buffer', () => {
-  it('it should create a new buffer for the given group', async () => {
+  test('it should create a new buffer for the given group', async () => {
     const {
       ee
     } = await Promise.resolve().then(() => _interopRequireWildcard(require('./contextual-ee')));
@@ -105,7 +105,7 @@ describe('event-emitter buffer', () => {
     }));
     expect(ee.isBuffering(eventType)).toEqual(true);
   });
-  it('it should default group to "feature"', async () => {
+  test('it should default group to "feature"', async () => {
     const {
       ee
     } = await Promise.resolve().then(() => _interopRequireWildcard(require('./contextual-ee')));
@@ -116,7 +116,7 @@ describe('event-emitter buffer', () => {
     }));
     expect(ee.isBuffering(eventType)).toEqual(true);
   });
-  it('it should not create buffer if event-emitter is aborted', async () => {
+  test('it should not create buffer if event-emitter is aborted', async () => {
     const {
       ee
     } = await Promise.resolve().then(() => _interopRequireWildcard(require('./contextual-ee')));
@@ -156,7 +156,7 @@ describe('event-emitter abort', () => {
   });
 });
 describe('event-emitter emit', () => {
-  it('should execute the listener', async () => {
+  test('should execute the listener', async () => {
     const {
       ee
     } = await Promise.resolve().then(() => _interopRequireWildcard(require('./contextual-ee')));
@@ -167,7 +167,7 @@ describe('event-emitter emit', () => {
     ee.emit(eventType, eventArgs);
     expect(mockListener).toHaveBeenCalledWith(eventArgs[0], eventArgs[1], eventArgs[2]);
   });
-  it('should not execute the listener after removal', async () => {
+  test('should not execute the listener after removal', async () => {
     const {
       ee
     } = await Promise.resolve().then(() => _interopRequireWildcard(require('./contextual-ee')));
@@ -180,7 +180,7 @@ describe('event-emitter emit', () => {
     ee.emit(eventType, eventArgs);
     expect(mockListener).toHaveBeenCalledTimes(1);
   });
-  it('should return early if global event-emitter is aborted', async () => {
+  test('should return early if global event-emitter is aborted', async () => {
     const {
       ee
     } = await Promise.resolve().then(() => _interopRequireWildcard(require('./contextual-ee')));
@@ -195,7 +195,7 @@ describe('event-emitter emit', () => {
     ee.emit(eventType, eventArgs);
     expect(mockListener).toHaveBeenCalledTimes(0);
   });
-  it('should still emit if global event-emitter is aborted but force flag is true', async () => {
+  test('should still emit if global event-emitter is aborted but force flag is true', async () => {
     const {
       ee
     } = await Promise.resolve().then(() => _interopRequireWildcard(require('./contextual-ee')));
@@ -211,7 +211,7 @@ describe('event-emitter emit', () => {
     scopeEE.emit(eventType, eventArgs, {}, true);
     expect(mockScopeListener).toHaveBeenCalledTimes(1);
   });
-  it('should bubble the event if bubble flag is true', async () => {
+  test('should bubble the event if bubble flag is true', async () => {
     const {
       ee
     } = await Promise.resolve().then(() => _interopRequireWildcard(require('./contextual-ee')));
@@ -226,7 +226,7 @@ describe('event-emitter emit', () => {
     expect(mockScopeListener).toHaveBeenCalledTimes(1);
     expect(mockListener).toHaveBeenCalledTimes(1);
   });
-  it('should not bubble the event if bubble flag is false', async () => {
+  test('should not bubble the event if bubble flag is false', async () => {
     const {
       ee
     } = await Promise.resolve().then(() => _interopRequireWildcard(require('./contextual-ee')));
@@ -241,7 +241,7 @@ describe('event-emitter emit', () => {
     expect(mockScopeListener).toHaveBeenCalledTimes(1);
     expect(mockListener).not.toHaveBeenCalled();
   });
-  it('should buffer the event on the scoped event-emitter', async () => {
+  test('should buffer the event on the scoped event-emitter', async () => {
     const {
       ee
     } = await Promise.resolve().then(() => _interopRequireWildcard(require('./contextual-ee')));

package/dist/cjs/common/harvest/harvest-scheduler.js

@@ -18,6 +18,17 @@ var _config = require("../config/config");
  * Periodically invokes harvest calls and handles retries
  */
 class HarvestScheduler extends _sharedContext.SharedContext {
+  /**
+     * Create a HarvestScheduler
+     * @param {string} endpoint - The base BAM endpoint name -- ex. 'events'
+     * @param {object} opts - The options used to configure the HarvestScheduler
+     * @param {Function} opts.onFinished - The callback to be fired when a harvest has finished
+     * @param {Function} opts.getPayload - A callback which can be triggered to return a payload for harvesting
+     * @param {number} opts.retryDelay - The number of seconds to wait before retrying after a network failure
+     * @param {boolean} opts.raw - Use a prefabricated payload shape as the harvest payload without the need for formatting
+     * @param {string} opts.customUrl - A custom url that falls outside of the shape of the standard BAM harvester url pattern.  Will use directly instead of concatenating various pieces
+     * @param {*} parent - The parent object, whose state can be passed into SharedContext
+     */
   constructor(endpoint, opts, parent) {
     super(parent); // gets any allowed properties from the parent and stores them in `sharedContext`
     this.endpoint = endpoint;
@@ -79,7 +90,12 @@ class HarvestScheduler extends _sharedContext.SharedContext {
       var payload = this.opts.getPayload({
         retry: retry
       });
-      if (!payload) return;
+      if (!payload) {
+        if (this.started) {
+          this.scheduleHarvest();
+        }
+        return;
+      }
       payload = Object.prototype.toString.call(payload) === '[object Array]' ? payload : [payload];
       harvests.push(...payload);
     }
@@ -101,9 +117,8 @@ class HarvestScheduler extends _sharedContext.SharedContext {
         opts,
         submitMethod,
         cbFinished: onHarvestFinished,
-        includeBaseParams: this.opts.includeBaseParams,
         customUrl: this.opts.customUrl,
-        gzip: this.opts.gzip
+        raw: this.opts.raw
       });
     });
     if (this.started) {

package/dist/cjs/common/harvest/harvest-scheduler.test.js

@@ -0,0 +1,39 @@
+"use strict";
+
+var _init = require("../config/state/init");
+var _harvestScheduler = require("./harvest-scheduler");
+describe('runHarvest', () => {
+  test('should re-schedule harvest even if there is no accumulated data', () => {
+    (0, _init.setConfiguration)('asdf', {});
+    const scheduler = new _harvestScheduler.HarvestScheduler('events', {
+      getPayload: jest.fn()
+    }, {
+      agentIdentifier: 'asdf',
+      ee: {
+        on: jest.fn()
+      }
+    });
+    scheduler.started = true;
+    jest.spyOn(scheduler, 'scheduleHarvest');
+    scheduler.runHarvest();
+    expect(scheduler.opts.getPayload()).toBeFalsy();
+    expect(scheduler.scheduleHarvest).toHaveBeenCalledTimes(1);
+  });
+  test('should also re-schedule harvest if there is accumulated data', () => {
+    (0, _init.setConfiguration)('asdf', {});
+    const scheduler = new _harvestScheduler.HarvestScheduler('events', {
+      getPayload: jest.fn().mockImplementation(() => 'payload')
+    }, {
+      agentIdentifier: 'asdf',
+      ee: {
+        on: jest.fn()
+      }
+    });
+    scheduler.started = true;
+    scheduler.harvest._send = () => {};
+    jest.spyOn(scheduler, 'scheduleHarvest');
+    scheduler.runHarvest();
+    expect(scheduler.opts.getPayload()).toBeTruthy();
+    expect(scheduler.scheduleHarvest).toHaveBeenCalledTimes(1);
+  });
+});

package/dist/cjs/common/harvest/harvest.js

@@ -125,13 +125,13 @@ class Harvest extends _sharedContext.SharedContext {
       submitMethod,
       cbFinished,
       customUrl,
-      gzip,
+      raw,
       includeBaseParams = true
     } = _ref;
     var info = (0, _config.getInfo)(this.sharedContext.agentIdentifier);
     if (!info.errorBeacon) return false;
     var agentRuntime = (0, _config.getRuntime)(this.sharedContext.agentIdentifier);
-    if (!payload.body) {
+    if (!payload.body && !opts?.sendEmptyBody) {
       // no payload body? nothing to send, just run onfinish stuff and return
       if (cbFinished) {
         cbFinished({
@@ -140,16 +140,18 @@ class Harvest extends _sharedContext.SharedContext {
       }
       return false;
     }
-    var url = customUrl || this.getScheme() + '://' + info.errorBeacon + '/' + endpoint + '/1/' + info.licenseKey + '?';
-    var baseParams = includeBaseParams ? this.baseQueryString() : '';
-    var params = payload.qs ? (0, _encode.obj)(payload.qs, agentRuntime.maxBytes) : '';
+    let url = '';
+    if (customUrl) url = customUrl;else if (raw) url = "".concat(this.getScheme(), "://").concat(info.errorBeacon, "/").concat(endpoint);else url = "".concat(this.getScheme(), "://").concat(info.errorBeacon).concat(endpoint !== 'rum' ? "/".concat(endpoint) : '', "/1/").concat(info.licenseKey);
+    var baseParams = !raw && includeBaseParams ? this.baseQueryString() : '';
+    var payloadParams = payload.qs ? (0, _encode.obj)(payload.qs, agentRuntime.maxBytes) : '';
     if (!submitMethod) {
       submitMethod = getSubmitMethod(endpoint, opts);
     }
     var method = submitMethod.method;
     var useBody = submitMethod.useBody;
     var body;
-    var fullUrl = url + baseParams + params;
+    var fullUrl = "".concat(url, "?").concat(baseParams).concat(payloadParams);
+    const gzip = payload?.qs?.content_encoding === 'gzip';
     if (!gzip) {
       if (useBody && endpoint === 'events') {
         body = payload.body.e;
@@ -165,25 +167,10 @@ class Harvest extends _sharedContext.SharedContext {
     // Get query bytes harvested per endpoint as a supportability metric. See metrics aggregator (on unload).
     agentRuntime.queryBytesSent[endpoint] = (agentRuntime.queryBytesSent[endpoint] || 0) + fullUrl.split('?').slice(-1)[0]?.length || 0;
     const headers = [];
-    if (gzip) {
-      headers.push({
-        key: 'content-type',
-        value: 'application/json'
-      });
-      headers.push({
-        key: 'X-Browser-Monitoring-Key',
-        value: info.licenseKey
-      });
-      headers.push({
-        key: 'Content-Encoding',
-        value: 'gzip'
-      });
-    } else {
-      headers.push({
-        key: 'content-type',
-        value: 'text/plain'
-      });
-    }
+    headers.push({
+      key: 'content-type',
+      value: 'text/plain'
+    });
 
     /* Since workers don't support sendBeacon right now, or Image(), they can only use XHR method.
         Because they still do permit synch XHR, the idea is that at final harvest time (worker is closing),
@@ -263,18 +250,11 @@ class Harvest extends _sharedContext.SharedContext {
   }
 }
 exports.Harvest = Harvest;
-function or(a, b) {
-  return a || b;
-}
 function getSubmitMethod(endpoint, opts) {
   opts = opts || {};
   var method;
   var useBody;
-  if (opts.needResponse) {
-    // currently: only STN needs a response
-    useBody = true;
-    method = _submitData.submitData.xhr;
-  } else if (opts.unload && _globalScope.isBrowserScope) {
+  if (opts.unload && _globalScope.isBrowserScope) {
     // all the features' final harvest; neither methods work outside window context
     useBody = haveSendBeacon;
     method = haveSendBeacon ? _submitData.submitData.beacon : _submitData.submitData.img; // really only IE doesn't have Beacon API for web browsers
@@ -304,7 +284,7 @@ function createAccumulator() {
   var accumulator = {};
   var hasData = false;
   return function (key, val) {
-    if (val !== null && val !== undefined && val.length) {
+    if (val !== null && val !== undefined && val.toString()?.length) {
       accumulator[key] = val;
       hasData = true;
     }

package/dist/cjs/common/harvest/harvest.test.js

@@ -0,0 +1,224 @@
+"use strict";
+
+var _submitData = require("../util/submit-data");
+var _harvest = require("./harvest");
+jest.mock('../context/shared-context', () => ({
+  __esModule: true,
+  SharedContext: function () {
+    this.sharedContext = {
+      agentIdentifier: 'abcd'
+    };
+  }
+}));
+jest.mock('../config/config', () => ({
+  __esModule: true,
+  getConfigurationValue: jest.fn(),
+  getInfo: jest.fn().mockReturnValue({
+    errorBeacon: 'example.com',
+    licenseKey: 'abcd'
+  }),
+  getRuntime: jest.fn().mockReturnValue({
+    bytesSent: {},
+    queryBytesSent: {}
+  })
+}));
+jest.mock('../util/submit-data', () => ({
+  __esModule: true,
+  submitData: {
+    xhr: jest.fn(() => ({
+      addEventListener: jest.fn()
+    })),
+    beacon: jest.fn(),
+    img: jest.fn()
+  }
+}));
+describe('sendX', () => {
+  test.each([null, undefined, false])('should not send request when body is empty and sendEmptyBody is %s', sendEmptyBody => {
+    const sendCallback = jest.fn();
+    const harvester = new _harvest.Harvest();
+    harvester.on('jserrors', () => ({
+      body: {},
+      qs: {}
+    }));
+    harvester.sendX({
+      endpoint: 'jserrors',
+      cbFinished: sendCallback
+    });
+    expect(sendCallback).toHaveBeenCalledWith({
+      sent: false
+    });
+    expect(_submitData.submitData.xhr).not.toHaveBeenCalled();
+    expect(_submitData.submitData.img).not.toHaveBeenCalled();
+    expect(_submitData.submitData.beacon).not.toHaveBeenCalled();
+  });
+  test('should send request when body is empty and sendEmptyBody is true', () => {
+    const harvester = new _harvest.Harvest();
+    harvester.on('jserrors', () => ({
+      body: {},
+      qs: {}
+    }));
+    harvester.sendX({
+      endpoint: 'jserrors',
+      opts: {
+        sendEmptyBody: true
+      },
+      cbFinished: jest.fn()
+    });
+    expect(_submitData.submitData.xhr).toHaveBeenCalledWith(expect.objectContaining({
+      url: expect.stringContaining('https://example.com/jserrors/1/abcd?'),
+      body: undefined
+    }));
+    expect(_submitData.submitData.img).not.toHaveBeenCalled();
+    expect(_submitData.submitData.beacon).not.toHaveBeenCalled();
+  });
+  test.each([null, undefined, []])('should remove %s values from the body and query string when sending', emptyValue => {
+    const harvester = new _harvest.Harvest();
+    harvester.on('jserrors', () => ({
+      body: {
+        bar: 'foo',
+        empty: emptyValue
+      },
+      qs: {
+        foo: 'bar',
+        empty: emptyValue
+      }
+    }));
+    harvester.sendX({
+      endpoint: 'jserrors',
+      cbFinished: jest.fn()
+    });
+    expect(_submitData.submitData.xhr).toHaveBeenCalledWith(expect.objectContaining({
+      url: expect.stringContaining('&foo=bar'),
+      body: JSON.stringify({
+        bar: 'foo'
+      })
+    }));
+    expect(_submitData.submitData.xhr).toHaveBeenCalledWith(expect.objectContaining({
+      url: expect.not.stringContaining('&empty'),
+      body: expect.not.stringContaining('empty')
+    }));
+    expect(_submitData.submitData.img).not.toHaveBeenCalled();
+    expect(_submitData.submitData.beacon).not.toHaveBeenCalled();
+  });
+  test.each([1, false, true])('should not remove value %s (when it doesn\'t have a length) from the body and query string when sending', nonStringValue => {
+    const harvester = new _harvest.Harvest();
+    harvester.on('jserrors', () => ({
+      body: {
+        bar: 'foo',
+        nonString: nonStringValue
+      },
+      qs: {
+        foo: 'bar',
+        nonString: nonStringValue
+      }
+    }));
+    harvester.sendX({
+      endpoint: 'jserrors',
+      cbFinished: jest.fn()
+    });
+    expect(_submitData.submitData.xhr).toHaveBeenCalledWith(expect.objectContaining({
+      url: expect.stringContaining("&nonString=".concat(nonStringValue)),
+      body: JSON.stringify({
+        bar: 'foo',
+        nonString: nonStringValue
+      })
+    }));
+    expect(_submitData.submitData.img).not.toHaveBeenCalled();
+    expect(_submitData.submitData.beacon).not.toHaveBeenCalled();
+  });
+});
+describe('send', () => {
+  test.each([null, undefined, false])('should not send request when body is empty and sendEmptyBody is %s', sendEmptyBody => {
+    const sendCallback = jest.fn();
+    const harvester = new _harvest.Harvest();
+    harvester.send({
+      endpoint: 'rum',
+      payload: {
+        qs: {},
+        body: {}
+      },
+      opts: {
+        sendEmptyBody
+      },
+      cbFinished: sendCallback
+    });
+    expect(sendCallback).toHaveBeenCalledWith({
+      sent: false
+    });
+    expect(_submitData.submitData.xhr).not.toHaveBeenCalled();
+    expect(_submitData.submitData.img).not.toHaveBeenCalled();
+    expect(_submitData.submitData.beacon).not.toHaveBeenCalled();
+  });
+  test('should send request when body is empty and sendEmptyBody is true', () => {
+    const harvester = new _harvest.Harvest();
+    harvester.send({
+      endpoint: 'rum',
+      payload: {
+        qs: {},
+        body: {}
+      },
+      opts: {
+        sendEmptyBody: true
+      }
+    });
+    expect(_submitData.submitData.xhr).toHaveBeenCalledWith(expect.objectContaining({
+      url: expect.stringContaining('https://example.com/1/abcd?'),
+      body: undefined
+    }));
+    expect(_submitData.submitData.img).not.toHaveBeenCalled();
+    expect(_submitData.submitData.beacon).not.toHaveBeenCalled();
+  });
+  test.each([null, undefined, []])('should remove %s values from the body and query string when sending', emptyValue => {
+    const harvester = new _harvest.Harvest();
+    harvester.send({
+      endpoint: 'rum',
+      payload: {
+        qs: {
+          foo: 'bar',
+          empty: emptyValue
+        },
+        body: {
+          bar: 'foo',
+          empty: emptyValue
+        }
+      }
+    });
+    expect(_submitData.submitData.xhr).toHaveBeenCalledWith(expect.objectContaining({
+      url: expect.stringContaining('&foo=bar'),
+      body: JSON.stringify({
+        bar: 'foo'
+      })
+    }));
+    expect(_submitData.submitData.xhr).toHaveBeenCalledWith(expect.objectContaining({
+      url: expect.not.stringContaining('&empty'),
+      body: expect.not.stringContaining('empty')
+    }));
+    expect(_submitData.submitData.img).not.toHaveBeenCalled();
+    expect(_submitData.submitData.beacon).not.toHaveBeenCalled();
+  });
+  test.each([1, false, true])('should not remove value %s (when it doesn\'t have a length) from the body and query string when sending', nonStringValue => {
+    const harvester = new _harvest.Harvest();
+    harvester.send({
+      endpoint: 'rum',
+      payload: {
+        qs: {
+          foo: 'bar',
+          nonString: nonStringValue
+        },
+        body: {
+          bar: 'foo',
+          nonString: nonStringValue
+        }
+      }
+    });
+    expect(_submitData.submitData.xhr).toHaveBeenCalledWith(expect.objectContaining({
+      url: expect.stringContaining("&nonString=".concat(nonStringValue)),
+      body: JSON.stringify({
+        bar: 'foo',
+        nonString: nonStringValue
+      })
+    }));
+    expect(_submitData.submitData.img).not.toHaveBeenCalled();
+    expect(_submitData.submitData.beacon).not.toHaveBeenCalled();
+  });
+});

package/dist/cjs/common/url/encode.js

@@ -52,11 +52,11 @@ function obj(payload, maxBytes) {
     var intermediate = [];
     var next;
     var i;
-    if (typeof dataArray === 'string') {
+    if (typeof dataArray === 'string' || !Array.isArray(dataArray) && dataArray !== null && dataArray !== undefined && dataArray.toString().length) {
       next = '&' + feature + '=' + qs(dataArray);
       total += next.length;
       result += next;
-    } else if (dataArray.length) {
+    } else if (Array.isArray(dataArray) && dataArray.length) {
       total += 9;
       for (i = 0; i < dataArray.length; i++) {
         next = qs((0, _stringify.stringify)(dataArray[i]));

package/dist/cjs/common/util/console.test.js

@@ -0,0 +1,30 @@
+"use strict";
+
+var _console = require("./console");
+beforeEach(() => {
+  console.warn = jest.fn();
+});
+afterEach(() => {
+  jest.restoreAllMocks();
+});
+describe('warn', () => {
+  test('should not call console.warn if it is not a function', () => {
+    const spy = jest.spyOn(console, 'warn');
+    console.warn = undefined;
+    (0, _console.warn)('test message');
+    expect(spy).not.toHaveBeenCalled();
+  });
+  test('should call console.warn with a prefixed message', () => {
+    (0, _console.warn)('test message');
+    expect(console.warn).toHaveBeenCalledWith('New Relic: test message');
+  });
+  test('should call console.warn with secondary argument if provided', () => {
+    const secondary = 'secondary value';
+    (0, _console.warn)('test message', secondary);
+    expect(console.warn).toHaveBeenCalledWith(secondary);
+  });
+  test('should not call console.warn with secondary argument if not provided', () => {
+    (0, _console.warn)('test message');
+    expect(console.warn).toHaveBeenCalledTimes(1);
+  });
+});

package/dist/cjs/common/util/get-or-set.js

@@ -11,7 +11,14 @@ exports.getOrSet = getOrSet;
 
 var has = Object.prototype.hasOwnProperty;
 
-// Always returns the current value of obj[prop], even if it has to set it first
+/**
+ * Always returns the current value of obj[prop], even if it has to set it first. Sets properties as non-enumerable if possible.
+ *
+ * @param {Object} obj - The object to get or set the property on.
+ * @param {string} prop - The name of the property.
+ * @param {Function} getVal - A function that returns the value to be set if the property does not exist.
+ * @returns {*} The value of the property in the object.
+ */
 function getOrSet(obj, prop, getVal) {
   // If the value exists return it.
   if (has.call(obj, prop)) return obj[prop];

package/dist/cjs/common/util/get-or-set.test.js

@@ -0,0 +1,47 @@
+"use strict";
+
+var _getOrSet = require("./get-or-set");
+test('should return the current value of an existing property', () => {
+  const obj = {
+    foo: 'bar'
+  };
+  const prop = 'foo';
+  const getVal = jest.fn();
+  const result = (0, _getOrSet.getOrSet)(obj, prop, getVal);
+  expect(result).toBe('bar');
+  expect(getVal).not.toHaveBeenCalled();
+});
+test('should set and return the value from getVal if the property does not exist', () => {
+  const obj = {};
+  const prop = 'foo';
+  const getVal = jest.fn().mockReturnValue('baz');
+  const result = (0, _getOrSet.getOrSet)(obj, prop, getVal);
+  expect(result).toBe('baz');
+  expect(getVal).toHaveBeenCalled();
+  expect(obj.foo).toBe('baz');
+});
+test('should set the property as non-enumerable if Object.defineProperty is supported', () => {
+  const obj = {};
+  const prop = 'foo';
+  const getVal = jest.fn().mockReturnValue('baz');
+  jest.spyOn(Object, 'defineProperty');
+  const result = (0, _getOrSet.getOrSet)(obj, prop, getVal);
+  expect(result).toBe('baz');
+  expect(Object.defineProperty).toHaveBeenCalledWith(obj, prop, {
+    value: 'baz',
+    writable: true,
+    enumerable: false
+  });
+});
+test('should set the property from getVal if Object.defineProperty and Object.keys are not supported', () => {
+  const obj = {};
+  const prop = 'foo';
+  const getVal = jest.fn(() => 'baz');
+  const originalFn = Object.defineProperty;
+  Object.defineProperty = null;
+  const result = (0, _getOrSet.getOrSet)(obj, prop, getVal);
+  expect(result).toBe('baz');
+  expect(obj.foo).toBe('baz');
+  expect(Object.prototype.propertyIsEnumerable.call(obj, 'foo')).toBe(true);
+  Object.defineProperty = originalFn;
+});