Add IAsyncDisposable support in mock generators (#456)

* Add IAsyncDisposable support to mock generators

Extend both GenerateMock and GenerateCapturingMock to support interfaces
that inherit IAsyncDisposable, mirroring the existing IDisposable pattern.

Changes:
- Add IAsyncDisposable to KnownInheritance type
- Detect IAsyncDisposable inheritance in interface parsing
- Generate DisposeAsync field with ValueTask return type
- Initialize DisposeAsync with completed ValueTask() in Empty mock
- Implement System.IAsyncDisposable interface explicitly
- Support interfaces inheriting both IDisposable and IAsyncDisposable

Test cases added:
- TypeWithAsyncDisposable: interface with only IAsyncDisposable
- TypeWithBothDisposables: interface with both disposal interfaces

🤖 Generated with [Claude Code](https://claude.com/claude-code)

.config/dotnet-tools.json

@@ -13,6 +13,12 @@
       "commands": [
         "fsharp-analyzers"
       ]
+    },
+    "woofware.nunittestrunner": {
+      "version": "0.3.9",
+      "commands": [
+        "woofware.nunittestrunner"
+      ]
     }
   }
-}
+}

ConsumePlugin/CapturingMockExample.fs

@@ -55,3 +55,15 @@ type TypeWithProperties =
     abstract Mem1 : string option -> string[] Async
     abstract Prop1 : int
     abstract Prop2 : unit Async
+
+[<GenerateCapturingMock>]
+type TypeWithAsyncDisposable =
+    inherit IAsyncDisposable
+    abstract Mem1 : string option -> string[] Async
+    abstract Mem2 : unit -> string[] Async
+
+[<GenerateCapturingMock>]
+type TypeWithBothDisposables =
+    inherit IDisposable
+    inherit IAsyncDisposable
+    abstract Mem1 : string -> int

ConsumePlugin/GeneratedCapturingMock.fs

@@ -36,7 +36,7 @@ type internal PublicTypeMock =
         Mem3 : int * System.Threading.CancellationToken option -> string
     }
 
-    /// An implementation where every non-unit method throws.
+    /// An implementation where every non-disposal method throws.
     static member Empty () : PublicTypeMock =
         {
             Calls = PublicTypeMockCalls.Calls.Empty ()
@@ -89,7 +89,7 @@ type public PublicTypeInternalFalseMock =
         Mem3 : int * System.Threading.CancellationToken option -> string
     }
 
-    /// An implementation where every non-unit method throws.
+    /// An implementation where every non-disposal method throws.
     static member Empty () : PublicTypeInternalFalseMock =
         {
             Calls = PublicTypeInternalFalseMockCalls.Calls.Empty ()
@@ -139,7 +139,7 @@ type internal InternalTypeMock =
         Mem2 : string -> int
     }
 
-    /// An implementation where every non-unit method throws.
+    /// An implementation where every non-disposal method throws.
     static member Empty () : InternalTypeMock =
         {
             Calls = InternalTypeMockCalls.Calls.Empty ()
@@ -184,7 +184,7 @@ type private PrivateTypeMock =
         Mem2 : string -> int
     }
 
-    /// An implementation where every non-unit method throws.
+    /// An implementation where every non-disposal method throws.
     static member Empty () : PrivateTypeMock =
         {
             Calls = PrivateTypeMockCalls.Calls.Empty ()
@@ -229,7 +229,7 @@ type private PrivateTypeInternalFalseMock =
         Mem2 : string -> int
     }
 
-    /// An implementation where every non-unit method throws.
+    /// An implementation where every non-disposal method throws.
     static member Empty () : PrivateTypeInternalFalseMock =
         {
             Calls = PrivateTypeInternalFalseMockCalls.Calls.Empty ()
@@ -271,7 +271,7 @@ type internal VeryPublicTypeMock<'a, 'b> =
         Mem1 : 'a -> 'b
     }
 
-    /// An implementation where every non-unit method throws.
+    /// An implementation where every non-disposal method throws.
     static member Empty () : VeryPublicTypeMock<'a, 'b> =
         {
             Calls = VeryPublicTypeMockCalls.Calls.Empty ()
@@ -365,7 +365,7 @@ type internal CurriedMock<'a> =
         Mem6 : int * string -> 'a * int -> string
     }
 
-    /// An implementation where every non-unit method throws.
+    /// An implementation where every non-disposal method throws.
     static member Empty () : CurriedMock<'a> =
         {
             Calls = CurriedMockCalls.Calls.Empty ()
@@ -486,7 +486,7 @@ type internal TypeWithInterfaceMock =
         Mem2 : unit -> string[] Async
     }
 
-    /// An implementation where every non-unit method throws.
+    /// An implementation where every non-disposal method throws.
     static member Empty () : TypeWithInterfaceMock =
         {
             Calls = TypeWithInterfaceMockCalls.Calls.Empty ()
@@ -540,7 +540,7 @@ type internal TypeWithPropertiesMock =
         Prop2 : unit -> unit Async
     }
 
