public void It_resolves_desktop_apps_with_MSBuild_defaulting_to_Debug_Configuration() { var configuration = "Debug"; var testAssetManager = new TestAssetsManager(Path.Combine(RepoRoot, "TestAssets", "TestProjects")); var testInstance = testAssetManager.CreateTestInstance("MSBuildAppWithMultipleFrameworksAndTools", "i") .WithLockFiles(); var projectFile = Path.Combine(testInstance.TestRoot, "MSBuildAppWithMultipleFrameworksAndTools.csproj"); new Restore3Command() .ExecuteWithCapturedOutput($"{projectFile} -s {_repoDirectoriesProvider.TestPackages}") .Should() .Pass(); new Build3Command() .Execute($"{projectFile} --configuration {configuration}") .Should() .Pass(); var factory = new ProjectDependenciesCommandFactory( s_desktopTestFramework, null, null, null, testInstance.TestRoot); var command = factory.Create("dotnet-desktop-and-portable", null); command.CommandName.Should().Contain(Path.Combine(testInstance.TestRoot, "bin", configuration)); Path.GetFileName(command.CommandName).Should().Be("dotnet-desktop-and-portable.exe"); }
public void It_resolves_desktop_apps_when_configuration_is_Release() { var configuration = "Debug"; var testInstance = TestAssets.Get(TestAssetKinds.DesktopTestProjects, "AppWithProjTool2Fx") .CreateInstance() .WithSourceFiles() .WithNuGetConfig(_repoDirectoriesProvider.TestPackages); var restoreCommand = new RestoreCommand() .WithWorkingDirectory(testInstance.Root) .ExecuteWithCapturedOutput() .Should().Pass(); var buildCommand = new BuildCommand() .WithWorkingDirectory(testInstance.Root) .WithConfiguration(configuration) .WithCapturedOutput() .Execute() .Should().Pass(); var factory = new ProjectDependenciesCommandFactory( s_desktopTestFramework, configuration, null, null, testInstance.Root.FullName); var command = factory.Create("dotnet-desktop-and-portable", null); command.CommandName.Should().Contain(testInstance.Root.GetDirectory("bin", configuration).FullName); Path.GetFileName(command.CommandName).Should().Be("dotnet-desktop-and-portable.exe"); }
public static int Main(string[] args) { DebugHelper.HandleDebugSwitch(ref args); var dotnetParams = new DotnetBaseParams("dotnet-dependency-tool-invoker", "DotNet Dependency Tool Invoker", "Invokes tools declared as NuGet dependencies of a project"); dotnetParams.Parse(args); if (string.IsNullOrEmpty(dotnetParams.Command)) { Console.WriteLine("A command name must be provided"); return(1); } var commandFactory = new ProjectDependenciesCommandFactory( dotnetParams.Framework, dotnetParams.Config, dotnetParams.Output, dotnetParams.BuildBasePath, dotnetParams.ProjectPath); var result = InvokeDependencyToolForMSBuild(commandFactory, dotnetParams); return(result); }
private static int RunConsole( ProjectContext projectContext, CommandLineApplication app, string testRunner, string configuration, string outputPath) { var commandArgs = new List <string> { GetAssemblyUnderTest(projectContext, configuration, outputPath) }; commandArgs.AddRange(app.RemainingArguments); var commandFactory = new ProjectDependenciesCommandFactory( projectContext.TargetFramework, configuration, outputPath, projectContext.ProjectDirectory); return(commandFactory.Create( $"dotnet-{GetCommandName(testRunner)}", commandArgs, projectContext.TargetFramework, configuration) .ForwardStdErr() .ForwardStdOut() .Execute() .ExitCode); }
private static int InvokeDependencyTool( ProjectDependenciesCommandFactory commandFactory, DotnetBaseParams dotnetParams, NuGetFramework framework) { try { var exitCode = commandFactory.Create( $"dotnet-{dotnetParams.Command}", dotnetParams.RemainingArguments, framework, dotnetParams.Config) .ForwardStdErr() .ForwardStdOut() .Execute() .ExitCode; Console.WriteLine($"Command returned {exitCode}"); } catch (CommandUnknownException) { Console.WriteLine($"Command not found"); return(1); } return(0); }
public void It_resolves_tools_whose_package_name_is_different_than_dll_name() { Environment.SetEnvironmentVariable( Constants.MSBUILD_EXE_PATH, Path.Combine(new RepoDirectoriesProvider().Stage2Sdk, "MSBuild.dll")); var configuration = "Debug"; var testInstance = TestAssets.Get("AppWithDirectDepWithOutputName") .CreateInstance() .WithSourceFiles() .WithRestoreFiles(); var buildCommand = new BuildCommand() .WithProjectDirectory(testInstance.Root) .WithConfiguration(configuration) .WithCapturedOutput() .Execute() .Should().Pass(); var factory = new ProjectDependenciesCommandFactory( NuGetFrameworks.NetCoreApp22, configuration, null, null, testInstance.Root.FullName); var command = factory.Create("dotnet-tool-with-output-name", null); command.CommandArgs.Should().Contain( Path.Combine("toolwithoutputname", "1.0.0", "lib", "netcoreapp2.2", "dotnet-tool-with-output-name.dll")); }
public void It_resolves_desktop_apps_when_configuration_is_Debug() { var configuration = "Debug"; var testAssetManager = new TestAssetsManager(Path.Combine(RepoRoot, "TestAssets", "DesktopTestProjects")); var testInstance = testAssetManager.CreateTestInstance("AppWithDirectDependencyDesktopAndPortable") .WithLockFiles(); var buildCommand = new BuildCommand( Path.Combine(testInstance.TestRoot, "project.json"), configuration: configuration) .ExecuteWithCapturedOutput() .Should() .Pass(); var context = ProjectContext.Create(testInstance.TestRoot, s_desktopTestFramework); var factory = new ProjectDependenciesCommandFactory( s_desktopTestFramework, configuration, null, null, testInstance.TestRoot); var command = factory.Create("dotnet-desktop-and-portable", null); command.CommandName.Should().Contain(Path.Combine(testInstance.TestRoot, "bin", configuration)); Path.GetFileName(command.CommandName).Should().Be("dotnet-desktop-and-portable.exe"); }
public void It_resolves_desktop_apps_when_configuration_is_Release() { var configuration = "Release"; var testAssetManager = new TestAssetsManager(Path.Combine(RepoRoot, "TestAssets", "DesktopTestProjects")); var testInstance = testAssetManager.CreateTestInstance("AppWithDirectDependencyDesktopAndPortable") .WithLockFiles(); var buildCommand = new BuildCommand( Path.Combine(testInstance.TestRoot, "project.json"), configuration: configuration) .ExecuteWithCapturedOutput() .Should() .Pass(); var context = ProjectContext.Create(testInstance.TestRoot, s_desktopTestFramework); var factory = new ProjectDependenciesCommandFactory( s_desktopTestFramework, configuration, null, null, testInstance.TestRoot); var command = factory.Create("dotnet-desktop-and-portable", null); command.CommandName.Should().Contain(Path.Combine(testInstance.TestRoot, "bin", configuration)); Path.GetFileName(command.CommandName).Should().Be("dotnet-desktop-and-portable.exe"); }
public void It_resolves_tools_whose_package_name_is_different_than_dll_name() { var configuration = "Debug"; var testAssetManager = new TestAssetsManager(Path.Combine(RepoRoot, "TestAssets", "TestProjects")); var testInstance = testAssetManager.CreateTestInstance("AppWithDirectDependencyWithOutputName") .WithLockFiles(); var buildCommand = new BuildCommand( Path.Combine(testInstance.TestRoot, "project.json"), configuration: configuration) .ExecuteWithCapturedOutput() .Should() .Pass(); var context = ProjectContext.Create(testInstance.TestRoot, FrameworkConstants.CommonFrameworks.NetCoreApp10); var factory = new ProjectDependenciesCommandFactory( FrameworkConstants.CommonFrameworks.NetCoreApp10, configuration, null, null, testInstance.TestRoot); var command = factory.Create("dotnet-tool-with-output-name", null); command.CommandArgs.Should().Contain( Path.Combine("ToolWithOutputName", "1.0.0", "lib", "netcoreapp1.0", "dotnet-tool-with-output-name.dll")); }
private static int InvokeDependencyTool( ProjectDependenciesCommandFactory commandFactory, string command, NuGetFramework framework, string configuration, IEnumerable <string> appArguments) { try { var exitCode = commandFactory.Create( $"dotnet-{command}", appArguments, framework, configuration) .ForwardStdErr() .ForwardStdOut() .Execute() .ExitCode; Console.WriteLine($"Command returned {exitCode}"); } catch (CommandUnknownException) { Console.WriteLine($"Command not found"); return(1); } return(0); }
public static ICommand CreateDispatchCommand( IEnumerable <string> dispatchArgs, NuGetFramework framework, string configuration, string outputPath, string buildBasePath, string projectDirectory, string toolName) { if (buildBasePath != null && !Path.IsPathRooted(buildBasePath)) { // ProjectDependenciesCommandFactory cannot handle relative build base paths. buildBasePath = Path.Combine(Directory.GetCurrentDirectory(), buildBasePath); } configuration = configuration ?? Constants.DefaultConfiguration; var commandFactory = new ProjectDependenciesCommandFactory( framework, configuration, outputPath, buildBasePath, projectDirectory); var dispatcherVersionArgumentValue = ResolveDispatcherVersionArgumentValue(DispatcherName); var dispatchArgsList = new List <string>(dispatchArgs) { DispatcherVersionArgumentName, dispatcherVersionArgumentValue }; return(commandFactory.Create(toolName, dispatchArgsList, framework, configuration)); }
private static int InvokeDependencyToolForMSBuild( ProjectDependenciesCommandFactory commandFactory, DotnetBaseParams dotnetParams) { Console.WriteLine($"Invoking '{dotnetParams.Command}' for '{dotnetParams.Framework.GetShortFolderName()}'."); return(InvokeDependencyTool(commandFactory, dotnetParams, dotnetParams.Framework)); }
public static int Main(string[] args) { DebugHelper.HandleDebugSwitch(ref args); var dotnetParams = new DotnetBaseParams("dotnet-dependency-tool-invoker", "DotNet Dependency Tool Invoker", "Invokes tools declared as NuGet dependencies of a project"); dotnetParams.Parse(args); if (string.IsNullOrEmpty(dotnetParams.Command)) { Console.WriteLine("A command name must be provided"); return(1); } var projectContexts = CreateProjectContexts(dotnetParams.ProjectPath) .Where(p => dotnetParams.Framework == null || dotnetParams.Framework.GetShortFolderName() .Equals(p.TargetFramework.GetShortFolderName())); var commandFactory = new ProjectDependenciesCommandFactory( dotnetParams.Framework, dotnetParams.Config, dotnetParams.Output, dotnetParams.BuildBasePath, projectContexts.First().ProjectDirectory); foreach (var projectContext in projectContexts) { Console.WriteLine($"Invoking '{dotnetParams.Command}' for '{projectContext.TargetFramework}'."); try { var exitCode = commandFactory.Create( $"dotnet-{dotnetParams.Command}", dotnetParams.RemainingArguments, projectContext.TargetFramework, dotnetParams.Config) .ForwardStdErr() .ForwardStdOut() .Execute() .ExitCode; Console.WriteLine($"Command returned {exitCode}"); } catch (CommandUnknownException) { Console.WriteLine($"Command not found"); return(1); } } return(0); }
private static int InvokeDependencyToolForMSBuild( ProjectDependenciesCommandFactory commandFactory, string command, NuGetFramework framework, string configuration, IEnumerable <string> appArguments) { Console.WriteLine($"Invoking '{command}' for '{framework.GetShortFolderName()}'."); return(InvokeDependencyTool(commandFactory, command, framework, configuration, appArguments)); }
public static int Main(string[] args) { DebugHelper.HandleDebugSwitch(ref args); args = new [] { "dotnet-dependency-tool-invoker" }.Concat(args).ToArray(); var parser = new Parser( options: DotnetDependencyToolInvokerParser.DotnetDependencyToolInvoker()); var parseResult = parser.Parse(args); var appliedOptions = parseResult["dotnet-dependency-tool-invoker"]; Console.WriteLine(parseResult.Diagram()); if (appliedOptions.HasOption("help")) { Console.WriteLine(parseResult.Command().HelpView()); return(0); } var command = appliedOptions.Arguments.First(); var framework = appliedOptions.ValueOrDefault <NuGetFramework>("framework"); var configuration = appliedOptions.ValueOrDefault <string>("configuration"); if (string.IsNullOrEmpty(configuration)) { configuration = Constants.DefaultConfiguration; } var output = appliedOptions.SingleArgumentOrDefault("output"); var projectPath = appliedOptions.ValueOrDefault <string>("project-path"); if (string.IsNullOrEmpty(projectPath)) { projectPath = PathUtility.EnsureTrailingSlash(Directory.GetCurrentDirectory()); } var appArguments = parseResult.UnmatchedTokens; var commandFactory = new ProjectDependenciesCommandFactory( framework, configuration, output, string.Empty, projectPath); var result = InvokeDependencyToolForMSBuild(commandFactory, command, framework, configuration, appArguments); return(result); }
public static int Main(string[] args) { return(StorytellerRunner.Program.Main(args)); var dotnetParams = new DotnetBaseParams("dotnet-storyteller", "Storyteller Runner", "Run or edit Storyteller specifications"); dotnetParams.Parse(args); var projectContexts = CreateProjectContexts(dotnetParams.ProjectPath) .Where(p => dotnetParams.Framework == null || dotnetParams.Framework.GetShortFolderName() .Equals(p.TargetFramework.GetShortFolderName())); var commandFactory = new ProjectDependenciesCommandFactory( dotnetParams.Framework, dotnetParams.Config, dotnetParams.Output, dotnetParams.BuildBasePath, projectContexts.First().ProjectDirectory); foreach (var projectContext in projectContexts) { Console.WriteLine($"Invoking '{dotnetParams.Command}' for '{projectContext.TargetFramework}'."); try { var exitCode = commandFactory.Create( $"StorytellerRunner", dotnetParams.RemainingArguments, projectContext.TargetFramework, dotnetParams.Config) .ForwardStdErr() .ForwardStdOut() .Execute() .ExitCode; Console.WriteLine($"Command returned {exitCode}"); } catch (CommandUnknownException) { Console.WriteLine($"Command not found"); return(1); } } return(0); }
private static int InvokeDependencyToolForProjectJson( IEnumerable <ProjectContext> projectContexts, ProjectDependenciesCommandFactory commandFactory, DotnetBaseParams dotnetParams) { foreach (var projectContext in projectContexts) { Console.WriteLine($"Invoking '{dotnetParams.Command}' for '{projectContext.TargetFramework}'."); if (InvokeDependencyTool(commandFactory, dotnetParams, projectContext.TargetFramework) != 0) { return(1); } } return(0); }
internal override int DoRunTests(ProjectContext projectContext, DotnetTestParams dotnetTestParams) { var commandFactory = new ProjectDependenciesCommandFactory( projectContext.TargetFramework, dotnetTestParams.Config, dotnetTestParams.Output, dotnetTestParams.BuildBasePath, projectContext.ProjectDirectory); return(commandFactory.Create( GetCommandName(projectContext.ProjectFile.TestRunner), GetCommandArgs(projectContext, dotnetTestParams), projectContext.TargetFramework, dotnetTestParams.Config) .Execute() .ExitCode); }
private static void HandleDesignTimeMessages( ProjectContext projectContext, string testRunner, int port, string configuration, string outputPath) { var reportingChannelFactory = new ReportingChannelFactory(); var adapterChannel = reportingChannelFactory.CreateAdapterChannel(port); try { var assemblyUnderTest = GetAssemblyUnderTest(projectContext, configuration, outputPath); var messages = new TestMessagesCollection(); using (var dotnetTest = new DotnetTest(messages, assemblyUnderTest)) { var commandFactory = new ProjectDependenciesCommandFactory( projectContext.TargetFramework, configuration, outputPath, projectContext.ProjectDirectory); var testRunnerFactory = new TestRunnerFactory(GetCommandName(testRunner), commandFactory); dotnetTest .AddNonSpecificMessageHandlers(messages, adapterChannel) .AddTestDiscoveryMessageHandlers(adapterChannel, reportingChannelFactory, testRunnerFactory) .AddTestRunMessageHandlers(adapterChannel, reportingChannelFactory, testRunnerFactory) .AddTestRunnnersMessageHandlers(adapterChannel, reportingChannelFactory); dotnetTest.StartListeningTo(adapterChannel); adapterChannel.Accept(); dotnetTest.StartHandlingMessages(); } } catch (Exception ex) { adapterChannel.SendError(ex); } }
private static void HandleDesignTimeMessages( ProjectContext projectContext, DotnetTestParams dotnetTestParams) { var reportingChannelFactory = new ReportingChannelFactory(); var adapterChannel = reportingChannelFactory.CreateAdapterChannel(dotnetTestParams.Port.Value); try { var pathToAssemblyUnderTest = new AssemblyUnderTest(projectContext, dotnetTestParams).Path; var messages = new TestMessagesCollection(); using (var dotnetTest = new DotnetTest(messages, pathToAssemblyUnderTest)) { var commandFactory = new ProjectDependenciesCommandFactory( projectContext.TargetFramework, dotnetTestParams.Config, dotnetTestParams.Output, dotnetTestParams.BuildBasePath, projectContext.ProjectDirectory); var testRunnerFactory = new TestRunnerFactory(GetCommandName(projectContext.ProjectFile.TestRunner), commandFactory); dotnetTest .AddNonSpecificMessageHandlers(messages, adapterChannel) .AddTestDiscoveryMessageHandlers(adapterChannel, reportingChannelFactory, testRunnerFactory) .AddTestRunMessageHandlers(adapterChannel, reportingChannelFactory, testRunnerFactory) .AddTestRunnnersMessageHandlers(adapterChannel, reportingChannelFactory); dotnetTest.StartListeningTo(adapterChannel); adapterChannel.Connect(); dotnetTest.StartHandlingMessages(); } } catch (Exception ex) { adapterChannel.SendError(ex); } }
public static int Main(string[] args) { DebugHelper.HandleDebugSwitch(ref args); var dotnetParams = new DotnetBaseParams("dotnet-dependency-tool-invoker", "DotNet Dependency Tool Invoker", "Invokes tools declared as NuGet dependencies of a project"); dotnetParams.Parse(args); if (string.IsNullOrEmpty(dotnetParams.Command)) { Console.WriteLine("A command name must be provided"); return(1); } var projectContexts = CreateProjectContexts(dotnetParams.ProjectPath) .Where(p => dotnetParams.Framework == null || dotnetParams.Framework.GetShortFolderName() .Equals(p.TargetFramework.GetShortFolderName())); var commandFactory = new ProjectDependenciesCommandFactory( dotnetParams.Framework, dotnetParams.Config, dotnetParams.Output, dotnetParams.BuildBasePath, dotnetParams.ProjectPath); var result = 0; if (projectContexts.Any()) { result = InvokeDependencyToolForProjectJson(projectContexts, commandFactory, dotnetParams); } else { result = InvokeDependencyToolForMSBuild(commandFactory, dotnetParams); } return(result); }
internal override int DoRunTests(ProjectContext projectContext, DotnetTestParams dotnetTestParams) { try { var commandFactory = new ProjectDependenciesCommandFactory( projectContext.TargetFramework, dotnetTestParams.Config, dotnetTestParams.Output, dotnetTestParams.BuildBasePath, projectContext.ProjectDirectory); return(commandFactory.Create( GetCommandName(projectContext.ProjectFile.TestRunner), GetCommandArgs(projectContext, dotnetTestParams), projectContext.TargetFramework, dotnetTestParams.Config) .ForwardStdErr() .ForwardStdOut() .Execute() .ExitCode); } catch (CommandUnknownException e) { var commandFactory = new DotNetCommandFactory(); return(commandFactory.Create( GetDotNetCommandName(projectContext.ProjectFile.TestRunner), GetCommandArgs(projectContext, dotnetTestParams), projectContext.TargetFramework, dotnetTestParams.Config) .ForwardStdErr() .ForwardStdOut() .Execute() .ExitCode); } }
private int RunTests(ProjectContext projectContext, DotnetTestParams dotnetTestParams) { var result = _testProjectBuilder.BuildTestProject(projectContext, dotnetTestParams); if (result == 0) { var commandFactory = new ProjectDependenciesCommandFactory( projectContext.TargetFramework, dotnetTestParams.Config, dotnetTestParams.Output, dotnetTestParams.BuildBasePath, projectContext.ProjectDirectory); var assemblyUnderTest = new AssemblyUnderTest(projectContext, dotnetTestParams); var framework = projectContext.TargetFramework; result = _nextRunner(commandFactory, assemblyUnderTest.Path, framework).RunTests(dotnetTestParams); } return(result); }