Add Verify Setup Tool

eng/common/instructions/azsdk-tools/verify-setup.instructions.md

@@ -0,0 +1,10 @@
+---
+description: 'Verify Setup'
+---
+This tool verifies the developer's environment for SDK development and release tasks. It returns what requirements are missing for the specified languages and repo.
+
+Your goal is to identify the project repo root, and pass in the packagePath to the Verify Setup tool. For a language repo, pass in the language. For a non-language repo, do not pass in any languages to just check the core requirements. Summarize the output of the tool.
+
+For example, in `azure-sdk-for-js`, run `VerifySetup` with `(langs=javascript, packagePath=<path>/azure-sdk-for-js)`.
+
+Display results in a user-friendly and concise format, highlighting any missing dependencies or configuration issues that need to be addressed.

tools/azsdk-cli/Azure.Sdk.Tools.Cli.Tests/Tools/TypeSpec/TspClientUpdateToolTests.cs

@@ -119,6 +119,7 @@ private class SingleResolver : ILanguageSpecificResolver<IClientUpdateLanguageSe
         private readonly IClientUpdateLanguageService _svc;
         public SingleResolver(IClientUpdateLanguageService svc) { _svc = svc; }
         public Task<IClientUpdateLanguageService?> Resolve(string packagePath, CancellationToken ct = default) => Task.FromResult(_svc);
+        public List<IClientUpdateLanguageService?> Resolve(List<string> languages, CancellationToken ct = default) => languages.Select(_ => _svc).ToList();
     }
 }
 

tools/azsdk-cli/Azure.Sdk.Tools.Cli.Tests/Tools/Verify/VerifySetupToolTests.cs

