chore(test): migrate from xunit v2 to xunit.v3 (#75)

- Migrated test project from xunit v2 to xunit.v3 (2.0.2)
- Update async tests for improved cancellation support
- Updated usage of fixture (MicrocksAsyncFeatureFixture) for xunit.v3 compatibility

Signed-off-by: SebastienDegodez <sebastien.degodez@gmail.com>

Author: SebastienDegodez

tests/Microcks.Testcontainers.Tests/Async/Amqp/MicrocksAsyncAmqpFeatureTest.cs

@@ -5,7 +5,7 @@
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
-//  http://www.apache.org/licenses/LICENSE-2.0 
+//  http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
@@ -32,7 +32,7 @@ public class MicrocksAsyncAmqpFeatureTest : IAsyncLifetime
     private MicrocksContainerEnsemble _ensemble;
     private INetwork _network;
 
-    public async Task InitializeAsync()
+    public async ValueTask InitializeAsync()
     {
         _network = new NetworkBuilder().Build();
         _rabbitMqContainer = new RabbitMqBuilder()
@@ -53,14 +53,15 @@ await _rabbitMqContainer.StartAsync()
         await _ensemble.StartAsync();
     }
 
-    public async Task DisposeAsync()
+    public async ValueTask DisposeAsync()
     {
         if (_ensemble != null)
             await _ensemble.DisposeAsync();
         if (_rabbitMqContainer != null)
             await _rabbitMqContainer.DisposeAsync();
         if (_network != null)
             await _network.DisposeAsync();
+        GC.SuppressFinalize(this);
     }
 
     [Fact]
@@ -79,28 +80,28 @@ public async Task ShouldReceiveAmqpMockMessageWhenMicrocksAsyncMinonEmits()
         };
 
         string receivedMessage = null;
-        using var connection = await factory.CreateConnectionAsync();
-        using var channel = await connection.CreateChannelAsync();
+        await using var connection = await factory.CreateConnectionAsync(cancellationToken: TestContext.Current.CancellationToken);
+        await using var channel = await connection.CreateChannelAsync(cancellationToken: TestContext.Current.CancellationToken);
 
-        await channel.ExchangeDeclareAsync(amqpDestination, "topic", false);
-        var queueDeclareResult = await channel.QueueDeclareAsync();
+        await channel.ExchangeDeclareAsync(amqpDestination, "topic", false, cancellationToken: TestContext.Current.CancellationToken);
+        var queueDeclareResult = await channel.QueueDeclareAsync(cancellationToken: TestContext.Current.CancellationToken);
         var queueName = queueDeclareResult.QueueName;
-        await channel.QueueBindAsync(queueName, amqpDestination, "#");
+        await channel.QueueBindAsync(queueName, amqpDestination, "#", cancellationToken: TestContext.Current.CancellationToken);
 
         var consumer = new AsyncEventingBasicConsumer(channel);
         var messageReceived = new ManualResetEventSlim(false);
 
         consumer.ReceivedAsync += async (model, ea) =>
         {
             receivedMessage = System.Text.Encoding.UTF8.GetString(ea.Body.ToArray());
-            await channel.BasicAckAsync(ea.DeliveryTag, false);
+            await channel.BasicAckAsync(ea.DeliveryTag, false, cancellationToken: TestContext.Current.CancellationToken);
             messageReceived.Set();
         };
 
-        await channel.BasicConsumeAsync(queue: queueName, autoAck: false, consumer: consumer);
+        await channel.BasicConsumeAsync(queue: queueName, autoAck: false, consumer: consumer, cancellationToken: TestContext.Current.CancellationToken);
 
         // Attendre le message (timeout 5s)
-        messageReceived.Wait(TimeSpan.FromSeconds(5));
+        messageReceived.Wait(TimeSpan.FromSeconds(5), TestContext.Current.CancellationToken);
 
         Assert.NotNull(receivedMessage);
         Assert.True(receivedMessage.Length > 1);

tests/Microcks.Testcontainers.Tests/Async/Kafka/MicrocksAsyncKafkaFunctionalityTest.cs

@@ -16,7 +16,6 @@
 //
 
 using System;
-using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
 using Confluent.Kafka;
@@ -40,13 +39,13 @@ public sealed class MicrocksAsyncKafkaFunctionalityTest : IAsyncLifetime
 
     private KafkaContainer _kafkaContainer;
 
