@yasserkhanorg/e2e-agents 0.3.2

package/dist/esm/agent/traceability_ingest.js

@@ -0,0 +1,234 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { dirname, isAbsolute, join } from 'path';
+import { normalizePath } from './utils.js';
+const DEFAULT_OPTIONS = {
+    minHits: 1,
+    maxFilesPerTest: 200,
+    maxAgeDays: 120,
+};
+function resolvePath(root, value) {
+    if (isAbsolute(value)) {
+        return value;
+    }
+    return join(root, value);
+}
+function parseDate(value) {
+    const parsed = Date.parse(value);
+    if (Number.isNaN(parsed)) {
+        return null;
+    }
+    return parsed;
+}
+function safeReadJson(path) {
+    if (!existsSync(path)) {
+        return null;
+    }
+    try {
+        return JSON.parse(readFileSync(path, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeFiles(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return Array.from(new Set(value
+        .filter((entry) => typeof entry === 'string')
+        .map((entry) => normalizePath(entry))));
+}
+function normalizeTest(value) {
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const normalized = normalizePath(value);
+    return normalized ? normalized : null;
+}
+function buildEntriesFromInput(payload) {
+    const warnings = [];
+    const entries = [];
+    const pushEntry = (testValue, filesValue, timestampValue) => {
+        const test = normalizeTest(testValue);
+        const files = normalizeFiles(filesValue);
+        if (!test || files.length === 0) {
+            return;
+        }
+        entries.push({
+            test,
+            touchedFiles: files,
+            timestamp: typeof timestampValue === 'string' ? timestampValue : undefined,
+        });
+    };
+    if (Array.isArray(payload)) {
+        for (const item of payload) {
+            if (!item || typeof item !== 'object') {
+                continue;
+            }
+            const entry = item;
+            pushEntry(entry.test, entry.touchedFiles, entry.timestamp);
+        }
+        if (entries.length === 0) {
+            warnings.push('Traceability input array had no valid entries.');
+        }
+        return { entries, warnings };
+    }
+    if (!payload || typeof payload !== 'object') {
+        warnings.push('Traceability input must be an object or array.');
+        return { entries, warnings };
+    }
+    const input = payload;
+    if (Array.isArray(input.tests)) {
+        for (const item of input.tests) {
+            pushEntry(item?.test, item?.touchedFiles, item?.timestamp);
+        }
+    }
+    if (Array.isArray(input.runs)) {
+        for (const item of input.runs) {
+            const files = Array.isArray(item?.touchedFiles) ? item?.touchedFiles : (Array.isArray(item?.coveredFiles) ? item?.coveredFiles : item?.files);
+            pushEntry(item?.test, files, item?.timestamp);
+        }
+    }
+    if (input.fileToTests && typeof input.fileToTests === 'object') {
+        for (const [file, tests] of Object.entries(input.fileToTests)) {
+            if (!Array.isArray(tests)) {
+                continue;
+            }
+            const normalizedFile = normalizePath(file);
+            for (const test of tests) {
+                pushEntry(test, [normalizedFile]);
+            }
+        }
+    }
+    if (Array.isArray(input.mappings)) {
+        for (const mapping of input.mappings) {
+            const file = typeof mapping?.file === 'string' ? normalizePath(mapping.file) : null;
+            if (!file || !Array.isArray(mapping.tests)) {
+                continue;
+            }
+            for (const test of mapping.tests) {
+                pushEntry(test, [file]);
+            }
+        }
+    }
+    if (entries.length === 0) {
+        warnings.push('Traceability input had no valid test<->file entries.');
+    }
+    return { entries, warnings };
+}
+function defaultState() {
+    return {
+        schemaVersion: '1.0.0',
+        updatedAt: new Date().toISOString(),
+        tests: {},
+    };
+}
+function loadState(path) {
+    const existing = safeReadJson(path);
+    if (!existing || typeof existing !== 'object' || !existing.tests) {
+        return defaultState();
+    }
+    return {
+        schemaVersion: '1.0.0',
+        updatedAt: existing.updatedAt || new Date().toISOString(),
+        tests: existing.tests,
+    };
+}
+function pruneByAge(state, maxAgeDays) {
+    const cutoff = Date.now() - maxAgeDays * 24 * 60 * 60 * 1000;
+    for (const [test, entry] of Object.entries(state.tests)) {
+        const lastSeen = parseDate(entry.lastSeen);
+        if (lastSeen === null) {
+            continue;
+        }
+        if (lastSeen < cutoff) {
+            delete state.tests[test];
+        }
+    }
+}
+function buildManifest(state, minHits, maxFilesPerTest) {
+    const tests = Object.entries(state.tests)
+        .map(([test, entry]) => {
+        const touchedFiles = Object.entries(entry.files)
+            .filter(([, hits]) => hits >= minHits)
+            .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))
+            .slice(0, maxFilesPerTest)
+            .map(([file]) => file);
+        const signalCount = Object.values(entry.files).reduce((acc, value) => acc + value, 0);
+        return {
+            test,
+            touchedFiles,
+            signalCount,
+            lastSeen: entry.lastSeen,
+        };
+    })
+        .filter((entry) => entry.touchedFiles.length > 0)
+        .sort((a, b) => a.test.localeCompare(b.test));
+    return {
+        schemaVersion: '1.0.0',
+        generatedAt: new Date().toISOString(),
+        tests,
+    };
+}
+function ensureParent(path) {
+    mkdirSync(dirname(path), { recursive: true });
+}
+export function ingestTraceabilityInput(rootPath, traceabilityConfig, inputPayload, options) {
+    const resolvedOptions = {
+        minHits: options?.minHits ?? DEFAULT_OPTIONS.minHits,
+        maxFilesPerTest: options?.maxFilesPerTest ?? DEFAULT_OPTIONS.maxFilesPerTest,
+        maxAgeDays: options?.maxAgeDays ?? DEFAULT_OPTIONS.maxAgeDays,
+    };
+    const warnings = [];
+    const manifestPath = resolvePath(rootPath, traceabilityConfig.manifestPath);
+    const statePath = join(dirname(manifestPath), 'traceability-state.json');
+    if (!traceabilityConfig.enabled) {
+        warnings.push('Traceability is disabled in config. Input was not ingested.');
+        return {
+            manifestPath,
+            statePath,
+            entriesIngested: 0,
+            testsTracked: 0,
+            edgesTracked: 0,
+            warnings,
+        };
+    }
+    const parsed = buildEntriesFromInput(inputPayload);
+    warnings.push(...parsed.warnings);
+    const state = loadState(statePath);
+    const now = new Date().toISOString();
+    for (const entry of parsed.entries) {
+        const bucket = state.tests[entry.test] || {
+            files: {},
+            seenCount: 0,
+            lastSeen: now,
+        };
+        bucket.seenCount += 1;
+        bucket.lastSeen = entry.timestamp || now;
+        for (const file of entry.touchedFiles) {
+            bucket.files[file] = (bucket.files[file] || 0) + 1;
+        }
+        state.tests[entry.test] = bucket;
+    }
+    pruneByAge(state, Math.max(1, resolvedOptions.maxAgeDays));
+    state.updatedAt = now;
+    const manifest = buildManifest(state, Math.max(1, resolvedOptions.minHits), Math.max(1, resolvedOptions.maxFilesPerTest));
+    let edgesTracked = 0;
+    for (const entry of manifest.tests) {
+        edgesTracked += entry.touchedFiles.length;
+    }
+    ensureParent(statePath);
+    ensureParent(manifestPath);
+    writeFileSync(statePath, JSON.stringify(state, null, 2), 'utf-8');
+    writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), 'utf-8');
+    return {
+        manifestPath,
+        statePath,
+        entriesIngested: parsed.entries.length,
+        testsTracked: manifest.tests.length,
+        edgesTracked,
+        warnings,
+    };
+}

