prebid.js 9.46.0 → 9.48.0

package/test/spec/modules/contxtfulBidAdapter_spec.js

@@ -1,4 +1,4 @@
-import { spec } from 'modules/contxtfulBidAdapter.js';
+import { spec, safeStringify } from 'modules/contxtfulBidAdapter.js';
 import { newBidder } from 'src/adapters/bidderFactory.js';
 import { config } from 'src/config.js';
 import * as ajax from 'src/ajax.js';
@@ -19,6 +19,514 @@ describe('contxtful bid adapter', function () {
     sandbox.restore();
   });
 
+  describe('SafeStringify function', function () {
+    it('should stringify normal objects successfully', function () {
+      const normalObject = { name: 'test', value: 123, active: true };
+      const result = safeStringify(normalObject);
+      expect(result).to.equal('{"name":"test","value":123,"active":true}');
+    });
+
+    it('should handle arrays correctly', function () {
+      const array = [1, 2, 'three', { nested: true }];
+      const result = safeStringify(array);
+      expect(result).to.equal('[1,2,"three",{"nested":true}]');
+    });
+
+    it('should handle circular references', function () {
+      const objA = { name: 'A' };
+      const objB = { name: 'B', ref: objA };
+      objA.ref = objB; // Create circular reference
+
+      const result = safeStringify(objA);
+      expect(result).to.be.a('string');
+      expect(result).to.include('[Circular]');
+      expect(result).to.include('"name":"A"');
+    });
+
+    it('should handle functions by omitting them (standard JSON.stringify behavior)', function () {
+      const objWithFunction = {
+        name: 'test',
+        method: function () { return 'hello'; },
+        arrow: () => 'world'
+      };
+
+      const result = safeStringify(objWithFunction);
+      expect(result).to.equal('{"name":"test"}');
+      expect(result).to.not.include('[Function]');
+    });
+
+    it('should handle undefined values by omitting them (standard JSON.stringify behavior)', function () {
+      const objWithUndefined = {
+        name: 'test',
+        undefinedValue: undefined,
+        nullValue: null
+      };
+
+      const result = safeStringify(objWithUndefined);
+      expect(result).to.equal('{"name":"test","nullValue":null}');
+      expect(result).to.not.include('[Undefined]');
+    });
+
+    it('should handle mixed complex objects', function () {
+      const complexObj = {
+        string: 'test',
+        number: 42,
+        boolean: true,
+        nullVal: null,
+        undefinedVal: undefined,
+        func: function () { return 'test'; },
+        nested: {
+          array: [1, 2, function () { }],
+          date: new Date('2023-01-01')
+        }
+      };
+
+      const result = safeStringify(complexObj);
+      expect(result).to.be.a('string');
+      expect(result).to.include('"string":"test"');
+      expect(result).to.include('"number":42');
+      // Functions and undefined values are omitted by standard JSON.stringify
+      expect(result).to.not.include('[Function]');
+      expect(result).to.not.include('[Undefined]');
+    });
+
+    it('should handle nested circular references', function () {
+      const parent = { name: 'parent', children: [] };
+      const child1 = { name: 'child1', parent: parent };
+      const child2 = { name: 'child2', parent: parent };
+      parent.children.push(child1, child2);
+
+      const result = safeStringify(parent);
+      expect(result).to.be.a('string');
+      expect(result).to.include('[Circular]');
+      expect(result).to.include('"name":"parent"');
+    });
+
+    it('should handle empty objects and arrays', function () {
+      expect(safeStringify({})).to.equal('{}');
+      expect(safeStringify([])).to.equal('[]');
+    });
+
+    it('should handle primitive values', function () {
+      expect(safeStringify('string')).to.equal('"string"');
+      expect(safeStringify(123)).to.equal('123');
+      expect(safeStringify(true)).to.equal('true');
+      expect(safeStringify(null)).to.equal('null');
+    });
+
+    it('should handle Date objects', function () {
+      const date = new Date('2023-01-01T00:00:00.000Z');
+      const result = safeStringify(date);
+      expect(result).to.include('2023-01-01');
+    });
+
+    it('should handle bigint values by converting them to strings', function () {
+      const objWithBigInt = {
+        name: 'test',
+        bigNumber: BigInt('12345678901234567890'),
+        regularNumber: 123
+      };
+
+      const result = safeStringify(objWithBigInt);
+      expect(result).to.include('"bigNumber":"12345678901234567890"');
+      expect(result).to.include('"name":"test"');
+      expect(result).to.include('"regularNumber":123');
+    });
+
+    it('should handle objects with toJSON methods', function () {
+      const objWithToJSON = {
+        name: 'test',
+        toJSON: function () {
+          return { serialized: true };
+        }
+      };
+
+      const result = safeStringify(objWithToJSON);
+      expect(result).to.equal('{"serialized":true}');
+    });
+
+    it('should fall back to safeJSONEncode for completely unstringifiable objects', function () {
+      // Mock an object that breaks JSON.stringify even with replacer
+      const problematicObj = {};
+      Object.defineProperty(problematicObj, 'problematic', {
+        get: function () {
+          throw new Error('Cannot access this property');
+        },
+        enumerable: true
+      });
+
+      const result = safeStringify(problematicObj);
+      // Should not throw and should return a string
+      expect(result).to.be.a('string');
+    });
+
+    it('should handle browser Window objects safely', function () {
+      const objWithWindow = {
+        name: 'test',
+        windowRef: window
+      };
+
+      const result = safeStringify(objWithWindow);
+      expect(result).to.include('[Browser Object]');
+      expect(result).to.include('"name":"test"');
+    });
+
+    it('should handle objects with inaccessible properties', function () {
+      const problematicObj = {
+        name: 'test',
+        safeData: 'value',
+        normalProperty: 'normal'
+      };
+
+      // Instead of testing property access errors (which can break entire stringify),
+      // let's test that the function handles objects that contain browser objects
+      // which should be converted to [Inaccessible Object] or [Browser Object]
+      if (typeof window !== 'undefined') {
+        problematicObj.browserRef = window;
+      }
+
+      const result = safeStringify(problematicObj);
+      expect(result).to.be.a('string');
+      expect(result).to.include('"name":"test"');
+      expect(result).to.include('"safeData":"value"');
+      expect(result).to.include('"normalProperty":"normal"');
+
+      if (typeof window !== 'undefined') {
+        expect(result).to.include('[Browser Object]');
+      }
+    });
+
+    it('should handle mixed problematic objects', function () {
+      const mixedObj = {
+        normal: 'value',
+        windowRef: window,
+        circular: null
+      };
+      mixedObj.circular = mixedObj; // Create circular reference
+
+      const result = safeStringify(mixedObj);
+      expect(result).to.include('[Browser Object]');
+      expect(result).to.include('[Circular]');
+      expect(result).to.include('"normal":"value"');
+    });
+
+    it('should handle IMA3 video renderer objects safely', function () {
+      // Simulate the IMA3 video renderer object with simpler structure
+      const ima3RendererObj = {
+        url: "https://imasdk.googleapis.com/js/sdkloader/ima3.js",
+        renderNow: false,
+        cmd: [null],
+        someData: "test"
+      };
+
+      // Add a simple browser object reference that should be detected
+      if (typeof window !== 'undefined') {
+        ima3RendererObj.windowRef = window;
+      }
+
+      const result = safeStringify(ima3RendererObj);
+      expect(result).to.be.a('string');
+      expect(result).to.include('"url":"https://imasdk.googleapis.com/js/sdkloader/ima3.js"');
+      expect(result).to.include('"renderNow":false');
+      expect(result).to.include('"someData":"test"');
+      if (typeof window !== 'undefined') {
+        expect(result).to.include('[Browser Object]'); // for window reference
+      }
+    });
+
+    it('should handle complex nested objects with mixed browser elements', function () {
+      const complexBidData = {
+        bidId: 'test-bid-123',
+        adUnitCode: 'div-ad-unit',
+        cpm: 1.25,
+        currency: 'USD',
+        renderer: {
+          url: "https://imasdk.googleapis.com/js/sdkloader/ima3.js",
+          renderNow: false,
+          cmd: [null]
+        },
+        sizes: [[300, 250], [728, 90]]
+      };
+
+      // Add browser objects that should be detected by current implementation
+      if (typeof window !== 'undefined') {
+        complexBidData.windowContext = window;
+      }
+      if (typeof document !== 'undefined') {
+        complexBidData.documentRef = document;
+      }
+
+      const result = safeStringify(complexBidData);
+      expect(result).to.be.a('string');
+      expect(result).to.include('"bidId":"test-bid-123"');
+      expect(result).to.include('"cpm":1.25');
+      if (typeof window !== 'undefined' || typeof document !== 'undefined') {
+        expect(result).to.include('[Browser Object]');
+      }
+    });
+
+    it('should handle additional browser objects safely', function () {
+      const objWithBrowserObjects = {
+        name: 'test'
+      };
+
+      // Only test browser objects that are detected by current implementation
+      if (typeof window !== 'undefined') {
+        objWithBrowserObjects.windowRef = window;
+      }
+      if (typeof document !== 'undefined') {
+        objWithBrowserObjects.documentRef = document;
+      }
+
+      const result = safeStringify(objWithBrowserObjects);
+      expect(result).to.be.a('string');
+      expect(result).to.include('"name":"test"');
+
+      // Current implementation only detects Window, Document, HTMLElement, Node
+      // It doesn't detect navigator, location, etc. as browser objects
+      if (typeof window !== 'undefined' || typeof document !== 'undefined') {
+        expect(result).to.include('[Browser Object]');
+      }
+    });
+
+    it('should handle event objects and DOM-related objects', function () {
+      const objWithDOMObjects = {
+        bidId: 'test-123',
+        data: 'normal-data'
+      };
+
+      // Add DOM element if available in test environment
+      if (typeof document !== 'undefined') {
+        const div = document.createElement('div');
+        objWithDOMObjects.element = div;
+      }
+
+      // Simulate an event object
+      if (typeof Event !== 'undefined') {
+        try {
+          objWithDOMObjects.event = new Event('click');
+        } catch (e) {
+          // Some test environments might not support Event constructor
+          objWithDOMObjects.event = { type: 'click', target: null };
+        }
+      }
+
+      const result = safeStringify(objWithDOMObjects);
+      expect(result).to.be.a('string');
+      expect(result).to.include('"bidId":"test-123"');
+      expect(result).to.include('"data":"normal-data"');
+    });
+
+    it('should handle storage and web API objects safely', function () {
+      const objWithWebAPIs = {
+        name: 'test-data',
+        normalArray: [1, 2, 3]
+      };
+
+      // Add storage references if available
+      if (typeof globalThis.localStorage !== 'undefined') {
+        objWithWebAPIs.storage = globalThis.localStorage;
+      }
+
+      // Add Blob if available
+      if (typeof Blob !== 'undefined') {
+        try {
+          objWithWebAPIs.blob = new Blob(['test'], { type: 'text/plain' });
+        } catch (e) {
+          // Fallback if Blob not available in test environment
+        }
+      }
+
+      const result = safeStringify(objWithWebAPIs);
+      expect(result).to.be.a('string');
+      expect(result).to.include('"name":"test-data"');
+      expect(result).to.include('"normalArray":[1,2,3]');
+      // Should handle browser objects without throwing
+      expect(result).to.not.throw;
+    });
+
+    it('should detect browser objects using parent hierarchies and duck typing', function () {
+      const testObj = {
+        normalData: 'safe-value',
+        number: 42
+      };
+
+      // Add various types of browser objects that should be caught by parent classes
+      if (typeof document !== 'undefined') {
+        testObj.element = document.createElement('div'); // HTMLElement -> EventTarget
+        testObj.textNode = document.createTextNode('test'); // Text -> Node
+      }
+
+      // Add objects that should be caught by duck typing (constructor name patterns)
+      const mockObjects = [];
+
+      // Mock HTMLCanvasElement (constructor name contains 'HTML' and 'Canvas')
+      function HTMLCanvasElement() {}
+      const mockCanvas = Object.create(HTMLCanvasElement.prototype);
+      Object.defineProperty(mockCanvas, 'constructor', { value: HTMLCanvasElement });
+      testObj.mockCanvas = mockCanvas;
+
+      // Mock CSSStyleDeclaration (constructor name contains 'CSS')
+      function CSSStyleDeclaration() {}
+      const mockStyle = Object.create(CSSStyleDeclaration.prototype);
+      Object.defineProperty(mockStyle, 'constructor', { value: CSSStyleDeclaration });
+      testObj.mockStyle = mockStyle;
+
+      const result = safeStringify(testObj);
+      expect(result).to.be.a('string');
+      expect(result).to.include('"normalData":"safe-value"');
+      expect(result).to.include('"number":42');
+      expect(result).to.include('[Browser Object]');
+
+      // Should not contain the actual browser object data
+      expect(result).to.not.include('HTMLCanvasElement');
+      expect(result).to.not.include('CSSStyleDeclaration');
+    });
+
+    it('should detect objects with browser-like properties using duck typing', function () {
+      const testObj = {
+        safeData: 'value'
+      };
+
+      // Add actual browser objects that the current implementation can detect
+      if (typeof document !== 'undefined') {
+        const div = document.createElement('div');
+        testObj.element = div; // HTMLElement should be detected
+      }
+
+      if (typeof window !== 'undefined') {
+        testObj.windowRef = window; // Window should be detected
+      }
+
+      const result = safeStringify(testObj);
+      expect(result).to.be.a('string');
+      expect(result).to.include('"safeData":"value"');
+
+      // Only expect [Browser Object] if we actually added detectable browser objects
+      if (typeof document !== 'undefined' || typeof window !== 'undefined') {
+        expect(result).to.include('[Browser Object]');
+      }
+    });
+
+    it('should exclude specified keys when keysToExclude parameter is provided', function () {
+      const testObj = {
+        bidId: 'test-123',
+        cpm: 1.25,
+        renderer: {
+          url: 'https://example.com/renderer.js',
+          handlers: { onLoad: function() {} }
+        },
+        ad: '<div>Ad content</div>',
+        meta: {
+          advertiserDomains: ['example.com']
+        }
+      };
+
+      const result = safeStringify(testObj, ['renderer']);
+      expect(result).to.be.a('string');
+      expect(result).to.include('"bidId":"test-123"');
+      expect(result).to.include('"cpm":1.25');
+      expect(result).to.include('"ad":"<div>Ad content</div>"');
+      expect(result).to.include('[Excluded]'); // renderer should be excluded
+      expect(result).to.not.include('https://example.com/renderer.js');
+    });
+
+    it('should exclude multiple keys when multiple keys are specified', function () {
+      const testObj = {
+        bidId: 'test-456',
+        renderer: { url: 'renderer.js' },
+        ad: '<script>alert("ad")</script>',
+        privateData: 'sensitive',
+        normalData: 'safe'
+      };
+
+      const result = safeStringify(testObj, ['renderer', 'privateData']);
+      expect(result).to.be.a('string');
+      expect(result).to.include('"bidId":"test-456"');
+      expect(result).to.include('"normalData":"safe"');
+      expect(result).to.include('[Excluded]'); // Both excluded keys should show this
+      expect(result).to.not.include('renderer.js');
+      expect(result).to.not.include('sensitive');
+      // ad should still be included since it's not in exclude list
+      expect(result).to.include('"ad":"<script>alert(\\"ad\\")</script>"');
+    });
+
+    it('should exclude keys at any nesting level', function () {
+      const testObj = {
+        bid: {
+          id: 'test-789',
+          renderer: {
+            url: 'nested-renderer.js',
+            config: { timeout: 5000 }
+          },
+          meta: {
+            renderer: 'should also be excluded'
+          }
+        },
+        topLevel: 'value'
+      };
+
+      const result = safeStringify(testObj, ['renderer']);
+      expect(result).to.be.a('string');
+      expect(result).to.include('"id":"test-789"');
+      expect(result).to.include('"topLevel":"value"');
+      expect(result).to.include('[Excluded]'); // Both renderer keys should be excluded
+      expect(result).to.not.include('nested-renderer.js');
+      expect(result).to.not.include('should also be excluded');
+    });
+
+    it('should work correctly when keysToExclude is empty array', function () {
+      const testObj = {
+        bidId: 'test-empty',
+        renderer: { url: 'renderer.js' },
+        normalData: 'value'
+      };
+
+      const result = safeStringify(testObj, []);
+      expect(result).to.be.a('string');
+      expect(result).to.include('"bidId":"test-empty"');
+      expect(result).to.include('"normalData":"value"');
+      expect(result).to.include('renderer.js'); // Should not be excluded
+      expect(result).to.not.include('[Excluded]');
+    });
+
+    it('should work correctly when keysToExclude parameter is not provided', function () {
+      const testObj = {
+        bidId: 'test-no-param',
+        renderer: { url: 'renderer.js' },
+        normalData: 'value'
+      };
+
+      const result = safeStringify(testObj); // No second parameter
+      expect(result).to.be.a('string');
+      expect(result).to.include('"bidId":"test-no-param"');
+      expect(result).to.include('"normalData":"value"');
+      expect(result).to.include('renderer.js'); // Should not be excluded
+      expect(result).to.not.include('[Excluded]');
+    });
+
+    it('should combine key exclusion with browser object detection', function () {
+      const testObj = {
+        bidId: 'test-combined',
+        renderer: {
+          url: 'renderer.js',
+          windowRef: window,
+          handlers: {}
+        },
+        windowRef: window,
+        normalData: 'safe'
+      };
+
+      const result = safeStringify(testObj, ['renderer']);
+      expect(result).to.be.a('string');
+      expect(result).to.include('"bidId":"test-combined"');
+      expect(result).to.include('"normalData":"safe"');
+      expect(result).to.include('[Excluded]'); // renderer key excluded
+      expect(result).to.include('[Browser Object]'); // top-level windowRef detected as browser object
+      expect(result).to.not.include('renderer.js');
+    });
+  });
+
   describe('is a functions', function () {
     it('exists and is a function', function () {
       expect(adapter.callBids).to.exist.and.to.be.a('function');
@@ -32,44 +540,44 @@ describe('contxtful bid adapter', function () {
   });
 
   let bidRequests =
-  [
-    {
-      bidder: 'contxtful',
-      bidId: 'bId1',
-      custom_param_1: 'value_1',
-      transactionId: 'tId1',
-      params: {
-        bcat: ['cat1', 'cat2'],
-        badv: ['adv1', 'adv2'],
-      },
-      mediaTypes: {
-        banner: {
-          sizes: [
-            [300, 250],
-            [300, 600]
-          ]
+    [
+      {
+        bidder: 'contxtful',
+        bidId: 'bId1',
+        custom_param_1: 'value_1',
+        transactionId: 'tId1',
+        params: {
+          bcat: ['cat1', 'cat2'],
+          badv: ['adv1', 'adv2'],
         },
-      },
-      ortb2Imp: {
-        ext: {
-          tid: 't-id-test-1',
-          gpid: 'gpid-id-unitest-1'
+        mediaTypes: {
+          banner: {
+            sizes: [
+              [300, 250],
+              [300, 600]
+            ]
+          },
         },
-      },
-      schain: {
-        ver: '1.0',
-        complete: 1,
-        nodes: [
-          {
-            asi: 'schain-seller-1.com',
-            sid: '00001',
-            hp: 1,
+        ortb2Imp: {
+          ext: {
+            tid: 't-id-test-1',
+            gpid: 'gpid-id-unitest-1'
           },
-        ],
-      },
-      getFloor: () => ({ currency: 'CAD', floor: 10 }),
-    }
-  ];
+        },
+        schain: {
+          ver: '1.0',
+          complete: 1,
+          nodes: [
+            {
+              asi: 'schain-seller-1.com',
+              sid: '00001',
+              hp: 1,
+            },
+          ],
+        },
+        getFloor: () => ({ currency: 'CAD', floor: 10 }),
+      }
+    ];
 
   let expectedReceptivityData = {
     rx: RX_FROM_API,
@@ -121,7 +629,7 @@ describe('contxtful bid adapter', function () {
     uspConsent: '12345'
   };
 
-  describe('valid configuration', function() {
+  describe('valid configuration', function () {
     const theories = [
       [
         null,
@@ -175,7 +683,7 @@ describe('contxtful bid adapter', function () {
 
     it('uses a valid configuration and returns the right url', () => {
       config.setConfig({
-        contxtful: {customer: CUSTOMER, version: VERSION}
+        contxtful: { customer: CUSTOMER, version: VERSION }
       });
       const bidRequest = spec.buildRequests(bidRequests);
       expect(bidRequest.url).to.eq('https://' + BIDDER_ENDPOINT + `/${VERSION}/prebid/${CUSTOMER}/bid`)
@@ -183,7 +691,7 @@ describe('contxtful bid adapter', function () {
 
     it('will take specific ortb2 configuration parameters and returns it in ortb2 object', () => {
       config.setConfig({
-        contxtful: {customer: CUSTOMER, version: VERSION},
+        contxtful: { customer: CUSTOMER, version: VERSION },
       });
       const bidRequest = spec.buildRequests(bidRequests, bidderRequest);
       expect(bidRequest.data.ortb2.property_1).to.equal('string_val_1');
@@ -192,7 +700,7 @@ describe('contxtful bid adapter', function () {
 
   describe('valid bid request', function () {
     config.setConfig({
-      contxtful: {customer: CUSTOMER, version: VERSION},
+      contxtful: { customer: CUSTOMER, version: VERSION },
     });
     const bidRequest = spec.buildRequests(bidRequests, bidderRequest);
 
@@ -239,7 +747,7 @@ describe('contxtful bid adapter', function () {
     });
 
     it('will contains the receptivity value within the ortb2.user.data with contxtful name', () => {
-      let obtained_receptivity_data = bidRequest.data.ortb2.user.data.filter(function(userData) {
+      let obtained_receptivity_data = bidRequest.data.ortb2.user.data.filter(function (userData) {
         return userData.name == 'contxtful';
       });
       expect(obtained_receptivity_data.length).to.equal(1);
@@ -256,40 +764,40 @@ describe('contxtful bid adapter', function () {
 
   describe('valid bid request with no floor module', () => {
     let noFloorsBidRequests =
-    [
-      {
-        bidder: 'contxtful',
-        bidId: 'bId1',
-        transactionId: 'tId1',
-        mediaTypes: {
-          banner: {
-            sizes: [
-              [300, 250],
-              [300, 600]
-            ]
+      [
+        {
+          bidder: 'contxtful',
+          bidId: 'bId1',
+          transactionId: 'tId1',
+          mediaTypes: {
+            banner: {
+              sizes: [
+                [300, 250],
+                [300, 600]
+              ]
+            },
           },
         },
-      },
-      {
-        bidder: 'contxtful',
-        bidId: 'bId2',
-        transactionId: 'tId2',
-        mediaTypes: {
-          banner: {
-            sizes: [
-              [300, 250],
-              [300, 600]
-            ]
+        {
+          bidder: 'contxtful',
+          bidId: 'bId2',
+          transactionId: 'tId2',
+          mediaTypes: {
+            banner: {
+              sizes: [
+                [300, 250],
+                [300, 600]
+              ]
+            },
           },
+          params: {
+            bidfloor: 54
+          }
         },
-        params: {
-          bidfloor: 54
-        }
-      },
-    ];
+      ];
 
     config.setConfig({
-      contxtful: {customer: CUSTOMER, version: VERSION},
+      contxtful: { customer: CUSTOMER, version: VERSION },
     });
 
     const bidRequest = spec.buildRequests(noFloorsBidRequests, bidderRequest);
@@ -326,7 +834,7 @@ describe('contxtful bid adapter', function () {
       }
     ];
     config.setConfig({
-      contxtful: {customer: CUSTOMER, version: VERSION},
+      contxtful: { customer: CUSTOMER, version: VERSION },
     });
 
     const bidRequest = spec.buildRequests(bidRequests, bidderRequest);
@@ -403,24 +911,24 @@ describe('contxtful bid adapter', function () {
     describe('onTimeout callback', () => {
       it('will always call server with sendBeacon available', () => {
         config.setConfig({
-          contxtful: {customer: CUSTOMER, version: VERSION},
+          contxtful: { customer: CUSTOMER, version: VERSION },
         });
 
         const beaconStub = sandbox.stub(ajax, 'sendBeacon').returns(true);
         const ajaxStub = sandbox.stub(ajax, 'ajax');
-        expect(spec.onTimeout({'customData': 'customvalue'})).to.not.throw;
+        expect(spec.onTimeout({ 'customData': 'customvalue' })).to.not.throw;
         expect(beaconStub.called).to.be.true;
         expect(ajaxStub.called).to.be.false;
       });
 
       it('will always call server with sendBeacon not available', () => {
         config.setConfig({
-          contxtful: {customer: CUSTOMER, version: VERSION},
+          contxtful: { customer: CUSTOMER, version: VERSION },
         });
 
         const ajaxStub = sandbox.stub(ajax, 'ajax');
         const beaconStub = sandbox.stub(ajax, 'sendBeacon').returns(false);
-        expect(spec.onTimeout({'customData': 'customvalue'})).to.not.throw;
+        expect(spec.onTimeout({ 'customData': 'customvalue' })).to.not.throw;
         expect(beaconStub.called).to.be.true;
         expect(beaconStub.returned(false)).to.be.true;
         expect(ajaxStub.calledOnce).to.be.true;
@@ -430,12 +938,12 @@ describe('contxtful bid adapter', function () {
     describe('on onBidderError callback', () => {
       it('will always call server', () => {
         config.setConfig({
-          contxtful: {customer: CUSTOMER, version: VERSION},
+          contxtful: { customer: CUSTOMER, version: VERSION },
         });
 
         const ajaxStub = sandbox.stub(ajax, 'ajax');
         const beaconStub = sandbox.stub(ajax, 'sendBeacon').returns(false);
-        spec.onBidderError({'customData': 'customvalue'});
+        spec.onBidderError({ 'customData': 'customvalue' });
         expect(ajaxStub.calledOnce).to.be.true;
         expect(beaconStub.returned(false)).to.be.true;
       });
@@ -444,25 +952,41 @@ describe('contxtful bid adapter', function () {
     describe('on onBidWon callback', () => {
       it('will always call server', () => {
         config.setConfig({
-          contxtful: {customer: CUSTOMER, version: VERSION},
+          contxtful: { customer: CUSTOMER, version: VERSION },
         });
 
         const ajaxStub = sandbox.stub(ajax, 'ajax');
         const beaconStub = sandbox.stub(ajax, 'sendBeacon').returns(false);
-        spec.onBidWon({'customData': 'customvalue'});
+        spec.onBidWon({ 'customData': 'customvalue' });
         expect(ajaxStub.calledOnce).to.be.true;
         expect(beaconStub.returned(false)).to.be.true;
       });
+
+      it('will call the server even if payload contains circular reference', () => {
+        config.setConfig({
+          contxtful: { customer: CUSTOMER, version: VERSION },
+        });
+
+        const ajaxStub = sandbox.stub(ajax, 'ajax');
+        const beaconStub = sandbox.stub(ajax, 'sendBeacon').returns(false);
+        const payload = {
+          adata: "hello"
+        };
+        payload.ref = payload
+        spec.onBidWon(payload);
+        expect(ajaxStub.calledOnce).to.be.true;
+        expect(beaconStub.returned(false)).to.be.true;
+      })
     });
 
     describe('on onBidBillable callback', () => {
       it('will always call server when sampling rate is configured to be 1.0', () => {
         config.setConfig({
-          contxtful: {customer: CUSTOMER, version: VERSION, sampling: {onBidBillable: 1.0}},
+          contxtful: { customer: CUSTOMER, version: VERSION, sampling: { onBidBillable: 1.0 } },
         });
         const ajaxStub = sandbox.stub(ajax, 'ajax');
         const beaconStub = sandbox.stub(ajax, 'sendBeacon').returns(false);
-        spec.onBidBillable({'customData': 'customvalue'});
+        spec.onBidBillable({ 'customData': 'customvalue' });
         expect(ajaxStub.calledOnce).to.be.true;
         expect(beaconStub.returned(false)).to.be.true;
       });
@@ -471,11 +995,11 @@ describe('contxtful bid adapter', function () {
     describe('on onAdRenderSucceeded callback', () => {
       it('will always call server when sampling rate is configured to be 1.0', () => {
         config.setConfig({
-          contxtful: {customer: CUSTOMER, version: VERSION, sampling: {onAdRenderSucceeded: 1.0}},
+          contxtful: { customer: CUSTOMER, version: VERSION, sampling: { onAdRenderSucceeded: 1.0 } },
         });
         const ajaxStub = sandbox.stub(ajax, 'ajax');
         const beaconStub = sandbox.stub(ajax, 'sendBeacon').returns(false);
-        spec.onAdRenderSucceeded({'customData': 'customvalue'});
+        spec.onAdRenderSucceeded({ 'customData': 'customvalue' });
         expect(ajaxStub.calledOnce).to.be.true;
         expect(beaconStub.returned(false)).to.be.true;
       });