@@ -0,0 +1,248 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+using System.CommandLine;
+using Moq;
+using Azure.Sdk.Tools.Cli.Helpers;
+using Azure.Sdk.Tools.Cli.Models;
+using Azure.Sdk.Tools.Cli.Services;
+using Azure.Sdk.Tools.Cli.Services.VerifySetup;
+using Azure.Sdk.Tools.Cli.Tests.TestHelpers;
+using Azure.Sdk.Tools.Cli.Tools.Verify;
+
+namespace Azure.Sdk.Tools.Cli.Tests.Tools.Verify;
+
+internal class VerifySetupToolTests
+{
+    private VerifySetupTool tool;
+    private Mock<IProcessHelper> mockProcessHelper;
+    private Mock<ILanguageSpecificResolver<IEnvRequirementsCheck>> mockEnvRequirementsCheck;
+    private TestLogger<VerifySetupTool> logger;
+
+    [SetUp]
+    public void Setup()
+    {
+        mockProcessHelper = new Mock<IProcessHelper>();
+        mockEnvRequirementsCheck = new Mock<ILanguageSpecificResolver<IEnvRequirementsCheck>>();
+        logger = new TestLogger<VerifySetupTool>();
+
+        tool = new VerifySetupTool(
+            mockProcessHelper.Object,
+            logger,
+            mockEnvRequirementsCheck.Object
+        );
+
+        SetupSuccessfulProcessMocks();
+    }
+
+    private void SetupSuccessfulProcessMocks()
+    {
+        var successfulCommands = new Dictionary<string, string>
+        {
+            { "node", "v22.16.0" },
+            { "npm", "10.5.0" },
+            { "tsp-client", "0.24.1" },
+            { "tsp", "1.0.1" },
+            { "pwsh", "PowerShell 7.2.0" },
+            { "gh", "gh version 2.30.0" },
+            { "python", "Python 3.9.0" },
+            { "java", "java 17.0.1" }
+        };
+
+        foreach (var (command, output) in successfulCommands)
+        {
+            mockProcessHelper
+                .Setup(x => x.Run(
+                    It.Is<ProcessOptions>(opt => opt.Command == command && (opt.Args.Contains("--version") || opt.Args.Contains("-version"))),
+                    It.IsAny<CancellationToken>()))
+                .ReturnsAsync(new ProcessResult 
+                { 
+                    ExitCode = 0, 
+                    OutputDetails = new List<(StdioLevel, string)> { (StdioLevel.StandardOutput, output) } 
+                });
+        }
+    }
+
+    private void SetupFailedProcessMock(string command, int exitCode = 1, string errorOutput = "Command not found")
+    {
+        mockProcessHelper
+            .Setup(x => x.Run(
+                It.Is<ProcessOptions>(opt => opt.Command == command && opt.Args.Contains("--version")),
+                It.IsAny<CancellationToken>()))
+            .ReturnsAsync(new ProcessResult 
+            { 
+                ExitCode = exitCode, 
+                OutputDetails = new List<(StdioLevel, string)> { (StdioLevel.StandardError, errorOutput) } 
+            });
+    }
+
+    private void SetupLanguageRequirementsMocks(Dictionary<string, (string requirement, string[] checkCommand, List<string> instructions)> languageSpecs)
+    {
+        mockEnvRequirementsCheck
+            .Setup(x => x.Resolve(It.IsAny<List<string>>(), It.IsAny<CancellationToken>()))
+            .Returns((List<string> langs, CancellationToken _) =>
+            {
+                var checkers = new List<IEnvRequirementsCheck?>();
+                foreach (var lang in langs)
+                {
+                    if (languageSpecs.ContainsKey(lang))
+                    {
+                        var mockChecker = new Mock<IEnvRequirementsCheck>();
+                        var spec = languageSpecs[lang];
+                        mockChecker
+                            .Setup(x => x.GetRequirements(It.IsAny<string>(), It.IsAny<CancellationToken>()))
+                            .ReturnsAsync(new List<SetupRequirements.Requirement>
+                            {
+                                new SetupRequirements.Requirement
+                                {
+                                    requirement = spec.requirement,
+                                    check = spec.checkCommand,
+                                    instructions = spec.instructions
+                                }
+                            });
+                        checkers.Add(mockChecker.Object);
+                    }
+                    else
+                    {
+                        checkers.Add(null); // Language not supported
+                    }
+                }
+                return checkers;
+            });
+    }
+
+    [Test]
+    public async Task VerifySetup_Succeeds_WhenAllRequirementsMet()
+    {
+        // Arrange
+        var languageSpecs = new Dictionary<string, (string, string[], List<string>)>
+        {
+            { "python", ("Python >= 3.8", new[] { "python", "--version" }, new List<string> { "Install Python 3.8 or higher" }) }
+        };
+        SetupLanguageRequirementsMocks(languageSpecs);
+
+        // Act
+        var result = await tool.VerifySetup(new List<string> { "python" }, "/test/path");
+
+        // Assert
+        Assert.That(result.AllRequirementsSatisfied, Is.True);
+        Assert.That(result.Results, Is.Empty);
+        Assert.That(result.ResponseError, Is.Null);
+    }
+
+    [Test]
+    public async Task VerifySetup_Fails_WhenSomeRequirementsNotMet()
+    {
+        var languageSpecs = new Dictionary<string, (string, string[], List<string>)>
+        {
+            { "python", ("Python >= 3.8", new[] { "python", "--version" }, new List<string> { "Install Python 3.8 or higher" }) }
+        };
+        SetupLanguageRequirementsMocks(languageSpecs);
+
+        SetupFailedProcessMock("node", 1, "node: command not found");
+
+        // Act
+        var result = await tool.VerifySetup(new List<string> { "python" }, "/test/path");
+
+        // Assert
+        Assert.That(result.AllRequirementsSatisfied, Is.False);
+        Assert.That(result.Results, Is.Not.Empty);
+        Assert.That(result.Results.Any(r => r.Requirement.Contains("Node.js")), Is.True);
+        Assert.That(result.ResponseError, Is.Null);
+    }
+
+    [Test]
+    public async Task VerifySetup_Fails_WhenSomeRequirementsVersionNotMet()
+    {
+        var languageSpecs = new Dictionary<string, (string, string[], List<string>)>
+        {
+            { "python", ("Python >= 3.14", new[] { "python", "--version" }, new List<string> { "Install Python 3.14 or higher" }) }
+        };
+        SetupLanguageRequirementsMocks(languageSpecs);
+
+        // Act
+        var result = await tool.VerifySetup(new List<string> { "python" }, "/test/path");
+
+        // Assert
+        Assert.That(result.AllRequirementsSatisfied, Is.False);
+        Assert.That(result.Results, Is.Not.Empty);
+        Assert.That(result.Results.Any(r => r.Requirement.Contains("Python")), Is.True);
+        Assert.That(result.ResponseError, Is.Null);
+    }
+
+    [Test]
+    public async Task VerifySetup_OnlyChecksSpecifiedLanguages()
+    {
+        // Arrange - Set up multiple language specs, but only request python
+        var languageSpecs = new Dictionary<string, (string, string[], List<string>)>
+        {
+            { "python", ("Python >= 3.8", new[] { "python", "--version" }, new List<string> { "Install Python 3.8" }) },
+            { "java", ("Java >= 17", new[] { "java", "-version" }, new List<string> { "Install Java 17" }) },
+            { "dotnet", (".NET >= 8.0", new[] { "dotnet", "--version" }, new List<string> { "Install .NET 8.0" }) }
+        };
+
+        SetupLanguageRequirementsMocks(languageSpecs);
+        SetupFailedProcessMock("java", 1, "java: command not found");
+
+        // Act
+        var result = await tool.VerifySetup(new List<string> { "python" }, "/test/path");
+
+        // Assert
+        Assert.That(result.AllRequirementsSatisfied, Is.True);
+        Assert.That(result.ResponseError, Is.Null);
+
+        // Verify that only Python language resolver was called, not Java or .NET
+        mockEnvRequirementsCheck.Verify(
+            x => x.Resolve(It.Is<List<string>>(langs => langs.Contains("python") && langs.Count == 1), It.IsAny<CancellationToken>()),
+            Times.Once);
+
+        mockEnvRequirementsCheck.Verify(
+            x => x.Resolve(It.Is<List<string>>(langs => langs.Contains("java")), It.IsAny<CancellationToken>()),
+            Times.Never);
+
+        mockEnvRequirementsCheck.Verify(
+            x => x.Resolve(It.Is<List<string>>(langs => langs.Contains("dotnet")), It.IsAny<CancellationToken>()),
+            Times.Never);
+    }
+
+    [Test]
+    public async Task VerifySetup_ChecksMultipleSpecifiedLanguages()
+    {
+        // Arrange
+        var languageSpecs = new Dictionary<string, (string, string[], List<string>)>
+        {
+            { "python", ("Python >= 3.8", new[] { "python", "--version" }, new List<string> { "Install Python 3.8" }) },
+            { "java", ("Java >= 17", new[] { "java", "-version" }, new List<string> { "Install Java 17" }) }
+        };
+
+        SetupLanguageRequirementsMocks(languageSpecs);
+
+        // Act - Request both Python and Java
+        var result = await tool.VerifySetup(new List<string> { "python", "java" }, "/test/path");
+
+        // Assert
+        Assert.That(result.AllRequirementsSatisfied, Is.True);
+        Assert.That(result.ResponseError, Is.Null);
+
+        // Verify that resolver was called with both languages
+        mockEnvRequirementsCheck.Verify(
+            x => x.Resolve(It.Is<List<string>>(langs => langs.Contains("python") && langs.Contains("java") && langs.Count == 2), It.IsAny<CancellationToken>()),
+            Times.Once);
+    }
+
+    [Test]
+    public async Task VerifySetup_HandlesInvalidLanguageInput()
+    {        
+        // Mock the resolver to return empty list for invalid languages (simulating no valid languages found)
+        mockEnvRequirementsCheck
+            .Setup(x => x.Resolve(It.IsAny<List<string>>(), It.IsAny<CancellationToken>()))
+            .Returns(new List<IEnvRequirementsCheck?>()); // Return empty list, not null
+
+        // Act - Pass invalid language
+        var result = await tool.VerifySetup(new List<string> { "invalidlang" }, "/test/path");
+
+        // Assert - Should succeed with just core requirements
+        Assert.That(result.AllRequirementsSatisfied, Is.True);
+        Assert.That(result.ResponseError, Is.Null);
+        Assert.That(result.Results, Is.Empty);
+    }
+}