-    /// An implementation where every non-unit method throws.
+    /// An implementation where every non-disposal method throws.
     static member Empty () : TypeWithPropertiesMock =
         {
             Calls = TypeWithPropertiesMockCalls.Calls.Empty ()
@@ -560,3 +560,103 @@ type internal TypeWithPropertiesMock =
 
     interface System.IDisposable with
         member this.Dispose () : unit = this.Dispose ()
+namespace SomeNamespace.CapturingMock
+
+open System
+open WoofWare.Myriad.Plugins
+
+[<RequireQualifiedAccess>]
+module internal TypeWithAsyncDisposableMockCalls =
+    /// All the calls made to a TypeWithAsyncDisposableMock mock
+    type internal Calls =
+        {
+            Mem1 : ResizeArray<string option>
+            Mem2 : ResizeArray<unit>
+        }
+
+        /// A fresh calls object which has not yet had any calls made.
+        static member Empty () : Calls =
+            {
+                Mem1 = ResizeArray ()
+                Mem2 = ResizeArray ()
+            }
+
+/// Mock record type for an interface
+type internal TypeWithAsyncDisposableMock =
+    {
+        Calls : TypeWithAsyncDisposableMockCalls.Calls
+        /// Implementation of IAsyncDisposable.DisposeAsync
+        DisposeAsync : unit -> System.Threading.Tasks.ValueTask
+        Mem1 : string option -> string[] Async
+        Mem2 : unit -> string[] Async
+    }
+
+    /// An implementation where every non-disposal method throws.
+    static member Empty () : TypeWithAsyncDisposableMock =
+        {
+            Calls = TypeWithAsyncDisposableMockCalls.Calls.Empty ()
+            DisposeAsync = (fun () -> (System.Threading.Tasks.ValueTask ()))
+            Mem1 = (fun _ -> raise (System.NotImplementedException "Unimplemented mock function: Mem1"))
+            Mem2 = (fun _ -> raise (System.NotImplementedException "Unimplemented mock function: Mem2"))
+        }
+
+    interface TypeWithAsyncDisposable with
+        member this.Mem1 arg_0_0 =
+            lock this.Calls.Mem1 (fun _ -> this.Calls.Mem1.Add (arg_0_0))
+            this.Mem1 (arg_0_0)
+
+        member this.Mem2 () =
+            lock this.Calls.Mem2 (fun _ -> this.Calls.Mem2.Add (()))
+            this.Mem2 (())
+
+    interface System.IAsyncDisposable with
+        member this.DisposeAsync () : System.Threading.Tasks.ValueTask = this.DisposeAsync ()
+namespace SomeNamespace.CapturingMock
+
+open System
+open WoofWare.Myriad.Plugins
+
+[<RequireQualifiedAccess>]
+module internal TypeWithBothDisposablesMockCalls =
+    /// All the calls made to a TypeWithBothDisposablesMock mock
+    type internal Calls =
+        {
+            Mem1 : ResizeArray<string>
+        }
+
+        /// A fresh calls object which has not yet had any calls made.
+        static member Empty () : Calls =
+            {
+                Mem1 = ResizeArray ()
+            }
+
+/// Mock record type for an interface
+type internal TypeWithBothDisposablesMock =
+    {
+        Calls : TypeWithBothDisposablesMockCalls.Calls
+        /// Implementation of IDisposable.Dispose
+        Dispose : unit -> unit
+        /// Implementation of IAsyncDisposable.DisposeAsync
+        DisposeAsync : unit -> System.Threading.Tasks.ValueTask
+        Mem1 : string -> int
+    }
+
+    /// An implementation where every non-disposal method throws.
+    static member Empty () : TypeWithBothDisposablesMock =
+        {
+            Calls = TypeWithBothDisposablesMockCalls.Calls.Empty ()
+            Dispose = (fun () -> ())
+            DisposeAsync = (fun () -> (System.Threading.Tasks.ValueTask ()))
+            Mem1 = (fun _ -> raise (System.NotImplementedException "Unimplemented mock function: Mem1"))
+        }
+
+    interface TypeWithBothDisposables with
+        member this.Mem1 arg_0_0 =
+            lock this.Calls.Mem1 (fun _ -> this.Calls.Mem1.Add (arg_0_0))
+            this.Mem1 (arg_0_0)
+
+    interface System.IDisposable with
+        member this.Dispose () : unit = this.Dispose ()
+
+    interface System.IAsyncDisposable with
+        member this.DisposeAsync () : System.Threading.Tasks.ValueTask = this.DisposeAsync ()

ConsumePlugin/GeneratedCapturingMockNoAttributes.fs

@@ -35,7 +35,7 @@ type internal PublicTypeNoAttrMock =
         Mem3 : int * System.Threading.CancellationToken option -> string
     }
 