-    public async Task DisposeAsync()
+    public async ValueTask DisposeAsync()
     {
         await this._microcksContainerEnsemble.DisposeAsync();
         await this._kafkaContainer.DisposeAsync();
     }
 
-    public async Task InitializeAsync()
+    public async ValueTask InitializeAsync()
     {
         var network = new NetworkBuilder().Build();
 
@@ -150,7 +149,7 @@ public async Task ShouldReturnsCorrectStatusContractWhenGoodMessageIsEmitted()
             .MicrocksContainer
             .TestEndpointAsync(testRequest);
 
-        await Task.Delay(750);
+        await Task.Delay(750, TestContext.Current.CancellationToken);
 
         // Act
         for (var i = 0; i < 5; i++)
@@ -160,8 +159,8 @@ public async Task ShouldReturnsCorrectStatusContractWhenGoodMessageIsEmitted()
                 Key = Guid.NewGuid().ToString(),
                 Value = message
             });
-            producer.Flush();
-            await Task.Delay(500);
+            producer.Flush(TestContext.Current.CancellationToken);
+            await Task.Delay(500, TestContext.Current.CancellationToken);
         }
 
         // Wait for a test result
@@ -219,7 +218,7 @@ public async Task ShouldReturnsCorrectStatusContractWhenBadMessageIsEmitted()
         var taskTestResult = this._microcksContainerEnsemble
             .MicrocksContainer
             .TestEndpointAsync(testRequest);
-        await Task.Delay(750);
+        await Task.Delay(750, TestContext.Current.CancellationToken);
 
         // Act
         for (var i = 0; i < 5; i++)
@@ -229,8 +228,8 @@ public async Task ShouldReturnsCorrectStatusContractWhenBadMessageIsEmitted()
                 Key = Guid.NewGuid().ToString(),
                 Value = message
             });
-            producer.Flush();
-            await Task.Delay(500);
+            producer.Flush(TestContext.Current.CancellationToken);
+            await Task.Delay(500, TestContext.Current.CancellationToken);
         }
 
         // Wait for a test result

tests/Microcks.Testcontainers.Tests/Async/MicrocksAsyncFeatureFixture.cs

@@ -0,0 +1,89 @@
+//
+// Copyright The Microcks Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License")
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//  http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
+
+using System;
+using DotNet.Testcontainers;
+using DotNet.Testcontainers.Builders;
+using DotNet.Testcontainers.Containers;
+
+namespace Microcks.Testcontainers.Tests.Async;
+
+[CollectionDefinition(nameof(MicrocksAsyncFeatureCollection))]
+public class MicrocksAsyncFeatureCollection : ICollectionFixture<MicrocksAsyncFeatureFixture> { }
+
+/// <summary>
+/// Fixture for Microcks Async Feature tests.
+/// </summary>
+public class MicrocksAsyncFeatureFixture : IAsyncLifetime
+{
+    /// <summary>
+    /// Image name for the Microcks container.
+    /// </summary>
+    private const string MicrocksImage = "quay.io/microcks/microcks-uber:1.10.1-native";
+
+    private const string BadPastryAsyncImage = "quay.io/microcks/contract-testing-demo-async:01";
+    private const string GoodPastryAsyncImage = "quay.io/microcks/contract-testing-demo-async:02";
+
+    public MicrocksContainerEnsemble MicrocksContainerEnsemble { get; private set; }
+    private IContainer WsGoodImplContainer { get; set; }
+    private IContainer WsBadImplContainer { get; set; }
+
+
+    public async ValueTask DisposeAsync()
+    {
+        await this.MicrocksContainerEnsemble.DisposeAsync();
+        await this.WsBadImplContainer.DisposeAsync();
+        await this.WsGoodImplContainer.DisposeAsync();
+        GC.SuppressFinalize(this);
+    }
+
+    public async ValueTask InitializeAsync()
+    {
+        ConsoleLogger.Instance.DebugLogLevelEnabled = true;
+
+        this.MicrocksContainerEnsemble = new MicrocksContainerEnsemble(MicrocksImage)
+            .WithMainArtifacts("pastry-orders-asyncapi.yml")
+            .WithAsyncFeature();
+
+        this.WsBadImplContainer = new ContainerBuilder()
+            .WithImage(BadPastryAsyncImage)
+            .WithNetwork(this.MicrocksContainerEnsemble.Network)
+            .WithNetworkAliases("bad-impl")
+            .WithExposedPort(4001)
+            .WithWaitStrategy(
+                Wait.ForUnixContainer()
+                    .UntilMessageIsLogged(".*Starting WebSocket server on ws://localhost:4001/websocket.*")
+            )
+            .Build();
+
+        this.WsGoodImplContainer = new ContainerBuilder()
+            .WithImage(GoodPastryAsyncImage)
+            .WithNetwork(this.MicrocksContainerEnsemble.Network)
+            .WithNetworkAliases("good-impl")
+            .WithExposedPort(4002)
+            .WithWaitStrategy(
+                Wait.ForUnixContainer()
+                    .UntilMessageIsLogged(".*Starting WebSocket server on ws://localhost:4002/websocket.*")
+            )
+            .Build();
+
+        await this.MicrocksContainerEnsemble.StartAsync();
+        await this.WsBadImplContainer.StartAsync();
+        await this.WsGoodImplContainer.StartAsync();
+    }
+
+}

