prebid.js 7.25.0 → 7.27.0

package/test/spec/modules/zeusPrimeRtdProvider_spec.js

@@ -0,0 +1,410 @@
+import { zeusPrimeSubmodule } from 'modules/zeusPrimeRtdProvider';
+import { server } from 'test/mocks/xhr.js';
+import * as utils from 'src/utils';
+
+async function waitForStatus(statusVar) {
+  const MAX_COUNT = 20;
+  let count = 0;
+  while (
+    count <= MAX_COUNT &&
+    window.zeusPrime.status &&
+    window.zeusPrime.status[statusVar] !== true
+  ) {
+    count += 1;
+    await new Promise((resolve) => setTimeout(resolve, 10));
+  }
+
+  if (count === MAX_COUNT) {
+    throw new Error('Timeout waiting for zeusPrimeRtdProvider to complete');
+  }
+}
+
+/**
+ * Execute all the commands in the googletag.cmd queue.
+ */
+function executeGoogletagTargeting() {
+  window.googletag.cmd.forEach((cmd) => cmd());
+}
+
+describe('Zeus Prime RTD submodule', () => {
+  let logErrorSpy;
+  let logMessageSpy;
+  let setTargetingStub;
+  let originalGtag;
+
+  beforeEach(() => {
+    logErrorSpy = sinon.spy(utils, 'logError');
+    logMessageSpy = sinon.spy(utils, 'logMessage');
+    setTargetingStub = sinon.stub();
+    window.zeusPrime = { cmd: [] };
+    originalGtag = window.googletag;
+    window.googletag = {
+      cmd: [],
+      pubads: () => ({
+        setTargeting: setTargetingStub,
+      }),
+    };
+
+    // Mock subtle since this doesnt exists in some test environments due to security in newer browsers.
+    if (typeof window.crypto.subtle === 'undefined') {
+      Object.defineProperty(crypto, 'subtle', { value: { digest: () => 'mockHash' } })
+    }
+  });
+
+  afterEach(() => {
+    logErrorSpy.restore();
+    logMessageSpy.restore();
+    window.googletag = originalGtag;
+  });
+
+  it('should init and set key-value for zeus_<gamId>', async () => {
+    zeusPrimeSubmodule.init({
+      params: {
+        gamId: '1234',
+        hostname: 'www.example.com',
+        pathname: '/',
+      },
+    });
+
+    // wait for the script to finish
+    await waitForStatus('scriptComplete');
+
+    // execute any googletag commands added to the queue during execution
+    executeGoogletagTargeting();
+
+    expect(window.googletag.cmd).to.have.length(1);
+    sinon.assert.callCount(setTargetingStub, 1);
+    sinon.assert.calledWith(setTargetingStub, 'zeus_1234', 'www.example.com');
+  });
+
+  it('should init and set key-value for zeus_<gamId> from command queue', async () => {
+    window.zeusPrime.cmd.push((prime) => (prime.gamId = '9876'));
+    zeusPrimeSubmodule.init({
+      params: {
+        hostname: 'www.example.com',
+        pathname: '/',
+      },
+    });
+
+    // wait for the script to finish
+    await waitForStatus('scriptComplete');
+
+    // execute any googletag commands added to the queue during execution
+    executeGoogletagTargeting();
+
+    expect(window.googletag.cmd).to.have.length(1);
+    sinon.assert.callCount(setTargetingStub, 1);
+    sinon.assert.calledWith(setTargetingStub, 'zeus_9876', 'www.example.com');
+  });
+
+  it('should init with values from location and set key-value for zeus_<gamId>', async () => {
+    zeusPrimeSubmodule.init({ params: { gamId: '1234' } });
+
+    // wait for the script to finish
+    await waitForStatus('scriptComplete');
+
+    // execute any googletag commands added to the queue during execution
+    executeGoogletagTargeting();
+
+    expect(window.googletag.cmd).to.have.length(1);
+    sinon.assert.callCount(setTargetingStub, 1);
+    sinon.assert.calledWith(setTargetingStub, 'zeus_1234', 'localhost');
+    expect(window.zeusPrime.pathname).to.equal('/context.html');
+  });
+
+  it('should emit error when gamId is not set', async () => {
+    zeusPrimeSubmodule.init({});
+
+    // wait for the script to finish
+    await waitForStatus('scriptComplete');
+
+    // execute any googletag commands added to the queue during execution
+    executeGoogletagTargeting();
+
+    expect(window.googletag.cmd).to.have.length(0);
+    sinon.assert.callCount(setTargetingStub, 0);
+    sinon.assert.calledWith(
+      logErrorSpy,
+      'zeusPrimeRtdProvider: ',
+      'Failed to run.',
+      'window.zeusPrime.gamId must be a string. Received: undefined'
+    );
+  });
+
+  it('should not make a call to the server when url is a homepage', async () => {
+    zeusPrimeSubmodule.init({
+      params: {
+        gamId: '1234',
+        hostname: 'www.example.com',
+        pathname: '/',
+      },
+    });
+
+    // wait for the script to finish
+    await waitForStatus('scriptComplete');
+
+    expect(server.requests).to.have.length(0);
+  });
+
+  it('should make a call to the server and set key-vlaue when url is an article page and returns topics', async () => {
+    zeusPrimeSubmodule.init({
+      params: {
+        gamId: '1234',
+        hostname: 'www.example.com',
+        pathname: '/article/some-article',
+      },
+    });
+
+    // Wait for request to be sent
+    await waitForStatus('insightsReqReceived');
+
+    // Response
+    server.requests[0].respond(
+      200,
+      { 'Content-Type': 'application/json' },
+      '{"topics": ["bs0"]}'
+    );
+
+    // Wait for the script to process the response
+    await waitForStatus('scriptComplete');
+
+    // execute any googletag commands added to the queue during execution
+    executeGoogletagTargeting();
+
+    expect(server.requestCount).to.be.equal(1);
+    expect(window.googletag.cmd).to.have.length(2);
+    sinon.assert.calledTwice(setTargetingStub);
+    sinon.assert.calledWith(
+      setTargetingStub.firstCall,
+      'zeus_1234',
+      'www.example.com'
+    );
+    sinon.assert.calledWith(setTargetingStub.secondCall, 'zeus_insights', [
+      'bs0',
+    ]);
+    sinon.assert.notCalled(logErrorSpy);
+  });
+
+  it('should not set insights keyvalue when server returns 204', async () => {
+    zeusPrimeSubmodule.init({
+      params: {
+        gamId: '1234',
+        hostname: 'www.example.com',
+        pathname: '/article/some-article',
+      },
+    });
+
+    // Wait for request to be sent
+    await waitForStatus('insightsReqReceived');
+
+    // Response
+    server.requests[0].respond(204, { 'Content-Type': 'application/json' });
+
+    // Wait for the script to process the response
+    await waitForStatus('scriptComplete');
+
+    // execute any googletag commands added to the queue during execution
+    executeGoogletagTargeting();
+
+    expect(server.requestCount).to.be.equal(1);
+    expect(window.googletag.cmd).to.have.length(1);
+    sinon.assert.calledOnce(setTargetingStub);
+    sinon.assert.calledWith(
+      setTargetingStub.firstCall,
+      'zeus_1234',
+      'www.example.com'
+    );
+    sinon.assert.notCalled(logErrorSpy);
+  });
+
+  it('should not set insights keyvalue when server returns empty topics array', async () => {
+    zeusPrimeSubmodule.init({
+      params: {
+        gamId: '1234',
+        hostname: 'www.example.com',
+        pathname: '/article/some-article',
+      },
+    });
+
+    // Wait for request to be sent
+    await waitForStatus('insightsReqReceived');
+
+    // Respond
+    server.requests[0].respond(
+      200,
+      { 'Content-Type': 'application/json' },
+      '{ "topics": [] }'
+    );
+
+    // Wait for the script to process the response
+    await waitForStatus('scriptComplete');
+
+    // execute any googletag commands added to the queue during execution
+    executeGoogletagTargeting();
+
+    expect(server.requestCount).to.be.equal(1);
+    expect(window.googletag.cmd).to.have.length(1);
+    sinon.assert.calledOnce(setTargetingStub);
+    sinon.assert.calledWith(
+      setTargetingStub.firstCall,
+      'zeus_1234',
+      'www.example.com'
+    );
+    sinon.assert.notCalled(logErrorSpy);
+  });
+
+  it('should not set insights keyvalue and emit error when server returns error status (400)', async () => {
+    zeusPrimeSubmodule.init({
+      params: {
+        gamId: '1234',
+        hostname: 'www.example.com',
+        pathname: '/article/some-article',
+      },
+    });
+
+    // Wait for request to be sent
+    await waitForStatus('insightsReqReceived');
+
+    // Response
+    server.requests[0].respond(
+      404,
+      { 'Content-Type': 'application/json' },
+      '{"message": "Not found"}'
+    );
+
+    // Wait for the script to process the response
+    await waitForStatus('scriptComplete');
+
+    // execute any googletag commands added to the queue during execution
+    executeGoogletagTargeting();
+
+    expect(server.requestCount).to.be.equal(1);
+    expect(window.googletag.cmd).to.have.length(1);
+    sinon.assert.calledOnce(setTargetingStub);
+    sinon.assert.calledWith(
+      setTargetingStub.firstCall,
+      'zeus_1234',
+      'www.example.com'
+    );
+    sinon.assert.calledWith(
+      logErrorSpy,
+      'zeusPrimeRtdProvider: ',
+      'Topics request returned error: 404'
+    );
+  });
+
+  it('should not set insights keyvalue and emit error when response is not received (network request)', async () => {
+    zeusPrimeSubmodule.init({
+      params: {
+        gamId: '1234',
+        hostname: 'www.example.com',
+        pathname: '/article/some-article',
+      },
+    });
+
+    // Wait for request to be sent
+    await waitForStatus('insightsReqReceived');
+
+    // Response
+    server.requests[0].error();
+
+    // Wait for the script to process the response
+    await waitForStatus('scriptComplete');
+
+    // execute any googletag commands added to the queue during execution
+    executeGoogletagTargeting();
+
+    expect(server.requestCount).to.be.equal(1);
+    expect(window.googletag.cmd).to.have.length(1);
+    sinon.assert.calledOnce(setTargetingStub);
+    sinon.assert.calledWith(
+      setTargetingStub.firstCall,
+      'zeus_1234',
+      'www.example.com'
+    );
+    sinon.assert.calledWith(
+      logErrorSpy,
+      'zeusPrimeRtdProvider: ',
+      'failed to request topics'
+    );
+  });
+
+  it('fails gracefully when crypto fails', async () => {
+    const digestStub = sinon.stub(window.crypto.subtle, 'digest');
+    digestStub.throwsException('Failed to generate digest.');
+
+    zeusPrimeSubmodule.init({
+      params: {
+        gamId: '1234',
+        hostname: 'www.example.com',
+        pathname: '/article/some-article',
+      },
+    });
+
+    // Wait for request to be sent
+    await waitForStatus('scriptComplete');
+
+    sinon.assert.calledWith(
+      logErrorSpy,
+      'zeusPrimeRtdProvider: ',
+      'Failed to load hash'
+    );
+
+    digestStub.restore();
+  });
+
+  it('script should add zeus_prime key and not send request when disabled is set', async () => {
+    zeusPrimeSubmodule.init({
+      params: {
+        gamId: '1234',
+        disabled: true,
+        hostname: 'www.example.com',
+        pathname: '/article/some-article',
+      },
+    });
+
+    // Wait for request to be sent
+    await waitForStatus('scriptComplete');
+
+    // execute any googletag commands added to the queue during execution
+    executeGoogletagTargeting();
+
+    expect(server.requestCount).to.be.equal(0);
+    expect(window.googletag.cmd).to.have.length(1);
+    sinon.assert.calledWith(setTargetingStub, 'zeus_prime', 'false');
+  });
+
+  it('debug true enables debug logging', async () => {
+    zeusPrimeSubmodule.init({
+      params: {
+        gamId: '1234',
+        debug: true,
+        hostname: 'www.example.com',
+        pathname: '/article/some-article',
+      },
+    });
+
+    // Wait for request to be sent
+    await waitForStatus('scriptComplete');
+
+    sinon.assert.called(logMessageSpy);
+    sinon.assert.notCalled(logErrorSpy);
+  });
+
+  it('debug false disables debug logging', async () => {
+    window.zeusPrime.disabled = false;
+    zeusPrimeSubmodule.init({
+      params: {
+        gamId: '1234',
+        hostname: 'www.example.com',
+        pathname: '/article/some-article',
+      },
+    });
+
+    // Wait for request to be sent
+    await waitForStatus('scriptComplete');
+
+    sinon.assert.notCalled(logMessageSpy);
+    sinon.assert.notCalled(logErrorSpy);
+  });
+});

