prebid.js 7.27.0 → 7.28.0

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

@@ -0,0 +1,16 @@
+import {toOrtb25Strict} from '../../../libraries/ortb2.5StrictTranslator/translator.js';
+
+describe('toOrtb25Strict', () => {
+  let translator;
+  beforeEach(() => {
+    translator = sinon.stub().callsFake((o) => o);
+  })
+  it('uses provided translator', () => {
+    translator.reset();
+    translator.callsFake(() => ({id: 'test'}));
+    expect(toOrtb25Strict(null, translator)).to.eql({id: 'test'});
+  });
+  it('removes fields out of spec', () => {
+    expect(toOrtb25Strict({unk: 'field', imp: ['err', {}]}, translator)).to.eql({imp: [{}]});
+  });
+});

package/test/spec/ortb2.5Translator/translator_spec.js

@@ -0,0 +1,64 @@
+import {EXT_PROMOTIONS, moveRule, splitPath, toOrtb25} from '../../../libraries/ortb2.5Translator/translator.js';
+import {deepAccess, deepClone, deepSetValue} from '../../../src/utils.js';
+
+describe('ORTB 2.5 translation', () => {
+  describe('moveRule', () => {
+    const rule = moveRule('f1.f2.f3', (prefix, field) => `${prefix}.m1.m2.${field}`);
+
+    function applyRule(rule, obj, del = true) {
+      obj = deepClone(obj);
+      const deleter = rule(obj);
+      if (typeof deleter === 'function' && del) {
+        deleter();
+      }
+      return obj;
+    }
+
+    it('returns undef when field is not present', () => {
+      expect(rule({})).to.eql(undefined);
+    });
+    it('can copy field', () => {
+      expect(applyRule(rule, {f1: {f2: {f3: 'value'}}}, false)).to.eql({
+        f1: {
+          f2: {
+            f3: 'value',
+            m1: {m2: {f3: 'value'}}
+          }
+        }
+      });
+    });
+    it('can move field', () => {
+      expect(applyRule(rule, {f1: {f2: {f3: 'value'}}}, true)).to.eql({f1: {f2: {m1: {m2: {f3: 'value'}}}}});
+    });
+  });
+  describe('toOrtb25', () => {
+    EXT_PROMOTIONS.forEach(path => {
+      const newPath = (() => {
+        const [prefix, field] = splitPath(path);
+        return `${prefix}.ext.${field}`;
+      })();
+
+      it(`moves ${path} to ${newPath}`, () => {
+        const obj = {};
+        deepSetValue(obj, path, 'val');
+        toOrtb25(obj);
+        expect(deepAccess(obj, path)).to.eql(undefined);
+        expect(deepAccess(obj, newPath)).to.eql('val');
+      });
+    });
+    it('moves kwarray into keywords', () => {
+      expect(toOrtb25({app: {keywords: 'k1,k2', kwarray: ['ka1', 'ka2']}})).to.eql({app: {keywords: 'k1,k2,ka1,ka2'}});
+    });
+    it('does not choke if kwarray is not an array', () => {
+      expect(toOrtb25({site: {keywords: 'k1,k2', kwarray: 'err'}})).to.eql({site: {keywords: 'k1,k2'}});
+    });
+    it('does not choke if keywords is not a string', () => {
+      expect(toOrtb25({user: {keywords: {}, kwarray: ['ka1', 'ka2']}})).to.eql({
+        user: {
+          keywords: {},
+          kwarray: ['ka1', 'ka2']
+        }
+      });
+    });
+  });
+});

package/test/spec/refererDetection_spec.js

@@ -2,94 +2,7 @@ import {detectReferer, ensureProtocol, parseDomain} from 'src/refererDetection.j
 import {config} from 'src/config.js';
 import {expect} from 'chai';
 
-/**
- * Build a walkable linked list of window-like objects for testing.
- *
- * @param {Array} urls Array of URL strings starting from the top window.
- * @param {string} [topReferrer]
- * @param {string} [canonicalUrl]
- * @param {boolean} [ancestorOrigins]
- * @returns {Object}
- */
-function buildWindowTree(urls, topReferrer = null, canonicalUrl = null, ancestorOrigins = false) {
-  /**
-   * Find the origin from a given fully-qualified URL.
-   *
-   * @param {string} url The fully qualified URL
-   * @returns {string|null}
-   */
-  function getOrigin(url) {
-    const originRegex = new RegExp('^(https?://[^/]+/?)');
-
-    const result = originRegex.exec(url);
-
-    if (result && result[0]) {
-      return result[0];
-    }
-
-    return null;
-  }
-
-  const inaccessibles = [];
-
-  let previousWindow, topWindow;
-  const topOrigin = getOrigin(urls[0]);
-
-  const windowList = urls.map((url, index) => {
-    const thisOrigin = getOrigin(url),
-      sameOriginAsPrevious = index === 0 ? true : (getOrigin(urls[index - 1]) === thisOrigin),
-      sameOriginAsTop = thisOrigin === topOrigin;
-
-    const win = {
-      location: {
-        href: url,
-      },
-      document: {
-        referrer: index === 0 ? topReferrer : urls[index - 1]
-      }
-    };
-
-    if (topWindow == null) {
-      topWindow = win;
-      win.document.querySelector = function (selector) {
-        if (selector === 'link[rel=\'canonical\']') {
-          return {
-            href: canonicalUrl
-          };
-        }
-        return null;
-      };
-    }
-
-    if (sameOriginAsPrevious) {
-      win.parent = previousWindow;
-    } else {
-      win.parent = inaccessibles[inaccessibles.length - 1];
-    }
-    if (ancestorOrigins) {
-      win.location.ancestorOrigins = urls.slice(0, index).reverse().map(getOrigin);
-    }
-    win.top = sameOriginAsTop ? topWindow : inaccessibles[0];
-
-    const inWin = {parent: inaccessibles[inaccessibles.length - 1], top: inaccessibles[0]};
-    if (index === 0) {
-      inWin.top = inWin;
-    }
-    ['document', 'location'].forEach((prop) => {
-      Object.defineProperty(inWin, prop, {
-        get: function () {
-          throw new Error('cross-origin access');
-        }
-      });
-    });
-    inaccessibles.push(inWin);
-    previousWindow = win;
-
-    return win;
-  });
-
-  return windowList[windowList.length - 1];
-}
+import { buildWindowTree } from '../helpers/refererDetectionHelper';
 
 describe('Referer detection', () => {
   afterEach(function () {