prebid.js 7.25.0 → 7.27.0

package/test/spec/modules/gdprEnforcement_spec.js

@@ -20,6 +20,7 @@ import * as events from 'src/events.js';
 import 'modules/appnexusBidAdapter.js'; // some tests expect this to be in the adapter registry
 import 'src/prebid.js'
 import {hook} from '../../../src/hook.js';
+import {VENDORLESS_GVLID} from '../../../src/consentHandler.js';
 
 describe('gdpr enforcement', function () {
   let nextFnSpy;
@@ -150,13 +151,13 @@ describe('gdpr enforcement', function () {
         }
       });
 
-      deviceAccessHook(nextFnSpy, false);
+      deviceAccessHook(nextFnSpy);
       expect(nextFnSpy.calledOnce).to.equal(true);
       let result = {
         hasEnforcementHook: true,
         valid: false
       }
-      sinon.assert.calledWith(nextFnSpy, false, undefined, undefined, result);
+      sinon.assert.calledWith(nextFnSpy, undefined, undefined, result);
     });
 
     it('should only check for consent for vendor exceptions when enforcePurpose and enforceVendor are false', function () {
@@ -178,8 +179,8 @@ describe('gdpr enforcement', function () {
       consentData.apiVersion = 2;
       gdprDataHandlerStub.returns(consentData);
 
-      deviceAccessHook(nextFnSpy, false, 1, 'appnexus');
-      deviceAccessHook(nextFnSpy, false, 5, 'rubicon');
+      deviceAccessHook(nextFnSpy, 1, 'appnexus');
+      deviceAccessHook(nextFnSpy, 5, 'rubicon');
       expect(logWarnSpy.callCount).to.equal(0);
     });
 
@@ -201,8 +202,8 @@ describe('gdpr enforcement', function () {
       consentData.apiVersion = 2;
       gdprDataHandlerStub.returns(consentData);
 
-      deviceAccessHook(nextFnSpy, false, 1, 'appnexus');
-      deviceAccessHook(nextFnSpy, false, 3, 'rubicon');
+      deviceAccessHook(nextFnSpy, 1, 'appnexus');
+      deviceAccessHook(nextFnSpy, 3, 'rubicon');
       expect(logWarnSpy.callCount).to.equal(1);
     });
 
@@ -224,13 +225,13 @@ describe('gdpr enforcement', function () {
       consentData.apiVersion = 2;
       gdprDataHandlerStub.returns(consentData);
 
-      deviceAccessHook(nextFnSpy, false, 1, 'appnexus');
+      deviceAccessHook(nextFnSpy, 1, 'appnexus');
       expect(nextFnSpy.calledOnce).to.equal(true);
       let result = {
         hasEnforcementHook: true,
         valid: true
       }
-      sinon.assert.calledWith(nextFnSpy, false, 1, 'appnexus', result);
+      sinon.assert.calledWith(nextFnSpy, 1, 'appnexus', result);
     });
 
     it('should use gvlMapping set by publisher', function() {
@@ -255,13 +256,13 @@ describe('gdpr enforcement', function () {
       consentData.apiVersion = 2;
       gdprDataHandlerStub.returns(consentData);
 
-      deviceAccessHook(nextFnSpy, false, 1, 'appnexus');
+      deviceAccessHook(nextFnSpy, 1, 'appnexus');
       expect(nextFnSpy.calledOnce).to.equal(true);
       let result = {
         hasEnforcementHook: true,
         valid: true
       }
-      sinon.assert.calledWith(nextFnSpy, false, 4, 'appnexus', result);
+      sinon.assert.calledWith(nextFnSpy, 4, 'appnexus', result);
       config.resetConfig();
     });
 
@@ -290,31 +291,17 @@ describe('gdpr enforcement', function () {
       consentData.apiVersion = 2;
       gdprDataHandlerStub.returns(consentData);
 
-      deviceAccessHook(nextFnSpy, false, 1, 'appnexus');
+      deviceAccessHook(nextFnSpy, 1, 'appnexus');
       expect(nextFnSpy.calledOnce).to.equal(true);
       let result = {
         hasEnforcementHook: true,
         valid: true
       }
-      sinon.assert.calledWith(nextFnSpy, false, 4, 'appnexus', result);
+      sinon.assert.calledWith(nextFnSpy, 4, 'appnexus', result);
       config.resetConfig();
       curBidderStub.restore();
     });
 
-    it(`should mark module as vendorless for rule validation when isVendorless = true and ${STRICT_STORAGE_ENFORCEMENT} is set`, () => {
-      setEnforcementConfig({
-        [STRICT_STORAGE_ENFORCEMENT]: true
-      });
-      let consentData = {
-        vendorData: staticConfig.consentData.getTCData,
-        gdprApplies: true
-      }
-      gdprDataHandlerStub.returns(consentData);
-      const validate = sinon.stub().callsFake(() => true);
-      deviceAccessHook(nextFnSpy, true, 123, 'mockModule', undefined, {validate});
-      expect(validate.args[0][4]('mockModule')).to.be.true;
-    });
-
     it(`should not enforce consent for vendorless modules if ${STRICT_STORAGE_ENFORCEMENT} is not set`, () => {
       setEnforcementConfig({});
       let consentData = {
@@ -323,9 +310,9 @@ describe('gdpr enforcement', function () {
       }
       gdprDataHandlerStub.returns(consentData);
       const validate = sinon.stub().callsFake(() => false);
-      deviceAccessHook(nextFnSpy, true, 123, 'mockModule', undefined, {validate});
+      deviceAccessHook(nextFnSpy, VENDORLESS_GVLID, 'mockModule', undefined, {validate});
       sinon.assert.callCount(validate, 0);
-      sinon.assert.calledWith(nextFnSpy, true, 123, 'mockModule', {hasEnforcementHook: true, valid: true});
+      sinon.assert.calledWith(nextFnSpy, VENDORLESS_GVLID, 'mockModule', {hasEnforcementHook: true, valid: true});
     })
   });
 
@@ -804,11 +791,12 @@ describe('gdpr enforcement', function () {
   });
 
   describe('validateRules', function () {
-    const createGdprRule = (purposeName = 'storage', enforcePurpose = true, enforceVendor = true, vendorExceptions = []) => ({
+    const createGdprRule = (purposeName = 'storage', enforcePurpose = true, enforceVendor = true, vendorExceptions = [], softVendorExceptions = []) => ({
       purpose: purposeName,
-      enforcePurpose: enforcePurpose,
-      enforceVendor: enforceVendor,
-      vendorExceptions: vendorExceptions
+      enforcePurpose,
+      enforceVendor,
+      vendorExceptions,
+      softVendorExceptions,
     });
 
     const consentData = {
@@ -922,6 +910,19 @@ describe('gdpr enforcement', function () {
       expect(isAllowed).to.equal(true);
     });
 
+    describe('when the vendor has a softVendorException', () => {
+      const gdprRule = createGdprRule('storage', true, true, [], [vendorBlockedModule]);
+
+      it('should return false if general consent was not given', () => {
+        const isAllowed = validateRules(gdprRule, consentDataWithPurposeConsentFalse, vendorBlockedModule, vendorBlockedGvlId);
+        expect(isAllowed).to.be.false;
+      })
+      it('should return true if general consent was given', () => {
+        const isAllowed = validateRules(gdprRule, consentData, vendorBlockedModule, vendorBlockedGvlId);
+        expect(isAllowed).to.be.true;
+      })
+    })
+
     describe('when module does not need vendor consent', () => {
       Object.entries({
         'storage': 1,
@@ -937,11 +938,9 @@ describe('gdpr enforcement', function () {
             it(`should be ${t} when purpose is ${t}`, () => {
               const consent = utils.deepClone(consentData);
               consent.vendorData.purpose.consents[purposeNo] = consentGiven;
-              // vendor consent (and gvlid) should be ignored
-              consent.vendorData.vendor.consents[123] = !consentGiven;
               // take legitimate interest out of the picture for this test
               consent.vendorData.purpose.legitimateInterests = {};
-              const actual = validateRules(rule, consent, 'mockModule', 123, () => true);
+              const actual = validateRules(rule, consent, 'mockModule', VENDORLESS_GVLID);
               expect(actual).to.equal(consentGiven);
             })
           })
@@ -1131,56 +1130,104 @@ describe('gdpr enforcement', function () {
     })
   });
 
-  describe('getGvlid', function() {
+  describe('gvlid resolution', () => {
     let sandbox;
-    let getGvlidForBidAdapterStub;
-    let getGvlidForUserIdModuleStub;
-    let getGvlidForAnalyticsAdapterStub;
     beforeEach(function() {
       sandbox = sinon.createSandbox();
-      getGvlidForBidAdapterStub = sandbox.stub(internal, 'getGvlidForBidAdapter');
-      getGvlidForUserIdModuleStub = sandbox.stub(internal, 'getGvlidForUserIdModule');
-      getGvlidForAnalyticsAdapterStub = sandbox.stub(internal, 'getGvlidForAnalyticsAdapter');
     });
+
     afterEach(function() {
       sandbox.restore();
       config.resetConfig();
     });
 
-    it('should return "null" if called without passing any argument', function() {
-      const gvlid = getGvlid();
-      expect(gvlid).to.equal(null);
-    });
+    describe('getGvlid', function() {
+      let getGvlidForBidAdapterStub;
+      let getGvlidForUserIdModuleStub;
+      let getGvlidForAnalyticsAdapterStub;
+      beforeEach(function() {
+        getGvlidForBidAdapterStub = sandbox.stub(internal, 'getGvlidForBidAdapter');
+        getGvlidForUserIdModuleStub = sandbox.stub(internal, 'getGvlidForUserIdModule');
+        getGvlidForAnalyticsAdapterStub = sandbox.stub(internal, 'getGvlidForAnalyticsAdapter');
+      });
 
-    it('should return "null" if GVL ID is not defined for any of these modules: Bid adapter, UserId submodule and Analytics adapter', function() {
-      getGvlidForBidAdapterStub.withArgs('moduleA').returns(null);
-      getGvlidForUserIdModuleStub.withArgs('moduleA').returns(null);
-      getGvlidForAnalyticsAdapterStub.withArgs('moduleA').returns(null);
+      it('should return "null" if called without passing any argument', function() {
+        const gvlid = getGvlid();
+        expect(gvlid).to.equal(null);
+      });
 
-      const gvlid = getGvlid('moduleA');
-      expect(gvlid).to.equal(null);
-    });
+      it('should return "null" if GVL ID is not defined for any of these modules: Bid adapter, UserId submodule and Analytics adapter', function() {
+        getGvlidForBidAdapterStub.withArgs('moduleA').returns(null);
+        getGvlidForUserIdModuleStub.withArgs('moduleA').returns(null);
+        getGvlidForAnalyticsAdapterStub.withArgs('moduleA').returns(null);
 
-    it('should return the GVL ID from gvlMapping if it is defined in setConfig', function() {
-      config.setConfig({
-        gvlMapping: {
-          moduleA: 1
-        }
+        const gvlid = getGvlid('moduleA');
+        expect(gvlid).to.equal(null);
+      });
+
+      it('should return the GVL ID from gvlMapping if it is defined in setConfig', function() {
+        config.setConfig({
+          gvlMapping: {
+            moduleA: 1
+          }
+        });
+
+        // Actual GVL ID for moduleA is 2, as defined on its the bidAdapter.js file.
+        getGvlidForBidAdapterStub.withArgs('moduleA').returns(2);
+
+        const gvlid = getGvlid('moduleA');
+        expect(gvlid).to.equal(1);
       });
 
-      // Actual GVL ID for moduleA is 2, as defined on its the bidAdapter.js file.
-      getGvlidForBidAdapterStub.withArgs('moduleA').returns(2);
+      it('should return the GVL ID by calling getGvlidForBidAdapter -> getGvlidForUserIdModule -> getGvlidForAnalyticsAdapter in sequence', function() {
+        getGvlidForBidAdapterStub.withArgs('moduleA').returns(null);
+        getGvlidForUserIdModuleStub.withArgs('moduleA').returns(null);
+        getGvlidForAnalyticsAdapterStub.withArgs('moduleA').returns(7);
+
+        expect(getGvlid('moduleA')).to.equal(7);
+      });
 
-      const gvlid = getGvlid('moduleA');
-      expect(gvlid).to.equal(1);
+      it('should pass extra arguments to analytics\' getGvlid', () => {
+        getGvlidForAnalyticsAdapterStub.withArgs('analytics').returns(321);
+        const cfg = {some: 'args'};
+        getGvlid('analytics', cfg);
+        sinon.assert.calledWith(getGvlidForAnalyticsAdapterStub, 'analytics', cfg);
+      });
     });
 
-    it('should return the GVL ID by calling getGvlidForBidAdapter -> getGvlidForUserIdModule -> getGvlidForAnalyticsAdapter in sequence', function() {
-      getGvlidForBidAdapterStub.withArgs('moduleA').returns(null);
-      getGvlidForUserIdModuleStub.withArgs('moduleA').returns(null);
-      getGvlidForAnalyticsAdapterStub.withArgs('moduleA').returns(7);
+    describe('getGvlidForAnalyticsAdapter', () => {
+      let getAnalyticsAdapter, adapter, adapterEntry;
+
+      beforeEach(() => {
+        adapter = {};
+        adapterEntry = {
+          adapter
+        };
+        getAnalyticsAdapter = sandbox.stub(adapterManager, 'getAnalyticsAdapter');
+        getAnalyticsAdapter.withArgs('analytics').returns(adapterEntry);
+      });
+
+      it('should return gvlid from adapterManager if defined', () => {
+        adapterEntry.gvlid = 123;
+        adapter.gvlid = 321
+        expect(internal.getGvlidForAnalyticsAdapter('analytics')).to.equal(123);
+      });
+
+      it('should return gvlid from adapter if defined', () => {
+        adapter.gvlid = 321;
+        expect(internal.getGvlidForAnalyticsAdapter('analytics')).to.equal(321);
+      });
 
-      expect(getGvlid('moduleA')).to.equal(7);
+      it('should invoke adapter.gvlid if it\'s a function', () => {
+        adapter.gvlid = (cfg) => cfg.k
+        const cfg = {k: 231};
+        expect(internal.getGvlidForAnalyticsAdapter('analytics', cfg)).to.eql(231);
+      });
+
+      it('should not choke if adapter gvlid fn throws', () => {
+        adapter.gvlid = () => { throw new Error(); };
+        expect(internal.getGvlidForAnalyticsAdapter('analytics')).to.not.be.ok;
+      });
     });
-  });
+  })
 });

package/test/spec/modules/genericAnalyticsAdapter_spec.js

@@ -0,0 +1,284 @@
+import {defaultHandler, GenericAnalytics} from '../../../modules/genericAnalyticsAdapter.js';
+import * as events from 'src/events.js';
+import * as CONSTANTS from 'src/constants.json';
+
+const {AUCTION_INIT, BID_RESPONSE} = CONSTANTS.EVENTS;
+
+describe('Generic analytics', () => {
+  describe('adapter', () => {
+    let adapter, sandbox, clock;
+    beforeEach(() => {
+      sandbox = sinon.sandbox.create();
+      sandbox.stub(events, 'getEvents').returns([]);
+      clock = sandbox.useFakeTimers();
+      adapter = new GenericAnalytics();
+    });
+
+    afterEach(() => {
+      adapter.disableAnalytics();
+      sandbox.restore();
+    });
+
+    describe('configuration', () => {
+      it('should be accepted if valid', () => {
+        adapter.enableAnalytics({
+          options: {
+            url: 'mock',
+            method: 'GET',
+            batchSize: 123,
+            batchDelay: 321
+          }
+        });
+        expect(adapter.enabled).to.be.true;
+      });
+
+      describe('should not work if', () => {
+        afterEach(function() {
+          expect(adapter.enabled).to.equal(false, this.currentTest.title);
+        });
+
+        it('neither handler nor url are specified', () => {
+          adapter.enableAnalytics({});
+        });
+
+        ['batchSize', 'batchDelay', 'handler'].forEach(option => {
+          it(`${option} is not valid`, () => {
+            adapter.enableAnalytics({
+              options: {
+                url: 'mock',
+                [option]: false
+              }
+            });
+          });
+        });
+
+        it('method is not GET or POST', () => {
+          adapter.enableAnalytics({
+            options: {
+              url: 'mock',
+              method: 'PATCH'
+            }
+          });
+        });
+
+        it('events is not an object', () => {
+          adapter.enableAnalytics({
+            options: {
+              url: 'mock',
+              events: null
+            }
+          });
+        });
+
+        it('events\' properties are not functions', () => {
+          adapter.enableAnalytics({
+            options: {
+              url: 'mock',
+              events: {
+                bidResponse: null
+              }
+            }
+          });
+        });
+      });
+    });
+
+    describe('when handler is specified', () => {
+      let handler;
+      beforeEach(() => {
+        handler = sinon.stub();
+      });
+
+      it('should collect events in batches, and call handler', () => {
+        adapter.enableAnalytics({
+          options: {
+            handler,
+            batchSize: 2
+          }
+        });
+        events.emit(AUCTION_INIT, {i: 0});
+        sinon.assert.notCalled(handler);
+        events.emit(BID_RESPONSE, {i: 0});
+        sinon.assert.calledWith(handler, sinon.match((arg) => {
+          return sinon.match({eventType: AUCTION_INIT, args: {i: 0}}).test(arg[0]) &&
+            sinon.match({eventType: BID_RESPONSE, args: {i: 0}}).test(arg[1]);
+        }));
+      });
+
+      it('should not choke if handler throws', () => {
+        adapter.enableAnalytics({
+          options: {
+            handler,
+            batchSize: 1
+          }
+        });
+        handler.throws(new Error());
+        events.emit(AUCTION_INIT, {i: 0});
+        let recv;
+        handler.reset();
+        handler.callsFake((arg) => {
+          recv = arg;
+        });
+        events.emit(BID_RESPONSE, {i: 1});
+        expect(recv).to.eql([{eventType: BID_RESPONSE, args: {i: 1}}]);
+      });
+
+      it('should not cause infinite recursion, if handler triggers more events', () => {
+        let i = 0;
+        handler.callsFake(() => {
+          if (i <= 100) {
+            i++;
+            events.emit(BID_RESPONSE, {});
+          }
+        });
+        adapter.enableAnalytics({
+          options: {
+            handler,
+          }
+        });
+        events.emit(AUCTION_INIT, {});
+        expect(i >= 100).to.be.false;
+      });
+
+      it('should send incomplete batch after batchDelay', () => {
+        adapter.enableAnalytics({
+          options: {
+            batchDelay: 100,
+            batchSize: 2,
+            handler
+          }
+        });
+        [0, 1, 2].forEach(i => events.emit(BID_RESPONSE, {i}));
+        sinon.assert.calledOnce(handler);
+        clock.tick(100);
+        sinon.assert.calledTwice(handler);
+      });
+
+      it('does not send empty batches', () => {
+        adapter.enableAnalytics({
+          options: {
+            batchDelay: 100,
+            batchSize: 2,
+            handler
+          }
+        });
+        [0, 1, 2].forEach(i => events.emit(BID_RESPONSE, {i}));
+        sinon.assert.calledOnce(handler);
+        clock.tick(50);
+        events.emit(BID_RESPONSE, {i: 3});
+        sinon.assert.calledTwice(handler);
+        clock.tick(100);
+        sinon.assert.calledTwice(handler);
+      });
+
+      describe('and options.events is specified', () => {
+        it('filters out other events', () => {
+          adapter.enableAnalytics({
+            options: {
+              handler,
+              events: {
+                bidResponse(bid) {
+                  return bid;
+                }
+              }
+            }
+          });
+          events.emit(AUCTION_INIT, {});
+          sinon.assert.notCalled(handler);
+        });
+
+        it('transforms event data', () => {
+          adapter.enableAnalytics({
+            options: {
+              handler,
+              events: {
+                bidResponse(bid) {
+                  return {
+                    extra: 'data',
+                    prop: bid.prop
+                  }
+                }
+              }
+            }
+          });
+          events.emit(BID_RESPONSE, {prop: 'value', i: 0});
+          sinon.assert.calledWith(handler, sinon.match(data => sinon.match({extra: 'data', prop: 'value'}).test(data[0])));
+        });
+
+        it('does not choke if an event handler throws', () => {
+          adapter.enableAnalytics({
+            options: {
+              handler,
+              events: {
+                bidResponse(bid) {
+                  return bid;
+                },
+                auctionInit(auction) {
+                  throw new Error();
+                }
+              }
+            }
+          });
+          events.emit(AUCTION_INIT, {});
+          events.emit(BID_RESPONSE, {i: 0});
+          sinon.assert.calledOnce(handler);
+          sinon.assert.calledWith(handler, sinon.match(data => sinon.match({i: 0}).test(data[0])));
+        });
+
+        it('filters out events when their handler returns undefined', () => {
+          adapter.enableAnalytics({
+            options: {
+              handler,
+              events: {
+                auctionInit(auction) {
+                  return auction;
+                },
+                bidResponse(bid) {}
+              }
+            }
+          });
+          events.emit(AUCTION_INIT, {i: 0});
+          events.emit(BID_RESPONSE, {i: 1});
+          sinon.assert.calledOnce(handler);
+          sinon.assert.calledWith(handler, sinon.match(data => sinon.match({i: 0}).test(data[0])));
+        });
+      });
+    });
+  });
+
+  describe('default handler', () => {
+    const url = 'mock-url';
+
+    let ajax;
+    beforeEach(() => {
+      ajax = sinon.stub();
+    });
+
+    Object.entries({
+      'GET': (data) => JSON.parse(data.data),
+      'POST': (data) => JSON.parse(data)
+    }).forEach(([method, parse]) => {
+      describe(`when HTTP method is ${method}`, () => {
+        it('should send single event when batchSize is 1', () => {
+          const handler = defaultHandler({url, method, batchSize: 1, ajax});
+          const payload = {i: 0};
+          handler([payload, {}]);
+          sinon.assert.calledWith(ajax, url, sinon.match.any,
+            sinon.match(data => sinon.match(payload).test(parse(data))),
+            {method}
+          );
+        });
+
+        it('should send multiple events when batchSize is greater than 1', () => {
+          const handler = defaultHandler({url, method, batchSize: 10, ajax});
+          const payload = [{i: 0}, {i: 1}];
+          handler(payload);
+          sinon.assert.calledWith(ajax, url, sinon.match.any,
+            sinon.match(data => sinon.match(payload).test(parse(data))),
+            {method}
+          );
+        });
+      });
+    });
+  });
+});

package/test/spec/modules/geoedgeRtdProvider_spec.js

@@ -2,6 +2,8 @@ import * as utils from '../../../src/utils.js';
 import * as hook from '../../../src/hook.js'
 import { beforeInit, geoedgeSubmodule, setWrapper, wrapper, htmlPlaceholder, WRAPPER_URL, getClientUrl } from '../../../modules/geoedgeRtdProvider.js';
 import { server } from '../../../test/mocks/xhr.js';
+import * as events from '../../../src/events.js';
+import CONSTANTS from '../../../src/constants.json';
 
 let key = '123123123';
 function makeConfig() {
@@ -88,6 +90,19 @@ describe('Geoedge RTD module', function () {
         let isLinkPreloadAsScript = arg => arg.tagName === 'LINK' && arg.rel === 'preload' && arg.as === 'script' && arg.href === getClientUrl(key);
         expect(insertElementStub.calledWith(sinon.match(isLinkPreloadAsScript))).to.equal(true);
       });
+      it('should emit billable events with applicable winning bids', function () {
+        let applicableBid = mockBid('bidderA');
+        let nonApplicableBid = mockBid('bidderB');
+        let counter = 0;
+        events.on(CONSTANTS.EVENTS.BILLABLE_EVENT, function (event) {
+          if (event.vendor === 'geoedge' && event.type === 'impression') {
+            counter += 1;
+          }
+        });
+        events.emit(CONSTANTS.EVENTS.BID_WON, applicableBid);
+        events.emit(CONSTANTS.EVENTS.BID_WON, nonApplicableBid);
+        expect(counter).to.equal(1);
+      });
     });
     describe('onBidResponseEvent', function () {
       let bidFromA = mockBid('bidderA');

package/test/spec/modules/glomexBidAdapter_spec.js

@@ -49,6 +49,10 @@ const RESPONSE = {
 describe('glomexBidAdapter', function () {
   const adapter = newBidder(spec)
 
+  it('should expose gvlid', function() {
+    expect(spec.gvlid).to.equal(967)
+  });
+
   describe('inherited functions', function () {
     it('exists and is a function', function () {
       expect(adapter.callBids).to.exist.and.to.be.a('function')

package/test/spec/modules/gravitoIdSystem_spec.js

@@ -40,7 +40,7 @@ describe('gravitompId module', function () {
   describe('decode()', function () {
     it('should return the gravitompId when it exists in cookie', function () {
       const decoded = gravitoIdSystemSubmodule.decode(GRAVITOID_TEST_OBJ);
-      expect(decoded).to.be.deep.equal({gravitompId: {id: GRAVITOID_TEST_VALUE}});
+      expect(decoded).to.be.deep.equal({gravitompId: GRAVITOID_TEST_VALUE});
     });
 
     it('should return the undefined when decode id is not "string"', function () {