gh-20 Integration test for MinIO

gh-25 Change APIs for Verify..

Signed-off-by: Victor Chang <vicchang@nvidia.com>

Author: mocsharp

.github/workflows/ci.yml

@@ -134,10 +134,11 @@ jobs:
         run: dotnet build -c ${{ env.BUILD_CONFIG }} --nologo "${{ env.SOLUTION }}"
         working-directory: ./src
 
+      - name: Start docker-compose
+        run: docker compose up -d --wait
+        working-directory: ./src/Plugins/MinIO/Tests
+
       - name: Test
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
         run: find ~+ -type f -name "*.Test.csproj" | xargs -L1 dotnet test -c ${{ env.BUILD_CONFIG }} -v=minimal -r "${{ env.TEST_RESULTS }}" --collect:"XPlat Code Coverage" --settings coverlet.runsettings
         working-directory: ./src
 
@@ -158,6 +159,14 @@ jobs:
           fail_ci_if_error: true
           verbose: true
 
+      - name: Stop docker-compose
+        run: |
+          docker compose down
+          docker volume rm tests_minio_data
+          docker volume rm tests_minio_config
+        working-directory: ./src/Plugins/MinIO/Tests
+
+
   build:
     runs-on: ${{ matrix.os }}
 

src/Plugins/AWSS3/AWS3StorageService.cs

@@ -40,10 +40,11 @@ public class StorageAdminService : IStorageAdminService
         private readonly string _get_connections_cmd;
         private readonly string _get_users_cmd;
 
