Remove directory option in dotnet test (#50434)

Author: mariam-abdulla

src/Cli/dotnet/Commands/CliCommandStrings.resx

@@ -2629,12 +2629,12 @@ Proceed?</value>
   <data name="TestCommandUseProject" xml:space="preserve">
     <value>Specifying a project for 'dotnet test' should be via '--project'.</value>
   </data>
-  <data name="TestCommandUseDirectory" xml:space="preserve">
-    <value>Specifying a directory for 'dotnet test' should be via '--directory'.</value>
-  </data>
   <data name="TestCommandUseTestModules" xml:space="preserve">
     <value>Specifying dlls or executables for 'dotnet test' should be via '--test-modules'.</value>
   </data>
+  <data name="TestCommandUseDirectoryWithSwitch" xml:space="preserve">
+    <value>Specifying a directory for 'dotnet test' should be via '--project' or '--solution'.</value>
+  </data>
   <data name="PackCmdVersionDescription" xml:space="preserve">
     <value>The version of the package to create</value>
   </data>

src/Cli/dotnet/Commands/Test/MSBuildHandler.cs

@@ -32,16 +32,22 @@ public bool RunMSBuild()
         if (!string.IsNullOrEmpty(pathOptions.ProjectPath))
         {
             path = PathUtility.GetFullPath(pathOptions.ProjectPath);
-            msBuildExitCode = RunBuild(path, isSolution: false);
+
+            msBuildExitCode = Directory.Exists(path)
+                ? RunBuild(path, expectProject: true)
+                : RunBuild(path, isSolution: false);
         }
         else if (!string.IsNullOrEmpty(pathOptions.SolutionPath))
         {
             path = PathUtility.GetFullPath(pathOptions.SolutionPath);
-            msBuildExitCode = RunBuild(path, isSolution: true);
+
+            msBuildExitCode = Directory.Exists(path)
+                ? RunBuild(path, expectSolution: true)
+                : RunBuild(path, isSolution: true);
         }
         else
         {
-            path = PathUtility.GetFullPath(pathOptions.DirectoryPath ?? Directory.GetCurrentDirectory());
+            path = PathUtility.GetFullPath(Directory.GetCurrentDirectory());
             msBuildExitCode = RunBuild(path);
         }
 
@@ -54,9 +60,27 @@ public bool RunMSBuild()
         return true;
     }
 
