Support --solution and --directory options in dotnet test

src/Cli/dotnet/commands/dotnet-test/CliConstants.cs

@@ -13,15 +13,28 @@ internal static class CliConstants
 
         public const string ServerOptionValue = "dotnettestcli";
 
-        public const string MSBuildExeName = "MSBuild.dll";
         public const string ParametersSeparator = "--";
+        public const string SemiColon = ";";
+        public const string Colon = ":";
 
         public const string VSTest = "VSTest";
         public const string MicrosoftTestingPlatform = "MicrosoftTestingPlatform";
 
         public const string TestSectionKey = "test";
 
         public const string RestoreCommand = "restore";
+
+        public static readonly string[] ProjectExtensions = { ".proj", ".csproj", ".vbproj", ".fsproj" };
+        public static readonly string[] SolutionExtensions = { ".sln", ".slnx" };
+
+        public const string ProjectExtensionPattern = "*.*proj";
+        public const string SolutionExtensionPattern = "*.sln";
+        public const string SolutionXExtensionPattern = "*.slnx";
+
+        public const string BinLogFileName = "msbuild.binlog";
+
+        public const string TestingPlatformVsTestBridgeRunSettingsFileEnvVar = "TESTINGPLATFORM_VSTESTBRIDGE_RUNSETTINGS_FILE";
+        public const string DLLExtension = "dll";
     }
 
     internal static class TestStates

src/Cli/dotnet/commands/dotnet-test/LocalizableStrings.resx

@@ -187,6 +187,12 @@
   <data name="CmdProjectDescription" xml:space="preserve">
     <value>Defines the path of the project file to run (folder name or full path). If not specified, it defaults to the current directory.</value>
   </data>
+  <data name="CmdSolutionDescription" xml:space="preserve">
+    <value>Defines the path of the solution file to run. If not specified, it defaults to the current directory.</value>
+  </data>
+  <data name="CmdDirectoryDescription" xml:space="preserve">
+    <value>Defines the path of directory to run. If not specified, it defaults to the current directory.</value>
+  </data>
   <data name="CmdResultsDirectoryDescription" xml:space="preserve">
     <value>The directory where the test results will be placed.
 The specified directory will be created if it does not exist.</value>
@@ -329,16 +335,28 @@ Examples:
   <data name="CmdUnsupportedTestRunnerDescription" xml:space="preserve">
     <value>Test runner not supported: {0}.</value>
   </data>
-  <data name="CmdNonExistentProjectFilePathDescription" xml:space="preserve">
-    <value>The provided project file path does not exist: {0}.</value>
+  <data name="CmdNonExistentFileErrorDescription" xml:space="preserve">
+    <value>The provided file path does not exist: {0}.</value>
+  </data>
+  <data name="CmdNonExistentDirectoryErrorDescription" xml:space="preserve">
+    <value>The provided directory path does not exist: {0}.</value>
   </data>
-  <data name="CmdMultipleProjectOrSolutionFilesErrorMessage" xml:space="preserve">
+  <data name="CmdMultipleProjectOrSolutionFilesErrorDescription" xml:space="preserve">
     <value>Specify which project or solution file to use because this folder contains more than one project or solution file.</value>
   </data>
-  <data name="CmdNoProjectOrSolutionFileErrorMessage" xml:space="preserve">
+  <data name="CmdNoProjectOrSolutionFileErrorDescription" xml:space="preserve">
     <value>Specify a project or solution file. The current working directory does not contain a project or solution file.</value>
   </data>
-  <data name="CmdMSBuildProjectsPropertiesErrorMessage" xml:space="preserve">
+  <data name="CmdMSBuildProjectsPropertiesErrorDescription" xml:space="preserve">
     <value>Get projects properties with MSBuild didn't execute properly with exit code: {0}.</value>
   </data>
+  <data name="CmdInvalidSolutionFileExtensionErrorDescription" xml:space="preserve">
+    <value>The provided solution file has an invalid extension: {0}.</value>
+  </data>
+  <data name="CmdInvalidProjectFileExtensionErrorDescription" xml:space="preserve">
+    <value>The provided project file has an invalid extension: {0}.</value>
+  </data>
+  <data name="CmdMultipleBuildPathOptionsErrorDescription" xml:space="preserve">
+    <value>Specify either the project, solution or directory option.</value>
+  </data>
 </root>

src/Cli/dotnet/commands/dotnet-test/MSBuildHandler.cs

@@ -6,6 +6,7 @@
 using Microsoft.Build.Execution;
 using Microsoft.Build.Framework;
 using Microsoft.Build.Logging;
