prebid-universal-creative 1.15.0 → 1.17.0

package/test/helpers/mocks.js

@@ -14,6 +14,7 @@ export const mocks = {
       },
       parent: {},
       top: {},
+      frames: {},
     };
   }
 }

package/test/spec/dynamicRenderer_spec.js

@@ -0,0 +1,167 @@
+import {makeIframe} from '../../src/domHelper.js';
+import {hasDynamicRenderer, MIN_RENDERER_VERSION, runDynamicRenderer} from '../../src/dynamicRenderer.js';
+import {AD_RENDER_FAILED, AD_RENDER_SUCCEEDED, PREBID_EVENT} from '../../src/messaging.js';
+
+describe('hasDynamicRenderer', () => {
+    Object.entries({
+        'neither': {},
+        'renderer, but no version': {
+            renderer: 'mock-renderer'
+        },
+        'renderer, but version is too low': {
+            renderer: 'mock-renderer',
+            rendererVersion: 1
+        },
+    }).forEach(([t, data]) => {
+        it(`returns false with ${t}`, () => {
+            expect(hasDynamicRenderer(data)).to.be.false;
+        })
+    });
+
+    it('returns true when both renderer and version are present', () => {
+        expect(hasDynamicRenderer({
+            renderer: 'mock-renderer',
+            rendererVersion: MIN_RENDERER_VERSION
+        })).to.be.true;
+    })
+})
+
+describe('runDynamicRenderer', () => {
+    let sendMessage, frame, render;
+    const adId = '123';
+    beforeEach(() => {
+        render = sinon.stub();
+        sendMessage = sinon.stub();
+        frame = makeIframe(document);
+        return new Promise((resolve) => {
+            frame.onload = resolve;
+            document.body.appendChild(frame);
+        }).then(() => {
+            frame.contentWindow._render = render;
+        });
+    });
+
+    afterEach(() => {
+        document.body.removeChild(frame);
+    });
+
+    function runRenderer(data) {
+        return runDynamicRenderer(adId, Object.assign({
+            renderer: `window.render = window.parent._render`
+        }, data), sendMessage, frame.contentWindow).catch(() => null);
+    }
+
+    it('runs renderer', () => {
+        const data = {ad: 'markup'};
+        return runRenderer(data).then(() => {
+            sinon.assert.calledWith(render, sinon.match(data), sinon.match({mkFrame: makeIframe}), frame.contentWindow);
+        });
+    });
+
+    Object.entries({
+        'returns': null,
+        'returns a promise that resolves': Promise.resolve()
+    }).forEach(([t, ret]) => {
+        it(`emits AD_RENDER_SUCCEDED when renderer ${t}`, () => {
+            render.callsFake(() => ret);
+            return runRenderer().then(() => {
+                sinon.assert.calledWith(sendMessage, {
+                    adId,
+                    message: PREBID_EVENT,
+                    event: AD_RENDER_SUCCEEDED
+                });
+            });
+        });
+    });
+
+    describe('emits AD_RENDER_FAILED', () => {
+        Object.entries({
+            throws: (ret) => {
+                throw ret;
+            },
+            'returns a promise that rejects': (ret) => Promise.reject(ret)
+        }).forEach(([t, transform]) => {
+            describe(`when renderer ${t}`, () => {
+                Object.entries({
+                    'error': {
+                        ret: new Error('error message'),
+                        info: {
+                            reason: 'exception',
+                            message: 'error message'
+                        }
+                    },
+                    'error with reason': {
+                        ret: {
+                            reason: 'failure',
+                            message: 'error message'
+                        },
+                        info: {
+                            reason: 'failure',
+                            message: 'error message'
+                        }
+                    }
+                }).forEach(([t, {ret, info}]) => {
+                    it(`an ${t}`, () => {
+                        render.callsFake(() => transform(ret));
+                        return runRenderer().then(() => {
+                            sinon.assert.calledWith(sendMessage, {
+                                adId,
+                                message: PREBID_EVENT,
+                                event: AD_RENDER_FAILED,
+                                info
+                            });
+                        });
+                    });
+                });
+            });
+        });
+    });
+
+    describe('renderer sendMessage', () => {
+        let rndSendMessage;
+        beforeEach(() => {
+            render.callsFake(() => new Promise())
+            return new Promise((resolve) => {
+                render.callsFake((_, {sendMessage}) => {
+                    rndSendMessage = sendMessage;
+                    resolve();
+                });
+                runRenderer();
+            })
+        });
+        it('adds message type and adId', () => {
+            rndSendMessage('type', {msg: 'data'});
+            sinon.assert.calledWith(sendMessage, {
+                message: 'type',
+                adId,
+                msg: 'data'
+            });
+        });
+        it('accepts response listeners', () => {
+            const listener = sinon.stub();
+            sendMessage.callsFake((_, responseListener) => {
+                responseListener('response');
+            })
+            rndSendMessage('msg', {}, listener);
+            sinon.assert.calledWith(listener, 'response');
+        });
+
+        it('emits AD_RENDER_FAILED if listener throws', () => {
+            const listener = sinon.stub().callsFake(() => { throw new Error('err') });
+            sendMessage.callsFake((_, responseListener) => {
+                responseListener && responseListener('response');
+            });
+            rndSendMessage('msg', {}, listener);
+            sinon.assert.calledWith(sendMessage, {
+                message: PREBID_EVENT,
+                event: AD_RENDER_FAILED,
+                adId,
+                info: {
+                    reason: 'exception',
+                    message: 'err'
+                }
+            })
+        })
+    });
+
+});