package/dist/esm/agent/utils.js

@@ -0,0 +1,138 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+import { readFileSync, statSync } from 'fs';
+import { basename, extname, posix, relative, resolve } from 'path';
+const MAX_READ_BYTES = 1024 * 1024; // 1MB
+const STOP_WORDS = new Set([
+    'index',
+    'component',
+    'components',
+    'page',
+    'pages',
+    'screen',
+    'screens',
+    'view',
+    'views',
+    'route',
+    'routes',
+    'feature',
+    'features',
+    'module',
+    'modules',
+    'flow',
+    'flows',
+    'test',
+    'tests',
+    'spec',
+    'specs',
+    'hooks',
+    'hook',
+    'context',
+    'state',
+    'store',
+]);
+const GLOB_CHARS = /[*?[\]{}()!]/;
+export function hasGlobChars(value) {
+    return GLOB_CHARS.test(value);
+}
+export function globToRegExp(pattern) {
+    const normalized = normalizePath(pattern);
+    let regex = '^';
+    let i = 0;
+    while (i < normalized.length) {
+        const char = normalized[i];
+        if (char === '*') {
+            const next = normalized[i + 1];
+            if (next === '*') {
+                regex += '.*';
+                i += 2;
+                continue;
+            }
+            regex += '[^/]*';
+            i += 1;
+            continue;
+        }
+        if (char === '?') {
+            regex += '[^/]';
+            i += 1;
+            continue;
+        }
+        if ('\\.[]{}()+-^$|'.includes(char)) {
+            regex += `\\${char}`;
+        }
+        else {
+            regex += char;
+        }
+        i += 1;
+    }
+    regex += '$';
+    return new RegExp(regex);
+}
+export function matchGlob(pathValue, pattern) {
+    const normalizedPath = normalizePath(pathValue);
+    const normalizedPattern = normalizePath(pattern);
+    if (!hasGlobChars(normalizedPattern)) {
+        if (normalizedPattern.endsWith('/')) {
+            return normalizedPath.startsWith(normalizedPattern);
+        }
+        return normalizedPath === normalizedPattern || normalizedPath.startsWith(`${normalizedPattern}/`);
+    }
+    const regex = globToRegExp(normalizedPattern);
+    return regex.test(normalizedPath);
+}
+export function safeReadTextFile(path) {
+    try {
+        const stats = statSync(path);
+        if (stats.size > MAX_READ_BYTES) {
+            return null;
+        }
+        return readFileSync(path, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+}
+export function normalizePath(pathValue) {
+    return pathValue.split('\\').join('/');
+}
+export function toRelativePosix(root, filePath) {
+    const relative = posix.relative(normalizePath(root), normalizePath(filePath));
+    return relative.startsWith('../') ? normalizePath(filePath) : relative;
+}
+export function isPathWithinRoot(root, target) {
+    const rootAbs = resolve(root);
+    const targetAbs = resolve(target);
+    const rel = relative(rootAbs, targetAbs);
+    return rel === '' || (!rel.startsWith('..') && !rel.includes(`..${posix.sep}`) && !rel.includes('..\\'));
+}
+export function fileExtension(pathValue) {
+    return extname(pathValue).replace('.', '').toLowerCase();
+}
+export function baseNameWithoutExt(pathValue) {
+    const base = basename(pathValue);
+    const ext = extname(base);
+    return ext ? base.slice(0, -ext.length) : base;
+}
+function splitCamelCase(value) {
+    return value.replace(/([a-z])([A-Z])/g, '$1 $2');
+}
+export function tokenize(value) {
+    const normalized = splitCamelCase(value)
+        .replace(/[_\-.]/g, ' ')
+        .replace(/[^a-zA-Z0-9\s]/g, ' ')
+        .toLowerCase();
+    return normalized
+        .split(/\s+/)
+        .map((token) => token.trim())
+        .filter((token) => token.length > 2 && !STOP_WORDS.has(token));
+}
+export function uniqueTokens(tokens) {
+    return Array.from(new Set(tokens.filter(Boolean)));
+}
+export function titleCase(value) {
+    return value
+        .split(/[\s_-]+/)
+        .filter(Boolean)
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+        .join(' ');
+}

package/dist/esm/agent/validators/selector-validator.js

@@ -0,0 +1,160 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+/**
+ * SelectorValidator: Enforces whitelist matching on generated selectors
+ * Comments out unobserved selectors instead of letting tests fail randomly
+ */
+export class SelectorValidator {
+    constructor(globalSelectors, minConfidence = 50) {
+        this.whitelist = new Set();
+        this.semanticWhitelist = new Map();
+        this.minConfidence = minConfidence;
+        // Build flat whitelist from semantic map
+        for (const [semantic, elements] of Object.entries(globalSelectors)) {
+            for (const elem of elements) {
+                if (elem.confidence >= minConfidence) {
+                    this.whitelist.add(elem.selector);
+                }
+            }
+            this.semanticWhitelist.set(semantic, elements.map((e) => e.selector));
+        }
+    }
+    /**
+     * Validate a selector against the whitelist
+     */
+    validateSelector(selector) {
+        if (this.whitelist.has(selector)) {
+            return {
+                isValid: true,
+                confidence: 100,
+                reason: 'Found in whitelist',
+            };
+        }
+        // Check for similar selectors (lenient matching)
+        const normalized = this.normalizeSelector(selector);
+        for (const whitelisted of this.whitelist) {
+            if (this.normalizeSelector(whitelisted).includes(normalized)) {
+                return {
+                    isValid: true,
+                    confidence: 75,
+                    reason: 'Found similar whitelisted selector',
+                };
+            }
+        }
+        return {
+            isValid: false,
+            confidence: 0,
+            reason: 'Not found in whitelist',
+            suggestedComment: `// UNOBSERVED SELECTOR - Not found in UI map. Use test.fixme() if needed.`,
+        };
+    }
+    /**
+     * Validate and comment out invalid selectors in generated test code
+     */
+    validateTestCode(code) {
+        const results = [];
+        const selectorRegex = /page\.(getByTestId|getByLabel|getByRole|locator)\(['"`]([^'"`]+)['"`]\)/g;
+        let match;
+        while ((match = selectorRegex.exec(code)) !== null) {
+            const [fullMatch, , selector] = match;
+            const validation = this.validateSelector(selector);
+            results.push({
+                selector,
+                isWhitelisted: validation.isValid,
+                confidence: validation.confidence,
+                originalCode: fullMatch,
+                validatedCode: validation.isValid
+                    ? fullMatch
+                    : `// ${validation.suggestedComment}\n    // ${fullMatch}`,
+            });
+        }
+        return results;
+    }
+    /**
+     * Apply validation to test code, commenting out unwhitelisted selectors
+     */
+    applyValidation(code) {
+        let validated = code;
+        const results = this.validateTestCode(code);
+        // Apply in reverse order to preserve indices
+        for (const result of results.reverse()) {
+            if (!result.isWhitelisted) {
+                validated = validated.replace(result.originalCode, result.validatedCode);
+            }
+        }
+        return validated;
+    }
+    /**
+     * Get validation summary
+     */
+    getSummary(code) {
+        const results = this.validateTestCode(code);
+        const unobserved = results.filter((r) => !r.isWhitelisted).map((r) => r.selector);
+        return {
+            total: results.length,
+            whitelisted: results.filter((r) => r.isWhitelisted).length,
+            coverage: results.length > 0
+                ? Math.round((results.filter((r) => r.isWhitelisted).length / results.length) * 100)
+                : 100,
+            unobserved,
+        };
+    }
+    normalizeSelector(selector) {
+        // Normalize selector for lenient matching
+        return selector.toLowerCase().replace(/[^a-z0-9-_]/g, '');
+    }
+}
+/**
+ * APIFallbackResolver: Provides fallback strategies when UI selectors fail
+ * Converts test methods to API calls when UI elements aren't available
+ */
+export class APIFallbackResolver {
+    constructor() {
+        this.apiMapping = new Map([
+            // UI action -> API endpoint mapping
+            ['click.*button.*submit', 'POST /api/v4/posts'],
+            ['fill.*search', 'GET /api/v4/users'],
+            ['click.*profile', 'GET /api/v4/users/me'],
+            ['navigate.*channel', 'GET /api/v4/channels'],
+            ['click.*settings', 'PATCH /api/v4/users/me'],
+        ]);
+    }
+    /**
+     * Check if a test should fall back to API testing
+     */
+    shouldFallback(selector, confidence) {
+        return confidence < 50;
+    }
+    /**
+     * Generate API-based fallback for unobserved selector
+     */
+    generateAPIFallback(selector, action) {
+        // Find matching API endpoint
+        let endpoint = 'GET /api/v4/';
+        for (const [pattern, api] of this.apiMapping) {
+            if (new RegExp(pattern, 'i').test(action)) {
+                endpoint = api;
+                break;
+            }
+        }
+        return `
+    // UI selector not found - falling back to API
+    const response = await fetch(\`\${baseUrl}${endpoint.split(' ')[1]}\`, {
+        method: '${endpoint.split(' ')[0]}',
+        headers: {'Authorization': \`Bearer \${token}\`},
+    });
+    expect(response.ok).toBe(true);`;
+    }
+    /**
+     * Wrap unobserved test in try-catch with API fallback
+     */
+    wrapWithFallback(testCode) {
+        return `
+    try {
+        ${testCode}
+    } catch (error) {
+        // UI element not found - using API fallback
+        ${this.generateAPIFallback('unknown', testCode)}
+    }`;
+    }
+}