Support IAD SDA test in Permutive module

Updates the Permutive RTD module to support a test for segmentation with
the new IAB standard data taxonomy.

Initially we are mapping a small selection of Permutive to IAB cohort
IDs and including these in the ORTB2 object. We also set the `segtax`
value appropriately for the Index exchange, which we're using for this
test.

Author: desbo

modules/permutiveRtdProvider.js

@@ -30,7 +30,7 @@ function init (moduleConfig, userConsent) {
 export function initSegments (reqBidsConfigObj, callback, customModuleConfig) {
   const permutiveOnPage = isPermutiveOnPage()
   const moduleConfig = getModuleConfig(customModuleConfig)
-  const segmentData = getSegments(moduleConfig.params.maxSegs)
+  const segmentData = getSegments(moduleConfig.params.maxSegs, segmentIdTransformationsByBidder)
 
   setSegments(reqBidsConfigObj, moduleConfig, segmentData)
 
@@ -70,11 +70,12 @@ export function setBidderRtb (auctionDetails, customModuleConfig) {
   const moduleConfig = getModuleConfig(customModuleConfig)
   const acBidders = deepAccess(moduleConfig, 'params.acBidders')
   const maxSegs = deepAccess(moduleConfig, 'params.maxSegs')
-  const segmentData = getSegments(maxSegs)
+  const segmentData = getSegments(maxSegs, segmentIdTransformationsByBidder)
 
   acBidders.forEach(function (bidder) {
     const currConfig = bidderConfig[bidder] || {}
-    const nextConfig = mergeOrtbConfig(currConfig, segmentData)
+    const extData = extensionDataByBidder[bidder] || {}
+    const nextConfig = mergeOrtbConfig(currConfig, segmentData, extData)
 
     config.setBidderConfig({
       bidders: [bidder],
@@ -84,12 +85,13 @@ export function setBidderRtb (auctionDetails, customModuleConfig) {
 }
 
 /**
- * Merges segments into existing bidder config
+ * Merges segments and extension data into existing bidder config
  * @param {Object} currConfig - Current bidder config
  * @param {Object} segmentData - Segment data
+ * @param {Object} extData - Exchange-specific extension data
  * @return {Object} Merged ortb2 object
  */
-function mergeOrtbConfig (currConfig, segmentData) {
+function mergeOrtbConfig (currConfig, segmentData, extData) {
   const segment = segmentData.ac.map(seg => {
     return { id: seg }
   })
@@ -98,7 +100,7 @@ function mergeOrtbConfig (currConfig, segmentData) {
   const currSegments = deepAccess(ortbConfig, 'ortb2.user.data') || []
   const userSegment = currSegments
     .filter(el => el.name !== name)
-    .concat({ name, segment })
+    .concat({ name, segment, ext: extData })
 
   deepSetValue(ortbConfig, 'ortb2.user.data', userSegment)
 
@@ -225,9 +227,10 @@ export function isPermutiveOnPage () {
 /**
  * Get all relevant segment IDs in an object
  * @param {number} maxSegs - Maximum number of segments to be included
+ * @param {Object} bidderTransformations - object containing functions to transform segment IDs, keyed by bidder ID
  * @return {Object}
  */
-export function getSegments (maxSegs) {
+export function getSegments (maxSegs, bidderTransformations) {
   const legacySegs = readSegments('_psegs').map(Number).filter(seg => seg >= 1000000).map(String)
   const _ppam = readSegments('_ppam')
   const _pcrprs = readSegments('_pcrprs')
@@ -236,11 +239,16 @@ export function getSegments (maxSegs) {
     ac: [..._pcrprs, ..._ppam, ...legacySegs],
     rubicon: readSegments('_prubicons'),
     appnexus: readSegments('_papns'),
-    gam: readSegments('_pdfps')
+    gam: readSegments('_pdfps'),
+    ix: legacySegs
   }
 
-  for (const type in segments) {
-    segments[type] = segments[type].slice(0, maxSegs)
+  for (const bidder in segments) {
+    segments[bidder] = segments[bidder].slice(0, maxSegs)
+
+    if (bidderTransformations.hasOwnProperty(bidder)) {
+      segments[bidder] = bidderTransformations[bidder](segments[bidder])
+    }
   }
 
   return segments
@@ -260,6 +268,37 @@ function readSegments (key) {
   }
 }
 
+/**
+ * Bidder-specific extension data for use in the ORTB2 object.
+ */
+const extensionDataByBidder = {
+  ix: {
+    segtax: '4'
+  }
+}
+
+/**
+ * Bidder-specific functions to apply to an array of segment IDs.
+ * Each function should return an a new array of transformed segment IDs.
+ */
+const segmentIdTransformationsByBidder = {
+  ix: segments => segments.map(iabSegmentId).filter(id => id != 'unknown')
+}
+
+/**
+ * Transform a Permutive segment ID into an IAB audience taxonomy ID.
+ * Currently uses a hardcoded mapping to support an initial test of this functionality.
+ * @param {string} permutiveSegmentId
+ * @return {string} IAB audience taxonomy ID associated with the Permutive segment ID
+ */
+function iabSegmentId(permutiveSegmentId) {
+  const iabIdsByPermutiveId = {
+    1: '1' // TODO
+  }
+
+  return iabIdsByPermutiveId[permutiveSegmentId] || 'unknown'
+}
+
 /** @type {RtdSubmodule} */
 export const permutiveSubmodule = {
   name: MODULE_NAME,

test/spec/modules/permutiveRtdProvider_spec.js

@@ -42,10 +42,17 @@ describe('permutiveRtdProvider', function () {
         return { id: seg }
       })
 
+      const expectedBidderExtensionData = {
+        ix: {
+          segtax: '4'
+        }
+      }
+
       setBidderRtb({}, moduleConfig)
 
       acBidders.forEach(bidder => {
         expect(bidderConfig[bidder].ortb2.user.data).to.deep.include.members([{
+          ext: expectedBidderExtensionData[bidder] || {},
           name: 'permutive.com',
           segment: expectedTargetingData
         }])
@@ -91,11 +98,22 @@ describe('permutiveRtdProvider', function () {
   describe('Getting segments', function () {
     it('should retrieve segments in the expected structure', function () {
       const data = transformedTargeting()
-      expect(getSegments(250)).to.deep.equal(data)
+      expect(getSegments(250, {})).to.deep.equal(data)
+    })
+    it('should apply bidder transformations', function () {
+      const transformedSegments = ['1', '2', '3']
+      const transformations = {
+        ix: segments => transformedSegments
+      }
+
+      const expectedSegmentData = transformedTargeting()
+      expectedSegmentData['ix'] = transformedSegments
+
+      expect(getSegments(10, transformations)).to.deep.equal(expectedSegmentData)
     })
     it('should enforce max segments', function () {
       const max = 1
-      const segments = getSegments(max)
+      const segments = getSegments(max, {})
 
       for (const key in segments) {
         expect(segments[key]).to.have.length(max)
@@ -293,6 +311,10 @@ describe('permutiveRtdProvider', function () {
       expect(isAcEnabled({ params: { acBidders: ['ozone'] } }, 'ozone')).to.equal(true)
       expect(isAcEnabled({ params: { acBidders: ['kjdvb'] } }, 'ozone')).to.equal(false)
     })
+    it('checks if AC is enabled for Index', function () {
+      expect(isAcEnabled({ params: { acBidders: ['ix'] } }, 'ix')).to.equal(true)
+      expect(isAcEnabled({ params: { acBidders: ['kjdvb'] } }, 'ix')).to.equal(false)
+    })
   })
 })
 
@@ -313,7 +335,7 @@ function getConfig () {
     name: 'permutive',
     waitForIt: true,
     params: {
-      acBidders: ['appnexus', 'rubicon', 'ozone', 'trustx'],
+      acBidders: ['appnexus', 'rubicon', 'ozone', 'trustx', 'ix'],
       maxSegs: 500
     }
   }
@@ -326,7 +348,8 @@ function transformedTargeting () {
     ac: [...data._pcrprs, ...data._ppam, ...data._psegs.filter(seg => seg >= 1000000)],
     appnexus: data._papns,
     rubicon: data._prubicons,
-    gam: data._pdfps
+    gam: data._pdfps,
+    ix: data._psegs.filter(seg => seg >= 1000000)
   }
 }