@yasserkhanorg/impact-gate 2.0.0

package/dist/esm/adapters/framework_adapter.js

@@ -0,0 +1,114 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+/**
+ * Framework Adapter Interface — abstracts test-framework-specific logic
+ * behind a uniform contract so the rest of the pipeline is framework-agnostic.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { PlaywrightAdapter } from './playwright.js';
+import { CypressAdapter } from './cypress.js';
+import { SupertestAdapter } from './supertest.js';
+import { PytestAdapter } from './pytest.js';
+/** Shared framework name lists used for test-mode detection across the codebase. */
+export const UI_FRAMEWORKS = ['playwright', '@playwright/test', 'cypress', 'selenium'];
+export const API_FRAMEWORKS = ['supertest', 'pytest', 'requests', 'vitest', 'jest'];
+/**
+ * Auto-detect which test framework a project uses by inspecting its
+ * package.json dependencies.  Falls back to Playwright when detection
+ * is inconclusive.
+ */
+export function detectFramework(projectRoot) {
+    const pkgPath = path.join(projectRoot, 'package.json');
+    if (fs.existsSync(pkgPath)) {
+        try {
+            const raw = fs.readFileSync(pkgPath, 'utf-8');
+            const pkg = JSON.parse(raw);
+            const allDeps = {
+                ...pkg.dependencies,
+                ...pkg.devDependencies,
+            };
+            if ('@playwright/test' in allDeps) {
+                return new PlaywrightAdapter();
+            }
+            if ('cypress' in allDeps) {
+                return new CypressAdapter();
+            }
+            // Backend API test frameworks
+            if ('supertest' in allDeps) {
+                const runner = 'vitest' in allDeps ? 'vitest' : 'jest';
+                return new SupertestAdapter(runner);
+            }
+        }
+        catch {
+            // Malformed package.json — fall through to default.
+        }
+    }
+    // Check for Python project
+    const pyprojectPath = path.join(projectRoot, 'pyproject.toml');
+    if (fs.existsSync(pyprojectPath)) {
+        try {
+            const content = fs.readFileSync(pyprojectPath, 'utf-8');
+            if (content.includes('pytest')) {
+                return new PytestAdapter();
+            }
+        }
+        catch {
+            // fall through
+        }
+    }
+    // Default to Playwright when we cannot determine the framework.
+    return new PlaywrightAdapter();
+}
+/**
+ * Detect the test mode for a project: UI testing, API testing, or both.
+ * Uses package.json / pyproject.toml dependencies and optional KG metadata.
+ */
+export function detectTestMode(projectRoot, kg) {
+    // If KG provides framework hints, use them
+    if (kg) {
+        const frameworks = kg.project.frameworks.map((f) => f.toLowerCase());
+        const uiSet = new Set(UI_FRAMEWORKS);
+        const apiSet = new Set(API_FRAMEWORKS);
+        const hasUi = frameworks.some((f) => uiSet.has(f));
+        const hasApi = frameworks.some((f) => apiSet.has(f));
+        if (hasUi && hasApi)
+            return 'both';
+        if (hasApi)
+            return 'api';
+        if (hasUi)
+            return 'ui';
+    }
+    // Fall back to package.json inspection
+    const pkgPath = path.join(projectRoot, 'package.json');
+    if (fs.existsSync(pkgPath)) {
+        try {
+            const raw = fs.readFileSync(pkgPath, 'utf-8');
+            const pkg = JSON.parse(raw);
+            const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+            const hasUi = '@playwright/test' in allDeps || 'cypress' in allDeps;
+            const hasApi = 'supertest' in allDeps;
+            if (hasUi && hasApi)
+                return 'both';
+            if (hasApi)
+                return 'api'; // supertest alone means API-only when no UI framework is present
+        }
+        catch {
+            // fall through
+        }
+    }
+    // Check for Python API testing
+    const pyprojectPath = path.join(projectRoot, 'pyproject.toml');
+    if (fs.existsSync(pyprojectPath)) {
+        try {
+            const content = fs.readFileSync(pyprojectPath, 'utf-8');
+            if (content.includes('pytest') && !fs.existsSync(path.join(projectRoot, 'package.json'))) {
+                return 'api';
+            }
+        }
+        catch {
+            // fall through
+        }
+    }
+    return 'ui';
+}

