fixed LambdaCommandBusExtensions return values

martinzima · martinzima · commit d86cc067a3e0 · 2024-06-24T13:10:10.000+02:00
diff --git a/RELEASE_NOTES.md b/RELEASE_NOTES.md
@@ -2,6 +2,9 @@
 
 ## [1.36.0] - 2024-06-24
 
+### Fixed
+- fixed LambdaCommandBusExtensions return values
+
 ### Changed
 
 - upgraded to EasyNetQ 7.8.0
diff --git a/Revo.Core/Commands/Lambda/LambdaCommandBusExtensions.cs b/Revo.Core/Commands/Lambda/LambdaCommandBusExtensions.cs
@@ -195,83 +195,83 @@ public static Task SendLambdaCommandAsync<T1, T2, T3, T4, T5, T6, T7>(this IComm
         /// Executes specified lambda function like it was performed by any regular command handler.
         /// This includes scoped resolution of its parameter dependencies, committing the unit of work, etc.
         /// </summary>
-        public static Task SendLambdaCommandAsync<TResult>(this ICommandBus commandBus, Func<Task<TResult>> query,
+        public static async Task<TResult> SendLambdaCommandAsync<TResult>(this ICommandBus commandBus, Func<Task<TResult>> query,
             CancellationToken cancellationToken = default(CancellationToken))
         {
-            return commandBus.SendAsync(new LambdaResultCommand(query, typeof(TResult)), cancellationToken);
+            return (TResult) await commandBus.SendAsync(new LambdaResultCommand(query, typeof(TResult)), cancellationToken);
         }
 
         /// <summary>
         /// Executes specified lambda function like it was performed by any regular command handler.
         /// This includes scoped resolution of its parameter dependencies, committing the unit of work, etc.
         /// </summary>
-        public static Task SendLambdaCommandAsync<TResult, T1>(this ICommandBus commandBus, Func<T1, Task<TResult>> query,
+        public static async Task<TResult> SendLambdaCommandAsync<TResult, T1>(this ICommandBus commandBus, Func<T1, Task<TResult>> query,
             CancellationToken cancellationToken = default(CancellationToken))
         {
-            return commandBus.SendAsync(new LambdaResultCommand(query, typeof(TResult)), cancellationToken);
+            return (TResult) await commandBus.SendAsync(new LambdaResultCommand(query, typeof(TResult)), cancellationToken);
         }
 
         /// <summary>
         /// Executes specified lambda function like it was performed by any regular command handler.
         /// This includes scoped resolution of its parameter dependencies, committing the unit of work, etc.
         /// </summary>
-        public static Task SendLambdaCommandAsync<TResult, T1, T2>(this ICommandBus commandBus, Func<T1, T2, Task<TResult>> query,
+        public static async Task<TResult> SendLambdaCommandAsync<TResult, T1, T2>(this ICommandBus commandBus, Func<T1, T2, Task<TResult>> query,
             CancellationToken cancellationToken = default(CancellationToken))
         {
-            return commandBus.SendAsync(new LambdaResultCommand(query, typeof(TResult)), cancellationToken);
+            return (TResult) await commandBus.SendAsync(new LambdaResultCommand(query, typeof(TResult)), cancellationToken);
         }
 
         /// <summary>
         /// Executes specified lambda function like it was performed by any regular command handler.
         /// This includes scoped resolution of its parameter dependencies, committing the unit of work, etc.
         /// </summary>
-        public static Task SendLambdaCommandAsync<TResult, T1, T2, T3>(this ICommandBus commandBus, Func<T1, T2, T3, Task<TResult>> query,
+        public static async Task<TResult> SendLambdaCommandAsync<TResult, T1, T2, T3>(this ICommandBus commandBus, Func<T1, T2, T3, Task<TResult>> query,
             CancellationToken cancellationToken = default(CancellationToken))
         {
-            return commandBus.SendAsync(new LambdaResultCommand(query, typeof(TResult)), cancellationToken);
+            return (TResult) await commandBus.SendAsync(new LambdaResultCommand(query, typeof(TResult)), cancellationToken);
         }
 
         /// <summary>
         /// Executes specified lambda function like it was performed by any regular command handler.
         /// This includes scoped resolution of its parameter dependencies, committing the unit of work, etc.
         /// </summary>
-        public static Task SendLambdaCommandAsync<TResult, T1, T2, T3, T4>(this ICommandBus commandBus, Func<T1, T2, T3, T4, Task<TResult>> query,
+        public static async Task<TResult> SendLambdaCommandAsync<TResult, T1, T2, T3, T4>(this ICommandBus commandBus, Func<T1, T2, T3, T4, Task<TResult>> query,
             CancellationToken cancellationToken = default(CancellationToken))
         {
-            return commandBus.SendAsync(new LambdaResultCommand(query, typeof(TResult)), cancellationToken);
+            return (TResult) await commandBus.SendAsync(new LambdaResultCommand(query, typeof(TResult)), cancellationToken);
         }
 
         /// <summary>
         /// Executes specified lambda function like it was performed by any regular command handler.
         /// This includes scoped resolution of its parameter dependencies, committing the unit of work, etc.
         /// </summary>
-        public static Task SendLambdaCommandAsync<TResult, T1, T2, T3, T4, T5>(this ICommandBus commandBus,
+        public static async Task<TResult> SendLambdaCommandAsync<TResult, T1, T2, T3, T4, T5>(this ICommandBus commandBus,
             Func<T1, T2, T3, T4, T5, Task<TResult>> query,
             CancellationToken cancellationToken = default(CancellationToken))
         {
-            return commandBus.SendAsync(new LambdaResultCommand(query, typeof(TResult)), cancellationToken);
+            return (TResult) await commandBus.SendAsync(new LambdaResultCommand(query, typeof(TResult)), cancellationToken);
         }
 
         /// <summary>
         /// Executes specified lambda function like it was performed by any regular command handler.
         /// This includes scoped resolution of its parameter dependencies, committing the unit of work, etc.
         /// </summary>
-        public static Task SendLambdaCommandAsync<TResult, T1, T2, T3, T4, T5, T6>(this ICommandBus commandBus,
+        public static async Task<TResult> SendLambdaCommandAsync<TResult, T1, T2, T3, T4, T5, T6>(this ICommandBus commandBus,
             Func<T1, T2, T3, T4, T5, T6, Task<TResult>> query,
             CancellationToken cancellationToken = default(CancellationToken))
         {
-            return commandBus.SendAsync(new LambdaResultCommand(query, typeof(TResult)), cancellationToken);
+            return (TResult) await commandBus.SendAsync(new LambdaResultCommand(query, typeof(TResult)), cancellationToken);
         }
 
         /// <summary>
         /// Executes specified lambda function like it was performed by any regular command handler.
         /// This includes scoped resolution of its parameter dependencies, committing the unit of work, etc.
         /// </summary>
-        public static Task SendLambdaCommandAsync<TResult, T1, T2, T3, T4, T5, T6, T7>(this ICommandBus commandBus,
+        public static async Task<TResult> SendLambdaCommandAsync<TResult, T1, T2, T3, T4, T5, T6, T7>(this ICommandBus commandBus,
             Func<T1, T2, T3, T4, T5, T6, T7, Task<TResult>> query,
             CancellationToken cancellationToken = default(CancellationToken))
         {
-            return commandBus.SendAsync(new LambdaResultCommand(query, typeof(TResult)), cancellationToken);
+            return (TResult) await commandBus.SendAsync(new LambdaResultCommand(query, typeof(TResult)), cancellationToken);
         }
 
         #endregion
@@ -282,93 +282,93 @@ public static Task SendLambdaCommandAsync<TResult, T1, T2, T3, T4, T5, T6, T7>(t
         /// Executes specified lambda function like it was performed by any regular command handler.
         /// This includes scoped resolution of its parameter dependencies, committing the unit of work, etc.
         /// </summary>
-        public static Task SendLambdaCommandAsync<TResult>(this ICommandBus commandBus, Func<Task<TResult>> query,
+        public static async Task<TResult> SendLambdaCommandAsync<TResult>(this ICommandBus commandBus, Func<Task<TResult>> query,
             CommandExecutionOptions executionOptions,
             CancellationToken cancellationToken = default(CancellationToken))
         {
-            return commandBus.SendAsync(new LambdaResultCommand(query, typeof(TResult)), executionOptions, cancellationToken);
+            return (TResult) await commandBus.SendAsync(new LambdaResultCommand(query, typeof(TResult)), executionOptions, cancellationToken);
         }
 
         /// <summary>
         /// Executes specified lambda function like it was performed by any regular command handler.
         /// This includes scoped resolution of its parameter dependencies, committing the unit of work, etc.
         /// </summary>
-        public static Task SendLambdaCommandAsync<TResult, T1>(this ICommandBus commandBus, Func<T1, Task<TResult>> query,
+        public static async Task<TResult> SendLambdaCommandAsync<TResult, T1>(this ICommandBus commandBus, Func<T1, Task<TResult>> query,
             CommandExecutionOptions executionOptions,
             CancellationToken cancellationToken = default(CancellationToken))
         {
-            return commandBus.SendAsync(new LambdaResultCommand(query, typeof(TResult)), executionOptions, cancellationToken);
+            return (TResult) await commandBus.SendAsync(new LambdaResultCommand(query, typeof(TResult)), executionOptions, cancellationToken);
         }
 
         /// <summary>
         /// Executes specified lambda function like it was performed by any regular command handler.
         /// This includes scoped resolution of its parameter dependencies, committing the unit of work, etc.
         /// </summary>
-        public static Task SendLambdaCommandAsync<TResult, T1, T2>(this ICommandBus commandBus, Func<T1, T2, Task<TResult>> query,
+        public static async Task<TResult> SendLambdaCommandAsync<TResult, T1, T2>(this ICommandBus commandBus, Func<T1, T2, Task<TResult>> query,
             CommandExecutionOptions executionOptions,
             CancellationToken cancellationToken = default(CancellationToken))
         {
-            return commandBus.SendAsync(new LambdaResultCommand(query, typeof(TResult)), executionOptions, cancellationToken);
+            return (TResult) await commandBus.SendAsync(new LambdaResultCommand(query, typeof(TResult)), executionOptions, cancellationToken);
         }
 
         /// <summary>
         /// Executes specified lambda function like it was performed by any regular command handler.
         /// This includes scoped resolution of its parameter dependencies, committing the unit of work, etc.
         /// </summary>
-        public static Task SendLambdaCommandAsync<TResult, T1, T2, T3>(this ICommandBus commandBus,
+        public static async Task<TResult> SendLambdaCommandAsync<TResult, T1, T2, T3>(this ICommandBus commandBus,
             Func<T1, T2, T3, Task<TResult>> query,
             CommandExecutionOptions executionOptions,
             CancellationToken cancellationToken = default(CancellationToken))
         {
-            return commandBus.SendAsync(new LambdaResultCommand(query, typeof(TResult)), executionOptions, cancellationToken);
+            return (TResult) await commandBus.SendAsync(new LambdaResultCommand(query, typeof(TResult)), executionOptions, cancellationToken);
         }
 
         /// <summary>
         /// Executes specified lambda function like it was performed by any regular command handler.
         /// This includes scoped resolution of its parameter dependencies, committing the unit of work, etc.
         /// </summary>
-        public static Task SendLambdaCommandAsync<TResult, T1, T2, T3, T4>(this ICommandBus commandBus,
+        public static async Task<TResult> SendLambdaCommandAsync<TResult, T1, T2, T3, T4>(this ICommandBus commandBus,
             Func<T1, T2, T3, T4, Task<TResult>> query,
             CommandExecutionOptions executionOptions,
             CancellationToken cancellationToken = default(CancellationToken))
         {
-            return commandBus.SendAsync(new LambdaResultCommand(query, typeof(TResult)), executionOptions, cancellationToken);
+            return (TResult) await commandBus.SendAsync(new LambdaResultCommand(query, typeof(TResult)), executionOptions, cancellationToken);
         }
 
         /// <summary>
         /// Executes specified lambda function like it was performed by any regular command handler.
         /// This includes scoped resolution of its parameter dependencies, committing the unit of work, etc.
         /// </summary>
-        public static Task SendLambdaCommandAsync<TResult, T1, T2, T3, T4, T5>(this ICommandBus commandBus,
+        public static async Task<TResult> SendLambdaCommandAsync<TResult, T1, T2, T3, T4, T5>(this ICommandBus commandBus,
             Func<T1, T2, T3, T4, T5, Task<TResult>> query,
             CommandExecutionOptions executionOptions,
             CancellationToken cancellationToken = default(CancellationToken))
         {
-            return commandBus.SendAsync(new LambdaResultCommand(query, typeof(TResult)), executionOptions, cancellationToken);
+            return (TResult) await commandBus.SendAsync(new LambdaResultCommand(query, typeof(TResult)), executionOptions, cancellationToken);
         }
 
         /// <summary>
         /// Executes specified lambda function like it was performed by any regular command handler.
         /// This includes scoped resolution of its parameter dependencies, committing the unit of work, etc.
         /// </summary>
-        public static Task SendLambdaCommandAsync<TResult, T1, T2, T3, T4, T5, T6>(this ICommandBus commandBus,
+        public static async Task<TResult> SendLambdaCommandAsync<TResult, T1, T2, T3, T4, T5, T6>(this ICommandBus commandBus,
             Func<T1, T2, T3, T4, T5, T6, Task<TResult>> query,
             CommandExecutionOptions executionOptions,
             CancellationToken cancellationToken = default(CancellationToken))
         {
-            return commandBus.SendAsync(new LambdaResultCommand(query, typeof(TResult)), executionOptions, cancellationToken);
+            return (TResult) await commandBus.SendAsync(new LambdaResultCommand(query, typeof(TResult)), executionOptions, cancellationToken);
         }
 
         /// <summary>
         /// Executes specified lambda function like it was performed by any regular command handler.
         /// This includes scoped resolution of its parameter dependencies, committing the unit of work, etc.
         /// </summary>
-        public static Task SendLambdaCommandAsync<TResult, T1, T2, T3, T4, T5, T6, T7>(this ICommandBus commandBus,
+        public static async Task<TResult> SendLambdaCommandAsync<TResult, T1, T2, T3, T4, T5, T6, T7>(this ICommandBus commandBus,
             Func<T1, T2, T3, T4, T5, T6, T7, Task<TResult>> query,
             CommandExecutionOptions executionOptions,
             CancellationToken cancellationToken = default(CancellationToken))
         {
-            return commandBus.SendAsync(new LambdaResultCommand(query, typeof(TResult)), executionOptions, cancellationToken);
+            return (TResult) await commandBus.SendAsync(new LambdaResultCommand(query, typeof(TResult)), executionOptions, cancellationToken);
         }
 
         #endregion
diff --git a/Tests/Revo.Core.Tests/Commands/Lambda/LambdaCommandBusExtensionsTests.cs b/Tests/Revo.Core.Tests/Commands/Lambda/LambdaCommandBusExtensionsTests.cs
@@ -1,4 +1,5 @@
 ﻿using System;
+using System.Threading;
 using System.Threading.Tasks;
 using NSubstitute;
 using Revo.Core.Commands;
@@ -28,6 +29,8 @@ public async Task SendCommand()
         public async Task SendResultCommand()
         {
             Func<object, Task<int>> lambda = async param1 => 1;
+            commandBus.SendAsync(Arg.Is<LambdaResultCommand>(x => x.Delegate == lambda), Arg.Any<CancellationToken>())
+                .Returns(1);
             await commandBus.SendLambdaCommandAsync(lambda);
             commandBus.Received(1).SendAsync(Arg.Is<LambdaResultCommand>(x => x.Delegate == lambda));
         }

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`	`1`	`using System;`
	`2`	`+using System.Threading;`
`2`	`3`	`using System.Threading.Tasks;`
`3`	`4`	`using NSubstitute;`
`4`	`5`	`using Revo.Core.Commands;`
`@@ -28,6 +29,8 @@ public async Task SendCommand()`
`28`	`29`	`public async Task SendResultCommand()`
`29`	`30`	`{`
`30`	`31`	`Func<object, Task<int>> lambda = async param1 => 1;`
	`32`	`+ commandBus.SendAsync(Arg.Is<LambdaResultCommand>(x => x.Delegate == lambda), Arg.Any<CancellationToken>())`
	`33`	`+ .Returns(1);`
`31`	`34`	`await commandBus.SendLambdaCommandAsync(lambda);`
`32`	`35`	`commandBus.Received(1).SendAsync(Arg.Is<LambdaResultCommand>(x => x.Delegate == lambda));`
`33`	`36`	`}`