-    /// An implementation where every non-unit method throws.
+    /// An implementation where every non-disposal method throws.
     static member Empty () : PublicTypeNoAttrMock =
         {
             Calls = PublicTypeNoAttrMockCalls.Calls.Empty ()
@@ -87,7 +87,7 @@ type public PublicTypeInternalFalseNoAttrMock =
         Mem3 : int * System.Threading.CancellationToken option -> string
     }
 
-    /// An implementation where every non-unit method throws.
+    /// An implementation where every non-disposal method throws.
     static member Empty () : PublicTypeInternalFalseNoAttrMock =
         {
             Calls = PublicTypeInternalFalseNoAttrMockCalls.Calls.Empty ()
@@ -136,7 +136,7 @@ type internal InternalTypeNoAttrMock =
         Mem2 : string -> int
     }
 
-    /// An implementation where every non-unit method throws.
+    /// An implementation where every non-disposal method throws.
     static member Empty () : InternalTypeNoAttrMock =
         {
             Calls = InternalTypeNoAttrMockCalls.Calls.Empty ()
@@ -180,7 +180,7 @@ type private PrivateTypeNoAttrMock =
         Mem2 : string -> int
     }
 
-    /// An implementation where every non-unit method throws.
+    /// An implementation where every non-disposal method throws.
     static member Empty () : PrivateTypeNoAttrMock =
         {
             Calls = PrivateTypeNoAttrMockCalls.Calls.Empty ()
@@ -224,7 +224,7 @@ type private PrivateTypeInternalFalseNoAttrMock =
         Mem2 : string -> int
     }
 
-    /// An implementation where every non-unit method throws.
+    /// An implementation where every non-disposal method throws.
     static member Empty () : PrivateTypeInternalFalseNoAttrMock =
         {
             Calls = PrivateTypeInternalFalseNoAttrMockCalls.Calls.Empty ()
@@ -265,7 +265,7 @@ type internal VeryPublicTypeNoAttrMock<'a, 'b> =
         Mem1 : 'a -> 'b
     }
 
-    /// An implementation where every non-unit method throws.
+    /// An implementation where every non-disposal method throws.
     static member Empty () : VeryPublicTypeNoAttrMock<'a, 'b> =
         {
             Calls = VeryPublicTypeNoAttrMockCalls.Calls.Empty ()
@@ -358,7 +358,7 @@ type internal CurriedNoAttrMock<'a> =
         Mem6 : int * string -> 'a * int -> string
     }
 
-    /// An implementation where every non-unit method throws.
+    /// An implementation where every non-disposal method throws.
     static member Empty () : CurriedNoAttrMock<'a> =
         {
             Calls = CurriedNoAttrMockCalls.Calls.Empty ()
@@ -478,7 +478,7 @@ type internal TypeWithInterfaceNoAttrMock =
         Mem2 : unit -> string[] Async
     }
 
-    /// An implementation where every non-unit method throws.
+    /// An implementation where every non-disposal method throws.
     static member Empty () : TypeWithInterfaceNoAttrMock =
         {
             Calls = TypeWithInterfaceNoAttrMockCalls.Calls.Empty ()

ConsumePlugin/GeneratedMock.fs

@@ -16,7 +16,7 @@ type internal PublicTypeMock =
         Mem3 : int * option<System.Threading.CancellationToken> -> string
     }
 
-    /// An implementation where every method throws.
+    /// An implementation where every non-disposal method throws.
     static member Empty : PublicTypeMock =
         {
             Mem1 = (fun _ -> raise (System.NotImplementedException "Unimplemented mock function: Mem1"))
@@ -41,7 +41,7 @@ type public PublicTypeInternalFalseMock =
         Mem3 : int * option<System.Threading.CancellationToken> -> string
     }
 
-    /// An implementation where every method throws.
+    /// An implementation where every non-disposal method throws.
     static member Empty : PublicTypeInternalFalseMock =
         {
             Mem1 = (fun _ -> raise (System.NotImplementedException "Unimplemented mock function: Mem1"))
@@ -65,7 +65,7 @@ type internal InternalTypeMock =
         Mem2 : string -> int
     }
 
-    /// An implementation where every method throws.
+    /// An implementation where every non-disposal method throws.
     static member Empty : InternalTypeMock =
         {
             Mem1 = (fun _ -> raise (System.NotImplementedException "Unimplemented mock function: Mem1"))
@@ -87,7 +87,7 @@ type private PrivateTypeMock =
         Mem2 : string -> int
     }
 
-    /// An implementation where every method throws.
+    /// An implementation where every non-disposal method throws.
     static member Empty : PrivateTypeMock =
         {
             Mem1 = (fun _ -> raise (System.NotImplementedException "Unimplemented mock function: Mem1"))
@@ -109,7 +109,7 @@ type private PrivateTypeInternalFalseMock =
         Mem2 : string -> int
     }
 
-    /// An implementation where every method throws.
+    /// An implementation where every non-disposal method throws.
     static member Empty : PrivateTypeInternalFalseMock =
         {
             Mem1 = (fun _ -> raise (System.NotImplementedException "Unimplemented mock function: Mem1"))
@@ -130,7 +130,7 @@ type internal VeryPublicTypeMock<'a, 'b> =
         Mem1 : 'a -> 'b
     }
 
