prebid.js 8.0.0 → 8.2.0

package/test/spec/modules/ucfunnelBidAdapter_spec.js

@@ -1,6 +1,7 @@
 import { expect } from 'chai';
 import { spec } from 'modules/ucfunnelBidAdapter.js';
 import {BANNER, VIDEO, NATIVE} from 'src/mediaTypes.js';
+import {deepClone} from '../../../src/utils.js';
 const URL = 'https://hb.aralego.com/header';
 const BIDDER_CODE = 'ucfunnel';
 
@@ -150,7 +151,10 @@ describe('ucfunnel Adapter', function () {
     });
   });
   describe('build request', function () {
-    const request = spec.buildRequests([validBannerBidReq], bidderRequest);
+    let request;
+    before(() => {
+      request = spec.buildRequests([validBannerBidReq], bidderRequest);
+    })
     it('should create a POST request for every bid', function () {
       expect(request[0].method).to.equal('GET');
       expect(request[0].url).to.equal(spec.ENDPOINT);
@@ -179,15 +183,16 @@ describe('ucfunnel Adapter', function () {
     it('must parse bid size from a nested array', function () {
       const width = 640;
       const height = 480;
-      validBannerBidReq.sizes = [[ width, height ]];
-      const requests = spec.buildRequests([ validBannerBidReq ], bidderRequest);
+      const bid = deepClone(validBannerBidReq);
+      bid.sizes = [[ width, height ]];
+      const requests = spec.buildRequests([ bid ], bidderRequest);
       const data = requests[0].data;
       expect(data.w).to.equal(width);
       expect(data.h).to.equal(height);
     });
 
     it('should set bidfloor if configured', function() {
-      let bid = Object.assign({}, validBannerBidReq);
+      let bid = deepClone(validBannerBidReq);
       bid.getFloor = function() {
         return {
           currency: 'USD',
@@ -200,7 +205,7 @@ describe('ucfunnel Adapter', function () {
     });
 
     it('should set bidfloor if configured', function() {
-      let bid = Object.assign({}, validBannerBidReq);
+      let bid = deepClone(validBannerBidReq);
       bid.params.bidfloor = 2.01;
       const requests = spec.buildRequests([ bid ], bidderRequest);
       const data = requests[0].data;
@@ -208,7 +213,7 @@ describe('ucfunnel Adapter', function () {
     });
 
     it('should set bidfloor if configured', function() {
-      let bid = Object.assign({}, validBannerBidReq);
+      let bid = deepClone(validBannerBidReq);
       bid.getFloor = function() {
         return {
           currency: 'USD',
@@ -224,8 +229,12 @@ describe('ucfunnel Adapter', function () {
 
   describe('interpretResponse', function () {
     describe('should support banner', function () {
-      const request = spec.buildRequests([ validBannerBidReq ], bidderRequest);
-      const result = spec.interpretResponse({body: validBannerBidRes}, request[0]);
+      let request, result;
+      before(() => {
+        request = spec.buildRequests([ validBannerBidReq ], bidderRequest);
+        result = spec.interpretResponse({body: validBannerBidRes}, request[0]);
+      });
+
       it('should build bid array for banner', function () {
         expect(result.length).to.equal(1);
       });
@@ -243,8 +252,11 @@ describe('ucfunnel Adapter', function () {
     });
 
     describe('handle banner no ad', function () {
-      const request = spec.buildRequests([ validBannerBidReq ], bidderRequest);
-      const result = spec.interpretResponse({body: invalidBannerBidRes}, request[0]);
+      let request, result;
+      before(() => {
+        request = spec.buildRequests([ validBannerBidReq ], bidderRequest);
+        result = spec.interpretResponse({body: invalidBannerBidRes}, request[0]);
+      })
       it('should build bid array for banner', function () {
         expect(result.length).to.equal(1);
       });
@@ -261,8 +273,11 @@ describe('ucfunnel Adapter', function () {
     });
 
     describe('handle banner cpm under bidfloor', function () {
-      const request = spec.buildRequests([ validBannerBidReq ], bidderRequest);
-      const result = spec.interpretResponse({body: invalidBannerBidRes}, request[0]);
+      let request, result;
+      before(() => {
+        request = spec.buildRequests([ validBannerBidReq ], bidderRequest);
+        result = spec.interpretResponse({body: invalidBannerBidRes}, request[0]);
+      })
       it('should build bid array for banner', function () {
         expect(result.length).to.equal(1);
       });
@@ -279,8 +294,11 @@ describe('ucfunnel Adapter', function () {
     });
 
     describe('should support video', function () {
-      const request = spec.buildRequests([ validVideoBidReq ], bidderRequest);
-      const result = spec.interpretResponse({body: validVideoBidRes}, request[0]);
+      let request, result;
+      before(() => {
+        request = spec.buildRequests([ validVideoBidReq ], bidderRequest);
+        result = spec.interpretResponse({body: validVideoBidRes}, request[0]);
+      })
       it('should build bid array', function () {
         expect(result.length).to.equal(1);
       });
@@ -299,8 +317,11 @@ describe('ucfunnel Adapter', function () {
     });
 
     describe('should support native', function () {
-      const request = spec.buildRequests([ validNativeBidReq ], bidderRequest);
-      const result = spec.interpretResponse({body: validNativeBidRes}, request[0]);
+      let request, result;
+      before(() => {
+        request = spec.buildRequests([ validNativeBidReq ], bidderRequest);
+        result = spec.interpretResponse({body: validNativeBidRes}, request[0]);
+      })
       it('should build bid array', function () {
         expect(result.length).to.equal(1);
       });

package/test/spec/modules/userId_spec.js

@@ -86,6 +86,19 @@ describe('User ID', function () {
     }
   }
 
+  function createMockIdSubmodule(name, value, aliasName) {
+    return {
+      name,
+      getId() {
+        return value;
+      },
+      decode(v) {
+        return v;
+      },
+      aliasName
+    }
+  }
+
   function getAdUnitMock(code = 'adUnit-code') {
     return {
       code,
@@ -109,12 +122,6 @@ describe('User ID', function () {
     return cfg;
   }
 
-  function findEid(eids, source) {
-    return find(eids, (eid) => {
-      if (eid.source === source) { return true; }
-    });
-  }
-
   let sandbox, consentData, startDelay, callbackDelay;
 
   function clearStack() {
@@ -397,6 +404,139 @@ describe('User ID', function () {
       })
     });
 
+    it('pbjs.getUserIds(Async) should prioritize user ids according to config available to core', () => {
+      init(config);
+
+      setSubmoduleRegistry([
+        createMockIdSubmodule('mockId1Module', {id: {mockId1: 'mockId1_value'}}),
+        createMockIdSubmodule('mockId2Module', {id: {mockId2: 'mockId2_value', mockId3: 'mockId3_value_from_mockId2Module'}}),
+        createMockIdSubmodule('mockId3Module', {id: {mockId1: 'mockId1_value_from_mockId3Module', mockId2: 'mockId2_value_from_mockId3Module', mockId3: 'mockId3_value', mockId4: 'mockId4_value_from_mockId3Module'}}),
+        createMockIdSubmodule('mockId4Module', {id: {mockId4: 'mockId4_value'}})
+      ]);
+
+      config.setConfig({
+        userSync: {
+          idPriority: {
+            mockId1: ['mockId3Module', 'mockId1Module'],
+            mockId4: ['mockId4Module', 'mockId3Module']
+          },
+          auctionDelay: 10, // with auctionDelay > 0, no auction is needed to complete init
+          userIds: [
+            { name: 'mockId1Module' },
+            { name: 'mockId2Module' },
+            { name: 'mockId3Module' },
+            { name: 'mockId4Module' }
+          ]
+        }
+      });
+
+      return getGlobal().getUserIdsAsync().then((uids) => {
+        expect(uids['mockId1']).to.deep.equal('mockId1_value_from_mockId3Module');
+        expect(uids['mockId2']).to.deep.equal('mockId2_value');
+        expect(uids['mockId3']).to.deep.equal('mockId3_value_from_mockId2Module');
+        expect(uids['mockId4']).to.deep.equal('mockId4_value');
+      });
+    });
+
+    it('pbjs.getUserIds(Async) should prioritize user ids according to config available to core when config uses aliases', () => {
+      init(config);
+
+      setSubmoduleRegistry([
+        createMockIdSubmodule('mockId1Module', {id: {mockId1: 'mockId1_value'}}),
+        createMockIdSubmodule('mockId2Module', {id: {mockId2: 'mockId2_value', mockId3: 'mockId3_value_from_mockId2Module'}}, 'mockId2Module_alias'),
+        createMockIdSubmodule('mockId3Module', {id: {mockId1: 'mockId1_value_from_mockId3Module', mockId2: 'mockId2_value_from_mockId3Module', mockId3: 'mockId3_value', mockId4: 'mockId4_value_from_mockId3Module'}}, 'mockId3Module_alias'),
+        createMockIdSubmodule('mockId4Module', {id: {mockId4: 'mockId4_value'}})
+      ]);
+
+      config.setConfig({
+        userSync: {
+          idPriority: {
+            mockId1: ['mockId3Module_alias', 'mockId1Module'],
+            mockId4: ['mockId4Module', 'mockId3Module']
+          },
+          auctionDelay: 10, // with auctionDelay > 0, no auction is needed to complete init
+          userIds: [
+            { name: 'mockId1Module' },
+            { name: 'mockId2Module' },
+            { name: 'mockId3Module' },
+            { name: 'mockId4Module' }
+          ]
+        }
+      });
+
+      return getGlobal().getUserIdsAsync().then((uids) => {
+        expect(uids['mockId1']).to.deep.equal('mockId1_value_from_mockId3Module');
+        expect(uids['mockId2']).to.deep.equal('mockId2_value');
+        expect(uids['mockId3']).to.deep.equal('mockId3_value_from_mockId2Module');
+        expect(uids['mockId4']).to.deep.equal('mockId4_value');
+      });
+    });
+
+    it('pbjs.getUserIds(Async) should prioritize user ids according to config available to core when called multiple times', () => {
+      init(config);
+
+      setSubmoduleRegistry([
+        createMockIdSubmodule('mockId1Module', {id: {mockId1: 'mockId1_value', mockId2: 'mockId2_value_from_mockId1Module'}}),
+        createMockIdSubmodule('mockId2Module', {id: {mockId1: 'mockId1_value_from_mockId2Module', mockId2: 'mockId2_value'}}),
+      ]);
+
+      config.setConfig({
+        userSync: {
+          idPriority: {
+            mockId1: ['mockId2Module', 'mockId1Module'],
+            mockId2: ['mockId1Module', 'mockId2Module']
+          },
+          auctionDelay: 10, // with auctionDelay > 0, no auction is needed to complete init
+          userIds: [
+            { name: 'mockId1Module' },
+            { name: 'mockId2Module' }
+          ]
+        }
+      });
+
+      return getGlobal().getUserIdsAsync().then((uidsFirstRequest) => {
+        getGlobal().getUserIdsAsync().then((uidsSecondRequest) => {
+          expect(uidsFirstRequest['mockId1']).to.deep.equal('mockId1_value_from_mockId2Module');
+          expect(uidsFirstRequest['mockId2']).to.deep.equal('mockId2_value_from_mockId1Module');
+          expect(uidsFirstRequest).to.deep.equal(uidsSecondRequest);
+        })
+      });
+    });
+
+    it('pbjs.getUserIds(Async) with priority config but no collision', () => {
+      init(config);
+
+      setSubmoduleRegistry([
+        createMockIdSubmodule('mockId1Module', {id: {mockId1: 'mockId1_value'}}),
+        createMockIdSubmodule('mockId2Module', {id: {mockId2: 'mockId2_value'}}),
+        createMockIdSubmodule('mockId3Module', {id: undefined}),
+        createMockIdSubmodule('mockId4Module', {id: {mockId4: 'mockId4_value'}})
+      ]);
+
+      config.setConfig({
+        userSync: {
+          idPriority: {
+            mockId1: ['mockId3Module', 'mockId1Module'],
+            mockId4: ['mockId2Module', 'mockId4Module']
+          },
+          auctionDelay: 10, // with auctionDelay > 0, no auction is needed to complete init
+          userIds: [
+            { name: 'mockId1Module' },
+            { name: 'mockId2Module' },
+            { name: 'mockId3Module' },
+            { name: 'mockId4Module' }
+          ]
+        }
+      });
+
+      return getGlobal().getUserIdsAsync().then((uids) => {
+        expect(uids['mockId1']).to.deep.equal('mockId1_value');
+        expect(uids['mockId2']).to.deep.equal('mockId2_value');
+        expect(uids['mockId3']).to.be.undefined;
+        expect(uids['mockId4']).to.deep.equal('mockId4_value');
+      });
+    });
+
     it('pbjs.getUserIdsAsEids', function (done) {
       init(config);
       setSubmoduleRegistry([sharedIdSystemSubmodule]);
@@ -416,6 +556,44 @@ describe('User ID', function () {
       });
     });
 
+    it('pbjs.getUserIdsAsEids should prioritize user ids according to config available to core', () => {
+      init(config);
+      setSubmoduleRegistry([
+        createMockIdSubmodule('mockId1Module', {id: {uid2: {id: 'uid2_value'}}}),
+        createMockIdSubmodule('mockId2Module', {id: {pubcid: 'pubcid_value', lipb: {lipbid: 'lipbid_value_from_mockId2Module'}}}),
+        createMockIdSubmodule('mockId3Module', {id: {uid2: {id: 'uid2_value_from_mockId3Module'}, pubcid: 'pubcid_value_from_mockId3Module', lipb: {lipbid: 'lipbid_value'}, merkleId: {id: 'merkleId_value_from_mockId3Module'}}}),
+        createMockIdSubmodule('mockId4Module', {id: {merkleId: {id: 'merkleId_value'}}})
+      ]);
+      config.setConfig({
+        userSync: {
+          idPriority: {
+            uid2: ['mockId3Module', 'mockId1Module'],
+            merkleId: ['mockId4Module', 'mockId3Module']
+          },
+          auctionDelay: 10, // with auctionDelay > 0, no auction is needed to complete init
+          userIds: [
+            { name: 'mockId1Module' },
+            { name: 'mockId2Module' },
+            { name: 'mockId3Module' },
+            { name: 'mockId4Module' }
+          ]
+        }
+      });
+
+      const ids = {
+        'uid2': { id: 'uid2_value_from_mockId3Module' },
+        'pubcid': 'pubcid_value',
+        'lipb': { lipbid: 'lipbid_value_from_mockId2Module' },
+        'merkleId': { id: 'merkleId_value' }
+      };
+
+      return getGlobal().getUserIdsAsync().then(() => {
+        const eids = getGlobal().getUserIdsAsEids();
+        const expected = createEidsArray(ids);
+        expect(eids).to.deep.equal(expected);
+      });
+    });
+
     it('should set googletag ppid correctly', function () {
       let adUnits = [getAdUnitMock()];
       init(config);
@@ -441,6 +619,41 @@ describe('User ID', function () {
       });
     });
 
+    it('should set googletag ppid correctly when prioritized according to config available to core', () => {
+      let adUnits = [getAdUnitMock()];
+      init(config);
+      setSubmoduleRegistry([
+        // some of the ids are padded to have length >= 32 characters
+        createMockIdSubmodule('mockId1Module', {id: {uid2: {id: 'uid2_value_7ac66c0f148de9519b8bd264312c4d64'}}}),
+        createMockIdSubmodule('mockId2Module', {id: {pubcid: 'pubcid_value_7ac66c0f148de9519b8bd264312c4d64', lipb: {lipbid: 'lipbid_value_from_mockId2Module_7ac66c0f148de9519b8bd264312c4d64'}}}),
+        createMockIdSubmodule('mockId3Module', {id: {uid2: {id: 'uid2_value_from_mockId3Module_7ac66c0f148de9519b8bd264312c4d64'}, pubcid: 'pubcid_value_from_mockId3Module_7ac66c0f148de9519b8bd264312c4d64', lipb: {lipbid: 'lipbid_value_7ac66c0f148de9519b8bd264312c4d64'}, merkleId: {id: 'merkleId_value_from_mockId3Module_7ac66c0f148de9519b8bd264312c4d64'}}}),
+        createMockIdSubmodule('mockId4Module', {id: {merkleId: {id: 'merkleId_value_7ac66c0f148de9519b8bd264312c4d64'}}})
+      ]);
+
+      // before ppid should not be set
+      expect(window.googletag._ppid).to.equal(undefined);
+
+      config.setConfig({
+        userSync: {
+          ppid: 'uidapi.com',
+          idPriority: {
+            uid2: ['mockId3Module', 'mockId1Module'],
+            merkleId: ['mockId4Module', 'mockId3Module']
+          },
+          userIds: [
+            { name: 'mockId1Module' },
+            { name: 'mockId2Module' },
+            { name: 'mockId3Module' },
+            { name: 'mockId4Module' }
+          ]
+        }
+      });
+
+      return expectImmediateBidHook(() => {}, {adUnits}).then(() => {
+        expect(window.googletag._ppid).to.equal('uid2valuefrommockId3Module7ac66c0f148de9519b8bd264312c4d64');
+      });
+    });
+
     describe('submodule callback', () => {
       const TEST_KEY = 'testKey';
 
@@ -589,6 +802,40 @@ describe('User ID', function () {
       })
     });
 
+    it('should make PPID available to core and respect priority', () => {
+      init(config);
+      setSubmoduleRegistry([
+        // some of the ids are padded to have length >= 32 characters
+        createMockIdSubmodule('mockId1Module', {id: {uid2: {id: 'uid2_value_7ac66c0f148de9519b8bd264312c4d64'}}}),
+        createMockIdSubmodule('mockId2Module', {id: {pubcid: 'pubcid_value_7ac66c0f148de9519b8bd264312c4d64', lipb: {lipbid: 'lipbid_value_from_mockId2Module_7ac66c0f148de9519b8bd264312c4d64'}}}),
+        createMockIdSubmodule('mockId3Module', {id: {uid2: {id: 'uid2_value_from_mockId3Module_7ac66c0f148de9519b8bd264312c4d64'}, pubcid: 'pubcid_value_from_mockId3Module_7ac66c0f148de9519b8bd264312c4d64', lipb: {lipbid: 'lipbid_value_7ac66c0f148de9519b8bd264312c4d64'}, merkleId: {id: 'merkleId_value_from_mockId3Module_7ac66c0f148de9519b8bd264312c4d64'}}}),
+        createMockIdSubmodule('mockId4Module', {id: {merkleId: {id: 'merkleId_value_7ac66c0f148de9519b8bd264312c4d64'}}})
+      ]);
+
+      // before ppid should not be set
+      expect(window.googletag._ppid).to.equal(undefined);
+
+      config.setConfig({
+        userSync: {
+          ppid: 'uidapi.com',
+          idPriority: {
+            uid2: ['mockId3Module', 'mockId1Module'],
+            merkleId: ['mockId4Module', 'mockId3Module']
+          },
+          userIds: [
+            { name: 'mockId1Module' },
+            { name: 'mockId2Module' },
+            { name: 'mockId3Module' },
+            { name: 'mockId4Module' }
+          ]
+        }
+      });
+
+      return getGlobal().refreshUserIds().then(() => {
+        expect(getPPID()).to.eql('uid2valuefrommockId3Module7ac66c0f148de9519b8bd264312c4d64');
+      })
+    });
+
     describe('refreshing before init is complete', () => {
       const MOCK_ID = {'MOCKID': '1111'};
       let mockIdCallback;
@@ -763,6 +1010,63 @@ describe('User ID', function () {
       });
     });
 
+    it('pbjs.refreshUserIds updates priority config', () => {
+      init(config);
+
+      setSubmoduleRegistry([
+        createMockIdSubmodule('mockId1Module', {id: {mockId1: 'mockId1_value'}}),
+        createMockIdSubmodule('mockId2Module', {id: {mockId2: 'mockId2_value', mockId3: 'mockId3_value_from_mockId2Module'}}),
+        createMockIdSubmodule('mockId3Module', {id: {mockId1: 'mockId1_value_from_mockId3Module', mockId2: 'mockId2_value_from_mockId3Module', mockId3: 'mockId3_value', mockId4: 'mockId4_value_from_mockId3Module'}}),
+        createMockIdSubmodule('mockId4Module', {id: {mockId4: 'mockId4_value'}})
+      ]);
+
+      config.setConfig({
+        userSync: {
+          idPriority: {
+            mockId1: ['mockId3Module', 'mockId1Module'],
+            mockId4: ['mockId4Module', 'mockId3Module']
+          },
+          auctionDelay: 10, // with auctionDelay > 0, no auction is needed to complete init
+          userIds: [
+            { name: 'mockId1Module' },
+            { name: 'mockId2Module' },
+            { name: 'mockId3Module' },
+            { name: 'mockId4Module' }
+          ]
+        }
+      });
+
+      return getGlobal().getUserIdsAsync().then((uids) => {
+        expect(uids['mockId1']).to.deep.equal('mockId1_value_from_mockId3Module');
+        expect(uids['mockId2']).to.deep.equal('mockId2_value');
+        expect(uids['mockId3']).to.deep.equal('mockId3_value_from_mockId2Module');
+        expect(uids['mockId4']).to.deep.equal('mockId4_value');
+
+        config.setConfig({
+          userSync: {
+            idPriority: {
+              mockId1: ['mockId1Module', 'mockId3Module'],
+              mockId4: ['mockId3Module', 'mockId4Module']
+            },
+            auctionDelay: 10, // with auctionDelay > 0, no auction is needed to complete init
+            userIds: [
+              { name: 'mockId1Module' },
+              { name: 'mockId2Module' },
+              { name: 'mockId3Module' },
+              { name: 'mockId4Module' }
+            ]
+          }
+        });
+
+        return getGlobal().getUserIdsAsync().then((uids) => {
+          expect(uids['mockId1']).to.deep.equal('mockId1_value');
+          expect(uids['mockId2']).to.deep.equal('mockId2_value');
+          expect(uids['mockId3']).to.deep.equal('mockId3_value_from_mockId2Module');
+          expect(uids['mockId4']).to.deep.equal('mockId4_value_from_mockId3Module');
+        });
+      });
+    });
+
     it('pbjs.refreshUserIds refreshes single', function() {
       coreStorage.setCookie('MOCKID', '', EXPIRED_COOKIE_DATE);
       coreStorage.setCookie('REFRESH', '', EXPIRED_COOKIE_DATE);
@@ -2950,6 +3254,50 @@ describe('User ID', function () {
         }).catch(done);
       });
 
+      it('pbjs.getEncryptedEidsForSource should return prioritized id as non-encrypted string', (done) => {
+        init(config);
+        setSubmoduleRegistry([
+          createMockIdSubmodule('mockId1Module', {id: {uid2: {id: 'uid2_value'}}}),
+          createMockIdSubmodule('mockId2Module', {id: {pubcid: 'pubcid_value', lipb: {lipbid: 'lipbid_value_from_mockId2Module'}}}),
+          createMockIdSubmodule('mockId3Module', {id: {uid2: {id: 'uid2_value_from_mockId3Module'}, pubcid: 'pubcid_value_from_mockId3Module', lipb: {lipbid: 'lipbid_value'}, merkleId: {id: 'merkleId_value_from_mockId3Module'}}}),
+          createMockIdSubmodule('mockId4Module', {id: {merkleId: {id: 'merkleId_value'}}})
+        ]);
+        config.setConfig({
+          userSync: {
+            idPriority: {
+              uid2: ['mockId3Module', 'mockId1Module'],
+              merkleId: ['mockId4Module', 'mockId3Module']
+            },
+            auctionDelay: 10, // with auctionDelay > 0, no auction is needed to complete init
+            userIds: [
+              { name: 'mockId1Module' },
+              { name: 'mockId2Module' },
+              { name: 'mockId3Module' },
+              { name: 'mockId4Module' }
+            ]
+          }
+        });
+
+        const expctedIds = [
+          'pubcid_value',
+          'uid2_value_from_mockId3Module',
+          'merkleId_value',
+          'lipbid_value_from_mockId2Module'
+        ];
+
+        const encrypt = false;
+
+        Promise.all([
+          getGlobal().getEncryptedEidsForSource('pubcid.org', encrypt),
+          getGlobal().getEncryptedEidsForSource('uidapi.com', encrypt),
+          getGlobal().getEncryptedEidsForSource('merkleinc.com', encrypt),
+          getGlobal().getEncryptedEidsForSource('liveintent.com', encrypt)
+        ]).then((result) => {
+          expect(result).to.deep.equal(expctedIds);
+          done();
+        })
+      });
+
       describe('pbjs.getEncryptedEidsForSource', () => {
         beforeEach(() => {
           init(config);
@@ -3013,6 +3361,45 @@ describe('User ID', function () {
           done();
         });
       });
+
+      it('pbjs.getUserIdsAsEidBySource with priority config available to core', () => {
+        init(config);
+        setSubmoduleRegistry([
+          createMockIdSubmodule('mockId1Module', {id: {uid2: {id: 'uid2_value'}}}),
+          createMockIdSubmodule('mockId2Module', {id: {pubcid: 'pubcid_value', lipb: {lipbid: 'lipbid_value_from_mockId2Module'}}}),
+          createMockIdSubmodule('mockId3Module', {id: {uid2: {id: 'uid2_value_from_mockId3Module'}, pubcid: 'pubcid_value_from_mockId3Module', lipb: {lipbid: 'lipbid_value'}, merkleId: {id: 'merkleId_value_from_mockId3Module'}}}),
+          createMockIdSubmodule('mockId4Module', {id: {merkleId: {id: 'merkleId_value'}}})
+        ]);
+        config.setConfig({
+          userSync: {
+            idPriority: {
+              uid2: ['mockId3Module', 'mockId1Module'],
+              merkleId: ['mockId4Module', 'mockId3Module']
+            },
+            auctionDelay: 10, // with auctionDelay > 0, no auction is needed to complete init
+            userIds: [
+              { name: 'mockId1Module' },
+              { name: 'mockId2Module' },
+              { name: 'mockId3Module' },
+              { name: 'mockId4Module' }
+            ]
+          }
+        });
+
+        const ids = {
+          'uidapi.com': {'uid2': {id: 'uid2_value_from_mockId3Module'}},
+          'pubcid.org': {'pubcid': 'pubcid_value'},
+          'liveintent.com': {'lipb': {lipbid: 'lipbid_value_from_mockId2Module'}},
+          'merkleinc.com': {'merkleId': {id: 'merkleId_value'}}
+        };
+
+        return getGlobal().getUserIdsAsync().then(() => {
+          expect(getGlobal().getUserIdsAsEidBySource('pubcid.org')).to.deep.equal(createEidsArray(ids['pubcid.org'])[0]);
+          expect(getGlobal().getUserIdsAsEidBySource('uidapi.com')).to.deep.equal(createEidsArray(ids['uidapi.com'])[0]);
+          expect(getGlobal().getUserIdsAsEidBySource('merkleinc.com')).to.deep.equal(createEidsArray(ids['merkleinc.com'])[0]);
+          expect(getGlobal().getUserIdsAsEidBySource('liveintent.com')).to.deep.equal(createEidsArray(ids['liveintent.com'])[0]);
+        });
+      });
     })
   });
 });