tests working

Author: eduard-dumitru

src/UiPath.Ipc.Tests/ComputingTests.cs

@@ -40,4 +40,71 @@ protected override ClientBase ConfigTransportAgnostic(ClientBase client)
         }
     };
     #endregion
+
+    [Theory, IpcAutoData]
+    public async Task Calls_ShouldWork(float x, float y)
+    => await Proxy.AddFloats(x, y).ShouldBeAsync(x + y);
+
+    [Theory, IpcAutoData]
+    public Task ConcurrentCalls_ShouldWork(float sameX, float sameY) => Task.WhenAll(Enumerable.Range(1, 100).Select(_ => Calls_ShouldWork(sameX, sameY)));
+
+    [Theory, IpcAutoData]
+    public async Task CallsWithStructParamsAndReturns_ShouldWork(ComplexNumber a, ComplexNumber b)
+    => await Proxy.AddComplexNumbers(a, b).ShouldBeAsync(a + b);
+
+    [Fact]
+    public async Task ClientCancellations_ShouldWork()
+    {
+        using var cts = new CancellationTokenSource();
+
+        var taskWaiting = Proxy.Wait(Timeout.InfiniteTimeSpan, cts.Token);
+
+        await Task.Delay(Constants.Timeout_Short);
+
+        taskWaiting.IsCompleted.ShouldBeFalse();
+
+        cts.Cancel();
+
+        await taskWaiting.ShouldCompleteInAsync(Constants.Timeout_Short).ShouldThrowAsync<OperationCanceledException>(); // in-process scheduling fast
+
+        await Proxy.Wait(TimeSpan.Zero).ShouldCompleteInAsync(Constants.Timeout_IpcRoundtrip).ShouldBeAsync(true); // connection still alive
+    }
+
+    [Fact, OverrideConfig(typeof(ShortClientTimeout))]
+    public async Task ClientTimeouts_ShouldWork()
+    {
+        await Proxy.Wait(Timeout.InfiniteTimeSpan).ShouldThrowAsync<TimeoutException>();
+
+        await Proxy.GetCallbackThreadName(
+            duration: TimeSpan.FromMilliseconds(500),
+            message: new()
+            {
+                RequestTimeout = TimeSpan.FromSeconds(2)
+            })
+            .ShouldBeAsync(Names.GuiThreadName)
+            .ShouldNotThrowAsync();
+    }
+
+    private sealed class ShortClientTimeout : OverrideConfig
+    {
+        public override ClientBase Override(ClientBase client)
+        => client with { RequestTimeout = TimeSpan.FromMilliseconds(10) };
+    }
+
+    [Theory, IpcAutoData]
+    public async Task CallsWithArraysOfStructsAsParams_ShouldWork(ComplexNumber a, ComplexNumber b, ComplexNumber c)
+    => await Proxy.AddComplexNumberList([a, b, c]).ShouldBeAsync(a + b + c);
+
+    [Fact]
+    public async Task Callbacks_ShouldWork()
+    => await Proxy.GetCallbackThreadName(duration: TimeSpan.Zero).ShouldBeAsync(Names.GuiThreadName);
+
+    [Fact]
+    public async Task CallbacksWithParams_ShouldWork()
+    => await Proxy.MultiplyInts(7, 1).ShouldBeAsync(7);
+
+    [Fact]
+    public async Task ConcurrentCallbacksWithParams_ShouldWork()
+    => await Task.WhenAll(
+        Enumerable.Range(1, 50).Select(_ => CallbacksWithParams_ShouldWork()));
 }

src/UiPath.Ipc.Tests/Helpers/Constants.cs

@@ -12,7 +12,7 @@ internal static class Constants
     /// Considering a service method which returns instantly, and the time it takes for UiPath.Ipc to complete a full roundtrip from calling to receiving the result,
     /// this value represents an exagerated timeout beyond which it's clear that a bug has occurred, even when running on a CI agent under load.
     /// </summary>
-    public static readonly TimeSpan Timeout_IpcRoundtrip = TimeSpan.FromMilliseconds(600);
+    public static readonly TimeSpan Timeout_IpcRoundtrip = TimeSpan.FromMilliseconds(800);
 
-    public static readonly TimeSpan Timeout_Short = TimeSpan.FromMilliseconds(100);
+    public static readonly TimeSpan Timeout_Short = TimeSpan.FromMilliseconds(300);
 }

src/UiPath.Ipc.Tests/Helpers/IpcAutoDataAttribute.cs

@@ -12,6 +12,7 @@ public IpcAutoDataAttribute() : base(CreateFixture)
     private static Fixture CreateFixture()
     {
         var fixture = new Fixture();
+        new SupportMutableValueTypesCustomization().Customize(fixture);
         return fixture;
     }
 }

src/UiPath.Ipc.Tests/Helpers/IpcHelpers.cs

@@ -18,7 +18,6 @@ public static ServiceProvider ConfigureServices(ITestOutputHelper outputHelper)
 
         .AddSingleton<ComputingService>()
         .AddSingletonAlias<IComputingService, ComputingService>()
