npm - @testivai/witness-playwright - Versions diffs - 1.0.0 - Mend

@testivai/witness-playwright 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (61) hide show

package/__tests__/.gitkeep +0 -0
package/__tests__/config-integration.spec.ts +102 -0
package/__tests__/snapshot.spec.d.ts +1 -0
package/__tests__/snapshot.spec.js +81 -0
package/__tests__/snapshot.spec.ts +58 -0
package/__tests__/unit/ci.spec.d.ts +1 -0
package/__tests__/unit/ci.spec.js +35 -0
package/__tests__/unit/ci.spec.ts +40 -0
package/__tests__/unit/reporter.spec.d.ts +1 -0
package/__tests__/unit/reporter.spec.js +37 -0
package/__tests__/unit/reporter.spec.ts +43 -0
package/__tests__/unit/structureAnalyzer.spec.js +212 -0
package/__tests__/unit/types.spec.ts +179 -0
package/dist/__tests__/unit/ci.spec.d.ts +1 -0
package/dist/__tests__/unit/ci.spec.js +226 -0
package/dist/__tests__/unit/compression.spec.d.ts +4 -0
package/dist/__tests__/unit/compression.spec.js +46 -0
package/dist/ci.d.ts +30 -0
package/dist/ci.js +117 -0
package/dist/cli/index.d.ts +2 -0
package/dist/cli/index.js +47 -0
package/dist/cli/init.d.ts +3 -0
package/dist/cli/init.js +158 -0
package/dist/config/loader.d.ts +29 -0
package/dist/config/loader.js +251 -0
package/dist/domAnalyzer.d.ts +10 -0
package/dist/domAnalyzer.js +285 -0
package/dist/index.d.ts +7 -0
package/dist/index.js +11 -0
package/dist/reporter-entry.d.ts +2 -0
package/dist/reporter-entry.js +5 -0
package/dist/reporter-types.d.ts +2 -0
package/dist/reporter-types.js +2 -0
package/dist/reporter.d.ts +21 -0
package/dist/reporter.js +249 -0
package/dist/snapshot.d.ts +12 -0
package/dist/snapshot.js +601 -0
package/dist/structureAnalyzer.d.ts +12 -0
package/dist/structureAnalyzer.js +288 -0
package/dist/types.d.ts +368 -0
package/dist/types.js +10 -0
package/examples/structure-analysis-example.spec.ts +118 -0
package/examples/structure-analysis.config.ts +159 -0
package/jest.config.js +8 -0
package/package.json +51 -0
package/playwright.config.ts +11 -0
package/src/__tests__/unit/ci.spec.ts +257 -0
package/src/__tests__/unit/compression.spec.ts +52 -0
package/src/ci.ts +140 -0
package/src/cli/index.ts +49 -0
package/src/cli/init.ts +131 -0
package/src/config/loader.ts +238 -0
package/src/index.ts +14 -0
package/src/reporter-entry.ts +6 -0
package/src/reporter-types.ts +5 -0
package/src/reporter.ts +251 -0
package/src/snapshot.ts +632 -0
package/src/structureAnalyzer.ts +338 -0
package/src/types.ts +388 -0
package/tsconfig.jest.json +7 -0
package/tsconfig.json +20 -0

package/__tests__/.gitkeep ADDED Viewed

File without changes

package/__tests__/config-integration.spec.ts ADDED Viewed

