Merge pull request #282 from okb/always-set-exit-code

Always set exit code

Author: JakeGinnivan

GitVersionExe.Tests/ArgumentBuilder.cs

@@ -0,0 +1,92 @@
+using System.Text;
+
+public class ArgumentBuilder
+{
+    public ArgumentBuilder(string workingDirectory)
+    {
+        this.workingDirectory = workingDirectory;
+    }
+
+
+    public ArgumentBuilder(string workingDirectory, string exec, string execArgs, string projectFile, string projectArgs, string logFile, bool isTeamCity)
+    {
+        this.workingDirectory = workingDirectory;
+        this.exec = exec;
+        this.execArgs = execArgs;
+        this.projectFile = projectFile;
+        this.projectArgs = projectArgs;
+        this.logFile = logFile;
+        this.isTeamCity = isTeamCity;
+    }
+
+    public ArgumentBuilder(string workingDirectory, string additionalArguments, bool isTeamCity)
+    {
+        this.workingDirectory = workingDirectory;
+        this.isTeamCity = isTeamCity;
+        this.additionalArguments = additionalArguments;
+    }
+
+
+    public string WorkingDirectory
+    {
+        get { return workingDirectory; }
+    }
+
+
+    public string LogFile
+    {
+        get { return logFile; }
+    }
+
+    public bool IsTeamCity
+    {
+        get { return isTeamCity; }
+    }
+
+
+    public override string ToString()
+    {
+        var arguments = new StringBuilder();
+
+        arguments.AppendFormat("\"{0}\"", workingDirectory);
+
+        if (!string.IsNullOrWhiteSpace(exec))
+        {
+            arguments.AppendFormat(" /exec \"{0}\"", exec);
+        }
+
+        if (!string.IsNullOrWhiteSpace(execArgs))
+        {
+            arguments.AppendFormat(" /execArgs \"{0}\"", execArgs);
+        }
+
+        if (!string.IsNullOrWhiteSpace(projectFile))
+        {
+            arguments.AppendFormat(" /proj \"{0}\"", projectFile);
+        }
+
+        if (!string.IsNullOrWhiteSpace(projectArgs))
+        {
+            arguments.AppendFormat(" /projargs \"{0}\"", projectArgs);
+        }
+
+        arguments.Append(additionalArguments);
+
+        if (!string.IsNullOrWhiteSpace(logFile))
+        {
+            arguments.AppendFormat(" /l \"{0}\"", logFile);
+        }
+
+        return arguments.ToString();
+    }
+
+
+    readonly string additionalArguments;
+    readonly string exec;
+    readonly string execArgs;
+    readonly bool isTeamCity;
+    readonly string logFile;
+    readonly string projectArgs;
+    readonly string projectFile;
+    readonly string workingDirectory;
+}

GitVersionExe.Tests/ExecCmdLineArgumentTest.cs

@@ -30,4 +30,28 @@ public void RunExecViaCommandLine()
             result.Log.ShouldContain("GitVersion_FullSemVer: 1.2.4+1");
         }
     }
+
+    [Test]
+    public void InvalidArgumentsExitCodeShouldNotBeZero()
+    {
+        using (var fixture = new EmptyRepositoryFixture())
+        {
+            fixture.Repository.MakeATaggedCommit("1.2.3");
+            fixture.Repository.MakeACommit();
+
+            var buildFile = Path.Combine(fixture.RepositoryPath, "RunExecViaCommandLine.proj");
+            File.Delete(buildFile);
+            const string buildFileContent = @"<?xml version=""1.0"" encoding=""utf-8""?>
+<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
+  <Target Name=""OutputResults"">
+    <Message Text=""GitVersion_FullSemVer: $(GitVersion_FullSemVer)""/>
+  </Target>
+</Project>";
+            File.WriteAllText(buildFile, buildFileContent);
+            var result = GitVersionHelper.ExecuteIn(fixture.RepositoryPath, arguments: " /invalid-argument");
+
+            result.ExitCode.ShouldBe(1);
+            result.Output.ShouldContain("Failed to parse arguments");
+        }
+    }
 }

GitVersionExe.Tests/GitVersionExe.Tests.csproj

@@ -73,6 +73,7 @@
     <None Include="TestBuildFile.proj" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="ArgumentBuilder.cs" />
     <Compile Include="ArgumentParserTests.cs" />
     <Compile Include="ExecCmdLineArgumentTest.cs" />
     <Compile Include="ExecutionResults.cs" />

GitVersionExe.Tests/GitVersionHelper.cs

