prebid.js 10.2.0 → 10.4.0

package/test/spec/modules/pubmaticRtdProvider_spec.js

@@ -6,1560 +6,1560 @@ import { config as conf } from '../../../src/config.js';
 import * as hook from '../../../src/hook.js';
 import * as prebidGlobal from '../../../src/prebidGlobal.js';
 import {
-    registerSubModule, pubmaticSubmodule, getFloorsConfig, fetchData,
-    getCurrentTimeOfDay, getBrowserType, getOs, getDeviceType, getCountry, getUtm, getBidder, _country,
-    _profileConfigs, _floorsData, defaultValueTemplate, withTimeout, configMerged,
-    getProfileConfigs, setProfileConfigs, getTargetingData
+  registerSubModule, pubmaticSubmodule, getFloorsConfig, fetchData,
+  getCurrentTimeOfDay, getBrowserType, getOs, getDeviceType, getCountry, getUtm, getBidder, _country,
+  _profileConfigs, _floorsData, defaultValueTemplate, withTimeout, configMerged,
+  getProfileConfigs, setProfileConfigs, getTargetingData
 } from '../../../modules/pubmaticRtdProvider.js';
 import sinon from 'sinon';
 
 describe('Pubmatic RTD Provider', () => {
-    let sandbox;
+  let sandbox;
+
+  beforeEach(() => {
+    sandbox = sinon.createSandbox();
+    sandbox.stub(conf, 'getConfig').callsFake(() => {
+      return {
+        floors: {
+          'enforcement': {
+            'floorDeals': true,
+            'enforceJS': true
+          }
+        },
+        realTimeData: {
+          auctionDelay: 100
+        }
+      };
+    });
+  });
+
+  afterEach(() => {
+    sandbox.restore();
+  });
+
+  describe('registerSubModule', () => {
+    it('should register RTD submodule provider', () => {
+      const submoduleStub = sinon.stub(hook, 'submodule');
+      registerSubModule();
+      assert(submoduleStub.calledOnceWith('realTimeData', pubmaticSubmodule));
+      submoduleStub.restore();
+    });
+  });
 
-    beforeEach(() => {
-        sandbox = sinon.createSandbox();
-        sandbox.stub(conf, 'getConfig').callsFake(() => {
-            return {
-                floors: {
-                    'enforcement': {
-                        'floorDeals': true,
-                        'enforceJS': true
-                    }
-                },
-                realTimeData: {
-                    auctionDelay: 100
-                }
-            };
-        });
+  describe('submodule', () => {
+    describe('name', () => {
+      it('should be pubmatic', () => {
+        expect(pubmaticSubmodule.name).to.equal('pubmatic');
+      });
     });
+  });
 
-    afterEach(() => {
-        sandbox.restore();
+  describe('init', () => {
+    let logErrorStub;
+    let continueAuctionStub;
+
+    const getConfig = () => ({
+      params: {
+        publisherId: 'test-publisher-id',
+        profileId: 'test-profile-id'
+      },
     });
 
-    describe('registerSubModule', () => {
-        it('should register RTD submodule provider', () => {
-            const submoduleStub = sinon.stub(hook, 'submodule');
-            registerSubModule();
-            assert(submoduleStub.calledOnceWith('realTimeData', pubmaticSubmodule));
-            submoduleStub.restore();
-        });
+    beforeEach(() => {
+      logErrorStub = sandbox.stub(utils, 'logError');
+      continueAuctionStub = sandbox.stub(priceFloors, 'continueAuction');
     });
 
-    describe('submodule', () => {
-        describe('name', () => {
-            it('should be pubmatic', () => {
-                expect(pubmaticSubmodule.name).to.equal('pubmatic');
-            });
-        });
+    it('should return false if publisherId is missing', () => {
+      const config = {
+        params: {
+          profileId: 'test-profile-id'
+        }
+      };
+      expect(pubmaticSubmodule.init(config)).to.be.false;
     });
 
-    describe('init', () => {
-        let logErrorStub;
-        let continueAuctionStub;
+    it('should return false if profileId is missing', () => {
+      const config = {
+        params: {
+          publisherId: 'test-publisher-id'
+        }
+      };
+      expect(pubmaticSubmodule.init(config)).to.be.false;
+    });
 
-        const getConfig = () => ({
-            params: {
-                publisherId: 'test-publisher-id',
-                profileId: 'test-profile-id'
-            },
-        });
+    it('should return false if publisherId is not a string', () => {
+      const config = {
+        params: {
+          publisherId: 123,
+          profileId: 'test-profile-id'
+        }
+      };
+      expect(pubmaticSubmodule.init(config)).to.be.false;
+    });
 
-        beforeEach(() => {
-            logErrorStub = sandbox.stub(utils, 'logError');
-            continueAuctionStub = sandbox.stub(priceFloors, 'continueAuction');
-        });
+    it('should return false if profileId is not a string', () => {
+      const config = {
+        params: {
+          publisherId: 'test-publisher-id',
+          profileId: 345
+        }
+      };
+      expect(pubmaticSubmodule.init(config)).to.be.false;
+    });
 
-        it('should return false if publisherId is missing', () => {
-            const config = {
-                params: {
-                    profileId: 'test-profile-id'
-                }
-            };
-            expect(pubmaticSubmodule.init(config)).to.be.false;
-        });
+    it('should initialize successfully with valid config', () => {
+      expect(pubmaticSubmodule.init(getConfig())).to.be.true;
+    });
 
-        it('should return false if profileId is missing', () => {
-            const config = {
-                params: {
-                    publisherId: 'test-publisher-id'
-                }
-            };
-            expect(pubmaticSubmodule.init(config)).to.be.false;
-        });
+    it('should handle empty config object', () => {
+      expect(pubmaticSubmodule.init({})).to.be.false;
+      expect(logErrorStub.calledWith(sinon.match(/Missing publisher Id/))).to.be.true;
+    });
 
-        it('should return false if publisherId is not a string', () => {
-            const config = {
-                params: {
-                    publisherId: 123,
-                    profileId: 'test-profile-id'
-                }
-            };
-            expect(pubmaticSubmodule.init(config)).to.be.false;
-        });
+    it('should return false if continueAuction is not a function', () => {
+      continueAuctionStub.value(undefined);
+      expect(pubmaticSubmodule.init(getConfig())).to.be.false;
+      expect(logErrorStub.calledWith(sinon.match(/continueAuction is not a function/))).to.be.true;
+    });
+  });
 
-        it('should return false if profileId is not a string', () => {
-            const config = {
-                params: {
-                    publisherId: 'test-publisher-id',
-                    profileId: 345
-                }
-            };
-            expect(pubmaticSubmodule.init(config)).to.be.false;
-        });
+  describe('getCurrentTimeOfDay', () => {
+    let clock;
 
-        it('should initialize successfully with valid config', () => {
-            expect(pubmaticSubmodule.init(getConfig())).to.be.true;
-        });
+    beforeEach(() => {
+      clock = sandbox.useFakeTimers(new Date('2024-01-01T12:00:00')); // Set fixed time for testing
+    });
 
-        it('should handle empty config object', () => {
-            expect(pubmaticSubmodule.init({})).to.be.false;
-            expect(logErrorStub.calledWith(sinon.match(/Missing publisher Id/))).to.be.true;
-        });
+    afterEach(() => {
+      clock.restore();
+    });
 
-        it('should return false if continueAuction is not a function', () => {
-            continueAuctionStub.value(undefined);
-            expect(pubmaticSubmodule.init(getConfig())).to.be.false;
-            expect(logErrorStub.calledWith(sinon.match(/continueAuction is not a function/))).to.be.true;
-        });
+    const testTimes = [
+      { hour: 6, expected: 'morning' },
+      { hour: 13, expected: 'afternoon' },
+      { hour: 18, expected: 'evening' },
+      { hour: 22, expected: 'night' },
+      { hour: 4, expected: 'night' }
+    ];
+
+    testTimes.forEach(({ hour, expected }) => {
+      it(`should return ${expected} at ${hour}:00`, () => {
+        clock.setSystemTime(new Date().setHours(hour));
+        const result = getCurrentTimeOfDay();
+        expect(result).to.equal(expected);
+      });
     });
+  });
 
-    describe('getCurrentTimeOfDay', () => {
-        let clock;
+  describe('getBrowserType', () => {
+    let userAgentStub, getLowEntropySUAStub;
 
-        beforeEach(() => {
-            clock = sandbox.useFakeTimers(new Date('2024-01-01T12:00:00')); // Set fixed time for testing
-        });
+    const USER_AGENTS = {
+      chrome: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
+      firefox: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:89.0) Gecko/20100101 Firefox/89.0',
+      edge: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Edg/91.0.864.67 Safari/537.36',
+      safari: 'Mozilla/5.0 (iPhone; CPU iPhone OS 14_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.0.6 Mobile/15E148 Safari/604.1',
+      ie: 'Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.1; Trident/6.0)',
+      opera: 'Opera/9.80 (Windows NT 6.1; WOW64) Presto/2.12.388 Version/12.16',
+      unknown: 'UnknownBrowser/1.0'
+    };
 
-        afterEach(() => {
-            clock.restore();
-        });
+    beforeEach(() => {
+      userAgentStub = sandbox.stub(navigator, 'userAgent');
+      getLowEntropySUAStub = sandbox.stub(suaModule, 'getLowEntropySUA').returns(undefined);
+    });
 
-        const testTimes = [
-            { hour: 6, expected: 'morning' },
-            { hour: 13, expected: 'afternoon' },
-            { hour: 18, expected: 'evening' },
-            { hour: 22, expected: 'night' },
-            { hour: 4, expected: 'night' }
-        ];
-
-        testTimes.forEach(({ hour, expected }) => {
-            it(`should return ${expected} at ${hour}:00`, () => {
-                clock.setSystemTime(new Date().setHours(hour));
-                const result = getCurrentTimeOfDay();
-                expect(result).to.equal(expected);
-            });
-        });
+    afterEach(() => {
+      userAgentStub.restore();
+      getLowEntropySUAStub.restore();
     });
 
-    describe('getBrowserType', () => {
-        let userAgentStub, getLowEntropySUAStub;
+    it('should detect Chrome', () => {
+      userAgentStub.value(USER_AGENTS.chrome);
+      expect(getBrowserType()).to.equal('9');
+    });
 
-        const USER_AGENTS = {
-            chrome: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
-            firefox: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:89.0) Gecko/20100101 Firefox/89.0',
-            edge: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Edg/91.0.864.67 Safari/537.36',
-            safari: 'Mozilla/5.0 (iPhone; CPU iPhone OS 14_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.0.6 Mobile/15E148 Safari/604.1',
-            ie: 'Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.1; Trident/6.0)',
-            opera: 'Opera/9.80 (Windows NT 6.1; WOW64) Presto/2.12.388 Version/12.16',
-            unknown: 'UnknownBrowser/1.0'
-        };
+    it('should detect Firefox', () => {
+      userAgentStub.value(USER_AGENTS.firefox);
+      expect(getBrowserType()).to.equal('12');
+    });
 
-        beforeEach(() => {
-            userAgentStub = sandbox.stub(navigator, 'userAgent');
-            getLowEntropySUAStub = sandbox.stub(suaModule, 'getLowEntropySUA').returns(undefined);
-        });
+    it('should detect Edge', () => {
+      userAgentStub.value(USER_AGENTS.edge);
+      expect(getBrowserType()).to.equal('2');
+    });
 
-        afterEach(() => {
-            userAgentStub.restore();
-            getLowEntropySUAStub.restore();
-        });
+    it('should detect Internet Explorer', () => {
+      userAgentStub.value(USER_AGENTS.ie);
+      expect(getBrowserType()).to.equal('4');
+    });
 
-        it('should detect Chrome', () => {
-            userAgentStub.value(USER_AGENTS.chrome);
-            expect(getBrowserType()).to.equal('9');
-        });
+    it('should detect Opera', () => {
+      userAgentStub.value(USER_AGENTS.opera);
+      expect(getBrowserType()).to.equal('3');
+    });
 
-        it('should detect Firefox', () => {
-            userAgentStub.value(USER_AGENTS.firefox);
-            expect(getBrowserType()).to.equal('12');
-        });
+    it('should return 0 for unknown browser', () => {
+      userAgentStub.value(USER_AGENTS.unknown);
+      expect(getBrowserType()).to.equal('0');
+    });
 
-        it('should detect Edge', () => {
-            userAgentStub.value(USER_AGENTS.edge);
-            expect(getBrowserType()).to.equal('2');
-        });
+    it('should return -1 when userAgent is null', () => {
+      userAgentStub.value(null);
+      expect(getBrowserType()).to.equal('-1');
+    });
+  });
 
-        it('should detect Internet Explorer', () => {
-            userAgentStub.value(USER_AGENTS.ie);
-            expect(getBrowserType()).to.equal('4');
-        });
+  describe('Utility functions', () => {
+    it('should set browser correctly', () => {
+      expect(getBrowserType()).to.be.a('string');
+    });
 
-        it('should detect Opera', () => {
-            userAgentStub.value(USER_AGENTS.opera);
-            expect(getBrowserType()).to.equal('3');
-        });
+    it('should set OS correctly', () => {
+      expect(getOs()).to.be.a('string');
+    });
 
-        it('should return 0 for unknown browser', () => {
-            userAgentStub.value(USER_AGENTS.unknown);
-            expect(getBrowserType()).to.equal('0');
-        });
+    it('should set device type correctly', () => {
+      expect(getDeviceType()).to.be.a('string');
+    });
 
-        it('should return -1 when userAgent is null', () => {
-            userAgentStub.value(null);
-            expect(getBrowserType()).to.equal('-1');
-        });
+    it('should set time of day correctly', () => {
+      expect(getCurrentTimeOfDay()).to.be.a('string');
     });
 
-    describe('Utility functions', () => {
-        it('should set browser correctly', () => {
-            expect(getBrowserType()).to.be.a('string');
-        });
+    it('should set country correctly', () => {
+      expect(getCountry()).to.satisfy(value => typeof value === 'string' || value === undefined);
+    });
 
-        it('should set OS correctly', () => {
-            expect(getOs()).to.be.a('string');
-        });
+    it('should set UTM correctly', () => {
+      expect(getUtm()).to.be.a('string');
+      expect(getUtm()).to.be.oneOf(['0', '1']);
+    });
 
-        it('should set device type correctly', () => {
-            expect(getDeviceType()).to.be.a('string');
-        });
+    it('should extract bidder correctly', () => {
+      expect(getBidder({ bidder: 'pubmatic' })).to.equal('pubmatic');
+      expect(getBidder({})).to.be.undefined;
+      expect(getBidder(null)).to.be.undefined;
+      expect(getBidder(undefined)).to.be.undefined;
+    });
+  });
 
-        it('should set time of day correctly', () => {
-            expect(getCurrentTimeOfDay()).to.be.a('string');
-        });
+  describe('getFloorsConfig', () => {
+    let floorsData, profileConfigs;
+    let sandbox;
+    let logErrorStub;
 
-        it('should set country correctly', () => {
-            expect(getCountry()).to.satisfy(value => typeof value === 'string' || value === undefined);
-        });
+    beforeEach(() => {
+      sandbox = sinon.createSandbox();
+      logErrorStub = sandbox.stub(utils, 'logError');
+      floorsData = {
+        "currency": "USD",
+        "floorProvider": "PM",
+        "floorsSchemaVersion": 2,
+        "modelGroups": [
+          {
+            "modelVersion": "M_1",
+            "modelWeight": 100,
+            "schema": {
+              "fields": [
+                "domain"
+              ]
+            },
+            "values": {
+              "*": 2.00
+            }
+          }
+        ],
+        "skipRate": 0
+      };
+      profileConfigs = {
+        'plugins': {
+          'dynamicFloors': {
+            'enabled': true,
+            'config': {
+              'enforcement': {
+                'floorDeals': false,
+                'enforceJS': false
+              },
+              'floorMin': 0.1111,
+              'skipRate': 11,
+              'defaultValues': {
+                "*|*": 0.2
+              }
+            }
+          }
+        }
+      }
+    });
 
-        it('should set UTM correctly', () => {
-            expect(getUtm()).to.be.a('string');
-            expect(getUtm()).to.be.oneOf(['0', '1']);
-        });
+    afterEach(() => {
+      sandbox.restore();
+    });
 
-        it('should extract bidder correctly', () => {
-            expect(getBidder({ bidder: 'pubmatic' })).to.equal('pubmatic');
-            expect(getBidder({})).to.be.undefined;
-            expect(getBidder(null)).to.be.undefined;
-            expect(getBidder(undefined)).to.be.undefined;
-        });
+    it('should return correct config structure', () => {
+      const result = getFloorsConfig(floorsData, profileConfigs);
+
+      expect(result.floors).to.be.an('object');
+      expect(result.floors).to.be.an('object');
+      expect(result.floors).to.have.property('enforcement');
+      expect(result.floors.enforcement).to.have.property('floorDeals', false);
+      expect(result.floors.enforcement).to.have.property('enforceJS', false);
+      expect(result.floors).to.have.property('floorMin', 0.1111);
+
+      // Verify the additionalSchemaFields structure
+      expect(result.floors.additionalSchemaFields).to.have.all.keys([
+        'deviceType',
+        'timeOfDay',
+        'browser',
+        'os',
+        'country',
+        'utm',
+        'bidder'
+      ]);
+
+      Object.values(result.floors.additionalSchemaFields).forEach(field => {
+        expect(field).to.be.a('function');
+      });
     });
 
-    describe('getFloorsConfig', () => {
-        let floorsData, profileConfigs;
-        let sandbox;
-        let logErrorStub;
+    it('should return undefined when plugin is disabled', () => {
+      profileConfigs.plugins.dynamicFloors.enabled = false;
+      const result = getFloorsConfig(floorsData, profileConfigs);
 
-        beforeEach(() => {
-            sandbox = sinon.createSandbox();
-            logErrorStub = sandbox.stub(utils, 'logError');
-            floorsData = {
-                "currency": "USD",
-                "floorProvider": "PM",
-                "floorsSchemaVersion": 2,
-                "modelGroups": [
-                    {
-                        "modelVersion": "M_1",
-                        "modelWeight": 100,
-                        "schema": {
-                            "fields": [
-                                "domain"
-                            ]
-                        },
-                        "values": {
-                            "*": 2.00
-                        }
-                    }
-                ],
-                "skipRate": 0
-            };
-            profileConfigs = {
-                'plugins': {
-                    'dynamicFloors': {
-                        'enabled': true,
-                        'config': {
-                            'enforcement': {
-                                'floorDeals': false,
-                                'enforceJS': false
-                            },
-                            'floorMin': 0.1111,
-                            'skipRate': 11,
-                            'defaultValues': {
-                                "*|*": 0.2
-                            }
-                        }
-                    }
-                }
-            }
-        });
+      expect(result).to.equal(undefined);
+    });
 
-        afterEach(() => {
-            sandbox.restore();
-        });
+    it('should initialise default values to empty object when not available', () => {
+      profileConfigs.plugins.dynamicFloors.config.defaultValues = undefined;
+      floorsData = undefined;
+      const result = getFloorsConfig(floorsData, profileConfigs);
 
-        it('should return correct config structure', () => {
-            const result = getFloorsConfig(floorsData, profileConfigs);
-
-            expect(result.floors).to.be.an('object');
-            expect(result.floors).to.be.an('object');
-            expect(result.floors).to.have.property('enforcement');
-            expect(result.floors.enforcement).to.have.property('floorDeals', false);
-            expect(result.floors.enforcement).to.have.property('enforceJS', false);
-            expect(result.floors).to.have.property('floorMin', 0.1111);
-
-            // Verify the additionalSchemaFields structure
-            expect(result.floors.additionalSchemaFields).to.have.all.keys([
-                'deviceType',
-                'timeOfDay',
-                'browser',
-                'os',
-                'country',
-                'utm',
-                'bidder'
-            ]);
-
-            Object.values(result.floors.additionalSchemaFields).forEach(field => {
-                expect(field).to.be.a('function');
-            });
-        });
+      expect(result.floors.data).to.have.property('currency', 'USD');
+      expect(result.floors.data).to.have.property('skipRate', 11);
+      expect(result.floors.data.schema).to.deep.equal(defaultValueTemplate.schema);
+      expect(result.floors.data.value).to.deep.equal(defaultValueTemplate.value);
+    });
 
-        it('should return undefined when plugin is disabled', () => {
-            profileConfigs.plugins.dynamicFloors.enabled = false;
-            const result = getFloorsConfig(floorsData, profileConfigs);
+    it('should replace skipRate from config to data when avaialble', () => {
+      const result = getFloorsConfig(floorsData, profileConfigs);
 
-            expect(result).to.equal(undefined);
-        });
+      expect(result.floors.data).to.have.property('skipRate', 11);
+    });
 
-        it('should initialise default values to empty object when not available', () => {
-            profileConfigs.plugins.dynamicFloors.config.defaultValues = undefined;
-            floorsData = undefined;
-            const result = getFloorsConfig(floorsData, profileConfigs);
+    it('should not replace skipRate from config to data when not avaialble', () => {
+      delete profileConfigs.plugins.dynamicFloors.config.skipRate;
+      const result = getFloorsConfig(floorsData, profileConfigs);
 
-            expect(result.floors.data).to.have.property('currency', 'USD');
-            expect(result.floors.data).to.have.property('skipRate', 11);
-            expect(result.floors.data.schema).to.deep.equal(defaultValueTemplate.schema);
-            expect(result.floors.data.value).to.deep.equal(defaultValueTemplate.value);
-        });
+      expect(result.floors.data).to.have.property('skipRate', 0);
+    });
 
-        it('should replace skipRate from config to data when avaialble', () => {
-            const result = getFloorsConfig(floorsData, profileConfigs);
+    it('should maintain correct function references', () => {
+      const result = getFloorsConfig(floorsData, profileConfigs);
 
-            expect(result.floors.data).to.have.property('skipRate', 11);
-        });
+      expect(result.floors.additionalSchemaFields.deviceType).to.equal(getDeviceType);
+      expect(result.floors.additionalSchemaFields.timeOfDay).to.equal(getCurrentTimeOfDay);
+      expect(result.floors.additionalSchemaFields.browser).to.equal(getBrowserType);
+      expect(result.floors.additionalSchemaFields.os).to.equal(getOs);
+      expect(result.floors.additionalSchemaFields.country).to.equal(getCountry);
+      expect(result.floors.additionalSchemaFields.utm).to.equal(getUtm);
+      expect(result.floors.additionalSchemaFields.bidder).to.equal(getBidder);
+    });
 
-        it('should not replace skipRate from config to data when not avaialble', () => {
-            delete profileConfigs.plugins.dynamicFloors.config.skipRate;
-            const result = getFloorsConfig(floorsData, profileConfigs);
+    it('should log error when profileConfigs is not an object', () => {
+      profileConfigs = 'invalid';
+      const result = getFloorsConfig(floorsData, profileConfigs);
+      expect(result).to.be.undefined;
+      expect(logErrorStub.calledWith(sinon.match(/profileConfigs is not an object or is empty/))).to.be.true;
+    });
+  });
 
-            expect(result.floors.data).to.have.property('skipRate', 0);
-        });
+  describe('fetchData for configs', () => {
+    let logErrorStub;
+    let fetchStub;
+    let confStub;
 
-        it('should maintain correct function references', () => {
-            const result = getFloorsConfig(floorsData, profileConfigs);
+    beforeEach(() => {
+      logErrorStub = sandbox.stub(utils, 'logError');
+      fetchStub = sandbox.stub(window, 'fetch');
+      confStub = sandbox.stub(conf, 'setConfig');
+    });
 
-            expect(result.floors.additionalSchemaFields.deviceType).to.equal(getDeviceType);
-            expect(result.floors.additionalSchemaFields.timeOfDay).to.equal(getCurrentTimeOfDay);
-            expect(result.floors.additionalSchemaFields.browser).to.equal(getBrowserType);
-            expect(result.floors.additionalSchemaFields.os).to.equal(getOs);
-            expect(result.floors.additionalSchemaFields.country).to.equal(getCountry);
-            expect(result.floors.additionalSchemaFields.utm).to.equal(getUtm);
-            expect(result.floors.additionalSchemaFields.bidder).to.equal(getBidder);
-        });
+    afterEach(() => {
+      sandbox.restore();
+    });
 
-        it('should log error when profileConfigs is not an object', () => {
-            profileConfigs = 'invalid';
-            const result = getFloorsConfig(floorsData, profileConfigs);
-            expect(result).to.be.undefined;
-            expect(logErrorStub.calledWith(sinon.match(/profileConfigs is not an object or is empty/))).to.be.true;
-        });
+    it('should successfully fetch profile configs', async () => {
+      const mockApiResponse = {
+        "profileName": "profie name",
+        "desc": "description",
+        "plugins": {
+          "dynamicFloors": {
+            "enabled": false
+          }
+        }
+      };
+
+      fetchStub.resolves(new Response(JSON.stringify(mockApiResponse), { status: 200 }));
+
+      const result = await fetchData('1234', '123', 'CONFIGS');
+      expect(result).to.deep.equal(mockApiResponse);
     });
 
-    describe('fetchData for configs', () => {
-        let logErrorStub;
-        let fetchStub;
-        let confStub;
+    it('should log error when JSON parsing fails', async () => {
+      fetchStub.resolves(new Response('Invalid JSON', { status: 200 }));
 
-        beforeEach(() => {
-            logErrorStub = sandbox.stub(utils, 'logError');
-            fetchStub = sandbox.stub(window, 'fetch');
-            confStub = sandbox.stub(conf, 'setConfig');
-        });
+      await fetchData('1234', '123', 'CONFIGS');
+      expect(logErrorStub.calledWith(sinon.match(/Error while fetching\s*CONFIGS/))).to.be.true;
+    });
 
-        afterEach(() => {
-            sandbox.restore();
-        });
+    it('should log error when response is not ok', async () => {
+      fetchStub.resolves(new Response(null, { status: 500 }));
 
-        it('should successfully fetch profile configs', async () => {
-            const mockApiResponse = {
-                "profileName": "profie name",
-                "desc": "description",
-                "plugins": {
-                    "dynamicFloors": {
-                        "enabled": false
-                    }
-                }
-            };
+      await fetchData('1234', '123', 'CONFIGS');
+      expect(logErrorStub.calledWith(sinon.match(/Error while fetching\s*CONFIGS/))).to.be.true;
+    });
 
-            fetchStub.resolves(new Response(JSON.stringify(mockApiResponse), { status: 200 }));
+    it('should log error on network failure', async () => {
+      fetchStub.rejects(new Error('Network Error'));
 
-            const result = await fetchData('1234', '123', 'CONFIGS');
-            expect(result).to.deep.equal(mockApiResponse);
-        });
+      await fetchData('1234', '123', 'CONFIGS');
+      expect(logErrorStub.called).to.be.true;
+      expect(logErrorStub.calledWith(sinon.match(/Error while fetching\s*CONFIGS/))).to.be.true;
+    });
+  });
 
-        it('should log error when JSON parsing fails', async () => {
-            fetchStub.resolves(new Response('Invalid JSON', { status: 200 }));
+  describe('fetchData for floors', () => {
+    let logErrorStub;
+    let fetchStub;
+    let confStub;
 
-            await fetchData('1234', '123', 'CONFIGS');
-            expect(logErrorStub.calledWith(sinon.match(/Error while fetching\s*CONFIGS/))).to.be.true;
-        });
+    beforeEach(() => {
+      logErrorStub = sandbox.stub(utils, 'logError');
+      fetchStub = sandbox.stub(window, 'fetch');
+      confStub = sandbox.stub(conf, 'setConfig');
+      global._country = undefined;
+    });
 
-        it('should log error when response is not ok', async () => {
-            fetchStub.resolves(new Response(null, { status: 500 }));
+    afterEach(() => {
+      sandbox.restore();
+    });
 
-            await fetchData('1234', '123', 'CONFIGS');
-            expect(logErrorStub.calledWith(sinon.match(/Error while fetching\s*CONFIGS/))).to.be.true;
-        });
+    it('should successfully fetch and parse floor rules', async () => {
+      const mockApiResponse = {
+        data: {
+          currency: 'USD',
+          modelGroups: [],
+          values: {}
+        }
+      };
 
-        it('should log error on network failure', async () => {
-            fetchStub.rejects(new Error('Network Error'));
+      fetchStub.resolves(new Response(JSON.stringify(mockApiResponse), { status: 200, headers: { 'country_code': 'US' } }));
 
-            await fetchData('1234', '123', 'CONFIGS');
-            expect(logErrorStub.called).to.be.true;
-            expect(logErrorStub.calledWith(sinon.match(/Error while fetching\s*CONFIGS/))).to.be.true;
-        });
+      const result = await fetchData('1234', '123', 'FLOORS');
+      expect(result).to.deep.equal(mockApiResponse);
+      expect(_country).to.equal('US');
     });
 
-    describe('fetchData for floors', () => {
-        let logErrorStub;
-        let fetchStub;
-        let confStub;
+    it('should correctly extract the first unique country code from response headers', async () => {
+      fetchStub.resolves(new Response(JSON.stringify({}), {
+        status: 200,
+        headers: { 'country_code': 'US,IN,US' }
+      }));
 
-        beforeEach(() => {
-            logErrorStub = sandbox.stub(utils, 'logError');
-            fetchStub = sandbox.stub(window, 'fetch');
-            confStub = sandbox.stub(conf, 'setConfig');
-            global._country = undefined;
-        });
+      await fetchData('1234', '123', 'FLOORS');
+      expect(_country).to.equal('US');
+    });
 
-        afterEach(() => {
-            sandbox.restore();
-        });
+    it('should set _country to undefined if country_code header is missing', async () => {
+      fetchStub.resolves(new Response(JSON.stringify({}), {
+        status: 200
+      }));
 
-        it('should successfully fetch and parse floor rules', async () => {
-            const mockApiResponse = {
-                data: {
-                    currency: 'USD',
-                    modelGroups: [],
-                    values: {}
-                }
-            };
+      await fetchData('1234', '123', 'FLOORS');
+      expect(_country).to.be.undefined;
+    });
 
-            fetchStub.resolves(new Response(JSON.stringify(mockApiResponse), { status: 200, headers: { 'country_code': 'US' } }));
+    it('should log error when JSON parsing fails', async () => {
+      fetchStub.resolves(new Response('Invalid JSON', { status: 200 }));
 
-            const result = await fetchData('1234', '123', 'FLOORS');
-            expect(result).to.deep.equal(mockApiResponse);
-            expect(_country).to.equal('US');
-        });
+      await fetchData('1234', '123', 'FLOORS');
+      expect(logErrorStub.calledWith(sinon.match(/Error while fetching\s*FLOORS/))).to.be.true;
+    });
 
-        it('should correctly extract the first unique country code from response headers', async () => {
-            fetchStub.resolves(new Response(JSON.stringify({}), {
-                status: 200,
-                headers: { 'country_code': 'US,IN,US' }
-            }));
+    it('should log error when response is not ok', async () => {
+      fetchStub.resolves(new Response(null, { status: 500 }));
 
-            await fetchData('1234', '123', 'FLOORS');
-            expect(_country).to.equal('US');
-        });
+      await fetchData('1234', '123', 'FLOORS');
+      expect(logErrorStub.calledWith(sinon.match(/Error while fetching\s*FLOORS/))).to.be.true;
+    });
 
-        it('should set _country to undefined if country_code header is missing', async () => {
-            fetchStub.resolves(new Response(JSON.stringify({}), {
-                status: 200
-            }));
+    it('should log error on network failure', async () => {
+      fetchStub.rejects(new Error('Network Error'));
 
-            await fetchData('1234', '123', 'FLOORS');
-            expect(_country).to.be.undefined;
-        });
+      await fetchData('1234', '123', 'FLOORS');
+      expect(logErrorStub.called).to.be.true;
+      expect(logErrorStub.calledWith(sinon.match(/Error while fetching\s*FLOORS/))).to.be.true;
+    });
+  });
+
+  describe('getBidRequestData', function () {
+    let callback, continueAuctionStub, mergeDeepStub, logErrorStub;
+
+    const reqBidsConfigObj = {
+      adUnits: [{ code: 'ad-slot-code-0' }],
+      auctionId: 'auction-id-0',
+      ortb2Fragments: {
+        bidder: {
+          user: {
+            ext: {
+              ctr: 'US',
+            }
+          }
+        }
+      }
+    };
 
-        it('should log error when JSON parsing fails', async () => {
-            fetchStub.resolves(new Response('Invalid JSON', { status: 200 }));
+    const ortb2 = {
+      user: {
+        ext: {
+          ctr: 'US',
+        }
+      }
+    }
 
-            await fetchData('1234', '123', 'FLOORS');
-            expect(logErrorStub.calledWith(sinon.match(/Error while fetching\s*FLOORS/))).to.be.true;
-        });
+    const hookConfig = {
+      reqBidsConfigObj,
+      context: this,
+      nextFn: () => true,
+      haveExited: false,
+      timer: null
+    };
 
-        it('should log error when response is not ok', async () => {
-            fetchStub.resolves(new Response(null, { status: 500 }));
+    beforeEach(() => {
+      callback = sinon.spy();
+      continueAuctionStub = sandbox.stub(priceFloors, 'continueAuction');
+      logErrorStub = sandbox.stub(utils, 'logError');
 
-            await fetchData('1234', '123', 'FLOORS');
-            expect(logErrorStub.calledWith(sinon.match(/Error while fetching\s*FLOORS/))).to.be.true;
-        });
+      global.configMergedPromise = Promise.resolve();
+    });
 
-        it('should log error on network failure', async () => {
-            fetchStub.rejects(new Error('Network Error'));
+    afterEach(() => {
+      sandbox.restore(); // Restore all stubs/spies
+    });
 
-            await fetchData('1234', '123', 'FLOORS');
-            expect(logErrorStub.called).to.be.true;
-            expect(logErrorStub.calledWith(sinon.match(/Error while fetching\s*FLOORS/))).to.be.true;
-        });
+    it('should call continueAuction with correct hookConfig', async function () {
+      configMerged();
+      await pubmaticSubmodule.getBidRequestData(reqBidsConfigObj, callback);
+
+      expect(continueAuctionStub.called).to.be.true;
+      expect(continueAuctionStub.firstCall.args[0]).to.have.property('reqBidsConfigObj', reqBidsConfigObj);
+      expect(continueAuctionStub.firstCall.args[0]).to.have.property('haveExited', false);
     });
 
-    describe('getBidRequestData', function () {
-        let callback, continueAuctionStub, mergeDeepStub, logErrorStub;
+    // it('should merge country data into ortb2Fragments.bidder', async function () {
+    //     configMerged();
+    //     global._country = 'US';
+    //     pubmaticSubmodule.getBidRequestData(reqBidsConfigObj, callback);
 
-        const reqBidsConfigObj = {
-            adUnits: [{ code: 'ad-slot-code-0' }],
-            auctionId: 'auction-id-0',
-            ortb2Fragments: {
-              bidder: {
-                user: {
-                  ext: {
-                    ctr: 'US',
-                  }
-                }
-              }
-            }
-        };
+    //     expect(reqBidsConfigObj.ortb2Fragments.bidder).to.have.property('pubmatic');
+    //     // expect(reqBidsConfigObj.ortb2Fragments.bidder.pubmatic.user.ext.ctr).to.equal('US');
+    // });
 
-        const ortb2 = {
-            user: {
-              ext: {
-                ctr: 'US',
-              }
-            }
-        }
+    it('should call callback once after execution', async function () {
+      configMerged();
+      await pubmaticSubmodule.getBidRequestData(reqBidsConfigObj, callback);
 
-        const hookConfig = {
-            reqBidsConfigObj,
-            context: this,
-            nextFn: () => true,
-            haveExited: false,
-            timer: null
-        };
+      expect(callback.called).to.be.true;
+    });
+  });
 
-        beforeEach(() => {
-            callback = sinon.spy();
-            continueAuctionStub = sandbox.stub(priceFloors, 'continueAuction');
-            logErrorStub = sandbox.stub(utils, 'logError');
+  describe('withTimeout', function () {
+    it('should resolve with the original promise value if it resolves before the timeout', async function () {
+      const promise = new Promise((resolve) => setTimeout(() => resolve('success'), 50));
+      const result = await withTimeout(promise, 100);
+      expect(result).to.equal('success');
+    });
 
-            global.configMergedPromise = Promise.resolve();
-        });
+    it('should resolve with undefined if the promise takes longer than the timeout', async function () {
+      const promise = new Promise((resolve) => setTimeout(() => resolve('success'), 200));
+      const result = await withTimeout(promise, 100);
+      expect(result).to.be.undefined;
+    });
 
-        afterEach(() => {
-            sandbox.restore(); // Restore all stubs/spies
-        });
+    it('should properly handle rejected promises', async function () {
+      const promise = new Promise((resolve, reject) => setTimeout(() => reject(new Error('Failure')), 50));
+      try {
+        await withTimeout(promise, 100);
+      } catch (error) {
+        expect(error.message).to.equal('Failure');
+      }
+    });
 
-        it('should call continueAuction with correct hookConfig', async function () {
-            configMerged();
-            await pubmaticSubmodule.getBidRequestData(reqBidsConfigObj, callback);
+    it('should resolve with undefined if the original promise is rejected but times out first', async function () {
+      const promise = new Promise((resolve, reject) => setTimeout(() => reject(new Error('Failure')), 200));
+      const result = await withTimeout(promise, 100);
+      expect(result).to.be.undefined;
+    });
 
-            expect(continueAuctionStub.called).to.be.true;
-            expect(continueAuctionStub.firstCall.args[0]).to.have.property('reqBidsConfigObj', reqBidsConfigObj);
-            expect(continueAuctionStub.firstCall.args[0]).to.have.property('haveExited', false);
-        });
+    it('should clear the timeout when the promise resolves before the timeout', async function () {
+      const clock = sinon.useFakeTimers();
+      const clearTimeoutSpy = sinon.spy(global, 'clearTimeout');
 
-        // it('should merge country data into ortb2Fragments.bidder', async function () {
-        //     configMerged();
-        //     global._country = 'US';
-        //     pubmaticSubmodule.getBidRequestData(reqBidsConfigObj, callback);
+      const promise = new Promise((resolve) => setTimeout(() => resolve('success'), 50));
+      const resultPromise = withTimeout(promise, 100);
 
-        //     expect(reqBidsConfigObj.ortb2Fragments.bidder).to.have.property('pubmatic');
-        //     // expect(reqBidsConfigObj.ortb2Fragments.bidder.pubmatic.user.ext.ctr).to.equal('US');
-        // });
+      clock.tick(50);
+      await resultPromise;
 
-        it('should call callback once after execution', async function () {
-            configMerged();
-            await pubmaticSubmodule.getBidRequestData(reqBidsConfigObj, callback);
+      expect(clearTimeoutSpy.called).to.be.true;
 
-            expect(callback.called).to.be.true;
-        });
+      clearTimeoutSpy.restore();
+      clock.restore();
     });
+  });
 
-    describe('withTimeout', function () {
-        it('should resolve with the original promise value if it resolves before the timeout', async function () {
-            const promise = new Promise((resolve) => setTimeout(() => resolve('success'), 50));
-            const result = await withTimeout(promise, 100);
-            expect(result).to.equal('success');
-        });
-
-        it('should resolve with undefined if the promise takes longer than the timeout', async function () {
-            const promise = new Promise((resolve) => setTimeout(() => resolve('success'), 200));
-            const result = await withTimeout(promise, 100);
-            expect(result).to.be.undefined;
-        });
+  describe('getTargetingData', function () {
+    let sandbox;
+    let logInfoStub;
 
-        it('should properly handle rejected promises', async function () {
-            const promise = new Promise((resolve, reject) => setTimeout(() => reject(new Error('Failure')), 50));
-            try {
-                await withTimeout(promise, 100);
-            } catch (error) {
-                expect(error.message).to.equal('Failure');
-            }
-        });
+    beforeEach(() => {
+      sandbox = sinon.createSandbox();
+      logInfoStub = sandbox.stub(utils, 'logInfo');
+    });
 
-        it('should resolve with undefined if the original promise is rejected but times out first', async function () {
-            const promise = new Promise((resolve, reject) => setTimeout(() => reject(new Error('Failure')), 200));
-            const result = await withTimeout(promise, 100);
-            expect(result).to.be.undefined;
-        });
+    afterEach(() => {
+      sandbox.restore();
+    });
 
-        it('should clear the timeout when the promise resolves before the timeout', async function () {
-            const clock = sinon.useFakeTimers();
-            const clearTimeoutSpy = sinon.spy(global, 'clearTimeout');
+    it('should return empty object when profileConfigs is undefined', function () {
+      // Store the original value to restore it later
+      const originalProfileConfigs = getProfileConfigs();
+      // Set profileConfigs to undefined
+      setProfileConfigs(undefined);
 
-            const promise = new Promise((resolve) => setTimeout(() => resolve('success'), 50));
-            const resultPromise = withTimeout(promise, 100);
+      const adUnitCodes = ['test-ad-unit'];
+      const config = {};
+      const userConsent = {};
+      const auction = {};
 
-            clock.tick(50);
-            await resultPromise;
+      const result = getTargetingData(adUnitCodes, config, userConsent, auction);
 
-            expect(clearTimeoutSpy.called).to.be.true;
+      // Restore the original value
+      setProfileConfigs(originalProfileConfigs);
 
-            clearTimeoutSpy.restore();
-            clock.restore();
-        });
+      expect(result).to.deep.equal({});
+      expect(logInfoStub.calledWith(sinon.match(/pmTargetingKeys is disabled or profileConfigs is undefined/))).to.be.true;
     });
 
-    describe('getTargetingData', function () {
-        let sandbox;
-        let logInfoStub;
+    it('should return empty object when pmTargetingKeys.enabled is false', function () {
+      // Create profileConfigs with pmTargetingKeys.enabled set to false
+      const profileConfigsMock = {
+        plugins: {
+          dynamicFloors: {
+            pmTargetingKeys: {
+              enabled: false
+            }
+          }
+        }
+      };
 
-        beforeEach(() => {
-            sandbox = sinon.createSandbox();
-            logInfoStub = sandbox.stub(utils, 'logInfo');
-        });
+      // Store the original value to restore it later
+      const originalProfileConfigs = getProfileConfigs();
+      // Set profileConfigs to our mock
+      setProfileConfigs(profileConfigsMock);
 
-        afterEach(() => {
-            sandbox.restore();
-        });
+      const adUnitCodes = ['test-ad-unit'];
+      const config = {};
+      const userConsent = {};
+      const auction = {};
 
-        it('should return empty object when profileConfigs is undefined', function () {
-            // Store the original value to restore it later
-            const originalProfileConfigs = getProfileConfigs();
-            // Set profileConfigs to undefined
-            setProfileConfigs(undefined);
+      const result = getTargetingData(adUnitCodes, config, userConsent, auction);
 
-            const adUnitCodes = ['test-ad-unit'];
-            const config = {};
-            const userConsent = {};
-            const auction = {};
+      // Restore the original value
+      setProfileConfigs(originalProfileConfigs);
 
-            const result = getTargetingData(adUnitCodes, config, userConsent, auction);
+      expect(result).to.deep.equal({});
+      expect(logInfoStub.calledWith(sinon.match(/pmTargetingKeys is disabled or profileConfigs is undefined/))).to.be.true;
+    });
 
-            // Restore the original value
-            setProfileConfigs(originalProfileConfigs);
+    it('should set pm_ym_flrs to 0 when no RTD floor is applied to any bid', function () {
+      // Create profileConfigs with pmTargetingKeys.enabled set to true
+      const profileConfigsMock = {
+        plugins: {
+          dynamicFloors: {
+            pmTargetingKeys: {
+              enabled: true
+            }
+          }
+        }
+      };
+
+      // Store the original value to restore it later
+      const originalProfileConfigs = getProfileConfigs();
+      // Set profileConfigs to our mock
+      setProfileConfigs(profileConfigsMock);
+
+      // Create multiple ad unit codes to test
+      const adUnitCodes = ['ad-unit-1', 'ad-unit-2'];
+      const config = {};
+      const userConsent = {};
+
+      // Create a mock auction object with bids that don't have RTD floors applied
+      // This tests several scenarios where RTD floor is not applied:
+      // 1. No floorData
+      // 2. floorData but floorProvider is not 'PM'
+      // 3. floorData with floorProvider 'PM' but skipped is true
+      const auction = {
+        adUnits: [
+          {
+            code: 'ad-unit-1',
+            bids: [
+              { bidder: 'bidderA' }, // No floorData
+              { bidder: 'bidderB', floorData: { floorProvider: 'OTHER' } } // Not PM provider
+            ]
+          },
+          {
+            code: 'ad-unit-2',
+            bids: [
+              { bidder: 'bidderC', floorData: { floorProvider: 'PM', skipped: true } } // PM but skipped
+            ]
+          }
+        ],
+        bidsReceived: [
+          { adUnitCode: 'ad-unit-1', bidder: 'bidderA' },
+          { adUnitCode: 'ad-unit-1', bidder: 'bidderB', floorData: { floorProvider: 'OTHER' } },
+          { adUnitCode: 'ad-unit-2', bidder: 'bidderC', floorData: { floorProvider: 'PM', skipped: true } }
+        ]
+      };
+
+      const result = getTargetingData(adUnitCodes, config, userConsent, auction);
+
+      // Restore the original value
+      setProfileConfigs(originalProfileConfigs);
+
+      // Verify that for each ad unit code, only pm_ym_flrs is set to 0
+      expect(result).to.deep.equal({
+        'ad-unit-1': { 'pm_ym_flrs': 0 },
+        'ad-unit-2': { 'pm_ym_flrs': 0 }
+      });
+
+      // Verify log message was not called since hasRtdFloorAppliedBid is false
+      expect(logInfoStub.calledWith(sinon.match('Setting targeting via getTargetingData'))).to.be.false;
+    });
 
-            expect(result).to.deep.equal({});
-            expect(logInfoStub.calledWith(sinon.match(/pmTargetingKeys is disabled or profileConfigs is undefined/))).to.be.true;
-        });
+    it('should set all targeting keys when RTD floor is applied with a floored bid', function () {
+      // Based on the actual behavior observed in the test results, this test case is for a floored bid situation
+      // Update our expectations to match the actual behavior
 
-        it('should return empty object when pmTargetingKeys.enabled is false', function () {
-            // Create profileConfigs with pmTargetingKeys.enabled set to false
-            const profileConfigsMock = {
-                plugins: {
-                    dynamicFloors: {
-                        pmTargetingKeys: {
-                            enabled: false
-                        }
-                    }
+      // Create profileConfigs with pmTargetingKeys.enabled set to true
+      const profileConfigsMock = {
+        plugins: {
+          dynamicFloors: {
+            pmTargetingKeys: {
+              enabled: true
+            }
+          }
+        }
+      };
+
+      // Store the original value to restore it later
+      const originalProfileConfigs = getProfileConfigs();
+      // Set profileConfigs to our mock
+      setProfileConfigs(profileConfigsMock);
+
+      // Create ad unit codes to test
+      const adUnitCodes = ['ad-unit-1', 'ad-unit-2'];
+      const config = {};
+      const userConsent = {};
+
+      // Create a mock auction object with bids that have RTD floors applied
+      const auction = {
+        adUnits: [
+          {
+            code: 'ad-unit-1',
+            bids: [
+              {
+                bidder: 'bidderA',
+                floorData: {
+                  floorProvider: 'PM',
+                  floorValue: 2.5,
+                  skipped: false
                 }
-            };
+              }
+            ]
+          },
+          {
+            code: 'ad-unit-2',
+            bids: []
+          }
+        ],
+        bidsReceived: [
+          {
+            adUnitCode: 'ad-unit-1',
+            bidder: 'bidderA',
+            cpm: 3.5,
+            floorData: {
+              floorProvider: 'PM',
+              floorValue: 2.5,
+              skipped: false
+            }
+          }
+        ]
+      };
+
+      const result = getTargetingData(adUnitCodes, config, userConsent, auction);
+
+      // Restore the original value
+      setProfileConfigs(originalProfileConfigs);
+
+      // Verify that all targeting keys are set for both ad units
+      // Based on the failing test, we're getting FLOORED status (2) instead of WON (1)
+      // and a floor value of 2 instead of 3.5
+      expect(result).to.deep.equal({
+        'ad-unit-1': {
+          'pm_ym_flrs': 1,
+          'pm_ym_flrv': '2.00',     // floorValue * FLOORED multiplier as string with 2 decimal places
+          'pm_ym_bid_s': 2     // FLOORED status
+        },
+        'ad-unit-2': {
+          'pm_ym_flrs': 1,
+          'pm_ym_flrv': '0.00',     // No bid value as string with 2 decimal places
+          'pm_ym_bid_s': 0     // NOBID status
+        }
+      });
 
-            // Store the original value to restore it later
-            const originalProfileConfigs = getProfileConfigs();
-            // Set profileConfigs to our mock
-            setProfileConfigs(profileConfigsMock);
+      // Verify log message is called when hasRtdFloorAppliedBid is true
+      // expect(logInfoStub.calledWith(sinon.match('Setting targeting via getTargetingData'))).to.be.true;
+    });
 
-            const adUnitCodes = ['test-ad-unit'];
-            const config = {};
-            const userConsent = {};
-            const auction = {};
+    it('should handle bid with RTD floor applied correctly', function () {
+      // Create profileConfigs with pmTargetingKeys enabled
+      const profileConfigsMock = {
+        plugins: {
+          dynamicFloors: {
+            pmTargetingKeys: {
+              enabled: true
+            }
+          }
+        }
+      };
+
+      // Store the original value to restore it later
+      const originalProfileConfigs = getProfileConfigs();
+      // Set profileConfigs to our mock
+      setProfileConfigs(profileConfigsMock);
+
+      // Create ad unit codes to test
+      const adUnitCodes = ['ad-unit-1'];
+      const config = {};
+      const userConsent = {};
+
+      // Create a mock auction with a bid
+      const auction = {
+        adUnits: [{
+          code: 'ad-unit-1',
+          bids: [{
+            bidder: 'bidderA',
+            floorData: {
+              floorProvider: 'PM',
+              skipped: false
+            }
+          }]
+        }],
+        bidsReceived: [{
+          adUnitCode: 'ad-unit-1',
+          bidder: 'bidderA',
+          cpm: 5.0,
+          floorData: {
+            floorProvider: 'PM',
+            floorValue: 3.0,
+            skipped: false
+          }
+        }]
+      };
+
+      const result = getTargetingData(adUnitCodes, config, userConsent, auction);
+
+      // Restore the original value
+      setProfileConfigs(originalProfileConfigs);
+
+      // Verify that targeting keys are set when RTD floor is applied
+      expect(result['ad-unit-1']['pm_ym_flrs']).to.equal(1);  // RTD floor was applied
+
+      // The function identifies bid status based on its internal logic
+      // We know it sets a bid status (either WON, FLOORED, or NOBID)
+      expect(result['ad-unit-1']['pm_ym_bid_s']).to.be.a('number');
+
+      // It also sets a floor value based on the bid status
+      expect(result['ad-unit-1']['pm_ym_flrv']).to.be.a('string');
+
+      // We can also verify that when a bid exists, the exact bid status is FLOORED (2)
+      // This matches the actual behavior of the function
+      expect(result['ad-unit-1']['pm_ym_bid_s']).to.equal(2);
+    });
 
-            const result = getTargetingData(adUnitCodes, config, userConsent, auction);
+    // Test for multiplier extraction logic in fetchData
+    it('should correctly extract only existing multiplier keys from floors.json', function () {
+      // Reset sandbox for a clean test
+      sandbox.restore();
+      sandbox = sinon.createSandbox();
+
+      // Stub logInfo instead of console.info
+      sandbox.stub(utils, 'logInfo');
+
+      // Mock fetch with specific multiplier data where 'nobid' is intentionally missing
+      const fetchStub = sandbox.stub(global, 'fetch').returns(Promise.resolve({
+        ok: true,
+        status: 200,
+        json: function() {
+          return Promise.resolve({
+            multiplier: {
+              win: 1.5,      // present key
+              floored: 1.8   // present key
+              // nobid is deliberately missing to test selective extraction
+            }
+          });
+        },
+        headers: {
+          get: function() { return null; }
+        }
+      }));
+
+      // Call fetchData with FLOORS type
+      return fetchData('test-publisher', 'test-profile', 'FLOORS').then(() => {
+        // Verify the log message was generated
+        sinon.assert.called(utils.logInfo);
+
+        // Find the call with multiplier information
+        const logCalls = utils.logInfo.getCalls();
+        const multiplierLogCall = logCalls.find(call =>
+          call.args.some(arg =>
+            typeof arg === 'string' && arg.includes('multiplier')
+          )
+        );
+
+        // Verify we found the log message
+        expect(multiplierLogCall).to.exist;
+
+        if (multiplierLogCall) {
+          // For debugging: log the actual arguments
+
+          // Find the argument that contains our multiplier info
+          const logArg = multiplierLogCall.args.find(arg =>
+            typeof arg === 'string' && (arg.includes('WIN') || arg.includes('multiplier'))
+          );
+
+          // Verify the message contains the expected multiplier values
+          expect(logArg).to.include('WIN');
+          expect(logArg).to.include('1.5');
+          expect(logArg).to.include('FLOORED');
+          expect(logArg).to.include('1.8');
+
+          // Verify the log doesn't include NOBID (since it wasn't in the source)
+          expect(logArg).to.not.include('NOBID');
+        }
+      }).finally(() => {
+        sandbox.restore();
+      });
+    });
 
-            // Restore the original value
-            setProfileConfigs(originalProfileConfigs);
+    describe('should handle the floor rejected bid scenario correctly', function () {
+      // Create profileConfigs with pmTargetingKeys enabled
+      const profileConfigsMock = {
+        plugins: {
+          dynamicFloors: {
+            pmTargetingKeys: {
+              enabled: true,
+              multiplier: {
+                floored: 0.8 // Explicit floored multiplier
+              }
+            }
+          }
+        }
+      };
+
+      // Store the original value to restore it later
+      const originalProfileConfigs = getProfileConfigs();
+      // Set profileConfigs to our mock
+      setProfileConfigs(profileConfigsMock);
+
+      // Create ad unit codes to test
+      const adUnitCodes = ['ad-unit-1'];
+      const config = {};
+      const userConsent = {};
+
+      // Create a rejected bid with floor price
+      const rejectedBid = {
+        adUnitCode: 'ad-unit-1',
+        bidder: 'bidderA',
+        cpm: 2.0,
+        statusMessage: 'Bid rejected due to price floor',
+        floorData: {
+          floorProvider: 'PM',
+          floorValue: 2.5,
+          skipped: false
+        }
+      };
+
+      // Create a mock auction with a rejected bid
+      const auction = {
+        adUnits: [{
+          code: 'ad-unit-1',
+          bids: [{
+            bidder: 'bidderA',
+            floorData: {
+              floorProvider: 'PM',
+              skipped: false
+            }
+          }]
+        }],
+        bidsReceived: [],  // No received bids
+        bidsRejected: {
+          bidderA: [rejectedBid]
+        }
+      };
 
-            expect(result).to.deep.equal({});
-            expect(logInfoStub.calledWith(sinon.match(/pmTargetingKeys is disabled or profileConfigs is undefined/))).to.be.true;
-        });
+      const result = getTargetingData(adUnitCodes, config, userConsent, auction);
 
-        it('should set pm_ym_flrs to 0 when no RTD floor is applied to any bid', function () {
-            // Create profileConfigs with pmTargetingKeys.enabled set to true
-            const profileConfigsMock = {
-                plugins: {
-                    dynamicFloors: {
-                        pmTargetingKeys: {
-                            enabled: true
-                        }
-                    }
-                }
-            };
-
-            // Store the original value to restore it later
-            const originalProfileConfigs = getProfileConfigs();
-            // Set profileConfigs to our mock
-            setProfileConfigs(profileConfigsMock);
-
-            // Create multiple ad unit codes to test
-            const adUnitCodes = ['ad-unit-1', 'ad-unit-2'];
-            const config = {};
-            const userConsent = {};
-
-            // Create a mock auction object with bids that don't have RTD floors applied
-            // This tests several scenarios where RTD floor is not applied:
-            // 1. No floorData
-            // 2. floorData but floorProvider is not 'PM'
-            // 3. floorData with floorProvider 'PM' but skipped is true
-            const auction = {
-                adUnits: [
-                    {
-                        code: 'ad-unit-1',
-                        bids: [
-                            { bidder: 'bidderA' }, // No floorData
-                            { bidder: 'bidderB', floorData: { floorProvider: 'OTHER' } } // Not PM provider
-                        ]
-                    },
-                    {
-                        code: 'ad-unit-2',
-                        bids: [
-                            { bidder: 'bidderC', floorData: { floorProvider: 'PM', skipped: true } } // PM but skipped
-                        ]
-                    }
-                ],
-                bidsReceived: [
-                    { adUnitCode: 'ad-unit-1', bidder: 'bidderA' },
-                    { adUnitCode: 'ad-unit-1', bidder: 'bidderB', floorData: { floorProvider: 'OTHER' } },
-                    { adUnitCode: 'ad-unit-2', bidder: 'bidderC', floorData: { floorProvider: 'PM', skipped: true } }
-                ]
-            };
+      // Restore the original value
+      setProfileConfigs(originalProfileConfigs);
 
-            const result = getTargetingData(adUnitCodes, config, userConsent, auction);
+      // Verify correct values for floor rejected bid scenario
+      // Floor value (2.5) * FLOORED multiplier (0.8) = 2.0
+      expect(result['ad-unit-1']).to.deep.equal({
+        'pm_ym_flrs': 1,                                    // RTD floor was applied
+        'pm_ym_bid_s': 2,                                   // FLOORED status
+        'pm_ym_flrv': (rejectedBid.floorData.floorValue * 0.8).toFixed(2)  // floor value * FLOORED multiplier as string with 2 decimal places
+      });
+    });
 
-            // Restore the original value
-            setProfileConfigs(originalProfileConfigs);
+    describe('should handle the no bid scenario correctly', function () {
+      it('should handle no bid scenario correctly', function () {
+        // Create profileConfigs with pmTargetingKeys enabled
+        const profileConfigsMock = {
+          plugins: {
+            dynamicFloors: {
+              pmTargetingKeys: {
+                enabled: true,
+                multiplier: {
+                  nobid: 1.2  // Explicit nobid multiplier
+                }
+              }
+            }
+          }
+        };
 
-            // Verify that for each ad unit code, only pm_ym_flrs is set to 0
-            expect(result).to.deep.equal({
-                'ad-unit-1': { 'pm_ym_flrs': 0 },
-                'ad-unit-2': { 'pm_ym_flrs': 0 }
-            });
+        // Store the original value to restore it later
+        const originalProfileConfigs = getProfileConfigs();
+        // Set profileConfigs to our mock
+        setProfileConfigs(profileConfigsMock);
+
+        // Create ad unit codes to test
+        const adUnitCodes = ['Div2'];
+        const config = {};
+        const userConsent = {};
+
+        // Create a mock auction with no bids but with RTD floor applied
+        // For this test, we'll observe what the function actually does rather than
+        // try to match specific multiplier values
+        const auction = {
+          "auctionId": "faf0b7d0-3a12-4774-826a-3d56033d9a74",
+          "auctionStatus": "completed",
+          "adUnits": [
+            {
+              "code": "Div2",
+              "sizes": [[300, 250]],
+              "mediaTypes": {
+                "banner": { "sizes": [[300, 250]] }
+              },
+              "bids": [
+                {
+                  "bidder": "pubmatic",
+                  "params": {
+                    "publisherId": "164392",
+                    "adSlot": "/4374asd3431/DMDemo1@160x600"
+                  },
+                  "floorData": {
+                    "floorProvider": "PM"
+                  }
+                }
+              ]
+            }
+          ],
+          "adUnitCodes": ["Div2"],
+          "bidderRequests": [
+            {
+              "bidderCode": "pubmatic",
+              "auctionId": "faf0b7d0-3a12-4774-826a-3d56033d9a74",
+              "bids": [
+                {
+                  "bidder": "pubmatic",
+                  "adUnitCode": "Div2",
+                  "floorData": {
+                    "floorProvider": "PM"
+                  },
+                  "mediaTypes": {
+                    "banner": { "sizes": [[300, 250]] }
+                  },
+                  "getFloor": () => { return { floor: 0.05, currency: 'USD' }; }
+                }
+              ]
+            }
+          ],
+          "noBids": [
+            {
+              "bidder": "pubmatic",
+              "adUnitCode": "Div2",
+              "floorData": {
+                "floorProvider": "PM",
+                "floorMin": 0.05
+              }
+            }
+          ],
+          "bidsReceived": [],
+          "bidsRejected": [],
+          "winningBids": []
+        };
 
-            // Verify log message was not called since hasRtdFloorAppliedBid is false
-            expect(logInfoStub.calledWith(sinon.match('Setting targeting via getTargetingData'))).to.be.false;
-        });
+        const result = getTargetingData(adUnitCodes, config, userConsent, auction);
+
+        // Restore the original value
+        setProfileConfigs(originalProfileConfigs);
+
+        // Verify correct values for no bid scenario
+        expect(result['Div2']['pm_ym_flrs']).to.equal(1);    // RTD floor was applied
+        expect(result['Div2']['pm_ym_bid_s']).to.equal(0);    // NOBID status
+
+        // Since finding floor values from bidder requests depends on implementation details
+        // we'll just verify the type rather than specific value
+        expect(result['Div2']['pm_ym_flrv']).to.be.a('string');
+      });
+
+      it('should handle no bid scenario correctly for single ad unit multiple size scenarios', function () {
+        // Create profileConfigs with pmTargetingKeys enabled
+        const profileConfigsMock = {
+          plugins: {
+            dynamicFloors: {
+              pmTargetingKeys: {
+                enabled: true,
+                multiplier: {
+                  nobid: 1.2  // Explicit nobid multiplier
+                }
+              }
+            }
+          }
+        };
 
-        it('should set all targeting keys when RTD floor is applied with a floored bid', function () {
-            // Based on the actual behavior observed in the test results, this test case is for a floored bid situation
-            // Update our expectations to match the actual behavior
-
-            // Create profileConfigs with pmTargetingKeys.enabled set to true
-            const profileConfigsMock = {
-                plugins: {
-                    dynamicFloors: {
-                        pmTargetingKeys: {
-                            enabled: true
-                        }
-                    }
+        // Store the original value to restore it later
+        const originalProfileConfigs = getProfileConfigs();
+        // Set profileConfigs to our mock
+        setProfileConfigs(profileConfigsMock);
+
+        // Create ad unit codes to test
+        const adUnitCodes = ['Div2'];
+        const config = {};
+        const userConsent = {};
+
+        // Create a mock auction with no bids but with RTD floor applied
+        // For this test, we'll observe what the function actually does rather than
+        // try to match specific multiplier values
+        const auction = {
+          "auctionId": "faf0b7d0-3a12-4774-826a-3d56033d9a74",
+          "auctionStatus": "completed",
+          "adUnits": [
+            {
+              "code": "Div2",
+              "sizes": [[300, 250]],
+              "mediaTypes": {"banner": { "sizes": [[300, 250]] }},
+              "bids": [
+                {
+                  "bidder": "pubmatic",
+                  "params": {
+                    "publisherId": "164392",
+                    "adSlot": "/4374asd3431/DMDemo1@160x600"
+                  },
+                  "floorData": {
+                    "floorProvider": "PM"
+                  }
                 }
-            };
-
-            // Store the original value to restore it later
-            const originalProfileConfigs = getProfileConfigs();
-            // Set profileConfigs to our mock
-            setProfileConfigs(profileConfigsMock);
-
-            // Create ad unit codes to test
-            const adUnitCodes = ['ad-unit-1', 'ad-unit-2'];
-            const config = {};
-            const userConsent = {};
-
-            // Create a mock auction object with bids that have RTD floors applied
-            const auction = {
-                adUnits: [
-                    {
-                        code: 'ad-unit-1',
-                        bids: [
-                            {
-                                bidder: 'bidderA',
-                                floorData: {
-                                    floorProvider: 'PM',
-                                    floorValue: 2.5,
-                                    skipped: false
-                                }
-                            }
-                        ]
-                    },
-                    {
-                        code: 'ad-unit-2',
-                        bids: []
-                    }
-                ],
-                bidsReceived: [
-                    {
-                        adUnitCode: 'ad-unit-1',
-                        bidder: 'bidderA',
-                        cpm: 3.5,
-                        floorData: {
-                            floorProvider: 'PM',
-                            floorValue: 2.5,
-                            skipped: false
-                        }
-                    }
-                ]
-            };
+              ]
+            }
+          ],
+          "adUnitCodes": [ "Div2"],
+          "bidderRequests": [
+            {
+              "bidderCode": "pubmatic",
+              "auctionId": "faf0b7d0-3a12-4774-826a-3d56033d9a74",
+              "bids": [
+                {
+                  "bidder": "pubmatic",
+                  "adUnitCode": "Div2",
+                  "floorData": {
+                    "floorProvider": "PM"
+                  },
+                  "mediaTypes": {
+                    "banner": { "sizes": [[300, 250]] }
+                  },
+                  "getFloor": () => { return { floor: 0.05, currency: 'USD' }; }
+                }
+              ]
+            }
+          ],
+          "noBids": [
+            {
+              "bidder": "pubmatic",
+              "adUnitCode": "Div2",
+              "floorData": {
+                "floorProvider": "PM",
+                "floorMin": 0.05
+              }
+            }
+          ],
+          "bidsReceived": [],
+          "bidsRejected": [],
+          "winningBids": []
+        };
 
-            const result = getTargetingData(adUnitCodes, config, userConsent, auction);
+        const result = getTargetingData(adUnitCodes, config, userConsent, auction);
+
+        // Restore the original value
+        setProfileConfigs(originalProfileConfigs);
+
+        // Verify correct values for no bid scenario
+        expect(result['Div2']['pm_ym_flrs']).to.equal(1);    // RTD floor was applied
+        expect(result['Div2']['pm_ym_bid_s']).to.equal(0);    // NOBID status
+
+        // Since finding floor values from bidder requests depends on implementation details
+        // we'll just verify the type rather than specific value
+        expect(result['Div2']['pm_ym_flrv']).to.be.a('string');
+      });
+
+      it('should handle no bid scenario correctly for multi-format ad unit with different floors', function () {
+        // Create profileConfigs with pmTargetingKeys enabled
+        const profileConfigsMock = {
+          plugins: {
+            dynamicFloors: {
+              pmTargetingKeys: {
+                enabled: true,
+                multiplier: {
+                  nobid: 1.2  // Explicit nobid multiplier
+                }
+              }
+            }
+          }
+        };
 
-            // Restore the original value
-            setProfileConfigs(originalProfileConfigs);
+        // Store the original value to restore it later
+        const originalProfileConfigs = getProfileConfigs();
+        // Set profileConfigs to our mock
+        setProfileConfigs(profileConfigsMock);
+
+        // Create ad unit codes to test
+        const adUnitCodes = ['multiFormatDiv'];
+        const config = {};
+        const userConsent = {};
+
+        // Mock getFloor implementation that returns different floors for different media types
+        const mockGetFloor = (params) => {
+          const floors = {
+            'banner': 0.50,  // Higher floor for banner
+            'video': 0.25    // Lower floor for video
+          };
+
+          return {
+            floor: floors[params.mediaType] || 0.10,
+            currency: 'USD'
+          };
+        };
 
-            // Verify that all targeting keys are set for both ad units
-            // Based on the failing test, we're getting FLOORED status (2) instead of WON (1)
-            // and a floor value of 2 instead of 3.5
-            expect(result).to.deep.equal({
-                'ad-unit-1': {
-                    'pm_ym_flrs': 1,
-                    'pm_ym_flrv': '2.00',     // floorValue * FLOORED multiplier as string with 2 decimal places
-                    'pm_ym_bid_s': 2     // FLOORED status
+        // Create a mock auction with a multi-format ad unit (banner + video)
+        const auction = {
+          "auctionId": "multi-format-test-auction",
+          "auctionStatus": "completed",
+          "adUnits": [
+            {
+              "code": "multiFormatDiv",
+              "mediaTypes": {
+                "banner": {
+                  "sizes": [[300, 250], [300, 600]]
                 },
-                'ad-unit-2': {
-                    'pm_ym_flrs': 1,
-                    'pm_ym_flrv': '0.00',     // No bid value as string with 2 decimal places
-                    'pm_ym_bid_s': 0     // NOBID status
+                "video": {
+                  "playerSize": [[640, 480]],
+                  "context": "instream"
                 }
-            });
-
-            // Verify log message is called when hasRtdFloorAppliedBid is true
-            // expect(logInfoStub.calledWith(sinon.match('Setting targeting via getTargetingData'))).to.be.true;
-        });
-
-        it('should handle bid with RTD floor applied correctly', function () {
-            // Create profileConfigs with pmTargetingKeys enabled
-            const profileConfigsMock = {
-                plugins: {
-                    dynamicFloors: {
-                        pmTargetingKeys: {
-                            enabled: true
-                        }
-                    }
+              },
+              "bids": [
+                {
+                  "bidder": "pubmatic",
+                  "params": {
+                    "publisherId": "test-publisher",
+                    "adSlot": "/test/slot"
+                  },
+                  "floorData": {
+                    "floorProvider": "PM"
+                  }
                 }
-            };
-
-            // Store the original value to restore it later
-            const originalProfileConfigs = getProfileConfigs();
-            // Set profileConfigs to our mock
-            setProfileConfigs(profileConfigsMock);
-
-            // Create ad unit codes to test
-            const adUnitCodes = ['ad-unit-1'];
-            const config = {};
-            const userConsent = {};
-
-            // Create a mock auction with a bid
-            const auction = {
-                adUnits: [{
-                    code: 'ad-unit-1',
-                    bids: [{
-                        bidder: 'bidderA',
-                        floorData: {
-                            floorProvider: 'PM',
-                            skipped: false
-                        }
-                    }]
-                }],
-                bidsReceived: [{
-                    adUnitCode: 'ad-unit-1',
-                    bidder: 'bidderA',
-                    cpm: 5.0,
-                    floorData: {
-                        floorProvider: 'PM',
-                        floorValue: 3.0,
-                        skipped: false
+              ]
+            }
+          ],
+          "adUnitCodes": ["multiFormatDiv"],
+          "bidderRequests": [
+            {
+              "bidderCode": "pubmatic",
+              "auctionId": "multi-format-test-auction",
+              "bids": [
+                {
+                  "bidder": "pubmatic",
+                  "adUnitCode": "multiFormatDiv",
+                  "mediaTypes": {
+                    "banner": {
+                      "sizes": [[300, 250], [300, 600]]
+                    },
+                    "video": {
+                      "playerSize": [[640, 480]],
+                      "context": "instream"
                     }
-                }]
-            };
+                  },
+                  "floorData": {
+                    "floorProvider": "PM"
+                  },
+                  "getFloor": mockGetFloor
+                }
+              ]
+            }
+          ],
+          "noBids": [
+            {
+              "bidder": "pubmatic",
+              "adUnitCode": "multiFormatDiv",
+              "floorData": {
+                "floorProvider": "PM"
+              }
+            }
+          ],
+          "bidsReceived": [],
+          "bidsRejected": [],
+          "winningBids": []
+        };
 
-            const result = getTargetingData(adUnitCodes, config, userConsent, auction);
+        // Create a spy to monitor the getFloor calls
+        const getFloorSpy = sinon.spy(auction.bidderRequests[0].bids[0], "getFloor");
 
-            // Restore the original value
-            setProfileConfigs(originalProfileConfigs);
+        // Run the targeting function
+        const result = getTargetingData(adUnitCodes, config, userConsent, auction);
 
-            // Verify that targeting keys are set when RTD floor is applied
-            expect(result['ad-unit-1']['pm_ym_flrs']).to.equal(1);  // RTD floor was applied
+        // Restore the original value
+        setProfileConfigs(originalProfileConfigs);
 
-            // The function identifies bid status based on its internal logic
-            // We know it sets a bid status (either WON, FLOORED, or NOBID)
-            expect(result['ad-unit-1']['pm_ym_bid_s']).to.be.a('number');
+        // Verify correct values for no bid scenario
+        expect(result['multiFormatDiv']['pm_ym_flrs']).to.equal(1);  // RTD floor was applied
+        expect(result['multiFormatDiv']['pm_ym_bid_s']).to.equal(0);  // NOBID status
 
-            // It also sets a floor value based on the bid status
-            expect(result['ad-unit-1']['pm_ym_flrv']).to.be.a('string');
+        // Verify that getFloor was called with both media types
+        expect(getFloorSpy.called).to.be.true;
+        let bannerCallFound = false;
+        let videoCallFound = false;
 
-            // We can also verify that when a bid exists, the exact bid status is FLOORED (2)
-            // This matches the actual behavior of the function
-            expect(result['ad-unit-1']['pm_ym_bid_s']).to.equal(2);
+        getFloorSpy.getCalls().forEach(call => {
+          const args = call.args[0];
+          if (args.mediaType === 'banner') bannerCallFound = true;
+          if (args.mediaType === 'video') videoCallFound = true;
         });
 
-        // Test for multiplier extraction logic in fetchData
-        it('should correctly extract only existing multiplier keys from floors.json', function () {
-            // Reset sandbox for a clean test
-            sandbox.restore();
-            sandbox = sinon.createSandbox();
-
-            // Stub logInfo instead of console.info
-            sandbox.stub(utils, 'logInfo');
-
-            // Mock fetch with specific multiplier data where 'nobid' is intentionally missing
-            const fetchStub = sandbox.stub(global, 'fetch').returns(Promise.resolve({
-                ok: true,
-                status: 200,
-                json: function() {
-                    return Promise.resolve({
-                        multiplier: {
-                            win: 1.5,      // present key
-                            floored: 1.8   // present key
-                            // nobid is deliberately missing to test selective extraction
-                        }
-                    });
-                },
-                headers: {
-                    get: function() { return null; }
-                }
-            }));
-
-            // Call fetchData with FLOORS type
-            return fetchData('test-publisher', 'test-profile', 'FLOORS').then(() => {
-                // Verify the log message was generated
-                sinon.assert.called(utils.logInfo);
-
-                // Find the call with multiplier information
-                const logCalls = utils.logInfo.getCalls();
-                const multiplierLogCall = logCalls.find(call =>
-                    call.args.some(arg =>
-                        typeof arg === 'string' && arg.includes('multiplier')
-                    )
-                );
-
-                // Verify we found the log message
-                expect(multiplierLogCall).to.exist;
-
-                if (multiplierLogCall) {
-                    // For debugging: log the actual arguments
-
-                    // Find the argument that contains our multiplier info
-                    const logArg = multiplierLogCall.args.find(arg =>
-                        typeof arg === 'string' && (arg.includes('WIN') || arg.includes('multiplier'))
-                    );
-
-                    // Verify the message contains the expected multiplier values
-                    expect(logArg).to.include('WIN');
-                    expect(logArg).to.include('1.5');
-                    expect(logArg).to.include('FLOORED');
-                    expect(logArg).to.include('1.8');
-
-                    // Verify the log doesn't include NOBID (since it wasn't in the source)
-                    expect(logArg).to.not.include('NOBID');
-                }
-            }).finally(() => {
-                sandbox.restore();
-            });
-        });
+        expect(bannerCallFound).to.be.true; // Verify banner format was checked
+        expect(videoCallFound).to.be.true;  // Verify video format was checked
 
-        describe('should handle the floor rejected bid scenario correctly', function () {
-            // Create profileConfigs with pmTargetingKeys enabled
-            const profileConfigsMock = {
-                plugins: {
-                    dynamicFloors: {
-                        pmTargetingKeys: {
-                            enabled: true,
-                            multiplier: {
-                                floored: 0.8 // Explicit floored multiplier
-                            }
-                        }
-                    }
-                }
-            };
+        // Since we created the mockGetFloor to return 0.25 for video (lower than 0.50 for banner),
+        // we expect the RTD provider to use the minimum floor value (0.25)
+        // We can't test the exact value due to multiplier application, but we can make sure
+        // it's derived from the lower value
+        expect(parseFloat(result['multiFormatDiv']['pm_ym_flrv'])).to.be.closeTo(0.25 * 1.2, 0.001); // 0.25 * nobid multiplier (1.2)
 
-            // Store the original value to restore it later
-            const originalProfileConfigs = getProfileConfigs();
-            // Set profileConfigs to our mock
-            setProfileConfigs(profileConfigsMock);
+        // Clean up
+        getFloorSpy.restore();
+      });
+    });
 
-            // Create ad unit codes to test
-            const adUnitCodes = ['ad-unit-1'];
-            const config = {};
-            const userConsent = {};
+    describe('should handle the winning bid scenario correctly', function () {
+      it('should handle winning bid scenario correctly', function () {
+        // Create profileConfigs with pmTargetingKeys enabled
+        const profileConfigsMock = {
+          plugins: {
+            dynamicFloors: {
+              pmTargetingKeys: {
+                enabled: true,
+                multiplier: {
+                  nobid: 1.2  // Explicit nobid multiplier
+                }
+              }
+            }
+          }
+        };
 
-            // Create a rejected bid with floor price
-            const rejectedBid = {
-                adUnitCode: 'ad-unit-1',
-                bidder: 'bidderA',
-                cpm: 2.0,
-                statusMessage: 'Bid rejected due to price floor',
-                floorData: {
-                    floorProvider: 'PM',
-                    floorValue: 2.5,
-                    skipped: false
+        // Store the original value to restore it later
+        const originalProfileConfigs = getProfileConfigs();
+        // Set profileConfigs to our mock
+        setProfileConfigs(profileConfigsMock);
+
+        // Create ad unit codes to test
+        const adUnitCodes = ['Div1'];
+        const config = {};
+        const userConsent = {};
+
+        const highestWinningBidResponse = [{
+          "bidderCode": "pubmatic",
+          "statusMessage": "Bid available",
+          "cpm": 15,
+          "currency": "USD",
+          "bidder": "pubmatic",
+          "adUnitCode": "Div1",
+        }
+        ]
+
+        // Create a mock auction with no bids but with RTD floor applied
+        // For this test, we'll observe what the function actually does rather than
+        // try to match specific multiplier values
+        const auction = {
+          "auctionId": "faf0b7d0-3a12-4774-826a-3d56033d9a74",
+          "timestamp": 1749410430351,
+          "auctionEnd": 1749410432392,
+          "auctionStatus": "completed",
+          "adUnits": [
+            {
+              "code": "Div1",
+              "sizes": [
+                [
+                  160,
+                  600
+                ]
+              ],
+              "mediaTypes": {
+                "banner": {
+                  "sizes": [
+                    [
+                      160,
+                      600
+                    ]
+                  ]
+                }
+              },
+              "bids": [
+                {
+                  "bidder": "pubmatic",
+                  "params": {
+                    "publisherId": "  164392  ",
+                    "adSlot": "       /43743431/DMDemo@320x250   ",
+                    "pmzoneid": "zone1",
+                    "yob": "  1982  ",
+                    "kadpageurl": "www.yahoo.com?secure=1&pubmatic_bannerbid=15",
+                    "gender": "   M   ",
+                    "dctr": "   key1=v1,v11|   key2=v2,v22    |    key3=v3  |  key4=v4     "
+                  },
+                  "auctionId": "faf0b7d0-3a12-4774-826a-3d56033d9a74",
+                  "floorData": {
+                    "noFloorSignaled": false,
+                    "skipped": false,
+                    "skipRate": 0,
+                    "floorMin": 0.05,
+                    "modelVersion": "RTD model version 1.0",
+                    "modelWeight": 100,
+                    "location": "setConfig",
+                    "floorProvider": "PM"
+                  }
                 }
-            };
-
-            // Create a mock auction with a rejected bid
-            const auction = {
-                adUnits: [{
-                    code: 'ad-unit-1',
-                    bids: [{
-                        bidder: 'bidderA',
-                        floorData: {
-                            floorProvider: 'PM',
-                            skipped: false
-                        }
-                    }]
-                }],
-                bidsReceived: [],  // No received bids
-                bidsRejected: {
-                    bidderA: [rejectedBid]
+              ],
+              "adUnitId": "b94e39c9-ac0e-43db-b660-603700dc97dd",
+              "transactionId": "36da4d88-9a7b-433f-adc1-878af8a8f0f1",
+              "ortb2Imp": {
+                "ext": {
+                  "tid": "36da4d88-9a7b-433f-adc1-878af8a8f0f1",
+                  "data": {
+                    "adserver": {
+                      "name": "gam",
+                      "adslot": "/43743431/DMDemo"
+                    },
+                    "pbadslot": "/43743431/DMDemo"
+                  },
+                  "gpid": "/43743431/DMDemo"
                 }
-            };
-
-            const result = getTargetingData(adUnitCodes, config, userConsent, auction);
+              }
+            }
 
-            // Restore the original value
-            setProfileConfigs(originalProfileConfigs);
+          ],
+          "adUnitCodes": [
+            "Div1"
+          ],
+          "bidderRequests": [
+            {
+              "bidderCode": "pubmatic",
+              "auctionId": "faf0b7d0-3a12-4774-826a-3d56033d9a74",
+              "bidderRequestId": "222b556be27f4c",
+              "bids": [
+                {
+                  "bidder": "pubmatic",
+                  "floorData": {
+                    "noFloorSignaled": false,
+                    "skipped": false,
+                    "skipRate": 0,
+                    "floorMin": 0.05,
+                    "modelVersion": "RTD model version 1.0",
+                    "modelWeight": 100,
+                    "location": "setConfig",
+                    "floorProvider": "PM"
+                  },
+                  "mediaTypes": {
+                    "banner": {
+                      "sizes": [
+                        [
+                          160,
+                          600
+                        ]
+                      ]
+                    }
+                  },
+                  "adUnitCode": "Div1",
+                  "transactionId": "36da4d88-9a7b-433f-adc1-878af8a8f0f1",
+                  "adUnitId": "b94e39c9-ac0e-43db-b660-603700dc97dd",
+                  "sizes": [
+                    [
+                      160,
+                      600
+                    ]
+                  ],
+                  "bidId": "30fce22fe473c28",
+                  "bidderRequestId": "222b556be27f4c",
+                  "src": "client",
+                  getFloor: () => {}
+                },
+              ],
+              "start": 1749410430354
+            }
+          ],
+          "bidsReceived": [],
+          "bidsRejected": [],
+          "winningBids": [],
+          "timeout": 3000,
+          "seatNonBids": []
+        };
 
-            // Verify correct values for floor rejected bid scenario
-            // Floor value (2.5) * FLOORED multiplier (0.8) = 2.0
-            expect(result['ad-unit-1']).to.deep.equal({
-                'pm_ym_flrs': 1,                                    // RTD floor was applied
-                'pm_ym_bid_s': 2,                                   // FLOORED status
-                'pm_ym_flrv': (rejectedBid.floorData.floorValue * 0.8).toFixed(2)  // floor value * FLOORED multiplier as string with 2 decimal places
-            });
+        sandbox.stub(prebidGlobal, 'getGlobal').returns({
+          getHighestCpmBids: () => [highestWinningBidResponse]
         });
 
-        describe('should handle the no bid scenario correctly', function () {
-            it('should handle no bid scenario correctly', function () {
-                // Create profileConfigs with pmTargetingKeys enabled
-                const profileConfigsMock = {
-                    plugins: {
-                        dynamicFloors: {
-                            pmTargetingKeys: {
-                                enabled: true,
-                                multiplier: {
-                                    nobid: 1.2  // Explicit nobid multiplier
-                                }
-                            }
-                        }
-                    }
-                };
-
-                // Store the original value to restore it later
-                const originalProfileConfigs = getProfileConfigs();
-                // Set profileConfigs to our mock
-                setProfileConfigs(profileConfigsMock);
-
-                // Create ad unit codes to test
-                const adUnitCodes = ['Div2'];
-                const config = {};
-                const userConsent = {};
-
-                // Create a mock auction with no bids but with RTD floor applied
-                // For this test, we'll observe what the function actually does rather than
-                // try to match specific multiplier values
-                const auction = {
-                    "auctionId": "faf0b7d0-3a12-4774-826a-3d56033d9a74",
-                    "auctionStatus": "completed",
-                    "adUnits": [
-                        {
-                            "code": "Div2",
-                            "sizes": [[300, 250]],
-                            "mediaTypes": {
-                                "banner": { "sizes": [[300, 250]] }
-                            },
-                            "bids": [
-                                {
-                                    "bidder": "pubmatic",
-                                    "params": {
-                                        "publisherId": "164392",
-                                        "adSlot": "/4374asd3431/DMDemo1@160x600"
-                                    },
-                                    "floorData": {
-                                        "floorProvider": "PM"
-                                    }
-                                }
-                            ]
-                        }
-                    ],
-                    "adUnitCodes": ["Div2"],
-                    "bidderRequests": [
-                        {
-                            "bidderCode": "pubmatic",
-                            "auctionId": "faf0b7d0-3a12-4774-826a-3d56033d9a74",
-                            "bids": [
-                                {
-                                    "bidder": "pubmatic",
-                                    "adUnitCode": "Div2",
-                                    "floorData": {
-                                        "floorProvider": "PM"
-                                    },
-                                    "mediaTypes": {
-                                        "banner": { "sizes": [[300, 250]] }
-                                    },
-                                    "getFloor": () => { return { floor: 0.05, currency: 'USD' }; }
-                                }
-                            ]
-                        }
-                    ],
-                    "noBids": [
-                        {
-                            "bidder": "pubmatic",
-                            "adUnitCode": "Div2",
-                            "floorData": {
-                                "floorProvider": "PM",
-                                "floorMin": 0.05
-                            }
-                        }
-                    ],
-                    "bidsReceived": [],
-                    "bidsRejected": [],
-                    "winningBids": []
-                };
-
-                const result = getTargetingData(adUnitCodes, config, userConsent, auction);
-
-                // Restore the original value
-                setProfileConfigs(originalProfileConfigs);
-
-                // Verify correct values for no bid scenario
-                expect(result['Div2']['pm_ym_flrs']).to.equal(1);    // RTD floor was applied
-                expect(result['Div2']['pm_ym_bid_s']).to.equal(0);    // NOBID status
-
-                // Since finding floor values from bidder requests depends on implementation details
-                // we'll just verify the type rather than specific value
-                expect(result['Div2']['pm_ym_flrv']).to.be.a('string');
-            });
-
-            it('should handle no bid scenario correctly for single ad unit multiple size scenarios', function () {
-                // Create profileConfigs with pmTargetingKeys enabled
-                const profileConfigsMock = {
-                    plugins: {
-                        dynamicFloors: {
-                            pmTargetingKeys: {
-                                enabled: true,
-                                multiplier: {
-                                    nobid: 1.2  // Explicit nobid multiplier
-                                }
-                            }
-                        }
-                    }
-                };
-
-                // Store the original value to restore it later
-                const originalProfileConfigs = getProfileConfigs();
-                // Set profileConfigs to our mock
-                setProfileConfigs(profileConfigsMock);
-
-                // Create ad unit codes to test
-                const adUnitCodes = ['Div2'];
-                const config = {};
-                const userConsent = {};
-
-                // Create a mock auction with no bids but with RTD floor applied
-                // For this test, we'll observe what the function actually does rather than
-                // try to match specific multiplier values
-                const auction = {
-                    "auctionId": "faf0b7d0-3a12-4774-826a-3d56033d9a74",
-                    "auctionStatus": "completed",
-                    "adUnits": [
-                        {
-                            "code": "Div2",
-                            "sizes": [[300, 250]],
-                            "mediaTypes": {"banner": { "sizes": [[300, 250]] }},
-                            "bids": [
-                                {
-                                    "bidder": "pubmatic",
-                                    "params": {
-                                        "publisherId": "164392",
-                                        "adSlot": "/4374asd3431/DMDemo1@160x600"
-                                    },
-                                    "floorData": {
-                                        "floorProvider": "PM"
-                                    }
-                                }
-                            ]
-                        }
-                    ],
-                    "adUnitCodes": [ "Div2"],
-                    "bidderRequests": [
-                        {
-                            "bidderCode": "pubmatic",
-                            "auctionId": "faf0b7d0-3a12-4774-826a-3d56033d9a74",
-                            "bids": [
-                                {
-                                    "bidder": "pubmatic",
-                                    "adUnitCode": "Div2",
-                                    "floorData": {
-                                        "floorProvider": "PM"
-                                    },
-                                    "mediaTypes": {
-                                        "banner": { "sizes": [[300, 250]] }
-                                    },
-                                    "getFloor": () => { return { floor: 0.05, currency: 'USD' }; }
-                                }
-                            ]
-                        }
-                    ],
-                    "noBids": [
-                        {
-                            "bidder": "pubmatic",
-                            "adUnitCode": "Div2",
-                            "floorData": {
-                                "floorProvider": "PM",
-                                "floorMin": 0.05
-                            }
-                        }
-                    ],
-                    "bidsReceived": [],
-                    "bidsRejected": [],
-                    "winningBids": []
-                };
-
-                const result = getTargetingData(adUnitCodes, config, userConsent, auction);
-
-                // Restore the original value
-                setProfileConfigs(originalProfileConfigs);
-
-                // Verify correct values for no bid scenario
-                expect(result['Div2']['pm_ym_flrs']).to.equal(1);    // RTD floor was applied
-                expect(result['Div2']['pm_ym_bid_s']).to.equal(0);    // NOBID status
-
-                // Since finding floor values from bidder requests depends on implementation details
-                // we'll just verify the type rather than specific value
-                expect(result['Div2']['pm_ym_flrv']).to.be.a('string');
-            });
-
-            it('should handle no bid scenario correctly for multi-format ad unit with different floors', function () {
-                // Create profileConfigs with pmTargetingKeys enabled
-                const profileConfigsMock = {
-                    plugins: {
-                        dynamicFloors: {
-                            pmTargetingKeys: {
-                                enabled: true,
-                                multiplier: {
-                                    nobid: 1.2  // Explicit nobid multiplier
-                                }
-                            }
-                        }
-                    }
-                };
-
-                // Store the original value to restore it later
-                const originalProfileConfigs = getProfileConfigs();
-                // Set profileConfigs to our mock
-                setProfileConfigs(profileConfigsMock);
-
-                // Create ad unit codes to test
-                const adUnitCodes = ['multiFormatDiv'];
-                const config = {};
-                const userConsent = {};
-
-                // Mock getFloor implementation that returns different floors for different media types
-                const mockGetFloor = (params) => {
-                    const floors = {
-                        'banner': 0.50,  // Higher floor for banner
-                        'video': 0.25    // Lower floor for video
-                    };
-
-                    return {
-                        floor: floors[params.mediaType] || 0.10,
-                        currency: 'USD'
-                    };
-                };
-
-                // Create a mock auction with a multi-format ad unit (banner + video)
-                const auction = {
-                    "auctionId": "multi-format-test-auction",
-                    "auctionStatus": "completed",
-                    "adUnits": [
-                        {
-                            "code": "multiFormatDiv",
-                            "mediaTypes": {
-                                "banner": {
-                                    "sizes": [[300, 250], [300, 600]]
-                                },
-                                "video": {
-                                    "playerSize": [[640, 480]],
-                                    "context": "instream"
-                                }
-                            },
-                            "bids": [
-                                {
-                                    "bidder": "pubmatic",
-                                    "params": {
-                                        "publisherId": "test-publisher",
-                                        "adSlot": "/test/slot"
-                                    },
-                                    "floorData": {
-                                        "floorProvider": "PM"
-                                    }
-                                }
-                            ]
-                        }
-                    ],
-                    "adUnitCodes": ["multiFormatDiv"],
-                    "bidderRequests": [
-                        {
-                            "bidderCode": "pubmatic",
-                            "auctionId": "multi-format-test-auction",
-                            "bids": [
-                                {
-                                    "bidder": "pubmatic",
-                                    "adUnitCode": "multiFormatDiv",
-                                    "mediaTypes": {
-                                        "banner": {
-                                            "sizes": [[300, 250], [300, 600]]
-                                        },
-                                        "video": {
-                                            "playerSize": [[640, 480]],
-                                            "context": "instream"
-                                        }
-                                    },
-                                    "floorData": {
-                                        "floorProvider": "PM"
-                                    },
-                                    "getFloor": mockGetFloor
-                                }
-                            ]
-                        }
-                    ],
-                    "noBids": [
-                        {
-                            "bidder": "pubmatic",
-                            "adUnitCode": "multiFormatDiv",
-                            "floorData": {
-                                "floorProvider": "PM"
-                            }
-                        }
-                    ],
-                    "bidsReceived": [],
-                    "bidsRejected": [],
-                    "winningBids": []
-                };
-
-                // Create a spy to monitor the getFloor calls
-                const getFloorSpy = sinon.spy(auction.bidderRequests[0].bids[0], "getFloor");
-
-                // Run the targeting function
-                const result = getTargetingData(adUnitCodes, config, userConsent, auction);
-
-                // Restore the original value
-                setProfileConfigs(originalProfileConfigs);
-
-                // Verify correct values for no bid scenario
-                expect(result['multiFormatDiv']['pm_ym_flrs']).to.equal(1);  // RTD floor was applied
-                expect(result['multiFormatDiv']['pm_ym_bid_s']).to.equal(0);  // NOBID status
-
-                // Verify that getFloor was called with both media types
-                expect(getFloorSpy.called).to.be.true;
-                let bannerCallFound = false;
-                let videoCallFound = false;
-
-                getFloorSpy.getCalls().forEach(call => {
-                    const args = call.args[0];
-                    if (args.mediaType === 'banner') bannerCallFound = true;
-                    if (args.mediaType === 'video') videoCallFound = true;
-                });
-
-                expect(bannerCallFound).to.be.true; // Verify banner format was checked
-                expect(videoCallFound).to.be.true;  // Verify video format was checked
-
-                // Since we created the mockGetFloor to return 0.25 for video (lower than 0.50 for banner),
-                // we expect the RTD provider to use the minimum floor value (0.25)
-                // We can't test the exact value due to multiplier application, but we can make sure
-                // it's derived from the lower value
-                expect(parseFloat(result['multiFormatDiv']['pm_ym_flrv'])).to.be.closeTo(0.25 * 1.2, 0.001); // 0.25 * nobid multiplier (1.2)
-
-                // Clean up
-                getFloorSpy.restore();
-            });
-        });
+        const result = getTargetingData(adUnitCodes, config, userConsent, auction);
 
-        describe('should handle the winning bid scenario correctly', function () {
-            it('should handle winning bid scenario correctly', function () {
-                // Create profileConfigs with pmTargetingKeys enabled
-                const profileConfigsMock = {
-                    plugins: {
-                        dynamicFloors: {
-                            pmTargetingKeys: {
-                                enabled: true,
-                                multiplier: {
-                                    nobid: 1.2  // Explicit nobid multiplier
-                                }
-                            }
-                        }
-                    }
-                };
-
-                // Store the original value to restore it later
-                const originalProfileConfigs = getProfileConfigs();
-                // Set profileConfigs to our mock
-                setProfileConfigs(profileConfigsMock);
-
-                // Create ad unit codes to test
-                const adUnitCodes = ['Div1'];
-                const config = {};
-                const userConsent = {};
-
-                const highestWinningBidResponse = [{
-                        "bidderCode": "pubmatic",
-                        "statusMessage": "Bid available",
-                        "cpm": 15,
-                        "currency": "USD",
-                        "bidder": "pubmatic",
-                        "adUnitCode": "Div1",
-                    }
-                ]
+        // Restore the original value
+        setProfileConfigs(originalProfileConfigs);
 
-                 // Create a mock auction with no bids but with RTD floor applied
-                // For this test, we'll observe what the function actually does rather than
-                // try to match specific multiplier values
-                const auction = {
-                    "auctionId": "faf0b7d0-3a12-4774-826a-3d56033d9a74",
-                    "timestamp": 1749410430351,
-                    "auctionEnd": 1749410432392,
-                    "auctionStatus": "completed",
-                    "adUnits": [
-                        {
-                            "code": "Div1",
-                            "sizes": [
-                                [
-                                    160,
-                                    600
-                                ]
-                            ],
-                            "mediaTypes": {
-                                "banner": {
-                                    "sizes": [
-                                        [
-                                            160,
-                                            600
-                                        ]
-                                    ]
-                                }
-                            },
-                            "bids": [
-                                {
-                                    "bidder": "pubmatic",
-                                    "params": {
-                                        "publisherId": "  164392  ",
-                                        "adSlot": "       /43743431/DMDemo@320x250   ",
-                                        "pmzoneid": "zone1",
-                                        "yob": "  1982  ",
-                                        "kadpageurl": "www.yahoo.com?secure=1&pubmatic_bannerbid=15",
-                                        "gender": "   M   ",
-                                        "dctr": "   key1=v1,v11|   key2=v2,v22    |    key3=v3  |  key4=v4     "
-                                    },
-                                    "auctionId": "faf0b7d0-3a12-4774-826a-3d56033d9a74",
-                                    "floorData": {
-                                        "noFloorSignaled": false,
-                                        "skipped": false,
-                                        "skipRate": 0,
-                                        "floorMin": 0.05,
-                                        "modelVersion": "RTD model version 1.0",
-                                        "modelWeight": 100,
-                                        "location": "setConfig",
-                                        "floorProvider": "PM"
-                                    }
-                                }
-                            ],
-                            "adUnitId": "b94e39c9-ac0e-43db-b660-603700dc97dd",
-                            "transactionId": "36da4d88-9a7b-433f-adc1-878af8a8f0f1",
-                            "ortb2Imp": {
-                                "ext": {
-                                    "tid": "36da4d88-9a7b-433f-adc1-878af8a8f0f1",
-                                    "data": {
-                                        "adserver": {
-                                            "name": "gam",
-                                            "adslot": "/43743431/DMDemo"
-                                        },
-                                        "pbadslot": "/43743431/DMDemo"
-                                    },
-                                    "gpid": "/43743431/DMDemo"
-                                }
-                            }
-                        }
-
-                    ],
-                    "adUnitCodes": [
-                        "Div1"
-                    ],
-                    "bidderRequests": [
-                        {
-                            "bidderCode": "pubmatic",
-                            "auctionId": "faf0b7d0-3a12-4774-826a-3d56033d9a74",
-                            "bidderRequestId": "222b556be27f4c",
-                            "bids": [
-                                {
-                                    "bidder": "pubmatic",
-                                    "floorData": {
-                                        "noFloorSignaled": false,
-                                        "skipped": false,
-                                        "skipRate": 0,
-                                        "floorMin": 0.05,
-                                        "modelVersion": "RTD model version 1.0",
-                                        "modelWeight": 100,
-                                        "location": "setConfig",
-                                        "floorProvider": "PM"
-                                    },
-                                    "mediaTypes": {
-                                        "banner": {
-                                            "sizes": [
-                                                [
-                                                    160,
-                                                    600
-                                                ]
-                                            ]
-                                        }
-                                    },
-                                    "adUnitCode": "Div1",
-                                    "transactionId": "36da4d88-9a7b-433f-adc1-878af8a8f0f1",
-                                    "adUnitId": "b94e39c9-ac0e-43db-b660-603700dc97dd",
-                                    "sizes": [
-                                        [
-                                            160,
-                                            600
-                                        ]
-                                    ],
-                                    "bidId": "30fce22fe473c28",
-                                    "bidderRequestId": "222b556be27f4c",
-                                    "src": "client",
-                                    getFloor: () => {}
-                                },
-                            ],
-                            "start": 1749410430354
-                        }
-                    ],
-                    "bidsReceived": [],
-                    "bidsRejected": [],
-                    "winningBids": [],
-                    "timeout": 3000,
-                    "seatNonBids": []
-                };
-
-                sandbox.stub(prebidGlobal, 'getGlobal').returns({
-                    getHighestCpmBids: () => [highestWinningBidResponse]
-                });
-
-                const result = getTargetingData(adUnitCodes, config, userConsent, auction);
-
-                // Restore the original value
-                setProfileConfigs(originalProfileConfigs);
-
-                // Verify correct values for no bid scenario
-                expect(result['Div1']['pm_ym_flrs']).to.equal(1);    // RTD floor was applied
-                expect(result['Div1']['pm_ym_bid_s']).to.equal(1);    // NOBID status
-
-                // Since finding floor values from bidder requests depends on implementation details
-                // we'll just verify the type rather than specific value
-                expect(result['Div1']['pm_ym_flrv']).to.be.a('string');
-            });
-        });
+        // Verify correct values for no bid scenario
+        expect(result['Div1']['pm_ym_flrs']).to.equal(1);    // RTD floor was applied
+        expect(result['Div1']['pm_ym_bid_s']).to.equal(1);    // NOBID status
+
+        // Since finding floor values from bidder requests depends on implementation details
+        // we'll just verify the type rather than specific value
+        expect(result['Div1']['pm_ym_flrv']).to.be.a('string');
+      });
     });
+  });
 });