-    /// An implementation where every method throws.
+    /// An implementation where every non-disposal method throws.
     static member Empty () : VeryPublicTypeMock<'a, 'b> =
         {
             Mem1 = (fun _ -> raise (System.NotImplementedException "Unimplemented mock function: Mem1"))
@@ -154,7 +154,7 @@ type internal CurriedMock<'a> =
         Mem6 : int * string -> 'a * int -> string
     }
 
-    /// An implementation where every method throws.
+    /// An implementation where every non-disposal method throws.
     static member Empty () : CurriedMock<'a> =
         {
             Mem1 = (fun _ -> raise (System.NotImplementedException "Unimplemented mock function: Mem1"))
@@ -192,7 +192,7 @@ type internal TypeWithInterfaceMock =
         Mem2 : unit -> string[] Async
     }
 
-    /// An implementation where every method throws.
+    /// An implementation where every non-disposal method throws.
     static member Empty : TypeWithInterfaceMock =
         {
             Dispose = (fun () -> ())
@@ -221,7 +221,7 @@ type internal TypeWithPropertiesMock =
         Mem1 : string option -> string[] Async
     }
 
-    /// An implementation where every method throws.
+    /// An implementation where every non-disposal method throws.
     static member Empty : TypeWithPropertiesMock =
         {
             Dispose = (fun () -> ())
@@ -237,3 +237,62 @@ type internal TypeWithPropertiesMock =
 
     interface System.IDisposable with
         member this.Dispose () : unit = this.Dispose ()
+namespace SomeNamespace
+
+open System
+open WoofWare.Myriad.Plugins
+
+/// Mock record type for an interface
+type internal TypeWithAsyncDisposableMock =
+    {
+        /// Implementation of IAsyncDisposable.DisposeAsync
+        DisposeAsync : unit -> System.Threading.Tasks.ValueTask
+        Mem1 : string option -> string[] Async
+        Mem2 : unit -> string[] Async
+    }
+
+    /// An implementation where every non-disposal method throws.
+    static member Empty : TypeWithAsyncDisposableMock =
+        {
+            DisposeAsync = (fun () -> (System.Threading.Tasks.ValueTask ()))
+            Mem1 = (fun _ -> raise (System.NotImplementedException "Unimplemented mock function: Mem1"))
+            Mem2 = (fun _ -> raise (System.NotImplementedException "Unimplemented mock function: Mem2"))
+        }
+
+    interface TypeWithAsyncDisposable with
+        member this.Mem1 arg_0_0 = this.Mem1 (arg_0_0)
+        member this.Mem2 () = this.Mem2 (())
+
+    interface System.IAsyncDisposable with
+        member this.DisposeAsync () : System.Threading.Tasks.ValueTask = this.DisposeAsync ()
+namespace SomeNamespace
+
+open System
+open WoofWare.Myriad.Plugins
+
+/// Mock record type for an interface
+type internal TypeWithBothDisposablesMock =
+    {
+        /// Implementation of IDisposable.Dispose
+        Dispose : unit -> unit
+        /// Implementation of IAsyncDisposable.DisposeAsync
+        DisposeAsync : unit -> System.Threading.Tasks.ValueTask
+        Mem1 : string -> int
+    }
+
+    /// An implementation where every non-disposal method throws.
+    static member Empty : TypeWithBothDisposablesMock =
+        {
+            Dispose = (fun () -> ())
+            DisposeAsync = (fun () -> (System.Threading.Tasks.ValueTask ()))
+            Mem1 = (fun _ -> raise (System.NotImplementedException "Unimplemented mock function: Mem1"))
+        }
+
+    interface TypeWithBothDisposables with
+        member this.Mem1 arg_0_0 = this.Mem1 (arg_0_0)
+
+    interface System.IDisposable with
+        member this.Dispose () : unit = this.Dispose ()
+
+    interface System.IAsyncDisposable with
+        member this.DisposeAsync () : System.Threading.Tasks.ValueTask = this.DisposeAsync ()

ConsumePlugin/GeneratedMockNoAttributes.fs

@@ -15,7 +15,7 @@ type internal PublicTypeNoAttrMock =
         Mem3 : int * option<System.Threading.CancellationToken> -> string
     }
 
-    /// An implementation where every method throws.
+    /// An implementation where every non-disposal method throws.
     static member Empty : PublicTypeNoAttrMock =
         {
             Mem1 = (fun _ -> raise (System.NotImplementedException "Unimplemented mock function: Mem1"))
@@ -39,7 +39,7 @@ type public PublicTypeInternalFalseNoAttrMock =
         Mem3 : int * option<System.Threading.CancellationToken> -> string
     }
 
-    /// An implementation where every method throws.
+    /// An implementation where every non-disposal method throws.
     static member Empty : PublicTypeInternalFalseNoAttrMock =
         {
             Mem1 = (fun _ -> raise (System.NotImplementedException "Unimplemented mock function: Mem1"))
@@ -62,7 +62,7 @@ type internal InternalTypeNoAttrMock =
         Mem2 : string -> int
     }
 
