prebid.js 9.53.3 → 9.53.4

package/test/spec/libraries/pubmaticUtils/plugins/unifiedPricingRule_spec.js

@@ -0,0 +1,359 @@
+import sinon from 'sinon';
+import { expect } from 'chai';
+
+import * as unifiedPricingRule from '../../../../../libraries/pubmaticUtils/plugins/unifiedPricingRule.js';
+import * as prebidGlobal from '../../../../../src/prebidGlobal.js';
+import * as utils from '../../../../../src/utils.js';
+
+// Helper profile configuration with multipliers defined at config.json level
+const profileConfigs = {
+  plugins: {
+    dynamicFloors: {
+      pmTargetingKeys: {
+        enabled: true,
+        multiplier: { win: 2, floored: 3, nobid: 4 }
+      },
+      data: {
+        multiplier: { win: 1.5, floored: 0.8, nobid: 1.2 }
+      }
+    }
+  }
+};
+
+describe('UnifiedPricingRule - getTargeting scenarios', () => {
+  let sandbox;
+  let pbjsStub;
+
+  beforeEach(() => {
+    sandbox = sinon.createSandbox();
+
+    // Stub logger methods to keep test output clean
+    sandbox.stub(utils, 'logInfo');
+    sandbox.stub(utils, 'logError');
+
+    // Stub getGlobal to return our fake pbjs object
+    pbjsStub = {
+      getHighestCpmBids: sandbox.stub()
+    };
+    sandbox.stub(prebidGlobal, 'getGlobal').returns(pbjsStub);
+
+    // Initialise plugin with mock config manager
+    unifiedPricingRule.init('dynamicFloors', {
+      getYMConfig: () => profileConfigs
+    });
+  });
+
+  afterEach(() => {
+    sandbox.restore();
+  });
+
+  const AD_UNIT_CODE = 'div1';
+
+  /**
+   * Utility to build an auction object skeleton
+   */
+  function buildAuction({ adUnits = [], bidsReceived = [], bidsRejected, bidderRequests } = {}) {
+    return {
+      adUnits,
+      bidsReceived,
+      bidsRejected,
+      bidderRequests
+    };
+  }
+
+  it('Winning bid', () => {
+    const winningBid = {
+      adUnitCode: AD_UNIT_CODE,
+      cpm: 2.5,
+      floorData: { floorProvider: 'PM', skipped: false, floorValue: 1.0 }
+    };
+
+    // pbjs should return highest CPM bids
+    pbjsStub.getHighestCpmBids.withArgs(AD_UNIT_CODE).returns([winningBid]);
+
+    const auction = buildAuction({
+      adUnits: [{ bids: [winningBid] }],
+      bidsReceived: [winningBid]
+    });
+
+    const targeting = unifiedPricingRule.getTargeting([AD_UNIT_CODE], {}, {}, auction);
+    expect(targeting[AD_UNIT_CODE].pm_ym_flrs).to.equal(1);
+    expect(targeting[AD_UNIT_CODE].pm_ym_bid_s).to.equal(1);
+    expect(targeting[AD_UNIT_CODE].pm_ym_flrv).to.equal('5.00'); // 2.5 * 2
+  });
+
+  it('No bid - uses findFloorValueFromBidderRequests to derive floor', () => {
+    pbjsStub.getHighestCpmBids.withArgs(AD_UNIT_CODE).returns([]);
+
+    const bidRequest = {
+      adUnitCode: AD_UNIT_CODE,
+      mediaTypes: { banner: { sizes: [[300, 250]] } },
+      getFloor: () => ({ currency: 'USD', floor: 2.0 })
+    };
+
+    // Dummy RTD-floor-applied bid for a different ad-unit so that hasRtdFloorAppliedBid === true
+    const dummyBid = {
+      adUnitCode: 'dummy',
+      floorData: { floorProvider: 'PM', skipped: false, floorValue: 1.0 }
+    };
+
+    const auction = buildAuction({
+      adUnits: [{ bids: [] }, { code: 'dummy', bids: [dummyBid] }],
+      bidsReceived: [dummyBid],
+      bidderRequests: [{ bids: [bidRequest] }]
+    });
+
+    const targeting = unifiedPricingRule.getTargeting([AD_UNIT_CODE], {}, {}, auction);
+    expect(targeting[AD_UNIT_CODE].pm_ym_flrs).to.equal(1);
+    expect(targeting[AD_UNIT_CODE].pm_ym_bid_s).to.equal(0);
+    // 2.0 (min floor) * 4 (nobid multiplier) => 8.00
+    expect(targeting[AD_UNIT_CODE].pm_ym_flrv).to.equal('8.00');
+  });
+
+  it('No bid & bidderRequests missing for adUnit - floor value 0', () => {
+    pbjsStub.getHighestCpmBids.withArgs(AD_UNIT_CODE).returns([]);
+
+    // bidderRequests only for different adUnit code
+    const otherBidRequest = {
+      adUnitCode: 'other',
+      mediaTypes: { banner: { sizes: [[300, 250]] } },
+      getFloor: () => ({ currency: 'USD', floor: 5.0 })
+    };
+
+    // RTD floor applied bid to ensure pm_ym_flrs logic executes
+    const dummyBid = {
+      adUnitCode: 'dummy',
+      floorData: { floorProvider: 'PM', skipped: false, floorValue: 1.0 }
+    };
+
+    const auction = buildAuction({
+      adUnits: [{ bids: [] }, { code: 'dummy', bids: [dummyBid] }],
+      bidsReceived: [dummyBid],
+      bidderRequests: [{ bids: [otherBidRequest] }]
+    });
+
+    const targeting = unifiedPricingRule.getTargeting([AD_UNIT_CODE], {}, {}, auction);
+    expect(targeting[AD_UNIT_CODE].pm_ym_flrs).to.equal(1);
+    expect(targeting[AD_UNIT_CODE].pm_ym_bid_s).to.equal(0);
+    expect(targeting[AD_UNIT_CODE].pm_ym_flrv).to.equal('0.00');
+  });
+
+  it('No bid - bidderRequests array missing', () => {
+    pbjsStub.getHighestCpmBids.withArgs(AD_UNIT_CODE).returns([]);
+
+    // Dummy bid to ensure RTD floor flag is true
+    const dummyBid = {
+      adUnitCode: 'dummy',
+      floorData: { floorProvider: 'PM', skipped: false, floorValue: 1.0 }
+    };
+
+    const auction = buildAuction({
+      adUnits: [{ bids: [] }, { code: 'dummy', bids: [dummyBid] }],
+      bidsReceived: [dummyBid]
+      // bidderRequests is undefined => triggers early return 0
+    });
+
+    const targeting = unifiedPricingRule.getTargeting([AD_UNIT_CODE], {}, {}, auction);
+    expect(targeting[AD_UNIT_CODE].pm_ym_flrs).to.equal(1);
+    expect(targeting[AD_UNIT_CODE].pm_ym_bid_s).to.equal(0);
+    expect(targeting[AD_UNIT_CODE].pm_ym_flrv).to.equal('0.00');
+  });
+
+  it('No bid - bidderRequest has no getFloor method', () => {
+    pbjsStub.getHighestCpmBids.withArgs(AD_UNIT_CODE).returns([]);
+
+    const bidRequest = {
+      adUnitCode: AD_UNIT_CODE,
+      mediaTypes: { banner: { sizes: [[300, 250]] } }, // no getFloor defined
+    };
+
+    const dummyBid = {
+      adUnitCode: 'dummy',
+      floorData: { floorProvider: 'PM', skipped: false, floorValue: 1.0 }
+    };
+
+    const auction = buildAuction({
+      adUnits: [{ bids: [] }, { code: 'dummy', bids: [dummyBid] }],
+      bidsReceived: [dummyBid],
+      bidderRequests: [{ bids: [bidRequest] }]
+    });
+
+    const targeting = unifiedPricingRule.getTargeting([AD_UNIT_CODE], {}, {}, auction);
+    expect(targeting[AD_UNIT_CODE].pm_ym_flrs).to.equal(1);
+    expect(targeting[AD_UNIT_CODE].pm_ym_bid_s).to.equal(0);
+    expect(targeting[AD_UNIT_CODE].pm_ym_flrv).to.equal('0.00');
+  });
+
+  it('No bid - video playerSize processed', () => {
+    pbjsStub.getHighestCpmBids.withArgs(AD_UNIT_CODE).returns([]);
+
+    const videoFloorStub = sinon.stub().returns({ currency: 'USD', floor: 3.0 });
+
+    const bidRequest = {
+      adUnitCode: AD_UNIT_CODE,
+      mediaTypes: { video: { playerSize: [[640, 480]] } },
+      getFloor: videoFloorStub
+    };
+
+    const dummyBid = {
+      adUnitCode: 'dummy',
+      floorData: { floorProvider: 'PM', skipped: false, floorValue: 1.0 }
+    };
+
+    const auction = buildAuction({
+      adUnits: [{ bids: [] }, { code: 'dummy', bids: [dummyBid] }],
+      bidsReceived: [dummyBid],
+      bidderRequests: [{ bids: [bidRequest] }]
+    });
+
+    const targeting = unifiedPricingRule.getTargeting([AD_UNIT_CODE], {}, {}, auction);
+    expect(videoFloorStub.called).to.be.true;
+    expect(videoFloorStub.firstCall.args[0].mediaType).to.equal('video');
+    expect(targeting[AD_UNIT_CODE].pm_ym_flrs).to.equal(1);
+    expect(targeting[AD_UNIT_CODE].pm_ym_bid_s).to.equal(0);
+    expect(targeting[AD_UNIT_CODE].pm_ym_flrv).to.equal('12.00'); // 3 * 4
+  });
+
+  it('No bid - fallback sizes array used', () => {
+    pbjsStub.getHighestCpmBids.withArgs(AD_UNIT_CODE).returns([]);
+
+    const sizesFloorStub = sinon.stub().returns({ currency: 'USD', floor: 4.0 });
+
+    const bidRequest = {
+      adUnitCode: AD_UNIT_CODE,
+      sizes: [[300, 600]], // general sizes (no mediaTypes)
+      getFloor: sizesFloorStub
+    };
+
+    const dummyBid = {
+      adUnitCode: 'dummy',
+      floorData: { floorProvider: 'PM', skipped: false, floorValue: 1.0 }
+    };
+
+    const auction = buildAuction({
+      adUnits: [{ bids: [] }, { code: 'dummy', bids: [dummyBid] }],
+      bidsReceived: [dummyBid],
+      bidderRequests: [{ bids: [bidRequest] }]
+    });
+
+    const targeting = unifiedPricingRule.getTargeting([AD_UNIT_CODE], {}, {}, auction);
+    expect(sizesFloorStub.called).to.be.true;
+    expect(sizesFloorStub.firstCall.args[0].mediaType).to.equal('banner');
+    expect(targeting[AD_UNIT_CODE].pm_ym_flrs).to.equal(1);
+    expect(targeting[AD_UNIT_CODE].pm_ym_bid_s).to.equal(0);
+    expect(targeting[AD_UNIT_CODE].pm_ym_flrv).to.equal('16.00'); // 4 * 4
+  });
+
+  it('No bid - wildcard size used when no sizes found', () => {
+    pbjsStub.getHighestCpmBids.withArgs(AD_UNIT_CODE).returns([]);
+
+    const wildcardFloorStub = sinon.stub().returns({ currency: 'USD', floor: 5.0 });
+
+    const bidRequest = {
+      adUnitCode: AD_UNIT_CODE,
+      getFloor: wildcardFloorStub
+    };
+
+    const dummyBid = {
+      adUnitCode: 'dummy',
+      floorData: { floorProvider: 'PM', skipped: false, floorValue: 1.0 }
+    };
+
+    const auction = buildAuction({
+      adUnits: [{ code: AD_UNIT_CODE, bids: [] }, { code: 'dummy', bids: [dummyBid] }],
+      bidsReceived: [dummyBid],
+      bidderRequests: [{ bids: [bidRequest] }]
+    });
+
+    const targeting = unifiedPricingRule.getTargeting([AD_UNIT_CODE], {}, {}, auction);
+    expect(wildcardFloorStub.called).to.be.true;
+    const floorArgs = wildcardFloorStub.firstCall.args[0];
+    expect(floorArgs.mediaType).to.equal('banner');
+    expect(floorArgs.size).to.deep.equal(['*', '*']);
+    expect(targeting[AD_UNIT_CODE].pm_ym_flrs).to.equal(1);
+    expect(targeting[AD_UNIT_CODE].pm_ym_bid_s).to.equal(0);
+    expect(targeting[AD_UNIT_CODE].pm_ym_flrv).to.equal('20.00'); // 5 * 4
+  });
+
+  it('Multiplier selection from floor.json when config multiplier missing', () => {
+    // Re-init with profileConfigs having multiplier only in data.multiplier (floor.json)
+    unifiedPricingRule.init('dynamicFloors', {
+      getYMConfig: () => ({
+        plugins: {
+          dynamicFloors: {
+            pmTargetingKeys: {
+              enabled: true // no multiplier object here
+            },
+            data: {
+              multiplier: { win: 1.7 }
+            }
+          }
+        }
+      })
+    });
+
+    const winningBid = { adUnitCode: AD_UNIT_CODE, cpm: 2.0, floorData: { floorProvider: 'PM', skipped: false, floorValue: 1 } };
+    pbjsStub.getHighestCpmBids.withArgs(AD_UNIT_CODE).returns([winningBid]);
+
+    const auction = buildAuction({ adUnits: [{ bids: [winningBid] }], bidsReceived: [winningBid] });
+
+    const targeting = unifiedPricingRule.getTargeting([AD_UNIT_CODE], {}, {}, auction);
+    expect(targeting[AD_UNIT_CODE].pm_ym_flrv).to.equal('3.40'); // 2 * 1.7
+  });
+
+  it('Multiplier default constant used when no multipliers in profileConfigs', () => {
+    unifiedPricingRule.init('dynamicFloors', {
+      getYMConfig: () => ({
+        plugins: {
+          dynamicFloors: {
+            pmTargetingKeys: { enabled: true },
+            data: {} // no multiplier in data
+          }
+        }
+      })
+    });
+
+    const winningBid = { adUnitCode: AD_UNIT_CODE, cpm: 2.0, floorData: { floorProvider: 'PM', skipped: false, floorValue: 1 } };
+    pbjsStub.getHighestCpmBids.withArgs(AD_UNIT_CODE).returns([winningBid]);
+
+    const auction = buildAuction({ adUnits: [{ bids: [winningBid] }], bidsReceived: [winningBid] });
+
+    const targeting = unifiedPricingRule.getTargeting([AD_UNIT_CODE], {}, {}, auction);
+    expect(targeting[AD_UNIT_CODE].pm_ym_flrv).to.equal('2.00'); // 2 * default 1.0
+  });
+
+  it('RTD floor not applied - pm_ym_flrs should be 0 only', () => {
+    // Floor data indicates skipped OR different provider
+    const nonRtdBid = {
+      adUnitCode: AD_UNIT_CODE,
+      cpm: 1.0,
+      floorData: { floorProvider: 'OTHER', skipped: true }
+    };
+
+    const auction = buildAuction({
+      adUnits: [{ bids: [nonRtdBid] }],
+      bidsReceived: [nonRtdBid]
+    });
+
+    const targeting = unifiedPricingRule.getTargeting([AD_UNIT_CODE], {}, {}, auction);
+    expect(targeting[AD_UNIT_CODE].pm_ym_flrs).to.equal(0);
+    expect(targeting[AD_UNIT_CODE]).to.not.have.property('pm_ym_flrv');
+    expect(targeting[AD_UNIT_CODE]).to.not.have.property('pm_ym_bid_s');
+  });
+
+  it('pmTargetingKeys disabled - should return empty object', () => {
+    // Re-init with pmTargetingKeys disabled
+    unifiedPricingRule.init('dynamicFloors', {
+      getYMConfig: () => ({
+        plugins: {
+          dynamicFloors: {
+            pmTargetingKeys: { enabled: false }
+          }
+        }
+      })
+    });
+
+    const targeting = unifiedPricingRule.getTargeting([AD_UNIT_CODE], {}, {}, {});
+    expect(targeting).to.deep.equal({});
+  });
+});