package/dist/esm/adapters/playwright.js

@@ -0,0 +1,49 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+/**
+ * Playwright Adapter — FrameworkAdapter implementation for @playwright/test.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+export class PlaywrightAdapter {
+    constructor() {
+        this.name = 'playwright';
+        this.specGlob = '**/*.spec.{ts,js}';
+        this.extractTestPattern = /\btest(?:\.describe)?\s*\(/g;
+        this.configFileNames = ['playwright.config.ts', 'playwright.config.js'];
+    }
+    detect(projectRoot) {
+        const pkgPath = path.join(projectRoot, 'package.json');
+        if (!fs.existsSync(pkgPath)) {
+            return false;
+        }
+        try {
+            const raw = fs.readFileSync(pkgPath, 'utf-8');
+            const pkg = JSON.parse(raw);
+            const allDeps = {
+                ...pkg.dependencies,
+                ...pkg.devDependencies,
+            };
+            return '@playwright/test' in allDeps;
+        }
+        catch {
+            return false;
+        }
+    }
+    buildRunCommand(specPath, options) {
+        const args = ['playwright', 'test', specPath];
+        if (options?.headed) {
+            args.push('--headed');
+        }
+        if (options?.browser) {
+            args.push('--browser', options.browser);
+        }
+        if (options?.project) {
+            args.push('--project', options.project);
+        }
+        if (options?.timeout != null) {
+            args.push('--timeout', String(options.timeout));
+        }
+        return { executable: 'npx', args };
+    }
+}

package/dist/esm/adapters/pytest.js