-    /// An implementation where every method throws.
+    /// An implementation where every non-disposal method throws.
     static member Empty : InternalTypeNoAttrMock =
         {
             Mem1 = (fun _ -> raise (System.NotImplementedException "Unimplemented mock function: Mem1"))
@@ -83,7 +83,7 @@ type private PrivateTypeNoAttrMock =
         Mem2 : string -> int
     }
 
-    /// An implementation where every method throws.
+    /// An implementation where every non-disposal method throws.
     static member Empty : PrivateTypeNoAttrMock =
         {
             Mem1 = (fun _ -> raise (System.NotImplementedException "Unimplemented mock function: Mem1"))
@@ -104,7 +104,7 @@ type private PrivateTypeInternalFalseNoAttrMock =
         Mem2 : string -> int
     }
 
-    /// An implementation where every method throws.
+    /// An implementation where every non-disposal method throws.
     static member Empty : PrivateTypeInternalFalseNoAttrMock =
         {
             Mem1 = (fun _ -> raise (System.NotImplementedException "Unimplemented mock function: Mem1"))
@@ -124,7 +124,7 @@ type internal VeryPublicTypeNoAttrMock<'a, 'b> =
         Mem1 : 'a -> 'b
     }
 
-    /// An implementation where every method throws.
+    /// An implementation where every non-disposal method throws.
     static member Empty () : VeryPublicTypeNoAttrMock<'a, 'b> =
         {
             Mem1 = (fun _ -> raise (System.NotImplementedException "Unimplemented mock function: Mem1"))
@@ -147,7 +147,7 @@ type internal CurriedNoAttrMock<'a> =
         Mem6 : int * string -> 'a * int -> string
     }
 
-    /// An implementation where every method throws.
+    /// An implementation where every non-disposal method throws.
     static member Empty () : CurriedNoAttrMock<'a> =
         {
             Mem1 = (fun _ -> raise (System.NotImplementedException "Unimplemented mock function: Mem1"))
@@ -184,7 +184,7 @@ type internal TypeWithInterfaceNoAttrMock =
         Mem2 : unit -> string[] Async
     }
 
-    /// An implementation where every method throws.
+    /// An implementation where every non-disposal method throws.
     static member Empty : TypeWithInterfaceNoAttrMock =
         {
             Dispose = (fun () -> ())

ConsumePlugin/MockExample.fs

@@ -55,3 +55,15 @@ type TypeWithProperties =
     abstract Mem1 : string option -> string[] Async
     abstract Prop1 : int
     abstract Prop2 : unit Async
+
+[<GenerateMock>]
+type TypeWithAsyncDisposable =
+    inherit IAsyncDisposable
+    abstract Mem1 : string option -> string[] Async
+    abstract Mem2 : unit -> string[] Async
+
+[<GenerateMock>]
+type TypeWithBothDisposables =
+    inherit IDisposable
+    inherit IAsyncDisposable
+    abstract Mem1 : string -> int

WoofWare.Myriad.Plugins.Test/TestCapturingMockGenerator/TestCapturingMockGenerator.fs

@@ -70,3 +70,63 @@ module TestCapturingMockGenerator =
                 bar = 3
                 Arg1 = "hello"
             }
+
+    [<Test>]
+    let ``Example of use IAsyncDisposable`` () =
+        let mock' =
+            { TypeWithAsyncDisposableMock.Empty () with
+                Mem1 = fun i -> async { return Option.toArray i }
+                Mem2 = fun () -> async { return [||] }
+            }
+
+        let mock = mock' :> TypeWithAsyncDisposable
+
+        mock.Mem1 (Some "hi") |> Async.RunSynchronously |> shouldEqual [| "hi" |]
+        mock.Mem2 () |> Async.RunSynchronously |> shouldEqual [||]
+
+        // Test that DisposeAsync returns a completed ValueTask
+        let asyncDisposable = mock :> IAsyncDisposable
+        let valueTask = asyncDisposable.DisposeAsync ()
+        valueTask.IsCompleted |> shouldEqual true
+
+        // Verify calls were captured
+        lock mock'.Calls.Mem1 (fun () -> Seq.toList mock'.Calls.Mem1)
+        |> List.exactlyOne
+        |> shouldEqual (Some "hi")
+
+        lock mock'.Calls.Mem2 (fun () -> Seq.toList mock'.Calls.Mem2)
+        |> List.exactlyOne
+        |> shouldEqual ()
+
+    [<Test>]
+    let ``Example of use: Both IDisposable and IAsyncDisposable`` () =
+        let mutable disposed = false
+        let mutable disposedAsync = false
+
+        let mock' =
+            { TypeWithBothDisposablesMock.Empty () with
+                Dispose = fun () -> disposed <- true
+                DisposeAsync =
+                    fun () ->
+                        disposedAsync <- true
+                        System.Threading.Tasks.ValueTask ()
+                Mem1 = fun s -> s.Length
+            }
+
+        let mock = mock' :> TypeWithBothDisposables
+
+        mock.Mem1 "hello" |> shouldEqual 5
+        mock.Mem1 "world" |> shouldEqual 5
+
+        // Test IDisposable.Dispose
+        (mock :> IDisposable).Dispose ()
+        disposed |> shouldEqual true
+
+        // Test IAsyncDisposable.DisposeAsync
+        let valueTask = (mock :> IAsyncDisposable).DisposeAsync ()
+        valueTask.IsCompleted |> shouldEqual true
+        disposedAsync |> shouldEqual true
+
+        // Verify calls were captured
+        lock mock'.Calls.Mem1 (fun () -> Seq.toList mock'.Calls.Mem1)
+        |> shouldEqual [ "hello" ; "world" ]