@@ -0,0 +1,102 @@
+import { test, expect } from '@playwright/test';
+import { snapshot } from '../src/snapshot';
+import * as fs from 'fs-extra';
+import * as path from 'path';
+test.describe('Configuration Integration', () => {
+  test('loads default configuration when no config file exists', async ({ page }) => {
+    // Remove any existing config file
+    const configPath = path.join(process.cwd(), 'testivai.config.ts');
+    if (await fs.pathExists(configPath)) {
+      await fs.remove(configPath);
+    }
+    await page.goto('data:text/html,<html><body><h1>Test Page</h1></body></html>');
+    // Mock TestInfo object
+    const mockTestInfo = {
+      title: 'Configuration Test'
+    } as any;
+    // This should use default configuration
+    await snapshot(page, mockTestInfo, 'test-no-config');
+    // Check that metadata was created with default config
+    const tempDir = path.join(process.cwd(), '.testivai', 'temp');
+    const files = await fs.readdir(tempDir);
+    const metadataFile = files.find(f => f.endsWith('.json'));
+    expect(metadataFile).toBeDefined();
+    const metadata = await fs.readJson(path.join(tempDir, metadataFile!));
+    expect(metadata.testivaiConfig).toBeDefined();
+    expect(metadata.testivaiConfig.layout.sensitivity).toBe(2);
+    expect(metadata.testivaiConfig.layout.tolerance).toBe(1.0);
+    expect(metadata.testivaiConfig.ai.sensitivity).toBe(2);
+    expect(metadata.testivaiConfig.ai.confidence).toBe(0.7);
+  });
+  test('uses custom configuration when provided', async ({ page }) => {
+    await page.goto('data:text/html,<html><body><h1>Test Page</h1></body></html>');
+    // Mock TestInfo object
+    const mockTestInfo = {
+      title: 'Custom Config Test'
+    } as any;
+    // Test with custom configuration
+    const customConfig = {
+      layout: {
+        sensitivity: 0,  // Strict
+        tolerance: 0.5
+      },
+      ai: {
+        sensitivity: 4,  // Aggressive
+        confidence: 0.9
+      },
+      selectors: ['h1']
+    };
+    await snapshot(page, mockTestInfo, 'test-custom-config', customConfig);
+    // Check that metadata was created with custom config
+    const tempDir = path.join(process.cwd(), '.testivai', 'temp');
+    const files = await fs.readdir(tempDir);
+    const metadataFile = files.find(f => f.includes('test_custom_config') && f.endsWith('.json'));
+    expect(metadataFile).toBeDefined();
+    const metadata = await fs.readJson(path.join(tempDir, metadataFile!));
+    expect(metadata.testivaiConfig).toBeDefined();
+    expect(metadata.testivaiConfig.layout.sensitivity).toBe(0);
+    expect(metadata.testivaiConfig.layout.tolerance).toBe(0.5);
+    expect(metadata.testivaiConfig.ai.sensitivity).toBe(4);
+    expect(metadata.testivaiConfig.ai.confidence).toBe(0.9);
+    expect(metadata.testivaiConfig.selectors).toEqual(['h1']);
+  });
+  test('CLI generates valid configuration file', async () => {
+    // Remove existing config
+    const configPath = path.join(process.cwd(), 'testivai.config.ts');
+    if (await fs.pathExists(configPath)) {
+      await fs.remove(configPath);
+    }
+    // Run CLI init using direct file system operations
+    const { createConfigFile } = require('../dist/cli/init');
+    await createConfigFile();
+    // Verify config file was created
+    expect(await fs.pathExists(configPath)).toBe(true);
+    // Verify config file content
+    const configContent = await fs.readFile(configPath, 'utf8');
+    expect(configContent).toContain('export default');
+    expect(configContent).toContain('sensitivity: 2');
+    expect(configContent).toContain('tolerance: 1.0');
+    expect(configContent).toContain('confidence: 0.7');
+    expect(configContent).toContain('Custom Configuration Examples');
+  });
+});

package/__tests__/snapshot.spec.d.ts ADDED Viewed

	@@ -0,0 +1 @@
1	+ export {};

package/__tests__/snapshot.spec.js ADDED Viewed

