@duckduckgo/autoconsent 14.97.0 → 15.0.0

package/tests-wtr/heuristics/get-actionable-popups.html

@@ -92,5 +92,21 @@
             <button>Accept All</button>
             <button>Reject All</button>
         </dialog>
+
+        <div id="popup-accept-only" class="popup">
+            <p>We use cookies to improve your experience.</p>
+            <button>Accept All</button>
+        </div>
+
+        <div id="popup-acknowledge-only" class="popup">
+            <p>We use cookies to improve your experience.</p>
+            <button>OK</button>
+        </div>
+
+        <div id="popup-multiple-reject" class="popup">
+            <p>We use cookies to improve your experience.</p>
+            <button>Reject All</button>
+            <button>Deny</button>
+        </div>
     </body>
 </html>

package/tests-wtr/heuristics/get-actionable-popups.ts

@@ -1,5 +1,14 @@
 import { expect } from '@esm-bundle/chai';
 import { getActionablePopups } from '../../lib/heuristics';
+import { ButtonData, PopupHandlingModes } from '../../lib/types';
+
+function rejectButtons(buttons: ButtonData[]) {
+    return buttons.filter((b) => b.regexClassification === 'reject');
+}
+
+function nonRejectButtons(buttons: ButtonData[]) {
+    return buttons.filter((b) => b.regexClassification !== 'reject');
+}
 
 // must be run from get-actionable-popups.html
 describe('getActionablePopups', () => {
@@ -21,8 +30,8 @@ describe('getActionablePopups', () => {
         const popups = getActionablePopups();
 
         expect(popups.length).to.equal(1);
-        expect(popups[0].rejectButtons?.length).to.equal(1);
-        expect(popups[0].rejectButtons?.[0].text).to.equal('Reject All');
+        expect(rejectButtons(popups[0].buttons)).to.have.length(1);
+        expect(rejectButtons(popups[0].buttons)[0].text).to.equal('Reject All');
     });
 
     describe('does not match non-cookie popups', () => {
@@ -34,13 +43,83 @@ describe('getActionablePopups', () => {
             expect(popups.length).to.equal(0);
         });
 
-        it('ignores popup without reject button', () => {
+        it('ignores popup with accept and settings buttons', () => {
             showPopup('popup-no-reject');
 
-            const popups = getActionablePopups();
+            const popups = getActionablePopups(PopupHandlingModes.Tier2);
+
+            expect(popups.length).to.equal(0);
+        });
+    });
+
+    describe('tier button candidates', () => {
+        it('finds accept-only popup with no reject buttons', () => {
+            showPopup('popup-accept-only');
+
+            const popups = getActionablePopups(PopupHandlingModes.Tier2);
+
+            expect(popups.length).to.equal(1);
+            expect(rejectButtons(popups[0].buttons)).to.have.length(0);
+            expect(popups[0].buttons.filter((b) => b.regexClassification === 'accept')).to.have.length(1);
+        });
+
+        it('finds acknowledge-only popup with no reject buttons', () => {
+            showPopup('popup-acknowledge-only');
+
+            const popups = getActionablePopups(PopupHandlingModes.Tier2);
+
+            expect(popups.length).to.equal(1);
+            expect(rejectButtons(popups[0].buttons)).to.have.length(0);
+            expect(popups[0].buttons.filter((b) => b.regexClassification === 'acknowledge')).to.have.length(1);
+        });
+
+        it('finds popup with multiple reject buttons', () => {
+            showPopup('popup-multiple-reject');
+
+            const popups = getActionablePopups(PopupHandlingModes.Tier2);
+
+            expect(popups.length).to.equal(1);
+            expect(popups[0].regexClassification).to.equal(PopupHandlingModes.Reject);
+            expect(rejectButtons(popups[0].buttons)).to.have.length(2);
+        });
+    });
+
+    describe('mode filtering', () => {
+        it('does not return accept-only popup when mode is Reject', () => {
+            showPopup('popup-accept-only');
+
+            const popups = getActionablePopups(PopupHandlingModes.Reject);
+
+            expect(popups.length).to.equal(0);
+        });
+
+        it('returns acknowledge-only popup when mode is Tier1', () => {
+            showPopup('popup-acknowledge-only');
+
+            const popups = getActionablePopups(PopupHandlingModes.Tier1);
+
+            expect(popups.length).to.equal(1);
+            expect(popups[0].regexClassification).to.equal(PopupHandlingModes.Tier1);
+        });
+
+        it('does not return accept-only popup when mode is Tier1', () => {
+            showPopup('popup-accept-only');
+
+            const popups = getActionablePopups(PopupHandlingModes.Tier1);
 
             expect(popups.length).to.equal(0);
         });
+
+        it('prefers reject popup when reject and accept popups are visible', () => {
+            showPopup('popup-reject-all');
+            showPopup('popup-accept-only');
+
+            const popups = getActionablePopups(PopupHandlingModes.Tier2);
+
+            expect(popups.length).to.equal(2);
+            expect(popups[0].regexClassification).to.equal(PopupHandlingModes.Reject);
+            expect(popups[1].regexClassification).to.equal(PopupHandlingModes.Tier2);
+        });
     });
 
     describe('positioning', () => {
@@ -112,8 +191,8 @@ describe('getActionablePopups', () => {
             const popups = getActionablePopups();
 
             expect(popups.length).to.equal(1);
-            expect(popups[0].rejectButtons?.length).to.equal(1);
-            expect(popups[0].otherButtons?.length).to.equal(3);
+            expect(rejectButtons(popups[0].buttons)).to.have.length(1);
+            expect(nonRejectButtons(popups[0].buttons)).to.have.length(3);
         });
     });
 });

package/tests-wtr/heuristics/heuristic-cmp.html

@@ -0,0 +1,69 @@
+<html>
+    <head>
+        <style>
+            .popup {
+                position: fixed;
+                top: 0;
+                left: 0;
+                width: 300px;
+                height: 200px;
+                background: white;
+                display: none;
+            }
+            .popup.visible {
+                display: block;
+            }
+            .popup.tier-preference-accept {
+                top: 0;
+                left: 320px;
+            }
+        </style>
+    </head>
+    <body>
+        <script type="module">
+            import { runTests } from '@web/test-runner-mocha';
+
+            runTests(async () => {
+                await import('./heuristic-cmp');
+            });
+        </script>
+
+        <div id="popup-reject" class="popup">
+            <p>We use cookies to improve your experience.</p>
+            <button>Accept All</button>
+            <button>Reject All</button>
+        </div>
+
+        <div id="popup-acknowledge-only" class="popup">
+            <p>We use cookies to improve your experience.</p>
+            <button>OK</button>
+        </div>
+
+        <div id="popup-accept-only" class="popup">
+            <p>We use cookies to improve your experience.</p>
+            <button>Accept All</button>
+        </div>
+
+        <div id="popup-accept-settings" class="popup">
+            <p>We use cookies to improve your experience.</p>
+            <button>Accept All</button>
+            <button>Settings</button>
+        </div>
+
+        <div id="popup-multiple-reject" class="popup">
+            <p>We use cookies to improve your experience.</p>
+            <button>Reject All</button>
+            <button>Deny</button>
+        </div>
+
+        <div id="popup-tier-preference-reject" class="popup">
+            <p>We use cookies to improve your experience.</p>
+            <button>Reject All</button>
+        </div>
+
+        <div id="popup-tier-preference-accept" class="popup tier-preference-accept">
+            <p>We use cookies to improve your experience.</p>
+            <button>Accept All</button>
+        </div>
+    </body>
+</html>

package/tests-wtr/heuristics/heuristic-cmp.ts

@@ -0,0 +1,178 @@
+import { expect } from '@esm-bundle/chai';
+import Autoconsent from '../../lib/web';
+import { AutoConsentHeuristicCMP } from '../../lib/cmps/base';
+import { PopupHandlingMode, PopupHandlingModes } from '../../lib/types';
+
+// must be run from heuristic-cmp.html
+describe('AutoConsentHeuristicCMP', () => {
+    function createAutoconsent(heuristicMode: PopupHandlingMode) {
+        return new Autoconsent(() => Promise.resolve(), {
+            enabled: false,
+            autoAction: null,
+            enableHeuristicAction: true,
+            heuristicMode,
+        });
+    }
+
+    function showPopup(...ids: string[]) {
+        hideAllPopups();
+        for (const id of ids) {
+            document.getElementById(id)?.classList.add('visible');
+        }
+    }
+
+    function hideAllPopups() {
+        document.querySelectorAll('.popup').forEach((el) => el.classList.remove('visible'));
+    }
+
+    afterEach(() => {
+        hideAllPopups();
+    });
+
+    describe('detectCmp', () => {
+        it('detects reject popup as HEURISTIC-TIER0', async () => {
+            const autoconsent = createAutoconsent(PopupHandlingModes.Tier2);
+            const cmp = new AutoConsentHeuristicCMP(autoconsent, PopupHandlingModes.Tier2);
+            showPopup('popup-reject');
+
+            const detected = await cmp.detectCmp();
+
+            expect(detected).to.be.true;
+            expect(cmp.name).to.equal('HEURISTIC-TIER0');
+        });
+
+        it('detects acknowledge-only popup as HEURISTIC-TIER1', async () => {
+            const autoconsent = createAutoconsent(PopupHandlingModes.Tier2);
+            const cmp = new AutoConsentHeuristicCMP(autoconsent, PopupHandlingModes.Tier2);
+            showPopup('popup-acknowledge-only');
+
+            const detected = await cmp.detectCmp();
+
+            expect(detected).to.be.true;
+            expect(cmp.name).to.equal('HEURISTIC-TIER1');
+        });
+
+        it('detects accept-only popup as HEURISTIC-TIER2', async () => {
+            const autoconsent = createAutoconsent(PopupHandlingModes.Tier2);
+            const cmp = new AutoConsentHeuristicCMP(autoconsent, PopupHandlingModes.Tier2);
+            showPopup('popup-accept-only');
+
+            const detected = await cmp.detectCmp();
+
+            expect(detected).to.be.true;
+            expect(cmp.name).to.equal('HEURISTIC-TIER2');
+        });
+
+        it('does not detect popup with accept and settings buttons', async () => {
+            const autoconsent = createAutoconsent(PopupHandlingModes.Tier2);
+            const cmp = new AutoConsentHeuristicCMP(autoconsent, PopupHandlingModes.Tier2);
+            showPopup('popup-accept-settings');
+
+            const detected = await cmp.detectCmp();
+
+            expect(detected).to.be.false;
+        });
+
+        it('detects popup with multiple reject buttons as HEURISTIC-TIER0', async () => {
+            const autoconsent = createAutoconsent(PopupHandlingModes.Tier2);
+            const cmp = new AutoConsentHeuristicCMP(autoconsent, PopupHandlingModes.Tier2);
+            showPopup('popup-multiple-reject');
+
+            const detected = await cmp.detectCmp();
+
+            expect(detected).to.be.true;
+            expect(cmp.name).to.equal('HEURISTIC-TIER0');
+        });
+
+        it('prefers reject popup when reject and accept popups are visible', async () => {
+            const autoconsent = createAutoconsent(PopupHandlingModes.Tier2);
+            const cmp = new AutoConsentHeuristicCMP(autoconsent, PopupHandlingModes.Tier2);
+            showPopup('popup-tier-preference-reject', 'popup-tier-preference-accept');
+
+            const detected = await cmp.detectCmp();
+
+            expect(detected).to.be.true;
+            expect(cmp.name).to.equal('HEURISTIC-TIER0');
+        });
+    });
+
+    describe('heuristicMode cap', () => {
+        it('does not detect accept-only popup when mode is Reject', async () => {
+            const autoconsent = createAutoconsent(PopupHandlingModes.Reject);
+            const cmp = new AutoConsentHeuristicCMP(autoconsent, PopupHandlingModes.Reject);
+            showPopup('popup-accept-only');
+
+            const detected = await cmp.detectCmp();
+
+            expect(detected).to.be.false;
+        });
+
+        it('detects acknowledge-only popup when mode is Tier1', async () => {
+            const autoconsent = createAutoconsent(PopupHandlingModes.Tier1);
+            const cmp = new AutoConsentHeuristicCMP(autoconsent, PopupHandlingModes.Tier1);
+            showPopup('popup-acknowledge-only');
+
+            const detected = await cmp.detectCmp();
+
+            expect(detected).to.be.true;
+            expect(cmp.name).to.equal('HEURISTIC-TIER1');
+        });
+
+        it('does not detect accept-only popup when mode is Tier1', async () => {
+            const autoconsent = createAutoconsent(PopupHandlingModes.Tier1);
+            const cmp = new AutoConsentHeuristicCMP(autoconsent, PopupHandlingModes.Tier1);
+            showPopup('popup-accept-only');
+
+            const detected = await cmp.detectCmp();
+
+            expect(detected).to.be.false;
+        });
+    });
+
+    describe('optOut', () => {
+        it('clicks the reject button for TIER0 popup', async () => {
+            const autoconsent = createAutoconsent(PopupHandlingModes.Tier2);
+            const cmp = new AutoConsentHeuristicCMP(autoconsent, PopupHandlingModes.Tier2);
+            showPopup('popup-reject');
+            await cmp.detectCmp();
+
+            const target = cmp.getTargetButton();
+            expect(target?.regexClassification).to.equal('reject');
+
+            const result = await cmp.optOut();
+
+            expect(result).to.be.true;
+            expect(autoconsent.state.clicks).to.equal(1);
+        });
+
+        it('clicks the acknowledge button for TIER1 popup', async () => {
+            const autoconsent = createAutoconsent(PopupHandlingModes.Tier2);
+            const cmp = new AutoConsentHeuristicCMP(autoconsent, PopupHandlingModes.Tier2);
+            showPopup('popup-acknowledge-only');
+            await cmp.detectCmp();
+
+            const target = cmp.getTargetButton();
+            expect(target?.regexClassification).to.equal('acknowledge');
+
+            const result = await cmp.optOut();
+
+            expect(result).to.be.true;
+            expect(autoconsent.state.clicks).to.equal(1);
+        });
+
+        it('clicks the accept button for TIER2 popup', async () => {
+            const autoconsent = createAutoconsent(PopupHandlingModes.Tier2);
+            const cmp = new AutoConsentHeuristicCMP(autoconsent, PopupHandlingModes.Tier2);
+            showPopup('popup-accept-only');
+            await cmp.detectCmp();
+
+            const target = cmp.getTargetButton();
+            expect(target?.regexClassification).to.equal('accept');
+
+            const result = await cmp.optOut();
+
+            expect(result).to.be.true;
+            expect(autoconsent.state.clicks).to.equal(1);
+        });
+    });
+});

package/tests-wtr/heuristics/heuristics-utils.test.ts

@@ -2,13 +2,22 @@ import { expect } from '@esm-bundle/chai';
 import {
     checkHeuristicPatterns,
     cleanButtonText,
-    isRejectButton,
+    classifyButtonTextRegex,
     classifyButtons,
     isDisabled,
     excludeContainers,
     getButtonData,
     isDialogLikeElement,
 } from '../../lib/heuristics';
+import { ButtonData } from '../../lib/types';
+
+function rejectButtons(buttons: ButtonData[]) {
+    return buttons.filter((b) => b.regexClassification === 'reject');
+}
+
+function nonRejectButtons(buttons: ButtonData[]) {
+    return buttons.filter((b) => b.regexClassification !== 'reject');
+}
 
 describe('checkHeuristicPatterns', () => {
     it('detects cookie-related text', () => {
@@ -66,69 +75,128 @@ describe('cleanButtonText', () => {
     });
 });
 
-describe('isRejectButton', () => {
+describe('classifyButtonTextRegex', () => {
     it('matches reject patterns', () => {
-        expect(isRejectButton('let us Reject All cookies', [/reject all/gi])).to.be.true;
+        expect(classifyButtonTextRegex('Reject All')).to.equal('reject');
     });
 
     it('does not match never match patterns', () => {
-        expect(isRejectButton('let us Reject All cookies', [/reject all/gi], [/let us/gi])).to.be.false;
+        expect(classifyButtonTextRegex('reject and pay')).to.equal('other');
     });
 
     it('matches "except strictly necessary" qualifier', () => {
         // OneTrust on apnews.com labels the reject button "I Reject All (except Strictly Necessary)"
-        expect(isRejectButton('I Reject All (except Strictly Necessary)')).to.be.true;
-        expect(isRejectButton('Reject All (except Strictly Necessary)')).to.be.true;
-        expect(isRejectButton('Reject All (except Necessary)')).to.be.true;
-        expect(isRejectButton('Deny All (except Strictly Essential)')).to.be.true;
-        expect(isRejectButton('I Reject All except necessary')).to.be.true;
+        expect(classifyButtonTextRegex('I Reject All (except Strictly Necessary)')).to.equal('reject');
+        expect(classifyButtonTextRegex('Reject All (except Strictly Necessary)')).to.equal('reject');
+        expect(classifyButtonTextRegex('Reject All (except Necessary)')).to.equal('reject');
+        expect(classifyButtonTextRegex('Deny All (except Strictly Essential)')).to.equal('reject');
+        expect(classifyButtonTextRegex('I Reject All except necessary')).to.equal('reject');
     });
 
-    it('returns false for empty string', () => {
-        expect(isRejectButton('')).to.be.false;
+    it('returns other for empty string', () => {
+        expect(classifyButtonTextRegex('')).to.equal('other');
     });
 
-    it('supports exact strings', () => {
-        expect(isRejectButton('let us reject all', ['let us reject all'])).to.be.true;
+    it('supports exact string patterns', () => {
+        expect(classifyButtonTextRegex('no')).to.equal('reject');
     });
 
-    it('does not match substrings in case of exact strings', () => {
-        expect(isRejectButton('let us reject all', ['reject'])).to.be.false;
+    it('does not match partial exact string patterns', () => {
+        expect(classifyButtonTextRegex('no problem')).to.equal('other');
     });
 });
 
 describe('classifyButtons', () => {
     it('separates reject buttons from other buttons', () => {
-        const buttons = [
+        const buttons: ButtonData[] = [
             { text: 'Accept All', element: document.createElement('button') },
             { text: 'Reject All', element: document.createElement('button') },
             { text: 'Settings', element: document.createElement('button') },
         ];
 
-        const { rejectButtons, otherButtons } = classifyButtons(buttons);
+        classifyButtons(buttons);
 
-        expect(rejectButtons).to.have.length(1);
-        expect(rejectButtons[0].text).to.equal('Reject All');
-        expect(otherButtons).to.have.length(2);
+        expect(rejectButtons(buttons)).to.have.length(1);
+        expect(rejectButtons(buttons)[0].text).to.equal('Reject All');
+        expect(nonRejectButtons(buttons)).to.have.length(2);
     });
 
-    it('returns empty arrays for empty input', () => {
-        const { rejectButtons, otherButtons } = classifyButtons([]);
+    it('handles empty input', () => {
+        const buttons: ButtonData[] = [];
+
+        classifyButtons(buttons);
 
-        expect(rejectButtons).to.have.length(0);
-        expect(otherButtons).to.have.length(0);
+        expect(rejectButtons(buttons)).to.have.length(0);
+        expect(nonRejectButtons(buttons)).to.have.length(0);
     });
 
     it('handles multiple reject buttons', () => {
-        const buttons = [
+        const buttons: ButtonData[] = [
             { text: 'Reject All', element: document.createElement('button') },
             { text: 'Deny', element: document.createElement('button') },
         ];
 
-        const { rejectButtons, otherButtons } = classifyButtons(buttons);
+        classifyButtons(buttons);
+
+        expect(rejectButtons(buttons)).to.have.length(2);
+        expect(nonRejectButtons(buttons)).to.have.length(0);
+    });
+
+    it('sets regexClassification on all buttons', () => {
+        const buttons: ButtonData[] = [
+            { text: 'Accept All', element: document.createElement('button') },
+            { text: 'Reject All', element: document.createElement('button') },
+            { text: 'Settings', element: document.createElement('button') },
+        ];
+
+        classifyButtons(buttons);
+
+        expect(buttons.every((b) => b.regexClassification)).to.be.true;
+    });
+
+    it('classifies accept buttons', () => {
+        const buttons: ButtonData[] = [{ text: 'Accept All', element: document.createElement('button') }];
+
+        classifyButtons(buttons);
+
+        expect(rejectButtons(buttons)).to.have.length(0);
+        expect(buttons).to.have.length(1);
+        expect(buttons[0].regexClassification).to.equal('accept');
+    });
+
+    it('classifies acknowledge buttons', () => {
+        const buttons: ButtonData[] = [
+            { text: 'OK', element: document.createElement('button') },
+            { text: 'I understand', element: document.createElement('button') },
+        ];
+
+        classifyButtons(buttons);
+
+        expect(rejectButtons(buttons)).to.have.length(0);
+        expect(buttons).to.have.length(2);
+        expect(buttons.every((b) => b.regexClassification === 'acknowledge')).to.be.true;
+    });
+
+    it('classifies settings buttons', () => {
+        const buttons: ButtonData[] = [
+            { text: 'Settings', element: document.createElement('button') },
+            { text: 'Cookie preferences', element: document.createElement('button') },
+        ];
+
+        classifyButtons(buttons);
+
+        expect(rejectButtons(buttons)).to.have.length(0);
+        expect(buttons).to.have.length(2);
+        expect(buttons.every((b) => b.regexClassification === 'settings')).to.be.true;
+    });
+
+    it('classifies reject buttons with regexClassification', () => {
+        const buttons: ButtonData[] = [{ text: 'Reject All', element: document.createElement('button') }];
+
+        classifyButtons(buttons);
 
-        expect(rejectButtons).to.have.length(2);
-        expect(otherButtons).to.have.length(0);
+        expect(rejectButtons(buttons)).to.have.length(1);
+        expect(rejectButtons(buttons)[0].regexClassification).to.equal('reject');
     });
 });
 

package/tests-wtr/lifecycle/find-cmp.html

@@ -19,6 +19,20 @@
             <button>Accept All</button>
             <button>Reject All</button>
         </div>
+        <div
+            id="heuristic-popup-acknowledge-only"
+            style="position: fixed; top: 0; left: 0; width: 300px; height: 200px; background: white; display: none"
+        >
+            <p>We use cookies to improve your experience.</p>
+            <button>OK</button>
+        </div>
+        <div
+            id="heuristic-popup-accept-only"
+            style="position: fixed; top: 0; left: 0; width: 300px; height: 200px; background: white; display: none"
+        >
+            <p>We use cookies to improve your experience.</p>
+            <button>Accept All</button>
+        </div>
         <div id="onetrust-pc-sdk" style="display: none">Cookie Preference Center</div>
     </body>
 </html>

package/tests-wtr/lifecycle/find-cmp.ts

@@ -1,6 +1,7 @@
 import { expect } from '@esm-bundle/chai';
 import Autoconsent from '../../lib/web';
 import Onetrust from '../../lib/cmps/onetrust';
+import { PopupHandlingModes } from '../../lib/types';
 
 describe('Autoconsent.findCmp', () => {
     let autoconsent: Autoconsent;
@@ -145,7 +146,12 @@ describe('Autoconsent.findCmp', () => {
         });
 
         afterEach(() => {
-            document.getElementById('heuristic-popup')?.remove();
+            const heuristicPopup = document.getElementById('heuristic-popup');
+            if (heuristicPopup) {
+                heuristicPopup.style.display = '';
+            }
+            document.getElementById('heuristic-popup-acknowledge-only')!.style.display = 'none';
+            document.getElementById('heuristic-popup-accept-only')!.style.display = 'none';
         });
 
         it('returns heuristic CMP when no declarative rules match', async () => {
@@ -161,7 +167,7 @@ describe('Autoconsent.findCmp', () => {
             const found = await autoconsent.findCmp(1);
 
             expect(found).to.have.length(1);
-            expect(found[0].name).to.equal('HEURISTIC');
+            expect(found[0].name).to.equal('HEURISTIC-TIER0');
         });
 
         it('prefers declarative rules over heuristic CMP', async () => {
@@ -178,5 +184,41 @@ describe('Autoconsent.findCmp', () => {
             expect(found).to.have.length(1);
             expect(found[0].name).to.equal('test');
         });
+
+        it('returns HEURISTIC-TIER1 for acknowledge-only popup when mode is Tier1', async () => {
+            document.getElementById('heuristic-popup')!.style.display = 'none';
+            document.getElementById('heuristic-popup-acknowledge-only')!.style.display = 'block';
+
+            autoconsent = new Autoconsent((msg) => Promise.resolve(), {
+                enabled: false,
+                autoAction: null,
+                enableHeuristicAction: true,
+                heuristicMode: PopupHandlingModes.Tier1,
+            });
+            autoconsent.state.findCmpAttempts = 1;
+
+            const found = await autoconsent.findCmp(1);
+
+            expect(found).to.have.length(1);
+            expect(found[0].name).to.equal('HEURISTIC-TIER1');
+        });
+
+        it('returns HEURISTIC-TIER2 for accept-only popup when mode is Tier2', async () => {
+            document.getElementById('heuristic-popup')!.style.display = 'none';
+            document.getElementById('heuristic-popup-accept-only')!.style.display = 'block';
+
+            autoconsent = new Autoconsent((msg) => Promise.resolve(), {
+                enabled: false,
+                autoAction: null,
+                enableHeuristicAction: true,
+                heuristicMode: PopupHandlingModes.Tier2,
+            });
+            autoconsent.state.findCmpAttempts = 1;
+
+            const found = await autoconsent.findCmp(1);
+
+            expect(found).to.have.length(1);
+            expect(found[0].name).to.equal('HEURISTIC-TIER2');
+        });
     });
 });