prebid.js 7.26.0 → 7.28.0

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 () {

package/test/spec/ortb2.5StrictTranslator/dsl_spec.js

@@ -0,0 +1,137 @@
+import {Arr, ERR_ENUM, ERR_TYPE, ERR_UNKNOWN_FIELD, IntEnum, Obj} from '../../../libraries/ortb2.5StrictTranslator/dsl.js';
+import {deepClone} from '../../../src/utils.js';
+
+describe('DSL', () => {
+  const spec = (() => {
+    const inner = Obj(['p21', 'p22'], {
+      enum: IntEnum(10, 20),
+      enumArray: Arr(IntEnum(10, 20))
+    });
+    return Obj(['p11', 'p12'], {
+      inner,
+      innerArray: Arr(inner)
+    });
+  })();
+
+  let onError;
+
+  function scan(obj) {
+    spec(null, null, null, obj, onError);
+  }
+
+  beforeEach(() => {
+    onError = sinon.stub();
+  });
+
+  it('checks object type', () => {
+    scan(null);
+    sinon.assert.calledWith(onError, ERR_TYPE, null, null, null, null);
+  });
+  it('ignores known fields and ext', () => {
+    scan({p11: 1, p12: 2, ext: {e1: 1, e2: 2}});
+    sinon.assert.notCalled(onError);
+  });
+  it('detects unknown fields', () => {
+    const obj = {p11: 1, unk: 2};
+    scan(obj);
+    sinon.assert.calledOnce(onError);
+    sinon.assert.calledWith(onError, ERR_UNKNOWN_FIELD, 'unk', obj, 'unk', 2);
+  });
+  describe('when nested', () => {
+    describe('directly', () => {
+      it('detects unknown fields', () => {
+        const obj = {inner: {p21: 1, unk: 2}};
+        scan(obj);
+        sinon.assert.calledOnce(onError);
+        sinon.assert.calledWith(onError, ERR_UNKNOWN_FIELD, 'inner.unk', obj.inner, 'unk', 2);
+      });
+      it('accepts enum values in range', () => {
+        scan({inner: {enum: 12}});
+        sinon.assert.notCalled(onError);
+      });
+      [Infinity, NaN, -Infinity].forEach(val => {
+        it(`does not accept ${val} in enum`, () => {
+          const obj = {inner: {enum: val}};
+          scan(obj);
+          sinon.assert.calledOnce(onError);
+          sinon.assert.calledWith(onError, ERR_ENUM, 'inner.enum', obj.inner, 'enum', val);
+        });
+      });
+      it('accepts arrays of enums that are in range', () => {
+        scan({inner: {enumArray: [12, 13]}});
+        sinon.assert.notCalled(onError);
+      })
+      it('detects enum values out of range', () => {
+        const obj = {inner: {enum: -1}};
+        scan(obj);
+        sinon.assert.calledOnce(onError);
+        sinon.assert.calledWith(onError, ERR_ENUM, 'inner.enum', obj.inner, 'enum', -1);
+      });
+      it('detects enum values that are not numbers', () => {
+        const obj = {inner: {enum: 'err'}};
+        scan(obj);
+        sinon.assert.calledOnce(onError);
+        sinon.assert.calledWith(onError, ERR_TYPE, 'inner.enum', obj.inner, 'enum', 'err');
+      })
+      it('detects arrays of enums that are out of range', () => {
+        const obj = {inner: {enumArray: [12, 13, -1, 14]}};
+        scan(obj);
+        sinon.assert.calledOnce(onError);
+        sinon.assert.calledWith(onError, ERR_ENUM, 'inner.enumArray.2', obj.inner.enumArray, 2, -1);
+      });
+      it('detects when enum arrays are not arrays', () => {
+        const obj = {inner: {enumArray: 'err'}};
+        scan(obj);
+        sinon.assert.calledOnce(onError);
+        sinon.assert.calledWith(onError, ERR_TYPE, 'inner.enumArray', obj.inner, 'enumArray', 'err');
+      });
+      it('detects items within enum arrays that are not numbers', () => {
+        const obj = {inner: {enumArray: [12, 'err', 13]}};
+        scan(obj);
+        sinon.assert.calledOnce(onError);
+        sinon.assert.calledWith(onError, ERR_TYPE, 'inner.enumArray.1', obj.inner.enumArray, 1, 'err');
+      })
+    });
+    describe('into arrays', () => {
+      it('detects if inner array is not an array', () => {
+        const obj = {innerArray: 'err', inner: {p21: 1}};
+        scan(obj);
+        sinon.assert.calledOnce(onError);
+        sinon.assert.calledWith(onError, ERR_TYPE, 'innerArray', obj, 'innerArray', 'err');
+      });
+      it('detects when elements of inner array are not objects', () => {
+        const obj = {innerArray: [{p21: 1}, 'err', {ext: {r: 1}}]};
+        scan(obj);
+        sinon.assert.calledOnce(onError);
+        sinon.assert.calledWith(onError, ERR_TYPE, 'innerArray.1', obj.innerArray, 1, 'err');
+      });
+      const oos = {
+        innerArray: [
+          {p22: 2, unk: 3, enumArray: [-1, 12, 'err']},
+          {p21: 1, enum: -1, ext: {e: 1}},
+        ]
+      };
+      it('detects invalid properties within inner array', () => {
+        const obj = deepClone(oos);
+        scan(obj);
+        sinon.assert.calledWith(onError, ERR_UNKNOWN_FIELD, 'innerArray.0.unk', obj.innerArray[0], 'unk', 3);
+        sinon.assert.calledWith(onError, ERR_ENUM, 'innerArray.0.enumArray.0', obj.innerArray[0].enumArray, 0, -1);
+        sinon.assert.calledWith(onError, ERR_TYPE, 'innerArray.0.enumArray.2', obj.innerArray[0].enumArray, 2, 'err');
+        sinon.assert.calledWith(onError, ERR_ENUM, 'innerArray.1.enum', obj.innerArray[1], 'enum', -1);
+      });
+      it('can remove all invalid properties during scan', () => {
+        onError.callsFake((errno, path, obj, field) => {
+          Array.isArray(obj) ? obj.splice(field, 1) : delete obj[field];
+        });
+        const obj = deepClone(oos);
+        scan(obj);
+        expect(obj).to.eql({
+          innerArray: [
+            {p22: 2, enumArray: [12]},
+            {p21: 1, ext: {e: 1}}
+          ]
+        });
+      })
+    })
+  })
+});