WoofWare.Myriad.Plugins.Test/TestMockGenerator/TestMockGenerator.fs

@@ -47,3 +47,45 @@ module TestMockGenerator =
         mock.Mem1 (Some "hi") |> Async.RunSynchronously |> shouldEqual [| "hi" |]
 
         mock.Prop1 |> shouldEqual 44
+
+    [<Test>]
+    let ``Example of use: IAsyncDisposable`` () =
+        let mock : TypeWithAsyncDisposable =
+            { TypeWithAsyncDisposableMock.Empty with
+                Mem1 = fun i -> async { return Option.toArray i }
+            }
+            :> _
+
+        mock.Mem1 (Some "hi") |> Async.RunSynchronously |> shouldEqual [| "hi" |]
+
+        // Test that DisposeAsync returns a completed ValueTask
+        let asyncDisposable = mock :> IAsyncDisposable
+        let valueTask = asyncDisposable.DisposeAsync ()
+        valueTask.IsCompleted |> shouldEqual true
+
+    [<Test>]
+    let ``Example of use: Both IDisposable and IAsyncDisposable`` () =
+        let mutable disposed = false
+        let mutable disposedAsync = false
+
+        let mock : TypeWithBothDisposables =
+            { TypeWithBothDisposablesMock.Empty with
+                Dispose = fun () -> disposed <- true
+                DisposeAsync =
+                    fun () ->
+                        disposedAsync <- true
+                        System.Threading.Tasks.ValueTask ()
+                Mem1 = fun s -> s.Length
+            }
+            :> _
+
+        mock.Mem1 "hello" |> shouldEqual 5
+
+        // Test IDisposable.Dispose
+        (mock :> IDisposable).Dispose ()
+        disposed |> shouldEqual true
+
+        // Test IAsyncDisposable.DisposeAsync
+        let valueTask = (mock :> IAsyncDisposable).DisposeAsync ()
+        valueTask.IsCompleted |> shouldEqual true
+        disposedAsync |> shouldEqual true

WoofWare.Myriad.Plugins.Test/WoofWare.Myriad.Plugins.Test.fsproj

@@ -9,7 +9,6 @@
       I have not yet seen a single instance where I care about this warning
     -->
     <NoWarn>$(NoWarn),NU1903</NoWarn>
-    <TestingPlatformDotnetTestSupport>true</TestingPlatformDotnetTestSupport>
   </PropertyGroup>
 
   <ItemGroup>

WoofWare.Myriad.Plugins/CapturingInterfaceMockGenerator.fs

@@ -19,7 +19,9 @@ module internal CapturingInterfaceMockGenerator =
     open Fantomas.FCS.Text.Range
 
     [<RequireQualifiedAccess>]
-    type private KnownInheritance = | IDisposable
+    type private KnownInheritance =
+        | IDisposable
+        | IAsyncDisposable
 
     /// Expects the input `args` list to have more than one element.
     let private createTypeForArgs
@@ -209,6 +211,8 @@ module internal CapturingInterfaceMockGenerator =
                     | [] -> failwith "Unexpected empty identifier in inheritance declaration"
                     | [ "IDisposable" ]
                     | [ "System" ; "IDisposable" ] -> KnownInheritance.IDisposable
+                    | [ "IAsyncDisposable" ]
+                    | [ "System" ; "IAsyncDisposable" ] -> KnownInheritance.IAsyncDisposable
                     | _ -> failwithf $"Unrecognised inheritance identifier: %+A{name}"
                 | x -> failwithf $"Unrecognised type in inheritance: %+A{x}"
             )
@@ -250,12 +254,26 @@ module internal CapturingInterfaceMockGenerator =
 
         let emptyRecordFieldInstantiations =
             let interfaceExtras =
-                if inherits.Contains KnownInheritance.IDisposable then
-                    let unitFun = SynExpr.createThunk (SynExpr.CreateConst ())
+                let disposable =
+                    if inherits.Contains KnownInheritance.IDisposable then
+                        let unitFun = SynExpr.createThunk (SynExpr.CreateConst ())
+                        [ SynLongIdent.createS "Dispose", unitFun ]
+                    else
+                        []
 
