Feature Request: ShouldResult property

.vscode/settings.json

@@ -22,5 +22,6 @@
       "systemId": "https://raw.githubusercontent.com/PowerShell/PowerShell/master/src/Schemas/Types.xsd",
       "pattern": "**/*.Types.ps1xml"
     }
-  ]
+  ],
+  "dotnet.defaultSolution": "src/csharp/Pester.sln"
 }

src/csharp/Pester/Factory.cs

@@ -1,8 +1,8 @@
-using System.Management.Automation;
-using System.Collections.Generic;
 using System;
-using System.Text;
+using System.Collections.Generic;
 using System.IO;
+using System.Management.Automation;
+using System.Text;
 
 namespace Pester
 {
@@ -33,13 +33,12 @@ public static List<object> CreateCollection()
         {
             return new List<object>();
         }
-
-        public static ErrorRecord CreateShouldErrorRecord(string message, string file, string line, string lineText, bool terminating)
+        public static ErrorRecord CreateShouldErrorRecord(string message, string file, string line, string lineText, bool terminating, object shouldResult = null)
         {
-            return CreateErrorRecord("PesterAssertionFailed", message, file, line, lineText, terminating);
+            return CreateErrorRecord("PesterAssertionFailed", message, file, line, lineText, terminating, shouldResult);
         }
 
-        public static ErrorRecord CreateErrorRecord(string errorId, string message, string file, string line, string lineText, bool terminating)
+        public static ErrorRecord CreateErrorRecord(string errorId, string message, string file, string line, string lineText, bool terminating, object shouldResult = null)
         {
             var exception = new Exception(message);
             // we use ErrorRecord.TargetObject to pass structured information about the error to a reporting system.
@@ -51,6 +50,11 @@ public static ErrorRecord CreateErrorRecord(string errorId, string message, stri
                 ["LineText"] = lineText,
                 ["Terminating"] = terminating,
             };
+
+            if (shouldResult is not null)
+            {
+                targetObject["ShouldResult"] = shouldResult;
+            }
             return new ErrorRecord(exception, errorId, ErrorCategory.InvalidResult, targetObject);
         }
 

src/csharp/Pester/ShouldResult.cs

@@ -0,0 +1,21 @@
+namespace Pester
+{
+  public class ShouldResult
+  {
+    public bool Succeeded { get; set; }
+    public string FailureMessage { get; set; }
+    public ShouldExpectResult ExpectResult { get; set; }
+  }
+
+  public class ShouldExpectResult
+  {
+    public string Actual { get; set; }
+    public string Expected { get; set; }
+    public string Because { get; set; }
+
+    public override string ToString()
+    {
+      return $"Expected: {Expected} Actual: {Actual} Because: {Because}";
+    }
+  }
+}

src/csharp/Pester/Test.cs

@@ -34,7 +34,6 @@ public Test()
         public object Data { get; set; }
         public string ExpandedName { get; set; }
         public string ExpandedPath { get; set; }
-
         public string Result { get; set; }
         public List<object> ErrorRecord { get; set; }
         public object StandardOutput { get; set; }

src/functions/Mock.ps1

@@ -300,6 +300,7 @@ function Create-MockHook ($contextInfo, $InvokeMockCallback) {
 
 function Should-InvokeVerifiableInternal {
     [CmdletBinding()]
+    [OutputType([Pester.ShouldResult])]
     param(
         [Parameter(Mandatory)]
         $Behaviors,
@@ -315,31 +316,45 @@ function Should-InvokeVerifiableInternal {
     }
 
     if ($filteredBehaviors.Count -gt 0) {
-        if ($Negate) { $message = "$([System.Environment]::NewLine)Expected no verifiable mocks to be called,$(Format-Because $Because) but these were:" }
-        else { $message = "$([System.Environment]::NewLine)Expected all verifiable mocks to be called,$(Format-Because $Because) but these were not:" }
-
+        [string]$filteredBehaviorMessage = ''
         foreach ($b in $filteredBehaviors) {
-            $message += "$([System.Environment]::NewLine) Command $($b.CommandName) "
+            $filteredBehaviorMessage += "$([System.Environment]::NewLine) Command $($b.CommandName) "
             if ($b.ModuleName) {
-                $message += "from inside module $($b.ModuleName) "
+                $filteredBehaviorMessage += "from inside module $($b.ModuleName) "
             }
-            if ($null -ne $b.Filter) { $message += "with { $($b.Filter.ToString().Trim()) }" }
+            if ($null -ne $b.Filter) { $filteredBehaviorMessage += "with { $($b.Filter.ToString().Trim()) }" }
+        }
+
+        if ($Negate) {
+            $message = "$([System.Environment]::NewLine)Expected no verifiable mocks to be called,$(Format-Because $Because) but these were:$filteredBehaviorMessage"
+            $ExpectedValue = 'No verifiable mocks to be called'
+            $ActualValue = "These mocks were called:$filteredBehaviorMessage"
+        }
+        else {
+            $message = "$([System.Environment]::NewLine)Expected all verifiable mocks to be called,$(Format-Because $Because) but these were not:$filteredBehaviorMessage"
+            $ExpectedValue = 'All verifiable mocks to be called'
+            $ActualValue = "These mocks were not called:$filteredBehaviorMessage"
         }
 
-        return [PSCustomObject] @{
+        return [Pester.ShouldResult] @{
             Succeeded      = $false
             FailureMessage = $message
+            ExpectResult   = @{
+                Expected = $ExpectedValue
+                Actual   = $ActualValue
+                Because  = Format-Because $Because
+            }
         }
     }
 
-    return [PSCustomObject] @{
+    return [Pester.ShouldResult] @{
         Succeeded      = $true
-        FailureMessage = $null
     }
 }
 
 function Should-InvokeInternal {
     [CmdletBinding(DefaultParameterSetName = 'ParameterFilter')]
+    [OutputType([Pester.ShouldResult])]
     param(
         [Parameter(Mandatory = $true)]
         [hashtable] $ContextInfo,
@@ -452,43 +467,67 @@ function Should-InvokeInternal {
 
     if ($Negate) {
         # Negative checks
-        if ($matchingCalls.Count -eq $Times -and ($Exactly -or !$PSBoundParameters.ContainsKey("Times"))) {
-            return [PSCustomObject] @{
+        if ($matchingCalls.Count -eq $Times -and ($Exactly -or !$PSBoundParameters.ContainsKey('Times'))) {
+            return [Pester.ShouldResult] @{
                 Succeeded      = $false
                 FailureMessage = "Expected ${commandName}${moduleMessage} not to be called exactly $Times times,$(Format-Because $Because) but it was"
+                ExpectResult   = [Pester.ShouldExpectResult]@{
+                    Expected = "${commandName}${moduleMessage} not to be called exactly $Times times"
+                    Actual   = "${commandName}${moduleMessage} was called $($matchingCalls.count) times"
+                    Because  = Format-Because $Because
+                }
             }
         }
         elseif ($matchingCalls.Count -ge $Times -and !$Exactly) {
-            return [PSCustomObject] @{
+            return [Pester.ShouldResult] @{
                 Succeeded      = $false
                 FailureMessage = "Expected ${commandName}${moduleMessage} to be called less than $Times times,$(Format-Because $Because) but was called $($matchingCalls.Count) times"
+                ExpectResult   = [Pester.ShouldExpectResult]@{
+                    Expected = "${commandName}${moduleMessage} to be called less than $Times times"
+                    Actual   = "${commandName}${moduleMessage} was called $($matchingCalls.count) times"
+                    Because  = Format-Because $Because
+                }
             }
         }
     }
     else {
         if ($matchingCalls.Count -ne $Times -and ($Exactly -or ($Times -eq 0))) {
-            return [PSCustomObject] @{
+            return [Pester.ShouldResult] @{
                 Succeeded      = $false
                 FailureMessage = "Expected ${commandName}${moduleMessage} to be called $Times times exactly,$(Format-Because $Because) but was called $($matchingCalls.Count) times"
+                ExpectResult   = [Pester.ShouldExpectResult]@{
+                    Expected = "${commandName}${moduleMessage} to be called $Times times exactly"
+                    Actual   = "${commandName}${moduleMessage} was called $($matchingCalls.count) times"
+                    Because  = Format-Because $Because
+                }
             }
         }
         elseif ($matchingCalls.Count -lt $Times) {
-            return [PSCustomObject] @{
+            return [Pester.ShouldResult] @{
                 Succeeded      = $false
                 FailureMessage = "Expected ${commandName}${moduleMessage} to be called at least $Times times,$(Format-Because $Because) but was called $($matchingCalls.Count) times"
+                ExpectResult   = [Pester.ShouldExpectResult]@{
+                    Expected = "${commandName}${moduleMessage} to be called at least $Times times"
+                    Actual   = "${commandName}${moduleMessage} was called $($matchingCalls.count) times"
+                    Because  = Format-Because $Because
+                }
             }
         }
         elseif ($filterIsExclusive -and $nonMatchingCalls.Count -gt 0) {
-            return [PSCustomObject] @{
+            return [Pester.ShouldResult] @{
                 Succeeded      = $false
                 FailureMessage = "Expected ${commandName}${moduleMessage} to only be called with with parameters matching the specified filter,$(Format-Because $Because) but $($nonMatchingCalls.Count) non-matching calls were made"
+                ExpectResult   = [Pester.ShouldExpectResult]@{
+                    Expected = "${commandName}${moduleMessage} to only be called with with parameters matching the specified filter"
+                    Actual   = "${commandName}${moduleMessage} was called $($nonMatchingCalls.Count) times with non-matching parameters"
+                    Because  = Format-Because $Because
+                }
             }
         }
     }
 
-    return [PSCustomObject] @{
+    return [Pester.ShouldResult] @{
         Succeeded      = $true
-        FailureMessage = $null
     }
 }
 

src/functions/assertions/Be.ps1

@@ -26,18 +26,23 @@ function Should-Be ($ActualValue, $ExpectedValue, [switch] $Negate, [string] $Be
 
     $failureMessage = ''
 
-    if (-not $succeeded) {
-        if ($Negate) {
-            $failureMessage = NotShouldBeFailureMessage -ActualValue $ActualValue -Expected $ExpectedValue -Because $Because
-        }
-        else {
-            $failureMessage = ShouldBeFailureMessage -ActualValue $ActualValue -Expected $ExpectedValue -Because $Because
-        }
+    if ($true -eq $succeeded) { return [Pester.ShouldResult]@{Succeeded = $succeeded } }
+
+    if ($Negate) {
+        $failureMessage = NotShouldBeFailureMessage -ActualValue $ActualValue -Expected $ExpectedValue -Because $Because
+    }
+    else {
+        $failureMessage = ShouldBeFailureMessage -ActualValue $ActualValue -Expected $ExpectedValue -Because $Because
     }
 
-    return [PSCustomObject] @{
+    return [Pester.ShouldResult] @{
         Succeeded      = $succeeded
         FailureMessage = $failureMessage
+        ExpectResult   = @{
+            Actual   = Format-Nicely $ActualValue
+            Expected = Format-Nicely $ExpectedValue
+            Because  = $Because
+        }
     }
 }
 
@@ -64,9 +69,9 @@ function NotShouldBeFailureMessage($ActualValue, $ExpectedValue, $Because) {
 }
 
 & $script:SafeCommands['Add-ShouldOperator'] -Name Be `
-    -InternalName       Should-Be `
-    -Test               ${function:Should-Be} `
-    -Alias              'EQ' `
+    -InternalName Should-Be `
+    -Test ${function:Should-Be} `
+    -Alias 'EQ' `
     -SupportsArrayInput
 
 Set-ShouldOperatorHelpMessage -OperatorName Be `
@@ -99,18 +104,23 @@ function Should-BeExactly($ActualValue, $ExpectedValue, $Because) {
 
     $failureMessage = ''
 
-    if (-not $succeeded) {
-        if ($Negate) {
-            $failureMessage = NotShouldBeExactlyFailureMessage -ActualValue $ActualValue -ExpectedValue $ExpectedValue -Because $Because
-        }
-        else {
-            $failureMessage = ShouldBeExactlyFailureMessage -ActualValue $ActualValue -ExpectedValue $ExpectedValue -Because $Because
-        }
+    if ($true -eq $succeeded) { return [Pester.ShouldResult]@{Succeeded = $succeeded } }
+
+    if ($Negate) {
+        $failureMessage = NotShouldBeExactlyFailureMessage -ActualValue $ActualValue -ExpectedValue $ExpectedValue -Because $Because
+    }
+    else {
+        $failureMessage = ShouldBeExactlyFailureMessage -ActualValue $ActualValue -ExpectedValue $ExpectedValue -Because $Because
     }
 
-    return [PSCustomObject] @{
+    return [Pester.ShouldResult] @{
         Succeeded      = $succeeded
         FailureMessage = $failureMessage
+        ExpectResult   = @{
+            Actual   = Format-Nicely $ActualValue
+            Expected = Format-Nicely $ExpectedValue
+            Because  = $Because
+        }
     }
 }
 

src/functions/assertions/BeGreaterThan.ps1

@@ -14,13 +14,18 @@
     }
 
     if ($ActualValue -le $ExpectedValue) {
-        return [PSCustomObject] @{
+        return [Pester.ShouldResult] @{
             Succeeded      = $false
             FailureMessage = "Expected the actual value to be greater than $(Format-Nicely $ExpectedValue),$(Format-Because $Because) but got $(Format-Nicely $ActualValue)."
+            ExpectResult   = @{
+                Actual   = Format-Nicely $ActualValue
+                Expected = Format-Nicely $ExpectedValue
+                Because  = $Because
+            }
         }
     }
 
-    return [PSCustomObject] @{
+    return [Pester.ShouldResult] @{
         Succeeded = $true
     }
 }
@@ -47,13 +52,18 @@ function Should-BeLessOrEqual($ActualValue, $ExpectedValue, [switch] $Negate, [s
     }
 
     if ($ActualValue -gt $ExpectedValue) {
-        return [PSCustomObject] @{
+        return [Pester.ShouldResult] @{
             Succeeded      = $false
             FailureMessage = "Expected the actual value to be less than or equal to $(Format-Nicely $ExpectedValue),$(Format-Because $Because) but got $(Format-Nicely $ActualValue)."
+            ExpectResult   = @{
+                Actual   = Format-Nicely $ActualValue
+                Expected = Format-Nicely $ExpectedValue
+                Because  = $Because
+            }
         }
     }
 
-    return [PSCustomObject] @{
+    return [Pester.ShouldResult] @{
         Succeeded = $true
     }
 }

src/functions/assertions/BeIn.ps1

@@ -16,20 +16,30 @@
 
     if (-not $succeeded) {
         if ($Negate) {
-            return [PSCustomObject] @{
+            return [Pester.ShouldResult] @{
                 Succeeded      = $false
                 FailureMessage = "Expected collection $(Format-Nicely $ExpectedValue) to not contain $(Format-Nicely $ActualValue),$(Format-Because $Because) but it was found."
+                ExpectResult           = @{
+                    Actual   = Format-Nicely $ActualValue
+                    Expected = Format-Nicely $ExpectedValue
+                    Because  = $Because
+                }
             }
         }
         else {
-            return [PSCustomObject] @{
+            return [Pester.ShouldResult] @{
                 Succeeded      = $false
                 FailureMessage = "Expected collection $(Format-Nicely $ExpectedValue) to contain $(Format-Nicely $ActualValue),$(Format-Because $Because) but it was not found."
+                ExpectResult           = @{
+                    Actual   = Format-Nicely $ActualValue
+                    Expected = Format-Nicely $ExpectedValue
+                    Because  = $Because
+                }
             }
         }
     }
 
-    return [PSCustomObject] @{
+    return [Pester.ShouldResult] @{
         Succeeded = $true
     }
 }