@afixt/test-utils 1.2.0 → 1.2.1

package/test/playwright/css-pseudo-elements.spec.js

@@ -9,19 +9,18 @@ const { test, expect } = require('@playwright/test');
 const path = require('path');
 
 test.describe('CSS Pseudo-element Support', () => {
-  test.beforeEach(async ({ page }) => {
-    // Load the test fixture HTML
-    const fixturePath = path.join(__dirname, 'fixtures', 'css-pseudo-elements.html');
-    await page.goto(`file://${fixturePath}`);
-
-    // Inject the functions into the page
-    await page.addScriptTag({
-      content: `
-        // Fix getComputedStyle usage and make it work in browser
+    test.beforeEach(async ({ page }) => {
+        // Load the test fixture HTML
+        const fixturePath = path.join(__dirname, 'fixtures', 'css-pseudo-elements.html');
+        await page.goto(`file://${fixturePath}`);
+
+        // Inject the functions into the page
+        await page.addScriptTag({
+            content: `
+        // getGeneratedContent: includes textContent alongside pseudo-element content
         function getGeneratedContent(el) {
           if (!el) return false;
 
-          // Get pseudo-element content properly
           const beforeStyle = window.getComputedStyle(el, '::before');
           const afterStyle = window.getComputedStyle(el, '::after');
 
@@ -29,11 +28,9 @@ test.describe('CSS Pseudo-element Support', () => {
           let after = afterStyle.getPropertyValue('content') || '';
           const inner = el.textContent || '';
 
-          // Remove quotes from CSS content values
           before = before.replace(/^["']|["']$/g, '');
           after = after.replace(/^["']|["']$/g, '');
 
-          // Filter out 'none' values
           if (before === 'none') before = '';
           if (after === 'none') after = '';
 
@@ -41,115 +38,251 @@ test.describe('CSS Pseudo-element Support', () => {
           return result || false;
         }
 
+        // extractMeaningfulContent: helper for getCSSGeneratedContent
+        function extractMeaningfulContent(rawValue) {
+          if (!rawValue || rawValue === 'none' || rawValue === 'normal') {
+            return false;
+          }
+          let cleaned = rawValue.replace(/^["'](.*)["']$/, '$1');
+          cleaned = cleaned.trim();
+          return cleaned.length > 0 ? cleaned : false;
+        }
+
+        // getCSSGeneratedContent: only checks ::before and ::after pseudo-elements
+        function getCSSGeneratedContent(el, pseudoElement) {
+          if (pseudoElement === undefined) pseudoElement = 'both';
+          if (!el) return false;
+
+          let content = '';
+
+          try {
+            if (pseudoElement === 'before' || pseudoElement === 'both') {
+              const style = window.getComputedStyle(el, '::before');
+              const before = style.getPropertyValue('content');
+              const cleanBefore = extractMeaningfulContent(before);
+              if (cleanBefore) {
+                content += cleanBefore;
+              }
+            }
+
+            if (pseudoElement === 'after' || pseudoElement === 'both') {
+              const style = window.getComputedStyle(el, '::after');
+              const after = style.getPropertyValue('content');
+              const cleanAfter = extractMeaningfulContent(after);
+              if (cleanAfter) {
+                content += (content ? ' ' : '') + cleanAfter;
+              }
+            }
+          } catch (e) {
+            return false;
+          }
+
+          return content ? content.trim() : false;
+        }
+
         function hasCSSGeneratedContent(el) {
           if (!el) return false;
-          const content = getGeneratedContent(el);
+          const content = getCSSGeneratedContent(el);
           return content !== false;
         }
 
         // Make functions globally available
         window.getGeneratedContent = getGeneratedContent;
+        window.getCSSGeneratedContent = getCSSGeneratedContent;
         window.hasCSSGeneratedContent = hasCSSGeneratedContent;
-      `
+      `,
+        });
     });
-  });
 
-  test.describe('getGeneratedContent', () => {
-    test('should return ::before content when present', async ({ page }) => {
-      const result = await page.evaluate(() => {
-        const element = document.getElementById('with-before');
-        return window.getGeneratedContent(element);
-      });
+    test.describe('getGeneratedContent', () => {
+        test('should return ::before content when present', async ({ page }) => {
+            const result = await page.evaluate(() => {
+                const element = document.getElementById('with-before');
+                return window.getGeneratedContent(element);
+            });
 
-      expect(result).toContain('Before Content');
-    });
+            expect(result).toContain('Before Content');
+        });
 
-    test('should return ::after content when present', async ({ page }) => {
-      const result = await page.evaluate(() => {
-        const element = document.getElementById('with-after');
-        return window.getGeneratedContent(element);
-      });
+        test('should return ::after content when present', async ({ page }) => {
+            const result = await page.evaluate(() => {
+                const element = document.getElementById('with-after');
+                return window.getGeneratedContent(element);
+            });
 
-      expect(result).toContain('After Content');
-    });
+            expect(result).toContain('After Content');
+        });
 
-    test('should combine ::before, text content, and ::after', async ({ page }) => {
-      const result = await page.evaluate(() => {
-        const element = document.getElementById('with-both');
-        return window.getGeneratedContent(element);
-      });
+        test('should combine ::before, text content, and ::after', async ({ page }) => {
+            const result = await page.evaluate(() => {
+                const element = document.getElementById('with-both');
+                return window.getGeneratedContent(element);
+            });
 
-      expect(result).toContain('Before');
-      expect(result).toContain('Text Content');
-      expect(result).toContain('After');
-    });
+            expect(result).toContain('Before');
+            expect(result).toContain('Text Content');
+            expect(result).toContain('After');
+        });
 
-    test('should handle quoted content values in CSS', async ({ page }) => {
-      const result = await page.evaluate(() => {
-        const element = document.getElementById('with-quotes');
-        return window.getGeneratedContent(element);
-      });
+        test('should handle quoted content values in CSS', async ({ page }) => {
+            const result = await page.evaluate(() => {
+                const element = document.getElementById('with-quotes');
+                return window.getGeneratedContent(element);
+            });
 
-      expect(result).toBeTruthy();
-      expect(result).toContain('Quoted');
-    });
+            expect(result).toBeTruthy();
+            expect(result).toContain('Quoted');
+        });
 
-    test('should handle CSS content with special characters', async ({ page }) => {
-      const result = await page.evaluate(() => {
-        const element = document.getElementById('with-special-chars');
-        return window.getGeneratedContent(element);
-      });
+        test('should handle CSS content with special characters', async ({ page }) => {
+            const result = await page.evaluate(() => {
+                const element = document.getElementById('with-special-chars');
+                return window.getGeneratedContent(element);
+            });
 
-      expect(result).toBeTruthy();
-    });
+            expect(result).toBeTruthy();
+        });
 
-    test('should trim whitespace from the combined result', async ({ page }) => {
-      const result = await page.evaluate(() => {
-        const element = document.getElementById('with-whitespace');
-        return window.getGeneratedContent(element);
-      });
+        test('should trim whitespace from the combined result', async ({ page }) => {
+            const result = await page.evaluate(() => {
+                const element = document.getElementById('with-whitespace');
+                return window.getGeneratedContent(element);
+            });
 
-      expect(result).toBeTruthy();
-      expect(result.startsWith(' ')).toBe(false);
-      expect(result.endsWith(' ')).toBe(false);
-    });
+            expect(result).toBeTruthy();
+            expect(result.startsWith(' ')).toBe(false);
+            expect(result.endsWith(' ')).toBe(false);
+        });
 
-    test('should handle nested elements with generated content', async ({ page }) => {
-      const result = await page.evaluate(() => {
-        const element = document.getElementById('nested-content');
-        return window.getGeneratedContent(element);
-      });
+        test('should handle nested elements with generated content', async ({ page }) => {
+            const result = await page.evaluate(() => {
+                const element = document.getElementById('nested-content');
+                return window.getGeneratedContent(element);
+            });
 
-      expect(result).toBeTruthy();
-    });
+            expect(result).toBeTruthy();
+        });
 
-    test('should handle content with HTML entities in CSS', async ({ page }) => {
-      const result = await page.evaluate(() => {
-        const element = document.getElementById('with-entities');
-        return window.getGeneratedContent(element);
-      });
+        test('should handle content with HTML entities in CSS', async ({ page }) => {
+            const result = await page.evaluate(() => {
+                const element = document.getElementById('with-entities');
+                return window.getGeneratedContent(element);
+            });
 
-      expect(result).toBeTruthy();
+            expect(result).toBeTruthy();
+        });
     });
-  });
 
-  test.describe('hasCSSGeneratedContent', () => {
-    test('should correctly identify elements with ::before content', async ({ page }) => {
-      const result = await page.evaluate(() => {
-        const element = document.getElementById('with-before');
-        return window.hasCSSGeneratedContent(element);
-      });
+    test.describe('getCSSGeneratedContent', () => {
+        test('should get ::before content', async ({ page }) => {
+            const result = await page.evaluate(() => {
+                const element = document.getElementById('with-before');
+                return window.getCSSGeneratedContent(element, 'before');
+            });
+
+            expect(result).toBe('Before Content');
+        });
+
+        test('should get ::after content', async ({ page }) => {
+            const result = await page.evaluate(() => {
+                const element = document.getElementById('with-after');
+                return window.getCSSGeneratedContent(element, 'after');
+            });
 
-      expect(result).toBe(true);
+            expect(result).toBe('After Content');
+        });
+
+        test('should get both ::before and ::after content', async ({ page }) => {
+            const result = await page.evaluate(() => {
+                const element = document.getElementById('with-both');
+                return window.getCSSGeneratedContent(element);
+            });
+
+            expect(result).toContain('Before');
+            expect(result).toContain('After');
+        });
+
+        test('should handle quoted content', async ({ page }) => {
+            const result = await page.evaluate(() => {
+                const element = document.getElementById('with-quotes');
+                return window.getCSSGeneratedContent(element, 'before');
+            });
+
+            expect(result).toBeTruthy();
+            expect(result).toContain('Quoted');
+        });
+
+        test('should handle URL content', async ({ page }) => {
+            const result = await page.evaluate(() => {
+                const element = document.getElementById('url-content');
+                return window.getCSSGeneratedContent(element, 'before');
+            });
+
+            expect(result).toBeTruthy();
+        });
+
+        test('should default pseudoElement to both', async ({ page }) => {
+            const result = await page.evaluate(() => {
+                const element = document.getElementById('with-before');
+                return window.getCSSGeneratedContent(element);
+            });
+
+            expect(result).toBe('Before Content');
+        });
+
+        test('should return false for empty content', async ({ page }) => {
+            const result = await page.evaluate(() => {
+                const element = document.getElementById('empty-content');
+                return window.getCSSGeneratedContent(element);
+            });
+
+            expect(result).toBe(false);
+        });
+
+        test('should return false for content: none', async ({ page }) => {
+            const result = await page.evaluate(() => {
+                const element = document.getElementById('no-content');
+                return window.getCSSGeneratedContent(element);
+            });
+
+            expect(result).toBe(false);
+        });
+
+        test('should return false for null element', async ({ page }) => {
+            const result = await page.evaluate(() => {
+                return window.getCSSGeneratedContent(null);
+            });
+
+            expect(result).toBe(false);
+        });
+
+        test('should return false for elements with no pseudo-element styles', async ({ page }) => {
+            const result = await page.evaluate(() => {
+                const element = document.getElementById('plain-div');
+                return window.getCSSGeneratedContent(element);
+            });
+
+            expect(result).toBe(false);
+        });
     });
 
-    test('should correctly identify elements with ::after content', async ({ page }) => {
-      const result = await page.evaluate(() => {
-        const element = document.getElementById('with-after');
-        return window.hasCSSGeneratedContent(element);
-      });
+    test.describe('hasCSSGeneratedContent', () => {
+        test('should correctly identify elements with ::before content', async ({ page }) => {
+            const result = await page.evaluate(() => {
+                const element = document.getElementById('with-before');
+                return window.hasCSSGeneratedContent(element);
+            });
+
+            expect(result).toBe(true);
+        });
+
+        test('should correctly identify elements with ::after content', async ({ page }) => {
+            const result = await page.evaluate(() => {
+                const element = document.getElementById('with-after');
+                return window.hasCSSGeneratedContent(element);
+            });
 
-      expect(result).toBe(true);
+            expect(result).toBe(true);
+        });
     });
-  });
 });

package/test/playwright/fixtures/css-pseudo-elements.html

@@ -52,6 +52,10 @@
     #no-content::before {
       content: none;
     }
+
+    #url-content::before {
+      content: url('data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7');
+    }
   </style>
 </head>
 <body>
@@ -67,6 +71,8 @@
   <div id="with-entities">Entities</div>
   <div id="empty-content">Empty</div>
   <div id="no-content">None</div>
+  <div id="url-content">URL Content</div>
+  <div id="plain-div">Plain div no pseudo-elements</div>
 
   <!-- Load the functions we need directly in the page -->
   <script type="module">

package/test/stringUtils.test.js

@@ -423,4 +423,226 @@ describe('stringUtils', () => {
             expect(typeof result).toBe('string');
         });
     });
+
+    describe('isEmptyOrWhitespace', () => {
+        it('should return true for null/undefined/empty', () => {
+            expect(stringUtils.isEmptyOrWhitespace(null)).toBe(true);
+            expect(stringUtils.isEmptyOrWhitespace(undefined)).toBe(true);
+            expect(stringUtils.isEmptyOrWhitespace('')).toBe(true);
+        });
+
+        it('should return true for whitespace-only strings', () => {
+            expect(stringUtils.isEmptyOrWhitespace('   ')).toBe(true);
+            expect(stringUtils.isEmptyOrWhitespace('\t\n')).toBe(true);
+        });
+
+        it('should return true for strings with zero-width spaces', () => {
+            expect(stringUtils.isEmptyOrWhitespace('\u200B')).toBe(true);
+            expect(stringUtils.isEmptyOrWhitespace('\u200C')).toBe(true);
+            expect(stringUtils.isEmptyOrWhitespace('\u200D')).toBe(true);
+            expect(stringUtils.isEmptyOrWhitespace('\uFEFF')).toBe(true);
+            expect(stringUtils.isEmptyOrWhitespace('\u2060')).toBe(true);
+        });
+
+        it('should return true for non-breaking spaces only', () => {
+            expect(stringUtils.isEmptyOrWhitespace('\u00A0')).toBe(true);
+        });
+
+        it('should return false for strings with visible characters', () => {
+            expect(stringUtils.isEmptyOrWhitespace('hello')).toBe(false);
+            expect(stringUtils.isEmptyOrWhitespace(' a ')).toBe(false);
+            expect(stringUtils.isEmptyOrWhitespace('\u200Bx')).toBe(false);
+        });
+    });
+
+    describe('isGenericTitle', () => {
+        it('should return true for known generic titles', () => {
+            expect(stringUtils.isGenericTitle('iframe')).toBe(true);
+            expect(stringUtils.isGenericTitle('frame')).toBe(true);
+            expect(stringUtils.isGenericTitle('untitled')).toBe(true);
+            expect(stringUtils.isGenericTitle('title')).toBe(true);
+            expect(stringUtils.isGenericTitle('content')).toBe(true);
+            expect(stringUtils.isGenericTitle('main')).toBe(true);
+            expect(stringUtils.isGenericTitle('page')).toBe(true);
+        });
+
+        it('should be case-insensitive', () => {
+            expect(stringUtils.isGenericTitle('IFRAME')).toBe(true);
+            expect(stringUtils.isGenericTitle('Untitled')).toBe(true);
+            expect(stringUtils.isGenericTitle('TITLE')).toBe(true);
+        });
+
+        it('should match numbered variants', () => {
+            expect(stringUtils.isGenericTitle('frame1')).toBe(true);
+            expect(stringUtils.isGenericTitle('iframe2')).toBe(true);
+            expect(stringUtils.isGenericTitle('untitled3')).toBe(true);
+            expect(stringUtils.isGenericTitle('title42')).toBe(true);
+        });
+
+        it('should return false for descriptive titles', () => {
+            expect(stringUtils.isGenericTitle('Contact Form')).toBe(false);
+            expect(stringUtils.isGenericTitle('Product Details')).toBe(false);
+            expect(stringUtils.isGenericTitle('Navigation Menu')).toBe(false);
+        });
+
+        it('should return false for null/undefined', () => {
+            expect(stringUtils.isGenericTitle(null)).toBe(false);
+            expect(stringUtils.isGenericTitle(undefined)).toBe(false);
+        });
+
+        it('should trim whitespace', () => {
+            expect(stringUtils.isGenericTitle('  iframe  ')).toBe(true);
+        });
+    });
+
+    describe('isGenericLinkText', () => {
+        it('should return true for common generic link text', () => {
+            expect(stringUtils.isGenericLinkText('click here')).toBe(true);
+            expect(stringUtils.isGenericLinkText('here')).toBe(true);
+            expect(stringUtils.isGenericLinkText('more')).toBe(true);
+            expect(stringUtils.isGenericLinkText('read more')).toBe(true);
+            expect(stringUtils.isGenericLinkText('learn more')).toBe(true);
+            expect(stringUtils.isGenericLinkText('link')).toBe(true);
+        });
+
+        it('should be case-insensitive', () => {
+            expect(stringUtils.isGenericLinkText('Click Here')).toBe(true);
+            expect(stringUtils.isGenericLinkText('READ MORE')).toBe(true);
+            expect(stringUtils.isGenericLinkText('LEARN MORE')).toBe(true);
+        });
+
+        it('should return false for descriptive text', () => {
+            expect(stringUtils.isGenericLinkText('View product details')).toBe(false);
+            expect(stringUtils.isGenericLinkText('Download annual report')).toBe(false);
+        });
+
+        it('should return false for null/undefined', () => {
+            expect(stringUtils.isGenericLinkText(null)).toBe(false);
+            expect(stringUtils.isGenericLinkText(undefined)).toBe(false);
+        });
+
+        it('should support custom generic list', () => {
+            const custom = ['foo', 'bar'];
+            expect(stringUtils.isGenericLinkText('foo', custom)).toBe(true);
+            expect(stringUtils.isGenericLinkText('bar', custom)).toBe(true);
+            expect(stringUtils.isGenericLinkText('click here', custom)).toBe(false);
+        });
+
+        it('should trim whitespace', () => {
+            expect(stringUtils.isGenericLinkText('  here  ')).toBe(true);
+        });
+    });
+
+    describe('getActualVisibleText', () => {
+        it('should return empty string for null/undefined', () => {
+            expect(stringUtils.getActualVisibleText(null)).toBe('');
+            expect(stringUtils.getActualVisibleText(undefined)).toBe('');
+        });
+
+        it('should return text content of element', () => {
+            const el = document.createElement('span');
+            el.textContent = 'Hello World';
+            expect(stringUtils.getActualVisibleText(el)).toBe('Hello World');
+        });
+
+        it('should trim whitespace', () => {
+            const el = document.createElement('span');
+            el.textContent = '  Hello  ';
+            expect(stringUtils.getActualVisibleText(el)).toBe('Hello');
+        });
+
+        it('should return empty string for empty element', () => {
+            const el = document.createElement('div');
+            expect(stringUtils.getActualVisibleText(el)).toBe('');
+        });
+
+        it('should include nested text content', () => {
+            const el = document.createElement('div');
+            el.innerHTML = '<span>Nested</span> text';
+            expect(stringUtils.getActualVisibleText(el)).toBe('Nested text');
+        });
+    });
+
+    describe('hasNewWindowWarning', () => {
+        it('should return true for text containing "new window"', () => {
+            expect(stringUtils.hasNewWindowWarning('Opens in a new window')).toBe(true);
+        });
+
+        it('should return true for text containing "new tab"', () => {
+            expect(stringUtils.hasNewWindowWarning('Opens in new tab')).toBe(true);
+        });
+
+        it('should return true for "opens in new" variant', () => {
+            expect(stringUtils.hasNewWindowWarning('Link opens in new browser window')).toBe(true);
+        });
+
+        it('should return true for "external link"', () => {
+            expect(stringUtils.hasNewWindowWarning('External link to resource')).toBe(true);
+        });
+
+        it('should return true for "external site"', () => {
+            expect(stringUtils.hasNewWindowWarning('Goes to external site')).toBe(true);
+        });
+
+        it('should be case-insensitive', () => {
+            expect(stringUtils.hasNewWindowWarning('Opens In A New Window')).toBe(true);
+            expect(stringUtils.hasNewWindowWarning('EXTERNAL LINK')).toBe(true);
+        });
+
+        it('should return false for text without warning', () => {
+            expect(stringUtils.hasNewWindowWarning('Contact us')).toBe(false);
+            expect(stringUtils.hasNewWindowWarning('Read the article')).toBe(false);
+        });
+
+        it('should return false for null/undefined', () => {
+            expect(stringUtils.hasNewWindowWarning(null)).toBe(false);
+            expect(stringUtils.hasNewWindowWarning(undefined)).toBe(false);
+        });
+    });
+
+    describe('textIncludingImgAlt', () => {
+        it('should return text content from text nodes', () => {
+            const el = document.createElement('div');
+            el.textContent = 'Hello World';
+            expect(stringUtils.textIncludingImgAlt(el).trim()).toBe('Hello World');
+        });
+
+        it('should include img alt text', () => {
+            const el = document.createElement('div');
+            el.innerHTML = 'Text <img alt="photo"> more text';
+            const result = stringUtils.textIncludingImgAlt(el);
+            expect(result).toContain('Text');
+            expect(result).toContain('photo');
+            expect(result).toContain('more text');
+        });
+
+        it('should handle img without alt', () => {
+            const el = document.createElement('div');
+            el.innerHTML = 'Text <img src="img.png"> more';
+            const result = stringUtils.textIncludingImgAlt(el);
+            expect(result).toContain('Text');
+            expect(result).toContain('more');
+        });
+
+        it('should not include aria-label text', () => {
+            const el = document.createElement('div');
+            el.innerHTML = '<button aria-label="Close">X</button>';
+            const result = stringUtils.textIncludingImgAlt(el);
+            expect(result).toContain('X');
+            expect(result).not.toContain('Close');
+        });
+
+        it('should handle empty element', () => {
+            const el = document.createElement('div');
+            expect(stringUtils.textIncludingImgAlt(el)).toBe('');
+        });
+
+        it('should concatenate text from nested elements', () => {
+            const el = document.createElement('div');
+            el.innerHTML = '<span>First</span> <span>Second</span>';
+            const result = stringUtils.textIncludingImgAlt(el);
+            expect(result).toContain('First');
+            expect(result).toContain('Second');
+        });
+    });
 });