[#33] Client: Add extended life tests

Signed-off-by: Pavel Gross <p.gross@yadro.com>

README.md

@@ -47,7 +47,7 @@ var placementPolicy = new FrostFsPlacementPolicy(true, new FrostFsReplica(1));
 var createContainerParam = new PrmContainerCreate(
     new FrostFsContainerInfo(BasicAcl.PublicRW, new FrostFsPlacementPolicy(true, new FrostFsReplica(1))));
 
-var containerId = await client.CreateContainerAsync(createContainerParam);
+var containerId = await client.PutContainerAsync(createContainerParam);
 
 using var fileStream = File.OpenRead(@"C:\Users\Paul\Pictures\cat.jpeg");
 

src/FrostFS.SDK.Client/FrostFSClient.cs

@@ -212,9 +212,15 @@ public class FrostFSClient : IFrostFSClient
         return GetContainerService().ListContainersAsync(args, ctx);
     }
 
+    [Obsolete("Use PutContainerAsync method")]
     public Task<FrostFsContainerId> CreateContainerAsync(PrmContainerCreate args, CallContext ctx)
     {
-        return GetContainerService().CreateContainerAsync(args, ctx);
+        return GetContainerService().PutContainerAsync(args, ctx);
+    }
+
+    public Task<FrostFsContainerId> PutContainerAsync(PrmContainerCreate args, CallContext ctx)
+    {
+        return GetContainerService().PutContainerAsync(args, ctx);
     }
 
     public Task DeleteContainerAsync(PrmContainerDelete args, CallContext ctx)
@@ -314,18 +320,6 @@ public class FrostFSClient : IFrostFSClient
     }
     #endregion
 