tests/Microcks.Testcontainers.Tests/Async/MicrocksAsyncFeatureTest.cs

@@ -21,76 +21,26 @@
 using System.Net.WebSockets;
 using System.Text;
 using System.Threading;
-using DotNet.Testcontainers;
-using DotNet.Testcontainers.Builders;
-using DotNet.Testcontainers.Containers;
 using Microcks.Testcontainers.Model;
 using Microsoft.Extensions.Logging;
 
 namespace Microcks.Testcontainers.Tests.Async;
 
-[Collection(nameof(WsCollection))]
-public sealed class MicrocksAsyncFeatureTest : IAsyncLifetime
+[Collection(nameof(MicrocksAsyncFeatureCollection))]
+public sealed class MicrocksAsyncFeatureTest
 {
-    /// <summary>
-    /// Image name for the Microcks container.
-    /// </summary>
-    private const string MicrocksImage = "quay.io/microcks/microcks-uber:1.10.1-native";
-
-    private const string BadPastryAsyncImage = "quay.io/microcks/contract-testing-demo-async:01";
-    private const string GoodPastryAsyncImage = "quay.io/microcks/contract-testing-demo-async:02";
-
-    private MicrocksContainerEnsemble _microcksContainerEnsemble;
-    private IContainer _wsGoodImplContainer;
-    private IContainer _wsBadImplContainer;
+    private readonly MicrocksAsyncFeatureFixture fixture;
 
-    public async Task DisposeAsync()
+    public MicrocksAsyncFeatureTest(MicrocksAsyncFeatureFixture fixture)
     {
-        await this._microcksContainerEnsemble.DisposeAsync();
-        await this._wsBadImplContainer.DisposeAsync();
-        await this._wsGoodImplContainer.DisposeAsync();
-    }
-
-    public async Task InitializeAsync()
-    {
-        ConsoleLogger.Instance.DebugLogLevelEnabled = true;
-
-        this._microcksContainerEnsemble = new MicrocksContainerEnsemble(MicrocksImage)
-            .WithMainArtifacts("pastry-orders-asyncapi.yml")
-            .WithAsyncFeature();
-
-        this._wsBadImplContainer = new ContainerBuilder()
-            .WithImage(BadPastryAsyncImage)
-            .WithNetwork(this._microcksContainerEnsemble.Network)
-            .WithNetworkAliases("bad-impl")
-            .WithExposedPort(4001)
-            .WithWaitStrategy(
-                Wait.ForUnixContainer()
-                    .UntilMessageIsLogged(".*Starting WebSocket server on ws://localhost:4001/websocket.*")
-            )
-            .Build();
-
-        this._wsGoodImplContainer = new ContainerBuilder()
-            .WithImage(GoodPastryAsyncImage)
-            .WithNetwork(this._microcksContainerEnsemble.Network)
-            .WithNetworkAliases("good-impl")
-            .WithExposedPort(4002)
-            .WithWaitStrategy(
-                Wait.ForUnixContainer()
-                    .UntilMessageIsLogged(".*Starting WebSocket server on ws://localhost:4002/websocket.*")
-            )
-            .Build();
-
-        await this._microcksContainerEnsemble.StartAsync();
-        await this._wsBadImplContainer.StartAsync();
-        await this._wsGoodImplContainer.StartAsync();
+        this.fixture = fixture;
     }
 
     [Fact]
     public void ShouldDetermineCorrectImageMessage()
     {
         Assert.Equal("quay.io/microcks/microcks-uber-async-minion:1.10.1",
-            this._microcksContainerEnsemble.AsyncMinionContainer.Image.FullName);
+            this.fixture.MicrocksContainerEnsemble.AsyncMinionContainer.Image.FullName);
     }
 
     /// <summary>