@@ -0,0 +1,81 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const test_1 = require("@playwright/test");
+const fs = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+const src_1 = require("../src");
+const tempDir = path.join(process.cwd(), '.testivai', 'temp');
+test_1.test.describe('testivai.witness()', () => {
+    // Ensure the temp directory is clean before each test
+    test_1.test.beforeEach(async () => {
+        await fs.emptyDir(tempDir);
+    });
+    test_1.test.afterAll(async () => {
+        await fs.emptyDir(tempDir);
+    });
+    (0, test_1.test)('should create all evidence files for a named snapshot', async ({ page }, testInfo) => {
+        await page.setContent('<body><h1>Hello Snapshot!</h1></body>');
+        await src_1.testivai.witness(page, testInfo, 'test-snapshot');
+        const files = await fs.readdir(tempDir);
+        (0, test_1.expect)(files).toHaveLength(3);
+        const jsonFile = files.find(f => f.endsWith('.json'));
+        const htmlFile = files.find(f => f.endsWith('.html'));
+        const pngFile = files.find(f => f.endsWith('.png'));
+        (0, test_1.expect)(jsonFile, 'JSON file should exist').toBeDefined();
+        (0, test_1.expect)(htmlFile, 'HTML file should exist').toBeDefined();
+        (0, test_1.expect)(pngFile, 'PNG file should exist').toBeDefined();
+        // Verify JSON metadata content
+        const metadata = await fs.readJson(path.join(tempDir, jsonFile));
+        (0, test_1.expect)(metadata.snapshotName).toBe('test-snapshot');
+        (0, test_1.expect)(metadata.testName).toBe('should create all evidence files for a named snapshot');
+        (0, test_1.expect)(metadata.layout.body).toBeDefined();
+        (0, test_1.expect)(typeof metadata.layout.body.x).toBe('number');
+        // Verify HTML content
+        const htmlContent = await fs.readFile(path.join(tempDir, htmlFile), 'utf-8');
+        (0, test_1.expect)(htmlContent).toContain('<h1>Hello Snapshot!</h1>');
+    });
+    (0, test_1.test)('should generate a snapshot name from the URL if not provided', async ({ page }, testInfo) => {
+        // Using a data URL is a reliable way to set a page URL in a test environment
+        await page.goto('data:text/html,<h2>Page Title</h2>');
+        await src_1.testivai.witness(page, testInfo);
+        const files = await fs.readdir(tempDir);
+        const jsonFile = files.find(f => f.endsWith('.json'));
+        (0, test_1.expect)(jsonFile, 'JSON file should exist').toBeDefined();
+        const metadata = await fs.readJson(path.join(tempDir, jsonFile));
+        // The default name for a data URL or empty path is 'snapshot'
+        (0, test_1.expect)(metadata.snapshotName).toBe('snapshot');
+    });
+});

package/__tests__/snapshot.spec.ts ADDED Viewed

