@duckduckgo/autoconsent 14.0.1 → 14.2.0

package/tests/{cookielawinfo.spec.ts → cookie-law-info.spec.ts}

@@ -4,4 +4,7 @@ generateCMPTests('cookie-law-info', ['https://www.omas-gegen-rechts.org/', 'http
     skipRegions: ['US', 'GB'],
 });
 
-generateCMPTests('cookie-law-info', ['https://www.sbid.org/']);
+generateCMPTests('cookie-law-info', [
+    'https://www.sbid.org/',
+    'https://diroots.com/revit-plugins/renumber-revit-elements-using-a-prefix-a-suffix-and-a-multiplier-with-reordering/',
+]);

package/tests/cookiehub.spec.ts

@@ -0,0 +1,8 @@
+import generateCMPTests from '../playwright/runner';
+
+generateCMPTests('cookiehub', [
+    'https://shorthand.com/',
+    'https://www.semrush.com/',
+    'https://www.nonstopdogwear.com/en/',
+    'https://searchengineland.com/',
+]);

package/tests/eu-cookie-compliance-banner.spec.ts

@@ -1,3 +1,3 @@
 import generateCMPTests from '../playwright/runner';
 
-generateCMPTests('eu-cookie-compliance-banner', ['https://www.theposh.com/table/226', 'https://publichealth.jhu.edu/']);
+generateCMPTests('eu-cookie-compliance-banner', ['https://publichealth.jhu.edu/', 'https://bibliotheek.be/']);

package/tests-wtr/dom-actions/dom-actions.click.ts

