Add Ability to Override Properties on New-MockObject

src/csharp/Pester/Factory.cs

@@ -13,6 +13,11 @@ public static PSNoteProperty CreateNoteProperty(string name, object value)
             return new PSNoteProperty(name, value);
         }
 
+        public static PSScriptMethod CreateScriptMethod(string name, ScriptBlock scriptBlock)
+        {
+            return new PSScriptMethod(name, scriptBlock);
+        }
+
         public static Dictionary<string, object> CreateDictionary()
         {
             return new Dictionary<string, object>();

src/functions/New-MockObject.ps1

@@ -9,7 +9,22 @@ Using the New-MockObject you can mock an object based on .NET type.
 An .NET assembly for the particular type must be available in the system and loaded.
 
 .PARAMETER Type
-The .NET type to create an object based on.
+The .NET type to create. This creates the object without calling any of its constructors or initializers. Use this to instantiate an object that does not have a public constructor. If your object has a constructor, or is giving you errors, try using the constructor and provide the object using the InputObject parameter to decorate it.
+
+.PARAMETER InputObject
+And already constucted object to decorate. Use New-Object or ::new to create it.
+
+.PARAMETER Properties
+Properties to define, specified as a hashtable, in format @{ PropertyName = value }.
+
+.PARAMETER Methods
+Methods to define, specified as a hashtable, in format @{ MethodName = scriptBlock }.
+
+ScriptBlock can define param block, and it will recieve arguments that were provided to the function call based on order.
+
+Method overloads are not supported because ScriptMethods are used to decorate the object, and ScriptMethods do not support method overloads.
+
+For each method a property named _MethodName is defined which holds history of the invocations of the method and the arguments that were provided.
 
 .EXAMPLE
 ```powershell
@@ -18,6 +33,27 @@ $obj.GetType().FullName
     System.Diagnostics.Process
 ```
 
+.EXAMPLE
+```powershell
+$obj = New-MockObject -Type 'System.Diagnostics.Process' -Properties @{ Id = 123 }
+```
+
+.EXAMPLE
+```powershell
+$obj = New-MockObject -Type 'System.Diagnostics.Process' -Methods @{ Kill = { param($entireProcessTree) "killed" } }
+$obj.Kill()
+$obj.Kill($true)
+$obj.Kill($false)
+
+$obj._Kill
+
+Call Arguments
+---- ---------
+   1 {}
+   2 {True}
+   3 {False}
+```
+
 .LINK
 https://pester.dev/docs/commands/New-MockObject
 
@@ -27,11 +63,73 @@ https://pester.dev/docs/usage/mocking
 #>
 
     param (
-        [Parameter(Mandatory = $true)]
+        [Parameter(ParameterSetName = "Type", Mandatory)]
+        [ValidateNotNullOrEmpty()]
+        [type]$Type,
+        [Parameter(ParameterSetName = "InputObject", Mandatory)]
         [ValidateNotNullOrEmpty()]
-        [type]$Type
+        $InputObject,
+        [Parameter(ParameterSetName = "Type")]
+        [Parameter(ParameterSetName = "InputObject")]
+        [hashtable]$Properties,
+        [Parameter(ParameterSetName = "Type")]
+        [Parameter(ParameterSetName = "InputObject")]
+        [hashtable]$Methods,
+        [string] $MethodHistoryPrefix = "_"
     )
 
-    [System.Runtime.Serialization.Formatterservices]::GetUninitializedObject($Type)
+    $mock = if ($PSBoundParameters.ContainsKey("InputObject")) {
+        $PSBoundParameters.InputObject
+    }
+    else {
+        [System.Runtime.Serialization.Formatterservices]::GetUninitializedObject($Type)
+    }
+
+    if ($null -ne $Properties) {
+        foreach ($property in $Properties.GetEnumerator()) {
+            if ($mock.PSObject.Properties.Item($property.Key)) {
+                $mock.PSObject.Properties.Remove($property.Key)
+            }
+            $mock.PSObject.Properties.Add([Pester.Factory]::CreateNoteProperty($property.Key, $property.Value))
+            }
+        }
+
+        if ($null -ne $Methods) {
+            foreach ($method in $Methods.GetEnumerator()) {
+                $historyName = "$($MethodHistoryPrefix)$($method.Key)"
+                if ($mock.PSObject.Properties.Item($historyName)) {
+                    $mock.PSObject.Properties.Remove($historyName)
+                }
+                $mock.PSObject.Properties.Add([Pester.Factory]::CreateNoteProperty($historyName, [System.Collections.Generic.List[object]]@()))
+
+                $saveHistoryAndInvokeUserScriptBlock = & {
+                    # this new scriptblock ensures we only copy the variables here
+                    # because closure only copies local variables, the scriptblock execution
+                    # returns a scriptblock that is a closure
+
+                    # save the provided scriptblock as $scriptblock in the closure
+                    $scriptBlock = $method.Value
+                    # save history name as $historyName in the closure
+                    $historyName = $historyName
+                    # save count as reference object so we can easily update the value
+                    $count = @{ Count = 0 }
+
+                    {
+                        # before invoking user scriptblock up the counter by 1 and save args
+                        $this.$historyName.Add([PSCustomObject] @{ Call = ++$count.Count; Arguments = $args })
+
+                        # then splat the args, if user specifies parameters in the scriptblock they
+                        # will get the values by order, same as if they called the script method
+                        & $scriptBlock @args
+                    }.GetNewClosure()
+                }
+                if ($mock.PSObject.Methods.Item($method.Key)) {
+                    $mock.PSObject.Methods.Remove($method.Key)
+                }
+
+                $mock.PSObject.Methods.Add([Pester.Factory]::CreateScriptMethod($method.Key, $saveHistoryAndInvokeUserScriptBlock))
+            }
+        }
 
-}
+        $mock
+    }

