[#28] Clients: Make immutable parameters

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

src/FrostFS.SDK.Tests/GlobalSuppressions.cs

@@ -1,6 +0,0 @@
-// This file is used by Code Analysis to maintain SuppressMessage
-// attributes that are applied to this project.
-// Project-level suppressions either have no target or are given
-// a specific target and scoped to a namespace, type, member, etc.
-
-

src/FrostFS.SDK.Tests/Multithread/MultiThreadTestsBase.cs

@@ -0,0 +1,42 @@
+using System.Security.Cryptography;
+
+using FrostFS.SDK.Client;
+using FrostFS.SDK.Cryptography;
+
+namespace FrostFS.SDK.Tests.Smoke;
+
+public abstract class MultiThreadTestsBase
+{
+    private TestNodeInfo[] nodes;
+
+    protected CallContext? Ctx { get; }
+
+    protected MultiThreadTestsBase()
+    {
+        nodes = new TestNodeInfo[4];
+
+        nodes[0] = new(new Uri(""), "");
+        nodes[1] = new(new Uri(""), "");
+        nodes[2] = new(new Uri(""), "");
+        nodes[3] = new(new Uri(""), "");
+    }
+}
+
+public class TestNodeInfo
+{
+    internal Uri Uri;
+
+    protected ECDsa? Key { get; }
+
+    protected FrostFsOwner? OwnerId { get; }
+
+    protected FrostFsVersion? Version { get; }
+
+    public TestNodeInfo(Uri uri, string keyString)
+    {
+        Uri = uri;
+        Key = keyString.LoadWif();
+        OwnerId = FrostFsOwner.FromKey(Key);
+        Version = new FrostFsVersion(2, 13);
+    }
+}

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

@@ -6,11 +6,11 @@ using FrostFS.SDK.Cryptography;
 
 using Microsoft.Extensions.Options;
 
-namespace 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 PoolSmokeTests : SmokeTestsBase
+public class MultithreadPoolSmokeTests : SmokeTestsBase
 {
     private static readonly PrmWait lightWait = new(100, 1);
 
@@ -20,7 +20,7 @@ public class PoolSmokeTests : SmokeTestsBase
         {
             Key = keyString.LoadWif(),
 
-            NodeParams = [new(1, this.url, 100.0f)],
+            NodeParams = [new(1, url, 100.0f)],
             ClientBuilder = null,
             GracefulCloseOnSwitchTimeout = 30_000_000,
             Logger = null
@@ -34,7 +34,7 @@ public class PoolSmokeTests : SmokeTestsBase
 
         using var pool = new Pool(options);
 
-        var error = await pool.Dial(new CallContext());
+        var error = await pool.Dial(new CallContext(TimeSpan.Zero));
 
         Assert.Null(error);
 
@@ -59,11 +59,11 @@ public class PoolSmokeTests : SmokeTestsBase
 
         using var pool = new Pool(options);
 
-        var error = await pool.Dial(new CallContext());
+        var error = await pool.Dial(new CallContext(TimeSpan.Zero));
 
         Assert.Null(error);
 
-        var result = await pool.GetNodeInfoAsync();
+        var result = await pool.GetNodeInfoAsync(default);
 
         Assert.Equal(2, result.Version.Major);
         Assert.Equal(13, result.Version.Minor);
@@ -82,8 +82,8 @@ public class PoolSmokeTests : SmokeTestsBase
         {
             Key = keyString.LoadWif(),
             NodeParams = [
-                new(1, this.url, 100.0f),
-                new(2, this.url.Replace('0', '1'), 100.0f)
+                new(1, url, 100.0f),
+                new(2, url.Replace('0', '1'), 100.0f)
                 ],
             ClientBuilder = null,
             GracefulCloseOnSwitchTimeout = 30_000_000,
@@ -93,17 +93,15 @@ public class PoolSmokeTests : SmokeTestsBase
 
         using var pool = new Pool(options);
 
-        var ctx = new CallContext
-        {
-        };
+        var ctx = new CallContext(TimeSpan.Zero);
 
         var error = await pool.Dial(ctx).ConfigureAwait(true);
 
         Assert.Null(error);
 
-        using var client = FrostFSClient.GetSingleOwnerInstance(GetSingleOwnerOptions(this.keyString, this.url));
+        using var client = FrostFSClient.GetInstance(GetSingleOwnerOptions(keyString, url));
 
-        var result = await client.GetNodeInfoAsync();
+        var result = await client.GetNodeInfoAsync(default);
 
         var statistics = pool.Statistic();
 
@@ -121,15 +119,15 @@ public class PoolSmokeTests : SmokeTestsBase
 
         using var pool = new Pool(options);
 
-        var ctx = new CallContext();
+        var ctx = new CallContext(TimeSpan.Zero);
 
         var error = await pool.Dial(ctx).ConfigureAwait(true);
 
         Assert.Null(error);
 
-        using var client = FrostFSClient.GetSingleOwnerInstance(GetSingleOwnerOptions(this.keyString, this.url));
+        using var client = FrostFSClient.GetInstance(GetSingleOwnerOptions(keyString, url));
 
-        var result = await client.GetNodeInfoAsync();
+        var result = await client.GetNodeInfoAsync(default);
 
         Assert.False(string.IsNullOrEmpty(callbackText));
         Assert.Contains(" took ", callbackText, StringComparison.Ordinal);
@@ -142,13 +140,13 @@ public class PoolSmokeTests : SmokeTestsBase
 
         using var pool = new Pool(options);
 
-        var error = await pool.Dial(new CallContext()).ConfigureAwait(true);
+        var error = await pool.Dial(new CallContext(TimeSpan.Zero)).ConfigureAwait(true);
 
         Assert.Null(error);
 
         var prm = new PrmSessionCreate(100);
 
-        var token = await pool.CreateSessionAsync(prm).ConfigureAwait(true);
+        var token = await pool.CreateSessionAsync(prm, default).ConfigureAwait(true);
 
         var ownerHash = Base58.Decode(OwnerId!.Value);
 
@@ -164,37 +162,36 @@ public class PoolSmokeTests : SmokeTestsBase
 
         using var pool = new Pool(options);
 
-        var error = await pool.Dial(new CallContext()).ConfigureAwait(true);
+        var error = await pool.Dial(new CallContext(TimeSpan.Zero)).ConfigureAwait(true);
 
         Assert.Null(error);
 
         await Cleanup(pool);
 
-        var token = await pool.CreateSessionAsync(new PrmSessionCreate(int.MaxValue));
+        var token = await pool.CreateSessionAsync(new PrmSessionCreate(int.MaxValue), default);
 
         var createContainerParam = new PrmContainerCreate(
-            new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))));
+            new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))),
+            PrmWait.DefaultParams,
+            xheaders: ["key1", "value1"]);
 
-        createContainerParam.XHeaders.Add("key1", "value1");
-
-        var containerId = await pool.CreateContainerAsync(createContainerParam);
+        var containerId = await pool.CreateContainerAsync(createContainerParam, default);
 
         var bytes = GetRandomBytes(1024);
 
-        var param = new PrmObjectPut
-        {
-            Header = new FrostFsObjectHeader(
+        var param = new PrmObjectPut(
+            new FrostFsObjectHeader(
                 containerId: containerId,
                 type: FrostFsObjectType.Regular,
                 [new FrostFsAttributePair("fileName", "test")]),
-            Payload = new MemoryStream(bytes),
-            ClientCut = false,
-            SessionToken = token
-        };
+            bufferMaxSize: 1024,
+            payload: new MemoryStream(bytes),
+            clientCut: false,
+            sessionToken: token);
 
-        var objectId = await pool.PutObjectAsync(param).ConfigureAwait(true);
+        var objectId = await pool.PutObjectAsync(param, default).ConfigureAwait(true);
 
-        var @object = await pool.GetObjectAsync(new PrmObjectGet(containerId, objectId));
+        var @object = await pool.GetObjectAsync(new PrmObjectGet(containerId, objectId), default);
 
         var downloadedBytes = new byte[@object.Header.PayloadLength];
         MemoryStream ms = new(downloadedBytes);
@@ -217,19 +214,17 @@ public class PoolSmokeTests : SmokeTestsBase
 
         using var pool = new Pool(options);
 
-        var error = await pool.Dial(new CallContext()).ConfigureAwait(true);
+        var error = await pool.Dial(new CallContext(TimeSpan.Zero)).ConfigureAwait(true);
 
         Assert.Null(error);
 
         await Cleanup(pool);
 
         var createContainerParam = new PrmContainerCreate(
-           new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))))
-        {
-            WaitParams = lightWait
-        };
+           new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))),
+           lightWait);
 
-        var containerId = await pool.CreateContainerAsync(createContainerParam);
+        var containerId = await pool.CreateContainerAsync(createContainerParam, default);
 
         var bytes = new byte[] { 1, 2, 3 };
 
@@ -240,30 +235,28 @@ public class PoolSmokeTests : SmokeTestsBase
             PayloadLength = 3
         };
 
-        var param = new PrmObjectPut
-        {
-            Header = new FrostFsObjectHeader(
+        var param = new PrmObjectPut(
+            new FrostFsObjectHeader(
                 containerId: containerId,
                 type: FrostFsObjectType.Regular,
                 [new FrostFsAttributePair("fileName", "test")],
                 new FrostFsSplit()),
-            Payload = new MemoryStream(bytes),
-            ClientCut = false
-        };
+            payload: new MemoryStream(bytes),
+            clientCut: false);
 
-        var objectId = await pool.PutObjectAsync(param);
+        var objectId = await pool.PutObjectAsync(param, default);
 
-        var head = await pool.GetObjectHeadAsync(new PrmObjectHeadGet(containerId, objectId));
+        var head = await pool.GetObjectHeadAsync(new PrmObjectHeadGet(containerId, objectId, false), default);
 
-        var ecdsaKey = this.keyString.LoadWif();
+        var ecdsaKey = keyString.LoadWif();
 
-        var networkInfo = await pool.GetNetmapSnapshotAsync();
+        var networkInfo = await pool.GetNetmapSnapshotAsync(default);
 
         await CheckFilter(pool, containerId, new FilterByContainerId(FrostFsMatchType.Equals, containerId));
 
         await CheckFilter(pool, containerId, new FilterByOwnerId(FrostFsMatchType.Equals, FrostFsOwner.FromKey(ecdsaKey)));
 
-        await CheckFilter(pool, containerId, new FilterBySplitId(FrostFsMatchType.Equals, param.Header.Split!.SplitId));
+        await CheckFilter(pool, containerId, new FilterBySplitId(FrostFsMatchType.Equals, param.Header!.Split!.SplitId));
 
         await CheckFilter(pool, containerId, new FilterByAttributePair(FrostFsMatchType.Equals, "fileName", "test"));
 
@@ -286,12 +279,12 @@ public class PoolSmokeTests : SmokeTestsBase
     {
         var resultObjectsCount = 0;
 
-        PrmObjectSearch searchParam = new(containerId) { Filters = [filter] };
+        PrmObjectSearch searchParam = new(containerId, null, [], filter);
 
-        await foreach (var objId in pool.SearchObjectsAsync(searchParam))
+        await foreach (var objId in pool.SearchObjectsAsync(searchParam, default))
         {
             resultObjectsCount++;
-            var objHeader = await pool.GetObjectHeadAsync(new PrmObjectHeadGet(containerId, objId));
+            var objHeader = await pool.GetObjectHeadAsync(new PrmObjectHeadGet(containerId, objId), default);
         }
 
         Assert.True(0 < resultObjectsCount, $"Filter for {filter.Key} doesn't work");
@@ -307,7 +300,7 @@ public class PoolSmokeTests : SmokeTestsBase
 
         var options = GetDefaultParams();
 
-        options.Callback = new((CallStatistics cs) =>
+        options.Callback = new((cs) =>
         {
             callbackInvoked = true;
             Assert.True(cs.ElapsedMicroSeconds > 0);
@@ -315,45 +308,45 @@ public class PoolSmokeTests : SmokeTestsBase
 
         using var pool = new Pool(options);
 
-        var error = await pool.Dial(new CallContext()).ConfigureAwait(true);
+        var error = await pool.Dial(new CallContext(TimeSpan.Zero)).ConfigureAwait(true);
 
         Assert.Null(error);
 
         await Cleanup(pool);
 
-        var ctx = new CallContext { };
-
         var createContainerParam = new PrmContainerCreate(
-            new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1)), [new("testKey", "testValue")]), ctx);
+            new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))),
+            PrmWait.DefaultParams,
+            xheaders: ["testKey", "testValue"]);
 
-        var createdContainer = await pool.CreateContainerAsync(createContainerParam);
+        var createdContainer = await pool.CreateContainerAsync(createContainerParam, default);
 
-        var container = await pool.GetContainerAsync(new PrmContainerGet(createdContainer));
+        var container = await pool.GetContainerAsync(new PrmContainerGet(createdContainer), default);
         Assert.NotNull(container);
         Assert.True(callbackInvoked);
 
         var bytes = GetRandomBytes(objectSize);
 