-    private async void CheckFrostFsVersionSupport(CallContext ctx)
-    {
-        var service = GetNetmapService();
-        var localNodeInfo = await service.GetLocalNodeInfoAsync(ctx).ConfigureAwait(false);
-
-        if (!localNodeInfo.Version.IsSupported(ClientCtx.Version))
-        {
-            var msg = $"FrostFS {localNodeInfo.Version} is not supported.";
-            throw new FrostFsException(msg);
-        }
-    }
-
     private CallInvoker? CreateInvoker()
     {
         CallInvoker? callInvoker = null;
@@ -361,7 +355,7 @@ public class FrostFSClient : IFrostFSClient
         {
             var invoker = CreateInvoker();
 
-            NetmapServiceClient = NetmapServiceClient ?? (
+            NetmapServiceClient ??= (
                 invoker != null
                 ? new NetmapServiceClient(invoker)
                 : new NetmapServiceClient(ClientCtx.Channel));
@@ -378,7 +372,7 @@ public class FrostFSClient : IFrostFSClient
         {
             var invoker = CreateInvoker();
 
-            SessionServiceClient = SessionServiceClient ?? (
+            SessionServiceClient ??= (
                 invoker != null
                 ? new SessionServiceClient(invoker)
                 : new SessionServiceClient(ClientCtx.Channel));
@@ -387,7 +381,6 @@ public class FrostFSClient : IFrostFSClient
         }
 
         return SessionServiceProvider;
-
     }
 
     private ApeManagerServiceProvider GetApeManagerService()
@@ -396,7 +389,7 @@ public class FrostFSClient : IFrostFSClient
         {
             var invoker = CreateInvoker();
 
-            ApeManagerServiceClient = ApeManagerServiceClient ?? (
+            ApeManagerServiceClient ??= (
                 invoker != null
                 ? new APEManagerServiceClient(invoker)
                 : new APEManagerServiceClient(ClientCtx.Channel));
@@ -413,7 +406,7 @@ public class FrostFSClient : IFrostFSClient
         {
             var invoker = CreateInvoker();
 
-            AccountingServiceClient = AccountingServiceClient ?? (
+            AccountingServiceClient ??= (
                 invoker != null
                 ? new AccountingServiceClient(invoker)
                 : new AccountingServiceClient(ClientCtx.Channel));
@@ -430,7 +423,7 @@ public class FrostFSClient : IFrostFSClient
         {
             var invoker = CreateInvoker();
 
-            ContainerServiceClient = ContainerServiceClient ?? (
+            ContainerServiceClient ??= (
                 invoker != null
                 ? new ContainerServiceClient(invoker)
                 : new ContainerServiceClient(ClientCtx.Channel));

src/FrostFS.SDK.Client/Interfaces/IFrostFSClient.cs

@@ -33,8 +33,11 @@ public interface IFrostFSClient
 
     IAsyncEnumerable<FrostFsContainerId> ListContainersAsync(PrmContainerGetAll args, CallContext ctx);
 
+    [Obsolete("Use PutContainerAsync method")]
     Task<FrostFsContainerId> CreateContainerAsync(PrmContainerCreate args, CallContext ctx);
 
+    Task<FrostFsContainerId> PutContainerAsync(PrmContainerCreate args, CallContext ctx);
+
     Task DeleteContainerAsync(PrmContainerDelete args, CallContext ctx);
     #endregion
 

src/FrostFS.SDK.Client/Mappers/Netmap/PlacementPolicy.cs

@@ -17,9 +17,9 @@ public static class PlacementPolicyMapper
         return new FrostFsPlacementPolicy(
             placementPolicy.Unique,
             placementPolicy.ContainerBackupFactor,
-            new System.Collections.ObjectModel.Collection<FrostFsSelector>(placementPolicy.Selectors.Select(selector => selector.ToModel()).ToList()),
+            [.. placementPolicy.Selectors.Select(s => s.ToModel())],
-            new System.Collections.ObjectModel.Collection<FrostFsFilter>(placementPolicy.Filters.Select(filter => filter.ToModel()).ToList()),
+            [.. placementPolicy.Filters.Select(f => f.ToModel())],
-            placementPolicy.Replicas.Select(replica => replica.ToModel()).ToArray()
+            [.. placementPolicy.Replicas.Select(r => r.ToModel())]
         );
     }
 }

src/FrostFS.SDK.Client/Mappers/Netmap/Replica.cs

@@ -50,13 +50,15 @@ public static class PolicyMapper
             throw new ArgumentNullException(nameof(selector));
         }
 
-        return new FrostFsSelector(selector.Name)
+        var model = new FrostFsSelector(selector.Name)
         {
             Count = selector.Count,
             Clause = (int)selector.Clause,
             Attribute = selector.Attribute,
             Filter = selector.Filter
         };
+
+        return model;
     }
 
     public static Filter ToMessage(this FrostFsFilter filter)
@@ -86,6 +88,13 @@ public static class PolicyMapper
             throw new ArgumentNullException(nameof(filter));
         }
 
-        return new FrostFsFilter(filter.Name, filter.Key, (int)filter.Op, filter.Value, filter.Filters.Select(f => f.ToModel()).ToArray());
+        var model = new FrostFsFilter(
+           filter.Name,
+           filter.Key,
+           (int)filter.Op,
+           filter.Value,
+           [.. filter.Filters.Select(f => f.ToModel())]);
+
+        return model;
     }
 }

src/FrostFS.SDK.Client/Mappers/Object/ObjectAttributeMapper.cs

@@ -8,11 +8,6 @@ public static class ObjectAttributeMapper
 {
     public static Header.Types.Attribute ToMessage(this FrostFsAttributePair attribute)
     {
-        if (attribute is null)
-        {
-            throw new ArgumentNullException(nameof(attribute));
-        }
-
         return new Header.Types.Attribute
         {
             Key = attribute.Key,

src/FrostFS.SDK.Client/Models/Netmap/FrostFsFilter.cs

@@ -1,4 +1,7 @@
-namespace FrostFS.SDK;
+using System.Linq;
+using FrostFS.Netmap;
+
+namespace FrostFS.SDK;
 
 public class FrostFsFilter(string name, string key, int operation, string value, FrostFsFilter[] filters) : IFrostFsFilter
 {
@@ -7,4 +10,19 @@ public class FrostFsFilter(string name, string key, int operation, string value,
     public int Operation { get; } = operation;
     public string Value { get; } = value;
     public FrostFsFilter[] Filters { get; } = filters;
+
+    internal Filter GetMessage()
+    {
+        var filter = new Filter()
+        {
+            Name = Name,
+            Key = Key,
+            Op = (Operation)Operation,
+            Value = Value,
+        };
+
+        filter.Filters.AddRange(Filters.Select(f => f.GetMessage()));
+
+        return filter;
+    }
 }

src/FrostFS.SDK.Client/Models/Netmap/FrostFsPlacementPolicy.cs

@@ -51,6 +51,16 @@ public struct FrostFsPlacementPolicy(bool unique,
                 ContainerBackupFactor = BackupFactor
             };
 
+            if (Selectors != null && Selectors.Count > 0)
+            {
+                policy.Selectors.AddRange(Selectors.Select(s => s.GetMessage()));
+            }
+
+            if (Filters != null && Filters.Count > 0)
+            {
+                policy.Filters.AddRange(Filters.Select(s => s.ToMessage()));
+            }
+
             foreach (var replica in Replicas)
             {
                 policy.Replicas.Add(replica.ToMessage());

src/FrostFS.SDK.Client/Models/Netmap/FrostFsSelector.cs

@@ -1,10 +1,24 @@
-namespace FrostFS.SDK;
+using FrostFS.Netmap;
+
+namespace FrostFS.SDK;
 
 public class FrostFsSelector(string name)
 {
-    public string Name { get; set; } = name;
+    public string Name { get; } = name;
     public uint Count { get; set; }
     public int Clause { get; set; }
     public string? Attribute { get; set; }
     public string? Filter { get; set; }
+
+    internal Selector GetMessage()
+    {
+        return new Selector()
+        {
+            Name = Name,
+            Clause = (Clause)Clause,
+            Count = Count,
+            Filter = Filter ?? string.Empty,
+            Attribute = Attribute ?? string.Empty,
+        };
+    }
 }

src/FrostFS.SDK.Client/Models/Object/FrostFsAttributePair.cs

@@ -1,8 +1,36 @@
 namespace FrostFS.SDK;
 
-public class FrostFsAttributePair(string key, string value)
+public struct FrostFsAttributePair(string key, string value) : System.IEquatable<FrostFsAttributePair>
 {
     public string Key { get; set; } = key;
 
     public string Value { get; set; } = value;
+
+    public override bool Equals(object obj)
+    {
+        if (obj == null || obj is not FrostFsAttributePair)
+            return false;
+
+        return Equals((FrostFsAttributePair)obj);
+    }
+
+    public override int GetHashCode()
+    {
+        return Key.GetHashCode() ^ Value.GetHashCode();
+    }
+
+    public static bool operator ==(FrostFsAttributePair left, FrostFsAttributePair right)
+    {
+        return left.Equals(right);
+    }
+
+    public static bool operator !=(FrostFsAttributePair left, FrostFsAttributePair right)
+    {
+        return !(left == right);
+    }
+
+    public bool Equals(FrostFsAttributePair other)
+    {
+        return GetHashCode().Equals(other.GetHashCode());
+    }
 }

src/FrostFS.SDK.Client/Pool/Pool.cs

@@ -568,10 +568,17 @@ public partial class Pool : IFrostFSClient
         return client.Client!.ListContainersAsync(args, ctx);
     }
 
+    [Obsolete("Use PutContainerAsync method")]
     public async Task<FrostFsContainerId> CreateContainerAsync(PrmContainerCreate args, CallContext ctx)
     {
         var client = Connection();
-        return await client.Client!.CreateContainerAsync(args, ctx).ConfigureAwait(false);
+        return await client.Client!.PutContainerAsync(args, ctx).ConfigureAwait(false);
+    }
+
+    public async Task<FrostFsContainerId> PutContainerAsync(PrmContainerCreate args, CallContext ctx)
+    {
+        var client = Connection();
+        return await client.Client!.PutContainerAsync(args, ctx).ConfigureAwait(false);
     }
 
     public async Task DeleteContainerAsync(PrmContainerDelete args, CallContext ctx)

src/FrostFS.SDK.Client/Services/ContainerServiceProvider.cs

@@ -71,7 +71,7 @@ internal sealed class ContainerServiceProvider(ContainerService.ContainerService
         }
     }
 
-    internal async Task<FrostFsContainerId> CreateContainerAsync(PrmContainerCreate args, CallContext ctx)
+    internal async Task<FrostFsContainerId> PutContainerAsync(PrmContainerCreate args, CallContext ctx)
     {
         var grpcContainer = args.Container.GetContainer();
 

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");
+        }
+    }
+}

src/FrostFS.SDK.Tests/Smoke/Client/MiscTests/InterceptorTest.cs

@@ -0,0 +1,37 @@
+using FrostFS.SDK.Client;
+using FrostFS.SDK.SmokeTests;
+
+namespace FrostFS.SDK.Tests.Smoke;
+
+public class InterceptorTests() : SmokeTestsBase
+{
+    [Fact]
+    public async void NodeInfoCallbackAndInterceptorTest()
+    {
+        bool callbackInvoked = false;
+        bool interceptorInvoked = false;
+
+        var options = ClientOptions;
+        options.Value.Callback = (cs) =>
+        {
+            callbackInvoked = true;
+            Assert.True(cs.ElapsedMicroSeconds > 0);
+        };
+
+        options.Value.Interceptors.Add(new CallbackInterceptor(s => interceptorInvoked = true));
+
+        var client = FrostFSClient.GetInstance(options, GrpcChannel);
+
+        var result = await client.GetNodeInfoAsync(default);
+
+        Assert.True(callbackInvoked);
+        Assert.True(interceptorInvoked);
+
+        Assert.Equal(2, result.Version.Major);
+        Assert.Equal(13, result.Version.Minor);
+        Assert.Equal(NodeState.Online, result.State);
+        Assert.Equal(33, result.PublicKey.Length);
+        Assert.NotNull(result.Addresses);
+        Assert.True(result.Attributes.Count > 0);
+    }
+}

src/FrostFS.SDK.Tests/Smoke/Client/NetworkTests/NetworkTests.cs

@@ -0,0 +1,111 @@
+using System.Diagnostics.CodeAnalysis;
+using FrostFS.SDK.Client;
+using FrostFS.SDK.SmokeTests;
+
+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 SmokeClientTests : SmokeTestsBase
+{
+    [Fact]
+    public async void AccountTest()
+    {
+        var test = lightWait.Timeout;
+
+        var client = FrostFSClient.GetInstance(ClientOptions, GrpcChannel);
+
+        var result = await client.GetBalanceAsync(default);
+
+        Assert.NotNull(result);
+        Assert.True(result.Value == 0);
+    }
+
+    [Fact]
+    public async void NodeInfoTest()
+    {
+        var client = FrostFSClient.GetInstance(ClientOptions, GrpcChannel);
+
+        var result = await client.GetNodeInfoAsync(default);
+
+        Assert.Equal(2, result.Version.Major);
+        Assert.Equal(13, result.Version.Minor);
+        Assert.Equal(NodeState.Online, result.State);
+        Assert.Equal(33, result.PublicKey.Length);
+        Assert.Equal(2, result.Addresses.Count);
+        Assert.Equal(11, result.Attributes.Count);
+    }
+
+    [Fact]
+    public async void NodeInfoStatisticsTest()
+    {
+        var options = ClientOptions;
+
+        var callbackContent = string.Empty;
+        options.Value.Callback = (cs) => callbackContent = $"{cs.MethodName} took {cs.ElapsedMicroSeconds} microseconds";
+
+        var client = FrostFSClient.GetInstance(options, GrpcChannel);
+
+        var result = await client.GetNodeInfoAsync(default);
+
+        Assert.NotEmpty(callbackContent);
+    }
+
+    [Fact]
+    public async void NetworkSettingsTest()
+    {
+        var options = ClientOptions;
+        var client = FrostFSClient.GetInstance(options, GrpcChannel);
+
+        var result = await client.GetNetworkSettingsAsync(default);
+
+        Assert.NotNull(result);
+
+        Assert.True(0u < result.Epoch);
+        Assert.True(result.HomomorphicHashingDisabled);
+        Assert.True(result.MaintenanceModeAllowed);
+        Assert.True(0u < result.MagicNumber);
+     
+        Assert.Equal(0u, result.AuditFee);
+        Assert.Equal(0u, result.BasicIncomeRate);
+        Assert.Equal(0u, result.ContainerAliasFee);
+        Assert.Equal(0u, result.ContainerFee);
+        Assert.Equal(75u, result.EpochDuration);
+        Assert.Equal(10_000_000_000u, result.InnerRingCandidateFee);       
+        Assert.Equal(12u, result.MaxECDataCount);
+        Assert.Equal(4u, result.MaxECParityCount);
+        Assert.Equal(5242880u, result.MaxObjectSize);
+        Assert.Equal(8000u, result.MsPerBlock);
+        Assert.Equal(100_000_000u, result.WithdrawFee);
+    }
+
+    [Fact]
+    public async void NodeInfoCallbackAndInterceptorTest()
+    {
+        bool callbackInvoked = false;
+        bool interceptorInvoked = false;
+
+        var options = ClientOptions;
+        options.Value.Callback = (cs) =>
+        {
+            callbackInvoked = true;
+            Assert.True(cs.ElapsedMicroSeconds > 0);
+        };
+
+        options.Value.Interceptors.Add(new CallbackInterceptor(s => interceptorInvoked = true));
+
+        var client = FrostFSClient.GetInstance(options, GrpcChannel);
+
+        var result = await client.GetNodeInfoAsync(default);
+
+        Assert.True(callbackInvoked);
+        Assert.True(interceptorInvoked);
+
+        Assert.Equal(2, result.Version.Major);
+        Assert.Equal(13, result.Version.Minor);
+        Assert.Equal(NodeState.Online, result.State);
+        Assert.Equal(33, result.PublicKey.Length);
+        Assert.NotNull(result.Addresses);
+        Assert.True(result.Attributes.Count > 0);
+    }
+}

src/FrostFS.SDK.Tests/Smoke/Client/ObjectTests/ObjectTests.cs

@@ -0,0 +1,337 @@
+using System.Diagnostics.CodeAnalysis;
+using System.Security.Cryptography;
+using FrostFS.SDK.Client;
+using FrostFS.SDK.Client.Interfaces;
+using FrostFS.SDK.Cryptography;
+using Xunit.Abstractions;
+
+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 ObjectTests(ITestOutputHelper testOutputHelper) : SmokeTestsBase
+{
+    private readonly ITestOutputHelper _testOutputHelper = testOutputHelper;
+
+    const string clientCut = "clientCut";
+    const string serverCut = "serverCut";
+    const string singleObject = "singleObject";
+
+    [Theory]
+    [InlineData(true, 1, 1)]
+    [InlineData(false, 1, 1)]
+    [InlineData(true, 1, 3)]
+    [InlineData(false, 1, 3)]
+    [InlineData(true, 2, 3)]
+    [InlineData(false, 2, 3)]
+    [InlineData(true, 2, 1)]
+    [InlineData(false, 2, 1)]
+    public async void FullScenario(bool unique, uint backupFactor, int replicas)
+    {
+        var client = FrostFSClient.GetInstance(ClientOptions, GrpcChannel);
+        _testOutputHelper.WriteLine("client created");
+
+        await Cleanup(client);
+        _testOutputHelper.WriteLine("existing containers removed");
+
+        FrostFsContainerId containerId = await CreateContainer(client,
+                ctx: default,
+                token: null,
+                unique: unique,
+                backupFactor: backupFactor,
+                selectors: [],
+                filter: [],
+                containerAttributes: [],
+                new FrostFsReplica(replicas));
+
+        Assert.NotNull(containerId);
+        _testOutputHelper.WriteLine("container created");
+
+        await AddObjectRules(client, containerId);
+        _testOutputHelper.WriteLine("rules added");
+       
+        await RunSuite(client, containerId);
+    }
+
+    private async Task RunSuite(IFrostFSClient client, FrostFsContainerId containerId)
+    {
+        int[] objectSizes = [1, 257, 6 * 1024, 20 * 1024];
+
+        string[] objectTypes = [clientCut, serverCut, singleObject];
+
+        foreach (var objectSize in objectSizes)
+        {
+            _testOutputHelper.WriteLine($"test set for object size {objectSize}");
+
+            var bytes = GetRandomBytes(objectSize);
+            var hash = SHA256.HashData(bytes);
+
+            FrostFsObjectId objectId;
+            foreach (var type in objectTypes)
+            {
+                switch (type)
+                {
+                    case serverCut:
+                        objectId = await CreateObjectServerCut(client, containerId, bytes);
+                        break;
+                    case clientCut:
+                        objectId = await CreateObjectClientCut(client, containerId, bytes);
+                        break;
+                    case singleObject:                        
+                        if (objectSize > 1 * 1024 * 1024)
+                            continue;
+                        objectId = await PutSingleObject(client, containerId, bytes);
+                       
+                        break;
+                    default:
+                        throw new ArgumentException("unexpected object type");
+                }
+
+                Assert.NotNull(objectId);
+
+                _testOutputHelper.WriteLine($"\tobject created");
+
+                await ValidateContent(client, containerId, hash, objectId);
+                _testOutputHelper.WriteLine($"\tcontent validated");
+
+                await ValidateFilters(client, containerId, objectId, null, (ulong)bytes.Length);
+                _testOutputHelper.WriteLine($"\tfilters validated");
+
+                // if (type != clientCut)
+                // {
+                //     await ValidatePatch(client, containerId, bytes, objectId);
+                //     _testOutputHelper.WriteLine($"\tpatch validated");
+                // }
+
+                await ValidateRange(client, containerId, bytes, objectId);
+                _testOutputHelper.WriteLine($"\trange validated");
+
+                await ValidateRangeHash(client, containerId, bytes, objectId);
+                _testOutputHelper.WriteLine($"\trange hash validated");
+
+                await RemoveObject(client, containerId, objectId);
+                _testOutputHelper.WriteLine($"\tobject removed");
+            }
+        }
+    }
+
+    private static async Task ValidateRangeHash(IFrostFSClient client, FrostFsContainerId containerId, byte[] bytes, FrostFsObjectId objectId)
+    {
+        if (bytes.Length < 200)
+            return;
+
+        var rangeParam = new PrmRangeHashGet(containerId, objectId, [new FrostFsRange(100, 64)], bytes);
+
+        var hashes = await client.GetRangeHashAsync(rangeParam, default);
+
+        foreach (var h in hashes)
+        {
+            var x = h[..32].ToArray();
+            Assert.NotNull(x);
+            Assert.True(x.Length > 0);
+        }
+    }
+
+    private async Task ValidateRange(IFrostFSClient client, FrostFsContainerId containerId, byte[] bytes, FrostFsObjectId objectId)
+    {
+        if (bytes.Length < 200)
+            return;
+
+        await CheckRange(client, containerId, bytes, objectId, new FrostFsRange(0, 50));
+        await CheckRange(client, containerId, bytes, objectId, new FrostFsRange(50, 100));
+
+        await CheckRange(client, containerId, bytes, objectId, new FrostFsRange((ulong)bytes.Length-100, 100));
+       
+        if (bytes.Length >= 6200)
+            await CheckRange(client, containerId, bytes, objectId, new FrostFsRange(6000, 100));
+    }
+
+    private async Task CheckRange(IFrostFSClient client, FrostFsContainerId containerId, byte[] bytes, FrostFsObjectId objectId, FrostFsRange range)
+    {
+        var rangeParam = new PrmRangeGet(containerId, objectId, range);
+
+        var rangeReader = await client.GetRangeAsync(rangeParam, default);
+
+        var rangeBytes = new byte[rangeParam.Range.Length];
+        MemoryStream ms = new(rangeBytes);
+
+        ReadOnlyMemory<byte>? chunk;
+        while ((chunk = await rangeReader!.ReadChunk()) != null)
+        {
+            ms.Write(chunk.Value.Span);
+        }
+
+        Assert.Equal(SHA256.HashData(bytes.AsSpan().Slice((int)range.Offset, (int)range.Length)), SHA256.HashData(rangeBytes));
+
+        _testOutputHelper.WriteLine($"\t\trange {range.Offset};{range.Length} validated");
+    }
+
+    private static async Task ValidatePatch(IFrostFSClient client, FrostFsContainerId containerId, byte[] bytes, FrostFsObjectId objectId)
+    {
+        if (bytes.Length < 1024 + 64)
+            return;
+
+        var patch = new byte[1024];
+        for (int i = 0; i < patch.Length; i++)
+        {
+            patch[i] = 32;
+        }
+
+        var range = new FrostFsRange(64, (ulong)patch.Length);
+
+        var patchParams = new PrmObjectPatch(
+            new FrostFsAddress(containerId, objectId),
+            payload: new MemoryStream(patch),
+            maxChunkLength: 1024,
+            range: range);
+
+        var newIbjId = await client.PatchObjectAsync(patchParams, default);
+
+        var @object = await client.GetObjectAsync(new PrmObjectGet(containerId, newIbjId), default);
+
+        var downloadedBytes = new byte[@object.Header.PayloadLength];
+        MemoryStream ms = new(downloadedBytes);
+
+        ReadOnlyMemory<byte>? chunk;
+        while ((chunk = await @object.ObjectReader!.ReadChunk()) != null)
+        {
+            ms.Write(chunk.Value.Span);
+        }
+
+        for (int i = 0; i < (int)range.Offset; i++)
+            Assert.Equal(downloadedBytes[i], bytes[i]);
+
+        var rangeEnd = range.Offset + range.Length;
+
+        for (int i = (int)range.Offset; i < (int)rangeEnd; i++)
+            Assert.Equal(downloadedBytes[i], patch[i - (int)range.Offset]);
+
+        for (int i = (int)rangeEnd; i < bytes.Length; i++)
+            Assert.Equal(downloadedBytes[i], bytes[i]);
+    }
+   
+
+    private async Task ValidateFilters(IFrostFSClient client, FrostFsContainerId containerId, FrostFsObjectId objectId, SplitId? splitId, ulong length)
+    {
+        var ecdsaKey = keyString.LoadWif();
+
+        var networkInfo = await client.GetNetmapSnapshotAsync(default);
+
+        await CheckFilter(client, containerId, new FilterByContainerId(FrostFsMatchType.Equals, containerId));
+
+        await CheckFilter(client, containerId, new FilterByOwnerId(FrostFsMatchType.Equals, FrostFsOwner.FromKey(ecdsaKey)));
+
+        if (splitId != null)
+        {
+            await CheckFilter(client, containerId, new FilterBySplitId(FrostFsMatchType.Equals, splitId));
+        }
+
+        await CheckFilter(client, containerId, new FilterByAttributePair(FrostFsMatchType.Equals, "fileName", "test"));
+
+        await CheckFilter(client, containerId, new FilterByObjectId(FrostFsMatchType.Equals, objectId));
+
+        await CheckFilter(client, containerId, new FilterByVersion(FrostFsMatchType.Equals, networkInfo.NodeInfoCollection[0].Version));
+
+        await CheckFilter(client, containerId, new FilterByEpoch(FrostFsMatchType.Equals, networkInfo.Epoch));
+
+        await CheckFilter(client, containerId, new FilterByPayloadLength(FrostFsMatchType.Equals, length));
+
+        // var checkSum = CheckSum.CreateCheckSum(hash);
+        // await CheckFilter(client, containerId, new FilterByPayloadHash(FrostFsMatchType.Equals, checkSum));
+
+        await CheckFilter(client, containerId, new FilterByPhysicallyStored());
+    }
+
+    private static async Task RemoveObject(IFrostFSClient client, FrostFsContainerId containerId, FrostFsObjectId objectId)
+    {
+        await client.DeleteObjectAsync(new PrmObjectDelete(containerId, objectId), default);
+
+        try
+        {
+            _ = await client.GetObjectAsync(
+                new PrmObjectGet(containerId, objectId),
+                default);
+
+            Assert.Fail("Exception is expected here");
+        }
+        catch (FrostFsResponseException ex)
+        {
+            Assert.Equal("object already removed", ex.Status!.Message);
+        }
+    }
+
+    private static async Task ValidateContent(IFrostFSClient client, FrostFsContainerId containerId,  byte[] hash, FrostFsObjectId objectId)
+    {
+        var @object = await client.GetObjectAsync(
+            new PrmObjectGet(containerId, objectId),
+            default);
+
+        var downloadedBytes = new byte[@object.Header.PayloadLength];
+        MemoryStream ms = new(downloadedBytes);
+
+        ReadOnlyMemory<byte>? chunk = null;
+        while ((chunk = await @object.ObjectReader!.ReadChunk()) != null)
+        {
+            ms.Write(chunk.Value.Span);
+        }
+
+        Assert.Equal(hash, SHA256.HashData(downloadedBytes));
+    }
+
+    private static async Task<FrostFsObjectId> CreateObjectServerCut(IFrostFSClient client, FrostFsContainerId containerId, byte[] bytes)
+    {
+        var header = new FrostFsObjectHeader(
+            containerId: containerId,
+            type: FrostFsObjectType.Regular,
+            [new FrostFsAttributePair("fileName", "test")]);
+
+        var param = new PrmObjectPut(header);
+
+        var objectWriter = await client.PutObjectAsync(param, default).ConfigureAwait(true);
+
+        await objectWriter.WriteAsync(bytes);
+        return await objectWriter.CompleteAsync();
+    }
+
+    private static async Task<FrostFsObjectId> CreateObjectClientCut(IFrostFSClient client, FrostFsContainerId containerId, byte[] bytes)
+    {
+        var header = new FrostFsObjectHeader(
+                        containerId: containerId,
+                        type: FrostFsObjectType.Regular,
+                        [new FrostFsAttributePair("fileName", "test")]);
+
+        var param = new PrmObjectClientCutPut(header, payload: new MemoryStream(bytes));
+
+        return await client.PutClientCutObjectAsync(param, default).ConfigureAwait(true);
+    }
+
+     private static async Task<FrostFsObjectId> PutSingleObject(IFrostFSClient client, FrostFsContainerId containerId, byte[] bytes)
+    {
+        var header = new FrostFsObjectHeader(
+            containerId: containerId,
+            type: FrostFsObjectType.Regular,
+            [new FrostFsAttributePair("fileName", "test")]);
+
+
+        var obj = new FrostFsObject(header) { SingleObjectPayload = bytes };
+
+        var param = new PrmSingleObjectPut(obj);
+
+        return await client.PutSingleObjectAsync(param, default).ConfigureAwait(true);
+    }
+    
+    private static async Task CheckFilter(IFrostFSClient client, FrostFsContainerId containerId, IObjectFilter filter)
+    {
+        var resultObjectsCount = 0;
+
+        PrmObjectSearch searchParam = new(containerId, null, [], filter);
+
+        await foreach (var objId in client.SearchObjectsAsync(searchParam, default))
+        {
+            resultObjectsCount++;
+            var objHeader = await client.GetObjectHeadAsync(new PrmObjectHeadGet(containerId, objId), default);
+        }
+
+        Assert.True(0 < resultObjectsCount, $"Filter for {filter.Key} doesn't work");
+    }
+}

src/FrostFS.SDK.Tests/Smoke/Client/SessionTests/SessionTests.cs

@@ -0,0 +1,21 @@
+using System.Diagnostics.CodeAnalysis;
+using FrostFS.SDK.Client;
+
+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 SessionTests : SmokeTestsBase
+{
+    [Fact]
+    public async void GetSessionTest()
+    {
+        var client = FrostFSClient.GetInstance(ClientOptions, GrpcChannel);
+
+        var token = await client.CreateSessionAsync(new(100), default);
+
+        Assert.NotNull(token);
+        Assert.NotEqual(Guid.Empty, token.Id);
+        Assert.Equal(33, token.SessionKey.Length);
+    }
+}

src/FrostFS.SDK.Tests/Smoke/PoolTests/Multithread/MultithreadPoolSmokeTests.cs

@@ -4,16 +4,12 @@ using System.Security.Cryptography;
 using FrostFS.SDK.Client;
 using FrostFS.SDK.Cryptography;
 
-using Microsoft.Extensions.Options;
-
 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 MultithreadPoolSmokeTests : SmokeTestsBase
 {
-    private static readonly PrmWait lightWait = new(100, 1);
-
     private InitParameters GetDefaultParams()
     {
         return new InitParameters((url) => Grpc.Net.Client.GrpcChannel.ForAddress(new Uri(url)))
@@ -170,7 +166,7 @@ public class MultithreadPoolSmokeTests : SmokeTestsBase
             PrmWait.DefaultParams,
             xheaders: ["key1", "value1"]);
 
-        var containerId = await pool.CreateContainerAsync(createContainerParam, default);
+        var containerId = await pool.PutContainerAsync(createContainerParam, default);
 
         var bytes = GetRandomBytes(1024);
 
@@ -219,7 +215,7 @@ public class MultithreadPoolSmokeTests : SmokeTestsBase
            new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, 1, [], [], new FrostFsReplica(1))),
            lightWait);
 
-        var containerId = await pool.CreateContainerAsync(createContainerParam, default);
+        var containerId = await pool.PutContainerAsync(createContainerParam, default);
 
         var bytes = new byte[] { 1, 2, 3 };
 
@@ -315,7 +311,7 @@ public class MultithreadPoolSmokeTests : SmokeTestsBase
             PrmWait.DefaultParams,
             xheaders: ["testKey", "testValue"]);
 