@@ -101,7 +51,8 @@ public void ShouldDetermineCorrectImageMessage()
     public async Task ShouldReceivedWebSocketMessageWhenMessageIsEmitted()
     {
         // Get the WebSocket endpoint for the "Pastry orders API" with version "0.1.0" and subscription "SUBSCRIBE pastry/orders".
-        var webSocketEndpoint = _microcksContainerEnsemble
+        var webSocketEndpoint = fixture
+            .MicrocksContainerEnsemble
             .AsyncMinionContainer
             .GetWebSocketMockEndpoint("Pastry orders API", "0.1.0", "SUBSCRIBE pastry/orders");
         const string expectedMessage = "{\"id\":\"4dab240d-7847-4e25-8ef3-1530687650c8\",\"customerId\":\"fe1088b3-9f30-4dc1-a93d-7b74f0a072b9\",\"status\":\"VALIDATED\",\"productQuantities\":[{\"quantity\":2,\"pastryName\":\"Croissant\"},{\"quantity\":1,\"pastryName\":\"Millefeuille\"}]}";
@@ -139,15 +90,15 @@ public async Task ShouldReturnsCorrectStatusContractWhenBadMessageIsEmitted()
             TestEndpoint = "ws://bad-impl:4001/websocket",
         };
 
-        var taskTestResult = _microcksContainerEnsemble.MicrocksContainer
+        var taskTestResult = fixture.MicrocksContainerEnsemble.MicrocksContainer
             .TestEndpointAsync(testRequest);
 
         stopwatch.Start();
         var testResult = await taskTestResult;
         stopwatch.Stop();
 
         // Add logging to trace the test result
-        var logger = _microcksContainerEnsemble
+        var logger = fixture.MicrocksContainerEnsemble
                         .MicrocksContainer
                         .Logger;
 
@@ -184,7 +135,7 @@ public async Task ShouldReturnsCorrectStatusContractWhenGoodMessageIsEmitted()
             TestEndpoint = "ws://good-impl:4002/websocket",
         };
 
-        var taskTestResult = _microcksContainerEnsemble.MicrocksContainer
+        var taskTestResult = fixture.MicrocksContainerEnsemble.MicrocksContainer
             .TestEndpointAsync(testRequest);
 
         var testResult = await taskTestResult;
@@ -197,4 +148,35 @@ public async Task ShouldReturnsCorrectStatusContractWhenGoodMessageIsEmitted()
         Assert.NotEmpty(testResult.TestCaseResults.First().TestStepResults);
         Assert.True(string.IsNullOrEmpty(testResult.TestCaseResults.First().TestStepResults.First().Message));
     }
+
+        /// <summary>
+    /// Test that verifies that the WaitForConditionAsync method throws a TaskCanceledException
+    /// when the specified timeout is reached.
+    /// </summary>
+    [Fact]
+    public async Task WaitForConditionAsyncShouldThrowTaskCanceledExceptionWhenTimeoutIsReached()
+    {
+        // New Test request
+        var testRequest = new TestRequest
+        {
+            ServiceId = "Pastry orders API:0.1.0",
+            RunnerType = TestRunnerType.ASYNC_API_SCHEMA,
+            Timeout = TimeSpan.FromMilliseconds(200),
+            TestEndpoint = "ws://good-impl:4002/websocket",
+        };
+
+        var taskTestResult = fixture.MicrocksContainerEnsemble.MicrocksContainer
+            .TestEndpointAsync(testRequest);
+
+        var stopwatch = new Stopwatch();
+        stopwatch.Start();
+        var testResult = await taskTestResult;
+        stopwatch.Stop();
+
+        // Assert
+        Assert.True(stopwatch.ElapsedMilliseconds > 200);
+        Assert.True(testResult.InProgress);
+        Assert.False(testResult.Success);
+        Assert.Equal(testRequest.TestEndpoint, testResult.TestedEndpoint);
+    }
 }