-        var param = new PrmObjectPut()
-        {
-            Header = new FrostFsObjectHeader(
+        var param = new PrmObjectPut(
+            new FrostFsObjectHeader(
                 containerId: createdContainer,
                 type: FrostFsObjectType.Regular,
                 [new FrostFsAttributePair("fileName", "test")]),
-            Payload = new MemoryStream(bytes),
-            ClientCut = false
-        };
+            payload: new MemoryStream(bytes),
+            clientCut: false);
 
-        var objectId = await pool.PutObjectAsync(param);
+        var objectId = await pool.PutObjectAsync(param, default);
 
         var filter = new FilterByAttributePair(FrostFsMatchType.Equals, "fileName", "test");
 
         bool hasObject = false;
-        await foreach (var objId in pool.SearchObjectsAsync(new PrmObjectSearch(createdContainer) { Filters = [filter] }))
+        await foreach (var objId in pool.SearchObjectsAsync(new PrmObjectSearch(createdContainer, null, [], filter), default))
         {
             hasObject = true;
 
-            var objHeader = await pool.GetObjectHeadAsync(new PrmObjectHeadGet(createdContainer, objectId));
+            var res = await pool.GetObjectHeadAsync(new PrmObjectHeadGet(createdContainer, objectId), default);
+            var objHeader = res.HeaderInfo;
+            Assert.NotNull(objHeader);
             Assert.Equal((ulong)bytes.Length, objHeader.PayloadLength);
             Assert.NotNull(objHeader.Attributes);
             Assert.Single(objHeader.Attributes!);
@@ -363,7 +356,7 @@ public class PoolSmokeTests : SmokeTestsBase
 
         Assert.True(hasObject);
 
-        var @object = await pool.GetObjectAsync(new PrmObjectGet(createdContainer, objectId));
+        var @object = await pool.GetObjectAsync(new PrmObjectGet(createdContainer, objectId), default);
 
         var downloadedBytes = new byte[@object.Header.PayloadLength];
         MemoryStream ms = new(downloadedBytes);
@@ -378,7 +371,7 @@ public class PoolSmokeTests : SmokeTestsBase
 
         await Cleanup(pool);
 
-        await foreach (var _ in pool.ListContainersAsync())
+        await foreach (var _ in pool.ListContainersAsync(default, default))
         {
             Assert.Fail("Containers exist");
         }
@@ -393,52 +386,51 @@ public class PoolSmokeTests : SmokeTestsBase
         var options = GetDefaultParams();
 
         using var pool = new Pool(options);
-        options.Callback = new((CallStatistics cs) => Assert.True(cs.ElapsedMicroSeconds > 0));
+        options.Callback = new((cs) => Assert.True(cs.ElapsedMicroSeconds > 0));
 
-        var error = await pool.Dial(new CallContext()).ConfigureAwait(true);
+        var error = await pool.Dial(new CallContext(TimeSpan.Zero)).ConfigureAwait(true);
 
         Assert.Null(error);
 
-        var token = await pool.CreateSessionAsync(new PrmSessionCreate(int.MaxValue));
+        var token = await pool.CreateSessionAsync(new PrmSessionCreate(int.MaxValue), default);
 
         await Cleanup(pool);
 
-        var ctx = new CallContext
-        {
-            Timeout = TimeSpan.FromSeconds(20)
-        };
+        var ctx = new CallContext(TimeSpan.FromSeconds(20));
 
         var createContainerParam = new PrmContainerCreate(
-            new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))), ctx);
+            new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))),
+             PrmWait.DefaultParams);
 
-        var container = await pool.CreateContainerAsync(createContainerParam);
+        var container = await pool.CreateContainerAsync(createContainerParam, ctx);
 
-        var containerInfo = await pool.GetContainerAsync(new PrmContainerGet(container, ctx));
+        var containerInfo = await pool.GetContainerAsync(new PrmContainerGet(container), ctx);
         Assert.NotNull(containerInfo);
 
         var bytes = GetRandomBytes(objectSize);
 
-        var param = new PrmObjectPut(new CallContext())
-        {
-            Header = new FrostFsObjectHeader(
+        var param = new PrmObjectPut(
+            new FrostFsObjectHeader(
                 containerId: container,
                 type: FrostFsObjectType.Regular,
                 [new FrostFsAttributePair("fileName", "test")]),
-            Payload = new MemoryStream(bytes),
-            ClientCut = false,
-            SessionToken = token
-        };
+            payload: new MemoryStream(bytes),
+            clientCut: false,
+            sessionToken: token);
 
-        var objectId = await pool.PutObjectAsync(param);
+        var objectId = await pool.PutObjectAsync(param, default);
 
         var filter = new FilterByAttributePair(FrostFsMatchType.Equals, "fileName", "test");
 
         bool hasObject = false;
-        await foreach (var objId in pool.SearchObjectsAsync(new PrmObjectSearch(container) { Filters = [filter], SessionToken = token }))
+        await foreach (var objId in pool.SearchObjectsAsync(new PrmObjectSearch(container, token, [], filter), default))
         {
             hasObject = true;
 
-            var objHeader = await pool.GetObjectHeadAsync(new PrmObjectHeadGet(container, objectId) { SessionToken = token });
+            var res = await pool.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);
@@ -448,7 +440,7 @@ public class PoolSmokeTests : SmokeTestsBase
 
         Assert.True(hasObject);
 
-        var @object = await pool.GetObjectAsync(new PrmObjectGet(container, objectId) { SessionToken = token });
+        var @object = await pool.GetObjectAsync(new PrmObjectGet(container, objectId, token), default);
 
         var downloadedBytes = new byte[@object.Header.PayloadLength];
         MemoryStream ms = new(downloadedBytes);
@@ -463,7 +455,7 @@ public class PoolSmokeTests : SmokeTestsBase
 
         await Cleanup(pool);
 
-        await foreach (var _ in pool.ListContainersAsync())
+        await foreach (var _ in pool.ListContainersAsync(default, default))
         {
             Assert.Fail("Containers exist");
         }
@@ -482,52 +474,49 @@ public class PoolSmokeTests : SmokeTestsBase
 
         using var pool = new Pool(options);
 
-        var error = await pool.Dial(new CallContext()).ConfigureAwait(true);
+        var error = await pool.Dial(new CallContext(TimeSpan.Zero)).ConfigureAwait(true);
 
         Assert.Null(error);
 
         await Cleanup(pool);
 
-        var createContainerParam = new PrmContainerCreate(new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))))
-        {
-            WaitParams = lightWait
-        };
+        var createContainerParam = new PrmContainerCreate(
+            new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))),
+            lightWait);
 
-        var containerId = await pool.CreateContainerAsync(createContainerParam);
+        var containerId = await pool.CreateContainerAsync(createContainerParam, default);
 
-        var ctx = new CallContext
-        {
-            Timeout = TimeSpan.FromSeconds(10),
-        };
+        var ctx = new CallContext(TimeSpan.FromSeconds(10));
 
         //  ctx.Interceptors.Add(new CallbackInterceptor());
 
-        var container = await pool.GetContainerAsync(new PrmContainerGet(containerId, ctx));
+        var container = await pool.GetContainerAsync(new PrmContainerGet(containerId), ctx);
 
         Assert.NotNull(container);
 
         byte[] bytes = GetRandomBytes(objectSize);
 
-        var param = new PrmObjectPut
-        {
-            Header = new FrostFsObjectHeader(
+        var param = new PrmObjectPut(
+            new FrostFsObjectHeader(
                 containerId: containerId,
                 type: FrostFsObjectType.Regular,
                 [new FrostFsAttributePair("fileName", "test")]),
-            Payload = new MemoryStream(bytes),
-            ClientCut = true
-        };
+            payload: new MemoryStream(bytes),
+            clientCut: true);
 
-        var objectId = await pool.PutObjectAsync(param);
+        var objectId = await pool.PutObjectAsync(param, default);
 
         var filter = new FilterByAttributePair(FrostFsMatchType.Equals, "fileName", "test");
 
         bool hasObject = false;
-        await foreach (var objId in pool.SearchObjectsAsync(new PrmObjectSearch(containerId, null, filter)))
+        await foreach (var objId in pool.SearchObjectsAsync(new PrmObjectSearch(containerId, null, [], filter), default))
         {
             hasObject = true;
 
-            var objHeader = await pool.GetObjectHeadAsync(new PrmObjectHeadGet(containerId, objectId));
+            var res = await pool.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);
@@ -537,7 +526,7 @@ public class PoolSmokeTests : SmokeTestsBase
 
         Assert.True(hasObject);
 
-        var @object = await pool.GetObjectAsync(new PrmObjectGet(containerId, objectId));
+        var @object = await pool.GetObjectAsync(new PrmObjectGet(containerId, objectId), default);
 
         var downloadedBytes = new byte[@object.Header.PayloadLength];
         MemoryStream ms = new(downloadedBytes);
@@ -554,7 +543,7 @@ public class PoolSmokeTests : SmokeTestsBase
 
         await Cleanup(pool);
 
-        await foreach (var cid in pool.ListContainersAsync())
+        await foreach (var cid in pool.ListContainersAsync(default, default))
         {
             Assert.Fail($"Container {cid.GetValue()} exist");
         }
@@ -587,9 +576,9 @@ public class PoolSmokeTests : SmokeTestsBase
 
     static async Task Cleanup(Pool pool)
     {
-        await foreach (var cid in pool.ListContainersAsync())
+        await foreach (var cid in pool.ListContainersAsync(default, default))
         {
-            await pool.DeleteContainerAsync(new PrmContainerDelete(cid) { WaitParams = lightWait }).ConfigureAwait(true);
+            await pool.DeleteContainerAsync(new PrmContainerDelete(cid, lightWait), default).ConfigureAwait(true);
         }
     }
 }

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

@@ -4,23 +4,24 @@ using System.Security.Cryptography;
 using FrostFS.SDK.Client;
 using FrostFS.SDK.Client.Interfaces;
 using FrostFS.SDK.Cryptography;
+using FrostFS.SDK.SmokeTests;
 
 using Microsoft.Extensions.Options;
 
-namespace 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
+public class MultithreadSmokeClientTests : SmokeTestsBase
 {
     private static readonly PrmWait lightWait = new(100, 1);
 
     [Fact]
     public async void AccountTest()
     {
-        using var client = FrostFSClient.GetSingleOwnerInstance(GetClientOptions(this.keyString, this.url));
+        using var client = FrostFSClient.GetInstance(GetClientOptions(keyString, url));
 
-        var result = await client.GetBalanceAsync();
+        var result = await client.GetBalanceAsync(default);
 
         Assert.NotNull(result);
         Assert.True(result.Value == 0);
@@ -29,9 +30,9 @@ public class SmokeClientTests : SmokeTestsBase
     [Fact]
     public async void NetworkMapTest()
     {
-        using var client = FrostFSClient.GetSingleOwnerInstance(GetClientOptions(this.keyString, this.url));
+        using var client = FrostFSClient.GetInstance(GetClientOptions(keyString, url));
 
-        var result = await client.GetNetmapSnapshotAsync();
+        var result = await client.GetNetmapSnapshotAsync(default);
 
         Assert.True(result.Epoch > 0);
         Assert.Single(result.NodeInfoCollection);
@@ -49,9 +50,9 @@ public class SmokeClientTests : SmokeTestsBase
     [Fact]
     public async void NodeInfoTest()
     {
-        using var client = FrostFSClient.GetSingleOwnerInstance(GetClientOptions(this.keyString, this.url));
+        using var client = FrostFSClient.GetInstance(GetClientOptions(keyString, url));
 
-        var result = await client.GetNodeInfoAsync();
+        var result = await client.GetNodeInfoAsync(default);
 
         Assert.Equal(2, result.Version.Major);
         Assert.Equal(13, result.Version.Minor);
@@ -64,14 +65,14 @@ public class SmokeClientTests : SmokeTestsBase
     [Fact]
     public async void NodeInfoStatisticsTest()
     {
-        var options = GetClientOptions(this.keyString, this.url);
+        var options = GetClientOptions(keyString, url);
 
         var callbackContent = string.Empty;
         options.Value.Callback = (cs) => callbackContent = $"{cs.MethodName} took {cs.ElapsedMicroSeconds} microseconds";
 
-        using var client = FrostFSClient.GetSingleOwnerInstance(options);
+        using var client = FrostFSClient.GetInstance(options);
 
-        var result = await client.GetNodeInfoAsync();
+        var result = await client.GetNodeInfoAsync(default);
 
         Assert.NotEmpty(callbackContent);
     }
@@ -79,11 +80,9 @@ public class SmokeClientTests : SmokeTestsBase
     [Fact]
     public async void GetSessionTest()
     {
-        using var client = FrostFSClient.GetSingleOwnerInstance(GetClientOptions(this.keyString, this.url));
+        using var client = FrostFSClient.GetInstance(GetClientOptions(keyString, url));
 
-        PrmSessionCreate? prm = new(100);
-
-        var token = await client.CreateSessionAsync(prm);
+        var token = await client.CreateSessionAsync(new(100), default);
 
         var ownerHash = Base58.Decode(OwnerId!.Value);
 
@@ -95,35 +94,33 @@ public class SmokeClientTests : SmokeTestsBase
     [Fact]
     public async void CreateObjectWithSessionToken()
     {
-        using var client = FrostFSClient.GetSingleOwnerInstance(GetClientOptions(this.keyString, this.url));
+        using var client = FrostFSClient.GetInstance(GetClientOptions(keyString, url));
 
         await Cleanup(client);
 
-        var token = await client.CreateSessionAsync(new PrmSessionCreate(int.MaxValue));
+        var token = await client.CreateSessionAsync(new PrmSessionCreate(int.MaxValue), default);
 
         var createContainerParam = new PrmContainerCreate(
-            new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))));
+            new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))),
+            PrmWait.DefaultParams,
+            xheaders: ["key1", "value1"]);
 