@@ -7,10 +7,10 @@ describe('click', () => {
     let clickCounter2: number;
 
     before(() => {
-        document.querySelector('#first > button').addEventListener('click', () => {
+        document.querySelector('#first > button')?.addEventListener('click', () => {
             clickCounter1++;
         });
-        document.querySelector('#second > button').addEventListener('click', () => {
+        document.querySelector('#second > button')?.addEventListener('click', () => {
             clickCounter2++;
         });
     });
@@ -20,24 +20,24 @@ describe('click', () => {
         clickCounter2 = 0;
     });
 
-    it('clicks on a button', () => {
+    it('clicks on a button', async () => {
         // Given
         const domActions = instantiateDomActions();
 
         // When
-        const clickedSuccessfully = domActions.click('#test');
+        const clickedSuccessfully = await domActions.click('#test');
 
         // Then
         expect(clickedSuccessfully).true;
         expect(clickCounter1).to.equal(1);
     });
 
-    it('clicks all upon multiple matches when all=true', () => {
+    it('clicks all upon multiple matches when all=true', async () => {
         // Given
         const domActions = instantiateDomActions();
 
         // When
-        const clickedSuccessfully = domActions.click('button', true);
+        const clickedSuccessfully = await domActions.click('button', true);
 
         // Then
         expect(clickedSuccessfully).true;
@@ -45,12 +45,12 @@ describe('click', () => {
         expect(clickCounter2).to.equal(1);
     });
 
-    it('clicks only first one upon multiple matches when all=false', () => {
+    it('clicks only first one upon multiple matches when all=false', async () => {
         // Given
         const domActions = instantiateDomActions();
 
         // When
-        const clickedSuccessfully = domActions.click('button');
+        const clickedSuccessfully = await domActions.click('button');
 
         // Then
         expect(clickedSuccessfully).true;
@@ -58,12 +58,12 @@ describe('click', () => {
         expect(clickCounter2).to.equal(0);
     });
 
-    it('clicks by chained selector', () => {
+    it('clicks by chained selector', async () => {
         // Given
         const domActions = instantiateDomActions();
 
         // When
-        const clickedSuccessfully = domActions.click(['#second', 'button']);
+        const clickedSuccessfully = await domActions.click(['#second', 'button']);
 
         // Then
         expect(clickedSuccessfully).true;
@@ -71,12 +71,12 @@ describe('click', () => {
         expect(clickCounter2).to.equal(1);
     });
 
-    it('clicks by xpath selector', () => {
+    it('clicks by xpath selector', async () => {
         // Given
         const domActions = instantiateDomActions();
 
         // When
-        const clickedSuccessfully = domActions.click(['xpath///*[@id="second"]/button']);
+        const clickedSuccessfully = await domActions.click(['xpath///*[@id="second"]/button']);
 
         // Then
         expect(clickedSuccessfully).true;
@@ -84,7 +84,7 @@ describe('click', () => {
         expect(clickCounter2).to.equal(1);
     });
 
-    it('clicks an open shadow dom element', () => {
+    it('clicks an open shadow dom element', async () => {
         // Given
         const domActions = instantiateDomActions();
 
@@ -101,7 +101,7 @@ describe('click', () => {
         });
 
         // When
-        const clickedSuccessfully = domActions.click(['#shadow', 'button']);
+        const clickedSuccessfully = await domActions.click(['#shadow', 'button']);
 
         // Then
         expect(clickedSuccessfully).true;

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

@@ -0,0 +1,166 @@
+import { expect } from '@esm-bundle/chai';
+import { highlightNode, unhighlightNode } from '../../lib/utils.js'; // Assuming utils.ts or TS can resolve .js
+
+declare global {
+    interface HTMLElement {
+        __oldStyles?: string;
+    }
+}
+
+describe('Node highlighting', () => {
+    let testElement: HTMLElement;
+    let styleTag: HTMLStyleElement | null;
+
+    beforeEach(() => {
+        // Create a new element for each test
+        testElement = document.createElement('div');
+        document.body.appendChild(testElement);
+        // Remove the style tag if it exists from a previous test
+        styleTag = document.getElementById('autoconsent-debug-styles') as HTMLStyleElement | null;
+        if (styleTag) {
+            styleTag.remove();
+        }
+    });
+
+    afterEach(() => {
+        // Clean up the element and style tag after each test
+        if (testElement.parentNode) {
+            testElement.parentNode.removeChild(testElement);
+        }
+        styleTag = document.getElementById('autoconsent-debug-styles') as HTMLStyleElement | null;
+        if (styleTag) {
+            styleTag.remove();
+        }
+    });
+
+    describe('highlightNode', () => {
+        it('should apply highlight styles and add keyframes style tag', () => {
+            const originalCssText = testElement.style.cssText;
+            highlightNode(testElement);
+
+            // Check that style was applied (is different from original) and a style attribute exists
+            expect(testElement.style.cssText).to.not.equal(originalCssText);
+            expect(testElement.hasAttribute('style')).to.be.true;
+
+            styleTag = document.getElementById('autoconsent-debug-styles') as HTMLStyleElement;
+            expect(styleTag).to.not.be.null;
+            if (styleTag) {
+                // type guard
+                expect(styleTag.textContent).to.contain('@keyframes pulsate');
+            }
+        });
+
+        it('should store original inline styles if present', () => {
+            testElement.style.color = 'blue';
+            testElement.style.fontSize = '16px';
+            const originalCssText = testElement.style.cssText;
+
+            highlightNode(testElement);
+
+            expect(testElement.__oldStyles).to.equal(originalCssText);
+            // Check that current styles are different from original
+            expect(testElement.style.cssText).to.not.equal(originalCssText);
+        });
+
+        it('should not store original styles if no inline styles are present', () => {
+            highlightNode(testElement);
+            expect(testElement.__oldStyles).to.be.undefined;
+        });
+
+        it('should do nothing if node has no style property (e.g., not an HTMLElement)', () => {
+            const notAnElement = {} as any; // Using any here to test non-HTMLElement behavior
+            highlightNode(notAnElement);
+            // No error should be thrown, and no properties should be added.
+            expect(notAnElement.style).to.be.undefined;
+            expect(notAnElement.__oldStyles).to.be.undefined;
+
+            styleTag = document.getElementById('autoconsent-debug-styles') as HTMLStyleElement | null;
+            expect(styleTag).to.be.null; // Style tag should not be added if node.style is undefined
+        });
+
+        it('should handle elements without a pre-existing style attribute', () => {
+            highlightNode(testElement);
+            expect(testElement.hasAttribute('style')).to.be.true;
+            expect(testElement.__oldStyles).to.be.undefined; // No old styles to store
+        });
+
+        it('should handle being called twice on the same element', () => {
+            testElement.style.color = 'blue';
+            testElement.style.fontSize = '16px';
+            const originalCssText = testElement.style.cssText;
+
+            // First call
+            highlightNode(testElement);
+            expect(testElement.__oldStyles).to.equal(originalCssText);
+            const highlightCssText = testElement.style.cssText;
+
+            // Second call
+            highlightNode(testElement);
+
+            // Should preserve the original styles, not the first highlight styles
+            expect(testElement.__oldStyles).to.equal(originalCssText);
+            expect(testElement.__oldStyles).to.not.equal(highlightCssText);
+
+            // Should still be highlighted (styles should be different from original)
+            expect(testElement.style.cssText).to.not.equal(originalCssText);
+
+            // Should still be highlighted (styles should not have changed)
+            expect(testElement.style.cssText).to.equal(highlightCssText);
+
+            // Should not create a second style tag
+            expect(document.querySelectorAll('#autoconsent-debug-styles').length).to.equal(1);
+        });
+    });
+
+    describe('unhighlightNode', () => {
+        it('should remove highlight styles and restore original styles if they existed', () => {
+            testElement.style.color = 'blue';
+            const originalCssText = testElement.style.cssText;
+            highlightNode(testElement);
+            expect(testElement.__oldStyles).to.equal(originalCssText);
+            const highlightedCssText = testElement.style.cssText;
+
+            unhighlightNode(testElement);
+
+            expect(testElement.style.cssText).to.equal(originalCssText);
+            expect(testElement.style.cssText).to.not.equal(highlightedCssText);
+            expect(testElement.__oldStyles).to.be.undefined;
+        });
+
+        it('should remove style attribute if no original styles were present', () => {
+            highlightNode(testElement);
+            expect(testElement.hasAttribute('style')).to.be.true;
+            expect(testElement.__oldStyles).to.be.undefined;
+
+            unhighlightNode(testElement);
+
+            expect(testElement.hasAttribute('style')).to.be.false;
+        });
+
+        it('should do nothing if node has no style property', () => {
+            const notAnElement = {} as any; // Using any here to test non-HTMLElement behavior
+            highlightNode(notAnElement);
+            unhighlightNode(notAnElement);
+            // No error should be thrown, and no properties should be changed or added.
+            expect(notAnElement.style).to.be.undefined;
+            expect(notAnElement.__oldStyles).to.be.undefined;
+        });
+
+        it('should do nothing if node has no style attribute (e.g., highlight was not called)', () => {
+            const initialAttributes = Array.from(testElement.attributes).map((attr) => attr.name);
+            unhighlightNode(testElement);
+            const finalAttributes = Array.from(testElement.attributes).map((attr) => attr.name);
+            expect(finalAttributes).to.deep.equal(initialAttributes);
+        });
+
+        it('should do nothing if node.style exists but no style attribute is set', () => {
+            Object.defineProperty(testElement, 'hasAttribute', { value: () => false, configurable: true });
+            const initialStyleCssText = testElement.style.cssText; // Should be empty
+
+            unhighlightNode(testElement);
+
+            expect(testElement.style.cssText).to.equal(initialStyleCssText);
+            expect(testElement.__oldStyles).to.be.undefined;
+        });
+    });
+});