-        var createdContainer = await pool.CreateContainerAsync(createContainerParam, default);
+        var createdContainer = await pool.PutContainerAsync(createContainerParam, default);
 
         var container = await pool.GetContainerAsync(new PrmContainerGet(createdContainer), default);
         Assert.NotNull(container);
@@ -399,7 +395,7 @@ public class MultithreadPoolSmokeTests : SmokeTestsBase
             new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, 1, [], [], new FrostFsReplica(1))),
              PrmWait.DefaultParams);
 
-        var container = await pool.CreateContainerAsync(createContainerParam, ctx);
+        var container = await pool.PutContainerAsync(createContainerParam, ctx);
 
         var containerInfo = await pool.GetContainerAsync(new PrmContainerGet(container), ctx);
         Assert.NotNull(containerInfo);
@@ -482,7 +478,7 @@ public class MultithreadPoolSmokeTests : SmokeTestsBase
             new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, 1, [], [], new FrostFsReplica(1))),
             lightWait);
 
-        var containerId = await pool.CreateContainerAsync(createContainerParam, default);
+        var containerId = await pool.PutContainerAsync(createContainerParam, default);
 
         var ctx = new CallContext(TimeSpan.FromSeconds(10));
 
@@ -545,37 +541,4 @@ public class MultithreadPoolSmokeTests : SmokeTestsBase
             Assert.Fail($"Container {cid.GetValue()} exist");
         }
     }