-        createContainerParam.XHeaders.Add("key1", "value1");
-
-        var containerId = await client.CreateContainerAsync(createContainerParam);
+        var containerId = await client.CreateContainerAsync(createContainerParam, default);
 
         var bytes = GetRandomBytes(1024);
 
-        var param = new PrmObjectPut
-        {
-            Header = new FrostFsObjectHeader(
+        var param = new PrmObjectPut(
+            new FrostFsObjectHeader(
                 containerId: containerId,
                 type: FrostFsObjectType.Regular,
                 [new FrostFsAttributePair("fileName", "test")]),
-            Payload = new MemoryStream(bytes),
-            ClientCut = false,
-            SessionToken = token
-        };
+            payload: new MemoryStream(bytes),
+            clientCut: false,
+            sessionToken: token);
 
-        var objectId = await client.PutObjectAsync(param).ConfigureAwait(true);
+        var objectId = await client.PutObjectAsync(param, default).ConfigureAwait(true);
 
-        var @object = await client.GetObjectAsync(new PrmObjectGet(containerId, objectId))
+        var @object = await client.GetObjectAsync(new PrmObjectGet(containerId, objectId), default)
             .ConfigureAwait(true);
 
         var downloadedBytes = new byte[@object.Header.PayloadLength];
@@ -143,17 +140,15 @@ public class SmokeClientTests : SmokeTestsBase
     [Fact]
     public async void FilterTest()
     {
-        using var client = FrostFSClient.GetSingleOwnerInstance(GetClientOptions(this.keyString, this.url));
+        using var client = FrostFSClient.GetInstance(GetClientOptions(keyString, url));
 
         await Cleanup(client);
 
         var createContainerParam = new PrmContainerCreate(
-           new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))))
-        {
-            WaitParams = lightWait
-        };
+            new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))),
+            lightWait);
 
-        var containerId = await client.CreateContainerAsync(createContainerParam);
+        var containerId = await client.CreateContainerAsync(createContainerParam, default);
 
         var bytes = new byte[] { 1, 2, 3 };
 
@@ -164,30 +159,28 @@ public class SmokeClientTests : SmokeTestsBase
             PayloadLength = 3
         };
 
-        var param = new PrmObjectPut
-        {
-            Header = new FrostFsObjectHeader(
+        var param = new PrmObjectPut(
+            new FrostFsObjectHeader(
                 containerId: containerId,
                 type: FrostFsObjectType.Regular,
                 [new FrostFsAttributePair("fileName", "test")],
                 new FrostFsSplit()),
-            Payload = new MemoryStream(bytes),
-            ClientCut = false
-        };
+            payload: new MemoryStream(bytes),
+            clientCut: false);
 
-        var objectId = await client.PutObjectAsync(param);
+        var objectId = await client.PutObjectAsync(param, default);
 
-        var head = await client.GetObjectHeadAsync(new PrmObjectHeadGet(containerId, objectId));
+        var head = await client.GetObjectHeadAsync(new PrmObjectHeadGet(containerId, objectId), default);
 
-        var ecdsaKey = this.keyString.LoadWif();
+        var ecdsaKey = keyString.LoadWif();
 
-        var networkInfo = await client.GetNetmapSnapshotAsync();
+        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 FilterBySplitId(FrostFsMatchType.Equals, param.Header!.Split!.SplitId));
 
         await CheckFilter(client, containerId, new FilterByAttributePair(FrostFsMatchType.Equals, "fileName", "test"));
 
@@ -210,12 +203,12 @@ public class SmokeClientTests : SmokeTestsBase
     {
         var resultObjectsCount = 0;
 
-        PrmObjectSearch searchParam = new(containerId) { Filters = [filter] };
+        PrmObjectSearch searchParam = new(containerId, null, [], filter);
 
-        await foreach (var objId in client.SearchObjectsAsync(searchParam))
+        await foreach (var objId in client.SearchObjectsAsync(searchParam, default))
         {
             resultObjectsCount++;
-            var objHeader = await client.GetObjectHeadAsync(new PrmObjectHeadGet(containerId, objId));
+            var objHeader = await client.GetObjectHeadAsync(new PrmObjectHeadGet(containerId, objId), default);
         }
 
         Assert.True(0 < resultObjectsCount, $"Filter for {filter.Key} doesn't work");
@@ -229,51 +222,53 @@ public class SmokeClientTests : SmokeTestsBase
     {
         bool callbackInvoked = false;
 
-        var options = GetClientOptions(this.keyString, this.url);
+        var options = GetClientOptions(keyString, url);
 
-        options.Value.Callback = new((CallStatistics cs) =>
+        options.Value.Callback = new((cs) =>
         {
             callbackInvoked = true;
             Assert.True(cs.ElapsedMicroSeconds > 0);
         });
 
-        using var client = FrostFSClient.GetSingleOwnerInstance(options);
+        using var client = FrostFSClient.GetInstance(options);
 
         await Cleanup(client);
 
-        var ctx = new CallContext { Timeout = TimeSpan.FromSeconds(20) };
+        var ctx = new CallContext(TimeSpan.FromSeconds(20));
 
         var createContainerParam = new PrmContainerCreate(
-            new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1)), [new("testKey", "testValue")]), ctx);
+            new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))),
+            PrmWait.DefaultParams,
+            xheaders: ["testKey", "testValue"]);
 
-        var createdContainer = await client.CreateContainerAsync(createContainerParam);
+        var createdContainer = await client.CreateContainerAsync(createContainerParam, ctx);
 
-        var container = await client.GetContainerAsync(new PrmContainerGet(createdContainer));
+        var container = await client.GetContainerAsync(new PrmContainerGet(createdContainer), default);
         Assert.NotNull(container);
         Assert.True(callbackInvoked);
 
         var bytes = GetRandomBytes(objectSize);
 
-        var param = new PrmObjectPut
-        {
-            Header = new FrostFsObjectHeader(
+        var param = new PrmObjectPut(
+            new FrostFsObjectHeader(
                 containerId: createdContainer,
                 type: FrostFsObjectType.Regular,
                 [new FrostFsAttributePair("fileName", "test")]),
-            Payload = new MemoryStream(bytes),
-            ClientCut = false
-        };
+            payload: new MemoryStream(bytes),
+            clientCut: false);
 
-        var objectId = await client.PutObjectAsync(param);
+        var objectId = await client.PutObjectAsync(param, default);
 
         var filter = new FilterByAttributePair(FrostFsMatchType.Equals, "fileName", "test");
 
         bool hasObject = false;
-        await foreach (var objId in client.SearchObjectsAsync(new PrmObjectSearch(createdContainer) { Filters = [filter] }))
+        await foreach (var objId in client.SearchObjectsAsync(new PrmObjectSearch(createdContainer, null, [], filter), default))
         {
             hasObject = true;
 
-            var objHeader = await client.GetObjectHeadAsync(new PrmObjectHeadGet(createdContainer, objectId));
+            var res = await client.GetObjectHeadAsync(new PrmObjectHeadGet(createdContainer, objectId), default);
+            var objHeader = res.HeaderInfo;
+            Assert.NotNull(objHeader);
             Assert.Equal((ulong)bytes.Length, objHeader.PayloadLength);
             Assert.NotNull(objHeader.Attributes);
             Assert.Single(objHeader.Attributes);
@@ -283,7 +278,7 @@ public class SmokeClientTests : SmokeTestsBase
 
         Assert.True(hasObject);
 
-        var @object = await client.GetObjectAsync(new PrmObjectGet(createdContainer, objectId));
+        var @object = await client.GetObjectAsync(new PrmObjectGet(createdContainer, objectId), default);
 
         var downloadedBytes = new byte[@object.Header.PayloadLength];
         MemoryStream ms = new(downloadedBytes);
@@ -298,7 +293,7 @@ public class SmokeClientTests : SmokeTestsBase
 
         await Cleanup(client);
 
-        await foreach (var _ in client.ListContainersAsync())
+        await foreach (var _ in client.ListContainersAsync(default, default))
         {
             Assert.Fail("Containers exist");
         }
@@ -307,54 +302,53 @@ public class SmokeClientTests : SmokeTestsBase
     [Fact]
     public async void PatchTest()
     {
-        using var client = FrostFSClient.GetSingleOwnerInstance(GetClientOptions(this.keyString, this.url));
+        using var client = FrostFSClient.GetInstance(GetClientOptions(keyString, url));
 
         await Cleanup(client);
 
         var createContainerParam = new PrmContainerCreate(
-            new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1)), [new("testKey", "testValue")]));
+            new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))),
+            PrmWait.DefaultParams,
+            xheaders: ["testKey", "testValue"]);
 
-        var createdContainer = await client.CreateContainerAsync(createContainerParam);
+        var createdContainer = await client.CreateContainerAsync(createContainerParam, default);
 
-        var container = await client.GetContainerAsync(new PrmContainerGet(createdContainer));
+        var container = await client.GetContainerAsync(new PrmContainerGet(createdContainer), default);
         Assert.NotNull(container);
 
         var bytes = new byte[1024];
         for (int i = 0; i < 1024; i++)
         {
-            bytes[i] = (byte)31;
+            bytes[i] = 31;
         }
 
-        var param = new PrmObjectPut
-        {
-            Header = new FrostFsObjectHeader(
+        var param = new PrmObjectPut(
+            new FrostFsObjectHeader(
                 containerId: createdContainer,
                 type: FrostFsObjectType.Regular,
                 [new FrostFsAttributePair("fileName", "test")]),
-            Payload = new MemoryStream(bytes),
-            ClientCut = false
-        };
+            payload: new MemoryStream(bytes),
+            clientCut: false);
 
-        var objectId = await client.PutObjectAsync(param);
+        var objectId = await client.PutObjectAsync(param, default);
 
         var patch = new byte[16];
         for (int i = 0; i < 16; i++)
         {
-            patch[i] = (byte)32;
+            patch[i] = 32;
         }
 
         var range = new FrostFsRange(8, (ulong)patch.Length);
 
-        var patchParams = new PrmObjectPatch(new FrostFsAddress(createdContainer, objectId))
-        {
-            Payload = new MemoryStream(patch),
-            MaxPayloadPatchChunkLength = 32,
-            Range = range
-        };
+        var patchParams = new PrmObjectPatch(
+            new FrostFsAddress(createdContainer, objectId),
+            payload: new MemoryStream(patch),
+            maxChunkLength: 32,
+            range: range);
 
-        var newIbjId = await client.PatchObjectAsync(patchParams);
+        var newIbjId = await client.PatchObjectAsync(patchParams, default);
 
-        var @object = await client.GetObjectAsync(new PrmObjectGet(createdContainer, newIbjId));
+        var @object = await client.GetObjectAsync(new PrmObjectGet(createdContainer, newIbjId), default);
 
         var downloadedBytes = new byte[@object.Header.PayloadLength];
         MemoryStream ms = new(downloadedBytes);
@@ -378,7 +372,7 @@ public class SmokeClientTests : SmokeTestsBase
 
         await Cleanup(client);
 
-        await foreach (var _ in client.ListContainersAsync())
+        await foreach (var _ in client.ListContainersAsync(default, default))
         {
             Assert.Fail("Containers exist");
         }
@@ -387,16 +381,18 @@ public class SmokeClientTests : SmokeTestsBase
     [Fact]
     public async void RangeTest()
     {
-        using var client = FrostFSClient.GetSingleOwnerInstance(GetClientOptions(this.keyString, this.url));
+        using var client = FrostFSClient.GetInstance(GetClientOptions(keyString, url));
 
         await Cleanup(client);
 
         var createContainerParam = new PrmContainerCreate(
-            new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1)), [new("testKey", "testValue")]));
+            new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))),
+            PrmWait.DefaultParams,
+            xheaders: ["testKey", "testValue"]);
 
-        var createdContainer = await client.CreateContainerAsync(createContainerParam);
+        var createdContainer = await client.CreateContainerAsync(createContainerParam, default);
 
-        var container = await client.GetContainerAsync(new PrmContainerGet(createdContainer));
+        var container = await client.GetContainerAsync(new PrmContainerGet(createdContainer), default);
         Assert.NotNull(container);
 
         var bytes = new byte[256];
@@ -405,20 +401,16 @@ public class SmokeClientTests : SmokeTestsBase
             bytes[i] = (byte)i;
         }
 
