prebid-universal-creative 1.12.0 → 1.14.0

package/test/spec/nativeORTBTrackerManager_spec.js

@@ -0,0 +1,76 @@
+import { addNativeClickTrackers, fireNativeImpressionTrackers } from 'src/nativeORTBTrackerManager';
+import * as utils from 'src/utils';
+
+describe('test firing native trackers', function () {
+  let triggerPixel;
+  let loadScript;
+  let getElementsByClassName;
+  let sendMessage;
+
+  beforeEach(function () {
+    triggerPixel = sinon.stub(utils, 'triggerPixel');
+    loadScript = sinon.stub(utils, 'loadScript');
+    sendMessage = sinon.spy();
+
+    getElementsByClassName = sinon.stub(document, 'getElementsByClassName').callsFake(() => {
+      return [{
+        addEventListener: (event, callback, capture) => {
+          // immediately call the callback to test the click
+          callback({
+            target: {
+              getAttribute: (name) => {
+                return 1;
+              }
+            }
+          })
+        }
+      }]
+    });
+  });
+
+  afterEach(function () {
+    triggerPixel.restore();
+    loadScript.restore();
+    getElementsByClassName.restore();
+    sendMessage.resetHistory();
+  });
+
+
+  it('should fire impression trackers', function () {
+    let imgUrl = 'foo.bar/event?type=img';
+    let jsUrl = 'foo.bar/event?type=js';
+    
+
+    fireNativeImpressionTrackers("abc123", sendMessage);
+
+    expect(sendMessage.getCall(0).args[0]).to.deep.equal({
+      message: 'Prebid Native', 
+      action: 'fireNativeImpressionTrackers',
+      adId: 'abc123'
+    })
+  });
+
+  it('should fire asset clicktrackers', function () {
+    let assetTrackers = ['foo.bar/click?id=1', 'foo.bar/click?id=2'];
+    let mainTrackers = ['foo.bar/click?id=3'];
+    let adId = "abc123";
+    let nativeOrtb = {
+      assets: [{
+        id: 1,
+        link: { clicktrackers: assetTrackers }
+      }],
+      link: {
+        clicktrackers: mainTrackers
+      }
+    }
+
+    addNativeClickTrackers(adId, nativeOrtb, sendMessage);
+    expect(sendMessage.getCall(0).args[0]).to.deep.equal({
+      message: "Prebid Native",
+      action: 'click',
+      adId: 'abc123',
+      assetId: 1
+    });
+    
+  });
+});

package/test/spec/nativeRenderManager_spec.js

@@ -1,4 +1,5 @@
 import { newNativeRenderManager } from 'src/nativeRenderManager';
+import * as nam  from 'src/nativeAssetManager';
 import { expect } from 'chai';
 import { mocks } from 'test/helpers/mocks';
 import { merge } from 'lodash';
