Use Get-Error instead of custom error formatting logic (#395)

* Relax ErrorRecordFormatter unit test expectationsEnsure the required data is there, but don't insist on formatting specifics.

* Replace custom error formatting with Get-Error

Author: AnatoliB

src/PowerShell/ErrorRecordFormatter.cs

@@ -13,7 +13,6 @@ namespace Microsoft.Azure.Functions.PowerShellWorker.PowerShell
     internal class ErrorRecordFormatter
     {
         private const string TruncationPostfix = "...";
-        private const string Indent = "   ";
 
         private readonly PowerShell _pwsh = PowerShell.Create();
 
@@ -26,89 +25,23 @@ internal class ErrorRecordFormatter
         /// </summary>
         public string Format(ErrorRecord errorRecord, int maxSize = 1 * 1024 * 1024)
         {
-            _pwsh.AddScript("$ErrorView = 'NormalView'").InvokeAndClearCommands();
-            var errorDetails = _pwsh.AddCommand("Microsoft.PowerShell.Utility\\Out-String")
+            var errorDetails = _pwsh.AddCommand("Microsoft.PowerShell.Utility\\Get-Error")
                                     .AddParameter("InputObject", errorRecord)
+                                    .AddCommand("Microsoft.PowerShell.Utility\\Out-String")
                                     .InvokeAndClearCommands<string>();
 
-            var result = new StringBuilder(
-                                capacity: Math.Min(1024, maxSize),
-                                maxCapacity: maxSize);
+            var result = new StringBuilder(capacity: Math.Min(1024, maxSize));
 
-            try
-            {
-                result.Append(errorDetails.Single());
-                result.AppendLine("Script stack trace:");
-                AppendStackTrace(result, errorRecord.ScriptStackTrace, Indent);
-                result.AppendLine();
-
-                if (errorRecord.Exception != null)
-                {
-                    AppendExceptionWithInners(result, errorRecord.Exception);
-                }
-
-                return result.ToString();
-            }
-            catch (ArgumentOutOfRangeException) // exceeding StringBuilder max capacity
-            {
-                return Truncate(result, maxSize);
-            }
-        }
-
-        private static void AppendExceptionWithInners(StringBuilder result, Exception exception)
-        {
-            AppendExceptionInfo(result, exception);
-
-            if (exception is AggregateException aggregateException)
-            {
-                foreach (var innerException in aggregateException.Flatten().InnerExceptions)
-                {
-                    AppendInnerExceptionIfNotNull(result, innerException);
-                }
-            }
-            else
-            {
-                AppendInnerExceptionIfNotNull(result, exception.InnerException);
-            }
-        }
-
-        private static void AppendInnerExceptionIfNotNull(StringBuilder result, Exception innerException)
-        {
-            if (innerException != null)
-            {
-                result.Append("Inner exception: ");
-                AppendExceptionWithInners(result, innerException);
-            }
-        }
-
-        private static void AppendExceptionInfo(StringBuilder stringBuilder, Exception exception)
-        {
-            stringBuilder.Append(exception.GetType().FullName);
-            stringBuilder.Append(": ");
-            stringBuilder.AppendLine(exception.Message);
-
-            AppendStackTrace(stringBuilder, exception.StackTrace, string.Empty);
-            stringBuilder.AppendLine();
-        }
-
-        private static void AppendStackTrace(StringBuilder stringBuilder, string stackTrace, string indent)
-        {
-            if (stackTrace != null)
-            {
-                stringBuilder.Append(indent);
-                stringBuilder.AppendLine(stackTrace.Replace(Environment.NewLine, Environment.NewLine + indent));
-            }
-        }
-
-        private static string Truncate(StringBuilder result, int maxSize)
-        {
-            var charactersToRemove = result.Length + TruncationPostfix.Length - maxSize;
-            if (charactersToRemove > 0)
+            result.AppendLine(errorRecord.Exception.Message);
+            result.Append(errorDetails.Single());
+            if (result.Length > maxSize)
             {
+                var charactersToRemove = result.Length + TruncationPostfix.Length - maxSize;
                 result.Remove(result.Length - charactersToRemove, charactersToRemove);
+                result.Append(TruncationPostfix);
             }
 
-            return result + TruncationPostfix;
+            return result.ToString();
         }
     }
 }