-        var param = new PrmObjectPut
-        {
-            Header = new FrostFsObjectHeader(
-                containerId: createdContainer,
-                type: FrostFsObjectType.Regular),
-            Payload = new MemoryStream(bytes),
-            ClientCut = false
-        };
+        var param = new PrmObjectPut(
+            new FrostFsObjectHeader(containerId: createdContainer, type: FrostFsObjectType.Regular),
+            payload: new MemoryStream(bytes),
+            clientCut: false);
 
-        var objectId = await client.PutObjectAsync(param);
+        var objectId = await client.PutObjectAsync(param, default);
 
         var rangeParam = new PrmRangeGet(createdContainer, objectId, new FrostFsRange(100, 64));
 
-        var rangeReader = await client.GetRangeAsync(rangeParam);
+        var rangeReader = await client.GetRangeAsync(rangeParam, default);
 
         var downloadedBytes = new byte[rangeParam.Range.Length];
         MemoryStream ms = new(downloadedBytes);
@@ -433,7 +425,7 @@ public class SmokeClientTests : SmokeTestsBase
 
         await Cleanup(client);
 
-        await foreach (var _ in client.ListContainersAsync())
+        await foreach (var _ in client.ListContainersAsync(default, default))
         {
             Assert.Fail("Containers exist");
         }
@@ -442,16 +434,18 @@ public class SmokeClientTests : SmokeTestsBase
     [Fact]
     public async void RangeHashTest()
     {
-        using var client = FrostFSClient.GetSingleOwnerInstance(GetClientOptions(this.keyString, this.url));
+        using var client = FrostFSClient.GetInstance(GetClientOptions(keyString, url));
 
         await Cleanup(client);
 
         var createContainerParam = new PrmContainerCreate(
-            new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1)), [new("testKey", "testValue")]));
+            new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))),
+            PrmWait.DefaultParams,
+            xheaders: ["testKey", "testValue"]);
 
-        var createdContainer = await client.CreateContainerAsync(createContainerParam);
+        var createdContainer = await client.CreateContainerAsync(createContainerParam, default);
 
-        var container = await client.GetContainerAsync(new PrmContainerGet(createdContainer));
+        var container = await client.GetContainerAsync(new PrmContainerGet(createdContainer), default);
         Assert.NotNull(container);
 
         var bytes = new byte[256];
@@ -460,20 +454,18 @@ public class SmokeClientTests : SmokeTestsBase
             bytes[i] = (byte)i;
         }
 
-        var param = new PrmObjectPut
-        {
-            Header = new FrostFsObjectHeader(
+        var param = new PrmObjectPut(
+            new FrostFsObjectHeader(
                 containerId: createdContainer,
                 type: FrostFsObjectType.Regular),
-            Payload = new MemoryStream(bytes),
-            ClientCut = false
-        };
+            payload: new MemoryStream(bytes),
+            clientCut: false);
 
-        var objectId = await client.PutObjectAsync(param);
+        var objectId = await client.PutObjectAsync(param, default);
 
         var rangeParam = new PrmRangeHashGet(createdContainer, objectId, [new FrostFsRange(100, 64)], bytes);
 
-        var hashes = await client.GetRangeHashAsync(rangeParam);
+        var hashes = await client.GetRangeHashAsync(rangeParam, default);
 
         foreach (var hash in hashes)
         {
@@ -482,7 +474,7 @@ public class SmokeClientTests : SmokeTestsBase
 
         await Cleanup(client);
 
-        await foreach (var _ in client.ListContainersAsync())
+        await foreach (var _ in client.ListContainersAsync(default, default))
         {
             Assert.Fail("Containers exist");
         }
@@ -494,49 +486,48 @@ public class SmokeClientTests : SmokeTestsBase
     [InlineData(6 * 1024 * 1024 + 100)]
     public async void SimpleScenarioWithSessionTest(int objectSize)
     {
-        using var client = FrostFSClient.GetSingleOwnerInstance(GetClientOptions(this.keyString, this.url));
+        using var client = FrostFSClient.GetInstance(GetClientOptions(keyString, url));
         //Callback = new((CallStatistics cs) => Assert.True(cs.ElapsedMicroSeconds > 0))
-        var token = await client.CreateSessionAsync(new PrmSessionCreate(int.MaxValue));
+        var token = await client.CreateSessionAsync(new PrmSessionCreate(int.MaxValue), default);
 
         await Cleanup(client);
 
-        var ctx = new CallContext
-        {
-            Timeout = TimeSpan.FromSeconds(20),
-
-        };
+        var ctx = new CallContext(TimeSpan.FromSeconds(20));
 
         var createContainerParam = new PrmContainerCreate(
-            new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))), ctx);
+            new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))),
+            PrmWait.DefaultParams);
 
-        var container = await client.CreateContainerAsync(createContainerParam);
+        var container = await client.CreateContainerAsync(createContainerParam, ctx);
 
-        var containerInfo = await client.GetContainerAsync(new PrmContainerGet(container, ctx));
+        var containerInfo = await client.GetContainerAsync(new PrmContainerGet(container), ctx);
         Assert.NotNull(containerInfo);
 
         var bytes = GetRandomBytes(objectSize);
 
-        var param = new PrmObjectPut
-        {
-            Header = new FrostFsObjectHeader(
+        var param = new PrmObjectPut(
+            new FrostFsObjectHeader(
                 containerId: container,
                 type: FrostFsObjectType.Regular,
                 [new FrostFsAttributePair("fileName", "test")]),
-            Payload = new MemoryStream(bytes),
-            ClientCut = false,
-            SessionToken = token
-        };
+            payload: new MemoryStream(bytes),
+            clientCut: false,
+            sessionToken: token);
 
-        var objectId = await client.PutObjectAsync(param);
+        var objectId = await client.PutObjectAsync(param, default);
 
         var filter = new FilterByAttributePair(FrostFsMatchType.Equals, "fileName", "test");
 
         bool hasObject = false;
-        await foreach (var objId in client.SearchObjectsAsync(new PrmObjectSearch(container) { Filters = [filter], SessionToken = token }))
+        await foreach (var objId in client.SearchObjectsAsync(
+            new PrmObjectSearch(container, token, [], filter), default))
         {
             hasObject = true;
 
-            var objHeader = await client.GetObjectHeadAsync(new PrmObjectHeadGet(container, objectId) { SessionToken = token });
+            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);
@@ -546,7 +537,7 @@ public class SmokeClientTests : SmokeTestsBase
 
         Assert.True(hasObject);
 
-        var @object = await client.GetObjectAsync(new PrmObjectGet(container, objectId) { SessionToken = token });
+        var @object = await client.GetObjectAsync(new PrmObjectGet(container, objectId, token), default);
 
         var downloadedBytes = new byte[@object.Header.PayloadLength];
         MemoryStream ms = new(downloadedBytes);
@@ -561,7 +552,7 @@ public class SmokeClientTests : SmokeTestsBase
 
         await Cleanup(client);
 
-        await foreach (var _ in client.ListContainersAsync())
+        await foreach (var _ in client.ListContainersAsync(default, default))
         {
             Assert.Fail("Containers exist");
         }
@@ -577,48 +568,48 @@ public class SmokeClientTests : SmokeTestsBase
     public async void ClientCutScenarioTest(int objectSize)
     {
 
-        var options = GetClientOptions(this.keyString, this.url);
+        var options = GetClientOptions(keyString, url);
         options.Value.Interceptors.Add(new CallbackInterceptor());
 
-        using var client = FrostFSClient.GetSingleOwnerInstance(GetClientOptions(this.keyString, this.url));
+        using var client = FrostFSClient.GetInstance(GetClientOptions(keyString, url));
 
         await Cleanup(client);
 
-        var createContainerParam = new PrmContainerCreate(new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))))
-        {
-            WaitParams = lightWait
-        };
+        var createContainerParam = new PrmContainerCreate(
+            new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))),
+            lightWait);
 
-        var containerId = await client.CreateContainerAsync(createContainerParam);
+        var containerId = await client.CreateContainerAsync(createContainerParam, default);
 
-        var ctx = new CallContext { Timeout = TimeSpan.FromSeconds(10) };
+        var ctx = new CallContext(TimeSpan.FromSeconds(10));
 
-        var container = await client.GetContainerAsync(new PrmContainerGet(containerId, ctx));
+        var container = await client.GetContainerAsync(new PrmContainerGet(containerId), ctx);
 
         Assert.NotNull(container);
 
         byte[] bytes = GetRandomBytes(objectSize);
 
-        var param = new PrmObjectPut
-        {
-            Header = new FrostFsObjectHeader(
+        var param = new PrmObjectPut(
+            new FrostFsObjectHeader(
                 containerId: containerId,
                 type: FrostFsObjectType.Regular,
                 [new FrostFsAttributePair("fileName", "test")]),
-            Payload = new MemoryStream(bytes),
-            ClientCut = true
-        };
+            payload: new MemoryStream(bytes),
+            clientCut: true);
 
-        var objectId = await client.PutObjectAsync(param);
+        var objectId = await client.PutObjectAsync(param, default);
 
         var filter = new FilterByAttributePair(FrostFsMatchType.Equals, "fileName", "test");
 
         bool hasObject = false;
-        await foreach (var objId in client.SearchObjectsAsync(new PrmObjectSearch(containerId, null, filter)))
+        await foreach (var objId in client.SearchObjectsAsync(new PrmObjectSearch(containerId, null, [], filter), default))
         {
             hasObject = true;
 
-            var objHeader = await client.GetObjectHeadAsync(new PrmObjectHeadGet(containerId, objectId));
+            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);
@@ -628,7 +619,7 @@ public class SmokeClientTests : SmokeTestsBase
 
         Assert.True(hasObject);
 
-        var @object = await client.GetObjectAsync(new PrmObjectGet(containerId, objectId));
+        var @object = await client.GetObjectAsync(new PrmObjectGet(containerId, objectId), default);
 
         var downloadedBytes = new byte[@object.Header.PayloadLength];
         MemoryStream ms = new(downloadedBytes);
@@ -656,7 +647,7 @@ public class SmokeClientTests : SmokeTestsBase
                 break;
             }
 
-            enumerator = client.ListContainersAsync().GetAsyncEnumerator();
+            enumerator = client.ListContainersAsync(default, default).GetAsyncEnumerator();
             await Task.Delay(500);
         }
         while (await enumerator!.MoveNextAsync());
@@ -668,8 +659,8 @@ public class SmokeClientTests : SmokeTestsBase
         bool callbackInvoked = false;
         bool intercepterInvoked = false;
 
-        var options = GetClientOptions(this.keyString, this.url);
-        options.Value.Callback = (CallStatistics cs) =>
+        var options = GetClientOptions(keyString, url);
+        options.Value.Callback = (cs) =>
         {
             callbackInvoked = true;
             Assert.True(cs.ElapsedMicroSeconds > 0);
@@ -677,9 +668,9 @@ public class SmokeClientTests : SmokeTestsBase
 
         options.Value.Interceptors.Add(new CallbackInterceptor(s => intercepterInvoked = true));
 
-        using var client = FrostFSClient.GetSingleOwnerInstance(options);
+        using var client = FrostFSClient.GetInstance(options);
 
-        var result = await client.GetNodeInfoAsync(new PrmNodeInfo());
+        var result = await client.GetNodeInfoAsync(default);
 
         Assert.True(callbackInvoked);
         Assert.True(intercepterInvoked);
@@ -712,9 +703,9 @@ public class SmokeClientTests : SmokeTestsBase
 
     static async Task Cleanup(IFrostFSClient client)
     {
-        await foreach (var cid in client.ListContainersAsync())
+        await foreach (var cid in client.ListContainersAsync(default, default))
         {
-            await client.DeleteContainerAsync(new PrmContainerDelete(cid) { WaitParams = lightWait });
+            await client.DeleteContainerAsync(new PrmContainerDelete(cid, lightWait), default);
         }
     }
 }

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