@@ -0,0 +1,58 @@
+import { test, expect } from '@playwright/test';
+import * as fs from 'fs-extra';
+import * as path from 'path';
+import { testivai } from '../src';
+const tempDir = path.join(process.cwd(), '.testivai', 'temp');
+test.describe('testivai.witness()', () => {
+  // Ensure the temp directory is clean before each test
+  test.beforeEach(async () => {
+    await fs.emptyDir(tempDir);
+  });
+  test.afterAll(async () => {
+    await fs.emptyDir(tempDir);
+  });
+  test('should create all evidence files for a named snapshot', async ({ page }, testInfo) => {
+    await page.setContent('<body><h1>Hello Snapshot!</h1></body>');
+    await testivai.witness(page, testInfo, 'test-snapshot');
+    const files = await fs.readdir(tempDir);
+    expect(files).toHaveLength(3);
+    const jsonFile = files.find(f => f.endsWith('.json'));
+    const htmlFile = files.find(f => f.endsWith('.html'));
+    const pngFile = files.find(f => f.endsWith('.png'));
+    expect(jsonFile, 'JSON file should exist').toBeDefined();
+    expect(htmlFile, 'HTML file should exist').toBeDefined();
+    expect(pngFile, 'PNG file should exist').toBeDefined();
+    // Verify JSON metadata content
+    const metadata = await fs.readJson(path.join(tempDir, jsonFile!));
+    expect(metadata.snapshotName).toBe('test-snapshot');
+    expect(metadata.testName).toBe('should create all evidence files for a named snapshot');
+    expect(metadata.layout.body).toBeDefined();
+    expect(typeof metadata.layout.body.x).toBe('number');
+    // Verify HTML content
+    const htmlContent = await fs.readFile(path.join(tempDir, htmlFile!), 'utf-8');
+    expect(htmlContent).toContain('<h1>Hello Snapshot!</h1>');
+  });
+  test('should generate a snapshot name from the URL if not provided', async ({ page }, testInfo) => {
+    // Using a data URL is a reliable way to set a page URL in a test environment
+    await page.goto('data:text/html,<h2>Page Title</h2>');
+    await testivai.witness(page, testInfo);
+    const files = await fs.readdir(tempDir);
+    const jsonFile = files.find(f => f.endsWith('.json'));
+    expect(jsonFile, 'JSON file should exist').toBeDefined();
+    const metadata = await fs.readJson(path.join(tempDir, jsonFile!));
+    // The default name for a data URL or empty path is 'snapshot'
+    expect(metadata.snapshotName).toBe('snapshot');
+  });
+});

package/__tests__/unit/ci.spec.d.ts ADDED Viewed

	@@ -0,0 +1 @@
1	+ export {};

package/__tests__/unit/ci.spec.js ADDED Viewed

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ci_1 = require("../../src/ci");
+describe('getCiRunId', () => {
+    const OLD_ENV = process.env;
+    beforeEach(() => {
+        jest.resetModules(); // Clears the module cache
+        // Start with a clean environment, preserving only essential vars like PATH
+        process.env = { PATH: OLD_ENV.PATH };
+    });
+    afterEach(() => {
+        process.env = OLD_ENV; // Restore original environment
+    });
+    test('should return GitHub run ID when in GitHub Actions', () => {
+        process.env.GITHUB_RUN_ID = 'github123';
+        expect((0, ci_1.getCiRunId)()).toBe('github-github123');
+    });
+    test('should return GitLab pipeline ID when in GitLab CI', () => {
+        process.env.GITLAB_CI = 'true';
+        process.env.CI_PIPELINE_ID = 'gitlab456';
+        expect((0, ci_1.getCiRunId)()).toBe('gitlab-gitlab456');
+    });
+    test('should return Jenkins build ID when in Jenkins', () => {
+        process.env.JENKINS_URL = 'http://jenkins.example.com';
+        process.env.BUILD_ID = 'jenkins789';
+        expect((0, ci_1.getCiRunId)()).toBe('jenkins-jenkins789');
+    });
+    test('should return null when not in a known CI environment', () => {
+        // Ensure no CI variables are set
+        delete process.env.GITHUB_RUN_ID;
+        delete process.env.GITLAB_CI;
+        delete process.env.JENKINS_URL;
+        expect((0, ci_1.getCiRunId)()).toBeNull();
+    });
+});

package/__tests__/unit/ci.spec.ts ADDED Viewed