-        public StorageAdminService(IOptions<StorageServiceConfiguration> options, ILogger<MinIoStorageService> logger, IFileSystem fileSystem)
+        public StorageAdminService(IOptions<StorageServiceConfiguration> options, ILogger<StorageAdminService> logger, IFileSystem fileSystem)
         {
-            Guard.Against.Null(options, nameof(options));
-            Guard.Against.Null(logger, nameof(logger));
+            Guard.Against.Null(options);
+            Guard.Against.Null(logger);
+
             _fileSystem = fileSystem ?? throw new ArgumentNullException(nameof(fileSystem));
 
             var configuration = options.Value;
@@ -62,7 +63,7 @@ public StorageAdminService(IOptions<StorageServiceConfiguration> options, ILogge
 
         private static void ValidateConfiguration(StorageServiceConfiguration configuration)
         {
-            Guard.Against.Null(configuration, nameof(configuration));
+            Guard.Against.Null(configuration);
 
             foreach (var key in ConfigurationKeys.McRequiredKeys)
             {
@@ -75,17 +76,17 @@ private static void ValidateConfiguration(StorageServiceConfiguration configurat
 
         private string CreateUserCmd(string username, string secretKey)
         {
-            Guard.Against.NullOrWhiteSpace(username, nameof(username));
-            Guard.Against.NullOrWhiteSpace(secretKey, nameof(secretKey));
+            Guard.Against.NullOrWhiteSpace(username);
+            Guard.Against.NullOrWhiteSpace(secretKey);
 
             return $"admin user add {_serviceName} {username} {secretKey}";
         }
 
         public async Task<bool> SetPolicyAsync(IdentityType policyType, List<string> policies, string itemName)
         {
-            Guard.Against.Null(policyType, nameof(policyType));
-            Guard.Against.Null(policies, nameof(policies));
-            Guard.Against.NullOrWhiteSpace(itemName, nameof(itemName));
+            Guard.Against.Null(policyType);
+            Guard.Against.Null(policies);
+            Guard.Against.NullOrWhiteSpace(itemName);
 
             var policiesStr = string.Join(',', policies);
             var setPolicyCmd = $"admin policy set {_serviceName} {policiesStr} {policyType.ToString().ToLower()}={itemName}";
@@ -101,7 +102,7 @@ public async Task<bool> SetPolicyAsync(IdentityType policyType, List<string> pol
 
         private async Task<List<string>> ExecuteAsync(string cmd)
         {
-            Guard.Against.NullOrWhiteSpace(cmd, nameof(cmd));
+            Guard.Against.NullOrWhiteSpace(cmd);
 
             if (cmd.StartsWith("mc"))
             {
@@ -122,7 +123,7 @@ private async Task<List<string>> ExecuteAsync(string cmd)
 
         private static async Task<(List<string> Output, List<string> Errors)> RunProcessAsync(Process process)
         {
-            Guard.Against.Null(process, nameof(process));
+            Guard.Against.Null(process);
 
             var output = new List<string>();
             var errors = new List<string>();
@@ -146,7 +147,7 @@ private async Task<List<string>> ExecuteAsync(string cmd)
 
         private Process CreateProcess(string cmd)
         {
-            Guard.Against.NullOrWhiteSpace(cmd, nameof(cmd));
+            Guard.Against.NullOrWhiteSpace(cmd);
 
             ProcessStartInfo startinfo = new()
             {
@@ -186,15 +187,15 @@ public async Task<bool> SetConnectionAsync()
 
         public async Task<bool> UserAlreadyExistsAsync(string username)
         {
-            Guard.Against.NullOrWhiteSpace(username, nameof(username));
+            Guard.Against.NullOrWhiteSpace(username);
 
             var result = await ExecuteAsync(_get_users_cmd).ConfigureAwait(false);
             return result.Any(r => r.Contains(username));
         }
 
         public async Task RemoveUserAsync(string username)
         {
-            Guard.Against.NullOrWhiteSpace(username, nameof(username));
+            Guard.Against.NullOrWhiteSpace(username);
 
             var result = await ExecuteAsync($"admin user remove {_serviceName} {username}").ConfigureAwait(false);
 
@@ -204,26 +205,11 @@ public async Task RemoveUserAsync(string username)
             }
         }
 
-        [Obsolete("CreateUserAsync with bucketNames is deprecated, please use CreateUserAsync with an array of PolicyRequest instead.")]
-        public async Task<Credentials> CreateUserAsync(string username, AccessPermissions permissions, string[] bucketNames)
-        {
-            Guard.Against.NullOrWhiteSpace(username, nameof(username));
-            Guard.Against.Null(bucketNames, nameof(bucketNames));
-
-            var policyRequests = new List<PolicyRequest>();
-
-            for (var i = 0; i < bucketNames.Length; i++)
-            {
-                policyRequests.Add(new PolicyRequest(bucketNames[i], "/*"));
-            }
-
-            return await CreateUserAsync(username, policyRequests.ToArray()).ConfigureAwait(false);
-        }
 
         public async Task<Credentials> CreateUserAsync(string username, PolicyRequest[] policyRequests)
         {
-            Guard.Against.NullOrWhiteSpace(username, nameof(username));
-            Guard.Against.Null(policyRequests, nameof(policyRequests));
+            Guard.Against.NullOrWhiteSpace(username);
+            Guard.Against.Null(policyRequests);
 
             if (!await SetConnectionAsync().ConfigureAwait(false))
             {
@@ -270,8 +256,8 @@ public async Task<Credentials> CreateUserAsync(string username, PolicyRequest[]
         /// <exception cref="InvalidOperationException"></exception>
         private async Task<string> CreatePolicyAsync(PolicyRequest[] policyRequests, string username)
         {
-            Guard.Against.Null(policyRequests, nameof(policyRequests));
-            Guard.Against.NullOrWhiteSpace(username, nameof(username));
+            Guard.Against.Null(policyRequests);
+            Guard.Against.NullOrWhiteSpace(username);
 
             var policyFileName = await CreatePolicyFile(policyRequests, username).ConfigureAwait(false);
             var result = await ExecuteAsync($"admin policy add {_serviceName} pol_{username} {policyFileName}").ConfigureAwait(false);
@@ -287,8 +273,8 @@ private async Task<string> CreatePolicyAsync(PolicyRequest[] policyRequests, str
 
         private async Task<string> CreatePolicyFile(PolicyRequest[] policyRequests, string username)
         {
-            Guard.Against.NullOrEmpty(policyRequests, nameof(policyRequests));
-            Guard.Against.NullOrWhiteSpace(username, nameof(username));
+            Guard.Against.NullOrEmpty(policyRequests);
+            Guard.Against.NullOrWhiteSpace(username);
 
             var policy = PolicyExtensions.ToPolicy(policyRequests);
             var jsonPolicy = policy.ToJson();

src/Plugins/MinIO/MinIoStorageService.cs

@@ -0,0 +1,23 @@
+/*
+ * Copyright 2022 MONAI Consortium
+ *
+ * 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 Xunit;
+//Optional
+[assembly: CollectionBehavior(DisableTestParallelization = true)]
+//Optional
+[assembly: TestCaseOrderer("Xunit.Extensions.Ordering.TestCaseOrderer", "Xunit.Extensions.Ordering")]
+//Optional
+[assembly: TestCollectionOrderer("Xunit.Extensions.Ordering.CollectionOrderer", "Xunit.Extensions.Ordering")]

src/Plugins/MinIO/StorageAdminService.cs

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2022 MONAI Consortium
+ *
+ * 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 Microsoft.Extensions.Diagnostics.HealthChecks;
+using Microsoft.Extensions.Logging;
+using Minio;
+using Moq;
+using Xunit;
+using Xunit.Extensions.Ordering;
+
+namespace Monai.Deploy.Storage.MinIO.Tests.Integration
+{
+    [Order(10)]
+    public class MinIoHealthCheckTest
+    {
+        private readonly Mock<IMinIoClientFactory> _minIoClientFactory;
+        private readonly Mock<ILogger<MinIoHealthCheck>> _logger;
+
+        public MinIoHealthCheckTest()
+        {
+            _minIoClientFactory = new Mock<IMinIoClientFactory>();
+            _logger = new Mock<ILogger<MinIoHealthCheck>>();
+        }
+
+        [Fact]
+        public async Task CheckHealthAsync_WhenListBucketSucceeds_ReturnHealthy()
+        {
+            var minioClient = new MinioClient()
+            .WithEndpoint("localhost:9000")
+            .WithCredentials("minioadmin", "minioadmin")
+            .Build();
+
+            _minIoClientFactory.Setup(p => p.GetBucketOperationsClient()).Returns(minioClient);
+            var healthCheck = new MinIoHealthCheck(_minIoClientFactory.Object, _logger.Object);
+            var results = await healthCheck.CheckHealthAsync(new HealthCheckContext()).ConfigureAwait(false);
+
+            Assert.Equal(HealthStatus.Healthy, results.Status);
+            Assert.Null(results.Exception);
+        }
+    }
+}

src/Plugins/MinIO/Tests/AssemblyInfo.cs

@@ -0,0 +1,113 @@
+/*
+ * Copyright 2022 MONAI Consortium
+ *
+ * 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 Microsoft.Extensions.Options;
+using Minio;
+using Monai.Deploy.Storage.Configuration;
+using Xunit;
+
+namespace Monai.Deploy.Storage.MinIO.Tests.Integration
+{
+    [CollectionDefinition("MinIoStorage")]
+    public class MinIoStorageCollection : ICollectionFixture<MinIoStorageFixture>
+    {
+        // This class has no code, and is never created. Its purpose is simply
+        // to be the place to apply [CollectionDefinition] and all the
+        // ICollectionFixture<> interfaces.
+    }
+
+    public class MinIoStorageFixture : IAsyncDisposable
+    {
+        const int MaxFileSize = 104857600;
+        private readonly Random _random;
+        private readonly List<string> _files;
+
+        public IOptions<StorageServiceConfiguration> Configurations { get; }
+        public IMinIoClientFactory ClientFactory { get; }
+        public IReadOnlyList<string> Files { get => _files; }
+        public string BucketName { get; }
+        public string Location { get; }
+
+        public MinIoStorageFixture()
+        {
+            _random = new Random();
+            _files = new List<string>();
+
+            Configurations = Options.Create(new StorageServiceConfiguration());
+            Configurations.Value.Settings.Add(ConfigurationKeys.EndPoint, "localhost:9000");
+            Configurations.Value.Settings.Add(ConfigurationKeys.AccessKey, "minioadmin");
+            Configurations.Value.Settings.Add(ConfigurationKeys.AccessToken, "minioadmin");
+            Configurations.Value.Settings.Add(ConfigurationKeys.SecuredConnection, "false");
+            Configurations.Value.Settings.Add(ConfigurationKeys.Region, "heaven");
+
+            ClientFactory = new MinIoClientFactory(Configurations);
+            BucketName = $"md-test-{_random.Next(1000)}";
+            Location = $"Heaven-L{_random.Next(28)}";
+        }
+
+        internal async Task GenerateAndUploadData(IObjectOperations client)
+        {
+            await GenerateAndUploadFile(client, $"{Guid.NewGuid()}").ConfigureAwait(false);
+            await GenerateAndUploadFile(client, $"dir-1/{Guid.NewGuid()}").ConfigureAwait(false);
+            await GenerateAndUploadFile(client, $"dir-2/{Guid.NewGuid()}").ConfigureAwait(false);
+            await GenerateAndUploadFile(client, $"dir-2/a/b/{Guid.NewGuid()}").ConfigureAwait(false);
+        }
+
+        private async Task GenerateAndUploadFile(IObjectOperations client, string filePath)
+        {
+            var data = GetRandomBytes();
+            var stream = new MemoryStream(data);
+
+            var putObjectArgs = new PutObjectArgs()
+                    .WithBucket(BucketName)
+                    .WithObject(filePath)
+                    .WithObjectSize(data.Length)
+                    .WithStreamData(stream);
+            await client.PutObjectAsync(putObjectArgs).ConfigureAwait(false);
+
+            _files.Add(filePath);
+        }
+
+        public byte[] GetRandomBytes()
+        {
+            return new byte[_random.Next(1, MaxFileSize)];
+        }
+
+        public async ValueTask DisposeAsync()
+        {
+            await RemoveData().ConfigureAwait(false);
+            await RemoveBucket().ConfigureAwait(false);
+        }
+
+        private async Task RemoveBucket()
+        {
+            var client = ClientFactory.GetBucketOperationsClient();
+            var args = new RemoveBucketArgs()
+                    .WithBucket(BucketName);
+            await client.RemoveBucketAsync(args).ConfigureAwait(false);
+        }
+
+        private async Task RemoveData()
+        {
+            var client = ClientFactory.GetObjectOperationsClient();
+            var args = new RemoveObjectsArgs()
+                    .WithBucket(BucketName)
+                    .WithObjects(_files);
+
+            await client.RemoveObjectsAsync(args).ConfigureAwait(false);
+        }
+    }
+}