@@ -0,0 +1,585 @@
+using System.Diagnostics.CodeAnalysis;
+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 PoolSmokeTests : SmokeTestsBase
+{
+    private static readonly PrmWait lightWait = new(100, 1);
+
+    private InitParameters GetDefaultParams()
+    {
+        return new InitParameters
+        {
+            Key = keyString.LoadWif(),
+
+            NodeParams = [new(1, url, 100.0f)],
+            ClientBuilder = null,
+            GracefulCloseOnSwitchTimeout = 30_000_000,
+            Logger = null
+        };
+    }
+
+    [Fact]
+    public async void NetworkMapTest()
+    {
+        var options = GetDefaultParams();
+
+        using var pool = new Pool(options);
+
+        var error = await pool.Dial(new CallContext(TimeSpan.Zero));
+
+        Assert.Null(error);
+
+        var result = await pool.GetNetmapSnapshotAsync(default);
+
+        Assert.True(result.Epoch > 0);
+        Assert.Single(result.NodeInfoCollection);
+
+        var item = result.NodeInfoCollection[0];
+        Assert.Equal(2, item.Version.Major);
+        Assert.Equal(13, item.Version.Minor);
+        Assert.Equal(NodeState.Online, item.State);
+        Assert.True(item.PublicKey.Length > 0);
+        Assert.Single(item.Addresses);
+        Assert.Equal(9, item.Attributes.Count);
+    }
+
+    [Fact]
+    public async void NodeInfoTest()
+    {
+        var options = GetDefaultParams();
+
+        using var pool = new Pool(options);
+
+        var error = await pool.Dial(new CallContext(TimeSpan.Zero));
+
+        Assert.Null(error);
+
+        var result = await pool.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 NodeInfoStatisticsTwoNodesTest()
+    {
+        var callbackText = string.Empty;
+
+        var options = new InitParameters
+        {
+            Key = keyString.LoadWif(),
+            NodeParams = [
+                new(1, url, 100.0f),
+                new(2, url.Replace('0', '1'), 100.0f)
+                ],
+            ClientBuilder = null,
+            GracefulCloseOnSwitchTimeout = 30_000_000,
+            Logger = null,
+            Callback = (cs) => callbackText = $"{cs.MethodName} took {cs.ElapsedMicroSeconds} microseconds"
+        };
+
+        using var pool = new Pool(options);
+
+        var ctx = new CallContext(TimeSpan.Zero);
+
+        var error = await pool.Dial(ctx).ConfigureAwait(true);
+
+        Assert.Null(error);
+
+        using var client = FrostFSClient.GetInstance(GetSingleOwnerOptions(keyString, url));
+
+        var result = await client.GetNodeInfoAsync(default);
+
+        var statistics = pool.Statistic();
+
+        Assert.False(string.IsNullOrEmpty(callbackText));
+        Assert.Contains(" took ", callbackText, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public async void NodeInfoStatisticsTest()
+    {
+        var options = GetDefaultParams();
+
+        var callbackText = string.Empty;
+        options.Callback = (cs) => callbackText = $"{cs.MethodName} took {cs.ElapsedMicroSeconds} microseconds";
+
+        using var pool = new Pool(options);
+
+        var ctx = new CallContext(TimeSpan.Zero);
+
+        var error = await pool.Dial(ctx).ConfigureAwait(true);
+
+        Assert.Null(error);
+
+        using var client = FrostFSClient.GetInstance(GetSingleOwnerOptions(keyString, url));
+
+        var result = await client.GetNodeInfoAsync(default);
+
+        Assert.False(string.IsNullOrEmpty(callbackText));
+        Assert.Contains(" took ", callbackText, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public async void GetSessionTest()
+    {
+        var options = GetDefaultParams();
+
+        using var pool = new Pool(options);
+
+        var error = await pool.Dial(new CallContext(TimeSpan.Zero)).ConfigureAwait(true);
+
+        Assert.Null(error);
+
+        var prm = new PrmSessionCreate(100);
+
+        var token = await pool.CreateSessionAsync(prm, default).ConfigureAwait(true);
+
+        var ownerHash = Base58.Decode(OwnerId!.Value);
+
+        Assert.NotNull(token);
+        Assert.NotEqual(Guid.Empty, token.Id);
+        Assert.Equal(33, token.SessionKey.Length);
+    }
+
+    [Fact]
+    public async void CreateObjectWithSessionToken()
+    {
+        var options = GetDefaultParams();
+
+        using var pool = new Pool(options);
+
+        var error = await pool.Dial(new CallContext(TimeSpan.Zero)).ConfigureAwait(true);
+
+        Assert.Null(error);
+
+        await Cleanup(pool);
+
+        var token = await pool.CreateSessionAsync(new PrmSessionCreate(int.MaxValue), default);
+
+        var createContainerParam = new PrmContainerCreate(
+            new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))),
+            PrmWait.DefaultParams,
+            xheaders: ["key1", "value1"]);
+
+        var containerId = await pool.CreateContainerAsync(createContainerParam, default);
+
+        var bytes = GetRandomBytes(1024);
+
+        var param = new PrmObjectPut(
+            new FrostFsObjectHeader(
+                containerId: containerId,
+                type: FrostFsObjectType.Regular,
+                [new FrostFsAttributePair("fileName", "test")]),
+            payload: new MemoryStream(bytes),
+            clientCut: false,
+            sessionToken: token);
+
+        var objectId = await pool.PutObjectAsync(param, default).ConfigureAwait(true);
+
+        var @object = await pool.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(pool);
+    }
+
+    [Fact]
+    public async void FilterTest()
+    {
+        var options = GetDefaultParams();
+
+        using var pool = new Pool(options);
+
+        var error = await pool.Dial(new CallContext(TimeSpan.Zero)).ConfigureAwait(true);
+
+        Assert.Null(error);
+
+        await Cleanup(pool);
+
+        var createContainerParam = new PrmContainerCreate(
+            new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))),
+            lightWait);
+
+        var containerId = await pool.CreateContainerAsync(createContainerParam, default);
+
+        var bytes = new byte[] { 1, 2, 3 };
+
+        var ParentHeader = new FrostFsObjectHeader(
+                containerId: containerId,
+                type: FrostFsObjectType.Regular)
+        {
+            PayloadLength = 3
+        };
+
+        var param = new PrmObjectPut(
+            new FrostFsObjectHeader(
+                containerId: containerId,
+                type: FrostFsObjectType.Regular,
+                [new FrostFsAttributePair("fileName", "test")],
+                new FrostFsSplit()),
+            payload: new MemoryStream(bytes),
+            clientCut: false);
+
+        var objectId = await pool.PutObjectAsync(param, default);
+
+        var head = await pool.GetObjectHeadAsync(new PrmObjectHeadGet(containerId, objectId), default);
+
+        var ecdsaKey = keyString.LoadWif();
+
+        var networkInfo = await pool.GetNetmapSnapshotAsync(default);
+
+        await CheckFilter(pool, containerId, new FilterByContainerId(FrostFsMatchType.Equals, containerId));
+
+        await CheckFilter(pool, containerId, new FilterByOwnerId(FrostFsMatchType.Equals, FrostFsOwner.FromKey(ecdsaKey)));
+
+        await CheckFilter(pool, containerId, new FilterBySplitId(FrostFsMatchType.Equals, param.Header!.Split!.SplitId));
+
+        await CheckFilter(pool, containerId, new FilterByAttributePair(FrostFsMatchType.Equals, "fileName", "test"));
+
+        await CheckFilter(pool, containerId, new FilterByObjectId(FrostFsMatchType.Equals, objectId));
+
+        await CheckFilter(pool, containerId, new FilterByVersion(FrostFsMatchType.Equals, networkInfo.NodeInfoCollection[0].Version));
+
+        await CheckFilter(pool, containerId, new FilterByEpoch(FrostFsMatchType.Equals, networkInfo.Epoch));
+
+        await CheckFilter(pool, containerId, new FilterByPayloadLength(FrostFsMatchType.Equals, 3));
+
+        var checkSum = CheckSum.CreateCheckSum(bytes);
+
+        await CheckFilter(pool, containerId, new FilterByPayloadHash(FrostFsMatchType.Equals, checkSum));
+
+        await CheckFilter(pool, containerId, new FilterByPhysicallyStored());
+    }
+
+    private static async Task CheckFilter(Pool pool, FrostFsContainerId containerId, IObjectFilter filter)
+    {
+        var resultObjectsCount = 0;
+
+        PrmObjectSearch searchParam = new(containerId, null, [], filter);
+
+        await foreach (var objId in pool.SearchObjectsAsync(searchParam, default))
+        {
+            resultObjectsCount++;
+            var objHeader = await pool.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 = GetDefaultParams();
+
+        options.Callback = new((cs) =>
+        {
+            callbackInvoked = true;
+            Assert.True(cs.ElapsedMicroSeconds > 0);
+        });
+
+        using var pool = new Pool(options);
+
+        var error = await pool.Dial(new CallContext(TimeSpan.Zero)).ConfigureAwait(true);
+
+        Assert.Null(error);
+
+        await Cleanup(pool);
+
+        var ctx = new CallContext(TimeSpan.Zero);
+
+        var createContainerParam = new PrmContainerCreate(
+            new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))),
+            PrmWait.DefaultParams,
+            xheaders: ["testKey", "testValue"]);
+
+        var createdContainer = await pool.CreateContainerAsync(createContainerParam, ctx);
+
+        var container = await pool.GetContainerAsync(new PrmContainerGet(createdContainer), default);
+        Assert.NotNull(container);
+        Assert.True(callbackInvoked);
+
+        var bytes = GetRandomBytes(objectSize);
+
+        var param = new PrmObjectPut(
+            new FrostFsObjectHeader(
+                containerId: createdContainer,
+                type: FrostFsObjectType.Regular,
+                [new FrostFsAttributePair("fileName", "test")]),
+            payload: new MemoryStream(bytes),
+            clientCut: false);
+
+        var objectId = await pool.PutObjectAsync(param, default);
+
+        var filter = new FilterByAttributePair(FrostFsMatchType.Equals, "fileName", "test");
+
+        bool hasObject = false;
+        await foreach (var objId in pool.SearchObjectsAsync(new PrmObjectSearch(createdContainer, null, [], filter), default))
+        {
+            hasObject = true;
+
+            var res = await pool.GetObjectHeadAsync(new PrmObjectHeadGet(createdContainer, 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 pool.GetObjectAsync(new PrmObjectGet(createdContainer, 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(pool);
+
+        await foreach (var _ in pool.ListContainersAsync(default, default))
+        {
+            Assert.Fail("Containers exist");
+        }
+    }
+
+    [Theory]
+    [InlineData(1)]
+    [InlineData(3 * 1024 * 1024)]            // exactly one chunk size - 3MB
+    [InlineData(6 * 1024 * 1024 + 100)]
+    public async void SimpleScenarioWithSessionTest(int objectSize)
+    {
+        var options = GetDefaultParams();
+
+        using var pool = new Pool(options);
+        options.Callback = new((cs) => Assert.True(cs.ElapsedMicroSeconds > 0));
+
+        var error = await pool.Dial(new CallContext(TimeSpan.Zero)).ConfigureAwait(true);
+
+        Assert.Null(error);
+
+        var token = await pool.CreateSessionAsync(new PrmSessionCreate(int.MaxValue), default);
+
+        await Cleanup(pool);
+
+        var ctx = new CallContext(TimeSpan.FromSeconds(20));
+
+        var createContainerParam = new PrmContainerCreate(
+            new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))),
+            PrmWait.DefaultParams);
+
+        var container = await pool.CreateContainerAsync(createContainerParam, ctx);
+
+        var containerInfo = await pool.GetContainerAsync(new PrmContainerGet(container), ctx);
+        Assert.NotNull(containerInfo);
+
+        var bytes = GetRandomBytes(objectSize);
+
+        var param = new PrmObjectPut(
+            new FrostFsObjectHeader(
+                containerId: container,
+                type: FrostFsObjectType.Regular,
+                [new FrostFsAttributePair("fileName", "test")]),
+            payload: new MemoryStream(bytes),
+            clientCut: false,
+            sessionToken: token);
+
+        var objectId = await pool.PutObjectAsync(param, new CallContext(TimeSpan.Zero));
+
+        var filter = new FilterByAttributePair(FrostFsMatchType.Equals, "fileName", "test");
+
+        bool hasObject = false;
+        var objs = pool.SearchObjectsAsync(new PrmObjectSearch(container, token, [], filter), default);
+        await foreach (var objId in objs)
+        {
+            hasObject = true;
+
+            var res = await pool.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 pool.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(pool);
+
+        await foreach (var _ in pool.ListContainersAsync(default, default))
+        {
+            Assert.Fail("Containers exist");
+        }
+    }
+
+    [Theory]
+    [InlineData(1)]
+    [InlineData(64 * 1024 * 1024)]      // exactly 1 block size - 64MB
+    [InlineData(64 * 1024 * 1024 - 1)]
+    [InlineData(64 * 1024 * 1024 + 1)]
+    [InlineData(2 * 64 * 1024 * 1024 + 256)]
+    [InlineData(200)]
+    public async void ClientCutScenarioTest(int objectSize)
+    {
+        var options = GetDefaultParams();
+
+        using var pool = new Pool(options);
+
+        var error = await pool.Dial(new CallContext(TimeSpan.Zero)).ConfigureAwait(true);
+
+        Assert.Null(error);
+
+        await Cleanup(pool);
+
+        var createContainerParam = new PrmContainerCreate(
+            new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))),
+            lightWait);
+
+        var containerId = await pool.CreateContainerAsync(createContainerParam, default);
+
+        var ctx = new CallContext(TimeSpan.FromSeconds(10));
+
+        //  ctx.Interceptors.Add(new CallbackInterceptor());
+
+        var container = await pool.GetContainerAsync(new PrmContainerGet(containerId), ctx);
+
+        Assert.NotNull(container);
+
+        byte[] bytes = GetRandomBytes(objectSize);
+
+        var param = new PrmObjectPut(
+            new FrostFsObjectHeader(
+                containerId: containerId,
+                type: FrostFsObjectType.Regular,
+                [new FrostFsAttributePair("fileName", "test")]),
+            payload: new MemoryStream(bytes),
+            clientCut: true);
+
+        var objectId = await pool.PutObjectAsync(param, default);
+
+        var filter = new FilterByAttributePair(FrostFsMatchType.Equals, "fileName", "test");
+
+        bool hasObject = false;
+        await foreach (var objId in pool.SearchObjectsAsync(new PrmObjectSearch(containerId, null, [], filter), default))
+        {
+            hasObject = true;
+
+            var res = await pool.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[0].Key);
+            Assert.Equal("test", objHeader.Attributes[0].Value);
+        }
+
+        Assert.True(hasObject);
+
+        var @object = await pool.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 CheckFilter(pool, containerId, new FilterByRootObject());
+
+        await Cleanup(pool);
+
+        await foreach (var cid in pool.ListContainersAsync(default, default))
+        {
+            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/SmokeClientTests.cs

@@ -0,0 +1,709 @@
+using System.Diagnostics.CodeAnalysis;
+using System.Security.Cryptography;
+
+using FrostFS.SDK.Client;
+using FrostFS.SDK.Client.Interfaces;
+using FrostFS.SDK.Cryptography;
+using FrostFS.SDK.SmokeTests;
+
+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()
+    {
+        using var client = FrostFSClient.GetInstance(GetClientOptions(keyString, url));
+
+        var result = await client.GetBalanceAsync(default);
+
+        Assert.NotNull(result);
+        Assert.True(result.Value == 0);
+    }
+
+    [Fact]
+    public async void NodeInfoTest()
+    {
+        using var client = FrostFSClient.GetInstance(GetClientOptions(keyString, url));
+
+        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 = GetClientOptions(keyString, url);
+
+        var callbackContent = string.Empty;
+        options.Value.Callback = (cs) => callbackContent = $"{cs.MethodName} took {cs.ElapsedMicroSeconds} microseconds";
+
+        using var client = FrostFSClient.GetInstance(options);
+
+        var result = await client.GetNodeInfoAsync(default);
+
+        Assert.NotEmpty(callbackContent);
+    }
+
+    [Fact]
+    public async void GetSessionTest()
+    {
+        using var client = FrostFSClient.GetInstance(GetClientOptions(keyString, url));
+
+        var token = await client.CreateSessionAsync(new(100), default);
+
+        var ownerHash = Base58.Decode(OwnerId!.Value);
+
+        Assert.NotNull(token);
+        Assert.NotEqual(Guid.Empty, token.Id);
+        Assert.Equal(33, token.SessionKey.Length);
+    }
+
+    [Fact]
+    public async void CreateObjectWithSessionToken()
+    {
+        using var client = FrostFSClient.GetInstance(GetClientOptions(keyString, url));
+
+        await Cleanup(client);
+
+        var token = await client.CreateSessionAsync(new PrmSessionCreate(int.MaxValue), default);
+
+        var createContainerParam = new PrmContainerCreate(
+            new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))),
+            PrmWait.DefaultParams,
+            xheaders: ["key1", "value1"]);
+
+        var containerId = await client.CreateContainerAsync(createContainerParam, default);
+
+        var bytes = GetRandomBytes(1024);
+
+        var param = new PrmObjectPut(
+            new FrostFsObjectHeader(
+                containerId: containerId,
+                type: FrostFsObjectType.Regular,
+                [new FrostFsAttributePair("fileName", "test")]),
+            payload: new MemoryStream(bytes),
+            clientCut: false,
+            sessionToken: token);
+
+        var objectId = await client.PutObjectAsync(param, default).ConfigureAwait(true);
+
+        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()
+    {
+        using var client = FrostFSClient.GetInstance(GetClientOptions(keyString, url));
+
+        await Cleanup(client);
+
+        var createContainerParam = new PrmContainerCreate(
+           new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))),
+           lightWait);
+
+        var containerId = await client.CreateContainerAsync(createContainerParam, default);
+
+        var bytes = new byte[] { 1, 2, 3 };
+
+        var ParentHeader = new FrostFsObjectHeader(
+                containerId: containerId,
+                type: FrostFsObjectType.Regular)
+        {
+            PayloadLength = 3
+        };
+
+        var param = new PrmObjectPut(
+            new FrostFsObjectHeader(
+                containerId: containerId,
+                type: FrostFsObjectType.Regular,
+                [new FrostFsAttributePair("fileName", "test")],
+                new FrostFsSplit()),
+            payload: new MemoryStream(bytes),
+            clientCut: false);
+
+        var objectId = await client.PutObjectAsync(param, default);
+
+        var head = await client.GetObjectHeadAsync(new PrmObjectHeadGet(containerId, objectId), default);
+
+        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 = GetClientOptions(keyString, url);
+
+        options.Value.Callback = new((cs) =>
+        {
+            callbackInvoked = true;
+            Assert.True(cs.ElapsedMicroSeconds > 0);
+        });
+
+        using var client = FrostFSClient.GetInstance(options);
+
+        await Cleanup(client);
+
+        var ctx = new CallContext(TimeSpan.FromSeconds(20));
+
+        var createContainerParam = new PrmContainerCreate(
+            new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))),
+            PrmWait.DefaultParams,
+            xheaders: ["testKey", "testValue"]);
+
+        var createdContainer = await client.CreateContainerAsync(createContainerParam, ctx);
+
+        var container = await client.GetContainerAsync(new PrmContainerGet(createdContainer), default);
+        Assert.NotNull(container);
+        Assert.True(callbackInvoked);
+
+        var bytes = GetRandomBytes(objectSize);
+
+        var param = new PrmObjectPut(
+            new FrostFsObjectHeader(
+                containerId: createdContainer,
+                type: FrostFsObjectType.Regular,
+                [new FrostFsAttributePair("fileName", "test")]),
+            payload: new MemoryStream(bytes),
+            clientCut: false);
+
+        var objectId = await client.PutObjectAsync(param, default);
+
+        var filter1 = new FilterByOwnerId(FrostFsMatchType.Equals, OwnerId!);
+        await foreach (var objId in client.SearchObjectsAsync(new PrmObjectSearch(createdContainer, null, [], filter1), default))
+        {
+            var objHeader = await client.GetObjectHeadAsync(new PrmObjectHeadGet(createdContainer, objectId, false), default);
+
+            var objHeader1 = await client.GetObjectHeadAsync(new PrmObjectHeadGet(createdContainer, objectId, true), default);
+
+        }
+
+        var filter = new FilterByAttributePair(FrostFsMatchType.Equals, "fileName", "test");
+
+        bool hasObject = false;
+        await foreach (var objId in client.SearchObjectsAsync(new PrmObjectSearch(createdContainer, null, [], filter), default))
+        {
+            hasObject = true;
+
+            var res = await client.GetObjectHeadAsync(new PrmObjectHeadGet(createdContainer, 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(createdContainer, 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 PatchTest()
+    {
+        using var client = FrostFSClient.GetInstance(GetClientOptions(keyString, url));
+
+        await Cleanup(client);
+
+        var createContainerParam = new PrmContainerCreate(
+            new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))),
+            PrmWait.DefaultParams,
+            xheaders: ["testKey", "testValue"]);
+
+        var createdContainer = await client.CreateContainerAsync(createContainerParam, default);
+
+        var container = await client.GetContainerAsync(new PrmContainerGet(createdContainer), default);
+        Assert.NotNull(container);
+
+        var bytes = new byte[1024];
+        for (int i = 0; i < 1024; i++)
+        {
+            bytes[i] = 31;
+        }
+
+        var param = new PrmObjectPut(
+            new FrostFsObjectHeader(
+                containerId: createdContainer,
+                type: FrostFsObjectType.Regular,
+                [new FrostFsAttributePair("fileName", "test")]),
+            payload: new MemoryStream(bytes),
+            clientCut: false);
+
+        var objectId = await client.PutObjectAsync(param, default);
+
+        var patch = new byte[16];
+        for (int i = 0; i < 16; i++)
+        {
+            patch[i] = 32;
+        }
+
+        var range = new FrostFsRange(8, (ulong)patch.Length);
+
+        var patchParams = new PrmObjectPatch(
+            new FrostFsAddress(createdContainer, objectId),
+            payload: new MemoryStream(patch),
+            maxChunkLength: 32,
+            range: range);
+
+        var newIbjId = await client.PatchObjectAsync(patchParams, default);
+
+        var @object = await client.GetObjectAsync(new PrmObjectGet(createdContainer, 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()
+    {
+        using var client = FrostFSClient.GetInstance(GetClientOptions(keyString, url));
+
+        await Cleanup(client);
+
+        var createContainerParam = new PrmContainerCreate(
+            new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))),
+            PrmWait.DefaultParams,
+            xheaders: ["testKey", "testValue"]);
+
+        var createdContainer = await client.CreateContainerAsync(createContainerParam, default);
+
+        var container = await client.GetContainerAsync(new PrmContainerGet(createdContainer), default);
+        Assert.NotNull(container);
+
+        var bytes = new byte[256];
+        for (int i = 0; i < 256; i++)
+        {
+            bytes[i] = (byte)i;
+        }
+
+        var param = new PrmObjectPut(
+            new FrostFsObjectHeader(
+                containerId: createdContainer,
+                type: FrostFsObjectType.Regular),
+            payload: new MemoryStream(bytes),
+            clientCut: false);
+
+        var objectId = await client.PutObjectAsync(param, default);
+
+        var rangeParam = new PrmRangeGet(createdContainer, objectId, new FrostFsRange(100, 64));
+
+        var rangeReader = await client.GetRangeAsync(rangeParam, default);
+
+        var downloadedBytes = new byte[rangeParam.Range.Length];
+        MemoryStream ms = new(downloadedBytes);
+
+        ReadOnlyMemory<byte>? chunk = null;
+        while ((chunk = await rangeReader!.ReadChunk()) != null)
+        {
+            ms.Write(chunk.Value.Span);
+        }
+
+        Assert.Equal(SHA256.HashData(bytes.AsSpan().Slice(100, 64)), SHA256.HashData(downloadedBytes));
+
+        await Cleanup(client);
+
+        await foreach (var _ in client.ListContainersAsync(default, default))
+        {
+            Assert.Fail("Containers exist");
+        }
+    }
+
+    [Fact]
+    public async void RangeHashTest()
+    {
+        using var client = FrostFSClient.GetInstance(GetClientOptions(keyString, url));
+
+        await Cleanup(client);
+
+        var createContainerParam = new PrmContainerCreate(
+            new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))),
+            PrmWait.DefaultParams,
+            xheaders: ["testKey", "testValue"]);
+
+        var createdContainer = await client.CreateContainerAsync(createContainerParam, default);
+
+        var container = await client.GetContainerAsync(new PrmContainerGet(createdContainer), default);
+        Assert.NotNull(container);
+
+        var bytes = new byte[256];
+        for (int i = 0; i < 256; i++)
+        {
+            bytes[i] = (byte)i;
+        }
+
+        var param = new PrmObjectPut(
+            new FrostFsObjectHeader(
+                containerId: createdContainer,
+                type: FrostFsObjectType.Regular),
+            payload: new MemoryStream(bytes),
+            clientCut: false);
+
+        var objectId = await client.PutObjectAsync(param, default);
+
+        var rangeParam = new PrmRangeHashGet(createdContainer, objectId, [new FrostFsRange(100, 64)], bytes);
+
+        var hashes = await client.GetRangeHashAsync(rangeParam, default);
+
+        foreach (var hash in hashes)
+        {
+            var x = hash[..32].ToArray();
+        }
+
+        await Cleanup(client);
+
+        await foreach (var _ in client.ListContainersAsync(default, default))
+        {
+            Assert.Fail("Containers exist");
+        }
+    }
+
+    [Theory]
+    [InlineData(1)]
+    [InlineData(3 * 1024 * 1024)]            // exactly one chunk size - 3MB
+    [InlineData(6 * 1024 * 1024 + 100)]
+    public async void SimpleScenarioWithSessionTest(int objectSize)
+    {
+        using var client = FrostFSClient.GetInstance(GetClientOptions(keyString, url));
+        //Callback = new((CallStatistics cs) => Assert.True(cs.ElapsedMicroSeconds > 0))
+        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, new FrostFsReplica(1))),
+            PrmWait.DefaultParams);
+
+        var container = await client.CreateContainerAsync(createContainerParam, ctx);
+
+        var containerInfo = await client.GetContainerAsync(new PrmContainerGet(container), ctx);
+        Assert.NotNull(containerInfo);
+
+        var bytes = GetRandomBytes(objectSize);
+
+        var param = new PrmObjectPut(
+            new FrostFsObjectHeader(
+                containerId: container,
+                type: FrostFsObjectType.Regular,
+                [new FrostFsAttributePair("fileName", "test")]),
+            payload: new MemoryStream(bytes),
+            clientCut: false,
+            sessionToken: token);
+
+        var objectId = await client.PutObjectAsync(param, default);
+
+        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");
+        }
+    }
+
+    [Theory]
+    [InlineData(1)]
+    [InlineData(64 * 1024 * 1024)]      // exactly 1 block size - 64MB
+    [InlineData(64 * 1024 * 1024 - 1)]
+    [InlineData(64 * 1024 * 1024 + 1)]
+    [InlineData(2 * 64 * 1024 * 1024 + 256)]
+    [InlineData(200)]
+    public async void ClientCutScenarioTest(int objectSize)
+    {
+
+        var options = GetClientOptions(keyString, url);
+        options.Value.Interceptors.Add(new CallbackInterceptor());
+
+        using var client = FrostFSClient.GetInstance(GetClientOptions(keyString, url));
+
+        await Cleanup(client);
+
+        var createContainerParam = new PrmContainerCreate(
+            new FrostFsContainerInfo(new FrostFsPlacementPolicy(true, new FrostFsReplica(1))),
+            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);
+
+        byte[] bytes = GetRandomBytes(objectSize);
+
+        var param = new PrmObjectPut(
+            new FrostFsObjectHeader(
+                containerId: containerId,
+                type: FrostFsObjectType.Regular,
+                [new FrostFsAttributePair("fileName", "test")]),
+            payload: new MemoryStream(bytes),
+            clientCut: true);
+
+        var objectId = await client.PutObjectAsync(param, 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 objHeader = await client.GetObjectHeadAsync(new PrmObjectHeadGet(containerId, objectId), default);
+        //    Assert.Equal((ulong)bytes.Length, objHeader.PayloadLength);
+        //    Assert.NotNull(objHeader.Attributes);
+        //    Assert.Single(objHeader.Attributes);
+        //    Assert.Equal("fileName", objHeader.Attributes[0].Key);
+        //    Assert.Equal("test", objHeader.Attributes[0].Value);
+        //}
+
+        //Assert.True(hasObject);
+
+
+        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 objHeader1 = await client.GetObjectHeadAsync(new PrmObjectHeadGet(containerId, objectId, true), default);
+
+        }
+
+        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 CheckFilter(client, containerId, new FilterByRootObject());
+
+        await Cleanup(client);
+
+        var deadline = DateTime.UtcNow.Add(TimeSpan.FromSeconds(5));
+
+        IAsyncEnumerator<FrostFsContainerId>? enumerator = null;
+        do
+        {
+            if (deadline <= DateTime.UtcNow)
+            {
+                Assert.Fail("Containers exist");
+                break;
+            }
+
+            enumerator = client.ListContainersAsync(default, default).GetAsyncEnumerator();
+            await Task.Delay(500);
+        }
+        while (await enumerator!.MoveNextAsync());
+    }
+
+    [Fact]
+    public async void NodeInfoCallbackAndInterceptorTest()
+    {
+        bool callbackInvoked = false;
+        bool intercepterInvoked = false;
+
+        var options = GetClientOptions(keyString, url);
+        options.Value.Callback = (cs) =>
+        {
+            callbackInvoked = true;
+            Assert.True(cs.ElapsedMicroSeconds > 0);
+        };
+
+        options.Value.Interceptors.Add(new CallbackInterceptor(s => intercepterInvoked = true));
+
+        using var client = FrostFSClient.GetInstance(options);
+
+        var result = await client.GetNodeInfoAsync(default);
+
+        Assert.True(callbackInvoked);
+        Assert.True(intercepterInvoked);
+
+        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);
+    }
+
+    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/SmokeTestsBase.cs

