[#33] Client: Add extended life tests

Signed-off-by: Pavel Gross <p.gross@yadro.com>
2025-02-19 10:55:57 +03:00 · 2025-02-19 10:55:57 +03:00 · bd8eb7cc60
commit bd8eb7cc60
parent 2e56c13946
24 changed files with 1020 additions and 976 deletions
--- a/src/FrostFS.SDK.Tests/Smoke/Client/ContainerTests/ContainerTests.cs
+++ b/src/FrostFS.SDK.Tests/Smoke/Client/ContainerTests/ContainerTests.cs
@ -0,0 +1,283 @@
+using System.Collections.Concurrent;
+using System.Collections.ObjectModel;
+using System.Diagnostics.CodeAnalysis;
+using FrostFS.SDK.Client;
+using Grpc.Core;
+
+namespace FrostFS.SDK.Tests.Smoke;
+
+[SuppressMessage("Reliability", "CA2007:Consider calling ConfigureAwait on the awaited task", Justification = "Default Value is correct for tests")]
+[SuppressMessage("Security", "CA5394:Do not use insecure randomness", Justification = "No secure purpose")]
+public class ContainerTests : SmokeTestsBase
+{
+    [Fact]
+    public async void FailCreateContainerByTimeoutTest()
+    {
+        var client = FrostFSClient.GetInstance(ClientOptions, GrpcChannel);
+
+        try
+        {
+            _ = await CreateContainer(client,
+                ctx: new CallContext(TimeSpan.FromMilliseconds(1)),
+                token: null,
+                unique: true,
+                backupFactor: 1,
+                selectors: [],
+                filter: [],
+                containerAttributes: [new("testKey1", "testValue1")],
+                new FrostFsReplica(1));
+
+            Assert.Fail("Exception is expected");
+        }
+        catch (RpcException ex)
+        {
+            Assert.Equal(StatusCode.DeadlineExceeded, ex.Status.StatusCode);
+        }
+    }
+
+    [Fact]
+    public async void CreateContainerTest1()
+    {
+        var client = FrostFSClient.GetInstance(ClientOptions, GrpcChannel);
+        await Cleanup(client);
+        
+        client = FrostFSClient.GetInstance(ClientOptions, GrpcChannel);
+   
+        FrostFsContainerId containerId = await CreateContainer(client,
+            ctx: default,
+            token: null,
+            unique: true,
+            backupFactor: 1,
+            selectors: [],
+            filter: [],
+            containerAttributes: [new ("testKey1", "testValue1")],
+            new FrostFsReplica(3));
+
+        Assert.NotNull(containerId);
+
+        var container = await client.GetContainerAsync(new PrmContainerGet(containerId), default);
+       
+        Assert.NotNull(container);
+
+        Assert.NotNull(container.Attributes);
+        Assert.Equal(2, container.Attributes.Count);
+        Assert.Equal("testKey1", container.Attributes[0].Key);
+        Assert.Equal("testValue1", container.Attributes[0].Value);
+        Assert.Equal("__SYSTEM__DISABLE_HOMOMORPHIC_HASHING", container.Attributes[1].Key);
+        Assert.Equal("true", container.Attributes[1].Value);
+        
+        Assert.True(container.PlacementPolicy.HasValue);
+
+        Assert.Equal(1u, container.PlacementPolicy.Value.BackupFactor);
+        Assert.True(container.PlacementPolicy.Value.Unique);
+        Assert.Empty(container.PlacementPolicy.Value.Selectors);
+        Assert.Empty(container.PlacementPolicy.Value.Filters);
+
+        Assert.Single(container.PlacementPolicy.Value.Replicas);
+        Assert.Equal(3, container.PlacementPolicy.Value.Replicas[0].Count);
+        Assert.Equal(0u, container.PlacementPolicy.Value.Replicas[0].EcParityCount);
+        Assert.Equal(0u, container.PlacementPolicy.Value.Replicas[0].EcDataCount);
+        Assert.Equal("", container.PlacementPolicy.Value.Replicas[0].Selector);
+
+        Assert.Equal(OwnerId!.ToString(), container.Owner!.Value);
+
+        Assert.NotNull(container.Version);
+        
+        Assert.Equal(Version!.Major, container.Version.Major);
+        Assert.Equal(Version.Minor, container.Version.Minor);
+    }
+
+    [Fact]
+    public async void CreateContainerTest2()
+    {
+        var client = FrostFSClient.GetInstance(ClientOptions, GrpcChannel);
+
+        await Cleanup(client);
+
+        client = FrostFSClient.GetInstance(ClientOptions, GrpcChannel);
+
+        Collection<FrostFsFilter> filters = [
+            new ("filter1", "filterKey1", 1, "testValue1", []),
+            new ("filter2", "filterKey2", 2, "testValue2", [new ("subFilter2", "subFilterKey2", 3, "testValue3",[])])
+        ];
+
+         Collection<FrostFsSelector> selectors = [
+            new ("selector1") {
+                Count = 1,
+                Clause = 1,
+                Attribute = "attribute1",
+                Filter = "filter1"
+            },
+            new ("selector2") {
+                Count = 2,
+                Clause = 2,
+                Attribute = "attribute2",
+                Filter = "filter2"
+            },
+        ];
+
+        FrostFsContainerId containerId = await CreateContainer(client,
+            ctx: default,
+            token: null,
+            unique: false,
+            backupFactor: 2,
+            selectors,
+            filter: filters,
+            containerAttributes: [],
+            new FrostFsReplica(1));
+
+        Assert.NotNull(containerId);
+
+        var container = await client.GetContainerAsync(new PrmContainerGet(containerId), default);
+       
+        Assert.NotNull(container);
+
+        Assert.NotNull(container.Attributes);
+        Assert.Single(container.Attributes);
+        Assert.Equal("__SYSTEM__DISABLE_HOMOMORPHIC_HASHING", container.Attributes[0].Key);
+        Assert.Equal("true", container.Attributes[0].Value);
+
+        Assert.True(container.PlacementPolicy.HasValue);
+
+        Assert.Equal(2u, container.PlacementPolicy.Value.BackupFactor);
+        Assert.False(container.PlacementPolicy.Value.Unique);
+  
+        Assert.NotEmpty(container.PlacementPolicy.Value.Selectors);
+
+        Assert.Equal(2, container.PlacementPolicy.Value.Selectors.Count);
+
+        var selector1 = container.PlacementPolicy.Value.Selectors[0];
+        Assert.Equal("selector1", selector1.Name);
+        Assert.Equal(1, selector1.Clause);
+        Assert.Equal(1u, selector1.Count);
+        Assert.Equal("attribute1", selector1.Attribute);
+        Assert.Equal("filter1", selector1.Filter);
+
+        var selector2 = container.PlacementPolicy.Value.Selectors[1];
+        Assert.Equal("selector2", selector2.Name);
+        Assert.Equal(2, selector2.Clause);
+        Assert.Equal(2u, selector2.Count);
+        Assert.Equal("attribute2", selector2.Attribute);
+        Assert.Equal("filter2", selector2.Filter);
+
+        Assert.NotEmpty(container.PlacementPolicy.Value.Filters);
+
+        Assert.Equal(2, container.PlacementPolicy.Value.Filters.Count);
+
+        var filter1 = container.PlacementPolicy.Value.Filters[0];
+        Assert.Equal("filter1", filter1.Name);
+        Assert.Equal("filterKey1", filter1.Key);
+        Assert.Equal("testValue1", filter1.Value);
+        Assert.Equal(1, filter1.Operation);
+        Assert.Empty(filter1.Filters);
+
+        var filter2 = container.PlacementPolicy.Value.Filters[1];
+        Assert.Equal("filter2", filter2.Name);
+        Assert.Equal("filterKey2", filter2.Key);
+        Assert.Equal("testValue2", filter2.Value);
+        Assert.Equal(2, filter2.Operation);
+        Assert.NotEmpty(filter2.Filters);
+
+        Assert.Single(filter2.Filters);
+
+        var subFilter = filter2.Filters.First();
+        Assert.Equal("subFilter2", subFilter.Name);
+        Assert.Equal("subFilterKey2", subFilter.Key);
+        Assert.Equal("testValue3", subFilter.Value);
+        Assert.Equal(3, subFilter.Operation);
+        Assert.Empty(subFilter.Filters);
+
+        Assert.Single(container.PlacementPolicy.Value.Replicas);
+        Assert.Equal(1, container.PlacementPolicy.Value.Replicas[0].Count);
+        Assert.Equal(0u, container.PlacementPolicy.Value.Replicas[0].EcParityCount);
+        Assert.Equal(0u, container.PlacementPolicy.Value.Replicas[0].EcDataCount);
+        Assert.Equal("", container.PlacementPolicy.Value.Replicas[0].Selector);
+
+        Assert.Equal(OwnerId!.ToString(), container.Owner!.Value);
+
+        Assert.NotNull(container.Version);
+        
+        Assert.Equal(Version!.Major, container.Version.Major);
+        Assert.Equal(Version.Minor, container.Version.Minor);
+    }
+
+    [Theory]
+    [InlineData(1)]
+    [InlineData(10)]
+    public async void ListAndDeleteContainersTest(int countainerCount)
+    {
+        var client = FrostFSClient.GetInstance(ClientOptions, GrpcChannel);
+
+        await Cleanup(client);
+
+        var tasks = new Task[countainerCount];
+
+        var createdContainers = new ConcurrentDictionary<string, int>();
+
+        for (int i = 0; i < countainerCount; i++)
+        {
+            int index = i;
+            tasks[i] = Task.Run(async () =>
+            {
+                FrostFsContainerId containerId = await CreateContainer(client,
+                    ctx: default,
+                    token: null,
+                    unique: true,
+                    backupFactor: 1,
+                    selectors: [],
+                    filter: [],
+                    containerAttributes: [new($"testKey{index}", $"testValue{index}")],
+                    new FrostFsReplica(3));
+
+                createdContainers.TryAdd(containerId.ToString(), index);
+            });
+        }
+
+        #pragma warning disable xUnit1031 // Timeout is used
+        if (!Task.WaitAll(tasks, 20000))
+        {
+            Assert.Fail("cannot create containers");
+        }
+        #pragma warning restore xUnit1031
+
+        var containers = client.ListContainersAsync(new PrmContainerGetAll(), default);
+
+        var receivedContainers = new List<string>();
+        await foreach (var cntr in containers)
+        {
+            receivedContainers.Add(cntr.ToString());
+        }
+
+        Assert.Equal(countainerCount, receivedContainers.Count);
+
+        foreach (var cntrId in receivedContainers)
+        {
+            if (!createdContainers.TryGetValue(cntrId, out var index))
+            {
+                Assert.Fail("Cannot find corresponding container");
+            }
+
+            FrostFsContainerId container = new(cntrId);
+            var containerInfo = await client.GetContainerAsync(new PrmContainerGet(container), default);
+
+            Assert.NotNull(containerInfo);
+            Assert.NotNull(containerInfo.Attributes);
+
+            Assert.Contains(new FrostFsAttributePair($"testKey{index}", $"testValue{index}"), containerInfo.Attributes);
+        }
+
+        tasks = new Task[countainerCount];
+
+        for (int i = 0; i < receivedContainers.Count; i++)
+        {
+            tasks[i] = client.DeleteContainerAsync(new PrmContainerDelete(new FrostFsContainerId(receivedContainers[i]), lightWait), default);
+        }
+
+        await Task.WhenAll(tasks);
+
+        await foreach (var _ in client.ListContainersAsync(default, default))
+        {
+            Assert.Fail("Containers exist");
+        }
+    }
+}