@browserstack/mcp-server 1.2.2-beta → 1.2.2-beta.1

package/dist/tools/percy-snapshot-utils/constants.js

@@ -0,0 +1,500 @@
+import { z } from "zod";
+import { SDKSupportedLanguages, SDKSupportedTestingFrameworks, } from "../sdk-utils/common/types.js";
+export const UpdateTestFileWithInstructionsParams = {
+    uuid: z
+        .string()
+        .describe("UUID referencing the in-memory array of test file paths"),
+    index: z.number().describe("Index of the test file to update"),
+};
+export const ListTestFilesParamsShape = {
+    dirs: z
+        .array(z.string())
+        .describe("Array of directory paths to search for test files"),
+    language: z
+        .enum(SDKSupportedLanguages)
+        .describe("Programming language"),
+    framework: z
+        .enum(SDKSupportedTestingFrameworks)
+        .describe("Testing framework (optional)"),
+};
+export const TEST_FILE_DETECTION = {
+    java: {
+        extensions: [".java"],
+        namePatterns: [
+            /Test\.java$/,
+            /Tests\.java$/,
+            /Steps\.java$/,
+            /.*UI.*Test\.java$/,
+            /.*Web.*Test\.java$/,
+            /.*E2E.*Test\.java$/,
+            /.*Integration.*Test\.java$/,
+            /.*Functional.*Test\.java$/,
+        ],
+        contentRegex: [
+            /@Test\b/,
+            /@RunWith\b/,
+            /@CucumberOptions\b/,
+            /import\s+org\.junit/,
+            /import\s+org\.testng/,
+            /import\s+io\.cucumber/,
+            /import\s+org\.jbehave/,
+        ],
+        uiDriverRegex: [
+            /import\s+org\.openqa\.selenium/,
+            /import\s+org\.seleniumhq\.selenium/,
+            /import\s+io\.appium\.java_client/,
+            /import\s+com\.microsoft\.playwright/,
+            /import\s+com\.codeborne\.selenide/,
+            /import\s+net\.serenitybdd/,
+            /import\s+cucumber\.api\.java\.en/,
+            /new\s+\w*Driver\s*\(/,
+            /\.findElement\s*\(/,
+            /\.get\s*\(['"]https?:/,
+            /\.click\s*\(/,
+            /\.navigate\(\)/,
+            /WebDriver/,
+            /RemoteWebDriver/,
+            /ChromeDriver/,
+            /FirefoxDriver/,
+        ],
+        uiIndicatorRegex: [
+            // UI interactions without explicit driver imports
+            /\.sendKeys\s*\(/,
+            /\.getText\s*\(/,
+            /\.isDisplayed\s*\(/,
+            /By\.id\s*\(/,
+            /By\.className\s*\(/,
+            /By\.xpath\s*\(/,
+            /waitForElement/,
+            /waitForVisible/,
+            /assertTitle/,
+            /screenshot/,
+            /captureScreenshot/,
+            // Page Object patterns
+            /PageObject/,
+            /BasePage/,
+            /WebPage/,
+            // UI test annotations and patterns
+            /@UITest/,
+            /@WebTest/,
+            /@E2ETest/,
+            // Common UI assertions
+            /assertUrl/,
+            /verifyText/,
+            /checkElement/,
+            // Browser/window operations
+            /maximizeWindow/,
+            /setWindowSize/,
+            /switchTo/,
+            // Cucumber UI steps
+            /Given.*I\s+(open|visit|navigate)/,
+            /When.*I\s+(click|type|select)/,
+            /Then.*I\s+(see|verify|check)/,
+            /And.*I\s+(wait|scroll)/,
+        ],
+        backendRegex: [
+            /import\s+org\.springframework\.test/,
+            /import\s+javax\.persistence/,
+            /@DataJpaTest/,
+            /@WebMvcTest/,
+            /@MockBean/,
+            /EntityManager/,
+            /JdbcTemplate/,
+            /TestRestTemplate/,
+            /@Repository/,
+            /@Service/,
+            /@Entity/,
+        ],
+        excludeRegex: [
+            /UnitTest/,
+            /MockTest/,
+            /StubTest/,
+            /DatabaseTest/,
+            /import\s+org\.mockito/,
+            /@Mock\b/,
+            /@Spy\b/,
+        ],
+    },
+    csharp: {
+        extensions: [".cs"],
+        namePatterns: [
+            /Test\.cs$/,
+            /Tests\.cs$/,
+            /Steps\.cs$/,
+            /.*UI.*Test\.cs$/,
+            /.*Web.*Test\.cs$/,
+            /.*E2E.*Test\.cs$/,
+        ],
+        contentRegex: [
+            /\[Test\]/,
+            /\[TestCase\]/,
+            /\[Fact\]/,
+            /\[Theory\]/,
+            /\[Binding\]/,
+            /using\s+NUnit\.Framework/,
+            /using\s+Xunit/,
+            /using\s+TechTalk\.SpecFlow/,
+        ],
+        uiDriverRegex: [
+            /using\s+OpenQA\.Selenium/,
+            /using\s+Appium/,
+            /using\s+Microsoft\.Playwright/,
+            /using\s+Selenide/,
+            /using\s+Atata/,
+            /new\s+\w*Driver\s*\(/,
+            /\.FindElement\s*\(/,
+            /\.Navigate\(\)/,
+            /IWebDriver/,
+            /WebDriver/,
+        ],
+        uiIndicatorRegex: [
+            /\.SendKeys\s*\(/,
+            /\.Click\s*\(/,
+            /\.Text/,
+            /\.Displayed/,
+            /By\.Id/,
+            /By\.ClassName/,
+            /By\.XPath/,
+            /WaitForElement/,
+            /TakeScreenshot/,
+            /PageObject/,
+            /\[UITest\]/,
+            /\[WebTest\]/,
+            /\[E2ETest\]/,
+            /NavigateTo/,
+            /VerifyText/,
+            /AssertUrl/,
+        ],
+        backendRegex: [
+            /using\s+Microsoft\.EntityFrameworkCore/,
+            /using\s+System\.Data/,
+            /DbContext/,
+            /Repository/,
+            /Controller/,
+            /\[ApiTest\]/,
+            /\[DatabaseTest\]/,
+        ],
+        excludeRegex: [/\[UnitTest\]/, /Mock/, /Stub/, /using\s+Moq/],
+    },
+    nodejs: {
+        extensions: [".js", ".ts"],
+        namePatterns: [
+            /.test.js$/,
+            /.spec.js$/,
+            /.test.ts$/,
+            /.spec.ts$/,
+            /.*ui.*.test.(js|ts)$/,
+            /.*web.*.test.(js|ts)$/,
+            /.*e2e.*.(js|ts)$/,
+            /.*integration.*.test.(js|ts)$/,
+        ],
+        contentRegex: [
+            /\bdescribe\s*\(/,
+            /\bit\s*\(/,
+            /\btest\s*\(/,
+            /require\(['"]mocha['"]\)/,
+            /require\(['"]jest['"]\)/,
+            /import.*from\s+['"]jest['"]/,
+            /from\s+['"]@jest/,
+        ],
+        uiDriverRegex: [
+            /require\(['"]selenium-webdriver['"]\)/,
+            /require\(['"]webdriverio['"]\)/,
+            /require\(['"]puppeteer['"]\)/,
+            /require\(['"]playwright['"]\)/,
+            /require\(['"]cypress['"]\)/,
+            /require\(['"]@wdio\/sync['"]\)/,
+            /import.*from\s+['"]selenium-webdriver['"]/,
+            /import.*from\s+['"]webdriverio['"]/,
+            /import.*from\s+['"]puppeteer['"]/,
+            /import.*from\s+['"]playwright['"]/,
+            /import.*from\s+['"]cypress['"]/,
+            /import.*from\s+['"]@wdio/,
+            /\.launch\(/,
+            /\.goto\(/,
+            /driver\./,
+            /browser\./,
+        ],
+        uiIndicatorRegex: [
+            // Browser automation - SPECIFIC CONTEXT
+            /driver\.click\(/,
+            /driver\.type\(/,
+            /driver\.fill\(/,
+            /browser\.click\(/,
+            /driver\.waitForSelector\(/,
+            /browser\.waitForElement\(/,
+            /driver\.screenshot\(/,
+            /browser\.screenshot\(/,
+            /driver\.evaluate\(/,
+            /driver\.focus\(/,
+            /driver\.hover\(/,
+            // Page object patterns - UI specific
+            /page\.goto/,
+            /page\.click/,
+            /page\.fill/,
+            /page\.screenshot/,
+            /page\.waitForSelector/,
+            /page\.locator/,
+            /page\.getByRole/,
+            // Cypress specific patterns
+            /cy\.visit/,
+            /cy\.get/,
+            /cy\.click/,
+            /cy\.type/,
+            /cy\.should/,
+            /cy\.wait/,
+            /cy\.screenshot/,
+            /cy\.viewport/,
+            // WebDriverIO specific patterns
+            /browser\.url/,
+            /browser\.click/,
+            /browser\.setValue/,
+            /\$\(['"][#.]/,
+            /\$\$\(['"][#.]/, // CSS/XPath selectors
+            // Playwright specific
+            /expect.*toBeVisible/,
+            /expect.*toHaveText/,
+            /expect.*toBeEnabled/,
+            /locator\(/,
+            /getByText\(/,
+            /getByRole\(/,
+            /getByTestId\(/,
+            // DOM queries in test context
+            /findElement/,
+            /querySelector.*\)\.click/,
+            /getElementById.*\)\.click/,
+            // Test descriptions clearly indicating UI
+            /describe.*['"`].*UI/,
+            /describe.*['"`].*Web/,
+            /describe.*['"`].*E2E/,
+            /describe.*['"`].*Browser/,
+            /describe.*['"`].*Selenium/,
+            /it.*['"`].*(click|type|navigate|visit|see).*element/,
+            /it.*['"`].*(open|load).*page/,
+            /it.*['"`].*browser/,
+        ],
+        backendRegex: [
+            /require\(['"]express['"]\)/,
+            /require\(['"]fastify['"]\)/,
+            /require\(['"]supertest['"]\)/,
+            /request\(app\)/,
+            /mongoose/,
+            /sequelize/,
+            /prisma/,
+            /knex/,
+            /app\.get\(/,
+            /app\.post\(/,
+            /server\./,
+            /\.connect\(/,
+            /\.query\(/,
+        ],
+        excludeRegex: [
+            /\.unit\./,
+            /\.mock\./,
+            /jest\.mock/,
+            /sinon/,
+            /describe.*['"`]Unit/,
+            /describe.*['"`]Mock/,
+        ],
+    },
+    python: {
+        extensions: [".py"],
+        namePatterns: [
+            /^test_.*\.py$/,
+            /_test\.py$/,
+            /test.*ui.*\.py$/,
+            /test.*web.*\.py$/,
+            /test.*e2e.*\.py$/,
+            /test.*integration.*\.py$/,
+        ],
+        contentRegex: [
+            /import\s+pytest/,
+            /@pytest\.mark/,
+            /def\s+test_/,
+            /\bpytest\./,
+            /import\s+unittest/,
+            /class.*TestCase/,
+        ],
+        uiDriverRegex: [
+            /import\s+selenium/,
+            /from\s+selenium/,
+            /import\s+playwright/,
+            /from\s+playwright/,
+            /import\s+appium/,
+            /from\s+appium/,
+            /import\s+splinter/,
+            /from\s+splinter/,
+            /driver\s*=\s*webdriver\./,
+            /webdriver\.Chrome/,
+            /webdriver\.Firefox/,
+        ],
+        uiIndicatorRegex: [
+            // Selenium patterns without imports
+            /\.find_element/,
+            /\.click\(/,
+            /\.send_keys/,
+            /\.get\(/,
+            /\.screenshot/,
+            /\.execute_script/,
+            /\.switch_to/,
+            /By\.ID/,
+            /By\.CLASS_NAME/,
+            /By\.XPATH/,
+            // Playwright patterns
+            /page\.goto/,
+            /page\.click/,
+            /page\.fill/,
+            /page\.screenshot/,
+            /expect.*to_be_visible/,
+            /expect.*to_have_text/,
+            // Generic UI patterns
+            /WebDriverWait/,
+            /expected_conditions/,
+            /ActionChains/,
+            /@pytest\.mark\.ui/,
+            /@pytest\.mark\.web/,
+            /@pytest\.mark\.e2e/,
+            // Page object patterns
+            /BasePage/,
+            /PageObject/,
+            /WebPage/,
+            // BDD step patterns
+            /def\s+.*_(open|visit|navigate|click|type|see|verify)/,
+        ],
+        backendRegex: [
+            /import\s+flask/,
+            /from\s+flask/,
+            /import\s+fastapi/,
+            /from\s+fastapi/,
+            /import\s+django/,
+            /from\s+django/,
+            /sqlalchemy/,
+            /requests\.get/,
+            /requests\.post/,
+            /TestClient/,
+            /@pytest\.mark\.django_db/,
+            /django\.test/,
+        ],
+        excludeRegex: [
+            /unittest\.mock/,
+            /from\s+unittest\.mock/,
+            /mock\.patch/,
+            /@pytest\.mark\.unit/,
+            /@mock\./,
+        ],
+    },
+    ruby: {
+        extensions: [".rb"],
+        namePatterns: [
+            /_spec\.rb$/,
+            /_test\.rb$/,
+            /.*ui.*_spec\.rb$/,
+            /.*web.*_spec\.rb$/,
+            /.*e2e.*_spec\.rb$/,
+        ],
+        contentRegex: [
+            /\bdescribe\s/,
+            /\bit\s/,
+            /require\s+['"]rspec/,
+            /require\s+['"]minitest/,
+            /RSpec\.describe/,
+        ],
+        uiDriverRegex: [
+            /require\s+['"]selenium-webdriver['"]/,
+            /require\s+['"]capybara['"]/,
+            /require\s+['"]appium_lib['"]/,
+            /require\s+['"]watir['"]/,
+            /Selenium::WebDriver/,
+            /Capybara\./,
+        ],
+        uiIndicatorRegex: [
+            // Capybara without explicit require
+            /visit\s/,
+            /click_button/,
+            /click_link/,
+            /fill_in/,
+            /find\(['"]/,
+            /has_content/,
+            /page\./,
+            /current_path/,
+            // Selenium patterns
+            /\.find_element/,
+            /\.click/,
+            /\.send_keys/,
+            // Generic UI patterns
+            /screenshot/,
+            /driver\./,
+            /browser\./,
+            /feature\s+['"]/,
+            /scenario\s+['"]/,
+            /expect.*to\s+have_content/,
+            /expect.*to\s+have_selector/,
+        ],
+        backendRegex: [
+            /require\s+['"]sinatra['"]/,
+            /require\s+['"]rails['"]/,
+            /ActiveRecord/,
+            /DatabaseCleaner/,
+            /FactoryBot/,
+        ],
+        excludeRegex: [
+            /double\(/,
+            /instance_double/,
+            /class_double/,
+            /allow\(.*\)\.to\s+receive/,
+            /mock/i,
+        ],
+    },
+};
+export const EXCLUDED_DIRS = new Set([
+    "node_modules",
+    ".venv",
+    "venv",
+    "__pycache__",
+    "site-packages",
+    "dist",
+    "build",
+    ".git",
+    ".mypy_cache",
+    ".pytest_cache",
+    ".tox",
+    ".idea",
+    ".vscode",
+    "coverage",
+    ".nyc_output",
+    "target",
+    "bin",
+    "obj",
+    "packages",
+    ".nuget",
+]);
+export const backendIndicators = [
+    /import\s+requests/,
+    /requests\.(get|post|put|delete|patch)/,
+    /@pytest\.mark\.(api|backend|integration)/,
+    /BASE_URL\s*=/,
+    /\.status_code/,
+    /\.json\(\)/,
+    /TestClient/,
+    /Bearer\s+/,
+    /Authorization.*Bearer/,
+];
+export const strongUIIndicators = [
+    // Browser automation with specific context
+    /(driver|browser|page)\.(click|type|fill|screenshot|wait)/,
+    /webdriver\.(Chrome|Firefox|Safari|Edge)/,
+    /(selenium|playwright|puppeteer|cypress).*import/,
+    // CSS/XPath selectors
+    /By\.(ID|CLASS_NAME|XPATH|CSS_SELECTOR)/,
+    /\$\(['"#[.][^'"]*['"]\)/, // $(".class") or $("#id")
+    // Page Object Model
+    /class.*Page.*:/,
+    /class.*PageObject/,
+    // UI test markers
+    /@(ui|web|e2e|browser)_?test/,
+    /@pytest\.mark\.(ui|web|e2e|browser)/,
+    // Browser navigation
+    /\.goto\s*\(['"]https?:/,
+    /\.visit\s*\(['"]https?:/,
+    /\.navigate\(\)\.to\(/,
+];

package/dist/tools/percy-snapshot-utils/detect-test-files.d.ts

@@ -0,0 +1,10 @@
+import { SDKSupportedLanguage, SDKSupportedTestingFrameworkEnum } from "../sdk-utils/common/types.js";
+export interface ListTestFilesOptions {
+    language: SDKSupportedLanguage;
+    framework?: SDKSupportedTestingFrameworkEnum;
+    baseDir: string;
+    strictMode?: boolean;
+}
+export declare function listTestFiles(options: ListTestFilesOptions): Promise<string[]>;
+export declare function listUITestFilesStrict(options: Omit<ListTestFilesOptions, "strictMode">): Promise<string[]>;
+export declare function listUITestFilesRelaxed(options: Omit<ListTestFilesOptions, "strictMode">): Promise<string[]>;

package/dist/tools/percy-snapshot-utils/detect-test-files.js

@@ -0,0 +1,194 @@
+import fs from "fs";
+import path from "path";
+import logger from "../../logger.js";
+import { EXCLUDED_DIRS, TEST_FILE_DETECTION, backendIndicators, strongUIIndicators, } from "../percy-snapshot-utils/constants.js";
+async function walkDir(dir, extensions) {
+    const result = [];
+    try {
+        const entries = await fs.promises.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (!EXCLUDED_DIRS.has(entry.name) && !entry.name.startsWith(".")) {
+                    result.push(...(await walkDir(fullPath, extensions)));
+                }
+            }
+            else if (extensions.some((ext) => entry.name.endsWith(ext))) {
+                result.push(fullPath);
+            }
+        }
+    }
+    catch {
+        logger.error(`Failed to read directory: ${dir}`);
+    }
+    return result;
+}
+async function fileContainsRegex(filePath, regexes) {
+    if (!regexes.length)
+        return false;
+    try {
+        const content = await fs.promises.readFile(filePath, "utf8");
+        return regexes.some((re) => re.test(content));
+    }
+    catch {
+        logger.warn(`Failed to read file: ${filePath}`);
+        return false;
+    }
+}
+async function batchRegexCheck(filePath, regexGroups) {
+    try {
+        const content = await fs.promises.readFile(filePath, "utf8");
+        return regexGroups.map((regexes) => regexes.length > 0 ? regexes.some((re) => re.test(content)) : false);
+    }
+    catch {
+        logger.warn(`Failed to read file: ${filePath}`);
+        return regexGroups.map(() => false);
+    }
+}
+async function isLikelyUITest(filePath) {
+    try {
+        const content = await fs.promises.readFile(filePath, "utf8");
+        if (backendIndicators.some((pattern) => pattern.test(content))) {
+            return false;
+        }
+        return strongUIIndicators.some((pattern) => pattern.test(content));
+    }
+    catch {
+        return false;
+    }
+}
+function getFileScore(fileName, config) {
+    let score = 0;
+    // Higher score for explicit UI test naming
+    if (/ui|web|e2e|integration|functional/i.test(fileName))
+        score += 3;
+    if (config.namePatterns.some((pattern) => pattern.test(fileName)))
+        score += 2;
+    return score;
+}
+export async function listTestFiles(options) {
+    const { language, framework, baseDir, strictMode = false } = options;
+    const config = TEST_FILE_DETECTION[language];
+    if (!config) {
+        logger.error(`Unsupported language: ${language}`);
+        return [];
+    }
+    // Step 1: Collect all files with matching extensions
+    let files = [];
+    try {
+        files = await walkDir(baseDir, config.extensions);
+    }
+    catch {
+        return [];
+    }
+    if (files.length === 0) {
+        throw new Error("No files found with the specified extensions");
+    }
+    const candidateFiles = new Map();
+    // Step 2: Fast name-based identification with scoring
+    for (const file of files) {
+        const fileName = path.basename(file);
+        const score = getFileScore(fileName, config);
+        if (config.namePatterns.some((pattern) => pattern.test(fileName))) {
+            candidateFiles.set(file, score);
+            logger.debug(`File matched by name pattern: ${file} (score: ${score})`);
+        }
+    }
+    // Step 3: Content-based test detection for remaining files
+    const remainingFiles = files.filter((file) => !candidateFiles.has(file));
+    const contentCheckPromises = remainingFiles.map(async (file) => {
+        const hasTestContent = await fileContainsRegex(file, config.contentRegex);
+        if (hasTestContent) {
+            const fileName = path.basename(file);
+            const score = getFileScore(fileName, config);
+            candidateFiles.set(file, score);
+            logger.debug(`File matched by content regex: ${file} (score: ${score})`);
+        }
+    });
+    await Promise.all(contentCheckPromises);
+    // Step 4: Handle SpecFlow .feature files for C# + SpecFlow
+    if (language === "csharp" && framework === "specflow") {
+        try {
+            const featureFiles = await walkDir(baseDir, [".feature"]);
+            featureFiles.forEach((file) => candidateFiles.set(file, 2));
+            logger.info(`Added ${featureFiles.length} SpecFlow .feature files`);
+        }
+        catch {
+            logger.warn(`Failed to collect SpecFlow .feature files from baseDir: ${baseDir}`);
+        }
+    }
+    if (candidateFiles.size === 0) {
+        logger.info("No test files found matching patterns");
+        return [];
+    }
+    // Step 6: UI Detection with fallback patterns
+    const uiFiles = [];
+    const filesToCheck = Array.from(candidateFiles.keys());
+    // Batch process UI detection for better performance
+    const batchSize = 10;
+    for (let i = 0; i < filesToCheck.length; i += batchSize) {
+        const batch = filesToCheck.slice(i, i + batchSize);
+        const batchPromises = batch.map(async (file) => {
+            // First, use the new precise UI detection
+            const isUITest = await isLikelyUITest(file);
+            if (isUITest) {
+                logger.debug(`File included - strong UI indicators: ${file}`);
+                return file;
+            }
+            // If not clearly UI, run the traditional checks
+            const [hasExplicitUI, hasUIIndicators, hasBackend, shouldExclude] = await batchRegexCheck(file, [
+                config.uiDriverRegex,
+                config.uiIndicatorRegex,
+                config.backendRegex,
+                config.excludeRegex || [],
+            ]);
+            // Skip if explicitly excluded (mocks, unit tests, etc.)
+            if (shouldExclude) {
+                logger.debug(`File excluded by exclude regex: ${file}`);
+                return null;
+            }
+            // Skip backend tests in any mode
+            if (hasBackend) {
+                logger.debug(`File excluded as backend test: ${file}`);
+                return null;
+            }
+            // Include if has explicit UI drivers
+            if (hasExplicitUI) {
+                logger.debug(`File included - explicit UI drivers: ${file}`);
+                return file;
+            }
+            // Include if has UI indicators (for cases where drivers aren't explicitly imported)
+            if (hasUIIndicators) {
+                logger.debug(`File included - UI indicators: ${file}`);
+                return file;
+            }
+            // In non-strict mode, include high-scoring test files even without explicit UI patterns
+            if (!strictMode) {
+                const score = candidateFiles.get(file) || 0;
+                if (score >= 3) {
+                    // High confidence UI test based on naming
+                    logger.debug(`File included - high confidence score: ${file} (score: ${score})`);
+                    return file;
+                }
+            }
+            logger.debug(`File excluded - no UI patterns detected: ${file}`);
+            return null;
+        });
+        const batchResults = await Promise.all(batchPromises);
+        uiFiles.push(...batchResults.filter((file) => file !== null));
+    }
+    // Step 7: Sort by score (higher confidence files first)
+    uiFiles.sort((a, b) => {
+        const scoreA = candidateFiles.get(a) || 0;
+        const scoreB = candidateFiles.get(b) || 0;
+        return scoreB - scoreA;
+    });
+    logger.info(`Returning ${uiFiles.length} UI test files from ${candidateFiles.size} total test files`);
+    return uiFiles;
+}
+export async function listUITestFilesStrict(options) {
+    return listTestFiles({ ...options, strictMode: true });
+}
+export async function listUITestFilesRelaxed(options) {
+    return listTestFiles({ ...options, strictMode: false });
+}