@@ -3,7 +3,7 @@
 using FrostFS.SDK.Client;
 using FrostFS.SDK.Cryptography;
 
-namespace FrostFS.SDK.SmokeTests;
+namespace FrostFS.SDK.Tests.Smoke;
 
 public abstract class SmokeTestsBase
 {

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

@@ -6,7 +6,7 @@ using FrostFS.SDK.Cryptography;
 
 using Google.Protobuf;
 
-namespace FrostFS.SDK.Tests;
+namespace FrostFS.SDK.Tests.Unit;
 
 [SuppressMessage("Reliability", "CA2007:Consider calling ConfigureAwait on the awaited task", Justification = "Default Value is correct for tests")]
 public class ContainerTest : ContainerTestsBase
@@ -14,9 +14,9 @@ public class ContainerTest : ContainerTestsBase
     [Fact]
     public async void CreateContainerTest()
     {
-        var param = new PrmContainerCreate(new FrostFsContainerInfo(Mocker.PlacementPolicy));
+        var param = new PrmContainerCreate(new FrostFsContainerInfo(Mocker.PlacementPolicy), PrmWait.DefaultParams);
 
-        var result = await GetClient().CreateContainerAsync(param);
+        var result = await GetClient().CreateContainerAsync(param, default);
 
         Assert.NotNull(result);
         Assert.NotNull(result.GetValue());
@@ -28,7 +28,7 @@ public class ContainerTest : ContainerTestsBase
     {
         var cid = new FrostFsContainerId(Base58.Encode(Mocker.ContainerGuid.ToBytes()));
 
-        var result = await GetClient().GetContainerAsync(new PrmContainerGet(cid));
+        var result = await GetClient().GetContainerAsync(new PrmContainerGet(cid), default);
 
         Assert.NotNull(result);
         Assert.Equal(Mocker.ContainerGuid, result.Nonce);
@@ -43,7 +43,7 @@ public class ContainerTest : ContainerTestsBase
         Mocker.ContainerIds.Add([0xbb]);
         Mocker.ContainerIds.Add([0xcc]);
 
-        var result = GetClient().ListContainersAsync();
+        var result = GetClient().ListContainersAsync(default, default);
 
         Assert.NotNull(result);
 
@@ -63,7 +63,7 @@ public class ContainerTest : ContainerTestsBase
         Mocker.ReturnContainerRemoved = true;
         var cid = new FrostFsContainerId(Base58.Encode(Mocker.ContainerGuid.ToBytes()));
 
-        await GetClient().DeleteContainerAsync(new PrmContainerDelete(cid));
+        await GetClient().DeleteContainerAsync(new PrmContainerDelete(cid, PrmWait.DefaultParams), default);
 
         Assert.Single(Mocker.Requests);
 

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

@@ -2,7 +2,7 @@
 
 using Microsoft.Extensions.Options;
 
-namespace FrostFS.SDK.Tests;
+namespace FrostFS.SDK.Tests.Unit;
 
 public abstract class ContainerTestsBase
 {
@@ -19,7 +19,7 @@ public abstract class ContainerTestsBase
             Host = "http://localhost:8080"
         });
 
-        Mocker = new ContainerMocker(this.key)
+        Mocker = new ContainerMocker(key)
         {
             PlacementPolicy = new FrostFsPlacementPolicy(true, new FrostFsReplica(1)),
             Version = new FrostFsVersion(2, 13),
@@ -32,9 +32,9 @@ public abstract class ContainerTestsBase
         return Client.FrostFSClient.GetTestInstance(
             Settings,
             null,
-            new NetworkMocker(this.key).GetMock().Object,
-            new SessionMocker(this.key).GetMock().Object,
+            new NetworkMocker(key).GetMock().Object,
+            new SessionMocker(key).GetMock().Object,
             Mocker.GetMock().Object,
-            new ObjectMocker(this.key).GetMock().Object);
+            new ObjectMocker(key).GetMock().Object);
     }
 }

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

