prebid-universal-creative 1.16.0 → 1.17.1

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,10 +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/postscribeRender';
+import {writeAdHtml} from 'src/adHtmlRender';
 
 
 function renderingMocks() {
@@ -188,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"
@@ -246,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"
@@ -277,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"
@@ -308,9 +284,26 @@ describe("renderingManager", function () {
 });
 
 describe('writeAdHtml', () => {
+
+  afterEach(() => {
+    window.testScriptExecuted = undefined;
+  });
+
   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>')
-  })
+    sinon.assert.calledWith(ps, '<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, '<div>mock-ad</div>')
+  });
+
+  it('should execute script tag inserted into the body', () => {
+    const markup = '<script>window.testScriptExecuted=true;</script>'
+    writeAdHtml(markup);
+    expect(window.testScriptExecuted).to.equal(true);
+  });
 })

package/test/spec/nativeAssetManager_spec.js

@@ -3,7 +3,9 @@ import {merge} from 'lodash';
 import {newNativeAssetManager} from 'src/nativeAssetManager';
 import {mocks} from 'test/helpers/mocks';
 import * as utils from 'src/utils';
+import * as dynamic from 'src/dynamicRenderer.js';
 import {prebidMessenger} from '../../src/messaging.js';
+import {MIN_RENDERER_VERSION} from "src/dynamicRenderer.js";
 
 const ORIGIN = 'https://origin.com'
 const AD_ID = 'abc123';