tst/functions/New-MockObject.Tests.ps1

@@ -1,9 +1,62 @@
 Set-StrictMode -Version Latest
 
-describe 'New-MockObject' {
+Describe 'New-MockObject' {
 
-    it 'instantiates an object from a class with no public constructors' {
+    It 'instantiates an object from a class with no public constructors' {
         $type = 'Microsoft.PowerShell.Commands.Language'
-        New-MockObject -Type $type | should -beoftype $type
+        New-MockObject -Type $type | Should -BeOfType $type
+    }
+
+    It 'Add a property to existing object' {
+        $o = New-Object -TypeName 'System.Diagnostics.Process'
+        $mockObject = New-MockObject -InputObject $o -Properties @{ Id = 123 }
+
+        $mockObject | Should -Be $o
+        $mockObject.Id | Should -Be 123
+    }
+
+    Context 'Methods' {
+        It "Adds a method to the object" {
+            $o = New-Object -TypeName 'System.Diagnostics.Process'
+            $mockObject = New-MockObject -InputObject $o -Methods @{ Kill = { param() "killed" } }
+
+            $mockObject | Should -Be $o
+            $mockObject.Kill() | Should -Be "killed"
+        }
+
+        It "Counts history of the invocation" {
+            $o = New-Object -TypeName 'System.Diagnostics.Process'
+            $mockObject = New-MockObject -InputObject $o -Methods @{ Kill = { param($entireProcessTree) "killed" } }
+
+            $mockObject | Should -Be $o
+            $mockObject.Kill() | Should -Be "killed"
+            $mockObject._Kill[-1].Call | Should -Be 1
+            $mockObject._Kill[-1].Arguments | Should -Be $null
+            $mockObject.Kill($true) | Should -Be "killed"
+            $mockObject._Kill[-1].Call | Should -Be 2
+            $mockObject._Kill[-1].Arguments | Should -Be $true
+        }
+    }
+
+
+    Context 'Modifying readonly-properties' {
+        # System.Diagnostics.Process.Id is normally read only, using the
+        # Properties switch in New-MockObject should allow us to mock these.
+        it 'Fails with just a normal mock' {
+            $mockedProcess = New-MockObject -Type 'System.Diagnostics.Process'
+
+            { $mockedProcess.Id = 123 } | Should -Throw
+        }
+
+        it 'Works when you mock the property' {
+            $mockedProcess = New-MockObject -Type 'System.Diagnostics.Process' -Properties @{ Id = 123 }
+
+            $mockedProcess.Id | Should -Be 123
+        }
+
+        it 'Should preserve types' {
+            $mockedProcess = New-MockObject -Type 'System.Diagnostics.Process' -Properties @{Id = 123 }
+            $mockedProcess.Id | Should -BeOfType [int]
+        }
     }
 }