@@ -5,7 +5,7 @@ using FrostFS.SDK.Client;
 
 using Google.Protobuf;
 
-namespace FrostFS.SDK.Tests;
+namespace FrostFS.SDK.Tests.Unit;
 
 [SuppressMessage("Reliability", "CA2007:Consider calling ConfigureAwait on the awaited task", Justification = "Default Value is correct for tests")]
 public class NetworkTest : NetworkTestsBase
@@ -28,17 +28,13 @@ public class NetworkTest : NetworkTestsBase
         Mocker.Parameters.Add("HomomorphicHashingDisabled", [1]);
         Mocker.Parameters.Add("MaintenanceModeAllowed", [1]);
 
-        var param = useContext ?
-            new PrmNetworkSettings(new CallContext
-            {
-                CancellationToken = Mocker.CancellationTokenSource.Token,
-                Timeout = TimeSpan.FromSeconds(20)
-            })
-            : new PrmNetworkSettings();
+        var ctx = useContext
+            ? new CallContext(TimeSpan.FromSeconds(20), Mocker.CancellationTokenSource.Token)
+            : default;
 
         var validTimeoutFrom = DateTime.UtcNow.AddSeconds(20);
 
-        var result = await GetClient(DefaultSettings).GetNetworkSettingsAsync(param);
+        var result = await GetClient(DefaultSettings).GetNetworkSettingsAsync(ctx);
 
         var validTimeoutTo = DateTime.UtcNow.AddSeconds(20);
 
@@ -110,28 +106,13 @@ public class NetworkTest : NetworkTestsBase
 
         Mocker.NetmapSnapshotResponse = new NetmapSnapshotResponse { Body = body };
 
-        PrmNetmapSnapshot param = new();
-
-        if (useContext)
-        {
-            var ctx = new CallContext
-            {
-                CancellationToken = Mocker.CancellationTokenSource.Token,
-                Timeout = TimeSpan.FromSeconds(20)
-            };
-
-            param = new(ctx);
-            param.XHeaders.Add("headerKey1", "headerValue1");
-
-        }
-        else
-        {
-            param = new();
-        }
+        var ctx = useContext
+            ? new CallContext(TimeSpan.FromSeconds(20), Mocker.CancellationTokenSource.Token)
+            : default;
 
         var validTimeoutFrom = DateTime.UtcNow.AddSeconds(20);
 
-        var result = await GetClient(DefaultSettings).GetNetmapSnapshotAsync(param);
+        var result = await GetClient(DefaultSettings).GetNetmapSnapshotAsync(ctx);
 
         var validTimeoutTo = DateTime.UtcNow.AddSeconds(20);
 
@@ -166,13 +147,10 @@ public class NetworkTest : NetworkTestsBase
         if (useContext)
         {
             Assert.NotNull(Mocker.NetmapSnapshotRequest);
-            Assert.Single(Mocker.NetmapSnapshotRequest.MetaHeader.XHeaders);
-            Assert.Equal(param.XHeaders.Keys[0], Mocker.NetmapSnapshotRequest.MetaHeader.XHeaders.First().Key);
-            Assert.Equal(param.XHeaders[param.XHeaders.Keys[0]], Mocker.NetmapSnapshotRequest.MetaHeader.XHeaders.First().Value);
+            Assert.Empty(Mocker.NetmapSnapshotRequest.MetaHeader.XHeaders);
 
             Assert.Equal(Mocker.CancellationTokenSource.Token, Mocker.CancellationToken);
             Assert.NotNull(Mocker.DateTime);
-
             Assert.True(Mocker.DateTime.Value >= validTimeoutFrom);
             Assert.True(Mocker.DateTime.Value <= validTimeoutTo);
         }
@@ -206,28 +184,13 @@ public class NetworkTest : NetworkTestsBase
 
         Mocker.NodeInfoResponse = new LocalNodeInfoResponse { Body = body };
 
-        PrmNodeInfo param;
-
-        if (useContext)
-        {
-            var ctx = new CallContext
-            {
-                CancellationToken = Mocker.CancellationTokenSource.Token,
-                Timeout = TimeSpan.FromSeconds(20)
-            };
-
-            param = new(ctx);
-            param.XHeaders.Add("headerKey1", "headerValue1");
-
-        }
-        else
-        {
-            param = new();
-        }
+        var ctx = useContext
+            ? new CallContext(TimeSpan.FromSeconds(20), Mocker.CancellationTokenSource.Token)
+            : default;
 
         var validTimeoutFrom = DateTime.UtcNow.AddSeconds(20);
 
-        var result = await GetClient(DefaultSettings).GetNodeInfoAsync(param);
+        var result = await GetClient(DefaultSettings).GetNodeInfoAsync(ctx);
 
         var validTimeoutTo = DateTime.UtcNow.AddSeconds(20);
 
@@ -246,10 +209,7 @@ public class NetworkTest : NetworkTestsBase
         Assert.NotNull(Mocker.LocalNodeInfoRequest);
         if (useContext)
         {
-            Assert.Single(Mocker.LocalNodeInfoRequest.MetaHeader.XHeaders);
-            Assert.Equal(param.XHeaders.Keys[0], Mocker.LocalNodeInfoRequest.MetaHeader.XHeaders.First().Key);
-            Assert.Equal(param.XHeaders[param.XHeaders.Keys[0]], Mocker.LocalNodeInfoRequest.MetaHeader.XHeaders.First().Value);
-
+            Assert.Empty(Mocker.LocalNodeInfoRequest.MetaHeader.XHeaders);
             Assert.Equal(Mocker.CancellationTokenSource.Token, Mocker.CancellationToken);
             Assert.NotNull(Mocker.DateTime);
 

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

@@ -4,7 +4,7 @@ using FrostFS.SDK.Client.Interfaces;
 
 using Microsoft.Extensions.Options;
 
-namespace FrostFS.SDK.Tests;
+namespace FrostFS.SDK.Tests.Unit;
 
 [SuppressMessage("Reliability", "CA2007:Consider calling ConfigureAwait on the awaited task", Justification = "Default Value is correct for tests")]
 public abstract class NetworkTestsBase
@@ -25,7 +25,7 @@ public abstract class NetworkTestsBase
             Host = "http://localhost:8080",
         };
 
-        Mocker = new NetworkMocker(this.key);
+        Mocker = new NetworkMocker(key);
     }
 
     protected IFrostFSClient GetClient(ClientSettings settings)
@@ -34,8 +34,8 @@ public abstract class NetworkTestsBase
             Options.Create(settings),
             null,
             Mocker.GetMock().Object,