+using Microsoft.DotNet.Tools.Test;
 
 namespace Microsoft.DotNet.Cli
 {
@@ -18,8 +19,6 @@ internal sealed class MSBuildHandler : IDisposable
         private readonly ConcurrentBag<TestApplication> _testApplications = new();
         private bool _areTestingPlatformApplications = true;
 
-        private const string BinLogFileName = "msbuild.binlog";
-        private const string Separator = ";";
         private static readonly Lock buildLock = new();
 
         public MSBuildHandler(List<string> args, TestApplicationActionQueue actionQueue, int degreeOfParallelism)
@@ -29,9 +28,86 @@ public MSBuildHandler(List<string> args, TestApplicationActionQueue actionQueue,
             _degreeOfParallelism = degreeOfParallelism;
         }
 
-        public async Task<int> RunWithMSBuild()
+        public async Task<bool> RunMSBuild(BuildPathsOptions buildPathOptions)
         {
-            bool solutionOrProjectFileFound = SolutionAndProjectUtility.TryGetProjectOrSolutionFilePath(Directory.GetCurrentDirectory(), out string projectOrSolutionFilePath, out bool isSolution);
+            if (!ValidateBuildPathOptions(buildPathOptions))
+            {
+                return false;
+            }
+
+            int msbuildExitCode;
+
+            if (!string.IsNullOrEmpty(buildPathOptions.ProjectPath))
+            {
+                msbuildExitCode = await RunBuild(buildPathOptions.ProjectPath, isSolution: false);
+            }
+            else if (!string.IsNullOrEmpty(buildPathOptions.SolutionPath))
+            {
+                msbuildExitCode = await RunBuild(buildPathOptions.SolutionPath, isSolution: true);
+            }
+            else
+            {
+                msbuildExitCode = await RunBuild(buildPathOptions.DirectoryPath ?? Directory.GetCurrentDirectory());
+            }
+
+            if (msbuildExitCode != ExitCodes.Success)
+            {
+                VSTestTrace.SafeWriteTrace(() => string.Format(LocalizableStrings.CmdMSBuildProjectsPropertiesErrorDescription, msbuildExitCode));
+                return false;
+            }
+
+            return true;
+        }
+
+        private bool ValidateBuildPathOptions(BuildPathsOptions buildPathOptions)
+        {
+            if ((!string.IsNullOrEmpty(buildPathOptions.ProjectPath) && !string.IsNullOrEmpty(buildPathOptions.SolutionPath)) ||
+                (!string.IsNullOrEmpty(buildPathOptions.ProjectPath) && !string.IsNullOrEmpty(buildPathOptions.DirectoryPath)) ||
+                (!string.IsNullOrEmpty(buildPathOptions.SolutionPath) && !string.IsNullOrEmpty(buildPathOptions.DirectoryPath)))
+            {
+                VSTestTrace.SafeWriteTrace(() => LocalizableStrings.CmdMultipleBuildPathOptionsErrorDescription);
+                return false;
+            }
+
+            if (!string.IsNullOrEmpty(buildPathOptions.ProjectPath))
+            {
+                return ValidateFilePath(buildPathOptions.ProjectPath, CliConstants.ProjectExtensions, LocalizableStrings.CmdInvalidProjectFileExtensionErrorDescription);
+            }
+
+            if (!string.IsNullOrEmpty(buildPathOptions.SolutionPath))
+            {
+                return ValidateFilePath(buildPathOptions.SolutionPath, CliConstants.SolutionExtensions, LocalizableStrings.CmdInvalidSolutionFileExtensionErrorDescription);
+            }
+
+            if (!string.IsNullOrEmpty(buildPathOptions.DirectoryPath) && !Directory.Exists(buildPathOptions.DirectoryPath))
+            {
+                VSTestTrace.SafeWriteTrace(() => string.Format(LocalizableStrings.CmdNonExistentDirectoryErrorDescription, Path.GetFullPath(buildPathOptions.DirectoryPath)));
+                return false;
+            }
+
+            return true;
+        }
+
+        private static bool ValidateFilePath(string filePath, string[] validExtensions, string errorMessage)
+        {
+            if (!validExtensions.Contains(Path.GetExtension(filePath)))
+            {
+                VSTestTrace.SafeWriteTrace(() => string.Format(errorMessage, filePath));
+                return false;
+            }
+
+            if (!File.Exists(filePath))
+            {
+                VSTestTrace.SafeWriteTrace(() => string.Format(LocalizableStrings.CmdNonExistentFileErrorDescription, Path.GetFullPath(filePath)));
+                return false;
+            }
+
+            return true;
+        }
+
+        private async Task<int> RunBuild(string directoryPath)
+        {
+            bool solutionOrProjectFileFound = SolutionAndProjectUtility.TryGetProjectOrSolutionFilePath(directoryPath, out string projectOrSolutionFilePath, out bool isSolution);
 
             if (!solutionOrProjectFileFound)
             {
@@ -45,9 +121,9 @@ public async Task<int> RunWithMSBuild()
             return restored ? ExitCodes.Success : ExitCodes.GenericFailure;
         }
 
-        public async Task<int> RunWithMSBuild(string filePath)
+        private async Task<int> RunBuild(string filePath, bool isSolution)
         {
-            (IEnumerable<Module> modules, bool restored) = await GetProjectsProperties(filePath, false);
+            (IEnumerable<Module> modules, bool restored) = await GetProjectsProperties(filePath, isSolution);
 
             InitializeTestApplications(modules);
 
@@ -92,7 +168,12 @@ public bool EnqueueTestApplications()
 
             if (isSolution)
             {
-                var projects = await SolutionAndProjectUtility.ParseSolution(solutionOrProjectFilePath);
+                string fileDirectory = Path.GetDirectoryName(solutionOrProjectFilePath);
+                string rootDirectory = string.IsNullOrEmpty(fileDirectory)
+                    ? Directory.GetCurrentDirectory()
+                    : fileDirectory;
+
+                var projects = await SolutionAndProjectUtility.ParseSolution(solutionOrProjectFilePath, rootDirectory);
                 ProcessProjectsInParallel(projects, allProjects, ref restored);
             }
             else
@@ -178,7 +259,7 @@ private static IEnumerable<Module> ExtractModulesFromProject(Project project)
             }
             else
             {
-                var frameworks = targetFrameworks.Split(Separator, StringSplitOptions.RemoveEmptyEntries);
+                var frameworks = targetFrameworks.Split(CliConstants.SemiColon, StringSplitOptions.RemoveEmptyEntries);
                 foreach (var framework in frameworks)
                 {
                     project.SetProperty(ProjectProperties.TargetFramework, framework);
@@ -225,8 +306,7 @@ private static BuildResult RestoreProject(string projectFilePath, ProjectCollect
 
         private static bool IsBinaryLoggerEnabled(List<string> args, out string binLogFileName)
         {
-            binLogFileName = BinLogFileName;
-
+            binLogFileName = string.Empty;
             var binLogArgs = new List<string>();
 
             foreach (var arg in args)
@@ -248,10 +328,16 @@ private static bool IsBinaryLoggerEnabled(List<string> args, out string binLogFi
                 // Get BinLog filename
                 var binLogArg = binLogArgs.LastOrDefault();
 
-                if (binLogArg.Contains(':'))
+                if (binLogArg.Contains(CliConstants.Colon))
                 {
-                    binLogFileName = binLogArg.Split(':')[1];
+                    var parts = binLogArg.Split(CliConstants.Colon, 2);
+                    binLogFileName = !string.IsNullOrEmpty(parts[1]) ? parts[1] : CliConstants.BinLogFileName;
                 }
+                else
+                {
+                    binLogFileName = CliConstants.BinLogFileName;
+                }
+
                 return true;
             }
 

src/Cli/dotnet/commands/dotnet-test/Options.cs

@@ -0,0 +1,9 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.DotNet.Cli
+{
+    internal record BuildConfigurationOptions(bool HasNoRestore, bool HasNoBuild, string Configuration, string Architecture);
+
+    internal record BuildPathsOptions(string ProjectPath, string SolutionPath, string DirectoryPath);
+}

src/Cli/dotnet/commands/dotnet-test/SolutionAndProjectUtility.cs

@@ -21,80 +21,63 @@ public static bool TryGetProjectOrSolutionFilePath(string directory, out string
                 return false;
             }
 
-            string[] possibleSolutionPaths = [
-                ..Directory.GetFiles(directory, "*.sln", SearchOption.TopDirectoryOnly),
-                    ..Directory.GetFiles(directory, "*.slnx", SearchOption.TopDirectoryOnly)];
+            var possibleSolutionPaths = GetSolutionFilePaths(directory);
 
-                // If more than a single sln file is found, an error is thrown since we can't determine which one to choose.
-                if (possibleSolutionPaths.Length > 1)
-                {
-                    VSTestTrace.SafeWriteTrace(() => string.Format(CommonLocalizableStrings.MoreThanOneSolutionInDirectory, directory));
-                    return false;
-                }
-                // If a single solution is found, use it.
-                else if (possibleSolutionPaths.Length == 1)
-                {
-                    // Get project file paths to check if there are any projects in the directory
-                    string[] possibleProjectPaths = GetProjectFilePaths(directory);
+            // If more than a single sln file is found, an error is thrown since we can't determine which one to choose.
+            if (possibleSolutionPaths.Length > 1)
+            {
+                VSTestTrace.SafeWriteTrace(() => string.Format(CommonLocalizableStrings.MoreThanOneSolutionInDirectory, directory));
+                return false;
+            }
+
+            if (possibleSolutionPaths.Length == 1)
+            {
+                var possibleProjectPaths = GetProjectFilePaths(directory);
 
                 if (possibleProjectPaths.Length == 0)
                 {
                     projectOrSolutionFilePath = possibleSolutionPaths[0];
                     isSolution = true;
                     return true;
                 }
-                else // If both solution and project files are found, return false
-                {
-                    VSTestTrace.SafeWriteTrace(() => LocalizableStrings.CmdMultipleProjectOrSolutionFilesErrorMessage);
-                    return false;
-                }
+
+                VSTestTrace.SafeWriteTrace(() => LocalizableStrings.CmdMultipleProjectOrSolutionFilesErrorDescription);
+                return false;
             }
-            // If no solutions are found, look for a project file
-            else
+            else  // If no solutions are found, look for a project file
             {
                 string[] possibleProjectPath = GetProjectFilePaths(directory);
 
-                // No projects found throws an error that no sln nor projects were found
                 if (possibleProjectPath.Length == 0)
                 {
-                    VSTestTrace.SafeWriteTrace(() => LocalizableStrings.CmdNoProjectOrSolutionFileErrorMessage);
+                    VSTestTrace.SafeWriteTrace(() => LocalizableStrings.CmdNoProjectOrSolutionFileErrorDescription);
                     return false;
                 }
-                // A single project found, use it
-                else if (possibleProjectPath.Length == 1)
+
+                if (possibleProjectPath.Length == 1)
                 {
                     projectOrSolutionFilePath = possibleProjectPath[0];
                     return true;
                 }
-                // More than one project found. Not sure which one to choose
-                else
-                {
-                    VSTestTrace.SafeWriteTrace(() => string.Format(CommonLocalizableStrings.MoreThanOneProjectInDirectory, directory));
-                    return false;
-                }
+
+                VSTestTrace.SafeWriteTrace(() => string.Format(CommonLocalizableStrings.MoreThanOneProjectInDirectory, directory));
+
+                return false;
             }
         }
 
-
-        private static string[] GetProjectFilePaths(string directory)
+        private static string[] GetSolutionFilePaths(string directory)
         {
-            var projectFiles = Directory.EnumerateFiles(directory, "*.*proj", SearchOption.TopDirectoryOnly)
-                .Where(IsProjectFile)
+            return Directory.EnumerateFiles(directory, CliConstants.SolutionExtensionPattern, SearchOption.TopDirectoryOnly)
+                .Concat(Directory.EnumerateFiles(directory, CliConstants.SolutionXExtensionPattern, SearchOption.TopDirectoryOnly))
                 .ToArray();
-
-            return projectFiles;
         }
 
-        private static bool IsProjectFile(string filePath)
-        {
-            var extension = Path.GetExtension(filePath);
-            return extension.Equals(".csproj", StringComparison.OrdinalIgnoreCase) ||
-                   extension.Equals(".vbproj", StringComparison.OrdinalIgnoreCase) ||
-                   extension.Equals(".fsproj", StringComparison.OrdinalIgnoreCase) ||
-                   extension.Equals(".proj", StringComparison.OrdinalIgnoreCase);
-        }
+        private static string[] GetProjectFilePaths(string directory) => [.. Directory.EnumerateFiles(directory, CliConstants.ProjectExtensionPattern, SearchOption.TopDirectoryOnly).Where(IsProjectFile)];
+
+        private static bool IsProjectFile(string filePath) => CliConstants.ProjectExtensions.Contains(Path.GetExtension(filePath), StringComparer.OrdinalIgnoreCase);
 
-        public static async Task<IEnumerable<string>> ParseSolution(string solutionFilePath)
+        public static async Task<IEnumerable<string>> ParseSolution(string solutionFilePath, string directory)
         {
             if (string.IsNullOrEmpty(solutionFilePath))
             {
@@ -119,7 +102,7 @@ public static async Task<IEnumerable<string>> ParseSolution(string solutionFileP
 
             if (solution is not null)
             {
-                projectsPaths = [.. solution.SolutionProjects.Select(project => Path.GetFullPath(project.FilePath))];
+                projectsPaths.AddRange(solution.SolutionProjects.Select(project => Path.Combine(directory, project.FilePath)));
             }
 
             return projectsPaths;