-                    [ SynLongIdent.createS "Dispose", unitFun ]
-                else
-                    []
+                let asyncDisposable =
+                    if inherits.Contains KnownInheritance.IAsyncDisposable then
+                        let valueTaskCtor =
+                            SynExpr.createLongIdent [ "System" ; "Threading" ; "Tasks" ; "ValueTask" ]
+                            |> SynExpr.applyTo (SynExpr.CreateConst ())
+                            |> SynExpr.paren
+                            |> SynExpr.createLambda "()"
+
+                        [ SynLongIdent.createS "DisposeAsync", valueTaskCtor ]
+                    else
+                        []
+
+                disposable @ asyncDisposable
 
             let originalMembers =
                 fields
@@ -275,23 +293,42 @@ module internal CapturingInterfaceMockGenerator =
                 [ Ident.create "Empty" ]
                 [ SynPat.unit ]
                 (SynExpr.createRecord None emptyRecordFieldInstantiations)
-            |> SynBinding.withXmlDoc (PreXmlDoc.create "An implementation where every non-unit method throws.")
+            |> SynBinding.withXmlDoc (PreXmlDoc.create "An implementation where every non-disposal method throws.")
             |> SynBinding.withReturnAnnotation constructorReturnType
             |> SynMemberDefn.staticMember
 
         let recordFields =
             let extras =
-                if inherits.Contains KnownInheritance.IDisposable then
-                    {
-                        Attrs = []
-                        Ident = Some (Ident.create "Dispose")
-                        Type = SynType.funFromDomain SynType.unit SynType.unit
-                    }
-                    |> SynField.make
-                    |> SynField.withDocString (PreXmlDoc.create "Implementation of IDisposable.Dispose")
-                    |> List.singleton
-                else
-                    []
+                let disposable =
+                    if inherits.Contains KnownInheritance.IDisposable then
+                        {
+                            Attrs = []
+                            Ident = Some (Ident.create "Dispose")
+                            Type = SynType.funFromDomain SynType.unit SynType.unit
+                        }
+                        |> SynField.make
+                        |> SynField.withDocString (PreXmlDoc.create "Implementation of IDisposable.Dispose")
+                        |> List.singleton
+                    else
+                        []
+
+                let asyncDisposable =
+                    if inherits.Contains KnownInheritance.IAsyncDisposable then
+                        {
+                            Attrs = []
+                            Ident = Some (Ident.create "DisposeAsync")
+                            Type =
+                                SynType.funFromDomain
+                                    SynType.unit
+                                    (SynType.createLongIdent' [ "System" ; "Threading" ; "Tasks" ; "ValueTask" ])
+                        }
+                        |> SynField.make
+                        |> SynField.withDocString (PreXmlDoc.create "Implementation of IAsyncDisposable.DisposeAsync")
+                        |> List.singleton
+                    else
+                        []
+
+                disposable @ asyncDisposable
 
             let nonExtras =
                 fields |> Map.toSeq |> Seq.map (fun (_, (field, _)) -> field) |> Seq.toList
@@ -528,6 +565,23 @@ module internal CapturingInterfaceMockGenerator =
                         Some [ mem ],
                         range0
                     )
+
+                | KnownInheritance.IAsyncDisposable ->
+                    let mem =
+                        SynExpr.createLongIdent [ "this" ; "DisposeAsync" ]
+                        |> SynExpr.applyTo (SynExpr.CreateConst ())
+                        |> SynBinding.basic [ Ident.create "this" ; Ident.create "DisposeAsync" ] [ SynPat.unit ]
+                        |> SynBinding.withReturnAnnotation (
+                            SynType.createLongIdent' [ "System" ; "Threading" ; "Tasks" ; "ValueTask" ]
+                        )
+                        |> SynMemberDefn.memberImplementation
+
+                    SynMemberDefn.Interface (
+                        SynType.createLongIdent' [ "System" ; "IAsyncDisposable" ],
+                        Some range0,
+                        Some [ mem ],
+                        range0
+                    )
             )
             |> Seq.toList
 

WoofWare.Myriad.Plugins/InterfaceMockGenerator.fs

@@ -20,7 +20,9 @@ module internal InterfaceMockGenerator =
         | Some id -> id
 
     [<RequireQualifiedAccess>]
-    type private KnownInheritance = | IDisposable
+    type private KnownInheritance =
+        | IDisposable
+        | IAsyncDisposable
 
     let createType
         (spec : GenerateMockOutputSpec)
@@ -39,6 +41,8 @@ module internal InterfaceMockGenerator =
                     | [] -> failwith "Unexpected empty identifier in inheritance declaration"
                     | [ "IDisposable" ]
                     | [ "System" ; "IDisposable" ] -> KnownInheritance.IDisposable
+                    | [ "IAsyncDisposable" ]
+                    | [ "System" ; "IAsyncDisposable" ] -> KnownInheritance.IAsyncDisposable
                     | _ -> failwithf "Unrecognised inheritance identifier: %+A" name
                 | x -> failwithf "Unrecognised type in inheritance: %+A" x
             )