@@ -0,0 +1,59 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+/**
+ * Pytest adapter for Python API testing.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+export class PytestAdapter {
+    constructor() {
+        this.name = 'pytest';
+        this.specGlob = '**/test_*.py';
+        this.extractTestPattern = /def\s+(test_\w+)/g;
+        this.configFileNames = ['pytest.ini', 'pyproject.toml', 'setup.cfg', 'conftest.py'];
+    }
+    detect(projectRoot) {
+        // Check for common pytest indicator files
+        const indicators = ['pyproject.toml', 'pytest.ini', 'conftest.py', 'setup.cfg'];
+        for (const file of indicators) {
+            const filePath = path.join(projectRoot, file);
+            if (!fs.existsSync(filePath))
+                continue;
+            // For setup.cfg, only match if it contains a [tool:pytest] or [pytest] section
+            if (file === 'setup.cfg') {
+                try {
+                    const content = fs.readFileSync(filePath, 'utf-8');
+                    if (content.includes('[tool:pytest]') || content.includes('[pytest]')) {
+                        return true;
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            else if (file === 'pyproject.toml') {
+                try {
+                    const content = fs.readFileSync(filePath, 'utf-8');
+                    if (content.includes('pytest')) {
+                        return true;
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            else {
+                // pytest.ini or conftest.py existence is sufficient
+                return true;
+            }
+        }
+        return false;
+    }
+    buildRunCommand(specPath, options) {
+        const args = ['-m', 'pytest', specPath, '-v'];
+        if (options?.timeout) {
+            args.push(`--timeout=${Math.ceil(options.timeout / 1000)}`);
+        }
+        return { executable: 'python', args };
+    }
+}

package/dist/esm/adapters/supertest.js

@@ -0,0 +1,48 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+/**
+ * Supertest + Vitest/Jest adapter for Node.js API testing.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+export class SupertestAdapter {
+    constructor(runner = 'vitest') {
+        this.name = 'supertest';
+        this.specGlob = '**/*.{test,spec}.{ts,js}';
+        this.extractTestPattern = /(?:it|test)\s*\(\s*(['"`])(.*?)\1/g;
+        this.configFileNames = ['vitest.config.ts', 'vitest.config.js', 'jest.config.ts', 'jest.config.js'];
+        this.runner = runner;
+    }
+    detect(projectRoot) {
+        const pkgPath = path.join(projectRoot, 'package.json');
+        if (!fs.existsSync(pkgPath)) {
+            return false;
+        }
+        try {
+            const raw = fs.readFileSync(pkgPath, 'utf-8');
+            const pkg = JSON.parse(raw);
+            const allDeps = {
+                ...pkg.dependencies,
+                ...pkg.devDependencies,
+            };
+            return 'supertest' in allDeps;
+        }
+        catch {
+            return false;
+        }
+    }
+    buildRunCommand(specPath, options) {
+        if (this.runner === 'jest') {
+            const args = ['jest', specPath];
+            if (options?.timeout) {
+                args.push(`--testTimeout=${options.timeout}`);
+            }
+            return { executable: 'npx', args };
+        }
+        const args = ['vitest', 'run', specPath];
+        if (options?.timeout) {
+            args.push(`--testTimeout=${options.timeout}`);
+        }
+        return { executable: 'npx', args };
+    }
+}

package/dist/esm/agent/api_catalog.js

@@ -0,0 +1,199 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+import { existsSync, readFileSync, readdirSync } from 'fs';
+import { join } from 'path';
+export function createDefaultApiSurfaceCatalog() {
+    const pwNestedMethods = new Map();
+    pwNestedMethods.set('apiClient', new Set([
+        'createPost',
+        'createDirectChannel',
+        'createChannel',
+        'getChannels',
+        'getChannelByName',
+        'getPostsSince',
+    ]));
+    return {
+        pwProps: new Set([
+            'initSetup',
+            'testBrowser',
+            'apiInitSetup',
+            'apiAdminSetup',
+            'apiCreateChannel',
+            'apiCreateUser',
+            'apiLogin',
+            'apiClient',
+        ]),
+        pwNestedMethods,
+        initSetupKeys: new Set([
+            'user',
+            'team',
+            'adminClient',
+            'adminUser',
+            'adminConfig',
+            'userClient',
+            'offTopicUrl',
+            'townSquareUrl',
+        ]),
+        initSetupVariableMethods: new Map(),
+        testBrowserMethods: new Set([
+            'login',
+            'openNewBrowserContext',
+            'newContext',
+        ]),
+        channelsPageMembers: new Set([
+            'goto',
+            'page',
+            'postMessage',
+            'getLastPost',
+            'sidebarRight',
+            'openChannelSettings',
+            'newChannel',
+            'globalHeader',
+            'searchBox',
+        ]),
+        sidebarRightMembers: new Set([
+            'openThreadForPost',
+            'postMessage',
+            'getLastPost',
+        ]),
+    };
+}
+export function collectMatches(content, pattern) {
+    const out = new Set();
+    for (const match of content.matchAll(pattern)) {
+        const value = match[1];
+        if (value) {
+            out.add(value);
+        }
+    }
+    return out;
+}
+export function addNestedMethod(catalog, objectName, methodName) {
+    const methods = catalog.pwNestedMethods.get(objectName) || new Set();
+    methods.add(methodName);
+    catalog.pwNestedMethods.set(objectName, methods);
+}
+export function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+export function parseInitSetupBindings(content) {
+    const bindings = [];
+    for (const match of content.matchAll(/(?:const|let|var)\s*\{\s*([^}]+)\s*\}\s*=\s*await\s+pw\.initSetup\s*\(/g)) {
+        const raw = match[1];
+        if (!raw) {
+            continue;
+        }
+        for (const part of raw.split(',')) {
+            const cleaned = part.trim();
+            if (!cleaned) {
+                continue;
+            }
+            const [leftRaw, rightRaw] = cleaned.split(':');
+            const key = (leftRaw || '').trim();
+            const variableCandidate = (rightRaw || leftRaw || '').trim().split('=')[0]?.trim();
+            if (!key || !variableCandidate) {
+                continue;
+            }
+            bindings.push({ key, variable: variableCandidate });
+        }
+    }
+    return bindings;
+}
+export function collectDestructuredInitSetupKeys(content) {
+    return new Set(parseInitSetupBindings(content).map((binding) => binding.key));
+}
+export function addInitSetupVariableMethod(catalog, variable, methodName) {
+    const methods = catalog.initSetupVariableMethods.get(variable) || new Set();
+    methods.add(methodName);
+    catalog.initSetupVariableMethods.set(variable, methods);
+}
+export function collectApiSurfaceFromContent(content, catalog) {
+    for (const prop of collectMatches(content, /\bpw\.([A-Za-z_][A-Za-z0-9_]*)\b/g)) {
+        catalog.pwProps.add(prop);
+    }
+    for (const match of content.matchAll(/\bpw\.([A-Za-z_][A-Za-z0-9_]*)\.([A-Za-z_][A-Za-z0-9_]*)\b/g)) {
+        const objectName = match[1];
+        const methodName = match[2];
+        if (!objectName || !methodName) {
+            continue;
+        }
+        addNestedMethod(catalog, objectName, methodName);
+    }
+    for (const method of collectMatches(content, /\bpw\.testBrowser\.([A-Za-z_][A-Za-z0-9_]*)\b/g)) {
+        catalog.testBrowserMethods.add(method);
+    }
+    for (const member of collectMatches(content, /\bchannelsPage\.([A-Za-z_][A-Za-z0-9_]*)\b/g)) {
+        catalog.channelsPageMembers.add(member);
+    }
+    for (const member of collectMatches(content, /\bchannelsPage\.sidebarRight\.([A-Za-z_][A-Za-z0-9_]*)\b/g)) {
+        catalog.sidebarRightMembers.add(member);
+    }
+    for (const binding of parseInitSetupBindings(content)) {
+        catalog.initSetupKeys.add(binding.key);
+        const methodPattern = new RegExp(`\\b${escapeRegExp(binding.variable)}\\.([A-Za-z_][A-Za-z0-9_]*)\\b`, 'g');
+        for (const method of collectMatches(content, methodPattern)) {
+            addInitSetupVariableMethod(catalog, binding.variable, method);
+        }
+    }
+}
+export function buildApiSurfaceCatalog(testsRoot, seedFile) {
+    const catalog = createDefaultApiSurfaceCatalog();
+    const candidateRoots = [
+        join(testsRoot, 'specs'),
+        join(testsRoot, 'tests'),
+    ];
+    const files = [];
+    for (const root of candidateRoots) {
+        if (!existsSync(root)) {
+            continue;
+        }
+        const stack = [root];
+        while (stack.length > 0) {
+            const current = stack.pop();
+            let entries;
+            try {
+                entries = readdirSync(current, { withFileTypes: true });
+            }
+            catch {
+                continue;
+            }
+            for (const entry of entries) {
+                const full = join(current, entry.name);
+                if (entry.isDirectory()) {
+                    if (entry.name === 'node_modules' || entry.name === '.git' || entry.name === 'dist') {
+                        continue;
+                    }
+                    stack.push(full);
+                    continue;
+                }
+                if (!entry.isFile()) {
+                    continue;
+                }
+                if (!/\.(spec|test)\.[jt]sx?$/.test(entry.name)) {
+                    continue;
+                }
+                files.push(full);
+            }
+        }
+    }
+    const uniqueFiles = Array.from(new Set(files)).slice(0, 2500);
+    for (const filePath of uniqueFiles) {
+        try {
+            const content = readFileSync(filePath, 'utf-8');
+            collectApiSurfaceFromContent(content, catalog);
+        }
+        catch {
+            continue;
+        }
+    }
+    const absoluteSeed = join(testsRoot, seedFile);
+    if (existsSync(absoluteSeed)) {
+        try {
+            collectApiSurfaceFromContent(readFileSync(absoluteSeed, 'utf-8'), catalog);
+        }
+        catch {
+            // ignore seed read failures; defaults + catalog scan still apply
+        }
+    }
+    return catalog;
+}