package/test/spec/native_spec.js

@@ -5,6 +5,7 @@ import {
   nativeBidIsValid,
   getAssetMessage,
   getAllAssetsMessage,
+  toLegacyResponse,
   decorateAdUnitsWithNativeParams,
   isOpenRTBBidRequestValid,
   isNativeOpenRTBBidValid,
@@ -37,6 +38,7 @@ const bid = {
     clickTrackers: ['https://tracker.example'],
     impressionTrackers: ['https://impression.example'],
     javascriptTrackers: '<script src="http://www.foobar.js"></script>',
+    privacyLink: 'https://privacy-link.example',
     ext: {
       foo: 'foo-value',
       baz: 'baz-value',
@@ -98,9 +100,18 @@ const ortbBid = {
       privacy: 'https://privacy-link.example',
       ver: '1.2'
     }
-  },
+  }
 };
 
+const completeNativeBid = {
+  adId: '123',
+  transactionId: 'au',
+  native: {
+    ...bid.native,
+    ...ortbBid.native
+  }
+}
+
 const ortbRequest = {
   assets: [
     {
@@ -224,6 +235,14 @@ describe('native.js', function () {
     expect(targeting.hb_native_baz).to.equal('hb_native_baz:123');
   });
 
+  it('sends placeholdes targetings with ortb native response', function () {
+    const targeting = getNativeTargeting(completeNativeBid);
+
+    expect(targeting[CONSTANTS.NATIVE_KEYS.title]).to.equal('Native Creative');
+    expect(targeting[CONSTANTS.NATIVE_KEYS.body]).to.equal('Cool description great stuff');
+    expect(targeting[CONSTANTS.NATIVE_KEYS.clickUrl]).to.equal('https://www.link.example');
+  });
+
   it('should only include native targeting keys with values', function () {
     const adUnit = {
       transactionId: 'au',
@@ -302,6 +321,10 @@ describe('native.js', function () {
           required: false,
           sendTargetingKeys: false,
         },
+        privacyLink: {
+          required: false,
+          sendTargetingKeys: false,
+        },
         ext: {
           foo: {
             required: false,
@@ -348,6 +371,7 @@ describe('native.js', function () {
       CONSTANTS.NATIVE_KEYS.icon,
       CONSTANTS.NATIVE_KEYS.sponsoredBy,
       CONSTANTS.NATIVE_KEYS.clickUrl,
+      CONSTANTS.NATIVE_KEYS.privacyLink,
       CONSTANTS.NATIVE_KEYS.rendererUrl,
     ]);
 
@@ -380,6 +404,7 @@ describe('native.js', function () {
       CONSTANTS.NATIVE_KEYS.icon,
       CONSTANTS.NATIVE_KEYS.sponsoredBy,
       CONSTANTS.NATIVE_KEYS.clickUrl,
+      CONSTANTS.NATIVE_KEYS.privacyLink,
     ]);
 
     expect(bid.native.adTemplate).to.deep.equal(
@@ -437,9 +462,9 @@ describe('native.js', function () {
       adId: '123',
     };
 
-    const message = getAllAssetsMessage(messageRequest, bid, {getNativeReq: () => null});
+    const message = getAllAssetsMessage(messageRequest, bid);
 
-    expect(message.assets.length).to.equal(9);
+    expect(message.assets.length).to.equal(10);
     expect(message.assets).to.deep.include({
       key: 'body',
       value: bid.native.body,
@@ -485,7 +510,7 @@ describe('native.js', function () {
       adId: '123',
     };
 
-    const message = getAllAssetsMessage(messageRequest, bidWithUndefinedFields, {getNativeReq: () => null});
+    const message = getAllAssetsMessage(messageRequest, bidWithUndefinedFields);
 
     expect(message.assets.length).to.equal(4);
     expect(message.assets).to.deep.include({
@@ -506,16 +531,16 @@ describe('native.js', function () {
     });
   });
 
-  it('creates native all asset message with OpenRTB format', function () {
+  it('creates native all asset message with complete format', function () {
     const messageRequest = {
       message: 'Prebid Native',
       action: 'allAssetRequest',
       adId: '123',
     };
 
-    const message = getAllAssetsMessage(messageRequest, ortbBid, {getNativeReq: () => ortbRequest});
+    const message = getAllAssetsMessage(messageRequest, completeNativeBid);
 
-    expect(message.assets.length).to.equal(8);
+    expect(message.assets.length).to.equal(10);
     expect(message.assets).to.deep.include({
       key: 'body',
       value: bid.native.body,
@@ -548,6 +573,14 @@ describe('native.js', function () {
       key: 'privacyLink',
       value: ortbBid.native.ortb.privacy,
     });
+    expect(message.assets).to.deep.include({
+      key: 'foo',
+      value: bid.native.ext.foo,
+    });
+    expect(message.assets).to.deep.include({
+      key: 'baz',
+      value: bid.native.ext.baz,
+    });
   });
 
   const SAMPLE_ORTB_REQUEST = toOrtbNativeRequest({
@@ -555,60 +588,39 @@ describe('native.js', function () {
     body: 'vbody'
   });
   const SAMPLE_ORTB_RESPONSE = {
-    native: {
-      ortb: {
-        link: {
-          url: 'url'
-        },
-        assets: [
-          {
-            id: 0,
-            title: {
-              text: 'vtitle'
-            }
-          },
-          {
-            id: 1,
-            data: {
-              value: 'vbody'
-            }
-          }
-        ]
+    link: {
+      url: 'url'
+    },
+    assets: [
+      {
+        id: 0,
+        title: {
+          text: 'vtitle'
+        }
+      },
+      {
+        id: 1,
+        data: {
+          value: 'vbody'
+        }
       }
-    }
+    ],
+    eventtrackers: [
+      { event: 1, method: 1, url: 'https://sampleurl.com' },
+      { event: 1, method: 2, url: 'https://sampleurljs.com' }
+    ]
   }
-  describe('getAllAssetsMessage', () => {
+  describe('toLegacyResponse', () => {
     it('returns assets in legacy format for ortb responses', () => {
-      const actual = getAllAssetsMessage({}, SAMPLE_ORTB_RESPONSE, {getNativeReq: () => SAMPLE_ORTB_REQUEST});
-      expect(actual.assets).to.eql([
-        {
-          key: 'clickUrl',
-          value: 'url'
-        },
-        {
-          key: 'title',
-          value: 'vtitle'
-        },
-        {
-          key: 'body',
-          value: 'vbody'
-        },
-      ])
+      const actual = toLegacyResponse(SAMPLE_ORTB_RESPONSE, SAMPLE_ORTB_REQUEST);
+      expect(actual.body).to.equal('vbody');
+      expect(actual.title).to.equal('vtitle');
+      expect(actual.clickUrl).to.equal('url');
+      expect(actual.javascriptTrackers).to.equal('<script async src="https://sampleurljs.com"></script>');
+      expect(actual.impressionTrackers.length).to.equal(1);
+      expect(actual.impressionTrackers[0]).to.equal('https://sampleurl.com');
     });
   });
-  describe('getAssetsMessage', () => {
-    Object.entries({
-      'hb_native_title': {key: 'title', value: 'vtitle'},
-      'hb_native_body': {key: 'body', value: 'vbody'}
-    }).forEach(([tkey, assetVal]) => {
-      it(`returns ${tkey} asset in legacy format for ortb responses`, () => {
-        const actual = getAssetMessage({
-          assets: [tkey]
-        }, SAMPLE_ORTB_RESPONSE, {getNativeReq: () => SAMPLE_ORTB_REQUEST})
-        expect(actual.assets).to.eql([assetVal])
-      })
-    })
-  })
 });
 
 describe('validate native openRTB', function () {