-            new SessionMocker(this.key).GetMock().Object,
-            new ContainerMocker(this.key).GetMock().Object,
-            new ObjectMocker(this.key).GetMock().Object);
+            new SessionMocker(key).GetMock().Object,
+            new ContainerMocker(key).GetMock().Object,
+            new ObjectMocker(key).GetMock().Object);
     }
 }

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

@@ -9,34 +9,12 @@ using FrostFS.SDK.Client.Mappers.GRPC;
 
 using Google.Protobuf;
 
-namespace FrostFS.SDK.Tests;
+namespace FrostFS.SDK.Tests.Unit;
 
 [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 ObjectTest : ObjectTestsBase
 {
-    [Fact]
-    public async void GetObjectTest()
-    {
-        var client = GetClient();
-
-        var objectId = client.CalculateObjectId(Mocker.ObjectHeader!);
-
-        var result = await client.GetObjectAsync(new PrmObjectGet(ContainerId, objectId));
-
-        Assert.NotNull(result);
-
-        Assert.NotNull(Mocker.ObjectHeader);
-
-        Assert.Equal(Mocker.ObjectHeader.ContainerId.GetValue(), result.Header.ContainerId.GetValue());
-        Assert.Equal(Mocker.ObjectHeader.OwnerId!.Value, result.Header.OwnerId!.Value);
-        Assert.Equal(Mocker.ObjectHeader.PayloadLength, result.Header.PayloadLength);
-        Assert.NotNull(result.Header.Attributes);
-        Assert.Single(result.Header.Attributes);
-        Assert.Equal(Mocker.ObjectHeader.Attributes![0].Key, result.Header.Attributes[0].Key);
-        Assert.Equal(Mocker.ObjectHeader.Attributes![0].Value, result.Header.Attributes[0].Value);
-    }
-
     [Fact]
     public async void PutObjectTest()
     {
@@ -46,14 +24,12 @@ public class ObjectTest : ObjectTestsBase
         var bytes = new byte[1024];
         rnd.NextBytes(bytes);
 
-        var param = new PrmObjectPut
-        {
-            Header = Mocker.ObjectHeader,
-            Payload = new MemoryStream(bytes),
-            ClientCut = false
-        };
+        var param = new PrmObjectPut(
+            Mocker.ObjectHeader,
+            payload: new MemoryStream(bytes),
+            clientCut: false);
 
-        var result = await GetClient().PutObjectAsync(param);
+        var result = await GetClient().PutObjectAsync(param, default);
 
         var sentMessages = Mocker.ClientStreamWriter!.Messages;
 
@@ -81,13 +57,11 @@ public class ObjectTest : ObjectTestsBase
         byte[] bytes = File.ReadAllBytes(@".\..\..\..\cat.jpg");
         var fileLength = bytes.Length;
 
-        var param = new PrmObjectPut
-        {
-            Header = Mocker.ObjectHeader,
-            Payload = new MemoryStream(bytes),
-            BufferMaxSize = 1024,
-            ClientCut = true
-        };
+        var param = new PrmObjectPut(
+            Mocker.ObjectHeader,
+            payload: new MemoryStream(bytes),
+            bufferMaxSize: 1024,
+            clientCut: true);
 
         Random rnd = new();
 
@@ -99,7 +73,7 @@ public class ObjectTest : ObjectTestsBase
         foreach (var objId in objIds)
             Mocker.ResultObjectIds!.Add(objId);
 
-        var result = await GetClient().PutObjectAsync(param);
+        var result = await GetClient().PutObjectAsync(param, default);
 
         var singleObjects = Mocker.PutSingleRequests.ToArray();
 
@@ -151,7 +125,7 @@ public class ObjectTest : ObjectTestsBase
         Assert.NotNull(header3.Split.ParentHeader);
         Assert.NotNull(header3.Split.ParentSignature);
         Assert.Equal(header2.Split.SplitId, header3.Split.SplitId);
-        Assert.Equal(bytes[((fileLength / blockSize) * blockSize)..fileLength], payload3);
+        Assert.Equal(bytes[(fileLength / blockSize * blockSize)..fileLength], payload3);
         Assert.True(header3.Attributes.Count == 0);
 
         //link object
@@ -175,7 +149,7 @@ public class ObjectTest : ObjectTestsBase
     {
         Mocker.ObjectId = new ObjectID { Value = ByteString.CopyFrom(SHA256.HashData(Encoding.UTF8.GetBytes("test"))) }.ToModel();
 
-        await GetClient().DeleteObjectAsync(new PrmObjectDelete(ContainerId, Mocker.ObjectId));
+        await GetClient().DeleteObjectAsync(new PrmObjectDelete(ContainerId, Mocker.ObjectId), default);
 
         var request = Mocker.DeleteRequests.FirstOrDefault();
         Assert.NotNull(request);
@@ -188,30 +162,33 @@ public class ObjectTest : ObjectTestsBase
     {
         Mocker.ObjectId = new ObjectID { Value = ByteString.CopyFrom(SHA256.HashData(Encoding.UTF8.GetBytes("test"))) }.ToModel();
 
-        var response = await GetClient().GetObjectHeadAsync(new PrmObjectHeadGet(ContainerId, Mocker.ObjectId));
+        var res = await GetClient().GetObjectHeadAsync(new PrmObjectHeadGet(ContainerId, Mocker.ObjectId), default);
+
+        var objHeader = res.HeaderInfo;
+        Assert.NotNull(objHeader);
 
         var request = Mocker.HeadRequests.FirstOrDefault();
         Assert.NotNull(request);
         Assert.Equal(ContainerId.ToMessage(), request.Body.Address.ContainerId);
         Assert.Equal(Mocker.ObjectId.ToMessage(), request.Body.Address.ObjectId);
 
-        Assert.NotNull(response);
-        Assert.Equal(ContainerId.GetValue(), response.ContainerId.GetValue());
+        Assert.NotNull(objHeader);
+        Assert.Equal(ContainerId.GetValue(), objHeader.ContainerId.GetValue());
 
-        Assert.Equal(Mocker.ObjectHeader!.OwnerId!.Value, response.OwnerId!.Value);
-        Assert.Equal(Mocker.ObjectHeader!.Version!.ToString(), response.Version!.ToString());
+        Assert.Equal(Mocker.ObjectHeader!.OwnerId!.Value, objHeader.OwnerId!.Value);
+        Assert.Equal(Mocker.ObjectHeader!.Version!.ToString(), objHeader.Version!.ToString());
 
-        Assert.Equal(Mocker.HeadResponse!.PayloadLength, response.PayloadLength);
+        Assert.Equal(Mocker.HeadResponse!.PayloadLength, objHeader.PayloadLength);
 
-        Assert.Equal(FrostFsObjectType.Regular, response.ObjectType);
+        Assert.Equal(FrostFsObjectType.Regular, objHeader.ObjectType);
 
-        Assert.NotNull(response.Attributes);
-        Assert.Single(response.Attributes);
+        Assert.NotNull(objHeader.Attributes);
+        Assert.Single(objHeader.Attributes);
 
-        Assert.Equal(Mocker.HeadResponse.Attributes[0].Key, response.Attributes.First().Key);
-        Assert.Equal(Mocker.HeadResponse.Attributes[0].Value, response.Attributes.First().Value);
+        Assert.Equal(Mocker.HeadResponse.Attributes[0].Key, objHeader.Attributes.First().Key);
+        Assert.Equal(Mocker.HeadResponse.Attributes[0].Value, objHeader.Attributes.First().Value);
 
-        Assert.Null(response.Split);
+        Assert.Null(objHeader.Split);
     }
 
     [Fact]
@@ -229,7 +206,7 @@ public class ObjectTest : ObjectTestsBase
 
         var param = new PrmRangeGet(ContainerId, Mocker.ObjectId, new FrostFsRange(100, (ulong)Mocker.RangeResponse.Length));
 
-        var result = await GetClient().GetRangeAsync(param);
+        var result = await GetClient().GetRangeAsync(param, default);
 
         Assert.NotNull(Mocker.GetRangeRequest);
 
@@ -271,7 +248,7 @@ public class ObjectTest : ObjectTestsBase
 
         var param = new PrmRangeHashGet(ContainerId, Mocker.ObjectId, [new FrostFsRange(100, len)], salt);
 
-        var result = await GetClient().GetRangeHashAsync(param);
+        var result = await GetClient().GetRangeHashAsync(param, default);
 
         Assert.NotNull(Mocker.GetRangeHashRequest);
 
@@ -299,14 +276,13 @@ public class ObjectTest : ObjectTestsBase
 
         var range = new FrostFsRange(8, (ulong)patch.Length);
 
-        var param = new PrmObjectPatch(address)
-        {
-            Payload = new MemoryStream(patch),
-            MaxPayloadPatchChunkLength = 32,
-            Range = range
-        };
+        var param = new PrmObjectPatch(
+            address,
+            payload: new MemoryStream(patch),
+            maxChunkLength: 32,
+            range: range);
 
-        var result = await GetClient().PatchObjectAsync(param);
+        var result = await GetClient().PatchObjectAsync(param, default);
 
         Assert.NotNull(result);
 

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

@@ -4,7 +4,7 @@ using FrostFS.SDK.Cryptography;
 
 using Microsoft.Extensions.Options;
 
-namespace FrostFS.SDK.Tests;
+namespace FrostFS.SDK.Tests.Unit;
 
 public abstract class ObjectTestsBase
 {

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

@@ -4,7 +4,7 @@ using FrostFS.SDK.Client;
 using FrostFS.SDK.Client.Mappers.GRPC;
 using FrostFS.SDK.Cryptography;
 
-namespace FrostFS.SDK.Tests;
+namespace FrostFS.SDK.Tests.Unit;
 
 [SuppressMessage("Reliability", "CA2007:Consider calling ConfigureAwait on the awaited task", Justification = "Default Value is correct for tests")]
 public class SessionTest : SessionTestsBase
@@ -17,26 +17,21 @@ public class SessionTest : SessionTestsBase
         var exp = 100u;
         PrmSessionCreate param;
 
+        CallContext ctx;
         if (useContext)
         {
-            var ctx = new CallContext
-            {
-                CancellationToken = Mocker.CancellationTokenSource.Token,
-                Timeout = TimeSpan.FromSeconds(20)
-            };
-
-            param = new PrmSessionCreate(exp, ctx);
-
-            param.XHeaders.Add("headerKey1", "headerValue1");
+            ctx = new CallContext(TimeSpan.FromSeconds(20), Mocker.CancellationTokenSource.Token);
+            param = new PrmSessionCreate(exp, ["headerKey1", "headerValue1"]);
         }
         else
         {
+            ctx = default;
             param = new PrmSessionCreate(exp);
         }
 
         var validTimeoutFrom = DateTime.UtcNow.AddSeconds(20);
 
-        var result = await GetClient().CreateSessionAsync(param);
+        var result = await GetClient().CreateSessionAsync(param, ctx);
 
         var validTimeoutTo = DateTime.UtcNow.AddSeconds(20);
 
@@ -64,8 +59,8 @@ public class SessionTest : SessionTestsBase
         if (useContext)
         {
             Assert.Single(Mocker.CreateSessionRequest.MetaHeader.XHeaders);
-            Assert.Equal(param.XHeaders.Keys[0], Mocker.CreateSessionRequest.MetaHeader.XHeaders.First().Key);
-            Assert.Equal(param.XHeaders[param.XHeaders.Keys[0]], Mocker.CreateSessionRequest.MetaHeader.XHeaders.First().Value);
+            Assert.Equal(param.XHeaders[0], Mocker.CreateSessionRequest.MetaHeader.XHeaders.First().Key);
+            Assert.Equal(param.XHeaders[1], Mocker.CreateSessionRequest.MetaHeader.XHeaders.First().Value);
 
             Assert.Equal(Mocker.CancellationTokenSource.Token, Mocker.CancellationToken);
             Assert.NotNull(Mocker.DateTime);

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

@@ -5,7 +5,7 @@ using FrostFS.SDK.Cryptography;
 
 using Microsoft.Extensions.Options;
 
-namespace FrostFS.SDK.Tests;
+namespace FrostFS.SDK.Tests.Unit;
 
 public abstract class SessionTestsBase
 {
@@ -28,7 +28,7 @@ public abstract class SessionTestsBase
         ECDsaKey = key.LoadWif();
         OwnerId = FrostFsOwner.FromKey(ECDsaKey);
 
-        Mocker = new SessionMocker(this.key)
+        Mocker = new SessionMocker(key)
         {
             PlacementPolicy = new FrostFsPlacementPolicy(true, new FrostFsReplica(1)),
             Version = new FrostFsVersion(2, 13)
@@ -40,9 +40,9 @@ public abstract class SessionTestsBase
         return Client.FrostFSClient.GetTestInstance(
             Settings,
             null,
-            new NetworkMocker(this.key).GetMock().Object,
+            new NetworkMocker(key).GetMock().Object,
             Mocker.GetMock().Object,
-            new ContainerMocker(this.key).GetMock().Object,
-            new ObjectMocker(this.key).GetMock().Object);
+            new ContainerMocker(key).GetMock().Object,
+            new ObjectMocker(key).GetMock().Object);
     }
 }