[fix] Enable easy DEBUG log level for Microcks containers (#196)

* Enable easy DEBUG log level for Microcks containers

Add WithDebugLogLevel() methods to MicrocksBuilder, MicrocksAsyncMinionBuilder, and MicrocksContainerEnsemble to set appropriate environment variables for DEBUG logging. Update README with usage examples. This simplifies troubleshooting by allowing users to enable detailed logs in both main and async minion containers, following Microcks documentation.

Fixes #191

Signed-off-by: Santhosh Reddy Vootukuri (SUNNY) <nagavo@microsoft.com>

* Centralize logging env vars in ConfigurationConstants

Move all logging-related environment variable constants to a new ConfigurationConstants class for better maintainability. Update all usages in builder and ensemble classes to reference the centralized constants. Ensure builder methods are chainable and update builder state as expected. Add copyright and license header to the new file.

sign off by: nagavo

Signed-off-by: Santhosh Reddy Vootukuri (SUNNY) <nagavo@microsoft.com>

* Rename DebugLogLevel to DebugLogLevelEnvVar constant

Clarifies that the "DEBUG" value is for environment variables by renaming DebugLogLevel to DebugLogLevelEnvVar in ConfigurationConstants. Updates all usages in MicrocksAsyncMinionBuilder and MicrocksBuilder for improved code clarity.

Signed-off-by: Santhosh Reddy Vootukuri<vns_smart5@hotmail.com>
Signed-off-by: Santhosh Reddy Vootukuri (SUNNY) <nagavo@microsoft.com>

* Update README: streamline debug logging instructions

Revised the README to remove the old, detailed section on enabling DEBUG logs in Microcks containers. Added a new, concise "Troubleshooting" section with updated code examples for enabling debug logs on both single containers and ensembles using .WithDebugLogLevel(). This improves clarity and makes troubleshooting steps easier to follow.

Signed-off-by: Santhosh Reddy Vootukuri (SUNNY) <nagavo@microsoft.com>

* Refactor ConfigurationConstants class structure and cleanup

Flatten ConfigurationConstants by removing inner class structure and unnecessary using directives. Preserve and reformat XML documentation comments for clarity.

Signed-off-by: Santhosh Reddy Vootukuri (SUNNY) <nagavo@microsoft.com>

* test(DebugLogLevel): add tests for WithDebugLogLevel feature

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

---------

Signed-off-by: Santhosh Reddy Vootukuri (SUNNY) <nagavo@microsoft.com>
Signed-off-by: Santhosh Reddy Vootukuri<vns_smart5@hotmail.com>
Signed-off-by: SebastienDegodez <sebastien.degodez@gmail.com>
Co-authored-by: Santhosh Reddy Vootukuri (SUNNY) <nagavo@microsoft.com>
Co-authored-by: SebastienDegodez <sebastien.degodez@gmail.com>

Author: 3 people

README.md

@@ -221,6 +221,7 @@ await TestcontainersSettings.ExposeHostPortsAsync(ports)
     .ConfigureAwait(false);
 ```
 
+
 ### Advanced features with MicrocksContainersEnsemble
 
 The `MicrocksContainer` referenced above supports essential features of Microcks provided by the main Microcks container.
@@ -353,3 +354,18 @@ testResult.IsSuccess.Should().BeTrue();
 ```
 
 In addition, you can use the `GetEventMessagesForTestCaseAsync()` method to retrieve the events received during the test.
+
+#### Troubleshooting
+
+You can enable debug logs on the Microcks container by setting the debug log level and then retrieving the logs:
+
+```csharp
+MicrocksContainer container = new MicrocksBuilder()
+    .WithImage("quay.io/microcks/microcks-uber:1.13.0")
+    .WithDebugLogLevel()
+    .Build();
+await container.StartAsync();
+```
+
+The same .withDebugLogLevel() method is available on also MicrocksContainersEnsemble for enabling debug logs on all contained Microcks containers.
+```

src/Microcks.Testcontainers/Helpers/ConfigurationConstants.cs

@@ -0,0 +1,44 @@
+//
+// 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.
+//
+//
+
+namespace Microcks.Testcontainers.Helpers;
+
+/// <summary>
+/// Configuration constants for Microcks Testcontainers.
+/// </summary>
+public class ConfigurationConstants
+{
+    /// <summary>
+    /// Environment variable name used to configure Microcks logging level for the Microcks package.
+    /// </summary>
+    public const string MicrocksLoggingLevelEnvVar = "LOGGING_LEVEL_IO_GITHUB_MICROCKS";
+
+    /// <summary>
+    /// Environment variable value for enabling DEBUG logging.
+    /// </summary>
+    public const string DebugLogLevelEnvVar = "DEBUG";
+
+    /// <summary>
+    /// Environment variable name used by Quarkus to configure console log level.
+    /// </summary>
+    public const string QuarkusConsoleLogLevelEnvVar = "QUARKUS_LOG_CONSOLE_LEVEL";
+
+    /// <summary>
+    /// Environment variable name used by Quarkus to configure the Microcks category log level.
+    /// </summary>
+    public const string QuarkusMicrocksCategoryLogLevelEnvVar = "QUARKUS_LOG_CATEGORY__IO_GITHUB_MICROCKS__LEVEL";
+}

src/Microcks.Testcontainers/MicrocksAsyncMinionBuilder.cs

@@ -18,6 +18,7 @@
 
 using DotNet.Testcontainers.Networks;
 using Microcks.Testcontainers.Connection;
+using Microcks.Testcontainers.Helpers;
 
 namespace Microcks.Testcontainers;
 
@@ -133,4 +134,19 @@ public MicrocksAsyncMinionBuilder WithAmqpConnection(GenericConnection amqpConne
 
         return Merge(DockerResourceConfiguration, new MicrocksAsyncMinionConfiguration(new ContainerConfiguration(environments: environments)));
     }
+
+
+    /// <summary>
+    /// Enables DEBUG log level for Microcks async minion components inside the container.
+    /// </summary>
+    /// <remarks>
+    /// This follows Microcks documentation for the Quarkus-based async-minion image.
+    /// It must be called before <see cref="Build"/> / container start.
+    /// </remarks>
+    public MicrocksAsyncMinionBuilder WithDebugLogLevel()
+    {
+        return this
+            .WithEnvironment(ConfigurationConstants.QuarkusConsoleLogLevelEnvVar, ConfigurationConstants.DebugLogLevelEnvVar)
+            .WithEnvironment(ConfigurationConstants.QuarkusMicrocksCategoryLogLevelEnvVar, ConfigurationConstants.DebugLogLevelEnvVar);
+    }
 }

src/Microcks.Testcontainers/MicrocksBuilder.cs

@@ -268,4 +268,12 @@ public MicrocksBuilder WithSecrets(params Model.Secret[] secrets)
 
         return this;
     }
+
+    /// <summary>
+    /// Enables DEBUG log level for Microcks components inside the container.
+    /// </summary>
+    public MicrocksBuilder WithDebugLogLevel()
+    {
+        return this.WithEnvironment(ConfigurationConstants.MicrocksLoggingLevelEnvVar, ConfigurationConstants.DebugLogLevelEnvVar);
+    }
 }

src/Microcks.Testcontainers/MicrocksContainerEnsemble.cs

@@ -29,11 +29,13 @@ namespace Microcks.Testcontainers;
 /// </summary>
 public class MicrocksContainerEnsemble : IAsyncDisposable, IArtifactAndSnapshotManager<MicrocksContainerEnsemble>
 {
-    private readonly MicrocksBuilder _microcksBuilder;
+    private MicrocksBuilder _microcksBuilder;
 
     private ContainerBuilder _postmanBuilder;
     private MicrocksAsyncMinionBuilder _asyncMinionBuilder;
 
+    private bool _debugLogLevelEnabled;
+
     /// <summary>
     /// Gets the Postman runtime container.
     /// </summary>
@@ -186,6 +188,11 @@ public MicrocksContainerEnsemble WithAsyncFeature()
             .WithEnvironment(MacOSHelper.GetJavaOptions())
             .WithImage(image);
 
+        if (this._debugLogLevelEnabled)
+        {
+            this._asyncMinionBuilder = this._asyncMinionBuilder.WithDebugLogLevel();
+        }
+
         return this;
     }
 
@@ -221,6 +228,24 @@ public MicrocksContainerEnsemble WithAmqpConnection(GenericConnection amqpConnec
         return this;
     }
 
+    /// <summary>
+    /// Enables DEBUG log level for the containers of this ensemble.
+    /// </summary>
+    /// <remarks>
+    /// Applies to the main Microcks container (Spring) and, when the async feature is enabled,
+    /// to the async-minion container (Quarkus).
+    /// </remarks>
+    public MicrocksContainerEnsemble WithDebugLogLevel()
+    {
+        this._debugLogLevelEnabled = true;
+        this._microcksBuilder = this._microcksBuilder.WithDebugLogLevel();
+
+        // If async feature has already been enabled, apply immediately.
+        this._asyncMinionBuilder = this._asyncMinionBuilder?.WithDebugLogLevel();
+
+        return this;
+    }
+
     /// <summary>
     /// Starts the Microcks container ensemble asynchronously.
     /// </summary>

tests/Microcks.Testcontainers.Tests/DebugLogLevel/MicrocksDebugLogLevelTests.cs

@@ -0,0 +1,105 @@
+//
+// 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 Microcks.Testcontainers.Helpers;
+
+namespace Microcks.Testcontainers.Tests.DebugLogLevel;
+
+/// <summary>
+/// Tests for the WithDebugLogLevel feature on MicrocksContainerEnsemble.
+/// Verifies that debug logging environment variables are correctly set or not set
+/// on both Microcks (Spring) and Async Minion (Quarkus) containers.
+/// </summary>
+[Collection("DisableParallelization")]
+public sealed class MicrocksDebugLogLevelTests
+{
+    /// <summary>
+    /// Verifies that when WithDebugLogLevel() is called, the appropriate debug
+    /// environment variables are set on both Microcks and Async Minion containers.
+    /// - Microcks (Spring): LOGGING_LEVEL_IO_GITHUB_MICROCKS=DEBUG
+    /// - Async Minion (Quarkus): QUARKUS_LOG_CONSOLE_LEVEL=DEBUG and 
+    ///   QUARKUS_LOG_CATEGORY__IO_GITHUB_MICROCKS__LEVEL=DEBUG
+    /// </summary>
+    [Fact]
+    public async Task WithDebugLogLevel_ShouldSetEnvironmentVariables()
+    {
+        // Arrange - Create ensemble WITH WithDebugLogLevel()
+        await using var ensemble = new MicrocksContainerEnsemble(MicrocksBuilder.MicrocksImage)
+            .WithDebugLogLevel()
+            .WithAsyncFeature();
+
+        await ensemble.StartAsync(TestContext.Current.CancellationToken);
+
+        // Assert - Use Docker Inspect API to verify environment variables
+        using var dockerClient = new Docker.DotNet.DockerClientConfiguration().CreateClient();
+
+        // Verify Microcks container has the debug environment variable
+        var microcksInspect = await dockerClient.Containers.InspectContainerAsync(
+            ensemble.MicrocksContainer.Id,
+            TestContext.Current.CancellationToken);
+
+        var expectedMicrocksEnvVar = $"{ConfigurationConstants.MicrocksLoggingLevelEnvVar}={ConfigurationConstants.DebugLogLevelEnvVar}";
+        Assert.Contains(expectedMicrocksEnvVar, microcksInspect.Config.Env);
+
+        // Verify Async Minion container has the Quarkus debug environment variables
+        var minionInspect = await dockerClient.Containers.InspectContainerAsync(
+            ensemble.AsyncMinionContainer.Id,
+            TestContext.Current.CancellationToken);
+
+        var expectedConsoleLogLevel = $"{ConfigurationConstants.QuarkusConsoleLogLevelEnvVar}={ConfigurationConstants.DebugLogLevelEnvVar}";
+        var expectedMicrocksLogLevel = $"{ConfigurationConstants.QuarkusMicrocksCategoryLogLevelEnvVar}={ConfigurationConstants.DebugLogLevelEnvVar}";
+
+        Assert.Contains(expectedConsoleLogLevel, minionInspect.Config.Env);
+        Assert.Contains(expectedMicrocksLogLevel, minionInspect.Config.Env);
+    }
+
+    /// <summary>
+    /// Verifies that when WithDebugLogLevel() is NOT called, the debug environment
+    /// variables are not present on the containers. This ensures the default behavior
+    /// does not enable debug logging.
+    /// </summary>
+    [Fact]
+    public async Task WithoutDebugLogLevel_ShouldNotSetEnvironmentVariables()
+    {
+        // Arrange - Create ensemble WITHOUT WithDebugLogLevel()
+        await using var ensemble = new MicrocksContainerEnsemble(MicrocksBuilder.MicrocksImage)
+            .WithAsyncFeature();
+
+        await ensemble.StartAsync(TestContext.Current.CancellationToken);
+
+        // Assert - Use Docker Inspect API to verify environment variables are NOT set
+        using var dockerClient = new Docker.DotNet.DockerClientConfiguration().CreateClient();
+
+        // Verify Microcks container does NOT have the debug environment variable
+        var microcksInspect = await dockerClient.Containers.InspectContainerAsync(
+            ensemble.MicrocksContainer.Id,
+            TestContext.Current.CancellationToken);
+
+        Assert.DoesNotContain(microcksInspect.Config.Env,
+            env => env.StartsWith($"{ConfigurationConstants.MicrocksLoggingLevelEnvVar}="));
+
+        // Verify Async Minion container does NOT have the Quarkus debug environment variables
+        var minionInspect = await dockerClient.Containers.InspectContainerAsync(
+            ensemble.AsyncMinionContainer.Id,
+            TestContext.Current.CancellationToken);
+
+        Assert.DoesNotContain(minionInspect.Config.Env,
+            env => env.StartsWith($"{ConfigurationConstants.QuarkusConsoleLogLevelEnvVar}="));
+        Assert.DoesNotContain(minionInspect.Config.Env,
+            env => env.StartsWith($"{ConfigurationConstants.QuarkusMicrocksCategoryLogLevelEnvVar}="));
+    }
+}

tests/Microcks.Testcontainers.Tests/DisableParallelizationCollection.cs

@@ -0,0 +1,28 @@
+//
+// 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.
+//
+//
+
+namespace Microcks.Testcontainers.Tests;
+
+/// <summary>
+/// Collection definition that disables parallel execution for tests.
+/// This prevents issues on GitHub Actions agents with limited resources.
+/// Use [Collection("DisableParallelization")] on test classes that should not run in parallel.
+/// </summary>
+[CollectionDefinition("DisableParallelization", DisableParallelization = true)]
+public class DisableParallelizationCollection
+{
+}