@codingame/monaco-vscode-testing-service-override 30.0.0 → 31.0.0

package/vscode/src/vs/workbench/contrib/testing/common/testingChatAgentTool.js

@@ -9,7 +9,6 @@ import { isAbsolute, basename } from '@codingame/monaco-vscode-api/vscode/vs/bas
 import { isDefined } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
 import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
-import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
 import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
 import { IUriIdentityService } from '@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
 import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
@@ -31,15 +30,17 @@ let TestingChatAgentToolContribution = class TestingChatAgentToolContribution ex
     static {
         this.ID = "workbench.contrib.testing.chatAgentTool";
     }
-    constructor(instantiationService, toolsService, contextKeyService) {
+    constructor(instantiationService, toolsService) {
         super();
         const runTestsTool = instantiationService.createInstance(RunTestTool);
         this._register(toolsService.registerTool(RunTestTool.DEFINITION, runTestsTool));
         this._register(toolsService.executeToolSet.addTool(RunTestTool.DEFINITION));
-        contextKeyService.createKey("chat.coreTestFailureToolEnabled", true).set(true);
+        const testFailureTool = instantiationService.createInstance(TestFailureTool);
+        this._register(toolsService.registerTool(TestFailureTool.DEFINITION, testFailureTool));
+        this._register(toolsService.executeToolSet.addTool(TestFailureTool.DEFINITION));
     }
 };
-TestingChatAgentToolContribution = ( __decorate([( __param(0, IInstantiationService)), ( __param(1, ILanguageModelToolsService)), ( __param(2, IContextKeyService))], TestingChatAgentToolContribution));
+TestingChatAgentToolContribution = ( __decorate([( __param(0, IInstantiationService)), ( __param(1, ILanguageModelToolsService))], TestingChatAgentToolContribution));
 let RunTestTool = class RunTestTool {
     static {
         this.ID = "runTests";
@@ -84,7 +85,7 @@ let RunTestTool = class RunTestTool {
                     }
                 }
             },
-            userDescription: ( localize(14665, "Run unit tests (optionally with coverage)")),
+            userDescription: ( localize(14821, "Run unit tests (optionally with coverage)")),
             source: ToolDataSource.Internal,
             tags: [
                 "vscode_editing_with_tests",
@@ -93,7 +94,7 @@ let RunTestTool = class RunTestTool {
                 "enable_other_tool_copilot_findFiles",
                 "enable_other_tool_copilot_runTests",
                 "enable_other_tool_copilot_runTestsWithCoverage",
-                "enable_other_tool_copilot_testFailure"
+                "enable_other_tool_testFailure"
             ]
         };
     }
@@ -123,11 +124,11 @@ let RunTestTool = class RunTestTool {
                     kind: "text",
                     value: "No tests found in the files. Ensure the correct absolute paths are passed to the tool."
                 }],
