prebid.js 5.19.0 → 5.20.3

package/test/spec/modules/adxcgBidAdapter_spec.js

@@ -1,653 +1,909 @@
-import {expect} from 'chai';
+// jshint esversion: 6, es3: false, node: true
+import {assert} from 'chai';
 import {spec} from 'modules/adxcgBidAdapter.js';
-import {deepClone, parseUrl} from 'src/utils.js';
-import * as utils from '../../../src/utils.js';
-
-describe('AdxcgAdapter', function () {
-  let bidBanner = {
-    bidder: 'adxcg',
-    params: {
-      adzoneid: '1'
-    },
-    adUnitCode: 'adunit-code',
-    mediaTypes: {
-      banner: {
-        sizes: [
-          [300, 250],
-          [640, 360],
-          [1, 1]
-        ]
-      }
-    },
-    bidId: '84ab500420319d',
-    bidderRequestId: '7101db09af0db2',
-    auctionId: '1d1a030790a475'
-  };
-
-  let bidVideo = {
-    bidder: 'adxcg',
-    params: {
-      adzoneid: '20',
-      video: {
-        api: [2],
-        maxduration: 30
-      }
-    },
-    mediaTypes: {
-      video: {
-        context: 'instream',
-        playerSize: [[640, 480]],
-        protocols: [1, 2],
-        mimes: ['video/mp4'],
-      }
-    },
-    adUnitCode: 'adunit-code',
-    bidId: '84ab500420319d',
-    bidderRequestId: '7101db09af0db2',
-    auctionId: '1d1a030790a475'
-  };
-
-  let bidNative = {
-    bidder: 'adxcg',
-    params: {
-      adzoneid: '2379'
-    },
-    mediaTypes: {
-      native: {
-        image: {
-          sendId: false,
-          required: true,
-          sizes: [80, 80]
-        },
-        title: {
-          required: true,
-          len: 75
-        },
-        body: {
-          required: true,
-          len: 200
-        },
-        sponsoredBy: {
-          required: false,
-          len: 20
-        }
-      }
-    },
-    adUnitCode: 'adunit-code',
-    bidId: '84ab500420319d',
-    bidderRequestId: '7101db09af0db2',
-    auctionId: '1d1a030790a475'
-  };
+import {config} from 'src/config.js';
+import {createEidsArray} from 'modules/userId/eids.js';
+const utils = require('src/utils');
 
-  describe('isBidRequestValid', function () {
-    it('should return true when required params found bidNative', function () {
-      expect(spec.isBidRequestValid(bidNative)).to.equal(true);
-    });
+describe('Adxcg adapter', function () {
+  let bids = [];
 
-    it('should return true when required params  found bidVideo', function () {
-      expect(spec.isBidRequestValid(bidVideo)).to.equal(true);
-    });
+  describe('isBidRequestValid', function () {
+    let bid = {
+      'bidder': 'adxcg',
+      'params': {
+        'adzoneid': '19910113'
+      }
+    };
 
-    it('should return true when required params found bidBanner', function () {
-      expect(spec.isBidRequestValid(bidBanner)).to.equal(true);
-    });
+    it('should return true when required params found', function () {
+      assert(spec.isBidRequestValid(bid));
 
-    it('should return false when required params not found', function () {
-      expect(spec.isBidRequestValid({})).to.be.false;
+      bid.params = {
+        adzoneid: 4332,
+      };
+      assert(spec.isBidRequestValid(bid));
     });
 
-    it('should return false when required params are not passed', function () {
-      let bid = Object.assign({}, bidBanner);
-      delete bid.params;
+    it('should return false when required params are missing', function () {
       bid.params = {};
-      expect(spec.isBidRequestValid(bid)).to.equal(false);
-    });
+      assert.isFalse(spec.isBidRequestValid(bid));
 
-    it('should return true when required video params not found', function () {
-      const simpleVideo = JSON.parse(JSON.stringify(bidVideo));
-      simpleVideo.params.adzoneid = 123;
-      expect(spec.isBidRequestValid(simpleVideo)).to.be.false;
+      bid.params = {
+        mname: 'some-placement'
+      };
+      assert.isFalse(spec.isBidRequestValid(bid));
+
+      bid.params = {
+        inv: 1234
+      };
+      assert.isFalse(spec.isBidRequestValid(bid));
     });
   });
 
-  describe('request function http', function () {
-    it('creates a valid adxcg request url bidBanner', function () {
-      let request = spec.buildRequests([bidBanner]);
-      expect(request).to.exist;
-      expect(request.method).to.equal('GET');
-      let parsedRequestUrl = parseUrl(request.url);
-      expect(parsedRequestUrl.hostname).to.equal('hbps.adxcg.net');
-      expect(parsedRequestUrl.pathname).to.equal('/get/adi');
-
-      let query = parsedRequestUrl.search;
-      expect(query.renderformat).to.equal('javascript');
-      expect(query.ver).to.equal('r20210330PB40');
-      expect(query.source).to.equal('pbjs10');
-      expect(query.pbjs).to.equal('$prebid.version$');
-      expect(query.adzoneid).to.equal('1');
-      expect(query.format).to.equal('300x250|640x360|1x1');
-      expect(query.jsonp).to.be.undefined;
-      expect(query.prebidBidIds).to.equal('84ab500420319d');
-      expect(query.bidfloors).to.equal('0');
-
-      expect(query).to.have.property('secure');
-      expect(query).to.have.property('uw');
-      expect(query).to.have.property('uh');
-      expect(query).to.have.property('dpr');
-      expect(query).to.have.property('bt');
-      expect(query).to.have.property('cookies');
-      expect(query).to.have.property('tz');
-      expect(query).to.have.property('dt');
-      expect(query).to.have.property('iob');
-      expect(query).to.have.property('rndid');
-      expect(query).to.have.property('ref');
-      expect(query).to.have.property('url');
+  describe('buildRequests', function () {
+    beforeEach(function () {
+      config.resetConfig();
     });
+    it('should send request with correct structure', function () {
+      let validBidRequests = [{
+        bidId: 'bidId',
+        params: {
+          adzoneid: '19910113'
+        }
+      }];
+      let request = spec.buildRequests(validBidRequests, {refererInfo: {referer: 'page'}});
 
-    it('creates a valid adxcg request url bidVideo', function () {
-      let request = spec.buildRequests([bidVideo]);
-      expect(request).to.exist;
-      expect(request.method).to.equal('GET');
-      let parsedRequestUrl = parseUrl(request.url);
-      expect(parsedRequestUrl.hostname).to.equal('hbps.adxcg.net');
-      expect(parsedRequestUrl.pathname).to.equal('/get/adi');
-
-      let query = parsedRequestUrl.search;
-      // general part
-      expect(query.renderformat).to.equal('javascript');
-      expect(query.ver).to.equal('r20210330PB40');
-      expect(query.source).to.equal('pbjs10');
-      expect(query.pbjs).to.equal('$prebid.version$');
-      expect(query.adzoneid).to.equal('20');
-      expect(query.format).to.equal('640x480');
-      expect(query.jsonp).to.be.undefined;
-      expect(query.prebidBidIds).to.equal('84ab500420319d');
-      expect(query.bidfloors).to.equal('0');
-
-      expect(query).to.have.property('secure');
-      expect(query).to.have.property('uw');
-      expect(query).to.have.property('uh');
-      expect(query).to.have.property('dpr');
-      expect(query).to.have.property('bt');
-      expect(query).to.have.property('cookies');
-      expect(query).to.have.property('tz');
-      expect(query).to.have.property('dt');
-      expect(query).to.have.property('iob');
-      expect(query).to.have.property('rndid');
-      expect(query).to.have.property('ref');
-      expect(query).to.have.property('url');
-
-      // video specific part
-      expect(query['video.maxduration.0']).to.equal('30');
-      expect(query['video.mimes.0']).to.equal('video/mp4');
-      expect(query['video.context.0']).to.equal('instream');
+      assert.equal(request.method, 'POST');
+      assert.equal(request.url, 'https://pbc.adxcg.net/rtb/ortb/pbc?adExchangeId=1');
+      assert.deepEqual(request.options, {contentType: 'application/json'});
+      assert.ok(request.data);
     });
 
-    it('creates a valid adxcg request url bidNative', function () {
-      let request = spec.buildRequests([bidNative]);
-      expect(request).to.exist;
-      expect(request.method).to.equal('GET');
-      let parsedRequestUrl = parseUrl(request.url);
-      expect(parsedRequestUrl.hostname).to.equal('hbps.adxcg.net');
-      expect(parsedRequestUrl.pathname).to.equal('/get/adi');
-
-      let query = parsedRequestUrl.search;
-      expect(query.renderformat).to.equal('javascript');
-      expect(query.ver).to.equal('r20210330PB40');
-      expect(query.source).to.equal('pbjs10');
-      expect(query.pbjs).to.equal('$prebid.version$');
-      expect(query.adzoneid).to.equal('2379');
-      expect(query.format).to.equal('0x0');
-      expect(query.jsonp).to.be.undefined;
-      expect(query.prebidBidIds).to.equal('84ab500420319d');
-      expect(query.bidfloors).to.equal('0');
-
-      expect(query).to.have.property('secure');
-      expect(query).to.have.property('uw');
-      expect(query).to.have.property('uh');
-      expect(query).to.have.property('dpr');
-      expect(query).to.have.property('bt');
-      expect(query).to.have.property('cookies');
-      expect(query).to.have.property('tz');
-      expect(query).to.have.property('dt');
-      expect(query).to.have.property('iob');
-      expect(query).to.have.property('rndid');
-      expect(query).to.have.property('ref');
-      expect(query).to.have.property('url');
-    });
-  });
+    describe('user privacy', function () {
+      it('should send GDPR Consent data to exchange if gdprApplies', function () {
+        let validBidRequests = [{bidId: 'bidId', params: {test: 1}}];
+        let bidderRequest = {
+          gdprConsent: {gdprApplies: true, consentString: 'consentDataString'},
+          refererInfo: {referer: 'page'}
+        };
+        let request = JSON.parse(spec.buildRequests(validBidRequests, bidderRequest).data);
+
+        assert.equal(request.user.ext.consent, bidderRequest.gdprConsent.consentString);
+        assert.equal(request.regs.ext.gdpr, bidderRequest.gdprConsent.gdprApplies);
+        assert.equal(typeof request.regs.ext.gdpr, 'number');
+      });
 
-  describe('gdpr compliance', function () {
-    it('should send GDPR Consent data if gdprApplies', function () {
-      let request = spec.buildRequests([bidBanner], {
-        gdprConsent: {
-          gdprApplies: true,
-          consentString: 'consentDataString'
-        }
+      it('should send gdpr as number', function () {
+        let validBidRequests = [{bidId: 'bidId', params: {test: 1}}];
+        let bidderRequest = {
+          gdprConsent: {gdprApplies: true, consentString: 'consentDataString'},
+          refererInfo: {referer: 'page'}
+        };
+        let request = JSON.parse(spec.buildRequests(validBidRequests, bidderRequest).data);
+
+        assert.equal(typeof request.regs.ext.gdpr, 'number');
+        assert.equal(request.regs.ext.gdpr, 1);
       });
-      let parsedRequestUrl = parseUrl(request.url);
-      let query = parsedRequestUrl.search;
 
-      expect(query.gdpr).to.equal('1');
-      expect(query.gdpr_consent).to.equal('consentDataString');
-    });
+      it('should send CCPA Consent data to exchange', function () {
+        let validBidRequests = [{bidId: 'bidId', params: {test: 1}}];
+        let bidderRequest = {uspConsent: '1YA-', refererInfo: {referer: 'page'}};
+        let request = JSON.parse(spec.buildRequests(validBidRequests, bidderRequest).data);
 
-    it('should not send GDPR Consent data if gdprApplies is false or undefined', function () {
-      let request = spec.buildRequests([bidBanner], {
-        gdprConsent: {
-          gdprApplies: false,
-          consentString: 'consentDataString'
-        }
+        assert.equal(request.regs.ext.us_privacy, '1YA-');
+
+        bidderRequest = {
+          uspConsent: '1YA-',
+          gdprConsent: {gdprApplies: true, consentString: 'consentDataString'},
+          refererInfo: {referer: 'page'}
+        };
+        request = JSON.parse(spec.buildRequests(validBidRequests, bidderRequest).data);
+
+        assert.equal(request.regs.ext.us_privacy, '1YA-');
+        assert.equal(request.user.ext.consent, 'consentDataString');
+        assert.equal(request.regs.ext.gdpr, 1);
       });
-      let parsedRequestUrl = parseUrl(request.url);
-      let query = parsedRequestUrl.search;
 
-      expect(query.gdpr).to.be.undefined;
-      expect(query.gdpr_consent).to.be.undefined;
+      it('should not send GDPR Consent data to adxcg if gdprApplies is undefined', function () {
+        let validBidRequests = [{
+          bidId: 'bidId',
+          params: {siteId: 'siteId'}
+        }];
+        let bidderRequest = {
+          gdprConsent: {gdprApplies: false, consentString: 'consentDataString'},
+          refererInfo: {referer: 'page'}
+        };
+        let request = JSON.parse(spec.buildRequests(validBidRequests, bidderRequest).data);
+
+        assert.equal(request.user.ext.consent, 'consentDataString');
+        assert.equal(request.regs.ext.gdpr, 0);
+
+        bidderRequest = {gdprConsent: {consentString: 'consentDataString'}, refererInfo: {referer: 'page'}};
+        request = JSON.parse(spec.buildRequests(validBidRequests, bidderRequest).data);
+
+        assert.equal(request.user, undefined);
+        assert.equal(request.regs, undefined);
+      });
+      it('should send default GDPR Consent data to exchange', function () {
+        let validBidRequests = [{
+          bidId: 'bidId',
+          params: {siteId: 'siteId'}
+        }];
+        let request = JSON.parse(spec.buildRequests(validBidRequests, {refererInfo: {referer: 'page'}}).data);
+
+        assert.equal(request.user, undefined);
+        assert.equal(request.regs, undefined);
+      });
     });
-  });
 
-  describe('userid pubcid should be passed to querystring', function () {
-    let bidderRequests = {};
-    let bid = deepClone([bidBanner]);
-    bid[0].userId = {pubcid: 'pubcidabcd'};
+    it('should add test and is_debug to request, if test is set in parameters', function () {
+      let validBidRequests = [{
+        bidId: 'bidId',
+        params: {test: 1}
+      }];
+      let request = JSON.parse(spec.buildRequests(validBidRequests, {refererInfo: {referer: 'page'}}).data);
 
-    it('should send pubcid if available', function () {
-      let request = spec.buildRequests(bid, bidderRequests);
-      let parsedRequestUrl = parseUrl(request.url);
-      let query = parsedRequestUrl.search;
-      expect(query.pubcid).to.equal('pubcidabcd');
+      assert.ok(request.is_debug);
+      assert.equal(request.test, 1);
     });
-  });
 
-  describe('userid tdid should be passed to querystring', function () {
-    let bid = deepClone([bidBanner]);
-    let bidderRequests = {};
+    it('should have default request structure', function () {
+      let keys = 'site,geo,device,source,ext,imp'.split(',');
+      let validBidRequests = [{
+        bidId: 'bidId',
+        params: {siteId: 'siteId'}
+      }];
+      let request = JSON.parse(spec.buildRequests(validBidRequests, {refererInfo: {referer: 'page'}}).data);
+      let data = Object.keys(request);
+
+      assert.deepEqual(keys, data);
+    });
 
-    bid[0].userId = {tdid: 'tdidabcd'};
+    it('should set request keys correct values', function () {
+      let validBidRequests = [{
+        bidId: 'bidId',
+        params: {siteId: 'siteId'},
+        transactionId: 'transactionId'
+      }];
+      let request = JSON.parse(spec.buildRequests(validBidRequests, {refererInfo: {referer: 'page'}}).data);
 
-    it('should send pubcid if available', function () {
-      let request = spec.buildRequests(bid, bidderRequests);
-      let parsedRequestUrl = parseUrl(request.url);
-      let query = parsedRequestUrl.search;
-      expect(query.tdid).to.equal('tdidabcd');
+      assert.equal(request.source.tid, validBidRequests[0].transactionId);
+      assert.equal(request.source.fd, 1);
     });
-  });
 
-  describe('userid id5id should be passed to querystring', function () {
-    let bid = deepClone([bidBanner]);
-    let bidderRequests = {};
+    it('should send info about device', function () {
+      config.setConfig({
+        device: {w: 100, h: 100}
+      });
+      let validBidRequests = [{
+        bidId: 'bidId',
+        params: {adzoneid: '1000'}
+      }];
+      let request = JSON.parse(spec.buildRequests(validBidRequests, {refererInfo: {referer: 'page'}}).data);
+
+      assert.equal(request.device.ua, navigator.userAgent);
+      assert.equal(request.device.w, 100);
+      assert.equal(request.device.h, 100);
+    });
 
-    bid[0].userId = {id5id: {uid: 'id5idsample'}};
+    it('should send app info', function () {
+      config.setConfig({
+        app: {id: 'appid'},
+        ortb2: {app: {name: 'appname'}}
+      });
+      let validBidRequests = [{
+        bidId: 'bidId',
+        params: {adzoneid: '1000'}
+      }];
+      let request = JSON.parse(spec.buildRequests(validBidRequests, {refererInfo: {referer: 'page'}}).data);
+
+      assert.equal(request.app.id, 'appid');
+      assert.equal(request.app.name, 'appname');
+      assert.equal(request.site, undefined);
+    });
 
-    it('should send pubcid if available', function () {
-      let request = spec.buildRequests(bid, bidderRequests);
-      let parsedRequestUrl = parseUrl(request.url);
-      let query = parsedRequestUrl.search;
-      expect(query.id5id).to.equal('id5idsample');
+    it('should send info about the site', function () {
+      config.setConfig({
+        site: {
+          id: '123123',
+          publisher: {
+            domain: 'publisher.domain.com'
+          }
+        },
+        ortb2: {
+          site: {
+            publisher: {
+              id: 4441,
+              name: 'publishers name'
+            }
+          }
+        }
+      });
+      let validBidRequests = [{
+        bidId: 'bidId',
+        params: {adzoneid: '1000'}
+      }];
+      let refererInfo = {referer: 'page'};
+      let request = JSON.parse(spec.buildRequests(validBidRequests, {refererInfo}).data);
+
+      let expected = {
+        id: '123123',
+        publisher: {
+          domain: 'publisher.domain.com',
+          id: 4441,
+          name: 'publishers name'
+        },
+        page: 'page',
+        domain: 'localhost'
+      };
+
+      assert.deepEqual(request.site.id, expected.id);
+      assert.deepEqual(request.site.publisher, expected.publisher);
+      assert.deepEqual(request.site.page, expected.page);
+      // assert.deepEqual(request.site.domain, expected.site.domain); // disabled for browser specific problem (IE11)
+      // in browserstack IE 11 we get empty "" request.site.domain, while in gulp test we get "localhost"
+      // all other browserstack enabled browsers work without problem
     });
-  });
 
-  describe('userid idl_env should be passed to querystring', function () {
-    let bid = deepClone([bidBanner]);
-    let bidderRequests = {};
+    it('should pass extended ids', function () {
+      let validBidRequests = [{
+        bidId: 'bidId',
+        params: {},
+        userIdAsEids: createEidsArray({
+          tdid: 'TTD_ID_FROM_USER_ID_MODULE',
+          pubcid: 'pubCommonId_FROM_USER_ID_MODULE'
+        })
+      }];
+
+      let request = JSON.parse(spec.buildRequests(validBidRequests, {refererInfo: {referer: 'page'}}).data);
+      assert.deepEqual(request.user.ext.eids, [
+        {source: 'adserver.org', uids: [{id: 'TTD_ID_FROM_USER_ID_MODULE', atype: 1, ext: {rtiPartner: 'TDID'}}]},
+        {source: 'pubcid.org', uids: [{id: 'pubCommonId_FROM_USER_ID_MODULE', atype: 1}]}
+      ]);
+    });
 
-    bid[0].userId = {idl_env: 'idl_envsample'};
+    it('should send currency if defined', function () {
+      config.setConfig({currency: {adServerCurrency: 'EUR'}});
+      let validBidRequests = [{params: {}}];
+      let refererInfo = {referer: 'page'};
+      let request = JSON.parse(spec.buildRequests(validBidRequests, {refererInfo}).data);
 
-    it('should send pubcid if available', function () {
-      let request = spec.buildRequests(bid, bidderRequests);
-      let parsedRequestUrl = parseUrl(request.url);
-      let query = parsedRequestUrl.search;
-      expect(query.idl_env).to.equal('idl_envsample');
+      assert.deepEqual(request.cur, ['EUR']);
     });
-  });
 
-  describe('response handler', function () {
-    let BIDDER_REQUEST = {
-      bidder: 'adxcg',
-      params: {
-        adzoneid: '1'
-      },
-      adUnitCode: 'adunit-code',
-      mediaTypes: {
-        banner: {
-          sizes: [
-            [300, 250],
-            [640, 360],
-            [1, 1]
-          ]
+    it('should pass supply chain object', function () {
+      let validBidRequests = [{
+        bidId: 'bidId',
+        params: {},
+        schain: {
+          validation: 'strict',
+          config: {
+            ver: '1.0'
+          }
         }
-      },
-      bidId: '84ab500420319d',
-      bidderRequestId: '7101db09af0db2',
-      auctionId: '1d1a030790a475'
-    };
+      }];
 
-    let BANNER_RESPONSE = {
-      body: {
-        id: 'auctionid',
-        bidid: '84ab500420319d',
-        seatbid: [{
-          bid: [
-            {
-              impid: '84ab500420319d',
-              price: 0.45,
-              crid: '42',
-              adm: '<!-- adContent -->',
-              w: 300,
-              h: 250,
-              adomain: ['adomain.com'],
-              cat: ['IAB1-4', 'IAB8-16', 'IAB25-5'],
-              ext: {
-                crType: 'banner',
-                advertiser_id: '777',
-                advertiser_name: 'advertiser',
-                agency_name: 'agency'
-              }
+      let request = JSON.parse(spec.buildRequests(validBidRequests, {refererInfo: {referer: 'page'}}).data);
+      assert.deepEqual(request.source.ext.schain, {
+        validation: 'strict',
+        config: {
+          ver: '1.0'
+        }
+      });
+    });
+
+    describe('bids', function () {
+      it('should add more than one bid to the request', function () {
+        let validBidRequests = [{
+          bidId: 'bidId',
+          params: {siteId: 'siteId'}
+        }, {
+          bidId: 'bidId2',
+          params: {siteId: 'siteId'}
+        }];
+        let request = JSON.parse(spec.buildRequests(validBidRequests, {refererInfo: {referer: 'page'}}).data);
+
+        assert.equal(request.imp.length, 2);
+      });
+      it('should add incrementing values of id', function () {
+        let validBidRequests = [{
+          bidId: 'bidId',
+          params: {adzoneid: '1000'},
+          mediaTypes: {video: {}}
+        }, {
+          bidId: 'bidId2',
+          params: {adzoneid: '1000'},
+          mediaTypes: {video: {}}
+        }, {
+          bidId: 'bidId3',
+          params: {adzoneid: '1000'},
+          mediaTypes: {video: {}}
+        }];
+        let imps = JSON.parse(spec.buildRequests(validBidRequests, {refererInfo: {referer: 'page'}}).data).imp;
+
+        for (let i = 0; i < 3; i++) {
+          assert.equal(imps[i].id, i + 1);
+        }
+      });
+
+      it('should add adzoneid', function () {
+        let validBidRequests = [{bidId: 'bidId', params: {adzoneid: 1000}, mediaTypes: {video: {}}},
+          {bidId: 'bidId2', params: {adzoneid: 1001}, mediaTypes: {video: {}}},
+          {bidId: 'bidId3', params: {adzoneid: 1002}, mediaTypes: {video: {}}}];
+        let imps = JSON.parse(spec.buildRequests(validBidRequests, {refererInfo: {referer: 'page'}}).data).imp;
+        for (let i = 0; i < 3; i++) {
+          assert.equal(imps[i].tagid, validBidRequests[i].params.adzoneid);
+        }
+      });
+
+      describe('price floors', function () {
+        it('should not add if floors module not configured', function () {
+          const validBidRequests = [{bidId: 'bidId', params: {adzoneid: 1000}, mediaTypes: {video: {}}}];
+          let imp = getRequestImps(validBidRequests)[0];
+
+          assert.equal(imp.bidfloor, undefined);
+          assert.equal(imp.bidfloorcur, undefined);
+        });
+
+        it('should not add if floor price not defined', function () {
+          const validBidRequests = [getBidWithFloor()];
+          let imp = getRequestImps(validBidRequests)[0];
+
+          assert.equal(imp.bidfloor, undefined);
+          assert.equal(imp.bidfloorcur, 'USD');
+        });
+
+        it('should request floor price in adserver currency', function () {
+          config.setConfig({currency: {adServerCurrency: 'DKK'}});
+          const validBidRequests = [getBidWithFloor()];
+          let imp = getRequestImps(validBidRequests)[0];
+
+          assert.equal(imp.bidfloor, undefined);
+          assert.equal(imp.bidfloorcur, 'DKK');
+        });
+
+        it('should add correct floor values', function () {
+          const expectedFloors = [1, 1.3, 0.5];
+          const validBidRequests = expectedFloors.map(getBidWithFloor);
+          let imps = getRequestImps(validBidRequests);
+
+          expectedFloors.forEach((floor, index) => {
+            assert.equal(imps[index].bidfloor, floor);
+            assert.equal(imps[index].bidfloorcur, 'USD');
+          });
+        });
+
+        function getBidWithFloor(floor) {
+          return {
+            params: {adzoneid: 1},
+            mediaTypes: {video: {}},
+            getFloor: ({currency}) => {
+              return {
+                currency: currency,
+                floor
+              };
             }
-          ]
-        }],
-        cur: 'USD'
-      },
-      headers: {someheader: 'fakedata'}
-    };
+          };
+        }
+      });
 
-    let BANNER_RESPONSE_WITHDEALID = {
-      body: {
-        id: 'auctionid',
-        bidid: '84ab500420319d',
-        seatbid: [{
-          bid: [
-            {
-              impid: '84ab500420319d',
-              price: 0.45,
-              crid: '42',
-              dealid: '7722',
-              adm: '<!-- adContent -->',
-              w: 300,
-              h: 250,
-              adomain: ['adomain.com'],
-              ext: {
-                crType: 'banner'
-              }
+      describe('multiple media types', function () {
+        it('should use all configured media types for bidding', function () {
+          let validBidRequests = [{
+            bidId: 'bidId',
+            params: {adzoneid: 1000},
+            mediaTypes: {
+              banner: {
+                sizes: [[100, 100], [200, 300]]
+              },
+              video: {}
             }
-          ]
-        }],
-        cur: 'USD'
-      }
-    };
+          }, {
+            bidId: 'bidId1',
+            params: {adzoneid: 1000},
+            mediaTypes: {
+              video: {},
+              native: {}
+            }
+          }, {
+            bidId: 'bidId2',
+            params: {adzoneid: 1000},
+            nativeParams: {
+              title: {required: true, len: 140}
+            },
+            mediaTypes: {
+              banner: {
+                sizes: [[100, 100], [200, 300]]
+              },
+              native: {},
+              video: {}
+            }
+          }];
+          let [first, second, third] = JSON.parse(spec.buildRequests(validBidRequests, {refererInfo: {referer: 'page'}}).data).imp;
 
-    let VIDEO_RESPONSE = {
-      body: {
-        id: 'auctionid',
-        bidid: '84ab500420319d',
-        seatbid: [{
-          bid: [
-            {
-              impid: '84ab500420319d',
-              price: 0.45,
-              crid: '42',
-              nurl: 'vastContentUrl',
-              adomain: ['adomain.com'],
-              w: 640,
-              h: 360,
-              ext: {
-                crType: 'video'
+          assert.ok(first.banner);
+          assert.ok(first.video);
+          assert.equal(first.native, undefined);
+
+          assert.ok(second.video);
+          assert.equal(second.banner, undefined);
+          assert.equal(second.native, undefined);
+
+          assert.ok(third.native);
+          assert.ok(third.video);
+          assert.ok(third.banner);
+        });
+      });
+
+      describe('banner', function () {
+        it('should convert sizes to openrtb format', function () {
+          let validBidRequests = [{
+            bidId: 'bidId',
+            params: {adzoneid: 1000},
+            mediaTypes: {
+              banner: {
+                sizes: [[100, 100], [200, 300]]
               }
             }
-          ]
-        }],
-        cur: 'USD'
-      },
-      headers: {someheader: 'fakedata'}
-    };
-
-    let NATIVE_RESPONSEob = {
-      assets: [
-        {
-          id: 1,
-          required: 0,
-          title: {
-            text: 'titleContent'
-          }
-        },
-        {
-          id: 2,
-          required: 0,
-          img: {
-            url: 'imageContent',
-            w: 600,
-            h: 600
-          }
-        },
-        {
-          id: 3,
-          required: 0,
-          data: {
-            label: 'DESC',
-            value: 'descriptionContent'
-          }
-        },
-        {
-          id: 0,
-          required: 0,
-          data: {
-            label: 'SPONSORED',
-            value: 'sponsoredByContent'
-          }
-        },
-        {
-          id: 5,
-          required: 0,
-          icon: {
-            url: 'iconContent',
-            w: 400,
-            h: 400
-          }
-        }
-      ],
-      link: {
-        url: 'linkContent'
-      },
-      imptrackers: ['impressionTracker1', 'impressionTracker2']
-    }
+          }];
+          let {banner} = JSON.parse(spec.buildRequests(validBidRequests, {refererInfo: {referer: 'page'}}).data).imp[0];
+          assert.deepEqual(banner, {
+            format: [{w: 100, h: 100}, {w: 200, h: 300}]
+          });
+        });
+      });
 
-    let NATIVE_RESPONSE = {
-      body: {
-        id: 'auctionid',
-        bidid: '84ab500420319d',
-        seatbid: [{
-          bid: [
-            {
-              impid: '84ab500420319d',
-              price: 0.45,
-              crid: '42',
-              w: 0,
-              h: 0,
-              adm: JSON.stringify(NATIVE_RESPONSEob),
-              adomain: ['adomain.com'],
-              ext: {
-                crType: 'native'
+      describe('video', function () {
+        it('should pass video mediatype config', function () {
+          let validBidRequests = [{
+            bidId: 'bidId',
+            params: {adzoneid: 1000},
+            mediaTypes: {
+              video: {
+                playerSize: [640, 480],
+                context: 'outstream',
+                mimes: ['video/mp4']
               }
             }
-          ]
-        }],
-        cur: 'USD'
-      },
-      headers: {someheader: 'fakedata'}
-    };
+          }];
+          let {video} = JSON.parse(spec.buildRequests(validBidRequests, {refererInfo: {referer: 'page'}}).data).imp[0];
+          assert.deepEqual(video, {
+            playerSize: [640, 480],
+            context: 'outstream',
+            mimes: ['video/mp4']
+          });
+        });
+      });
 
-    it('handles regular responses', function () {
-      expect(BANNER_RESPONSE).to.exist;
-      expect(BANNER_RESPONSE.body).to.exist;
-      expect(BANNER_RESPONSE.body.id).to.exist;
-      expect(BANNER_RESPONSE.body.seatbid[0]).to.exist;
-      let result = spec.interpretResponse(BANNER_RESPONSE, BIDDER_REQUEST);
-
-      expect(result).to.have.lengthOf(1);
-
-      expect(result[0]).to.exist;
-      expect(result[0].width).to.equal(300);
-      expect(result[0].height).to.equal(250);
-      expect(result[0].creativeId).to.equal(42);
-      expect(result[0].cpm).to.be.within(0.45, 0.46);
-      expect(result[0].ad).to.equal('<!-- adContent -->');
-      expect(result[0].currency).to.equal('USD');
-      expect(result[0].netRevenue).to.equal(true);
-      expect(result[0].ttl).to.equal(300);
-      expect(result[0].dealId).to.not.exist;
-      expect(result[0].meta.advertiserDomains[0]).to.equal('adomain.com');
-      expect(result[0].meta.advertiserId).to.be.eql('777');
-      expect(result[0].meta.advertiserName).to.be.eql('advertiser');
-      expect(result[0].meta.agencyName).to.be.eql('agency');
-      expect(result[0].meta.advertiserDomains).to.be.eql(['adomain.com']);
-      expect(result[0].meta.secondaryCatIds).to.be.eql(['IAB1-4', 'IAB8-16', 'IAB25-5']);
+      describe('native', function () {
+        describe('assets', function () {
+          it('should set correct asset id', function () {
+            let validBidRequests = [{
+              bidId: 'bidId',
+              params: {adzoneid: 1000},
+              nativeParams: {
+                title: {required: true, len: 140},
+                image: {required: false, wmin: 836, hmin: 627, w: 325, h: 300, mimes: ['image/jpg', 'image/gif']},
+                body: {len: 140}
+              }
+            }];
+            let nativeRequest = JSON.parse(spec.buildRequests(validBidRequests, {refererInfo: {referer: 'page'}}).data).imp[0].native.request;
+            let assets = JSON.parse(nativeRequest).assets;
+
+            assert.equal(assets[0].id, 0);
+            assert.equal(assets[1].id, 3);
+            assert.equal(assets[2].id, 4);
+          });
+          it('should add required key if it is necessary', function () {
+            let validBidRequests = [{
+              bidId: 'bidId',
+              params: {adzoneid: 1000},
+              nativeParams: {
+                title: {required: true, len: 140},
+                image: {required: false, wmin: 836, hmin: 627, w: 325, h: 300, mimes: ['image/jpg', 'image/gif']},
+                body: {len: 140},
+                sponsoredBy: {required: true, len: 140}
+              }
+            }];
+
+            let nativeRequest = JSON.parse(spec.buildRequests(validBidRequests, {refererInfo: {referer: 'page'}}).data).imp[0].native.request;
+            let assets = JSON.parse(nativeRequest).assets;
+
+            assert.equal(assets[0].required, 1);
+            assert.ok(!assets[1].required);
+            assert.ok(!assets[2].required);
+            assert.equal(assets[3].required, 1);
+          });
+
+          it('should map img and data assets', function () {
+            let validBidRequests = [{
+              bidId: 'bidId',
+              params: {adzoneid: 1000},
+              nativeParams: {
+                title: {required: true, len: 140},
+                image: {required: true, sizes: [150, 50]},
+                icon: {required: false, sizes: [50, 50]},
+                body: {required: false, len: 140},
+                sponsoredBy: {required: true},
+                cta: {required: false},
+                clickUrl: {required: false}
+              }
+            }];
+
+            let nativeRequest = JSON.parse(spec.buildRequests(validBidRequests, {refererInfo: {referer: 'page'}}).data).imp[0].native.request;
+            let assets = JSON.parse(nativeRequest).assets;
+            assert.ok(assets[0].title);
+            assert.equal(assets[0].title.len, 140);
+            assert.deepEqual(assets[1].img, {type: 3, w: 150, h: 50});
+            assert.deepEqual(assets[2].img, {type: 1, w: 50, h: 50});
+            assert.deepEqual(assets[3].data, {type: 2, len: 140});
+            assert.deepEqual(assets[4].data, {type: 1});
+            assert.deepEqual(assets[5].data, {type: 12});
+            assert.ok(!assets[6]);
+          });
+
+          describe('icon/image sizing', function () {
+            it('should flatten sizes and utilise first pair', function () {
+              const validBidRequests = [{
+                bidId: 'bidId',
+                params: {adzoneid: 1000},
+                nativeParams: {
+                  image: {
+                    sizes: [[200, 300], [100, 200]]
+                  },
+                }
+              }];
+
+              let nativeRequest = JSON.parse(spec.buildRequests(validBidRequests, {refererInfo: {referer: 'page'}}).data).imp[0].native.request;
+              let assets = JSON.parse(nativeRequest).assets;
+              assert.ok(assets[0].img);
+              assert.equal(assets[0].img.w, 200);
+              assert.equal(assets[0].img.h, 300);
+            });
+          });
+
+          it('should utilise aspect_ratios', function () {
+            const validBidRequests = [{
+              bidId: 'bidId',
+              params: {adzoneid: 1000},
+              nativeParams: {
+                image: {
+                  aspect_ratios: [{
+                    min_width: 100,
+                    ratio_height: 3,
+                    ratio_width: 1
+                  }]
+                },
+                icon: {
+                  aspect_ratios: [{
+                    min_width: 10,
+                    ratio_height: 5,
+                    ratio_width: 2
+                  }]
+                }
+              }
+            }];
+
+            let nativeRequest = JSON.parse(spec.buildRequests(validBidRequests, {refererInfo: {referer: 'page'}}).data).imp[0].native.request;
+            let assets = JSON.parse(nativeRequest).assets;
+            assert.ok(assets[0].img);
+            assert.equal(assets[0].img.wmin, 100);
+            assert.equal(assets[0].img.hmin, 300);
+
+            assert.ok(assets[1].img);
+            assert.equal(assets[1].img.wmin, 10);
+            assert.equal(assets[1].img.hmin, 25);
+          });
+
+          it('should not throw error if aspect_ratios config is not defined', function () {
+            const validBidRequests = [{
+              bidId: 'bidId',
+              params: {adzoneid: 1000},
+              nativeParams: {
+                image: {
+                  aspect_ratios: []
+                },
+                icon: {
+                  aspect_ratios: []
+                }
+              }
+            }];
+
+            assert.doesNotThrow(() => spec.buildRequests(validBidRequests, {refererInfo: {referer: 'page'}}));
+          });
+        });
+
+        it('should expect any dimensions if min_width not passed', function () {
+          const validBidRequests = [{
+            bidId: 'bidId',
+            params: {adzoneid: 1000},
+            nativeParams: {
+              image: {
+                aspect_ratios: [{
+                  ratio_height: 3,
+                  ratio_width: 1
+                }]
+              }
+            }
+          }];
+
+          let nativeRequest = JSON.parse(spec.buildRequests(validBidRequests, {refererInfo: {referer: 'page'}}).data).imp[0].native.request;
+          let assets = JSON.parse(nativeRequest).assets;
+          assert.ok(assets[0].img);
+          assert.equal(assets[0].img.wmin, 0);
+          assert.equal(assets[0].img.hmin, 0);
+          assert.ok(!assets[1]);
+        });
+      });
     });
 
-    it('handles regular responses with dealid', function () {
-      let result = spec.interpretResponse(BANNER_RESPONSE_WITHDEALID);
+    function getRequestImps(validBidRequests) {
+      return JSON.parse(spec.buildRequests(validBidRequests, {refererInfo: {referer: 'page'}}).data).imp;
+    }
+  });
 
-      expect(result).to.have.lengthOf(1);
+  describe('interpretResponse', function () {
+    it('should return if no body in response', function () {
+      let serverResponse = {};
+      let bidRequest = {};
 
-      expect(result[0].width).to.equal(300);
-      expect(result[0].height).to.equal(250);
-      expect(result[0].creativeId).to.equal(42);
-      // expect(result[0].cpm).to.equal(0.45);
-      expect(result[0].cpm).to.be.within(0.45, 0.46);
-      expect(result[0].ad).to.equal('<!-- adContent -->');
-      expect(result[0].currency).to.equal('USD');
-      expect(result[0].netRevenue).to.equal(true);
-      expect(result[0].ttl).to.equal(300);
+      assert.ok(!spec.interpretResponse(serverResponse, bidRequest));
     });
+    it('should return more than one bids', function () {
+      let serverResponse = {
+        body: {
+          seatbid: [{
+            bid: [{
+              impid: '1',
+              native: {ver: '1.1', link: {url: 'link'}, assets: [{id: 1, title: {text: 'Asset title text'}}]}
+            }]
+          }, {
+            bid: [{
+              impid: '2',
+              native: {ver: '1.1', link: {url: 'link'}, assets: [{id: 1, data: {value: 'Asset title text'}}]}
+            }]
+          }]
+        }
+      };
+      let bidRequest = {
+        data: {},
+        bids: [
+          {
+            bidId: 'bidId1',
+            params: {adzoneid: 1000},
+            nativeParams: {
+              title: {required: true, len: 140},
+              image: {required: false, wmin: 836, hmin: 627, w: 325, h: 300, mimes: ['image/jpg', 'image/gif']},
+              body: {len: 140}
+            }
+          },
+          {
+            bidId: 'bidId2',
+            params: {adzoneid: 1000},
+            nativeParams: {
+              title: {required: true, len: 140},
+              image: {required: false, wmin: 836, hmin: 627, w: 325, h: 300, mimes: ['image/jpg', 'image/gif']},
+              body: {len: 140}
+            }
+          }
+        ]
+      };
 
-    it('handles video responses', function () {
-      let result = spec.interpretResponse(VIDEO_RESPONSE);
-      expect(result).to.have.lengthOf(1);
-
-      expect(result[0].width).to.equal(640);
-      expect(result[0].height).to.equal(360);
-      expect(result[0].mediaType).to.equal('video');
-      expect(result[0].creativeId).to.equal(42);
-      expect(result[0].cpm).to.equal(0.45);
-      expect(result[0].vastUrl).to.equal('vastContentUrl');
-      expect(result[0].currency).to.equal('USD');
-      expect(result[0].netRevenue).to.equal(true);
-      expect(result[0].ttl).to.equal(300);
+      bids = spec.interpretResponse(serverResponse, bidRequest);
+      assert.equal(spec.interpretResponse(serverResponse, bidRequest).length, 2);
     });
 
-    it('handles native responses', function () {
-      let result = spec.interpretResponse(NATIVE_RESPONSE);
-
-      expect(result[0].width).to.equal(0);
-      expect(result[0].height).to.equal(0);
-
-      expect(result[0].creativeId).to.equal(42);
-      expect(result[0].cpm).to.equal(0.45);
-      expect(result[0].currency).to.equal('USD');
-      expect(result[0].netRevenue).to.equal(true);
-      expect(result[0].ttl).to.equal(300);
+    it('should set correct values to bid', function () {
+      let nativeExample1 = {
+        assets: [],
+        link: {url: 'link'},
+        imptrackers: ['imptrackers url1', 'imptrackers url2']
+      }
 
-      expect(result[0].mediaType).to.equal('native');
+      let serverResponse = {
+        body: {
+          id: null,
+          bidid: null,
+          seatbid: [{
+            bid: [
+              {
+                impid: '1',
+                price: 93.1231,
+                crid: '12312312',
+                adm: JSON.stringify(nativeExample1),
+                dealid: 'deal-id',
+                adomain: ['demo.com'],
+                ext: {
+                  crType: 'native',
+                  advertiser_id: 'adv1',
+                  advertiser_name: 'advname',
+                  agency_name: 'agname',
+                  mediaType: 'native'
+                }
+              }
+            ]
+          }],
+          cur: 'EUR'
+        }
+      };
+      let bidRequest = {
+        data: {},
+        bids: [
+          {
+            bidId: 'bidId1',
+            params: {adzoneid: 1000},
+            nativeParams: {
+              title: {required: true, len: 140},
+              image: {required: false, wmin: 836, hmin: 627, w: 325, h: 300, mimes: ['image/jpg', 'image/gif']},
+              body: {len: 140}
+            }
+          }
+        ]
+      };
 
-      expect(result[0].native.clickUrl).to.equal('linkContent');
-      expect(result[0].native.impressionTrackers).to.deep.equal([
-        'impressionTracker1',
-        'impressionTracker2'
-      ]);
-      expect(result[0].native.title).to.equal('titleContent');
+      const bids = spec.interpretResponse(serverResponse, bidRequest);
+      const bid = serverResponse.body.seatbid[0].bid[0];
+      assert.deepEqual(bids[0].requestId, bidRequest.bids[0].bidId);
+      assert.deepEqual(bids[0].cpm, bid.price);
+      assert.deepEqual(bids[0].creativeId, bid.crid);
+      assert.deepEqual(bids[0].ttl, 300);
+      assert.deepEqual(bids[0].netRevenue, false);
+      assert.deepEqual(bids[0].currency, serverResponse.body.cur);
+      assert.deepEqual(bids[0].mediaType, 'native');
+      assert.deepEqual(bids[0].meta.mediaType, 'native');
+      assert.deepEqual(bids[0].meta.advertiserDomains, ['demo.com']);
+
+      assert.deepEqual(bids[0].meta.advertiserName, 'advname');
+      assert.deepEqual(bids[0].meta.agencyName, 'agname');
+
+      assert.deepEqual(bids[0].dealId, 'deal-id');
+    });
 
-      expect(result[0].native.image.url).to.equal('imageContent');
-      expect(result[0].native.image.height).to.equal(600);
-      expect(result[0].native.image.width).to.equal(600);
+    it('should return empty when there is no bids in response', function () {
+      const serverResponse = {
+        body: {
+          id: null,
+          bidid: null,
+          seatbid: [{bid: []}],
+          cur: 'EUR'
+        }
+      };
+      let bidRequest = {
+        data: {},
+        bids: [{bidId: 'bidId1'}]
+      };
+      const result = spec.interpretResponse(serverResponse, bidRequest)[0];
+      assert.ok(!result);
+    });
 
-      expect(result[0].native.icon.url).to.equal('iconContent');
-      expect(result[0].native.icon.height).to.equal(400);
-      expect(result[0].native.icon.width).to.equal(400);
+    describe('banner', function () {
+      it('should set ad content on response', function () {
+        let serverResponse = {
+          body: {
+            seatbid: [{
+              bid: [{impid: '1', adm: '<banner>', ext: {crType: 'banner'}}]
+            }]
+          }
+        };
+        let bidRequest = {
+          data: {},
+          bids: [
+            {
+              bidId: 'bidId1',
+              params: {adzoneid: 1000}
+            }
+          ]
+        };
 
-      expect(result[0].native.body).to.equal('descriptionContent');
-      expect(result[0].native.sponsoredBy).to.equal('sponsoredByContent');
+        bids = spec.interpretResponse(serverResponse, bidRequest);
+        assert.equal(bids.length, 1);
+        assert.equal(bids[0].ad, '<banner>');
+        assert.equal(bids[0].mediaType, 'banner');
+        assert.equal(bids[0].meta.mediaType, 'banner');
+      });
     });
 
-    it('handles nobid responses', function () {
-      let response = [];
-      let bidderRequest = BIDDER_REQUEST;
+    describe('video', function () {
+      it('should set vastXml on response', function () {
+        let serverResponse = {
+          body: {
+            seatbid: [{
+              bid: [{impid: '1', adm: '<vast>', ext: {crType: 'video'}}]
+            }]
+          }
+        };
+        let bidRequest = {
+          data: {},
+          bids: [
+            {
+              bidId: 'bidId1',
+              params: {adzoneid: 1000}
+            }
+          ]
+        };
 
-      let result = spec.interpretResponse(response, bidderRequest);
-      expect(result.length).to.equal(0);
+        bids = spec.interpretResponse(serverResponse, bidRequest);
+        assert.equal(bids.length, 1);
+        assert.equal(bids[0].vastXml, '<vast>');
+        assert.equal(bids[0].mediaType, 'video');
+        assert.equal(bids[0].meta.mediaType, 'video');
+      });
     });
   });
 
   describe('getUserSyncs', function () {
-    let syncoptionsIframe = {
-      iframeEnabled: 'true'
-    };
+    const usersyncUrl = 'https://usersync-url.com';
+    beforeEach(() => {
+      config.setConfig(
+        {
+          adxcg: {
+            usersyncUrl: usersyncUrl,
+          }
+        }
+      )
+    })
+    after(() => {
+      config.resetConfig()
+    })
+
+    it('should return user sync if pixel enabled with adxcg config', function () {
+      const ret = spec.getUserSyncs({pixelEnabled: true})
+      expect(ret).to.deep.equal([{type: 'image', url: usersyncUrl}])
+    })
+
+    it('should not return user sync if pixel disabled', function () {
+      const ret = spec.getUserSyncs({pixelEnabled: false})
+      expect(ret).to.be.an('array').that.is.empty
+    })
+
+    it('should not return user sync if url is not set', function () {
+      config.resetConfig()
+      const ret = spec.getUserSyncs({pixelEnabled: true})
+      expect(ret).to.be.an('array').that.is.empty
+    })
+
+    it('should pass GDPR consent', function() {
+      expect(spec.getUserSyncs({ pixelEnabled: true }, {}, {gdprApplies: true, consentString: 'foo'}, undefined)).to.deep.equal([{
+        type: 'image', url: `${usersyncUrl}?gdpr=1&gdpr_consent=foo`
+      }]);
+      expect(spec.getUserSyncs({ pixelEnabled: true }, {}, {gdprApplies: false, consentString: 'foo'}, undefined)).to.deep.equal([{
+        type: 'image', url: `${usersyncUrl}?gdpr=0&gdpr_consent=foo`
+      }]);
+      expect(spec.getUserSyncs({ pixelEnabled: true }, {}, {gdprApplies: true, consentString: undefined}, undefined)).to.deep.equal([{
+        type: 'image', url: `${usersyncUrl}?gdpr=1&gdpr_consent=`
+      }]);
+    });
+
+    it('should pass US consent', function() {
+      expect(spec.getUserSyncs({ pixelEnabled: true }, {}, undefined, '1NYN')).to.deep.equal([{
+        type: 'image', url: `${usersyncUrl}?us_privacy=1NYN`
+      }]);
+    });
 
-    it('should return iframe sync option', function () {
-      expect(spec.getUserSyncs(syncoptionsIframe)[0].type).to.equal('iframe');
-      expect(spec.getUserSyncs(syncoptionsIframe)[0].url).to.equal(
-        'https://cdn.adxcg.net/pb-sync.html'
-      );
+    it('should pass GDPR and US consent', function() {
+      expect(spec.getUserSyncs({ pixelEnabled: true }, {}, {gdprApplies: true, consentString: 'foo'}, '1NYN')).to.deep.equal([{
+        type: 'image', url: `${usersyncUrl}?gdpr=1&gdpr_consent=foo&us_privacy=1NYN`
+      }]);
     });
   });
 
-  describe('on bidWon', function () {
-    beforeEach(function () {
+  describe('onBidWon', function() {
+    beforeEach(function() {
       sinon.stub(utils, 'triggerPixel');
     });
-    afterEach(function () {
+    afterEach(function() {
       utils.triggerPixel.restore();
     });
-    it('should replace burl for banner', function () {
-      const burl = 'burl=${' + 'AUCTION_PRICE}';
+
+    it('Should trigger pixel if bid nurl', function() {
       const bid = {
-        'bidderCode': 'adxcg',
-        'width': 0,
-        'height': 0,
-        'statusMessage': 'Bid available',
-        'adId': '3d0b6ff1dda89',
-        'requestId': '2a423489e058a1',
-        'mediaType': 'banner',
-        'source': 'client',
-        'ad': burl,
-        'cpm': 0.66,
-        'creativeId': '353538_591471',
-        'currency': 'USD',
-        'dealId': '',
-        'netRevenue': true,
-        'ttl': 300,
-        // 'nurl': nurl,
-        'burl': burl,
-        'isBurl': true,
-        'auctionId': 'a92bffce-14d2-4f8f-a78a-7b9b5e4d28fa',
-        'responseTimestamp': 1556867386065,
-        'requestTimestamp': 1556867385916,
-        'bidder': 'adxcg',
-        'adUnitCode': 'div-gpt-ad-1555415275793-0',
-        'timeToRespond': 149,
-        'pbLg': '0.50',
-        'pbMg': '0.60',
-        'pbHg': '0.66',
-        'pbAg': '0.65',
-        'pbDg': '0.66',
-        'pbCg': '',
-        'size': '0x0',
-        'adserverTargeting': {
-          'hb_bidder': 'mgid',
-          'hb_adid': '3d0b6ff1dda89',
-          'hb_pb': '0.66',
-          'hb_size': '0x0',
-          'hb_source': 'client',
-          'hb_format': 'banner',
-          'hb_banner_title': 'TITLE',
-          'hb_banner_image': 'hb_banner_image:3d0b6ff1dda89',
-          'hb_banner_icon': 'IconURL',
-          'hb_banner_linkurl': 'hb_banner_linkurl:3d0b6ff1dda89'
-        },
-        'status': 'targetingSet',
-        'params': [{'adzoneid': '20'}]
-      };
+        nurl: 'http://example.com/win/${AUCTION_PRICE}',
+        cpm: 2.1,
+        originalCpm: 1.1,
+      }
       spec.onBidWon(bid);
-      expect(bid.burl).to.deep.equal(burl);
-    });
-  });
+      expect(utils.triggerPixel.callCount).to.equal(1)
+    })
+  })
 });