-
-    private static byte[] GetRandomBytes(int size)
-    {
-        Random rnd = new();
-        var bytes = new byte[size];
-        rnd.NextBytes(bytes);
-        return bytes;
-    }
-
-    private static IOptions<ClientSettings> GetSingleOwnerOptions(string key, string url)
-    {
-        return Options.Create(new ClientSettings
-        {
-            Key = key,
-            Host = url
-        });
-    }
-
-    private static IOptions<ClientSettings> GetOptions(string url)
-    {
-        return Options.Create(new ClientSettings
-        {
-            Host = url
-        });
-    }
-
-    static async Task Cleanup(Pool pool)
-    {
-        await foreach (var cid in pool.ListContainersAsync(default, default))
-        {
-            await pool.DeleteContainerAsync(new PrmContainerDelete(cid, lightWait), default).ConfigureAwait(true);
-        }
-    }
 }

src/FrostFS.SDK.Tests/Smoke/PoolTests/Multithread/MultithreadSmokeClientTests.cs

@@ -14,8 +14,6 @@ namespace FrostFS.SDK.Tests.Smoke;
 [SuppressMessage("Security", "CA5394:Do not use insecure randomness", Justification = "No secure purpose")]
 public class MultithreadSmokeClientTests : SmokeTestsBase
 {
-    private static readonly PrmWait lightWait = new(100, 1);
-
     [Fact]
     public async void AccountTest()
     {
@@ -103,7 +101,7 @@ public class MultithreadSmokeClientTests : SmokeTestsBase
             PrmWait.DefaultParams,
             xheaders: ["key1", "value1"]);
 
-        var containerId = await client.CreateContainerAsync(createContainerParam, default);
+        var containerId = await client.PutContainerAsync(createContainerParam, default);
 
         var bytes = GetRandomBytes(1024);
 
@@ -147,7 +145,7 @@ public class MultithreadSmokeClientTests : SmokeTestsBase
             new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, 1, [], [], new FrostFsReplica(1))),
             lightWait);
 
-        var containerId = await client.CreateContainerAsync(createContainerParam, default);
+        var containerId = await client.PutContainerAsync(createContainerParam, default);
 
         var bytes = new byte[] { 1, 2, 3 };
 
@@ -241,7 +239,7 @@ public class MultithreadSmokeClientTests : SmokeTestsBase
             PrmWait.DefaultParams,
             xheaders: ["testKey", "testValue"]);
 
-        var createdContainer = await client.CreateContainerAsync(createContainerParam, ctx);
+        var createdContainer = await client.PutContainerAsync(createContainerParam, ctx);
 
         var container = await client.GetContainerAsync(new PrmContainerGet(createdContainer), default);
         Assert.NotNull(container);
@@ -312,7 +310,7 @@ public class MultithreadSmokeClientTests : SmokeTestsBase
             PrmWait.DefaultParams,
             xheaders: ["testKey", "testValue"]);
 
-        var createdContainer = await client.CreateContainerAsync(createContainerParam, default);
+        var createdContainer = await client.PutContainerAsync(createContainerParam, default);
 
         var container = await client.GetContainerAsync(new PrmContainerGet(createdContainer), default);
         Assert.NotNull(container);
@@ -392,7 +390,7 @@ public class MultithreadSmokeClientTests : SmokeTestsBase
             PrmWait.DefaultParams,
             xheaders: ["testKey", "testValue"]);
 
-        var createdContainer = await client.CreateContainerAsync(createContainerParam, default);
+        var createdContainer = await client.PutContainerAsync(createContainerParam, default);
 
         var container = await client.GetContainerAsync(new PrmContainerGet(createdContainer), default);
         Assert.NotNull(container);
@@ -446,7 +444,7 @@ public class MultithreadSmokeClientTests : SmokeTestsBase
             PrmWait.DefaultParams,
             xheaders: ["testKey", "testValue"]);
 
-        var createdContainer = await client.CreateContainerAsync(createContainerParam, default);
+        var createdContainer = await client.PutContainerAsync(createContainerParam, default);
 
         var container = await client.GetContainerAsync(new PrmContainerGet(createdContainer), default);
         Assert.NotNull(container);
@@ -502,7 +500,7 @@ public class MultithreadSmokeClientTests : SmokeTestsBase
             new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, 1, [], [], new FrostFsReplica(1))),
             PrmWait.DefaultParams);
 
-        var container = await client.CreateContainerAsync(createContainerParam, ctx);
+        var container = await client.PutContainerAsync(createContainerParam, ctx);
 
         var containerInfo = await client.GetContainerAsync(new PrmContainerGet(container), ctx);
         Assert.NotNull(containerInfo);
@@ -583,7 +581,7 @@ public class MultithreadSmokeClientTests : SmokeTestsBase
             new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, 1, [], [], new FrostFsReplica(1))),
             lightWait);
 
-        var containerId = await client.CreateContainerAsync(createContainerParam, default);
+        var containerId = await client.PutContainerAsync(createContainerParam, default);
 
         var ctx = new CallContext(TimeSpan.FromSeconds(10));
 
@@ -685,30 +683,4 @@ public class MultithreadSmokeClientTests : SmokeTestsBase
         Assert.Single(result.Addresses);
         Assert.Equal(9, result.Attributes.Count);
     }
-
-    private static byte[] GetRandomBytes(int size)
-    {
-        Random rnd = new();
-        var bytes = new byte[size];
-        rnd.NextBytes(bytes);
-        return bytes;
-    }
-
-    private static IOptions<ClientSettings> GetClientOptions(string key, string url)
-    {
-        return Options.Create(new ClientSettings
-        {
-            Key = key,
-            Host = url
-        });
-    }
-
-
-    static async Task Cleanup(IFrostFSClient client)
-    {
-        await foreach (var cid in client.ListContainersAsync(default, default))
-        {
-            await client.DeleteContainerAsync(new PrmContainerDelete(cid, lightWait), default);
-        }
-    }
 }