@@ -0,0 +1,40 @@
+import { getCiRunId } from '../../src/ci';
+describe('getCiRunId', () => {
+  const OLD_ENV = process.env;
+  beforeEach(() => {
+    jest.resetModules(); // Clears the module cache
+    // Start with a clean environment, preserving only essential vars like PATH
+    process.env = { PATH: OLD_ENV.PATH };
+  });
+  afterEach(() => {
+    process.env = OLD_ENV; // Restore original environment
+  });
+  test('should return GitHub run ID when in GitHub Actions', () => {
+    process.env.GITHUB_RUN_ID = 'github123';
+    expect(getCiRunId()).toBe('github-github123');
+  });
+  test('should return GitLab pipeline ID when in GitLab CI', () => {
+    process.env.GITLAB_CI = 'true';
+    process.env.CI_PIPELINE_ID = 'gitlab456';
+    expect(getCiRunId()).toBe('gitlab-gitlab456');
+  });
+  test('should return Jenkins build ID when in Jenkins', () => {
+    process.env.JENKINS_URL = 'http://jenkins.example.com';
+    process.env.BUILD_ID = 'jenkins789';
+    expect(getCiRunId()).toBe('jenkins-jenkins789');
+  });
+  test('should return null when not in a known CI environment', () => {
+    // Ensure no CI variables are set
+    delete process.env.GITHUB_RUN_ID;
+    delete process.env.GITLAB_CI;
+    delete process.env.JENKINS_URL;
+    expect(getCiRunId()).toBeNull();
+  });
+});

package/__tests__/unit/reporter.spec.d.ts ADDED Viewed

	@@ -0,0 +1 @@
1	+ export {};

package/__tests__/unit/reporter.spec.js ADDED Viewed

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const reporter_1 = require("../../src/reporter");
+// Mock the module that imports Playwright-specific types.
+// This prevents a type-checking conflict within the Jest environment.
+jest.mock('../../src/reporter-types', () => ({}));
+describe('TestivAIPlaywrightReporter', () => {
+    const OLD_ENV = process.env;
+    beforeEach(() => {
+        jest.resetModules();
+        process.env = { ...OLD_ENV };
+    });
+    afterAll(() => {
+        process.env = OLD_ENV;
+    });
+    test('should initialize with API URL and key from environment variables', () => {
+        process.env.TESTIVAI_API_URL = 'http://env.api';
+        process.env.TESTIVAI_API_KEY = 'env-key';
+        const reporter = new reporter_1.TestivAIPlaywrightReporter();
+        // Accessing private options for testing purposes
+        expect(reporter.options.apiUrl).toBe('http://env.api');
+        expect(reporter.options.apiKey).toBe('env-key');
+    });
+    test('should be disabled if API URL is not provided', async () => {
+        const reporter = new reporter_1.TestivAIPlaywrightReporter();
+        // onBegin should set the apiUrl to undefined, disabling the reporter.
+        await reporter.onBegin({}, {});
+        expect(reporter.options.apiUrl).toBeUndefined();
+    });
+    test('should be disabled if API Key is not provided', async () => {
+        process.env.TESTIVAI_API_URL = 'http://env.api';
+        const reporter = new reporter_1.TestivAIPlaywrightReporter();
+        // onBegin should set the apiUrl to undefined, disabling the reporter.
+        await reporter.onBegin({}, {});
+        expect(reporter.options.apiUrl).toBeUndefined();
+    });
+});

package/__tests__/unit/reporter.spec.ts ADDED Viewed

@@ -0,0 +1,43 @@
+import { TestivAIPlaywrightReporter } from '../../src/reporter';
+// Mock the module that imports Playwright-specific types.
+// This prevents a type-checking conflict within the Jest environment.
+jest.mock('../../src/reporter-types', () => ({}));
+describe('TestivAIPlaywrightReporter', () => {
+  const OLD_ENV = process.env;
+  beforeEach(() => {
+    jest.resetModules();
+    process.env = { ...OLD_ENV };
+  });
+  afterAll(() => {
+    process.env = OLD_ENV;
+  });
+  test('should initialize with API URL and key from environment variables', () => {
+    process.env.TESTIVAI_API_URL = 'http://env.api';
+    process.env.TESTIVAI_API_KEY = 'env-key';
+    const reporter = new TestivAIPlaywrightReporter();
+    // Accessing private options for testing purposes
+    expect((reporter as any).options.apiUrl).toBe('http://env.api');
+    expect((reporter as any).options.apiKey).toBe('env-key');
+  });
+  test('should be disabled if API URL is not provided', async () => {
+    const reporter = new TestivAIPlaywrightReporter();
+    // onBegin should set the apiUrl to undefined, disabling the reporter.
+    await reporter.onBegin({} as any, {} as any);
+    expect((reporter as any).options.apiUrl).toBeUndefined();
+  });
+  test('should be disabled if API Key is not provided', async () => {
+    process.env.TESTIVAI_API_URL = 'http://env.api';
+    const reporter = new TestivAIPlaywrightReporter();
+    // onBegin should set the apiUrl to undefined, disabling the reporter.
+    await reporter.onBegin({} as any, {} as any);
+    expect((reporter as any).options.apiUrl).toBeUndefined();
+  });
+});