package/test/spec/libraries/pubmaticUtils/pubmaticUtils_spec.js

@@ -0,0 +1,236 @@
+/* globals describe, beforeEach, afterEach, it, sinon */
+import { expect } from 'chai';
+import * as sua from '../../../../src/fpd/sua.js';
+import { getBrowserType, getCurrentTimeOfDay, getUtmValue } from '../../../../libraries/pubmaticUtils/pubmaticUtils.js';
+
+describe('pubmaticUtils', () => {
+  let sandbox;
+  const ORIGINAL_USER_AGENT = window.navigator.userAgent;
+  const ORIGINAL_LOCATION = window.location;
+
+  beforeEach(() => {
+    sandbox = sinon.sandbox.create();
+  });
+
+  afterEach(() => {
+    sandbox.restore();
+    window.navigator.__defineGetter__('userAgent', () => ORIGINAL_USER_AGENT);
+
+    // Restore original window.location if it was modified
+    if (window.location !== ORIGINAL_LOCATION) {
+      delete window.location;
+      window.location = ORIGINAL_LOCATION;
+    }
+  });
+
+  describe('getBrowserType', () => {
+    it('should return browser type from SUA when available', () => {
+      const mockSuaData = {
+        browsers: [
+          { brand: 'Chrome' }
+        ]
+      };
+
+      sandbox.stub(sua, 'getLowEntropySUA').returns(mockSuaData);
+
+      expect(getBrowserType()).to.equal('9'); // Chrome ID from BROWSER_REGEX_MAP
+    });
+
+    it('should return browser type from userAgent when SUA is not available', () => {
+      sandbox.stub(sua, 'getLowEntropySUA').returns(null);
+
+      const chromeUserAgent = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36';
+      window.navigator.__defineGetter__('userAgent', () => chromeUserAgent);
+
+      expect(getBrowserType()).to.equal('9'); // Chrome ID
+    });
+
+    it('should return browser type for Edge browser', () => {
+      sandbox.stub(sua, 'getLowEntropySUA').returns(null);
+
+      const edgeUserAgent = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36 Edg/91.0.864.59';
+      window.navigator.__defineGetter__('userAgent', () => edgeUserAgent);
+
+      expect(getBrowserType()).to.equal('2'); // Edge ID
+    });
+
+    it('should return browser type for Opera browser', () => {
+      sandbox.stub(sua, 'getLowEntropySUA').returns(null);
+
+      const operaUserAgent = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36 OPR/77.0.4054.277';
+      window.navigator.__defineGetter__('userAgent', () => operaUserAgent);
+
+      expect(getBrowserType()).to.equal('3'); // Opera ID
+    });
+
+    it('should return browser type for Firefox browser', () => {
+      sandbox.stub(sua, 'getLowEntropySUA').returns(null);
+
+      const firefoxUserAgent = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:89.0) Gecko/20100101 Firefox/89.0';
+      window.navigator.__defineGetter__('userAgent', () => firefoxUserAgent);
+
+      expect(getBrowserType()).to.equal('12'); // Firefox ID
+    });
+
+    it('should return "0" when browser type cannot be determined', () => {
+      sandbox.stub(sua, 'getLowEntropySUA').returns(null);
+
+      const unknownUserAgent = 'Unknown Browser';
+      window.navigator.__defineGetter__('userAgent', () => unknownUserAgent);
+
+      expect(getBrowserType()).to.equal('0');
+    });
+
+    it('should return "-1" when userAgent is null', () => {
+      sandbox.stub(sua, 'getLowEntropySUA').returns(null);
+      window.navigator.__defineGetter__('userAgent', () => null);
+
+      expect(getBrowserType()).to.equal('-1');
+    });
+  });
+
+  describe('getCurrentTimeOfDay', () => {
+    let clock;
+
+    afterEach(() => {
+      if (clock) {
+        clock.restore();
+      }
+    });
+
+    it('should return "night" for hours between 0 and 4', () => {
+      // Set time to 3:30 AM
+      clock = sinon.useFakeTimers(new Date(2025, 7, 6, 3, 30, 0).getTime());
+      expect(getCurrentTimeOfDay()).to.equal('night');
+    });
+
+    it('should return "morning" for hours between 5 and 11', () => {
+      // Set time to 9:15 AM
+      clock = sinon.useFakeTimers(new Date(2025, 7, 6, 9, 15, 0).getTime());
+      expect(getCurrentTimeOfDay()).to.equal('morning');
+    });
+
+    it('should return "afternoon" for hours between 12 and 16', () => {
+      // Set time to 2:45 PM
+      clock = sinon.useFakeTimers(new Date(2025, 7, 6, 14, 45, 0).getTime());
+      expect(getCurrentTimeOfDay()).to.equal('afternoon');
+    });
+
+    it('should return "evening" for hours between 17 and 18', () => {
+      // Set time to 5:30 PM
+      clock = sinon.useFakeTimers(new Date(2025, 7, 6, 17, 30, 0).getTime());
+      expect(getCurrentTimeOfDay()).to.equal('evening');
+    });
+
+    it('should return "night" for hours between 19 and 23', () => {
+      // Set time to 10:00 PM
+      clock = sinon.useFakeTimers(new Date(2025, 7, 6, 22, 0, 0).getTime());
+      expect(getCurrentTimeOfDay()).to.equal('night');
+    });
+  });
+
+  describe('getUtmValue', () => {
+    // Setup for mocking URL and URLSearchParams
+    let mockUrl;
+    let mockUrlParams;
+    let origURL;
+    let origURLSearchParams;
+
+    beforeEach(() => {
+      // Save original constructors
+      origURL = global.URL;
+      origURLSearchParams = global.URLSearchParams;
+
+      // Create mock URL and URLSearchParams
+      mockUrl = {};
+      mockUrlParams = {
+        toString: sandbox.stub().returns(''),
+        includes: sandbox.stub().returns(false)
+      };
+
+      // Mock URL constructor
+      global.URL = sandbox.stub().returns(mockUrl);
+
+      // Mock URLSearchParams constructor
+      global.URLSearchParams = sandbox.stub().returns(mockUrlParams);
+    });
+
+    afterEach(() => {
+      // Restore original constructors
+      global.URL = origURL;
+      global.URLSearchParams = origURLSearchParams;
+    });
+
+    it('should return "1" when URL contains utm_source parameter', () => {
+      // Setup mock URL with utm_source parameter
+      mockUrl.search = '?utm_source=test';
+      mockUrlParams.toString.returns('utm_source=test');
+      mockUrlParams.includes.withArgs('utm_').returns(true);
+
+      expect(getUtmValue()).to.equal('1');
+    });
+
+    it('should return "1" when URL contains utm_medium parameter', () => {
+      // Setup mock URL with utm_medium parameter
+      mockUrl.search = '?utm_medium=social';
+      mockUrlParams.toString.returns('utm_medium=social');
+      mockUrlParams.includes.withArgs('utm_').returns(true);
+
+      expect(getUtmValue()).to.equal('1');
+    });
+
+    it('should return "1" when URL contains utm_campaign parameter', () => {
+      // Setup mock URL with utm_campaign parameter
+      mockUrl.search = '?utm_campaign=summer2025';
+      mockUrlParams.toString.returns('utm_campaign=summer2025');
+      mockUrlParams.includes.withArgs('utm_').returns(true);
+
+      expect(getUtmValue()).to.equal('1');
+    });
+
+    it('should return "1" when URL contains multiple UTM parameters', () => {
+      // Setup mock URL with multiple UTM parameters
+      mockUrl.search = '?utm_source=google&utm_medium=cpc&utm_campaign=brand';
+      mockUrlParams.toString.returns('utm_source=google&utm_medium=cpc&utm_campaign=brand');
+      mockUrlParams.includes.withArgs('utm_').returns(true);
+
+      expect(getUtmValue()).to.equal('1');
+    });
+
+    it('should return "1" when URL contains UTM parameters mixed with other parameters', () => {
+      // Setup mock URL with mixed parameters
+      mockUrl.search = '?id=123&utm_source=newsletter&page=2';
+      mockUrlParams.toString.returns('id=123&utm_source=newsletter&page=2');
+      mockUrlParams.includes.withArgs('utm_').returns(true);
+
+      expect(getUtmValue()).to.equal('1');
+    });
+
+    it('should return "0" when URL contains no UTM parameters', () => {
+      // Setup mock URL with no UTM parameters
+      mockUrl.search = '?id=123&page=2';
+      mockUrlParams.toString.returns('id=123&page=2');
+      mockUrlParams.includes.withArgs('utm_').returns(false);
+
+      expect(getUtmValue()).to.equal('0');
+    });
+
+    it('should return "0" when URL has no query parameters', () => {
+      // Setup mock URL with no query parameters
+      mockUrl.search = '';
+      mockUrlParams.toString.returns('');
+      mockUrlParams.includes.withArgs('utm_').returns(false);
+
+      expect(getUtmValue()).to.equal('0');
+    });
+
+    it('should handle URL with hash fragment correctly', () => {
+      // Setup mock URL with hash fragment
+      mockUrl.search = '?utm_source=test';
+      mockUrlParams.toString.returns('utm_source=test');
+      mockUrlParams.includes.withArgs('utm_').returns(true);
+
+      expect(getUtmValue()).to.equal('1');
+    });
+  });
+});