test/Unit/PowerShell/ErrorRecordFormatterTests.cs

@@ -30,7 +30,7 @@ public void FormattedStringContainsBasicErrorRecordData()
             var resultLines = result.Split(Environment.NewLine);
             Assert.Contains(resultLines, line => Regex.IsMatch(line, @"\bCategoryInfo\b[:\s]*?\bInvalidOperation\b"));
             Assert.Contains(resultLines, line => Regex.IsMatch(line, @"\bFullyQualifiedErrorId\b[:\s]*?\berror id\b"));
-            Assert.Contains(resultLines, line => line == "System.Management.Automation.RuntimeException: My exception");
+            Assert.Contains(resultLines, line => Regex.IsMatch(line, @"\bSystem.Management.Automation.RuntimeException\b"));
         }
 
         [Fact]
@@ -44,9 +44,9 @@ public void FormattedStringContainsInnerExceptions()
             var result = s_errorRecordFormatter.Format(errorRecord);
 
             var resultLines = result.Split(Environment.NewLine);
-            Assert.Contains(resultLines, line => line == "Inner exception: System.Exception: My exception 1");
-            Assert.Contains(resultLines, line => line == "Inner exception: System.Exception: My exception 2");
-            Assert.Equal(2, resultLines.Count(line => line.Contains("Inner exception:")));
+            Assert.Contains(resultLines, line => line.Contains(exception1.Message));
+            Assert.Contains(resultLines, line => line.Contains(exception2.Message));
+            Assert.Equal(2, resultLines.Count(line => Regex.IsMatch(line, @"\binner", RegexOptions.IgnoreCase)));
         }
 
         [Fact]
@@ -64,13 +64,13 @@ public void FormattedStringContainsAggregateExceptionMembers()
             var result = s_errorRecordFormatter.Format(errorRecord);
 
             var resultLines = result.Split(Environment.NewLine);
-            Assert.Contains(resultLines, line => line == "Inner exception: System.Exception: My exception 1");
-            Assert.Contains(resultLines, line => line == "Inner exception: System.Exception: My exception 2");
-            Assert.Contains(resultLines, line => line.StartsWith("Inner exception: System.AggregateException: My exception 3"));
-            Assert.Contains(resultLines, line => line == "Inner exception: System.Exception: My exception 4");
-            Assert.Contains(resultLines, line => line == "Inner exception: System.Exception: My exception 5");
-            Assert.Contains(resultLines, line => line.StartsWith("Inner exception: System.AggregateException: My exception 6"));
-            Assert.Contains(resultLines, line => line == "System.Exception: My exception 7");
+            Assert.Contains(resultLines, line => line.Contains(exception1.Message));
+            Assert.Contains(resultLines, line => line.Contains(exception2.Message));
+            Assert.Contains(resultLines, line => line.Contains(exception3.Message));
+            Assert.Contains(resultLines, line => line.Contains(exception4.Message));
+            Assert.Contains(resultLines, line => line.Contains(exception5.Message));
+            Assert.Contains(resultLines, line => line.Contains(exception6.Message));
+            Assert.Contains(resultLines, line => line.Contains(exception7.Message));
         }
 
         [Fact]
@@ -89,6 +89,7 @@ public void FormattedStringIsTruncatedIfTooLong()
             Assert.InRange(truncatedResult.Length, ExpectedPostfix.Length + 1, maxSize);
             Assert.EndsWith(ExpectedPostfix, truncatedResult);
             Assert.StartsWith(fullResult.Substring(0, truncatedResult.Length - ExpectedPostfix.Length), truncatedResult);
+            Assert.Equal(maxSize, truncatedResult.Length);
         }
     }
 }