package/__tests__/unit/structureAnalyzer.spec.js ADDED Viewed

@@ -0,0 +1,212 @@
+/**
+ * @jest-environment node
+ *
+ * Tests for the renamed Structure Analyzer module.
+ * @renamed Was `domAnalyzer.spec.js` — renamed to match the new public API (IP protection)
+ *
+ * Terminology mapping:
+ *   analyzeDOM()          → analyzeStructure()
+ *   compareDOMAnalysis()  → compareStructureAnalysis()
+ *   DOMAnalysis           → StructureAnalysis
+ *   DOMChange             → StructureChange
+ *   DOMAnalysisConfig     → StructureAnalysisConfig
+ */
+describe('Structure Analyzer', () => {
+  // Mock the page.evaluate method for testing
+  const mockPage = {
+    evaluate: jest.fn(),
+  };
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+  test('analyzeStructure() should generate structure fingerprint and analysis', async () => {
+    // Mock the page.evaluate to return structure analysis
+    mockPage.evaluate.mockResolvedValue({
+      fingerprint: 'dGVzdCBmaW5nZXJwcmludA==', // base64 encoded
+      structure: {
+        totalElements: 10,
+        elementTypes: { html: 1, body: 1, div: 3, p: 2, button: 1 },
+        maxDepth: 3,
+        interactiveElements: {
+          buttons: 1,
+          inputs: 0,
+          links: 0,
+          forms: 0,
+        },
+      },
+      semantic: {
+        headings: { h1: 0, h2: 0, h3: 0, h4: 0, h5: 0, h6: 0 },
+        landmarks: {
+          hasHeader: false,
+          hasNav: false,
+          hasMain: false,
+          hasFooter: false,
+          hasAside: false,
+        },
+        lists: { ordered: 0, unordered: 0 },
+        tables: 0,
+        images: 0,
+      },
+    });
+    const { analyzeStructure } = require('../../src/structureAnalyzer');
+    const result = await analyzeStructure(mockPage, {
+      enableFingerprint: true,
+      enableStructure: true,
+      enableSemantic: true,
+    });
+    expect(result.fingerprint).toBe('dGVzdCBmaW5nZXJwcmludA==');
+    expect(result.structure.totalElements).toBe(10);
+    expect(result.semantic.headings.h1).toBe(0);
+  });
+  test('compareStructureAnalysis() should detect changes between baseline and current', () => {
+    const { compareStructureAnalysis } = require('../../src/structureAnalyzer');
+    const baseline = {
+      fingerprint: 'abc123',
+      structure: {
+        totalElements: 10,
+        elementTypes: { div: 3, p: 2 },
+      },
+      semantic: {
+        headings: { h1: 1, h2: 2 },
+        landmarks: { hasHeader: true, hasNav: false },
+      },
+    };
+    const current = {
+      fingerprint: 'def456',
+      structure: {
+        totalElements: 12,
+        elementTypes: { div: 3, p: 2, span: 2 },
+      },
+      semantic: {
+        headings: { h1: 1, h2: 2 },
+        landmarks: { hasHeader: true, hasNav: true },
+      },
+    };
+    const changes = compareStructureAnalysis(baseline, current);
+    expect(changes.length).toBeGreaterThanOrEqual(3);
+    expect(changes[0].type).toBe('fingerprint');
+    expect(changes[0].severity).toBe('high');
+    expect(changes.some(c => c.type === 'structure')).toBe(true);
+    expect(changes.some(c => c.type === 'semantic')).toBe(true);
+  });
+  test('analyzeStructure() should handle empty configuration', async () => {
+    mockPage.evaluate.mockResolvedValue({
+      fingerprint: 'base64hash',
+    });
+    const { analyzeStructure } = require('../../src/structureAnalyzer');
+    const result = await analyzeStructure(mockPage);
+    expect(result.fingerprint).toBe('base64hash');
+    expect(mockPage.evaluate).toHaveBeenCalled();
+  });
+  test('compareStructureAnalysis() should return empty array when analyses are identical', () => {
+    const { compareStructureAnalysis } = require('../../src/structureAnalyzer');
+    const analysis = {
+      fingerprint: 'same_hash',
+      structure: {
+        totalElements: 5,
+        elementTypes: { div: 3, p: 2 },
+      },
+      semantic: {
+        headings: { h1: 1 },
+        landmarks: { hasHeader: true, hasNav: false },
+      },
+    };
+    const changes = compareStructureAnalysis(analysis, analysis);
+    expect(changes.length).toBe(0);
+  });
+  test('compareStructureAnalysis() should detect fingerprint-only changes', () => {
+    const { compareStructureAnalysis } = require('../../src/structureAnalyzer');
+    const baseline = { fingerprint: 'hash_a' };
+    const current = { fingerprint: 'hash_b' };
+    const changes = compareStructureAnalysis(baseline, current);
+    expect(changes.length).toBe(1);
+    expect(changes[0].type).toBe('fingerprint');
+    expect(changes[0].severity).toBe('high');
+    expect(changes[0].description).toBe('Page structure has changed');
+  });
+  test('compareStructureAnalysis() should detect removed element types', () => {
+    const { compareStructureAnalysis } = require('../../src/structureAnalyzer');
+    const baseline = {
+      structure: {
+        totalElements: 10,
+        elementTypes: { div: 3, p: 2, span: 1 },
+      },
+    };
+    const current = {
+      structure: {
+        totalElements: 9,
+        elementTypes: { div: 3, p: 2 },
+      },
+    };
+    const changes = compareStructureAnalysis(baseline, current);
+    expect(changes.some(c => c.description.includes('Removed element types: span'))).toBe(true);
+  });
+  test('compareStructureAnalysis() should detect added element types', () => {
+    const { compareStructureAnalysis } = require('../../src/structureAnalyzer');
+    const baseline = {
+      structure: {
+        totalElements: 5,
+        elementTypes: { div: 3 },
+      },
+    };
+    const current = {
+      structure: {
+        totalElements: 7,
+        elementTypes: { div: 3, button: 2 },
+      },
+    };
+    const changes = compareStructureAnalysis(baseline, current);
+    expect(changes.some(c => c.description.includes('Added element types: button'))).toBe(true);
+  });
+  test('compareStructureAnalysis() should detect landmark changes', () => {
+    const { compareStructureAnalysis } = require('../../src/structureAnalyzer');
+    const baseline = {
+      semantic: {
+        headings: {},
+        landmarks: { hasHeader: false, hasNav: false },
+      },
+    };
+    const current = {
+      semantic: {
+        headings: {},
+        landmarks: { hasHeader: true, hasNav: false },
+      },
+    };
+    const changes = compareStructureAnalysis(baseline, current);
+    expect(changes.some(c => c.type === 'semantic' && c.description.includes('hasHeader'))).toBe(true);
+  });
+  test('structureAnalyzer exports are available (old domAnalyzer deleted)', () => {
+    const mod = require('../../src/structureAnalyzer');
+    expect(typeof mod.analyzeStructure).toBe('function');
+    expect(typeof mod.compareStructureAnalysis).toBe('function');
+  });
+});