src/FrostFS.SDK.Tests/Smoke/PoolTests/PoolSmokeTests.cs

@@ -10,8 +10,6 @@ namespace FrostFS.SDK.Tests.Smoke;
 [SuppressMessage("Security", "CA5394:Do not use insecure randomness", Justification = "No secure purpose")]
 public class PoolSmokeTests : SmokeTestsBase
 {
-    private static readonly PrmWait lightWait = new(100, 1);
-
     private InitParameters GetDefaultParams()
     {
         return new InitParameters((url) => Grpc.Net.Client.GrpcChannel.ForAddress(new Uri(url)))
@@ -168,7 +166,7 @@ public class PoolSmokeTests : SmokeTestsBase
             PrmWait.DefaultParams,
             xheaders: ["key1", "value1"]);
 
-        var containerId = await pool.CreateContainerAsync(createContainerParam, default);
+        var containerId = await pool.PutContainerAsync(createContainerParam, default);
 
         var bytes = GetRandomBytes(1024);
 
@@ -217,7 +215,7 @@ public class PoolSmokeTests : SmokeTestsBase
             new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, 1, [], [], new FrostFsReplica(1))),
             lightWait);
 
-        var containerId = await pool.CreateContainerAsync(createContainerParam, default);
+        var containerId = await pool.PutContainerAsync(createContainerParam, default);
 
         var bytes = new byte[] { 1, 2, 3 };
 
@@ -315,7 +313,7 @@ public class PoolSmokeTests : SmokeTestsBase
             PrmWait.DefaultParams,
             xheaders: ["testKey", "testValue"]);
 
-        var createdContainer = await pool.CreateContainerAsync(createContainerParam, ctx);
+        var createdContainer = await pool.PutContainerAsync(createContainerParam, ctx);
 
         var container = await pool.GetContainerAsync(new PrmContainerGet(createdContainer), default);
         Assert.NotNull(container);
@@ -399,7 +397,7 @@ public class PoolSmokeTests : SmokeTestsBase
             new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, 1, [], [], new FrostFsReplica(1))),
             PrmWait.DefaultParams);
 
-        var container = await pool.CreateContainerAsync(createContainerParam, ctx);
+        var container = await pool.PutContainerAsync(createContainerParam, ctx);
 
         var containerInfo = await pool.GetContainerAsync(new PrmContainerGet(container), ctx);
         Assert.NotNull(containerInfo);
@@ -483,7 +481,7 @@ public class PoolSmokeTests : SmokeTestsBase
             new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, 1, [], [], new FrostFsReplica(1))),
             lightWait);
 
-        var containerId = await pool.CreateContainerAsync(createContainerParam, default);
+        var containerId = await pool.PutContainerAsync(createContainerParam, default);
 
         var ctx = new CallContext(TimeSpan.FromSeconds(10));
 
@@ -545,20 +543,4 @@ public class PoolSmokeTests : SmokeTestsBase
             Assert.Fail($"Container {cid.GetValue()} exist");
         }
     }
-
-    private static byte[] GetRandomBytes(int size)
-    {
-        Random rnd = new();
-        var bytes = new byte[size];
-        rnd.NextBytes(bytes);
-        return bytes;
-    }
-
-    static async Task Cleanup(Pool pool)
-    {
-        await foreach (var cid in pool.ListContainersAsync(default, default))
-        {
-            await pool.DeleteContainerAsync(new PrmContainerDelete(cid, lightWait), default).ConfigureAwait(true);
-        }
-    }
 }

src/FrostFS.SDK.Tests/Smoke/SmokeClientTests.cs