@@ -12,37 +12,47 @@ public static ExecutionResults ExecuteIn(string workingDirectory,
         bool isTeamCity = false)
     {
         var logFile = Path.Combine(workingDirectory, "log.txt");
-        var gitHubFlowVersion = Path.Combine(PathHelper.GetCurrentDirectory(), "GitVersion.exe");
-        var execArg = exec == null ? null : string.Format(" /exec \"{0}\"", exec);
-        var execArgsArg = execArgs == null ? null : string.Format(" /execArgs \"{0}\"", execArgs);
-        var projectFileArg = projectFile == null ? null : string.Format(" /proj \"{0}\"", projectFile);
-        var targetsArg = projectArgs == null ? null : string.Format(" /projargs \"{0}\"", projectArgs);
-        var logArg = string.Format(" /l \"{0}\"", logFile);
-        var arguments = string.Format("\"{0}\"{1}{2}{3}{4}{5}", workingDirectory, execArg, execArgsArg,
-            projectFileArg, targetsArg, logArg);
+        var args = new ArgumentBuilder(workingDirectory, exec, execArgs, projectFile, projectArgs, logFile, isTeamCity);
+        return ExecuteIn(args);
+    }
+
+    public static ExecutionResults ExecuteIn(string workingDirectory, string arguments, bool isTeamCity = false)
+    {
+        var args = new ArgumentBuilder(workingDirectory, arguments, isTeamCity);
+        return ExecuteIn(args);
+    }
 
+    static ExecutionResults ExecuteIn(ArgumentBuilder arguments)
+    {
+        var gitHubFlowVersion = Path.Combine(PathHelper.GetCurrentDirectory(), "GitVersion.exe");
         var output = new StringBuilder();
 
         Console.WriteLine("Executing: {0} {1}", gitHubFlowVersion, arguments);
         Console.WriteLine();
         var environmentalVariables =
             new[]
             {
-                new KeyValuePair<string, string>("TEAMCITY_VERSION", isTeamCity ? "8.0.0" : null)
+                new KeyValuePair<string, string>("TEAMCITY_VERSION", arguments.IsTeamCity ? "8.0.0" : null)
             };
 
         var exitCode = ProcessHelper.Run(
             s => output.AppendLine(s), s => output.AppendLine(s), null,
-            gitHubFlowVersion, arguments, workingDirectory,
+            gitHubFlowVersion, arguments.ToString(), arguments.WorkingDirectory,
             environmentalVariables);
 
-        var logContents = File.ReadAllText(logFile);
         Console.WriteLine("Output from GitVersion.exe");
         Console.WriteLine("-------------------------------------------------------");
         Console.WriteLine(output.ToString());
         Console.WriteLine();
         Console.WriteLine();
         Console.WriteLine("-------------------------------------------------------");
+
+        if (string.IsNullOrWhiteSpace(arguments.LogFile))
+        {
+            return new ExecutionResults(exitCode, output.ToString(), null);
+        }
+
+        var logContents = File.ReadAllText(arguments.LogFile);
         Console.WriteLine("Log from GitVersion.exe");
         Console.WriteLine("-------------------------------------------------------");
         Console.WriteLine(logContents);

GitVersionExe/Program.cs

@@ -14,8 +14,24 @@ class Program
 
         static void Main()
         {
-            int? exitCode = null;
+            var exitCode = Run();
 
+            if (Debugger.IsAttached)
+            {
+                Console.ReadKey();
+            }
+
+            if (exitCode != 0)
+            {
+                // Dump log to console if we fail to complete successfully
+                Console.Write(log.ToString());
+            } 
+            
+            Environment.Exit(exitCode);
+        }
+
+        static int Run()
+        {
             try
             {
                 Arguments arguments;
@@ -29,17 +45,19 @@ static void Main()
                     Console.WriteLine("Failed to parse arguments: {0}", string.Join(" ", argumentsWithoutExeName));
 
                     HelpWriter.Write();
-                    return;
+                    return 1;
                 }
 
                 if (arguments.IsHelp)
                 {
                     HelpWriter.Write();
-                    return;
+                    return 0;
                 }
 
                 if (!string.IsNullOrEmpty(arguments.Proj) || !string.IsNullOrEmpty(arguments.Exec))
+                {
                     arguments.Output = OutputType.BuildServer;
+                }
 
                 ConfigureLogging(arguments);
 
@@ -48,7 +66,7 @@ static void Main()
                 if (string.IsNullOrEmpty(gitDirectory))
                 {
                     Console.Error.WriteLine("Failed to prepare or find the .git directory in path '{0}'", arguments.TargetPath);
-                    Environment.Exit(1);
+                    return 1;
                 }
 
                 var workingDirectory = Directory.GetParent(gitDirectory).FullName;
@@ -119,33 +137,16 @@ static void Main()
             {
                 var error = string.Format("An error occurred:\r\n{0}", exception.Message);
                 Logger.WriteWarning(error);
-
-                exitCode = 1;
+                return 1;
             }
             catch (Exception exception)
             {
                 var error = string.Format("An unexpected error occurred:\r\n{0}", exception);
                 Logger.WriteError(error);
-
-                exitCode = 1;
-            }
-
-            if (Debugger.IsAttached)
-            {
-                Console.ReadKey();
-            }
-
-            if (!exitCode.HasValue)
-            {
-                exitCode = 0;
-            }
-            else
-            {
-                // Dump log to console if we fail to complete successfully
-                Console.Write(log.ToString());
+                return 1;
             }
 
-            Environment.Exit(exitCode.Value);
+            return 0;
         }
 
         static IEnumerable<IBuildServer> GetApplicableBuildServers(Authentication authentication)