@ai-dev-tools/test-copilot-core 1.0.19

package/out/core/generate/UTGen.js

@@ -0,0 +1,795 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UTGen = void 0;
+const analyze_1 = require("../analyze");
+const llm_1 = require("../llm");
+const common_1 = require("../utils/common");
+const file_1 = require("../utils/file");
+const system_1 = require("../utils/system");
+const lint_1 = require("../utils/lint");
+const validateMockedTest_1 = require("../quality/validateMockedTest");
+const removeFailedCases_1 = require("../features/removeFailedCases");
+const validFix_1 = require("../features/validFix");
+const tag_1 = require("../valid/tag");
+const mock_1 = require("../valid/mock");
+const extractVitestConfig_1 = require("../valid/extractVitestConfig");
+const fs_1 = __importDefault(require("fs"));
+const config_1 = require("../config");
+const console_1 = require("../utils/console");
+const deps_1 = require("../utils/deps");
+const tsMorph_1 = require("../utils/tsMorph");
+const getViteConfig_1 = require("../valid/getViteConfig");
+const path_1 = __importDefault(require("path"));
+const telemetry_1 = require("../utils/telemetry");
+const move_1 = require("../utils/move");
+const reactFunctionSet = new Set([
+    'componentDidMount',
+    'componentDidUpdate',
+    'componentWillUnmount',
+    'componentWillReceiveProps',
+    'componentWillUpdate',
+    'componentWillMount',
+    'componentWillUpdate',
+    'shouldComponentUpdate',
+    'componentDidCatch',
+    'getDerivedStateFromProps',
+    'getSnapshotBeforeUpdate'
+]);
+class UTGen {
+    filePath;
+    projectFolder;
+    options;
+    #sourceFile;
+    #fileDir;
+    // file name with extension
+    #fileName;
+    // file name without extension
+    #filePrefix;
+    // file extension
+    #fileSuffix;
+    // ${this.#filePrefix}.spec or custom test folder
+    #specDir;
+    #testFileSpecifier = 'web.spec';
+    #stopped = false;
+    #status;
+    #count = {
+        unknown: 0,
+        success: 0,
+        funFailed: 0,
+        classMemberFailed: 0,
+        skip: 0,
+        exception: 0,
+        testException: 0,
+        gptException: 0,
+    };
+    #generatedFiles = [];
+    #memoResult = {};
+    #isInWSL = false;
+    vitestConfig;
+    tempTestFileDir;
+    get status() {
+        return this.#status;
+    }
+    get generatedFiles() {
+        return this.#generatedFiles;
+    }
+    get count() {
+        return this.#count;
+    }
+    get memoResult() {
+        return this.#memoResult;
+    }
+    get testFramework() {
+        return (0, config_1.getConfig)().common.testFramework || 'jest';
+    }
+    get sourceFile() {
+        return this.#sourceFile;
+    }
+    get specDir() {
+        return this.#specDir;
+    }
+    constructor(filePath, projectFolder, options) {
+        this.filePath = filePath;
+        this.projectFolder = projectFolder;
+        this.options = options;
+        this.#sourceFile = (0, file_1.toUnixStyle)(filePath);
+        this.#fileDir = (0, file_1.toUnixStyle)(path_1.default.dirname(filePath));
+        this.#fileName = (0, file_1.toUnixStyle)(path_1.default.basename(filePath));
+        this.#filePrefix = this.#fileName.replace(/(\.[jt]sx?)$/, '');
+        this.#fileSuffix = this.#fileName.replace(this.#filePrefix, '');
+        this.projectFolder = projectFolder || (0, file_1.findProjectRoot)(filePath) || this.#fileDir;
+        const { testFolder, testFileSpecifier } = (0, config_1.getConfig)().common;
+        this.#testFileSpecifier = testFileSpecifier || 'web.spec';
+        if (testFolder) {
+            const srcFolder = path_1.default.resolve(this.projectFolder, 'src');
+            const srcExists = fs_1.default.existsSync(srcFolder) && fs_1.default.statSync(srcFolder).isDirectory();
+            const relatedFolder = path_1.default.relative(srcExists ? srcFolder : this.projectFolder, this.#fileDir);
+            this.#specDir = path_1.default.resolve(this.projectFolder, testFolder, relatedFolder, this.#filePrefix);
+        }
+        else {
+            this.#specDir = path_1.default.resolve(this.#fileDir, this.#fileName.replace(/(\.[jt]sx?)$/, `.spec`));
+        }
+        this.#isInWSL = /^(\\|\/\/)wsl.localhost(\\|\/)/.test(this.#fileDir);
+        this.tempTestFileDir = this.#fileDir;
+        if (this.testFramework === 'vitest') {
+            const vitestConfigPath = (0, getViteConfig_1.getViteConfigPath)(this.#fileDir);
+            if (vitestConfigPath) {
+                const vitestConfig = (0, extractVitestConfig_1.extractTestConfigWithAST)(vitestConfigPath);
+                if (vitestConfig.testDir) {
+                    // reset the spec dir with test dir
+                    this.#specDir = testFolder ? this.#specDir : path_1.default.normalize(this.#specDir.replace('src', vitestConfig.testDir));
+                    this.tempTestFileDir = path_1.default.normalize(this.tempTestFileDir.replace('src', vitestConfig.testDir));
+                }
+                if (vitestConfig.testSpecifier) {
+                    this.#testFileSpecifier = testFileSpecifier || vitestConfig.testSpecifier;
+                }
+            }
+        }
+        if ((0, config_1.getConfig)().common.testDirRelativeToPackage) {
+            const packageRoot = (0, file_1.findProjectRoot)(this.#fileDir);
+            this.#specDir = path_1.default.resolve(packageRoot, (0, config_1.getConfig)().common.testDirRelativeToPackage, this.#fileName.replace(/(\.[jt]sx?)$/, `.spec`));
+            this.tempTestFileDir = path_1.default.resolve(packageRoot, (0, config_1.getConfig)().common.testDirRelativeToPackage);
+        }
+    }
+    log(...args) {
+        (0, console_1.getConsole)().log(...args);
+    }
+    error(...args) {
+        (0, console_1.getConsole)().error(...args);
+    }
+    progress(message, options) {
+        this.options?.progress?.({
+            message,
+            ...options
+        });
+    }
+    stop = () => {
+        this.#stopped = true;
+    };
+    #sendTelemetry = (type, properties, measurements) => {
+        (0, telemetry_1.sendTelemetry)('UTGen', {
+            type,
+            runTest: this.options?.runTest ? 'true' : 'false',
+            ...properties
+        }, measurements);
+    };
+    #updateCount(status, isClassMember) {
+        if (status === 2 /* GenerateResult.Success */) {
+            this.#count.success++;
+        }
+        else if (status === 1 /* GenerateResult.Failed */) {
+            if (isClassMember) {
+                this.#count.classMemberFailed++;
+            }
+            else {
+                this.#count.funFailed++;
+            }
+        }
+        else if (status === 4 /* GenerateResult.Exception */) {
+            this.#count.exception++;
+        }
+        else if (status === 5 /* GenerateResult.TestException */) {
+            this.#count.testException++;
+        }
+        else if (status === 6 /* GenerateResult.GPTException */) {
+            this.#count.gptException++;
+        }
+        else if (status === 3 /* GenerateResult.Skip */) {
+            this.#count.skip++;
+        }
+        else {
+            this.#count.unknown++;
+        }
+    }
+    async run() {
+        if (this.options?.abortSignal) {
+            this.options.abortSignal.addEventListener('abort', this.stop, { once: true });
+        }
+        const start = Date.now();
+        try {
+            this.progress(`Analyzing ${this.#fileName}`);
+            const { project: cachedProject } = (0, tsMorph_1.getProject)(this.filePath);
+            // analyze may take a long time, put the rest actions to the next loop
+            await (0, system_1.sleep)(10);
+            if (this.#stopped) {
+                return;
+            }
+            this.#sendTelemetry("start" /* Events.Start */);
+            const exporteds = await (0, analyze_1.read)(this.filePath, {
+                deepTypesCheck: false,
+                cachedProject
+            });
+            const processEndTime = Date.now();
+            const processTime = processEndTime - start;
+            if (!exporteds.length) {
+                if (this.#fileName === "index.ts" && (0, config_1.getConfig)().common.createIndexSpec) {
+                    const testCode = `import * as Exports from './${this.#filePrefix}';\ndescribe("Exports", () => {\n  it("should be defined", () => {\n    expect(Exports).toBeDefined();\n  });\n});`;
+                    const specFile = this.filePath.replace(/(\.[jt]sx?)$/, `.${this.#testFileSpecifier}$1`);
+                    if (!fs_1.default.existsSync(specFile) && !fs_1.default.existsSync(specFile.replace(/\.web\./, '.node.')) && !fs_1.default.existsSync(specFile.replace(/\.web\./, '.'))) {
+                        fs_1.default.writeFileSync(specFile, testCode, 'utf-8');
+                    }
+                    this.#status = 2 /* GenerateResult.Success */;
+                    this.#sendTelemetry("index" /* Events.GenIndex */, {}, {
+                        processTime,
+                        totalTime: Date.now() - start
+                    });
+                }
+                else {
+                    this.progress(`No export function/class found in ${this.#fileName}`);
+                    this.#status = 3 /* GenerateResult.Skip */;
+                    this.#sendTelemetry("skipConst" /* Events.SkipConstants */, {}, {
+                        processTime,
+                        totalTime: Date.now() - start
+                    });
+                    return;
+                }
+            }
+            for (let i = 0; i < exporteds.length && !this.#stopped; i++) {
+                const exportData = exporteds[i];
+                await (0, system_1.sleep)(10);
+                this.log(`Exported: ${i + 1}/${exporteds.length} ${exportData.name}`);
+                if (exportData.type === analyze_1.CodeType.Function) {
+                    this.#updateCount(await this.genFunctionTestCode(exportData), false);
+                }
+                else {
+                    const res = await this.genClassTestCode(exportData);
+                    res.forEach(r => this.#updateCount(r, true));
+                }
+            }
+            let mark = '';
+            if (this.#count.success) {
+                mark = 'Success';
+                this.progress('Success', { finish: 1 });
+                this.#status = 2 /* GenerateResult.Success */;
+            }
+            else if (!(this.#count.funFailed || this.#count.classMemberFailed)) {
+                mark = 'Skip';
+                this.#status = 3 /* GenerateResult.Skip */;
+                this.progress('Skipped', { finish: 1 });
+            }
+            else {
+                mark = 'Failed';
+                this.progress('Failed', { finish: 2, lastFailed: true });
+                this.#status = 1 /* GenerateResult.Failed */;
+            }
+            const totalTime = Date.now() - start;
+            const seconds = totalTime / 1000;
+            const timeStr = seconds < 60 ? `${seconds} sec` : `${Math.floor(seconds / 60)} min ${Math.floor(seconds % 60)} sec`;
+            this.log(`[${mark}] Generated test files for ${this.#fileName} in ${timeStr}`);
+            this.#sendTelemetry("finish" /* Events.Finish */, {}, {
+                processTime,
+                totalTime,
+                ...this.#count
+            });
+        }
+        catch (e) {
+            this.progress(`Error: ${e.message}`, { finish: 2, lastFailed: true });
+        }
+        finally {
+            if (this.options?.abortSignal) {
+                this.options.abortSignal.removeEventListener('abort', this.stop);
+            }
+        }
+    }
+    async writeSpecFile(code, testName, existsSpec) {
+        // TODO: check new test cases coverage should be greater than existing
+        const specName = this.getSpecName(testName);
+        let targetPath;
+        if (existsSpec?.isFileLevel) {
+            targetPath = existsSpec.filePath;
+        }
+        else {
+            targetPath = path_1.default.resolve(this.#specDir, specName);
+        }
+        const specDir = path_1.default.dirname(targetPath);
+        if (!fs_1.default.existsSync(specDir) && !this.options?.saveInMemo) {
+            fs_1.default.mkdirSync(specDir, { recursive: true });
+        }
+        let newCode = code;
+        if (!existsSpec?.isFileLevel) {
+            newCode = (0, tag_1.addTag)(newCode);
+        }
+        newCode = await (0, move_1.updateCodeReferences)(this.#fileDir, specDir, specName, newCode);
+        const targetRelatedPath = path_1.default.relative(this.projectFolder, targetPath);
+        this.log(`Writing test file: ${targetPath}`);
+        if (this.options?.saveInMemo) {
+            this.#memoResult[testName] = {
+                code: newCode,
+                targetPath,
+            };
+            return targetPath;
+        }
+        const existsSpecPath = fs_1.default.existsSync(targetPath) ? targetPath : undefined;
+        let oldSpec = undefined;
+        if (this.options?.saveOldSpec && existsSpecPath) {
+            oldSpec = fs_1.default.readFileSync(existsSpecPath, 'utf8').toString();
+        }
+        this.progress(`Writing test file to ${targetRelatedPath}`);
+        fs_1.default.writeFileSync(targetPath, newCode, 'utf-8');
+        this.#generatedFiles.push({
+            filePath: targetPath,
+            status: existsSpecPath ? 'modify' : 'add',
+            oldSpec: oldSpec
+        });
+        return targetPath;
+    }
+    async genFunctionTestCode(data) {
+        if (!this.isFunctionMatch(data.name)) {
+            return 3 /* GenerateResult.Skip */;
+        }
+        if (!this.isLineMatch(data.linesRange)) {
+            return 3 /* GenerateResult.Skip */;
+        }
+        if (!this.isLineRangeMatch(data.linesRange)) {
+            return 3 /* GenerateResult.Skip */;
+        }
+        if ((0, config_1.getConfig)().common.ignoreFuncs?.has(data.name)) {
+            return 3 /* GenerateResult.Skip */;
+        }
+        let mockString = (0, deps_1.getPackageMocks)(data.importDeclares);
+        let existsSpec = this.isSpecExists(data.name);
+        let specCode;
+        if (existsSpec) {
+            if (!this.options?.repair) {
+                this.progress(`Spec file exists (${existsSpec.filePath}), please use "Update test" to fix`);
+                return 3 /* GenerateResult.Skip */;
+            }
+            specCode = await this.readExistingSpec(existsSpec.filePath);
+        }
+        this.progress(`Generating test code for ${data.name}`);
+        const specName = `./${this.#filePrefix}.${this.#testFileSpecifier}${this.#fileSuffix}`;
+        const code = (0, analyze_1.getCode)(data, {
+            beforeImports: '// external import declarations:\n',
+            beforeLocal: `// dependencies in the same file (./${this.#fileName}):\n`,
+            beforeCode: '// test target code:\n'
+        });
+        const promptKey = specCode ? "RepairFuncUT" /* PromptKey.RepairFuncUT */ : "GenFuncUT" /* PromptKey.GenFuncUT */;
+        const messages = (0, llm_1.getPrompt)(promptKey, {
+            ["<<<SourceFileName>>>" /* PromptPlaceholder.SourceFileName */]: this.#fileName,
+            ["<<<FunctionName>>>" /* PromptPlaceholder.FunctionName */]: (0, common_1.formatImportName)(data.name, data.isDefaultExport),
+            ["<<<SpecFileName>>>" /* PromptPlaceholder.SpecFileName */]: specName,
+            ["<<<SourceCode>>>" /* PromptPlaceholder.SourceCode */]: code,
+            ["<<<MockCode>>>" /* PromptPlaceholder.MockCode */]: mockString,
+            ["<<<Spec>>>" /* PromptPlaceholder.SpecCode */]: specCode,
+            ["<<<Language>>>" /* PromptPlaceholder.Language */]: (0, common_1.getLanguage)(this.#fileSuffix),
+            ["<<<ModuleType>>>" /* PromptPlaceholder.ModuleType */]: data.isCommonJS ? "cjs" /* ModuleType.CJS */ : "esm" /* ModuleType.ESM */,
+            ["<<<TestFramework>>>" /* PromptPlaceholder.TestFramework */]: this.testFramework,
+        }, this.options?.promptConfigs?.[promptKey]);
+        const testName = (0, config_1.getConfig)().common?.kebabCaseTestFileName ? this.toKebabCase(data.name) : data.name;
+        return await this.runTask({
+            messages,
+            testName: testName,
+            targetCode: code,
+            mockString,
+            testFuncName: data.name,
+            moduleName: this.#fileName,
+            existsSpec
+        });
+    }
+    async genClassTestCode(data) {
+        if (!data.classFunctions.length) {
+            return [3 /* GenerateResult.Skip */];
+        }
+        if (!this.isLineMatch(data.linesRange)) {
+            return [3 /* GenerateResult.Skip */];
+        }
+        if (!this.isLineRangeMatch(data.linesRange)) {
+            return [3 /* GenerateResult.Skip */];
+        }
+        if ((0, config_1.getConfig)().common.ignoreFuncs?.has(`${data.name}.*`)) {
+            return [3 /* GenerateResult.Skip */];
+        }
+        const isDataConnector = this.#fileName.includes('.connector.') && data.name.endsWith('Connector');
+        const classDeclare = (0, analyze_1.getCode)(data, {
+            beforeImports: '// external import declarations:\n',
+            beforeLocal: `// dependencies in the same file (./${this.#fileName}):\n`,
+            beforeCode: '// test target code:\n'
+        });
+        const res = [];
+        const declareMap = {};
+        // for wc
+        const commonDeclares = {};
+        for (const module in data.importDeclares) {
+            const declares = data.importDeclares[module];
+            for (const declare of declares) {
+                if ((module === '@msnews/experiences-web-component' && declare.name === 'WebComponentExperience')
+                    || (module === '@cs-core/foundation' && ['attr', 'observable', 'volatile', 'FASTElement'].includes(declare.name))) {
+                    if (!commonDeclares[module]) {
+                        commonDeclares[module] = [];
+                    }
+                    commonDeclares[module].push(declare);
+                    // skip the declares of web component
+                    continue;
+                }
+                declareMap[declare.name] = module;
+            }
+        }
+        const ignoreFuncs = (0, config_1.getConfig)().common.ignoreFuncs;
+        for (let i = 0; i < data.classFunctions.length; i++) {
+            const member = data.classFunctions[i];
+            if (!this.isLineMatch(member.linesRange)) {
+                res.push(3 /* GenerateResult.Skip */);
+                continue;
+            }
+            if (!this.isLineRangeMatch(member.linesRange)) {
+                res.push(3 /* GenerateResult.Skip */);
+                continue;
+            }
+            // if this.options?.methods is not empty && current function is not in the methods set to gen test, skip it
+            if (this.options?.methods?.size && !this.options.methods.has(member.name)) {
+                continue;
+            }
+            if (ignoreFuncs?.has(`${data.name}.${member.name}`)
+                || ignoreFuncs?.has(`*.${member.name}`)) {
+                continue;
+            }
+            if (reactFunctionSet.has(member.name)) {
+                continue;
+            }
+            let existsSpec = this.isSpecExists(member.name, data.name);
+            let specCode;
+            if (existsSpec) {
+                if (!this.options?.repair) {
+                    this.progress(`Spec file exists (${existsSpec.filePath}), please use "Update test" to fix`);
+                    res.push(3 /* GenerateResult.Skip */);
+                    continue;
+                }
+                specCode = await this.readExistingSpec(existsSpec.filePath);
+            }
+            this.progress(`Generating test code for ${data.name}.${member.name}`);
+            // get mocks
+            const declares = {
+                ...commonDeclares
+            };
+            for (const [id] of member.externalIdentifiers || []) {
+                const module = declareMap[id];
+                if (!module) {
+                    continue;
+                }
+                if (!declares[module]) {
+                    declares[module] = [];
+                }
+                declares[module].push({ name: id, declare: '' });
+            }
+            const mockString = (0, deps_1.getPackageMocks)(declares);
+            let codeTmpl = mockString;
+            if (isDataConnector) {
+                codeTmpl += `\n${llm_1.Templates.dataConnector(data.name, member.name)}`;
+            }
+            const promptKey = specCode ? "RepairClassMemberUT" /* PromptKey.RepairClassMemberUT */ : "GenClassMemberUT" /* PromptKey.GenClassMemberUT */;
+            const messages = (0, llm_1.getPrompt)(promptKey, {
+                ["<<<SourceFileName>>>" /* PromptPlaceholder.SourceFileName */]: this.#fileName,
+                ["<<<ClassName>>>" /* PromptPlaceholder.ClassName */]: (0, common_1.formatImportName)(data.name, data.isDefaultExport),
+                ["<<<FunctionName>>>" /* PromptPlaceholder.FunctionName */]: member.name,
+                ["<<<SpecFileName>>>" /* PromptPlaceholder.SpecFileName */]: `./${this.#filePrefix}.${this.#testFileSpecifier}${this.#fileSuffix}`,
+                ["<<<ClassDeclare>>>" /* PromptPlaceholder.ClassDeclare */]: classDeclare,
+                ["<<<SourceCode>>>" /* PromptPlaceholder.SourceCode */]: member.body,
+                ["<<<MockCode>>>" /* PromptPlaceholder.MockCode */]: codeTmpl,
+                ["<<<Spec>>>" /* PromptPlaceholder.SpecCode */]: specCode,
+                ["<<<Language>>>" /* PromptPlaceholder.Language */]: (0, common_1.getLanguage)(this.#fileSuffix),
+                ["<<<ModuleType>>>" /* PromptPlaceholder.ModuleType */]: data.isCommonJS ? "cjs" /* ModuleType.CJS */ : "esm" /* ModuleType.ESM */,
+                ["<<<TestFramework>>>" /* PromptPlaceholder.TestFramework */]: this.testFramework,
+            }, this.options?.promptConfigs?.[promptKey]);
+            const taskRes = await this.runTask({
+                messages,
+                testName: `${data.name}.${member.name}`,
+                targetCode: member.body,
+                mockString,
+                className: data.name,
+                testFuncName: member.name,
+                moduleName: this.#fileName,
+                existsSpec
+            });
+            res.push(taskRes);
+        }
+        return res;
+    }
+    isLineMatch(pos) {
+        if (!this.options?.selectedLine) {
+            return true;
+        }
+        return this.options.selectedLine >= pos[0] && this.options.selectedLine <= pos[1];
+    }
+    isLineRangeMatch(pos) {
+        if (!this.options?.lineRanges || this.options?.lineRanges.length === 0) {
+            return true;
+        }
+        return this.options?.lineRanges.some(([start, end]) => {
+            return !(pos[1] < start || pos[0] > end);
+        });
+    }
+    isFunctionMatch(functionName) {
+        if (!this.options?.methods || this.options.methods.size === 0) {
+            return true;
+        }
+        return this.options.methods?.has(functionName);
+    }
+    async runTask(params) {
+        const retry = (0, config_1.getConfig)().common.retryCount ?? 0;
+        let result;
+        for (let i = 0; i <= retry; ++i) {
+            await (0, system_1.sleep)(10);
+            result = await this._runTask(params);
+            if (result !== 1 /* GenerateResult.Failed */) {
+                return result;
+            }
+        }
+        return result;
+    }
+    async _runTask(params) {
+        const { messages, testName, testFuncName, targetCode, mockString, existsSpec, className } = params;
+        if (this.#stopped) {
+            return 3 /* GenerateResult.Skip */;
+        }
+        const tempSpecFileName = path_1.default.resolve(this.tempTestFileDir, `${this.#filePrefix}.${testName}.gptgen.${this.#testFileSpecifier}${this.#fileSuffix}`);
+        let testCode = '';
+        try {
+            this.log(`Generating test code from GPT: ${testName}`);
+            this.progress(`Fetching code from AI`);
+            const res = await (0, llm_1.getLLMResponse)(messages, {
+                momentum: true,
+                flag: 'generateTestCode'
+            });
+            if (!res.success) {
+                this.progress(`Failed to get code from AI: ${res.message}`, { lastFailed: true, failed: true });
+                this.error('Unknown AI response', res);
+                return 6 /* GenerateResult.GPTException */;
+            }
+            testCode = (0, common_1.extractCodeFromResponse)(res.content);
+            if (!testCode) {
+                this.progress(`Failed to get code from AI`, { lastFailed: true });
+                this.error('Unknown AI response format', res);
+                return 6 /* GenerateResult.GPTException */;
+            }
+            testCode = (0, mock_1.checkMock)(testCode) || testCode;
+        }
+        catch (error) {
+            this.error('Error when generating test code', error);
+            return 6 /* GenerateResult.GPTException */;
+        }
+        if (this.#stopped) {
+            return 3 /* GenerateResult.Skip */;
+        }
+        let needRunTest = this.options?.runTest && !this.#isInWSL;
+        if (this.#isInWSL) {
+            this.progress(`Detected file in WSL environment, skip running test, please run test manually in WSL`, {
+                failed: true,
+                link: {
+                    url: 'https://eng.ms/docs/microsoft-ai/microsoft-ads-msn/feed-verticals/content-verticals/microsoft-weather/test-copilot/faq',
+                    title: 'FAQ'
+                }
+            });
+        }
+        if (!needRunTest) {
+            (0, console_1.getConsole)().log('Generated test code:', testCode);
+            (0, console_1.getConsole)().log('Skip running test');
+            const testFilePath = await this.writeSpecFile(testCode, testName);
+            this.progress(`Running Lint for ${testName}`);
+            await (0, lint_1.runLint)(testFilePath, this.projectFolder);
+            return 2 /* GenerateResult.Success */;
+        }
+        // Use ValidFix to validate and fix test code
+        const validFix = new validFix_1.ValidFix({
+            progress: this.options?.progress,
+            promptConfigs: this.options?.promptConfigs,
+            abortSignal: this.options?.abortSignal,
+            testFramework: this.testFramework
+        });
+        const validResult = await validFix.run({
+            targetName: testName,
+            targetSourceCode: targetCode,
+            sourceMockCode: mockString,
+            inputSpecCode: testCode,
+            sourceFilePath: this.filePath,
+            specFilePath: tempSpecFileName,
+            projectFolder: this.projectFolder,
+            testFileSpecifier: this.#testFileSpecifier,
+            maxRetry: 3,
+        });
+        let finalTestCode = validResult.code;
+        let testResult = validResult.testResult;
+        let success = validResult.status === 'valid';
+        if (fs_1.default.existsSync(tempSpecFileName)) {
+            const saveFailed = (0, config_1.getConfig)().common.saveFailed;
+            if (success || !saveFailed || this.#stopped) {
+                if (!saveFailed) {
+                    this.progress(`Removing temporary spec file: ${tempSpecFileName}`);
+                }
+                (0, system_1.removeFile)(tempSpecFileName);
+            }
+            else if (saveFailed) {
+                const newFile = tempSpecFileName.replace('.gptgen', '.failed');
+                fs_1.default.renameSync(tempSpecFileName, newFile);
+                fs_1.default.appendFileSync(newFile, `\n/*\n${JSON.stringify(testResult, null, 4)}\n*/`);
+            }
+        }
+        if (this.#stopped) {
+            return 3 /* GenerateResult.Skip */;
+        }
+        let validationRes = true;
+        try {
+            if (className) {
+                validationRes = (0, validateMockedTest_1.validateMockedClassTest)(finalTestCode, testFuncName, className, this.#fileName);
+            }
+            else {
+                validationRes = (0, validateMockedTest_1.validateMockedFuncTest)(finalTestCode, testFuncName, this.#fileName);
+            }
+        }
+        catch (error) {
+            this.error('Error when validating test code', error);
+        }
+        if (success && validationRes) {
+            const testFilePath = await this.writeSpecFile(finalTestCode, testName, existsSpec);
+            this.progress(`Running Lint autofix for ${testName}`);
+            const lintResult = await (0, lint_1.runLintWithAutofix)(testFilePath, this.testFramework, this.options?.abortSignal, this.projectFolder);
+            if (!lintResult.success) {
+                this.error(`Lint autofix failed for generated test file: ${testFilePath}`);
+                (0, system_1.removeFile)(testFilePath);
+                this.progress(`Lint autofix failed for ${testName}, removed the generated test file`, {
+                    failed: true,
+                    extra: {
+                        title: 'Lint info',
+                        content: `[Lint] Lint issues can't be autofixed for ${testName}, errors: ${lintResult.errors?.join('\n')}`
+                    }
+                });
+                return 1 /* GenerateResult.Failed */;
+            }
+            this.progress(`Success to generate test code for ${testName}`);
+            return 2 /* GenerateResult.Success */;
+        }
+        if (!testResult) {
+            this.error('[Remove] Unknown error when running test: undefined');
+            return 4 /* GenerateResult.Exception */;
+        }
+        if (!validationRes) {
+            this.log(`[Validate] The test for ${testName} does not test real logic`);
+            this.progress(`Failed to generate test code for ${testName}`, {
+                lastFailed: true,
+                extra: {
+                    title: 'Test info',
+                    content: `[Validate] The test for ${testName} does not test real logic`
+                }
+            });
+            return 1 /* GenerateResult.Failed */;
+        }
+        if (testResult.numFailedTestSuites === testResult.numTotalTestSuites && testResult.numFailedTests === testResult.numTotalTests) {
+            this.log('All test cases failed, skip');
+            this.progress(`Failed to generate test code for ${testName}`, {
+                lastFailed: true,
+                extra: {
+                    title: 'Test info',
+                    content: JSON.stringify(testResult, null, 4)
+                }
+            });
+            return 1 /* GenerateResult.Failed */;
+        }
+        // Use RemoveFailedCases to remove failed test cases
+        this.progress(`Removing failed cases`, { lastFailed: true });
+        const removeFailedCases = new removeFailedCases_1.RemoveFailedCases({
+            progress: this.options?.progress,
+            abortSignal: this.options?.abortSignal
+        });
+        const removeResult = await removeFailedCases.run({
+            inputSpecCode: finalTestCode,
+            targetName: testName,
+            inputFailedCases: validResult.failedCases || [],
+            sourceFilePath: this.filePath,
+            specFilePath: tempSpecFileName,
+            projectFolder: this.projectFolder
+        });
+        if (this.#stopped) {
+            return 3 /* GenerateResult.Skip */;
+        }
+        if (removeResult.status === 'success') {
+            const testFilePath = await this.writeSpecFile(removeResult.code, testName);
+            this.progress(`Running Lint autofix for ${testName}`);
+            const lintResult = await (0, lint_1.runLintWithAutofix)(testFilePath, this.testFramework, this.options?.abortSignal, this.projectFolder);
+            if (!lintResult.success) {
+                this.error(`Lint autofix failed for generated test file: ${testFilePath}`);
+                (0, system_1.removeFile)(testFilePath);
+                this.progress(`Lint autofix failed for ${testName}, removed the generated test file`, {
+                    failed: true,
+                    extra: {
+                        title: 'Lint info',
+                        content: `[Lint] Lint issues can't be autofixed for ${testName}, errors: ${lintResult.errors?.join('\n')}`
+                    }
+                });
+                return 1 /* GenerateResult.Failed */;
+            }
+            this.progress(`Success to generate test code for ${testName}`);
+            return 2 /* GenerateResult.Success */;
+        }
+        this.progress(`Failed to generate test code for ${testName}`, {
+            lastFailed: true,
+            extra: {
+                title: 'Test info',
+                content: JSON.stringify(testResult, null, 4)
+            }
+        });
+        return 1 /* GenerateResult.Failed */;
+    }
+    isSpecExists(targetFunctionName, className) {
+        // Check function level test file exists first
+        let filePath = this.isFunctionLevelTestExists(targetFunctionName, className);
+        if (filePath) {
+            this.progress(`Found [function level] test file: ${filePath}`);
+            return {
+                filePath,
+                isFileLevel: false
+            };
+        }
+        // If skip file level check, return directly
+        if (this.options?.skipFileLevelCheck) {
+            return undefined;
+        }
+        // If not found, check file level test file exists
+        filePath = this.isFileLevelTestExists(targetFunctionName);
+        if (filePath) {
+            this.progress(`Found [file level] test file: ${filePath}`);
+            return {
+                filePath,
+                isFileLevel: true
+            };
+        }
+        return undefined;
+    }
+    async readExistingSpec(specFilePath) {
+        let specCode = fs_1.default.readFileSync(specFilePath, 'utf8').toString();
+        const specDir = path_1.default.dirname(specFilePath);
+        // temporarily remove the file to the same directory as the source file
+        specCode = await (0, move_1.updateCodeReferences)(specDir, this.#fileDir, this.#fileName, specCode);
+        return specCode;
+    }
+    getSpecName(testName) {
+        return `${testName}.${this.#testFileSpecifier}${this.#fileSuffix}`;
+    }
+    isFileLevelTestExists(targetFunctionName) {
+        const fileNames = [`${this.#filePrefix}.${this.#testFileSpecifier}${this.#fileSuffix}`];
+        // for pergrine
+        if (this.#testFileSpecifier === 'web.spec') {
+            fileNames.push(`${this.#filePrefix}.${this.#testFileSpecifier.replace('.web', '')}${this.#fileSuffix}`);
+        }
+        else if (this.#testFileSpecifier === 'spec') {
+            fileNames.push(`${this.#filePrefix}.web.${this.#testFileSpecifier}${this.#fileSuffix}`);
+        }
+        const specDirs = [this.#fileDir];
+        if (this.#specDir !== this.#fileDir) {
+            specDirs.push(this.#specDir);
+        }
+        const checkList = specDirs.flatMap(dir => fileNames.map(fileName => path_1.default.resolve(dir, fileName)));
+        const filePath = this.checkFilesExist(checkList);
+        if (!filePath) {
+            return undefined;
+        }
+        const fileContent = fs_1.default.readFileSync(filePath, 'utf8').toString();
+        const regex = new RegExp(`\\b${targetFunctionName}\\b`, 'g');
+        return regex.test(fileContent) ? filePath : undefined;
+    }
+    isFunctionLevelTestExists(targetFunctionName, className) {
+        const testName = className ? `${className}.${targetFunctionName}` : targetFunctionName;
+        const filename = this.getSpecName(testName);
+        const oldSpecName = `${this.#filePrefix}.${testName}.${this.#testFileSpecifier}${this.#fileSuffix}`;
+        const oldWebSpecName = `${this.#filePrefix}.${testName}.web.${this.#testFileSpecifier}${this.#fileSuffix}`;
+        const rawSpecName = `${this.#filePrefix}.${this.#testFileSpecifier}${this.#fileSuffix}`;
+        return this.checkFilesExist([
+            path_1.default.resolve(this.#specDir, filename),
+            path_1.default.resolve(this.#specDir, rawSpecName),
+            path_1.default.resolve(this.#specDir, oldSpecName),
+            path_1.default.resolve(this.#specDir, oldWebSpecName),
+        ]);
+    }
+    checkFilesExist(files) {
+        return files.find(fs_1.default.existsSync);
+    }
+    toKebabCase(input) {
+        return input
+            .replace(/([a-z0-9])([A-Z])/g, '$1-$2') // insert - between lower & upper
+            .replace(/([A-Z])([A-Z][a-z])/g, '$1-$2') // handle consecutive uppercase scenarios, e.g. "TrackIDScroll" → "track-id-scroll"
+            .toLowerCase();
+    }
+}
+exports.UTGen = UTGen;
+//# sourceMappingURL=UTGen.js.map