@@ -69,12 +73,26 @@ module internal InterfaceMockGenerator =
 
         let constructorFields =
             let extras =
-                if inherits.Contains KnownInheritance.IDisposable then
-                    let unitFun = SynExpr.createThunk (SynExpr.CreateConst ())
+                let disposable =
+                    if inherits.Contains KnownInheritance.IDisposable then
+                        let unitFun = SynExpr.createThunk (SynExpr.CreateConst ())
+                        [ SynLongIdent.createS "Dispose", unitFun ]
+                    else
+                        []
 
-                    [ SynLongIdent.createS "Dispose", unitFun ]
-                else
-                    []
+                let asyncDisposable =
+                    if inherits.Contains KnownInheritance.IAsyncDisposable then
+                        let valueTaskCtor =
+                            SynExpr.createLongIdent [ "System" ; "Threading" ; "Tasks" ; "ValueTask" ]
+                            |> SynExpr.applyTo (SynExpr.CreateConst ())
+                            |> SynExpr.paren
+                            |> SynExpr.createLambda "()"
+
+                        [ SynLongIdent.createS "DisposeAsync", valueTaskCtor ]
+                    else
+                        []
+
+                disposable @ asyncDisposable
 
             let nonExtras =
                 fields
@@ -90,23 +108,42 @@ module internal InterfaceMockGenerator =
                  else
                      [ SynPat.unit ])
                 (SynExpr.createRecord None constructorFields)
-            |> SynBinding.withXmlDoc (PreXmlDoc.create "An implementation where every method throws.")
+            |> SynBinding.withXmlDoc (PreXmlDoc.create "An implementation where every non-disposal method throws.")
             |> SynBinding.withReturnAnnotation constructorReturnType
             |> SynMemberDefn.staticMember
 
         let fields =
             let extras =
-                if inherits.Contains KnownInheritance.IDisposable then
-                    {
-                        Attrs = []
-                        Ident = Some (Ident.create "Dispose")
-                        Type = SynType.funFromDomain SynType.unit SynType.unit
-                    }
-                    |> SynField.make
-                    |> SynField.withDocString (PreXmlDoc.create "Implementation of IDisposable.Dispose")
-                    |> List.singleton
-                else
-                    []
+                let disposable =
+                    if inherits.Contains KnownInheritance.IDisposable then
+                        {
+                            Attrs = []
+                            Ident = Some (Ident.create "Dispose")
+                            Type = SynType.funFromDomain SynType.unit SynType.unit
+                        }
+                        |> SynField.make
+                        |> SynField.withDocString (PreXmlDoc.create "Implementation of IDisposable.Dispose")
+                        |> List.singleton
+                    else
+                        []
+
+                let asyncDisposable =
+                    if inherits.Contains KnownInheritance.IAsyncDisposable then
+                        {
+                            Attrs = []
+                            Ident = Some (Ident.create "DisposeAsync")
+                            Type =
+                                SynType.funFromDomain
+                                    SynType.unit
+                                    (SynType.createLongIdent' [ "System" ; "Threading" ; "Tasks" ; "ValueTask" ])
+                        }
+                        |> SynField.make
+                        |> SynField.withDocString (PreXmlDoc.create "Implementation of IAsyncDisposable.DisposeAsync")
+                        |> List.singleton
+                    else
+                        []
+
+                disposable @ asyncDisposable
 
             extras @ fields
 
@@ -212,6 +249,23 @@ module internal InterfaceMockGenerator =
                         Some [ mem ],
                         range0
                     )
+
+                | KnownInheritance.IAsyncDisposable ->
+                    let mem =
+                        SynExpr.createLongIdent [ "this" ; "DisposeAsync" ]
+                        |> SynExpr.applyTo (SynExpr.CreateConst ())
+                        |> SynBinding.basic [ Ident.create "this" ; Ident.create "DisposeAsync" ] [ SynPat.unit ]
+                        |> SynBinding.withReturnAnnotation (
+                            SynType.createLongIdent' [ "System" ; "Threading" ; "Tasks" ; "ValueTask" ]
+                        )
+                        |> SynMemberDefn.memberImplementation
+
+                    SynMemberDefn.Interface (
+                        SynType.createLongIdent' [ "System" ; "IAsyncDisposable" ],
+                        Some range0,
+                        Some [ mem ],
+                        range0
+                    )
             )
             |> Seq.toList
 

nix/deps.json

@@ -389,6 +389,11 @@
     "version": "0.8.4",
     "hash": "sha256-UI7f2nt4g4Gg1Ke/IChrA4fpVOYAChXpvR6zkKfkmzE="
   },
+  {
+    "pname": "WoofWare.NUnitTestRunner",
+    "version": "0.3.9",
+    "hash": "sha256-+QVx5NYdY1JZoMcWfJRwFgvEj2dBxWlJU0mu1Hmnlhs="
+  },
   {
     "pname": "WoofWare.Whippet.Fantomas",
     "version": "0.6.4",