-                toolResultError: ( localize(14666, "No tests found in the files"))
+                toolResultError: ( localize(14822, "No tests found in the files"))
             };
         }
         progress.report({
-            message: ( localize(14667, "Starting test run..."))
+            message: ( localize(14823, "Starting test run..."))
         });
         if (group === TestRunProfileBitset.Coverage) {
             if (!( testCases.some(
@@ -144,7 +145,7 @@ let RunTestTool = class RunTestTool {
                     value: "No test run was started. Instruct the user to ensure their test runner is correctly configured"
                 }],
                 toolResultError: ( localize(
-                    14668,
+                    14824,
                     "No test run was started. This may be an issue with your test runner or extension."
                 ))
             };
@@ -155,9 +156,9 @@ let RunTestTool = class RunTestTool {
             return {
                 content: [{
                     kind: "text",
-                    value: ( localize(14669, "Test run was cancelled."))
+                    value: ( localize(14825, "Test run was cancelled."))
                 }],
-                toolResultMessage: ( localize(14669, "Test run was cancelled."))
+                toolResultMessage: ( localize(14825, "Test run was cancelled."))
             };
         }
         const summary = await buildTestRunSummary(result, mode, coverageFiles);
@@ -228,7 +229,7 @@ let RunTestTool = class RunTestTool {
             return tests;
         }
         progress.report({
-            message: ( localize(14670, "Filtering tests..."))
+            message: ( localize(14826, "Filtering tests..."))
         });
         const testNames = ( params.testNames.map(t => t.toLowerCase().trim()));
         const filtered = [];
@@ -257,7 +258,7 @@ let RunTestTool = class RunTestTool {
             return [...this._testService.collection.rootItems];
         }
         progress.report({
-            message: ( localize(14671, "Discovering tests..."))
+            message: ( localize(14827, "Discovering tests..."))
         });
         const firstWorkspaceFolder = this._workspaceContextService.getWorkspace().folders.at(0)?.uri;
         const uris = ( params.files.map(f => {
@@ -281,19 +282,76 @@ let RunTestTool = class RunTestTool {
     }
     prepareToolInvocation(context, token) {
         const params = context.parameters;
-        const title = ( localize(14672, "Allow test run?"));
+        const title = ( localize(14828, "Allow test run?"));
         const inFiles = params.files?.map(f => "`" + basename(f) + "`");
         return Promise.resolve({
-            invocationMessage: ( localize(14673, "Running tests...")),
+            invocationMessage: ( localize(14829, "Running tests...")),
             confirmationMessages: {
                 title,
-                message: inFiles?.length ? ( new MarkdownString()).appendMarkdown(( localize(14674, "The model wants to run tests in {0}.", inFiles.join(", ")))) : ( localize(14675, "The model wants to run all tests.")),
+                message: inFiles?.length ? ( new MarkdownString()).appendMarkdown(( localize(14830, "The model wants to run tests in {0}.", inFiles.join(", ")))) : ( localize(14831, "The model wants to run all tests.")),
                 allowAutoConfirm: true
             }
         });
     }
 };
 RunTestTool = ( __decorate([( __param(0, ITestService)), ( __param(1, IUriIdentityService)), ( __param(2, IWorkspaceContextService)), ( __param(3, ITestResultService)), ( __param(4, ITestProfileService))], RunTestTool));
+let TestFailureTool = class TestFailureTool {
+    static {
+        this.ID = "testFailure";
+    }
+    static {
+        this.DEFINITION = {
+            id: this.ID,
+            toolReferenceName: "testFailure",
+            legacyToolReferenceFullNames: ["copilot_testFailure"],
+            when: TestingContextKeys.hasAnyResults,
+            displayName: ( localize(14832, "Test failures")),
+            modelDescription: "Includes test failure information in the prompt. Use this tool to get the details of test failures from the most recent test run. If there are no failures yet, suggest running tests first.",
+            icon: Codicon.beaker,
+            inputSchema: {
+                type: "object",
+                properties: {}
+            },
+            userDescription: ( localize(14833, "Include test failure information")),
+            source: ToolDataSource.Internal,
+            tags: [
+                "vscode_editing_with_tests",
+                "enable_other_tool_copilot_readFile",
+                "enable_other_tool_copilot_listDirectory",
+                "enable_other_tool_copilot_findFiles",
+                "enable_other_tool_copilot_runTests"
+            ]
+        };
+    }
+    constructor(_testResultService) {
+        this._testResultService = _testResultService;
+    }
+    async invoke(invocation, countTokens, progress, token) {
+        const result = this._testResultService.results.find(r => r.tasks.length > 0);
+        if (!result) {
+            return {
+                content: [{
+                    kind: "text",
+                    value: "No test failures were found yet, call the runTests tool to run tests and find failures."
+                }]
+            };
+        }
+        const details = await getFailureDetails(result);
+        return {
+            content: [{
+                kind: "text",
+                value: details
+            }]
+        };
+    }
+    prepareToolInvocation(context, token) {
+        return Promise.resolve({
+            invocationMessage: ( localize(14834, "Finding test failures")),
+            pastTenseMessage: ( localize(14835, "Found test failures"))
+        });
+    }
+};
+TestFailureTool = ( __decorate([( __param(0, ITestResultService))], TestFailureTool));
 async function buildTestRunSummary(result, mode, coverageFiles) {
     const failures = result.counts[TestResultState.Errored] + result.counts[TestResultState.Failed];
     let str = `<summary passed=${result.counts[TestResultState.Passed]} failed=${failures} />\n`;
@@ -471,4 +529,4 @@ async function getFailureDetails(result) {
     return str;
 }
 
-export { RunTestTool, TestingChatAgentToolContribution, buildTestRunSummary, getCoverageSummary, getFailureDetails, getFileCoverageDetails, getOverallCoverageSummary, mergeLineRanges };
+export { RunTestTool, TestFailureTool, TestingChatAgentToolContribution, buildTestRunSummary, getCoverageSummary, getFailureDetails, getFileCoverageDetails, getOverallCoverageSummary, mergeLineRanges };

package/vscode/src/vs/workbench/contrib/testing/common/testingContentProvider.js

@@ -59,7 +59,7 @@ let TestingContentProvider = class TestingContentProvider {
                     return;
                 }
                 if (!hadContent) {
-                    append(( localize(14676, "The test run did not record any output.")));
+                    append(( localize(14836, "The test run did not record any output.")));
                     dispose.dispose();
                 }
             });

package/vscode/src/vs/workbench/contrib/testing/common/testingContextKeys.js

@@ -10,120 +10,120 @@ var TestingContextKeys;
     TestingContextKeys.canRefreshTests = ( new RawContextKey("testing.canRefresh", false, {
         type: "boolean",
         description: ( localize(
-            14677,
+            14837,
             "Indicates whether any test controller has an attached refresh handler."
         ))
     }));
     TestingContextKeys.isRefreshingTests = ( new RawContextKey("testing.isRefreshing", false, {
         type: "boolean",
         description: ( localize(
-            14678,
+            14838,
             "Indicates whether any test controller is currently refreshing tests."
         ))
     }));
     TestingContextKeys.isContinuousModeOn = ( new RawContextKey("testing.isContinuousModeOn", false, {
         type: "boolean",
-        description: ( localize(14679, "Indicates whether continuous test mode is on."))
+        description: ( localize(14839, "Indicates whether continuous test mode is on."))
     }));
     TestingContextKeys.hasDebuggableTests = ( new RawContextKey("testing.hasDebuggableTests", false, {
         type: "boolean",
         description: ( localize(
-            14680,
+            14840,
             "Indicates whether any test controller has registered a debug configuration"
         ))
     }));
     TestingContextKeys.hasRunnableTests = ( new RawContextKey("testing.hasRunnableTests", false, {
         type: "boolean",
         description: ( localize(
-            14681,
+            14841,
             "Indicates whether any test controller has registered a run configuration"
         ))
     }));
     TestingContextKeys.hasCoverableTests = ( new RawContextKey("testing.hasCoverableTests", false, {
         type: "boolean",
         description: ( localize(
-            14682,
+            14842,
             "Indicates whether any test controller has registered a coverage configuration"
         ))
     }));
     TestingContextKeys.hasNonDefaultProfile = ( new RawContextKey("testing.hasNonDefaultProfile", false, {
         type: "boolean",
         description: ( localize(
-            14683,
+            14843,
             "Indicates whether any test controller has registered a non-default configuration"
         ))
     }));
     TestingContextKeys.hasConfigurableProfile = ( new RawContextKey("testing.hasConfigurableProfile", false, {
         type: "boolean",
-        description: ( localize(14684, "Indicates whether any test configuration can be configured"))
+        description: ( localize(14844, "Indicates whether any test configuration can be configured"))
     }));
     TestingContextKeys.supportsContinuousRun = ( new RawContextKey("testing.supportsContinuousRun", false, {
         type: "boolean",
-        description: ( localize(14685, "Indicates whether continous test running is supported"))
+        description: ( localize(14845, "Indicates whether continuous test running is supported"))
     }));
     TestingContextKeys.isParentRunningContinuously = ( new RawContextKey("testing.isParentRunningContinuously", false, {
         type: "boolean",
         description: ( localize(
-            14686,
+            14846,
             "Indicates whether the parent of a test is continuously running, set in the menu context of test items"
         ))
     }));
     TestingContextKeys.activeEditorHasTests = ( new RawContextKey("testing.activeEditorHasTests", false, {
         type: "boolean",
-        description: ( localize(14687, "Indicates whether any tests are present in the current editor"))
+        description: ( localize(14847, "Indicates whether any tests are present in the current editor"))
     }));
     TestingContextKeys.cursorInsideTestRange = ( new RawContextKey("testing.cursorInsideTestRange", false, {
         type: "boolean",
-        description: ( localize(14688, "Whether the cursor is currently inside a test range"))
+        description: ( localize(14848, "Whether the cursor is currently inside a test range"))
     }));
     TestingContextKeys.isTestCoverageOpen = ( new RawContextKey("testing.isTestCoverageOpen", false, {
         type: "boolean",
-        description: ( localize(14689, "Indicates whether a test coverage report is open"))
+        description: ( localize(14849, "Indicates whether a test coverage report is open"))
     }));
     TestingContextKeys.hasCoverageInFile = ( new RawContextKey("testing.hasCoverageInFile", false, {
         type: "boolean",
-        description: ( localize(14690, "Indicates coverage has been reported in the curent editor."))
+        description: ( localize(14850, "Indicates coverage has been reported in the curent editor."))
     }));
     TestingContextKeys.hasPerTestCoverage = ( new RawContextKey("testing.hasPerTestCoverage", false, {
         type: "boolean",
-        description: ( localize(14691, "Indicates whether per-test coverage is available"))
+        description: ( localize(14851, "Indicates whether per-test coverage is available"))
     }));
     TestingContextKeys.hasInlineCoverageDetails = ( new RawContextKey("testing.hasInlineCoverageDetails", false, {
         type: "boolean",
         description: ( localize(
-            14692,
+            14852,
             "Indicates whether detailed per-line coverage is available for inline display"
         ))
     }));
     TestingContextKeys.isCoverageFilteredToTest = ( new RawContextKey("testing.isCoverageFilteredToTest", false, {
         type: "boolean",
-        description: ( localize(14693, "Indicates whether coverage has been filterd to a single test"))
+        description: ( localize(14853, "Indicates whether coverage has been filterd to a single test"))
     }));
     TestingContextKeys.coverageToolbarEnabled = ( new RawContextKey("testing.coverageToolbarEnabled", true, {
         type: "boolean",
-        description: ( localize(14694, "Indicates whether the coverage toolbar is enabled"))
+        description: ( localize(14854, "Indicates whether the coverage toolbar is enabled"))
     }));
     TestingContextKeys.inlineCoverageEnabled = ( new RawContextKey("testing.inlineCoverageEnabled", false, {
         type: "boolean",
-        description: ( localize(14695, "Indicates whether inline coverage is shown"))
+        description: ( localize(14855, "Indicates whether inline coverage is shown"))
     }));
     TestingContextKeys.canGoToRelatedCode = ( new RawContextKey("testing.canGoToRelatedCode", false, {
         type: "boolean",
         description: ( localize(
-            14696,
+            14856,
             "Whether a controller implements a capability to find code related to a test"
         ))
     }));
     TestingContextKeys.canGoToRelatedTest = ( new RawContextKey("testing.canGoToRelatedTest", false, {
         type: "boolean",
         description: ( localize(
-            14697,
+            14857,
             "Whether a controller implements a capability to find tests related to code"
         ))
     }));
     TestingContextKeys.peekHasStack = ( new RawContextKey("testing.peekHasStack", false, {
         type: "boolean",
-        description: ( localize(14698, "Whether the message shown in a peek view has a stack trace"))
+        description: ( localize(14858, "Whether the message shown in a peek view has a stack trace"))
     }));
     TestingContextKeys.capabilityToContextKey = {
         [TestRunProfileBitset.Run]: TestingContextKeys.hasRunnableTests,
@@ -142,54 +142,54 @@ var TestingContextKeys;
     TestingContextKeys.peekItemType = ( new RawContextKey("peekItemType", undefined, {
         type: "string",
         description: ( localize(
-            14699,
+            14859,
             "Type of the item in the output peek view. Either a \"test\", \"message\", \"task\", or \"result\"."
         ))
     }));
     TestingContextKeys.controllerId = ( new RawContextKey("controllerId", undefined, {
         type: "string",
-        description: ( localize(14700, "Controller ID of the current test item"))
+        description: ( localize(14860, "Controller ID of the current test item"))
     }));
     TestingContextKeys.testItemExtId = ( new RawContextKey("testId", undefined, {
         type: "string",
         description: ( localize(
-            14701,
+            14861,
             "ID of the current test item, set when creating or opening menus on test items"
         ))
     }));
     TestingContextKeys.testItemHasUri = ( new RawContextKey("testing.testItemHasUri", false, {
         type: "boolean",
-        description: ( localize(14702, "Boolean indicating whether the test item has a URI defined"))
+        description: ( localize(14862, "Boolean indicating whether the test item has a URI defined"))
     }));
     TestingContextKeys.testItemIsHidden = ( new RawContextKey("testing.testItemIsHidden", false, {
         type: "boolean",
-        description: ( localize(14703, "Boolean indicating whether the test item is hidden"))
+        description: ( localize(14863, "Boolean indicating whether the test item is hidden"))
     }));
     TestingContextKeys.testMessageContext = ( new RawContextKey("testMessage", undefined, {
         type: "string",
         description: ( localize(
-            14704,
+            14864,
             "Value set in `testMessage.contextValue`, available in editor/content and testing/message/context"
         ))
     }));
     TestingContextKeys.testResultOutdated = ( new RawContextKey("testResultOutdated", undefined, {
         type: "boolean",
         description: ( localize(
-            14705,
+            14865,
             "Value available in editor/content and testing/message/context when the result is outdated"
         ))
     }));
     TestingContextKeys.testResultState = ( new RawContextKey("testResultState", undefined, {
         type: "string",
         description: ( localize(
-            14706,
+            14866,
             "Value available testing/item/result indicating the state of the item."
         ))
     }));
     TestingContextKeys.testProfileContextGroup = ( new RawContextKey("testing.profile.context.group", undefined, {
         type: "string",
         description: ( localize(
-            14707,
+            14867,
             "Type of menu where the configure testing profile submenu exists. Either \"run\", \"debug\", or \"coverage\""
         ))
     }));

package/vscode/src/vs/workbench/contrib/testing/common/testingProgressMessages.js

@@ -43,10 +43,10 @@ const getTestProgressText = (
     }
     if (isRunning) {
         if (runSoFar === 0) {
-            return localize(14708, "Running tests...");
+            return localize(14868, "Running tests...");
         } else if (skipped === 0) {
             return localize(
-                14709,
+                14869,
                 "Running tests, {0}/{1} passed ({2}%)",
                 passed,
                 totalWillBeRun,
@@ -54,7 +54,7 @@ const getTestProgressText = (
             );
         } else {
             return localize(
-                14710,
+                14870,
                 "Running tests, {0}/{1} tests passed ({2}%, {3} skipped)",
                 passed,
                 totalWillBeRun,
@@ -65,7 +65,7 @@ const getTestProgressText = (
     } else {
         if (skipped === 0) {
             return localize(
-                14711,
+                14871,
                 "{0}/{1} tests passed ({2}%)",
                 passed,
                 runSoFar,
@@ -73,7 +73,7 @@ const getTestProgressText = (
             );
         } else {
             return localize(
-                14712,
+                14872,
                 "{0}/{1} tests passed ({2}%, {3} skipped)",
                 passed,
                 runSoFar,