-        .AddSingletonAlias<IComputingServiceBase, ComputingService>()
 
         .BuildServiceProvider();
 

src/UiPath.Ipc.Tests/Helpers/ShouldlyHelpers.cs

@@ -18,6 +18,21 @@ public static async Task ShouldBeAsync<T>(this Task<T> task, T expected, [Caller
         }
     }
 
+    public static async Task<T> ShouldNotBeNullAsync<T>(this Task<T> task, [CallerArgumentExpression(nameof(task))] string? taskExpression = null)
+        where T : class
+    {
+        var actual = await task;
+        try
+        {
+            return actual.ShouldNotBeNull();
+        }
+        catch
+        {
+            throw new ShouldAssertException($"The provided expression `{taskExpression}`\r\n\tshouldn't have yielded null but did.");
+        }
+    }
+
+
     public static async Task<T> ShouldNotThrowAsyncAnd<T>(this Task<T> task, [CallerArgumentExpression(nameof(task))] string? taskExpression = null)
     {
         try

src/UiPath.Ipc.Tests/Services/ArithmeticCallback.cs

@@ -0,0 +1,7 @@
+namespace UiPath.Ipc.Tests;
+
+public sealed class ArithmeticCallback : IArithmeticCallback
+{
+    public async Task<int> Increment(int x) => x + 1;
+}
+

src/UiPath.Ipc.Tests/Services/Computing.cs

@@ -3,4 +3,9 @@
 public sealed class ComputingCallback : IComputingCallback
 {
     public Guid Id { get; } = Guid.NewGuid();
-}
+
+    public async Task<string> GetThreadName() => Thread.CurrentThread.Name!;
+
+    public async Task<int> AddInts(int x, int y) => x + y;
+}
+

src/UiPath.Ipc.Tests/Services/ComputingCallback.cs

@@ -0,0 +1,54 @@
+
+using Microsoft.Extensions.Logging;
+
+namespace UiPath.Ipc.Tests;
+
+public sealed class ComputingService(ILogger<ComputingService> logger) : IComputingService
+{
+    public async Task<float> AddFloats(float a, float b, CancellationToken ct = default)
+    {
+        logger.LogInformation($"{nameof(AddFloats)} called.");
+        return a + b;
+    }
+
+    public async Task<ComplexNumber> AddComplexNumbers(ComplexNumber a, ComplexNumber b)
+    {
+        logger.LogInformation($"{nameof(AddComplexNumbers)} called.");
+        return a + b;
+    }
+
+    public async Task<bool> Wait(TimeSpan duration, CancellationToken ct = default)
+    {
+        await Task.Delay(duration, ct);
+        return true;
+    }
+
+    public async Task<string> GetCallbackThreadName(TimeSpan duration, Message message = null!, CancellationToken cancellationToken = default)
+    {
+        await Task.Delay(duration);
+        return await message.GetCallback<IComputingCallback>().GetThreadName();
+    }
+
+    public async Task<ComplexNumber> AddComplexNumberList(IReadOnlyList<ComplexNumber> numbers)
+    {
+        var result = ComplexNumber.Zero;
+        foreach (var number in numbers)
+        {
+            result += number;
+        }
+        return result;
+    }
+
+    public async Task<int> MultiplyInts(int x, int y, Message message = null!)
+    {
+        var callback = message.GetCallback<IComputingCallback>();
+
+        var result = 0;
+        for (int i = 0; i < y; i++)
+        {
+            result = await callback.AddInts(result, x);
+        }
+
+        return result;
+    }
+}

src/UiPath.Ipc.Tests/Services/ComputingService.cs

@@ -1,13 +1,39 @@
-namespace UiPath.Ipc.Tests;
+
+namespace UiPath.Ipc.Tests;
 
-public interface IComputingServiceBase
+public interface IComputingService
 {
+    Task<float> AddFloats(float x, float y, CancellationToken ct = default);
+    Task<ComplexNumber> AddComplexNumbers(ComplexNumber a, ComplexNumber b);
+    Task<bool> Wait(TimeSpan duration, CancellationToken ct = default);
+    Task<string> GetCallbackThreadName(TimeSpan duration, Message message = null!, CancellationToken cancellationToken = default);
+    Task<ComplexNumber> AddComplexNumberList(IReadOnlyList<ComplexNumber> numbers);
+    Task<int> MultiplyInts(int x, int y, Message message = null!);
 }
 
-public interface IComputingService : IComputingServiceBase
+public interface IComputingCallback
 {
+    Task<string> GetThreadName();
+    Task<int> AddInts(int x, int y);
 }
 
-public interface IComputingCallback
+public interface IArithmeticCallback
 {
+    Task<int> Increment(int x);
 }
+
+public readonly record struct ComplexNumber
+{
+    public static readonly ComplexNumber Zero = default;
+    public static ComplexNumber operator +(ComplexNumber a, ComplexNumber b)
+    => new()
+    {
+        I = a.I + b.I,
+        J = a.J + b.J
+    };
+
+    public required float I { get; init; }
+    public required float J { get; init; }
+
+    public override string ToString() => $"[{I}, {J}]";
+}