@@ -1,829 +0,0 @@
-using System.Diagnostics.CodeAnalysis;
-using System.Security.Cryptography;
-using System.Security.Cryptography.X509Certificates;
-using System.Text;
-using FrostFS.Refs;
-using FrostFS.SDK.Client;
-using FrostFS.SDK.Client.Interfaces;
-using FrostFS.SDK.Cryptography;
-using FrostFS.SDK.SmokeTests;
-using FrostFS.Session;
-using Google.Protobuf;
-using Microsoft.Extensions.Options;
-
-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 SmokeClientTests : SmokeTestsBase
-{
-    private static readonly PrmWait lightWait = new(100, 1);
-
-    [Fact]
-    public async void AccountTest()
-    {
-        var test = lightWait.Timeout;
-
-        var client = FrostFSClient.GetInstance(ClientOptions, GrpcChannel);
-
-        var result = await client.GetBalanceAsync(default);
-
-        Assert.NotNull(result);
-        Assert.True(result.Value == 0);
-    }
-
-    [Fact]
-    public async void NodeInfoTest()
-    {
-        var client = FrostFSClient.GetInstance(ClientOptions, GrpcChannel);
-
-        var result = await client.GetNodeInfoAsync(default);
-
-        Assert.Equal(2, result.Version.Major);
-        Assert.Equal(13, result.Version.Minor);
-        Assert.Equal(NodeState.Online, result.State);
-        Assert.Equal(33, result.PublicKey.Length);
-        // Assert.Single(result.Addresses);
-        // Assert.Equal(9, result.Attributes.Count);
-    }
-
-    [Fact]
-    public async void NodeInfoStatisticsTest()
-    {
-        var options = ClientOptions;
-
-        var callbackContent = string.Empty;
-        options.Value.Callback = (cs) => callbackContent = $"{cs.MethodName} took {cs.ElapsedMicroSeconds} microseconds";
-
-        var client = FrostFSClient.GetInstance(options, GrpcChannel);
-
-        var result = await client.GetNodeInfoAsync(default);
-
-        Assert.NotEmpty(callbackContent);
-    }
-
-    [Fact]
-    public async void GetSessionTest()
-    {
-        var client = FrostFSClient.GetInstance(ClientOptions, GrpcChannel);
-
-        var token = await client.CreateSessionAsync(new(100), default);
-
-        Assert.NotNull(token);
-        Assert.NotEqual(Guid.Empty, token.Id);
-        Assert.Equal(33, token.SessionKey.Length);
-    }
-
-    [Fact]
-    public async void CreateObjectWithSessionToken()
-    {
-        var client = FrostFSClient.GetInstance(ClientOptions, GrpcChannel);
-
-        await Cleanup(client);
-
-        var token = await client.CreateSessionAsync(new PrmSessionCreate(int.MaxValue), default);
-
-        var createContainerParam = new PrmContainerCreate(
-             new FrostFsContainerInfo(
-                    new FrostFsPlacementPolicy(true, 1, [], [], new FrostFsReplica(3)),
-                    [new FrostFsAttributePair("__SYSTEM__DISABLE_HOMOMORPHIC_HASHING", "true")]),
-            PrmWait.DefaultParams,
-            xheaders: ["key1", "value1"]);
-
-        var containerId = await client.CreateContainerAsync(createContainerParam, default);
-
-        await AddObjectRules(client, containerId);
-
-        var bytes = GetRandomBytes(1024);
-
-        var param = new PrmObjectPut(
-            new FrostFsObjectHeader(
-                containerId: containerId,
-                type: FrostFsObjectType.Regular,
-                [new FrostFsAttributePair("fileName", "test")]),
-            sessionToken: token);
-
-        var stream = await client.PutObjectAsync(param, default).ConfigureAwait(true);
-
-        await stream.WriteAsync(bytes.AsMemory());
-        var objectId = await stream.CompleteAsync();
-
-        var @object = await client.GetObjectAsync(new PrmObjectGet(containerId, objectId), default)
-            .ConfigureAwait(true);
-
-        var downloadedBytes = new byte[@object.Header.PayloadLength];
-        MemoryStream ms = new(downloadedBytes);
-
-        ReadOnlyMemory<byte>? chunk = null;
-        while ((chunk = await @object.ObjectReader!.ReadChunk().ConfigureAwait(true)) != null)
-        {
-            ms.Write(chunk.Value.Span);
-        }
-
-        Assert.Equal(SHA256.HashData(bytes), SHA256.HashData(downloadedBytes));
-
-        await Cleanup(client).ConfigureAwait(true);
-    }
-
-    [Fact]
-    public async void FilterTest()
-    {
-        var client = FrostFSClient.GetInstance(ClientOptions, GrpcChannel);
-
-        await Cleanup(client);
-
-        var createContainerParam = new PrmContainerCreate(
-            new FrostFsContainerInfo(
-                    new FrostFsPlacementPolicy(true, 1, [], [], new FrostFsReplica(3)),
-                    [new FrostFsAttributePair("__SYSTEM__DISABLE_HOMOMORPHIC_HASHING", "true")]),
-           lightWait);
-
-        var containerId = await client.CreateContainerAsync(createContainerParam, default);
-
-        await AddObjectRules(client, containerId);
-
-        var bytes = new byte[] { 1, 2, 3 };
-
-        var param = new PrmObjectPut(
-               new FrostFsObjectHeader(
-                   containerId: containerId,
-                   type: FrostFsObjectType.Regular,
-                   [new FrostFsAttributePair("fileName", "test")],
-                   new FrostFsSplit()));
-
-        var stream = await client.PutObjectAsync(param, default).ConfigureAwait(true);
-
-        await stream.WriteAsync(bytes.AsMemory());
-        var objectId = await stream.CompleteAsync();
-
-        var ecdsaKey = keyString.LoadWif();
-
-        var networkInfo = await client.GetNetmapSnapshotAsync(default);
-
-        await CheckFilter(client, containerId, new FilterByContainerId(FrostFsMatchType.Equals, containerId));
-
-        await CheckFilter(client, containerId, new FilterByOwnerId(FrostFsMatchType.Equals, FrostFsOwner.FromKey(ecdsaKey)));
-
-        await CheckFilter(client, containerId, new FilterBySplitId(FrostFsMatchType.Equals, param.Header!.Split!.SplitId));
-
-        await CheckFilter(client, containerId, new FilterByAttributePair(FrostFsMatchType.Equals, "fileName", "test"));
-
-        await CheckFilter(client, containerId, new FilterByObjectId(FrostFsMatchType.Equals, objectId));
-
-        await CheckFilter(client, containerId, new FilterByVersion(FrostFsMatchType.Equals, networkInfo.NodeInfoCollection[0].Version));
-
-        await CheckFilter(client, containerId, new FilterByEpoch(FrostFsMatchType.Equals, networkInfo.Epoch));
-
-        await CheckFilter(client, containerId, new FilterByPayloadLength(FrostFsMatchType.Equals, 3));
-
-        var checkSum = CheckSum.CreateCheckSum(bytes);
-
-        //   await CheckFilter(client, containerId, new FilterByPayloadHash(FrostFsMatchType.Equals, checkSum));
-
-        await CheckFilter(client, containerId, new FilterByPhysicallyStored());
-    }
-
-    private static async Task CheckFilter(IFrostFSClient client, FrostFsContainerId containerId, IObjectFilter filter)
-    {
-        var resultObjectsCount = 0;
-
-        PrmObjectSearch searchParam = new(containerId, null, [], filter);
-
-        await foreach (var objId in client.SearchObjectsAsync(searchParam, default))
-        {
-            resultObjectsCount++;
-            var objHeader = await client.GetObjectHeadAsync(new PrmObjectHeadGet(containerId, objId), default);
-        }
-
-        Assert.True(0 < resultObjectsCount, $"Filter for {filter.Key} doesn't work");
-    }
-
-    [Theory]
-    [InlineData(1)]
-    [InlineData(3 * 1024 * 1024)]            // exactly one chunk size - 3MB
-    [InlineData(6 * 1024 * 1024 + 100)]
-    public async void SimpleScenarioTest(int objectSize)
-    {
-        bool callbackInvoked = false;
-
-        var options = ClientOptions;
-
-        options.Value.Callback = new((cs) =>
-        {
-            callbackInvoked = true;
-            Assert.True(cs.ElapsedMicroSeconds > 0);
-        });
-
-        var client = FrostFSClient.GetInstance(options, GrpcChannel);
-
-        await Cleanup(client);
-
-        var ctx = new CallContext(TimeSpan.FromSeconds(20));
-
-        var createContainerParam = new PrmContainerCreate(
-            new FrostFsContainerInfo(
-                new FrostFsPlacementPolicy(true, 1, [], [], new FrostFsReplica(3)),
-                [new FrostFsAttributePair("__SYSTEM__DISABLE_HOMOMORPHIC_HASHING", "true")]),
-            PrmWait.DefaultParams,
-            xheaders: ["testKey", "testValue"]);
-
-        var containerId = await client.CreateContainerAsync(createContainerParam, ctx);
-
-        var container = await client.GetContainerAsync(new PrmContainerGet(containerId), default);
-        Assert.NotNull(container);
-        Assert.True(callbackInvoked);
-
-        await AddObjectRules(client, containerId);
-
-        var bytes = GetRandomBytes(objectSize);
-
-        var param = new PrmObjectPut(
-            new FrostFsObjectHeader(
-                containerId: containerId,
-                type: FrostFsObjectType.Regular,
-                [new FrostFsAttributePair("fileName", "test")]));
-
-        var stream = await client.PutObjectAsync(param, default).ConfigureAwait(true);
-
-        await stream.WriteAsync(bytes.AsMemory());
-        var objectId = await stream.CompleteAsync();
-
-        var filter1 = new FilterByOwnerId(FrostFsMatchType.Equals, OwnerId!);
-        await foreach (var objId in client.SearchObjectsAsync(new PrmObjectSearch(containerId, null, [], filter1), default))
-        {
-            var objHeader = await client.GetObjectHeadAsync(new PrmObjectHeadGet(containerId, objectId, false), default);
-        }
-
-        var filter = new FilterByAttributePair(FrostFsMatchType.Equals, "fileName", "test");
-
-        bool hasObject = false;
-        await foreach (var objId in client.SearchObjectsAsync(new PrmObjectSearch(containerId, null, [], filter), default))
-        {
-            hasObject = true;
-
-            var res = await client.GetObjectHeadAsync(new PrmObjectHeadGet(containerId, objectId), default);
-
-            var objHeader = res.HeaderInfo;
-            Assert.NotNull(objHeader);
-            Assert.Equal((ulong)bytes.Length, objHeader.PayloadLength);
-            Assert.NotNull(objHeader.Attributes);
-            Assert.Single(objHeader.Attributes);
-            Assert.Equal("fileName", objHeader.Attributes.First().Key);
-            Assert.Equal("test", objHeader.Attributes.First().Value);
-        }
-
-        Assert.True(hasObject);
-
-        var @object = await client.GetObjectAsync(new PrmObjectGet(containerId, objectId), default);
-
-        var downloadedBytes = new byte[@object.Header.PayloadLength];
-        MemoryStream ms = new(downloadedBytes);
-
-        ReadOnlyMemory<byte>? chunk = null;
-        while ((chunk = await @object.ObjectReader!.ReadChunk()) != null)
-        {
-            ms.Write(chunk.Value.Span);
-        }
-
-        Assert.Equal(SHA256.HashData(bytes), SHA256.HashData(downloadedBytes));
-    }
-
-    [Theory]
-    [InlineData(1)]
-    [InlineData(500 * 1024)]
-    [InlineData(3 * 1024 * 1024)]
-    public async void PutSingleObjectTest(int objectSize)
-    {
-        var options = ClientOptions;
-
-        var client = FrostFSClient.GetInstance(options, GrpcChannel);
-
-        await Cleanup(client);
-
-        var ctx = new CallContext();
-
-        var createContainerParam = new PrmContainerCreate(
-            new FrostFsContainerInfo(
-                new FrostFsPlacementPolicy(true, 1, [], [], new FrostFsReplica(3)),
-                [new FrostFsAttributePair("__SYSTEM__DISABLE_HOMOMORPHIC_HASHING", "true")]),
-            PrmWait.DefaultParams,
-            xheaders: ["testKey1", "testValue1"]);
-
-        var containerId = await client.CreateContainerAsync(createContainerParam, ctx);
-
-        var container = await client.GetContainerAsync(new PrmContainerGet(containerId), default);
-        Assert.NotNull(container);
-     
-        await AddObjectRules(client, containerId);
-
-        var bytes = GetRandomBytes(objectSize);
-
-        var header = new FrostFsObjectHeader(
-                       containerId: containerId,
-                       type: FrostFsObjectType.Regular,
-                       [new FrostFsAttributePair("fileName1", "test1")]);
-
-        var obj = new FrostFsObject(header) { SingleObjectPayload = bytes };
-
-        var param = new PrmSingleObjectPut(obj);
-
-        var objectId = await client.PutSingleObjectAsync(param, default).ConfigureAwait(true);
-
-        var filter = new FilterByAttributePair(FrostFsMatchType.Equals, "fileName1", "test1");
-
-        bool hasObject = false;
-        await foreach (var objId in client.SearchObjectsAsync(new PrmObjectSearch(containerId, null, [], filter), default))
-        {
-            hasObject = true;
-
-            var res = await client.GetObjectHeadAsync(new PrmObjectHeadGet(containerId, objectId), default);
-
-            var objHeader = res.HeaderInfo;
-            Assert.NotNull(objHeader);
-            Assert.Equal((ulong)bytes.Length, objHeader.PayloadLength);
-            Assert.NotNull(objHeader.Attributes);
-            Assert.Single(objHeader.Attributes);
-            Assert.Equal("fileName1", objHeader.Attributes.First().Key);
-            Assert.Equal("test1", objHeader.Attributes.First().Value);
-        }
-
-        Assert.True(hasObject);
-
-        var @object = await client.GetObjectAsync(new PrmObjectGet(containerId, objectId), default);
-
-        var downloadedBytes = new byte[@object.Header.PayloadLength];
-        MemoryStream ms = new(downloadedBytes);
-
-        ReadOnlyMemory<byte>? chunk = null;
-        while ((chunk = await @object.ObjectReader!.ReadChunk()) != null)
-        {
-            ms.Write(chunk.Value.Span);
-        }
-
-        Assert.Equal(SHA256.HashData(bytes), SHA256.HashData(downloadedBytes));
-
-        await Cleanup(client);
-
-        await foreach (var _ in client.ListContainersAsync(default, default))
-        {
-            Assert.Fail("Containers exist");
-        }
-    }
-
-    [Fact]
-    public async void CleanupTest()
-    {
-        var client = FrostFSClient.GetInstance(ClientOptions, GrpcChannel);
-
-        await Cleanup(client);
-    }
-
-    [Fact]
-    public async void PatchTest()
-    {
-        var client = FrostFSClient.GetInstance(ClientOptions, GrpcChannel);
-
-        await Cleanup(client);
-
-        var createContainerParam = new PrmContainerCreate(
-             new FrostFsContainerInfo(
-                    new FrostFsPlacementPolicy(true, 1, [], [], new FrostFsReplica(1)),
-                    [new FrostFsAttributePair("__SYSTEM__DISABLE_HOMOMORPHIC_HASHING", "true")]),
-            PrmWait.DefaultParams,
-            xheaders: ["testKey", "testValue"]);
-
-        var containerId = await client.CreateContainerAsync(createContainerParam, default);
-
-        var container = await client.GetContainerAsync(new PrmContainerGet(containerId), default);
-        Assert.NotNull(container);
-
-        await AddObjectRules(client, containerId);
-
-        var bytes = new byte[1024];
-        for (int i = 0; i < 1024; i++)
-        {
-            bytes[i] = 31;
-        }
-
-        var param = new PrmObjectPut(
-            new FrostFsObjectHeader(
-                containerId: containerId,
-                type: FrostFsObjectType.Regular,
-                [new FrostFsAttributePair("fileName", "test")]));
-
-        var stream = await client.PutObjectAsync(param, default).ConfigureAwait(true);
-
-        await stream.WriteAsync(bytes.AsMemory());
-        var objectId = await stream.CompleteAsync();
-
-        var patch = new byte[256];
-        for (int i = 0; i < patch.Length; i++)
-        {
-            patch[i] = 32;
-        }
-
-        var range = new FrostFsRange(64, (ulong)patch.Length);
-
-        var patchParams = new PrmObjectPatch(
-            new FrostFsAddress(containerId, objectId),
-            payload: new MemoryStream(patch),
-            maxChunkLength: 256,
-            range: range);
-
-        var newIbjId = await client.PatchObjectAsync(patchParams, default);
-
-        var @object = await client.GetObjectAsync(new PrmObjectGet(containerId, newIbjId), default);
-
-        var downloadedBytes = new byte[@object.Header.PayloadLength];
-        MemoryStream ms = new(downloadedBytes);
-
-        ReadOnlyMemory<byte>? chunk = null;
-        while ((chunk = await @object.ObjectReader!.ReadChunk()) != null)
-        {
-            ms.Write(chunk.Value.Span);
-        }
-
-        for (int i = 0; i < (int)range.Offset; i++)
-            Assert.Equal(downloadedBytes[i], bytes[i]);
-
-        var rangeEnd = range.Offset + range.Length;
-
-        for (int i = (int)range.Offset; i < (int)rangeEnd; i++)
-            Assert.Equal(downloadedBytes[i], patch[i - (int)range.Offset]);
-
-        for (int i = (int)rangeEnd; i < bytes.Length; i++)
-            Assert.Equal(downloadedBytes[i], bytes[i]);
-
-        await Cleanup(client);
-
-        await foreach (var _ in client.ListContainersAsync(default, default))
-        {
-            Assert.Fail("Containers exist");
-        }
-    }
-
-    [Fact]
-    public async void RangeTest()
-    {
-        var client = FrostFSClient.GetInstance(ClientOptions, GrpcChannel);
-
-        await Cleanup(client);
-
-        var createContainerParam = new PrmContainerCreate(
-             new FrostFsContainerInfo(
-                    new FrostFsPlacementPolicy(true, 1, [], [], new FrostFsReplica(3)),
-                    [new FrostFsAttributePair("__SYSTEM__DISABLE_HOMOMORPHIC_HASHING", "true")]),
-            PrmWait.DefaultParams,
-            xheaders: ["testKey", "testValue"]);
-
-        var containerId = await client.CreateContainerAsync(createContainerParam, default);
-
-        var container = await client.GetContainerAsync(new PrmContainerGet(containerId), default);
-        Assert.NotNull(container);
-
-        await AddObjectRules(client, containerId);
-
-        var bytes = new byte[256];
-        for (int i = 0; i < 256; i++)
-        {
-            bytes[i] = (byte)i;
-        }
-
-        var param = new PrmObjectPut(
-            new FrostFsObjectHeader(
-                containerId: containerId,
-                type: FrostFsObjectType.Regular));
-
-        var stream = await client.PutObjectAsync(param, default).ConfigureAwait(true);
-
-        await stream.WriteAsync(bytes.AsMemory());
-        var objectId = await stream.CompleteAsync();
-
-        var rangeParam = new PrmRangeGet(containerId, objectId, new FrostFsRange(50, 100));
-
-        var rangeReader = await client.GetRangeAsync(rangeParam, default);
-
-        var downloadedBytes = new byte[rangeParam.Range.Length];
-        MemoryStream ms = new(downloadedBytes);
-
-        ReadOnlyMemory<byte>? chunk;
-        while ((chunk = await rangeReader!.ReadChunk()) != null)
-        {
-            ms.Write(chunk.Value.Span);
-        }
-
-        Assert.Equal(SHA256.HashData(bytes.AsSpan().Slice(50, 100)), SHA256.HashData(downloadedBytes));
-    }
-
-    [Fact]
-    public async void RangeHashTest()
-    {
-        var client = FrostFSClient.GetInstance(ClientOptions, GrpcChannel);
-
-        await Cleanup(client);
-
-        var createContainerParam = new PrmContainerCreate(
-             new FrostFsContainerInfo(
-                    new FrostFsPlacementPolicy(true, 1, [], [], new FrostFsReplica(3)),
-                    [new FrostFsAttributePair("__SYSTEM__DISABLE_HOMOMORPHIC_HASHING", "true")]),
-            PrmWait.DefaultParams,
-            xheaders: ["testKey", "testValue"]);
-
-        var containerId = await client.CreateContainerAsync(createContainerParam, default);
-
-        var container = await client.GetContainerAsync(new PrmContainerGet(containerId), default);
-        Assert.NotNull(container);
-
-        await AddObjectRules(client, containerId);
-
-        var bytes = new byte[256];
-        for (int i = 0; i < 256; i++)
-        {
-            bytes[i] = (byte)i;
-        }
-
-        var param = new PrmObjectPut(
-            new FrostFsObjectHeader(
-                containerId: containerId,
-                type: FrostFsObjectType.Regular));
-
-        var stream = await client.PutObjectAsync(param, default).ConfigureAwait(true);
-
-        await stream.WriteAsync(bytes.AsMemory());
-        var objectId = await stream.CompleteAsync();
-
-        var rangeParam = new PrmRangeHashGet(containerId, objectId, [new FrostFsRange(100, 64)], bytes);
-
-        var hashes = await client.GetRangeHashAsync(rangeParam, default);
-
-        foreach (var hash in hashes)
-        {
-            var x = hash[..32].ToArray();
-            Assert.NotNull(x);
-            Assert.True(x.Length > 0);
-        }
-    }
-
-    [Theory]
-    [InlineData(1)]
-    [InlineData(3 * 1024 * 1024)]            // exactly one chunk size - 3MB
-    [InlineData(6 * 1024 * 1024 + 100)]
-    public async void SimpleScenarioWithSessionTest(int objectSize)
-    {
-        var client = FrostFSClient.GetInstance(ClientOptions, GrpcChannel);
-     
-        var token = await client.CreateSessionAsync(new PrmSessionCreate(int.MaxValue), default);
-
-        await Cleanup(client);
-
-        var ctx = new CallContext(TimeSpan.FromSeconds(20));
-
-        var createContainerParam = new PrmContainerCreate(
-             new FrostFsContainerInfo(
-                    new FrostFsPlacementPolicy(true, 1, [], [], new FrostFsReplica(3)),
-                    [new FrostFsAttributePair("__SYSTEM__DISABLE_HOMOMORPHIC_HASHING", "true")]),
-            PrmWait.DefaultParams);
-
-        var container = await client.CreateContainerAsync(createContainerParam, ctx);
-
-        var containerInfo = await client.GetContainerAsync(new PrmContainerGet(container), ctx);
-        Assert.NotNull(containerInfo);
-
-        await AddObjectRules(client, container);
-
-        var bytes = GetRandomBytes(objectSize);
-
-        var param = new PrmObjectPut(
-            new FrostFsObjectHeader(
-                containerId: container,
-                type: FrostFsObjectType.Regular,
-                [new FrostFsAttributePair("fileName", "test")]),
-            sessionToken: token);
-
-        var stream = await client.PutObjectAsync(param, default).ConfigureAwait(true);
-
-        await stream.WriteAsync(bytes.AsMemory());
-        var objectId = await stream.CompleteAsync();
-
-        var filter = new FilterByAttributePair(FrostFsMatchType.Equals, "fileName", "test");
-
-        bool hasObject = false;
-        await foreach (var objId in client.SearchObjectsAsync(new PrmObjectSearch(container, token, [], filter), default))
-        {
-            hasObject = true;
-
-            var res = await client.GetObjectHeadAsync(new PrmObjectHeadGet(container, objectId, false, token), default);
-
-            var objHeader = res.HeaderInfo;
-            Assert.NotNull(objHeader);
-            Assert.Equal((ulong)bytes.Length, objHeader.PayloadLength);
-            Assert.NotNull(objHeader.Attributes);
-            Assert.Single(objHeader.Attributes);
-            Assert.Equal("fileName", objHeader.Attributes.First().Key);
-            Assert.Equal("test", objHeader.Attributes.First().Value);
-        }
-
-        Assert.True(hasObject);
-
-        var @object = await client.GetObjectAsync(new PrmObjectGet(container, objectId, token), default);
-
-        var downloadedBytes = new byte[@object.Header.PayloadLength];
-        MemoryStream ms = new(downloadedBytes);
-
-        ReadOnlyMemory<byte>? chunk = null;
-        while ((chunk = await @object.ObjectReader!.ReadChunk()) != null)
-        {
-            ms.Write(chunk.Value.Span);
-        }
-
-        Assert.Equal(SHA256.HashData(bytes), SHA256.HashData(downloadedBytes));
-
-        await Cleanup(client);
-
-        await foreach (var _ in client.ListContainersAsync(default, default))
-        {
-            Assert.Fail("Containers exist");
-        }
-    }
-
-    [Fact]
-    public async void ClientCutScenarioTest()
-    {
-        var options = ClientOptions;
-        options.Value.Interceptors.Add(new CallbackInterceptor());
-
-        var client = FrostFSClient.GetInstance(options, GrpcChannel);
-
-        await Cleanup(client);
-
-        int[] replicas = [3]; //1
-
-        foreach (var rep in replicas)
-        {
-            var createContainerParam = new PrmContainerCreate(
-                 new FrostFsContainerInfo(
-                        new FrostFsPlacementPolicy(true, 1, [], [], new FrostFsReplica(rep)),
-                        [new FrostFsAttributePair("__SYSTEM__DISABLE_HOMOMORPHIC_HASHING", "true")]),
-                lightWait);
-
-            var containerId = await client.CreateContainerAsync(createContainerParam, default);
-
-            var ctx = new CallContext(TimeSpan.FromSeconds(10));
-
-            var container = await client.GetContainerAsync(new PrmContainerGet(containerId), ctx);
-
-            Assert.NotNull(container);
-
-            await AddObjectRules(client, containerId);
-           
-            var mb = 1024 * 1024;
-
-            int[] objectSizes = [1, 1024, 64 * mb + 1];  //64 * mb, 64 * mb - 1, , 2 * 64 * mb + 256];
-
-            foreach (var objectSize in objectSizes)
-            {
-                byte[] bytes = GetRandomBytes(objectSize);
-
-                var param = new PrmObjectClientCutPut(
-                    new FrostFsObjectHeader(
-                        containerId: containerId,
-                        type: FrostFsObjectType.Regular,
-                        [new FrostFsAttributePair("fileName", "test")]),
-                    payload: new MemoryStream(bytes));
-
-                var objectId = await client.PutClientCutObjectAsync(param, default).ConfigureAwait(true);
-
-                var @object = await client.GetObjectAsync(new PrmObjectGet(containerId, objectId), default);
-
-                var downloadedBytes = new byte[@object.Header.PayloadLength];
-                MemoryStream ms = new(downloadedBytes);
-
-                ReadOnlyMemory<byte>? chunk = null;
-                while ((chunk = await @object.ObjectReader!.ReadChunk()) != null)
-                {
-                    ms.Write(chunk.Value.Span);
-                }
-
-                Assert.Equal(SHA256.HashData(bytes), SHA256.HashData(downloadedBytes));
-            }
-        }
-    }
-
-    [Fact]
-    public async void NodeInfoCallbackAndInterceptorTest()
-    {
-        bool callbackInvoked = false;
-        bool interceptorInvoked = false;
-
-        var options = ClientOptions;
-        options.Value.Callback = (cs) =>
-        {
-            callbackInvoked = true;
-            Assert.True(cs.ElapsedMicroSeconds > 0);
-        };
-
-        options.Value.Interceptors.Add(new CallbackInterceptor(s => interceptorInvoked = true));
-
-        var client = FrostFSClient.GetInstance(options, GrpcChannel);
-
-        var result = await client.GetNodeInfoAsync(default);
-
-        Assert.True(callbackInvoked);
-        Assert.True(interceptorInvoked);
-
-        Assert.Equal(2, result.Version.Major);
-        Assert.Equal(13, result.Version.Minor);
-        Assert.Equal(NodeState.Online, result.State);
-        Assert.Equal(33, result.PublicKey.Length);
-        Assert.NotNull(result.Addresses);
-        Assert.True(result.Attributes.Count > 0);
-    }
-
-    private static byte[] GetRandomBytes(int size)
-    {
-        Random rnd = new();
-        var bytes = new byte[size];
-        rnd.NextBytes(bytes);
-        return bytes;
-    }
-
-    private static IOptions<ClientSettings> GetClientOptions(string key, string url)
-    {
-        return Options.Create(new ClientSettings
-        {
-            Key = key,
-            Host = url
-        });
-    }
-
-    static async Task Cleanup(IFrostFSClient client)
-    {
-        await foreach (var cid in client.ListContainersAsync(default, default))
-        {
-            await client.DeleteContainerAsync(new PrmContainerDelete(cid, lightWait), default);
-        }
-    }
-
-    private static async Task AddContainerRules(IFrostFSClient client, FrostFsContainerId containerId)
-    {
-        var addChainPrm = new PrmApeChainAdd(
-           new FrostFsChainTarget(FrostFsTargetType.Container, containerId.GetValue()),
-           new FrostFsChain
-           {
-               ID = Encoding.ASCII.GetBytes("chain-id-test1"),
-               Rules = [
-                    new FrostFsRule
-                        {
-                            Status = RuleStatus.Allow,
-                            Actions = new Actions(inverted: false, names: ["*"]),
-                            Resources = new Resource (inverted: false, names: [$"native:container/*"]),
-                            Any = false,
-                            Conditions = []
-                        }
-               ],
-               MatchType = RuleMatchType.DenyPriority
-           }
-       );
-
-        await client.AddChainAsync(addChainPrm, default);
-
-        var listChainPrm = new PrmApeChainList(new FrostFsChainTarget(FrostFsTargetType.Container, containerId.GetValue()));
-
-        while (true)
-        {
-            await Task.Delay(1000);
-            var chains = await client.ListChainAsync(listChainPrm, default);
-
-            if (chains.Length > 0)
-                break;
-        }
-
-        await Task.Delay(8000);
-    }
-
-    private static async Task AddObjectRules(IFrostFSClient client, FrostFsContainerId containerId)
-    {
-        var addChainPrm = new PrmApeChainAdd(
-           new FrostFsChainTarget(FrostFsTargetType.Container, containerId.GetValue()),
-           new FrostFsChain
-           {
-               ID = Encoding.ASCII.GetBytes("chain-id-test"),
-               Rules = [
-                    new FrostFsRule
-                        {
-                            Status = RuleStatus.Allow,
-                            Actions = new Actions(inverted: false, names: ["*"]),
-                            Resources = new Resource (inverted: false, names: [$"native:object/*"]),
-                            Any = false,
-                            Conditions = []
-                        }
-               ],
-               MatchType = RuleMatchType.DenyPriority
-           }
-       );
-
-        await client.AddChainAsync(addChainPrm, default);
-
-        await Task.Delay(8000);
-    }
-}