-    private int RunBuild(string directoryPath)
+    private int RunBuild(string directoryPath, bool expectProject = false, bool expectSolution = false)
     {
-        (bool solutionOrProjectFileFound, string message) = SolutionAndProjectUtility.TryGetProjectOrSolutionFilePath(directoryPath, out string projectOrSolutionFilePath, out bool isSolution);
+        bool solutionOrProjectFileFound;
+        string message;
+        string projectOrSolutionFilePath;
+        bool isSolution;
+
+        if (expectProject)
+        {
+            (solutionOrProjectFileFound, message) = SolutionAndProjectUtility.TryGetProjectFilePath(directoryPath, out projectOrSolutionFilePath);
+            isSolution = false;
+        }
+        else if (expectSolution)
+        {
+            (solutionOrProjectFileFound, message) = SolutionAndProjectUtility.TryGetSolutionFilePath(directoryPath, out projectOrSolutionFilePath);
+            isSolution = true;
+        }
+        else
+        {
+            (solutionOrProjectFileFound, message) = SolutionAndProjectUtility.TryGetProjectOrSolutionFilePath(directoryPath, out projectOrSolutionFilePath, out isSolution);
+        }
 
         if (!solutionOrProjectFileFound)
         {

src/Cli/dotnet/Commands/Test/MSBuildUtility.cs

@@ -87,7 +87,6 @@ public static BuildOptions GetBuildOptions(ParseResult parseResult, int degreeOf
         PathOptions pathOptions = new(
             parseResult.GetValue(TestingPlatformOptions.ProjectOption),
             parseResult.GetValue(TestingPlatformOptions.SolutionOption),
-            parseResult.GetValue(TestingPlatformOptions.DirectoryOption),
             resultsDirectory,
             configFile,
             diagnosticOutputDirectory);

src/Cli/dotnet/Commands/Test/Options.cs

@@ -5,7 +5,7 @@ namespace Microsoft.DotNet.Cli.Commands.Test;
 
 internal record TestOptions(bool HasFilterMode, bool IsHelp);
 
-internal record PathOptions(string? ProjectPath, string? SolutionPath, string? DirectoryPath, string? ResultsDirectoryPath, string? ConfigFilePath, string? DiagnosticOutputDirectoryPath);
+internal record PathOptions(string? ProjectPath, string? SolutionPath, string? ResultsDirectoryPath, string? ConfigFilePath, string? DiagnosticOutputDirectoryPath);
 
 internal record BuildOptions(
     PathOptions PathOptions,
@@ -14,6 +14,6 @@ internal record BuildOptions(
     Utils.VerbosityOptions? Verbosity,
     bool NoLaunchProfile,
     bool NoLaunchProfileArguments,
-    int DegreeOfParallelism, 
+    int DegreeOfParallelism,
     List<string> UnmatchedTokens,
     IEnumerable<string> MSBuildArgs);

src/Cli/dotnet/Commands/Test/SolutionAndProjectUtility.cs

@@ -114,6 +114,56 @@ public static (bool SolutionOrProjectFileFound, string Message) TryGetProjectOrS
         return (true, string.Empty);
     }
 
+    public static (bool ProjectFileFound, string Message) TryGetProjectFilePath(string directory, out string projectFilePath)
+    {
+        projectFilePath = string.Empty;
+
+        if (!Directory.Exists(directory))
+        {
+            return (false, string.Format(CliCommandStrings.CmdNonExistentDirectoryErrorDescription, directory));
+        }
+
+        var actualProjectFiles = GetProjectFilePaths(directory);
+
+        if (actualProjectFiles.Length == 0)
+        {
+            return (false, string.Format(CliStrings.CouldNotFindAnyProjectInDirectory, directory));
+        }
+
+        if (actualProjectFiles.Length == 1)
+        {
+            projectFilePath = actualProjectFiles[0];
+            return (true, string.Empty);
+        }
+
+        return (false, string.Format(CliStrings.MoreThanOneProjectInDirectory, directory));
+    }
+
+    public static (bool SolutionFileFound, string Message) TryGetSolutionFilePath(string directory, out string solutionFilePath)
+    {
+        solutionFilePath = string.Empty;
+
+        if (!Directory.Exists(directory))
+        {
+            return (false, string.Format(CliCommandStrings.CmdNonExistentDirectoryErrorDescription, directory));
+        }
+
+        var actualSolutionFiles = GetSolutionFilePaths(directory);
+
+        if (actualSolutionFiles.Length == 0)
+        {
+            return (false, string.Format(CliStrings.SolutionDoesNotExist, directory + Path.DirectorySeparatorChar));
+        }
+
+        if (actualSolutionFiles.Length > 1)
+        {
+            return (false, string.Format(CliStrings.MoreThanOneSolutionInDirectory, directory + Path.DirectorySeparatorChar));
+        }
+
+        solutionFilePath = actualSolutionFiles[0];
+        return (true, string.Empty);
+    }
+
     private static string[] GetSolutionFilePaths(string directory) => [
             .. Directory.GetFiles(directory, CliConstants.SolutionExtensionPattern, SearchOption.TopDirectoryOnly),
             .. Directory.GetFiles(directory, CliConstants.SolutionXExtensionPattern, SearchOption.TopDirectoryOnly)

src/Cli/dotnet/Commands/Test/TestCommandParser.cs

@@ -2,7 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.CommandLine;
-using System.Diagnostics;
 using Microsoft.DotNet.Cli.Extensions;
 using Microsoft.Extensions.Configuration;
 
@@ -232,7 +231,6 @@ private static Command GetTestingPlatformCliCommand()
         command.SetAction(parseResult => command.Run(parseResult));
         command.Options.Add(TestingPlatformOptions.ProjectOption);
         command.Options.Add(TestingPlatformOptions.SolutionOption);
-        command.Options.Add(TestingPlatformOptions.DirectoryOption);
         command.Options.Add(TestingPlatformOptions.TestModulesFilterOption);
         command.Options.Add(TestingPlatformOptions.TestModulesRootDirectoryOption);
         command.Options.Add(TestingPlatformOptions.ResultsDirectoryOption);

src/Cli/dotnet/Commands/Test/TestingPlatformCommand.cs

@@ -6,13 +6,11 @@
 using System.CommandLine;
 using Microsoft.DotNet.Cli.Commands.Test.Terminal;
 using Microsoft.DotNet.Cli.Extensions;
-using Microsoft.DotNet.Cli.Utils;
 using Microsoft.TemplateEngine.Cli.Commands;
-using Microsoft.TemplateEngine.Cli.Help;
 
 namespace Microsoft.DotNet.Cli.Commands.Test;
 
-internal partial class TestingPlatformCommand : System.CommandLine.Command, ICustomHelp
+internal partial class TestingPlatformCommand : Command, ICustomHelp
 {
     private MSBuildHandler _msBuildHandler;
     private TerminalTestReporter _output;
@@ -47,7 +45,7 @@ private int RunInternal(ParseResult parseResult)
     {
         ValidationUtility.ValidateMutuallyExclusiveOptions(parseResult);
         ValidationUtility.ValidateSolutionOrProjectOrDirectoryOrModulesArePassedCorrectly(parseResult);
-        
+
         PrepareEnvironment(parseResult, out TestOptions testOptions, out int degreeOfParallelism);
 
         InitializeOutput(degreeOfParallelism, parseResult, testOptions.IsHelp);

src/Cli/dotnet/Commands/Test/TestingPlatformOptions.cs

@@ -4,7 +4,6 @@
 #nullable disable
 
 using System.CommandLine;
-using Microsoft.DotNet.Cli.Extensions;
 
 namespace Microsoft.DotNet.Cli.Commands.Test;
 
@@ -24,13 +23,6 @@ internal static class TestingPlatformOptions
         Arity = ArgumentArity.ExactlyOne
     };
 
-    public static readonly Option<string> DirectoryOption = new("--directory")
-    {
-        Description = CliCommandStrings.CmdDirectoryDescription,
-        HelpName = CliCommandStrings.CmdDirectoryPathName,
-        Arity = ArgumentArity.ExactlyOne
-    };
-
     public static readonly Option<string> TestModulesFilterOption = new("--test-modules")
     {
         Description = CliCommandStrings.CmdTestModulesDescription,

src/Cli/dotnet/Commands/Test/ValidationUtility.cs

@@ -23,9 +23,6 @@ static void ValidatePathOptions(ParseResult parseResult)
             if (parseResult.HasOption(TestingPlatformOptions.TestModulesFilterOption))
                 count++;
 
-            if (parseResult.HasOption(TestingPlatformOptions.DirectoryOption))
-                count++;
-
             if (parseResult.HasOption(TestingPlatformOptions.SolutionOption))
                 count++;
 
@@ -60,18 +57,12 @@ public static bool ValidateBuildPathOptions(BuildOptions buildPathOptions, Termi
 
         if (!string.IsNullOrEmpty(pathOptions.ProjectPath))
         {
-            return ValidateProjectFilePath(pathOptions.ProjectPath, output);
+            return ValidateProjectPath(pathOptions.ProjectPath, output);
         }
 
         if (!string.IsNullOrEmpty(pathOptions.SolutionPath))
         {
-            return ValidateSolutionFilePath(pathOptions.SolutionPath, output);
-        }
-
-        if (!string.IsNullOrEmpty(pathOptions.DirectoryPath) && !Directory.Exists(pathOptions.DirectoryPath))
-        {
-            output.WriteMessage(string.Format(CliCommandStrings.CmdNonExistentDirectoryErrorDescription, pathOptions.DirectoryPath));
-            return false;
+            return ValidateSolutionPath(pathOptions.SolutionPath, output);
         }
 
         return true;
@@ -105,39 +96,53 @@ public static void ValidateSolutionOrProjectOrDirectoryOrModulesArePassedCorrect
             {
                 throw new GracefulException(CliCommandStrings.TestCommandUseProject);
             }
-            else if (Directory.Exists(token))
-            {
-                throw new GracefulException(CliCommandStrings.TestCommandUseDirectory);
-            }
             else if ((token.EndsWith(".dll", StringComparison.OrdinalIgnoreCase) ||
                       token.EndsWith(".exe", StringComparison.OrdinalIgnoreCase)) &&
                      File.Exists(token))
             {
                 throw new GracefulException(CliCommandStrings.TestCommandUseTestModules);
             }
+            else if (Directory.Exists(token))
+            {
+                throw new GracefulException(CliCommandStrings.TestCommandUseDirectoryWithSwitch);
+            }
         }
     }
 
-    private static bool ValidateSolutionFilePath(string filePath, TerminalTestReporter output)
+    private static bool ValidateSolutionPath(string path, TerminalTestReporter output)
     {
-        if (!CliConstants.SolutionExtensions.Contains(Path.GetExtension(filePath)))
+        // If it's a directory, just check if it exists
+        if (Directory.Exists(path))
         {
-            output.WriteMessage(string.Format(CliCommandStrings.CmdInvalidSolutionFileExtensionErrorDescription, filePath));
+            return true;
+        }
+
+        // If it's not a directory, validate as a file path
+        if (!CliConstants.SolutionExtensions.Contains(Path.GetExtension(path)))
+        {
+            output.WriteMessage(string.Format(CliCommandStrings.CmdInvalidSolutionFileExtensionErrorDescription, path));
             return false;
         }
 
-        return ValidateFilePathExists(filePath, output);
+        return ValidateFilePathExists(path, output);
     }
 
-    private static bool ValidateProjectFilePath(string filePath, TerminalTestReporter output)
+    private static bool ValidateProjectPath(string path, TerminalTestReporter output)
     {
-        if (!Path.GetExtension(filePath).EndsWith("proj", StringComparison.OrdinalIgnoreCase))
+        // If it's a directory, just check if it exists
+        if (Directory.Exists(path))
+        {
+            return true;
+        }
+
+        // If it's not a directory, validate as a file path
+        if (!Path.GetExtension(path).EndsWith("proj", StringComparison.OrdinalIgnoreCase))
         {
-            output.WriteMessage(string.Format(CliCommandStrings.CmdInvalidProjectFileExtensionErrorDescription, filePath));
+            output.WriteMessage(string.Format(CliCommandStrings.CmdInvalidProjectFileExtensionErrorDescription, path));
             return false;
         }
 
-        return ValidateFilePathExists(filePath, output);
+        return ValidateFilePathExists(path, output);
     }
 
     private static bool ValidateFilePathExists(string filePath, TerminalTestReporter output)