@@ -90,7 +92,7 @@ function generateRenderer(assets) {
 }
 
 describe('nativeAssetManager', () => {
-  let win;
+  let win, sandbox;
 
   function makeManager(args, mkMessenger = prebidMessenger) {
     return newNativeAssetManager(win, {
@@ -101,6 +103,29 @@ describe('nativeAssetManager', () => {
 
   beforeEach(() => {
     win = merge(mocks.createFakeWindow(), mockDocument.getWindowObject());
+    sandbox = sinon.createSandbox();
+  });
+
+  afterEach(() => {
+    sandbox.restore();
+  })
+
+  it(`should run dynamic renderer`, () => {
+    const data = {
+      renderer: 'mock-renderer',
+      rendererVersion: MIN_RENDERER_VERSION,
+      native: 'data'
+    }
+    sandbox.stub(dynamic, 'runDynamicRenderer');
+    const sendMessage = sinon.stub().callsFake((msg, reply) => {
+      reply({data: JSON.stringify(Object.assign({adId: '123', message: 'assetResponse'}, data))});
+    })
+    win.pbNativeData = {
+      requestAllAssets: true
+    };
+    const mgr = makeManager({}, () => sendMessage);
+    mgr.loadAssets('123');
+    sinon.assert.calledWith(dynamic.runDynamicRenderer, '123', sinon.match(data));
   });
 
   describe('safe frames enabled', () => {
@@ -256,7 +281,7 @@ describe('nativeAssetManager', () => {
       ],null,null);
 
       const nativeAssetManager = makeManager();
-      nativeAssetManager.loadAssets(AD_ID);
+      nativeAssetManager.loadAssets(win.pbNativeData.adId);
 
       expect(win.document.body.innerHTML).to.equal(`<script>
                 let nativeTag = {};
@@ -558,8 +583,9 @@ describe('nativeAssetManager', () => {
       }
     })
 
-    it('should set the iframe to the width of the container', () => {
-      const html = `<script>
+    describe('body width resizing', () => {
+      beforeEach(() => {
+        const html = `<script>
                   let nativeTag = {};
                 nativeTag.adTemplate = "<div class=\"sponsored-post\">\r\n  <div class=\"thumbnail\"><\/div>\r\n  <div class=\"content\">\r\n  <h1>\r\n    <a href=\"##hb_native_linkurl##\" target=\"_blank\" class=\"pb-click\">##hb_native_title##<\/a>\r\n   <\/h1>\r\n    <p>##hb_native_body##<\/p>\r\n    \t<div class=\"attribution\">\r\n                   \t<img class=\"pb-icon\" src=\"##hb_native_image##\" alt=\"icon\" height=\"150\" width=\"50\">\r\n \t\r\n           \t<\/div>\r\n\t<\/div>\r\n<\/div>";
                 nativeTag.pubUrl = "https://www.url.com";
@@ -567,27 +593,51 @@ describe('nativeAssetManager', () => {
                 nativeTag.requestAllAssets = true;
                 window.pbNativeTag.renderNativeAd(nativeTag);
         </script>`;
-      win.pbNativeData = {
-        pubUrl : 'https://www.url.com',
-        adId : AD_ID,
-        adTemplate : '<div class=\"sponsored-post\">\r\n  <div class=\"thumbnail\"><\/div>\r\n  <div class=\"content\">\r\n  <h1>\r\n    <a href=\"##hb_native_linkurl##\" target=\"_blank\" class=\"pb-click\">##hb_native_title##<\/a>\r\n   <\/h1>\r\n    <p>##hb_native_body##<\/p>\r\n    \t<div class=\"attribution\">\r\n                   \t<img class=\"pb-icon\" src=\"##hb_native_image##\" alt=\"icon\" height=\"150\" width=\"50\">\r\n \t\r\n           \t<\/div>\r\n\t<\/div>\r\n<\/div>'
-      };
-
-      win.document.body.innerHTML = html;
-      win.addEventListener = createResponder([
-        { key: 'body', value: 'Body content' },
-        { key: 'title', value: 'new value' },
-        { key: 'clickUrl', value: 'http://www.example.com' },
-        { key: 'image', value: 'http://www.image.com/picture.jpg' },
-      ]);
+        win.pbNativeData = {
+          pubUrl : 'https://www.url.com',
+          adId : AD_ID,
+          adTemplate : '<div class=\"sponsored-post\">\r\n  <div class=\"thumbnail\"><\/div>\r\n  <div class=\"content\">\r\n  <h1>\r\n    <a href=\"##hb_native_linkurl##\" target=\"_blank\" class=\"pb-click\">##hb_native_title##<\/a>\r\n   <\/h1>\r\n    <p>##hb_native_body##<\/p>\r\n    \t<div class=\"attribution\">\r\n                   \t<img class=\"pb-icon\" src=\"##hb_native_image##\" alt=\"icon\" height=\"150\" width=\"50\">\r\n \t\r\n           \t<\/div>\r\n\t<\/div>\r\n<\/div>'
+        };
+
+        win.document.body.innerHTML = html;
+        win.addEventListener = createResponder([
+          { key: 'body', value: 'Body content' },
+          { key: 'title', value: 'new value' },
+          { key: 'clickUrl', value: 'http://www.example.com' },
+          { key: 'image', value: 'http://www.image.com/picture.jpg' },
+        ]);
+      });
 
-      const nativeAssetManager = makeManager();
-      nativeAssetManager.loadAssets(AD_ID);
+      it('should not choke when parent window is not available',() => {
+        win.parent.frames = [win];
+        Object.defineProperty(win.parent, 'document', {
+          get() {
+            throw new Error('unvailable');
+          }
+        })
+        const nativeAssetManager = makeManager();
+        nativeAssetManager.loadAssets(AD_ID);
+        expect(win.document.body.innerHTML).to.include(`<a href="http://www.example.com" target="_blank" class="pb-click">new value</a>`);
+      });
 
-      expect(win.document.body.innerHTML).to.include(`<a href="http://www.example.com" target="_blank" class="pb-click">new value</a>`);
-      expect(win.document.body.innerHTML).to.include(`<img class="pb-icon" src="http://www.image.com/picture.jpg" alt="icon" height="150" width="50">`);
-      expect(win.document.body.innerHTML).to.include(`<p>Body content</p>`);
-      expect(win.document.body.style.width).to.equal('600px');
+      it('should not request width resize if width is 1', () => {
+        sandbox.stub(document.body, 'clientWidth').get(() => 1);
+        const nativeAssetManager = makeManager();
+        nativeAssetManager.loadAssets(AD_ID);
+        const resizeRequest = win.parent.postMessage.args
+            .map(([msg]) => JSON.parse(msg))
+            .find((msg) => msg.action === 'resizeNativeHeight')
+        expect(resizeRequest.width).to.not.exist;
+      })
+
+      it('should set the iframe to the width of the container', () => {
+        const nativeAssetManager = makeManager();
+        nativeAssetManager.loadAssets(AD_ID);
+        expect(win.document.body.innerHTML).to.include(`<a href="http://www.example.com" target="_blank" class="pb-click">new value</a>`);
+        expect(win.document.body.innerHTML).to.include(`<img class="pb-icon" src="http://www.image.com/picture.jpg" alt="icon" height="150" width="50">`);
+        expect(win.document.body.innerHTML).to.include(`<p>Body content</p>`);
+        expect(win.document.body.style.width).to.equal('600px');
+      });
     });
   });
 

package/test/spec/renderingManager_spec.js

@@ -1,9 +1,11 @@
 import { renderCrossDomain, renderLegacy } from 'src/renderingManager';
 import * as utils from 'src/utils';
 import * as domHelper from 'src/domHelper';
+import * as dynamic from 'src/dynamicRenderer.js';
 import { expect } from 'chai';
 import { mocks } from 'test/helpers/mocks';
 import { merge } from 'lodash';
+import {MIN_RENDERER_VERSION} from "src/dynamicRenderer.js";
 
 function renderingMocks() {
   return {
@@ -72,6 +74,7 @@ describe('renderingManager', function() {
 
   describe('cross domain creative', function() {
     const ORIGIN = 'http://example.com';
+    let sandbox;
     let parseStub;
     let iframeStub;
     let triggerPixelSpy;
@@ -81,10 +84,11 @@ describe('renderingManager', function() {
     let eventSource;
 
     beforeEach(function(){
+      sandbox = sinon.createSandbox();
       mockIframe = createMockIframe();
-      parseStub = sinon.stub(utils, 'parseUrl');
-      iframeStub = sinon.stub(domHelper, 'getEmptyIframe').returns(mockIframe);
-      triggerPixelSpy = sinon.stub(utils, 'triggerPixel');
+      parseStub = sandbox.stub(utils, 'parseUrl');
+      iframeStub = sandbox.stub(domHelper, 'getEmptyIframe').returns(mockIframe);
+      triggerPixelSpy = sandbox.stub(utils, 'triggerPixel');
       parseStub.returns({
         protocol: 'http',
         host: 'example.com'
@@ -102,9 +106,7 @@ describe('renderingManager', function() {
     });
 
     afterEach(function () {
-      parseStub.restore();
-      iframeStub.restore();
-      triggerPixelSpy.restore();
+      sandbox.restore();
     });
 
     function mockPrebidResponse(msg)  {
@@ -114,6 +116,18 @@ describe('renderingManager', function() {
       });
     }
 
+    it('should run renderer if present', () => {
+      sandbox.stub(dynamic, 'runDynamicRenderer');
+      const data = {
+        adId: '123',
+        renderer: 'mock-renderer',
+        rendererVersion: MIN_RENDERER_VERSION,
+        ad: 'markup'
+      };
+      mockPrebidResponse(data);
+      sinon.assert.calledWith(dynamic.runDynamicRenderer, data.adId, sinon.match(data))
+    })
+
     it("should render cross domain creative", function () {
       mockPrebidResponse({
         ad: "ad",