src/FrostFS.SDK.Tests/Smoke/SmokeTestsBase.cs

@@ -1,28 +1,34 @@
-using System.Security.Cryptography;
+using System.Collections.ObjectModel;
-
+using System.Diagnostics.CodeAnalysis;
+using System.Security.Cryptography;
+using System.Security.Principal;
+using System.Text;
 using FrostFS.SDK.Client;
+using FrostFS.SDK.Client.Interfaces;
 using FrostFS.SDK.Cryptography;
 
 using Grpc.Core;
 
 using Microsoft.Extensions.Options;
+using Xunit.Abstractions;
 
 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 abstract class SmokeTestsBase
 {
     // cluster Ori
-    internal readonly string url = "http://10.78.128.207:8080";
+    // internal readonly string url = "http://10.78.128.207:8080";
-    internal readonly string keyString = "L4JWLdedUd4b21sriRHtCPGkjG2Mryz2AWLiVqTBSNyxxyAUcc7s";
+    // internal readonly string keyString = "L4JWLdedUd4b21sriRHtCPGkjG2Mryz2AWLiVqTBSNyxxyAUcc7s";
-
 
     // cluster
-    // internal readonly string url = "http://10.78.128.190:8080";
+    internal readonly string url = "http://10.78.128.190:8080";
-    // internal readonly string keyString = "L47c3bunc6bJd7uEAfPUae2VkyupFR9nizoH6jfPonzQxijqH2Ba";
+    internal readonly string keyString = "L47c3bunc6bJd7uEAfPUae2VkyupFR9nizoH6jfPonzQxijqH2Ba";
 
     // WSL2
-    //internal readonly string url = "http://172.29.238.97:8080";
+    // internal readonly string url = "http://172.29.238.97:8080";
-    //internal readonly string keyString = "KzPXA6669m2pf18XmUdoR8MnP1pi1PMmefiFujStVFnv7WR5SRmK";
+    // internal readonly string keyString = "KwHDAJ66o8FoLBjVbjP2sWBmgBMGjt7Vv4boA7xQrBoAYBE397Aq"; // "KzPXA6669m2pf18XmUdoR8MnP1pi1PMmefiFujStVFnv7WR5SRmK";
 
     //"KwHDAJ66o8FoLBjVbjP2sWBmgBMGjt7Vv4boA7xQrBoAYBE397Aq";
 
@@ -44,4 +50,88 @@ public abstract class SmokeTestsBase
     protected static Func<string, ChannelBase> GrpcChannel => (url) => Grpc.Net.Client.GrpcChannel.ForAddress(new Uri(url));
 
     protected IOptions<ClientSettings> ClientOptions => Options.Create(new ClientSettings { Key = keyString, Host = url });
+
+    protected static readonly PrmWait lightWait = new(100, 1);
+
+    protected static byte[] GetRandomBytes(int size)
+    {
+        Random rnd = new();
+        var bytes = new byte[size];
+        rnd.NextBytes(bytes);
+        return bytes;
+    }
+
+    protected static async Task<FrostFsContainerId> CreateContainer(IFrostFSClient client,
+        CallContext ctx,
+        FrostFsSessionToken? token,
+        bool unique,
+        uint backupFactor,
+        Collection<FrostFsSelector> selectors,
+        Collection<FrostFsFilter> filter,
+        Collection<FrostFsAttributePair> containerAttributes,
+        params FrostFsReplica[] replicas)
+    {
+        ArgumentNullException.ThrowIfNull(client);
+
+        var networkSettings = await client.GetNetworkSettingsAsync(ctx);
+
+        var attributes = containerAttributes ?? [];
+
+        if (networkSettings.HomomorphicHashingDisabled)
+            attributes.Add(new("__SYSTEM__DISABLE_HOMOMORPHIC_HASHING", "true"));
+        
+        var containerInfo = new FrostFsContainerInfo(
+            new FrostFsPlacementPolicy(unique, backupFactor, selectors, filter, replicas),
+            [.. attributes]);
+
+        var createContainerParam = new PrmContainerCreate(
+            containerInfo,
+            PrmWait.DefaultParams,
+            token,
+            xheaders: ["key1", "value1"]);
+
+        return await client.PutContainerAsync(createContainerParam, ctx);
+    }
+
+    protected static async Task Cleanup(IFrostFSClient client)
+    {
+        ArgumentNullException.ThrowIfNull(client);
+
+        var tasks = new List<Task>();
+        await foreach (var cid in client.ListContainersAsync(default, default))
+        {
+            tasks.Add(client.DeleteContainerAsync(new PrmContainerDelete(cid, lightWait), default));
+        }
+
+        await Task.WhenAll(tasks);
+    }
+
+    protected static async Task AddObjectRules(IFrostFSClient client, FrostFsContainerId containerId)
+    {
+        ArgumentNullException.ThrowIfNull(client);
+        ArgumentNullException.ThrowIfNull(containerId);
+
+        var addChainPrm = new PrmApeChainAdd(
+           new FrostFsChainTarget(FrostFsTargetType.Container, containerId.GetValue()),
+           new FrostFsChain
+           {
+               ID = Encoding.ASCII.GetBytes("chain-id-test"),
+               Rules = [
+                    new FrostFsRule
+                        {
+                            Status = RuleStatus.Allow,
+                            Actions = new Actions(inverted: false, names: ["*"]),
+                            Resources = new Resource (inverted: false, names: [$"native:object/*"]),
+                            Any = false,
+                            Conditions = []
+                        }
+               ],
+               MatchType = RuleMatchType.DenyPriority
+           }
+       );
+
+        await client.AddChainAsync(addChainPrm, default);
+
+        await Task.Delay(8000);
+    }
 }

src/FrostFS.SDK.Tests/Unit/ContainerTest.cs

@@ -16,7 +16,7 @@ public class ContainerTest : ContainerTestsBase
     {
         var param = new PrmContainerCreate(new FrostFsContainerInfo(Mocker.PlacementPolicy), PrmWait.DefaultParams);
 
-        var result = await GetClient().CreateContainerAsync(param, default);
+        var result = await GetClient().PutContainerAsync(param, default);
 
         Assert.NotNull(result);
         Assert.NotNull(result.GetValue());