@@ -22,6 +23,17 @@ describe('nativeRenderManager', function () {
   describe('load renderNativeAd', function () {
     let mockWin;
     let consoleWarn;
+    let assetManagerStub;
+
+    before(function() {
+      assetManagerStub = sinon.stub(nam, 'newNativeAssetManager').callsFake(() => {
+        return {
+          loadAssets: (adId, callback) => {
+            callback();
+          }
+        }
+      });
+    });
 
     let tagData = {
       pubUrl: 'http://example.com',
@@ -36,6 +48,11 @@ describe('nativeRenderManager', function () {
 
     afterEach(function () {
       consoleWarn.restore();
+      assetManagerStub.resetHistory();
+    });
+
+    after(function() {
+      assetManagerStub.restore();
     });
 
     it('should verify the postMessage for impression trackers was executed', function() {
@@ -81,7 +98,7 @@ describe('nativeRenderManager', function () {
       expect(mockWin.parent.postMessage.callCount).to.equal(2);
 
       let postMessageTargetDomain = mockWin.parent.postMessage.args[0][1];
-      let postMessageContents = mockWin.parent.postMessage.args[0][0];
+      let postMessageContents = mockWin.parent.postMessage.args[1][0];
       let rawPostMessage = JSON.parse(postMessageContents);
 
       expect(rawPostMessage.message).to.exist.and.to.equal("Prebid Native");

package/test/spec/renderingManager_spec.js

@@ -4,11 +4,11 @@ import * as domHelper from 'src/domHelper';
 import { expect } from 'chai';
 import { mocks } from 'test/helpers/mocks';
 import { merge } from 'lodash';
-import * as postscribe from "postscribe";
 
-const renderingMocks = {
-  messages: [],
-  getWindowObject: function() {
+function renderingMocks() {
+  return {
+    messages: [],
+        getWindowObject: function() {
     return {
       document: {
         body: {
@@ -39,13 +39,17 @@ const renderingMocks = {
       innerHeight: 250
     }
   }
+  }
 }
 
-let mockIframe = {
-  contentDocument: {
-    open: sinon.spy(),
-    write: sinon.spy(),
-    close: sinon.spy()
+function createMockIframe() {
+  return {
+    contentDocument: {
+      open: sinon.spy(),
+      write: sinon.spy(),
+      close: sinon.spy()
+    },
+    style: {},
   }
 }
 
@@ -76,7 +80,7 @@ describe('renderingManager', function() {
       writeHtmlSpy = sinon.spy(utils, 'writeAdHtml');
       sendRequestSpy = sinon.spy(utils, 'sendRequest');
       triggerPixelSpy = sinon.spy(utils, 'triggerPixel');
-      mockWin = merge(mocks.createFakeWindow('http://example.com'), renderingMocks.getWindowObject());
+      mockWin = merge(mocks.createFakeWindow('http://example.com'), renderingMocks().getWindowObject());
     });
 
     afterEach(function() {
@@ -161,36 +165,36 @@ describe('renderingManager', function() {
       expect(sendRequestSpy.args[0][0]).to.equal('https://prebid.adnxs.com/pbc/v1/cache?uuid=123');
     });
 
-    it('should catch errors from creative', function (done) {
-      window.addEventListener('error', e => {
-        done(e.error);
-      });
-
-      const consoleErrorSpy = sinon.spy(console, 'error');
-
-      const renderObject = newRenderingManager(mockWin, env);
-      let ucTagData = {
-        cacheHost: 'example.com',
-        cachePath: '/path',
-        uuid: '123',
-        size: '300x250'
-      };
-
-      renderObject.renderAd(mockWin.document, ucTagData);
-
-      let response = {
-        width: 300,
-        height: 250,
-        crid: 123,
-        adm: '<script src="notExistingScript.js"></script>'
-      };
-      requests[0].respond(200, {}, JSON.stringify(response));
-
-      setTimeout(()=>{
-        expect(consoleErrorSpy.callCount).to.equal(1);
-        done();
-      }, 10);
-    });
+    // it('should catch errors from creative', function (done) {
+    //   window.addEventListener('error', e => {
+    //     done(e.error);
+    //   });
+
+    //   const consoleErrorSpy = sinon.spy(console, 'error');
+
+    //   const renderObject = newRenderingManager(mockWin, env);
+    //   let ucTagData = {
+    //     cacheHost: 'example.com',
+    //     cachePath: '/path',
+    //     uuid: '123',
+    //     size: '300x250'
+    //   };
+
+    //   renderObject.renderAd(mockWin.document, ucTagData);
+
+    //   let response = {
+    //     width: 300,
+    //     height: 250,
+    //     crid: 123,
+    //     adm: '<script src="notExistingScript.js"></script>'
+    //   };
+    //   requests[0].respond(200, {}, JSON.stringify(response));
+
+    //   setTimeout(()=>{
+    //     expect(consoleErrorSpy.callCount).to.equal(1);
+    //     done();
+    //   }, 10);
+    // });
   });
 
   describe('amp creative', function() {
@@ -203,7 +207,7 @@ describe('renderingManager', function() {
       writeHtmlSpy = sinon.spy(utils, 'writeAdHtml');
       sendRequestSpy = sinon.spy(utils, 'sendRequest');
       triggerPixelSpy = sinon.spy(utils, 'triggerPixel');
-      mockWin = merge(mocks.createFakeWindow('http://example.com'), renderingMocks.getWindowObject());
+      mockWin = merge(mocks.createFakeWindow('http://example.com'), renderingMocks().getWindowObject());
     });
 
     afterEach(function() {
@@ -304,64 +308,150 @@ describe('renderingManager', function() {
   });
 
   describe('cross domain creative', function() {
+    const ORIGIN = 'http://example.com';
     let parseStub;
     let iframeStub;
     let triggerPixelSpy;
+    let mockWin;
+    let env;
+    let renderObject;
+    let ucTagData;
+    let mockIframe;
+    let eventSource;
+
     beforeEach(function(){
+      mockIframe = createMockIframe();
       parseStub = sinon.stub(utils, 'parseUrl');
-      iframeStub = sinon.stub(domHelper, 'getEmptyIframe');
+      iframeStub = sinon.stub(domHelper, 'getEmptyIframe').returns(mockIframe);
       triggerPixelSpy = sinon.stub(utils, 'triggerPixel');
-    });
-
-    after(function() {
-      parseStub.restore();
-      iframeStub.restore();
-      triggerPixelSpy.restore();
-    });
-
-    it('should render cross domain creative', function() {
       parseStub.returns({
         protocol: 'http',
         host: 'example.com'
       });
-      iframeStub.returns(mockIframe);
-
-      const mockWin = merge(mocks.createFakeWindow('http://example.com'), renderingMocks.getWindowObject());
-      const env = {
+      mockWin = merge(mocks.createFakeWindow(ORIGIN), renderingMocks().getWindowObject());
+      env = {
         isMobileApp: () => false,
         isAmp: () => false,
         canLocatePrebid: () => false
       };
-      const renderObject = newRenderingManager(mockWin, env);
-      let ucTagData = {
+      renderObject = newRenderingManager(mockWin, env);
+      ucTagData = {
         adId: '123',
         adServerDomain: 'mypub.com',
-        pubUrl: 'http://example.com'
+        pubUrl: ORIGIN,
       };
-
       renderObject.renderAd(mockWin.document, ucTagData);
 
-      // dummy implementation of postmessage from prebid.js
-      let ev = {
-        origin: 'http://example.com',
-        message: JSON.stringify({
-          message: 'Prebid Response',
-          ad: 'ad',
-          adUrl: 'http://example.com',
-          adId: '123',
-          width: 300,
-          height: 250
-        })
-      };
+    });
 
-      mockWin.postMessage(ev);
+    afterEach(function() {
+      parseStub.restore();
+      iframeStub.restore();
+      triggerPixelSpy.restore();
+    });
+
+    function mockPrebidResponse(msg)  {
+      mockWin.postMessage({
+        origin: ORIGIN,
+        message: JSON.stringify(Object.assign({message: 'Prebid Response'}, msg))
+      });
+    }
+
+    it('should render cross domain creative', function() {
+      mockPrebidResponse({
+        ad: 'ad',
+        adUrl: ORIGIN,
+        adId: '123',
+        width: 300,
+        height: 250
+      });
       expect(mockIframe.contentDocument.write.args[0][0]).to.equal("ad");
     });
+
+    describe('should signal event', () => {
+      const RENDER_FAILED = 'adRenderFailed',
+        RENDER_SUCCESS = 'adRenderSucceeded';
+
+      function expectEventMessage(expected) {
+        const actual = JSON.parse(mockWin.parent.postMessage.args[1][0]);
+        sinon.assert.match(actual, Object.assign({message: 'Prebid Event'}, expected));
+      }
+
+      describe('AD_RENDER_FAILED', () => {
+        it('on video ads', () => {
+          mockPrebidResponse({
+            ad: 'ad',
+            adId: '123',
+            mediaType: 'video'
+          });
+          expectEventMessage({
+            adId: '123',
+            event: RENDER_FAILED,
+            info: {
+              reason: 'preventWritingOnMainDocument'
+            }
+          })
+        });
+
+        it('on ads that have no markup or adUrl', () => {
+          mockPrebidResponse({
+            adId: '123',
+          })
+          expectEventMessage({
+            adId: '123',
+            event: RENDER_FAILED,
+            info: {
+              reason: 'noAd'
+            }
+          });
+        });
+
+        it('on exceptions', () => {
+          iframeStub.callsFake(() => {
+            throw new Error()
+          });
+          mockPrebidResponse({
+            adId: '123',
+            ad: 'ad',
+            adUrl: ORIGIN,
+          });
+          expectEventMessage({
+            adId: '123',
+            event: RENDER_FAILED,
+            info: {
+              reason: 'exception'
+            }
+          });
+        })
+      });
+      describe('should post AD_RENDER_SUCCEEDED', () => {
+        it('on ad with markup', () => {
+          mockPrebidResponse({
+            adId: '123',
+            ad: 'markup'
+          });
+          expectEventMessage({
+            adId: '123',
+            event: RENDER_SUCCESS
+          });
+        });
+        it('on ad with adUrl', () => {
+          mockPrebidResponse({
+            adId: '123',
+            adUrl: 'url'
+          });
+          expectEventMessage({
+            adId: '123',
+            event: RENDER_SUCCESS
+          });
+        })
+      })
+    });
   });
 
   describe('legacy creative', function() {
     it('should render legacy creative', function() {
-      const mockWin = merge(mocks.createFakeWindow('http://example.com'), renderingMocks.getWindowObject());
+      const mockWin = merge(mocks.createFakeWindow('http://example.com'), renderingMocks().getWindowObject());
       const env = {
         isMobileApp: () => false,
         isAmp: () => false,