tools/azsdk-cli/Azure.Sdk.Tools.Cli/Commands/SharedCommandGroups.cs

@@ -51,6 +51,12 @@ public static class SharedCommandGroups
             Options: []
         );
 
+        public static readonly CommandGroup Verify = new(
+            Verb: "verify",
+            Description: "Tools for verifying project environments.",
+            Options: []
+        );
+
 #if DEBUG
         public static readonly CommandGroup Example = new(
             Verb: "example",

tools/azsdk-cli/Azure.Sdk.Tools.Cli/Commands/SharedOptions.cs

@@ -10,6 +10,7 @@
 using Azure.Sdk.Tools.Cli.Tools.ReleasePlan;
 using Azure.Sdk.Tools.Cli.Tools.Example;
 using Azure.Sdk.Tools.Cli.Tools.TypeSpec;
+using Azure.Sdk.Tools.Cli.Tools.Verify;
 
 namespace Azure.Sdk.Tools.Cli.Commands
 {
@@ -40,6 +41,7 @@ public static class SharedOptions
             typeof(TypeSpecInitTool),
             typeof(TspClientUpdateTool),
             typeof(TypeSpecPublicRepoValidationTool),
+            typeof(VerifySetupTool),
             typeof(TestTool),
 #if DEBUG
             // only add these tools in debug mode