package/test/spec/messaging_spec.js

@@ -1,5 +1,11 @@
 import {mocks} from '../helpers/mocks.js';
-import {prebidMessenger} from '../../src/messaging.js';
+import {
+    AD_RENDER_FAILED,
+    AD_RENDER_SUCCEEDED,
+    PREBID_EVENT,
+    prebidMessenger,
+    renderEventMessage
+} from '../../src/messaging.js';
 
 describe('prebidMessenger',() => {
     let win;
@@ -25,7 +31,6 @@ describe('prebidMessenger',() => {
     describe('when publisher URL is available', () => {
         const URL = 'https://www.publisher.com/page.html';
         const ORIGIN = 'https://www.publisher.com'
-        let sendMessage;
         let callback, handler;
 
         beforeEach(() => {
@@ -33,15 +38,73 @@ describe('prebidMessenger',() => {
                 handler = h;
             }
             win.removeEventListener = sinon.spy();
-            sendMessage = prebidMessenger(URL, win);
             callback = sinon.spy();
         })
 
+        function sendMessage(...args) {
+            return prebidMessenger(URL, win)(...args);
+        }
+
         it('should use origin for postMessage', () => {
            sendMessage('test');
            sinon.assert.calledWith(win.parent.postMessage, JSON.stringify('test'), ORIGIN);
         });
 
+        describe('when window has multiple ancestors', () => {
+            let target;
+            beforeEach(() => {
+                const top = mocks.createFakeWindow('top');
+                target = {
+                    ...win.parent,
+                    frames: {},
+                    parent: {
+                        top,
+                        frames: {},
+                        parent: top
+                    }
+                };
+                win = {
+                    top,
+                    frames: {},
+                    parent: {
+                        top,
+                        frames: {},
+                        parent: target
+                    }
+                };
+            })
+            Object.entries({
+                throws() { throw new DOMException() },
+                'does not throw'() { return {} }
+            }).forEach(([t, getFrames]) => {
+                describe(`when ancestor ${t}`, () => {
+                    beforeEach(() => {
+                        Object.defineProperty(target.parent.parent, 'frames', {get: getFrames});
+                    })
+                    it('should post to first ancestor that has a __pb_locator__ child', () => {
+                        [target, target.parent].forEach(win => {
+                            win.frames = {
+                                __pb_locator__: {}
+                            };
+                        })
+                        sendMessage('test');
+                        sinon.assert.called(target.postMessage);
+                    });
+                })
+            })
+            it('should post to immediate parent when no ancestor has __pb_locator__', () => {
+                win.parent.postMessage = sinon.spy();
+                delete target.postMessage;
+                sendMessage('test');
+                sinon.assert.called(win.parent.postMessage);
+            });
+            it('should post to first restricted frame if no __pb_locator__ can be found', () => {
+                Object.defineProperty(target, 'frames', {get() { throw new DOMException() }});
+                sendMessage('test');
+                sinon.assert.called(target.postMessage)
+            })
+        });
+
         it('should not run callback on response if origin does not mach', ()=> {
            sendMessage('test', callback);
            handler({origin: 'different'});
@@ -62,3 +125,35 @@ describe('prebidMessenger',() => {
 
     });
 })
+
+describe('renderEventMessage', () => {
+    Object.entries({
+        'success': {
+            input: {adId: '123'},
+            output: {
+                event: AD_RENDER_SUCCEEDED
+            }
+        },
+        'failure': {
+            input: {
+                adId: '321',
+                errorInfo: {
+                    reason: 'failureReason',
+                    message: 'error message'
+                }
+            },
+            output: {
+                event: AD_RENDER_FAILED,
+                info: {
+                    reason: 'failureReason',
+                    message: 'error message'
+                }
+            }
+        }
+    }).forEach(([t, {input: {adId, errorInfo}, output}]) => {
+        Object.assign(output, {message: PREBID_EVENT, adId});
+        it(t, () => {
+            expect(renderEventMessage(adId, errorInfo)).to.eql(output);
+        })
+    })
+})

package/test/spec/mobileAndAmpRender_spec.js

@@ -1,9 +1,10 @@
 import { renderAmpOrMobileAd } from 'src/mobileAndAmpRender';
-import * as postscribeRender from 'src/postscribeRender'
+import * as postscribeRender from 'src/adHtmlRender'
 import * as utils from 'src/utils';
 import { expect } from 'chai';
 import { mocks } from 'test/helpers/mocks';
 import { merge } from 'lodash';
+import {writeAdHtml} from 'src/adHtmlRender';
 
 
 function renderingMocks() {
@@ -187,51 +188,58 @@ describe("renderingManager", function () {
   });
 
   describe("amp creative", function () {
+    let sandbox;
     let writeHtmlSpy;
     let sendRequestSpy;
     let triggerPixelSpy;
     let mockWin;
-
-    before(function () {
-      writeHtmlSpy = sinon.spy(postscribeRender, "writeAdHtml");
-      sendRequestSpy = sinon.spy(utils, "sendRequest");
-      triggerPixelSpy = sinon.spy(utils, "triggerPixel");
-      mockWin = merge(
-        mocks.createFakeWindow("http://example.com"),
-        renderingMocks().getWindowObject()
-      );
-    });
-
-    afterEach(function () {
-      writeHtmlSpy.resetHistory();
-      sendRequestSpy.resetHistory();
-      triggerPixelSpy.resetHistory();
-    });
-
-    after(function () {
-      writeHtmlSpy.restore();
-      sendRequestSpy.restore();
-      triggerPixelSpy.restore();
-    });
-
-    it("should render amp creative", function () {
-      let ucTagData = {
+    let ucTagData;
+    let response;
+
+    beforeEach(function () {
+      sandbox = sinon.sandbox.create();
+      writeHtmlSpy = sandbox.spy(postscribeRender, "writeAdHtml");
+      sendRequestSpy = sandbox.spy(utils, "sendRequest");
+      triggerPixelSpy = sandbox.spy(utils, "triggerPixel");
+      ucTagData = {
         cacheHost: "example.com",
         cachePath: "/path",
         uuid: "123",
         size: "300x250",
-        hbPb: "10.00",
       };
-
-      renderAmpOrMobileAd(ucTagData);
-
-      let response = {
+      response = {
         width: 300,
         height: 250,
         crid: 123,
         adm: "ad-markup${AUCTION_PRICE}",
         wurl: "https://test.prebidcache.wurl",
       };
+    });
+
+
+
+    afterEach(function () {
+      sandbox.restore();
+    });
+
+    it('should send embed-resize message', () => {
+      sandbox.spy(window.parent, 'postMessage');
+      ucTagData.size = '400x500'
+      renderAmpOrMobileAd(ucTagData);
+      requests[0].respond(200, {}, JSON.stringify(response));
+      sinon.assert.calledWith(window.parent.postMessage, {
+        sentinel: "amp",
+        type: "embed-size",
+        width: 400,
+        height: 500,
+      });
+    })
+
+    it("should render amp creative", function () {
+      ucTagData.hbPb = "10.00";
+      renderAmpOrMobileAd(ucTagData);
+
+
       requests[0].respond(200, {}, JSON.stringify(response));
       expect(writeHtmlSpy.args[0][0]).to.equal(
         "<!--Creative 123 served by Prebid.js Header Bidding-->ad-markup10.00"
@@ -245,24 +253,8 @@ describe("renderingManager", function () {
     });
 
     it("should replace AUCTION_PRICE with response.price over hbPb", function () {
-      let ucTagData = {
-        cacheHost: "example.com",
-        cachePath: "/path",
-        uuid: "123",
-        size: "300x250",
-        hbPb: "10.00",
-      };
-
       renderAmpOrMobileAd(ucTagData);
-
-      let response = {
-        width: 300,
-        height: 250,
-        crid: 123,
-        price: 12.5,
-        adm: "ad-markup${AUCTION_PRICE}",
-        wurl: "https://test.prebidcache.wurl",
-      };
+      response.price = 12.5;
       requests[0].respond(200, {}, JSON.stringify(response));
       expect(writeHtmlSpy.args[0][0]).to.equal(
         "<!--Creative 123 served by Prebid.js Header Bidding-->ad-markup12.5"
@@ -276,22 +268,7 @@ describe("renderingManager", function () {
     });
 
     it("should replace AUCTION_PRICE with with empty value when neither price nor hbPb exist", function () {
-      let ucTagData = {
-        cacheHost: "example.com",
-        cachePath: "/path",
-        uuid: "123",
-        size: "300x250",
-      };
-
       renderAmpOrMobileAd(ucTagData);
-
-      let response = {
-        width: 300,
-        height: 250,
-        crid: 123,
-        adm: "ad-markup${AUCTION_PRICE}",
-        wurl: "https://test.prebidcache.wurl",
-      };
       requests[0].respond(200, {}, JSON.stringify(response));
       expect(writeHtmlSpy.args[0][0]).to.equal(
         "<!--Creative 123 served by Prebid.js Header Bidding-->ad-markup"
@@ -306,3 +283,16 @@ describe("renderingManager", function () {
   });
 });
 
+describe('writeAdHtml', () => {
+  it('removes DOCTYPE from markup', () => {
+    const ps = sinon.stub();
+    writeAdHtml('<!DOCTYPE html><div>mock-ad</div>', ps);
+    sinon.assert.calledWith(ps, sinon.match.any, '<div>mock-ad</div>')
+  });
+
+  it('removes lowercase doctype from markup', () => {
+    const ps = sinon.stub();
+    writeAdHtml('<!doctype html><div>mock-ad</div>', ps);
+    sinon.assert.calledWith(ps, sinon.match.any, '<div>mock-ad</div>')
+  });
+})