[#16] Unit tests

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

src/FrostFS.SDK.Tests/ContainerTest.cs

@@ -1,118 +1,112 @@
 using FrostFS.SDK.ClientV2;
-using FrostFS.SDK.Cryptography;
 using FrostFS.SDK.ModelsV2;
-using FrostFS.SDK.ModelsV2.Enums;
-using FrostFS.SDK.ModelsV2.Netmap;
+using FrostFS.SDK.ClientV2.Mappers.GRPC.Netmap;
 using FrostFS.SDK.ClientV2.Mappers.GRPC;
+using FrostFS.SDK.Cryptography;
 
 using Microsoft.Extensions.Options;
+using FrostFS.SDK.ModelsV2.Netmap;
+using FrostFS.SDK.ModelsV2.Enums;
+using Google.Protobuf;
+using FrostFS.SDK.ClientV2.Interfaces;
 
 namespace FrostFS.SDK.Tests;
 
-public class ContainerTest
-{
-    private readonly string key = "KwHDAJ66o8FoLBjVbjP2sWBmgBMGjt7Vv4boA7xQrBoAYBE397Aq";
 
-    [Fact]
-    public async void CreateContainerTest()
+public abstract class ContainerTestsBase
+{
+    protected readonly string key = "KwHDAJ66o8FoLBjVbjP2sWBmgBMGjt7Vv4boA7xQrBoAYBE397Aq";
+
+    protected IOptions<ClientSettings> Settings { get; set; }
+    protected ContainerMocker Mocker { get; set; }
+
+    protected ContainerTestsBase()
     {
-        var factory = new PutContainerMockFactory(this.key)
+        Settings = Options.Create(new ClientSettings
+        {
+            Key = key,
+            Host = "http://localhost:8080"
+        });
+
+        Mocker = new ContainerMocker(this.key)
         {
             PlacementPolicy = new PlacementPolicy(true, new Replica(1)),
             Version = new ModelsV2.Version(2, 13),
             ContainerGuid = Guid.NewGuid()
         };
+    }
 
-        var settings = Options.Create(new ClientSettings
-        {
-            Key = key,
-            Host = "http://localhost:8080"
-        });
+    protected IFrostFSClient GetClient()
+    {
+        return ClientV2.Client.GetTestInstance(
+         Settings,
+         null,
+         new NetworkMocker(this.key).GetMock().Object,
+         new SessionMocker(this.key).GetMock().Object,
+         Mocker.GetMock().Object,
+         new ObjectMocker(this.key).GetMock().Object);
+    }
+}
 
-        var fsClient = Client.GetTestInstance(
-            settings,
-            null,
-            new NetmapMockFactory(this.key).GetMock().Object,
-            new SessionMockFactory(this.key).GetMock().Object,
-            factory.GetMock().Object,
-            new ObjectMockFactory(this.key).GetMock().Object);
-
-        var result = await fsClient.CreateContainerAsync(new ModelsV2.Container(BasicAcl.PublicRW, factory.PlacementPolicy));
+public class ContainerTest : ContainerTestsBase
+{   
+    [Fact]
+    public async void CreateContainerTest()
+    {
+        var result = await GetClient().CreateContainerAsync(new ModelsV2.Container(BasicAcl.PublicRW, Mocker.PlacementPolicy));
 
         Assert.NotNull(result);
         Assert.NotNull(result.Value);
-        Assert.True(Base58.Encode(factory.ContainerGuid.ToBytes()) == result.Value);
+        Assert.True(Base58.Encode(Mocker.ContainerGuid.ToBytes()) == result.Value);
     }
 
     [Fact]
     public async void GetContainerTest()
     {
-        var factory = new GetContainerMockFactory(this.key)
-        {
-            PlacementPolicy = new PlacementPolicy(true, new Replica(1)),
-            Version = new ModelsV2.Version(2, 13),
-            Acl = BasicAcl.PublicRO,
-            ContainerGuid = Guid.NewGuid(),
-        };
+        var cid = new ContainerId(Base58.Encode(Mocker.ContainerGuid.ToBytes()));
 
-        var settings = Options.Create(new ClientSettings
-        {
-            Key = key,
-            Host = "http://localhost:8080"
-        });
+        Mocker.Acl = BasicAcl.PublicRO;
 
-        var fsClient = Client.GetTestInstance(
-            settings,
-            null,
-            new NetmapMockFactory(this.key).GetMock().Object,
-            new SessionMockFactory(this.key).GetMock().Object,
-            factory.GetMock().Object,
-            new ObjectMockFactory(this.key).GetMock().Object);
-
-        var cid = new ContainerId(Base58.Encode(factory.ContainerGuid.ToBytes()));
-
-        var context = new Context();
-
-        var result = await fsClient.GetContainerAsync(cid, context);
+        var result = await GetClient().GetContainerAsync(cid);
 
         Assert.NotNull(result);
-        Assert.Equal(factory.Acl, result.BasicAcl);
-        Assert.Equal(factory.ContainerGuid, result.Nonce);
-        Assert.Equal(0, factory.PlacementPolicy.CompareTo(result.PlacementPolicy));
-        Assert.Equal(factory.Version.ToString(), result.Version!.ToString());
+        Assert.Equal(Mocker.Acl, result.BasicAcl);
+        Assert.Equal(Mocker.ContainerGuid, result.Nonce);
+        Assert.Equal(0, Mocker.PlacementPolicy.CompareTo(result.PlacementPolicy));
+        Assert.Equal(Mocker.Version.ToString(), result.Version!.ToString());
+    }
+
+    [Fact]
+    public async void GetContainerListTest()
+    {
+        Mocker.ContainerIds.Add([0xaa]);
+        Mocker.ContainerIds.Add([0xbb]);
+        Mocker.ContainerIds.Add([0xcc]);
+
+        var result = GetClient().ListContainersAsync();
+
+        Assert.NotNull(result);
+
+        int i = 0;
+        await foreach (var cid in result)
+        {
+            var val = Base58.Encode(ByteString.CopyFrom(Mocker.ContainerIds[i++]).ToByteArray());
+            Assert.Equal(val, cid.Value);
+        }
+
+        Assert.Equal(3, i);
     }
 
     [Fact]
     public async void DeleteContainerAsyncTest()
     {
-        var factory = new DeleteContainerMockFactory(this.key)
-        {
-            Version = new ModelsV2.Version(2, 13),
-            Acl = BasicAcl.PublicRW,
-            ContainerGuid = Guid.NewGuid(),
-        };
+        var cid = new ContainerId(Base58.Encode(Mocker.ContainerGuid.ToBytes()));
 
-        var settings = Options.Create(new ClientSettings
-        {
-            Key = key,
-            Host = "http://localhost:8080"
-        });
+        await GetClient().DeleteContainerAsync(cid);
 
-        var fsClient = Client.GetTestInstance(
-            settings,
-            null,
-            new NetmapMockFactory(this.key).GetMock().Object,
-            new SessionMockFactory(this.key).GetMock().Object,
-            factory.GetMock().Object,
-            new ObjectMockFactory(this.key).GetMock().Object);
+        Assert.Single(Mocker.Requests);
 
-        var cid = new ContainerId(Base58.Encode(factory.ContainerGuid.ToBytes()));
-
-        await fsClient.DeleteContainerAsync(cid);
-
-        Assert.Single(factory.Requests);
-
-        var request = factory.Requests.First();
+        var request = Mocker.Requests.First();
         
         Assert.Equal(cid.ToGrpcMessage(), request.Request.Body.ContainerId);        
     }

src/FrostFS.SDK.Tests/FrostFS.SDK.Tests.csproj

@@ -9,6 +9,10 @@
     <IsTestProject>true</IsTestProject>
   </PropertyGroup>
 
+  <ItemGroup>
+    <None Remove="TestData\cat.jpeg" />
+  </ItemGroup>
+
   <ItemGroup>
     <PackageReference Include="coverlet.collector" Version="6.0.0" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
@@ -25,4 +29,10 @@
     <ProjectReference Include="..\FrostFS.SDK.ClientV2\FrostFS.SDK.ClientV2.csproj" />
   </ItemGroup>
 
+  <ItemGroup>
+    <None Update="TestData\cat.jpg">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+  </ItemGroup>
+
 </Project>

src/FrostFS.SDK.Tests/Mocks/AsyncStreamReaderMock.cs

@@ -0,0 +1,60 @@
+using FrostFS.Object;
+using FrostFS.Session;
+using Google.Protobuf;
+using Grpc.Core;
+using FrostFS.SDK.ClientV2;
+using FrostFS.SDK.ModelsV2;
+using FrostFS.SDK.ClientV2.Mappers.GRPC.Netmap;
+using FrostFS.SDK.ClientV2.Mappers.GRPC;
+using FrostFS.SDK.Cryptography;
+using System.Security.Cryptography;
+
+namespace FrostFS.SDK.Tests;
+
+public class AsyncStreamReaderMock(string key, ObjectHeader objectHeader) : ServiceBase(key), IAsyncStreamReader<GetResponse>
+{
+    public GetResponse Current
+    {
+        get
+        {
+            var header = new Header
+            {
+                ContainerId =  objectHeader.ContainerId.ToGrpcMessage(),
+                PayloadLength = objectHeader.PayloadLength,
+                Version = objectHeader.Version!.ToGrpcMessage(),
+                OwnerId = objectHeader.OwnerId!.ToGrpcMessage()
+            };
+
+            foreach (var attr in objectHeader.Attributes)
+                header.Attributes.Add(attr.ToGrpcMessage());
+
+            var response = new GetResponse
+            {
+                Body = new GetResponse.Types.Body
+                {
+                    Init = new GetResponse.Types.Body.Types.Init
+                    {
+                        Header = header,
+                        ObjectId = new Refs.ObjectID { Value = ByteString.CopyFrom(SHA256.HashData(Array.Empty<byte>())) },
+                        Signature = new Refs.Signature
+                        {
+                            Key = ByteString.CopyFrom(Key.PublicKey()),
+                            Sign = ByteString.CopyFrom(Key.SignData(header.ToByteArray())),
+                        }
+                    }
+                },
+                MetaHeader = new ResponseMetaHeader()
+            };
+
+            response.VerifyHeader = GetResponseVerificationHeader(response);
+
+            return response;
+        }
+    }
+
+    public Task<bool> MoveNext(CancellationToken cancellationToken)
+    {
+        return Task.FromResult(true);
+    }
+}
+

src/FrostFS.SDK.Tests/Mocks/ClientStreamWriter.cs

@@ -0,0 +1,29 @@
+using Grpc.Core;
+using FrostFS.SDK.ProtosV2.Interfaces;
+
+namespace FrostFS.SDK.Tests;
+
+public class ClientStreamWriter : IClientStreamWriter<IRequest>
+{
+    public List<IRequest> Messages { get; set; } = [];
+    public bool CompletedTask { get; private set; }
+
+    public WriteOptions? WriteOptions
+    {
+        get => throw new NotImplementedException();
+        set => throw new NotImplementedException();
+    }
+
+    public Task CompleteAsync()
+    {
+        CompletedTask = true;
+        return Task.CompletedTask;        
+    }
+
+    public Task WriteAsync(IRequest message)
+    {   
+        Messages.Add(message);        
+        return Task.CompletedTask;
+    }
+}
+

src/FrostFS.SDK.Tests/Mocks/ContainerServiceMocks/ContainerServiceBase.cs

@@ -17,6 +17,7 @@ namespace FrostFS.SDK.Tests;
 
 public abstract class ServiceBase(string key)
 {
+    public string StringKey { get; private set; } = key;
     public ECDsa Key { get; private set; } = key.LoadWif();
     public ModelsV2.Version Version { get; set; } = DefaultVersion;
     public BasicAcl Acl { get; set; } = DefaultAcl;

src/FrostFS.SDK.Tests/Mocks/ContainerServiceMocks/ContainerStub.cs

@@ -1,7 +1,6 @@
 using FrostFS.Container;
 using Moq;
 
-
 namespace FrostFS.SDK.Tests;
 
 public class ContainerStub(string key) : ContainerServiceBase(key)

src/FrostFS.SDK.Tests/Mocks/ContainerServiceMocks/DeleteContainerMock.cs

@@ -1,54 +0,0 @@
-using FrostFS.Container;
-using FrostFS.Session;
-using Grpc.Core;
-using Moq;
-
-namespace FrostFS.SDK.Tests;
-
-public class DeleteContainerMockFactory(string key) : ContainerServiceBase(key)
-{
-    public override Mock<ContainerService.ContainerServiceClient> GetMock()
-    {
-        var mock = new Mock<ContainerService.ContainerServiceClient>();
-
-        var v = mock.Setup(x => x.DeleteAsync(
-            It.IsAny<DeleteRequest>(),
-            It.IsAny<Metadata>(),
-            It.IsAny<DateTime?>(),
-            It.IsAny<CancellationToken>()))
-            .Returns((DeleteRequest r, Metadata m, DateTime? dt, CancellationToken ct) =>
-            {
-                Requests.Add(new RequestData<DeleteRequest>(r, m, dt, ct));
-
-                var response = new DeleteResponse
-                {
-                    Body = new DeleteResponse.Types.Body(),
-                    MetaHeader = new ResponseMetaHeader()
-                };
-
-                var metadata = new Metadata();
-
-                response.VerifyHeader = GetResponseVerificationHeader(response);
-
-                return new AsyncUnaryCall<DeleteResponse>(
-                    Task.FromResult(response),
-                    Task.FromResult(metadata),
-                    () => new Grpc.Core.Status(StatusCode.OK, string.Empty),
-                    () => metadata,
-                    () => { });
-            });
-
-        return mock;
-    }
-
-    public List<RequestData<DeleteRequest>> Requests = [];
-}
-
-public class RequestData<T>(T request, Metadata m, DateTime? dt, CancellationToken ct)
-{
-    public T Request => request;
-    public Metadata Metadata => m;
-    public DateTime? deadline => dt;
-    public CancellationToken CancellationToken => ct;
-}
-       

src/FrostFS.SDK.Tests/Mocks/ContainerServiceMocks/GetContainerMock.cs

@@ -8,10 +8,13 @@ using FrostFS.SDK.ClientV2;
 using FrostFS.SDK.ModelsV2.Netmap;
 using FrostFS.SDK.ClientV2.Mappers.GRPC.Netmap;
 using FrostFS.SDK.ClientV2.Mappers.GRPC;
+using FrostFS.Session;
+using FrostFS.Refs;
+using System.Collections.Generic;
 
 namespace FrostFS.SDK.Tests;
 
-public class GetContainerMockFactory(string key) : ContainerServiceBase(key)
+public class ContainerMocker(string key) : ContainerServiceBase(key)
 {
     public override Mock<ContainerService.ContainerServiceClient> GetMock()
     {
@@ -19,7 +22,46 @@ public class GetContainerMockFactory(string key) : ContainerServiceBase(key)
 
         var grpcVersion = Version.ToGrpcMessage();
 
-        var response = new GetResponse
+        PutResponse putResponse = new()
+        {
+            Body = new PutResponse.Types.Body
+            {
+                ContainerId = new ContainerID
+                {
+                    Value = ByteString.CopyFrom(ContainerGuid.ToBytes())
+                }
+            },
+            MetaHeader = new ResponseMetaHeader
+            {
+                Version = Version is null ? DefaultVersion.ToGrpcMessage() : Version.ToGrpcMessage(),
+                Epoch = 100,
+                Ttl = 1
+            }
+        };
+
+        putResponse.VerifyHeader = GetResponseVerificationHeader(putResponse);
+
+        var metadata = new Metadata();
+        var putContainerResponse = new AsyncUnaryCall<PutResponse>(
+                    Task.FromResult(putResponse),
+                    Task.FromResult(metadata),
+                    () => new Grpc.Core.Status(StatusCode.OK, string.Empty),
+                    () => metadata,
+                    () => { });
+
+        mock.Setup(x => x.PutAsync(
+            It.IsAny<PutRequest>(),
+            It.IsAny<Metadata>(),
+            It.IsAny<DateTime?>(),
+            It.IsAny<CancellationToken>()))
+                .Returns((PutRequest r, Metadata m, DateTime? dt, CancellationToken ct) =>
+                {
+                    Verifier.CheckRequest(r);
+
+                    return putContainerResponse;
+                });
+
+        var getResponse = new GetResponse
         {
             Body = new GetResponse.Types.Body
             {
@@ -34,7 +76,7 @@ public class GetContainerMockFactory(string key) : ContainerServiceBase(key)
             MetaHeader = ResponseMetaHeader
         };
 
-        response.VerifyHeader = GetResponseVerificationHeader(response);
+        getResponse.VerifyHeader = GetResponseVerificationHeader(getResponse);
 
         mock.Setup(x => x.GetAsync(
             It.IsAny<GetRequest>(),
@@ -46,13 +88,74 @@ public class GetContainerMockFactory(string key) : ContainerServiceBase(key)
                     Verifier.CheckRequest(r);
 
                     return new AsyncUnaryCall<GetResponse>(
-                        Task.FromResult(response),
+                        Task.FromResult(getResponse),
                         Task.FromResult(ResponseMetaData),
                         () => new Grpc.Core.Status(StatusCode.OK, string.Empty),
                         () => ResponseMetaData,
                         () => { });
                 });
 
+        var listResponse = new ListResponse
+        {
+            Body = new ListResponse.Types.Body(),
+            MetaHeader = ResponseMetaHeader
+        };
+
+        foreach (var item in ContainerIds)
+        {
+            listResponse.Body.ContainerIds.Add(new ContainerID { Value = ByteString.CopyFrom(item) });
+        }
+
+        listResponse.VerifyHeader = GetResponseVerificationHeader(listResponse);
+
+        mock.Setup(x => x.ListAsync(
+           It.IsAny<ListRequest>(),
+           It.IsAny<Metadata>(),
+           It.IsAny<DateTime?>(),
+           It.IsAny<CancellationToken>()))
+               .Returns((ListRequest r, Metadata m, DateTime? dt, CancellationToken ct) =>
+               {
+                   Verifier.CheckRequest(r);
+
+                   return new AsyncUnaryCall<ListResponse>(
+                       Task.FromResult(listResponse),
+                       Task.FromResult(ResponseMetaData),
+                       () => new Grpc.Core.Status(StatusCode.OK, string.Empty),
+                       () => ResponseMetaData,
+                       () => { });
+               });
+
+        var v = mock.Setup(x => x.DeleteAsync(
+           It.IsAny<DeleteRequest>(),
+           It.IsAny<Metadata>(),
+           It.IsAny<DateTime?>(),
+           It.IsAny<CancellationToken>()))
+           .Returns((DeleteRequest r, Metadata m, DateTime? dt, CancellationToken ct) =>
+           {
+               Requests.Add(new RequestData<DeleteRequest>(r, m, dt, ct));
+
+               var response = new DeleteResponse
+               {
+                   Body = new DeleteResponse.Types.Body(),
+                   MetaHeader = new ResponseMetaHeader()
+               };
+
+               var metadata = new Metadata();
+
+               response.VerifyHeader = GetResponseVerificationHeader(response);
+
+               return new AsyncUnaryCall<DeleteResponse>(
+                   Task.FromResult(response),
+                   Task.FromResult(metadata),
+                   () => new Grpc.Core.Status(StatusCode.OK, string.Empty),
+                   () => metadata,
+                   () => { });
+           });
+
         return mock;
     }
+
+    public List<byte[]> ContainerIds { get; set; } = [];
+
+    public List<RequestData<DeleteRequest>> Requests { get; set; } = [];
 }

src/FrostFS.SDK.Tests/Mocks/ContainerServiceMocks/PutContainerMock.cs

@@ -1,88 +0,0 @@
-using FrostFS.Container;
-using FrostFS.Session;
-using Google.Protobuf;
-using Grpc.Core;
-using Moq;
-using FrostFS.SDK.ClientV2;
-using FrostFS.SDK.ClientV2.Mappers.GRPC.Netmap;
-using FrostFS.SDK.ClientV2.Mappers.GRPC;
-using FrostFS.SDK.Cryptography;
-using FrostFS.Refs;
-
-namespace FrostFS.SDK.Tests;
-
-public class PutContainerMockFactory(string key) : ContainerServiceBase(key)
-{
-    public override Mock<ContainerService.ContainerServiceClient> GetMock()
-    {
-        var mock = new Mock<ContainerService.ContainerServiceClient>();
-
-        PutResponse response = new()
-        {
-            Body = new PutResponse.Types.Body
-            {
-                ContainerId = new ContainerID
-                {
-                    Value = ByteString.CopyFrom(ContainerGuid.ToBytes())
-                }
-            },
-            MetaHeader = new ResponseMetaHeader
-            {
-                Version = Version is null ? DefaultVersion.ToGrpcMessage() : Version.ToGrpcMessage(),
-                Epoch = 100,
-                Ttl = 1
-            }
-        };
-
-        response.VerifyHeader = PutResponseVerificationHeader(response);
-
-        var metadata = new Metadata();
-        var putContainerResponse = new AsyncUnaryCall<PutResponse>(
-                    Task.FromResult(response),
-                    Task.FromResult(metadata),
-                    () => new Grpc.Core.Status(StatusCode.OK, string.Empty),
-                    () => metadata,
-                    () => { });
-
-        mock.Setup(x => x.PutAsync(
-            It.IsAny<PutRequest>(),
-            It.IsAny<Metadata>(),
-            It.IsAny<DateTime?>(),
-            It.IsAny<CancellationToken>()))
-                .Returns((PutRequest r, Metadata m, DateTime? dt, CancellationToken ct) =>
-                {
-                    Verifier.CheckRequest(r);
-
-                    return putContainerResponse;
-                });
-
-        return mock;
-    }
-
-    private ResponseVerificationHeader PutResponseVerificationHeader(PutResponse response)
-    {
-        var verifyHeader = new ResponseVerificationHeader
-        {
-            MetaSignature = new Signature
-            {
-                Key = ByteString.CopyFrom(Key.PublicKey()),
-                Scheme = SignatureScheme.EcdsaRfc6979Sha256,
-                Sign = ByteString.CopyFrom(Key.SignData(response.MetaHeader.ToByteArray()))
-            },
-            BodySignature = new Signature
-            {
-                Key = ByteString.CopyFrom(Key.PublicKey()),
-                Scheme = SignatureScheme.EcdsaRfc6979Sha256,
-                Sign = ByteString.CopyFrom(Key.SignData(response.GetBody().ToByteArray()))
-            },
-            OriginSignature = new Signature
-            {
-                Key = ByteString.CopyFrom(Key.PublicKey()),
-                Scheme = SignatureScheme.EcdsaRfc6979Sha256,
-                Sign = ByteString.CopyFrom(Key.SignData([]))
-            }
-        };
-
-        return verifyHeader;
-    }
-}

src/FrostFS.SDK.Tests/Mocks/ContainerServiceMocks/RequestData.cs

@@ -0,0 +1,12 @@
+using Grpc.Core;
+
+namespace FrostFS.SDK.Tests;
+
+public class RequestData<T>(T request, Metadata m, DateTime? dt, CancellationToken ct)
+{
+    public T Request => request;
+    public Metadata Metadata => m;
+    public DateTime? Deadline => dt;
+    public CancellationToken CancellationToken => ct;
+}
+       

src/FrostFS.SDK.Tests/Mocks/NetmapMock.cs

@@ -1,14 +0,0 @@
-using Moq;
-using FrostFS.Netmap;
-
-namespace FrostFS.SDK.Tests;
-
-public class NetmapMockFactory(string key) : ServiceBase(key)
-{
-    public Mock<NetmapService.NetmapServiceClient> GetMock()
-    {
-        var mock = new Mock<NetmapService.NetmapServiceClient>();
-
-        return mock;
-    }
-}

src/FrostFS.SDK.Tests/Mocks/NetworkMocker.cs

@@ -0,0 +1,78 @@
+using Moq;
+using FrostFS.Netmap;
+using Grpc.Core;
+using FrostFS.SDK.ClientV2;
+using Google.Protobuf;
+using NuGet.Frameworks;
+
+namespace FrostFS.SDK.Tests;
+
+public class NetworkMocker(string key) : ServiceBase(key)
+{
+    private static readonly string[] parameterKeys = [
+        "ContainerFee",
+        "EpochDuration",
+        "IRCandidateFee",
+        "MaxECDataCount",
+        "MaxECParityCount",
+        "MaxObjectSize",
+        "WithdrawalFee",
+        "HomomorphicHashingDisabled",
+        "MaintenanceModeAllowed" ];
+
+    public Dictionary<string, byte[]>? Parameters { get; set; }
+
+    public Mock<NetmapService.NetmapServiceClient> GetMock()
+    {
+        var mock = new Mock<NetmapService.NetmapServiceClient>();
+
+        var networkInfoResponse = new NetworkInfoResponse();
+
+        var networkConfig = new NetworkConfig();
+
+        foreach (var key in parameterKeys)
+        {
+            networkConfig.Parameters.Add(new NetworkConfig.Types.Parameter
+            {
+                Key = ByteString.CopyFromUtf8(key),
+                Value = (Parameters != null && Parameters.TryGetValue(key, out byte[]? value)) ? ByteString.CopyFrom(value) : ByteString.CopyFrom(0)
+            });
+        }
+
+        var response = new NetworkInfoResponse
+        {
+            Body = new NetworkInfoResponse.Types.Body
+            {
+                NetworkInfo = new NetworkInfo
+                {
+                    CurrentEpoch = 99,
+                    MagicNumber = 13,
+                    MsPerBlock = 999,
+                    NetworkConfig = networkConfig
+                }
+            },
+            MetaHeader = ResponseMetaHeader
+        };
+
+        response.VerifyHeader = GetResponseVerificationHeader(response);
+
+        mock.Setup(x => x.NetworkInfoAsync(
+                It.IsAny<NetworkInfoRequest>(),
+                It.IsAny<Metadata>(),
+                It.IsAny<DateTime?>(),
+                It.IsAny<CancellationToken>()))
+                .Returns((NetworkInfoRequest r, Metadata m, DateTime? dt, CancellationToken ct) =>
+                {
+                    Verifier.CheckRequest(r);
+
+                    return new AsyncUnaryCall<NetworkInfoResponse>(
+                        Task.FromResult(response),
+                        Task.FromResult(ResponseMetaData),
+                        () => new Grpc.Core.Status(StatusCode.OK, string.Empty),
+                        () => ResponseMetaData,
+                        () => { });
+                });
+
+        return mock;
+    }
+}

src/FrostFS.SDK.Tests/Mocks/ObjectMock.cs

@@ -1,101 +1,208 @@
-using Moq;
-using FrostFS.Object;
-using Grpc.Core;
-using FrostFS.SDK.ClientV2;
-using FrostFS.Session;
 using Google.Protobuf;
+using Grpc.Core;
+using Moq;
+using FrostFS.SDK.ClientV2;
+using FrostFS.SDK.ModelsV2;
+using FrostFS.Object;
+using FrostFS.SDK.ClientV2.Mappers.GRPC;
 using System.Security.Cryptography;
 using FrostFS.SDK.Cryptography;
-using FrostFS.SDK.ClientV2.Mappers.GRPC;
-using FrostFS.SDK.ModelsV2;
 
 namespace FrostFS.SDK.Tests;
 
-public class ObjectMockFactory(string key) : ObjectServiceBase(key)
+public class ObjectMocker(string key) : ObjectServiceBase(key)
 {
     public override Mock<ObjectService.ObjectServiceClient> GetMock()
     {
         var mock = new Mock<ObjectService.ObjectServiceClient>();
 
-        GetResponse response = new() 
+        if (ObjectHeader != null)
         {
-            Body = new GetResponse.Types.Body
-            {                 
-            },
-            MetaHeader = ResponseMetaHeader
-        };
-
-        response.VerifyHeader = GetResponseVerificationHeader(response);
-
-        mock.Setup(x => x.Get(
-            It.IsAny<GetRequest>(),
-            It.IsAny<Metadata>(),
-            It.IsAny<DateTime?>(),
-            It.IsAny<CancellationToken>()))
-             .Returns((GetRequest r, Metadata m, DateTime? dt, CancellationToken ct) =>
+            mock.Setup(x => x.Get(
+                It.IsAny<GetRequest>(),
+                It.IsAny<Metadata>(),
+                It.IsAny<DateTime?>(),
+                It.IsAny<CancellationToken>()))
+                .Returns((GetRequest r, Metadata m, DateTime? dt, CancellationToken ct) =>
                 {
                     Verifier.CheckRequest(r);
 
-                     return new AsyncServerStreamingCall<GetResponse>(
-                        new AsyncStreamReaderMock(key, ObjectHeader),
+                    return new AsyncServerStreamingCall<GetResponse>(
+                        new AsyncStreamReaderMock(StringKey, ObjectHeader),
                         Task.FromResult(ResponseMetaData),
                         () => new Grpc.Core.Status(StatusCode.OK, string.Empty),
                         () => ResponseMetaData,
                         () => { });
                 });
 
+            HeadResponse ??= new Header
+            {
+                CreationEpoch = 99,
+                ContainerId = ObjectHeader.ContainerId.ToGrpcMessage(),
+                ObjectType = ObjectType.Regular,
+                OwnerId = ObjectHeader.OwnerId!.ToGrpcMessage(),
+                PayloadLength = 1,
+                PayloadHash = new Refs.Checksum { Type = Refs.ChecksumType.Sha256, Sum = ByteString.CopyFrom(SHA256.HashData([0xff])) },
+                Version = ObjectHeader.Version!.ToGrpcMessage()
+            };
+
+            HeadResponse headResponse = new()
+            {
+                Body = new HeadResponse.Types.Body
+                {
+                    Header = new HeaderWithSignature
+                    {
+                        Header = HeadResponse
+                    }
+                },
+                MetaHeader = ResponseMetaHeader
+            };
+
+            headResponse.Body.Header.Header.Attributes.Add(new Header.Types.Attribute { Key = "k", Value = "v" });
+
+            headResponse.Body.Header.Signature = new Refs.Signature
+            {
+                Key = ByteString.CopyFrom(Key.PublicKey()),
+                Sign = ByteString.CopyFrom(Key.SignData(headResponse.Body.Header.ToByteArray())),
+            };
+
+            headResponse.VerifyHeader = GetResponseVerificationHeader(headResponse);
+
+            mock.Setup(x => x.HeadAsync(
+                It.IsAny<HeadRequest>(),
+                It.IsAny<Metadata>(),
+                It.IsAny<DateTime?>(),
+                It.IsAny<CancellationToken>()))
+                .Returns((HeadRequest r, Metadata m, DateTime? dt, CancellationToken ct) =>
+                {
+                    Verifier.CheckRequest(r);
+
+                    HeadRequests.Add(r);
+
+                    return new AsyncUnaryCall<HeadResponse>(
+                        Task.FromResult(headResponse),
+                        Task.FromResult(ResponseMetaData),
+                        () => new Grpc.Core.Status(StatusCode.OK, string.Empty),
+                        () => ResponseMetaData,
+                        () => { });
+                });
+
+        }
+
+        if (ResultObjectId != null)
+        {
+            PutResponse putResponse = new()
+            {
+                Body = new PutResponse.Types.Body
+                {
+                    ObjectId = new Refs.ObjectID
+                    {
+                        Value = ByteString.CopyFrom(ResultObjectId)
+                    }
+                },
+                MetaHeader = ResponseMetaHeader,
+            };
+
+            putResponse.VerifyHeader = GetResponseVerificationHeader(putResponse);
+
+            mock.Setup(x => x.Put(
+                It.IsAny<Metadata>(),
+                It.IsAny<DateTime?>(),
+                It.IsAny<CancellationToken>()))
+                .Returns((Metadata m, DateTime? dt, CancellationToken ct) =>
+                {
+                    return new AsyncClientStreamingCall<PutRequest, PutResponse>(
+                        ClientStreamWriter!,
+                        Task.FromResult(putResponse),
+                        Task.FromResult(ResponseMetaData),
+                        () => new Grpc.Core.Status(StatusCode.OK, string.Empty),
+                        () => ResponseMetaData,
+                        () => { });
+                });
+        }
+
+        PutSingleResponse putSingleResponse = new()
+        {
+            Body = new PutSingleResponse.Types.Body(),
+            MetaHeader = ResponseMetaHeader,
+        };
+
+        putSingleResponse.VerifyHeader = GetResponseVerificationHeader(putSingleResponse);
+
+        mock.Setup(x => x.PutSingleAsync(
+            It.IsAny<PutSingleRequest>(),
+            It.IsAny<Metadata>(),
+            It.IsAny<DateTime?>(),
+            It.IsAny<CancellationToken>()))
+            .Returns((PutSingleRequest r, Metadata m, DateTime? dt, CancellationToken ct) =>
+            {
+                Verifier.CheckRequest(r);
+
+                PutSingleRequests.Add(r);
+
+                return new AsyncUnaryCall<PutSingleResponse>(
+                    Task.FromResult(putSingleResponse),
+                    Task.FromResult(ResponseMetaData),
+                    () => new Grpc.Core.Status(StatusCode.OK, string.Empty),
+                    () => ResponseMetaData,
+                    () => { });
+            });
+
+        if (ObjectId != null)
+        {
+            DeleteResponse deleteResponse = new()
+            {
+                Body = new DeleteResponse.Types.Body
+                {
+                    Tombstone = new Refs.Address
+                    {
+                        ContainerId = ObjectHeader!.ContainerId.ToGrpcMessage(),
+                        ObjectId = ObjectId.ToGrpcMessage()
+                    }
+                },
+                MetaHeader = ResponseMetaHeader
+            };
+
+            deleteResponse.VerifyHeader = GetResponseVerificationHeader(deleteResponse);
+
+            mock.Setup(x => x.DeleteAsync(
+                It.IsAny<DeleteRequest>(),
+                It.IsAny<Metadata>(),
+                It.IsAny<DateTime?>(),
+                It.IsAny<CancellationToken>()))
+                .Returns((DeleteRequest r, Metadata m, DateTime? dt, CancellationToken ct) =>
+                {
+                    Verifier.CheckRequest(r);
+
+                    DeleteRequests.Add(r);
+
+                    return new AsyncUnaryCall<DeleteResponse>(
+                        Task.FromResult(deleteResponse),
+                        Task.FromResult(ResponseMetaData),
+                        () => new Grpc.Core.Status(StatusCode.OK, string.Empty),
+                        () => ResponseMetaData,
+                        () => { });
+                });
+        }
+
+        
         return mock;
     }
 
-    public ObjectHeader ObjectHeader { get; set; }
-}
-
-public class AsyncStreamReaderMock(string key, ObjectHeader objectHeader) : ServiceBase(key), IAsyncStreamReader<GetResponse>
-{
-    public GetResponse Current
-    {
-        get
-        {
-            var ecdsaKey = key.LoadWif();
-
-            var header = new Header
-            {
-                ContainerId =  objectHeader.ContainerId.ToGrpcMessage(),
-                PayloadLength = objectHeader.PayloadLength,
-                Version = objectHeader.Version!.ToGrpcMessage(),
-                OwnerId = objectHeader.OwnerId!.ToGrpcMessage()
-            };
-
-            foreach (var attr in objectHeader.Attributes)
-                header.Attributes.Add(attr.ToGrpcMessage());
-
-            var response = new GetResponse
-            {
-                Body = new GetResponse.Types.Body
-                {
-                    Init = new GetResponse.Types.Body.Types.Init
-                    {
-                        Header = header,
-                        ObjectId = new Refs.ObjectID { Value = ByteString.CopyFrom(SHA256.HashData(Array.Empty<byte>())) },
-                        Signature = new Refs.Signature
-                        {
-                            Key = ByteString.CopyFrom(ecdsaKey.PublicKey()),
-                            Sign = ByteString.CopyFrom(ecdsaKey.SignData(header.ToByteArray())),
-                        }
-                    }
-                },
-                MetaHeader = new ResponseMetaHeader()
-            };
-
-            response.VerifyHeader = GetResponseVerificationHeader(response);
-
-            return response;
-        }
-    }
-
-    public Task<bool> MoveNext(CancellationToken cancellationToken)
-    {
-        return Task.FromResult(true);
-    }
+    public ObjectId? ObjectId { get; set; }
+
+    public ObjectHeader? ObjectHeader { get; set; }
+
+    public Header? HeadResponse { get; set; }
+
+    public byte[]? ResultObjectId { get; set; }
+
+    public ClientStreamWriter? ClientStreamWriter { get; private set; } = new ();
+
+    public List<PutSingleRequest> PutSingleRequests { get; private set; } = [];
+
+    public List<DeleteRequest> DeleteRequests { get; private set; } = [];
+
+    public List<HeadRequest> HeadRequests { get; private set; } = [];
 }
 

src/FrostFS.SDK.Tests/Mocks/SessionMock.cs

@@ -6,7 +6,7 @@ using Google.Protobuf;
 
 namespace FrostFS.SDK.Tests;
 
-public class SessionMockFactory(string key) : ServiceBase(key)
+public class SessionMocker(string key) : ServiceBase(key)
 {
     public byte[]? SessionId { get; set; }
 

src/FrostFS.SDK.Tests/ObjectTest.cs

@@ -1,66 +1,237 @@
+using FrostFS.Refs;
 using FrostFS.SDK.ClientV2;
+using FrostFS.SDK.ClientV2.Interfaces;
 using FrostFS.SDK.ClientV2.Mappers.GRPC;
 using FrostFS.SDK.Cryptography;
 using FrostFS.SDK.ModelsV2;
+using FrostFS.SDK.ModelsV2.Enums;
 using FrostFS.SDK.ModelsV2.Netmap;
+using Google.Protobuf;
 using Microsoft.Extensions.Options;
-
 using System.Security.Cryptography;
+using System.Text;
 
 namespace FrostFS.SDK.Tests;
 
-public class ObjectTest
+public abstract class ObjectTestsBase
 {
-    private readonly string key = "KwHDAJ66o8FoLBjVbjP2sWBmgBMGjt7Vv4boA7xQrBoAYBE397Aq";
+    protected static readonly string key = "KwHDAJ66o8FoLBjVbjP2sWBmgBMGjt7Vv4boA7xQrBoAYBE397Aq";
 
-    [Fact]
-    public async void GetObjectTest()
+    protected IOptions<ClientSettings> Settings { get; set; }
+    protected ContainerId ContainerId { get; set; }
+
+    protected NetworkMocker NetworkMocker { get; set; } = new NetworkMocker(key);
+    protected SessionMocker SessionMocker { get; set; } = new SessionMocker(key);
+    protected ContainerMocker ContainerMocker { get; set; } = new ContainerMocker(key);
+    protected ObjectMocker Mocker { get; set; }
+
+    protected ObjectTestsBase()
     {
         var ecdsaKey = key.LoadWif();
-        ContainerId cntId = new("xyz");
-
-        ObjectHeader header = new(cntId, ModelsV2.Enums.ObjectType.Regular, [new ObjectAttribute("k", "v")])
-        {
-            PayloadLength = 1,
-            Version = new ModelsV2.Version(2, 13),
-            OwnerId = OwnerId.FromKey(ecdsaKey)
-        };
-
-        var objectMockFactory = new ObjectMockFactory(this.key)
-        {
-            PlacementPolicy = new PlacementPolicy(true, new Replica(1)),
-            Version = new ModelsV2.Version(2, 13),
-            ContainerGuid = Guid.NewGuid(),
-            ObjectHeader = header
-        };
         
-        var settings = Options.Create(new ClientSettings
+        Settings = Options.Create(new ClientSettings
         {
             Key = key,
             Host = "http://localhost:8080"
         });
 
-        var fsClient = Client.GetTestInstance(
-            settings,
+        Mocker = new ObjectMocker(key)
+        {
+            PlacementPolicy = new PlacementPolicy(true, new Replica(1)),
+            Version = new ModelsV2.Version(2, 13),
+            ContainerGuid = Guid.NewGuid()
+        };
+
+        ContainerId = new ContainerId(Base58.Encode(Mocker.ContainerGuid.ToBytes()));
+
+        Mocker.ObjectHeader = new(ContainerId, ModelsV2.Enums.ObjectType.Regular, [new ObjectAttribute("k", "v")])
+        {
+            PayloadLength = 1,
+            Version = new ModelsV2.Version(2, 13),
+            OwnerId = OwnerId.FromKey(ecdsaKey)
+        };
+    }
+
+    protected IFrostFSClient GetClient()
+    {   
+        return Client.GetTestInstance(
+            Settings,
             null,
-            new NetmapMockFactory(this.key).GetMock().Object,
-            new SessionMockFactory(this.key).GetMock().Object,
-            new ContainerStub(this.key).GetMock().Object,
-            objectMockFactory.GetMock().Object);
+            NetworkMocker.GetMock().Object,
+            SessionMocker.GetMock().Object,
+            ContainerMocker.GetMock().Object,
+            Mocker.GetMock().Object);
+    }
+}
 
-        var objectId = fsClient.CalculateObjectId(header);
+public class ObjectTest : ObjectTestsBase
+{
+    [Fact]
+    public async void GetObjectTest()
+    {
+        var client = GetClient();
+        var objectId = client.CalculateObjectId(Mocker.ObjectHeader!);
 
-        var containerId = new ContainerId(Base58.Encode(objectMockFactory.ContainerGuid.ToBytes()));
+        var context = new Context
+        {
+            Timeout = TimeSpan.FromSeconds(2)
+        };
 
-        var result = await fsClient.GetObjectAsync(containerId, objectId);
+        var result = await client.GetObjectAsync(ContainerId, objectId, context);
 
         Assert.NotNull(result);
 
-        Assert.Equal(header.ContainerId.Value, result.Header.ContainerId.Value);
-        Assert.Equal(header.OwnerId.ToGrpcMessage().ToString(), result.Header.OwnerId!.Value);
-        Assert.Equal(header.PayloadLength, result.Header.PayloadLength);
+        Assert.Equal(Mocker.ObjectHeader!.ContainerId.Value, result.Header.ContainerId.Value);
+        Assert.Equal(Mocker.ObjectHeader!.OwnerId!.ToGrpcMessage().ToString(), result.Header.OwnerId!.Value);
+        Assert.Equal(Mocker.ObjectHeader.PayloadLength, result.Header.PayloadLength);
         Assert.Single(result.Header.Attributes);
-        Assert.Equal(header.Attributes[0].Key, result.Header.Attributes[0].Key);
-        Assert.Equal(header.Attributes[0].Value,result.Header.Attributes[0].Value);
+        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()
+    {
+        Mocker.ResultObjectId = SHA256.HashData([]);
+       
+        Random rnd = new();
+        var bytes = new byte[1024];
+        rnd.NextBytes(bytes);
+
+        var param = new PutObjectParameters
+        {
+            Header = Mocker.ObjectHeader,
+            Payload = new MemoryStream(bytes),
+            ClientCut = false
+        };
+
+        var result = await GetClient().PutObjectAsync(param);
+
+        var sentMessages = Mocker.ClientStreamWriter!.Messages;
+
+        var body1 = sentMessages.ElementAt(0).GetBody() as Object.PutRequest.Types.Body;
+        var body2 = sentMessages.ElementAt(1).GetBody() as Object.PutRequest.Types.Body;
+
+        Assert.NotNull(result);
+        Assert.Equal(Mocker.ResultObjectId, result.ToHash());
+       
+        Assert.True(Mocker.ClientStreamWriter.CompletedTask);
+
+        Assert.Equal(0, body1!.Chunk.Length);
+        Assert.Equal(Object.PutRequest.Types.Body.ObjectPartOneofCase.Init, body1!.ObjectPartCase);
+
+        Assert.Equal(1024, body2!.Chunk.Length);
+        Assert.Equal(Object.PutRequest.Types.Body.ObjectPartOneofCase.Chunk, body2!.ObjectPartCase);       
+    }
+
+    [Fact]
+    public async void ClientCutTest()
+    {
+        NetworkMocker.Parameters = new Dictionary<string, byte[]>() { { "MaxObjectSize", [0x0, 0xa] } }; 
+
+        var blockSize = 2560;
+        byte[] bytes = File.ReadAllBytes(@".\..\..\..\TestData\cat.jpg");
+        var fileLength = bytes.Length;
+
+        var param = new PutObjectParameters
+        {
+            Header = Mocker.ObjectHeader,
+            Payload = new MemoryStream(bytes),
+            ClientCut = true
+        };
+
+        var result = await GetClient().PutObjectAsync(param);
+
+        var sentMessages = Mocker.PutSingleRequests.ToArray();
+
+        Assert.Equal(4, sentMessages.Length);
+
+        var object_0 = sentMessages[0].Body.Object;
+        var object_1 = sentMessages[1].Body.Object;
+        var object_2 = sentMessages[2].Body.Object;
+        var object_3 = sentMessages[3].Body.Object;
+
+        Assert.NotNull(object_0.Header.Split.SplitId);
+        Assert.Null(object_0.Header.Split.Previous);
+        Assert.Equal(blockSize, (int)object_0.Header.PayloadLength);
+        Assert.Equal(bytes[..blockSize], object_0.Payload);
+        Assert.True(object_0.Header.Attributes.Count == 0);
+
+        Assert.Equal(object_0.Header.Split.SplitId, object_1.Header.Split.SplitId);
+        Assert.Equal(object_0.ObjectId, object_1.Header.Split.Previous);
+        Assert.Equal(blockSize, (int)object_1.Header.PayloadLength);
+        Assert.Equal(bytes[blockSize..(blockSize * 2)], object_1.Payload);
+        Assert.True(object_1.Header.Attributes.Count == 0);
+
+        // last part
+        Assert.NotNull(object_2.Header.Split.Parent);
+        Assert.NotNull(object_2.Header.Split.ParentHeader);
+        Assert.NotNull(object_2.Header.Split.ParentSignature);
+        Assert.Equal(object_1.Header.Split.SplitId, object_2.Header.Split.SplitId);
+        Assert.Equal(object_1.ObjectId, object_2.Header.Split.Previous);
+        Assert.Equal(fileLength%blockSize, (int)object_2.Header.PayloadLength);
+        Assert.Equal(bytes[((fileLength/blockSize) * blockSize)..fileLength], object_2.Payload);
+        Assert.True(object_2.Header.Attributes.Count == 0);
+
+        // link object
+        Assert.Equal(object_2.Header.Split.Parent, object_3.Header.Split.Parent);
+        Assert.Equal(object_2.Header.Split.ParentHeader, object_3.Header.Split.ParentHeader);
+        Assert.Equal(object_2.Header.Split.SplitId, object_3.Header.Split.SplitId);
+        Assert.Equal(0, (int)object_3.Header.PayloadLength);
+        Assert.Contains(object_0.ObjectId, object_3.Header.Split.Children);
+        Assert.Contains(object_2.ObjectId, object_3.Header.Split.Children);
+        Assert.Contains(object_2.ObjectId, object_3.Header.Split.Children);
+        Assert.True(object_2.Header.Attributes.Count == 0);
+
+        Assert.Single(object_3.Header.Split.ParentHeader.Attributes);
+        Assert.Equal("k", object_3.Header.Split.ParentHeader.Attributes[0].Key);
+        Assert.Equal("v", object_3.Header.Split.ParentHeader.Attributes[0].Value);
+
+        var modelObjId = ObjectId.FromHash(object_3.Header.Split.Parent.Value.ToByteArray());
+
+        Assert.Equal(result.Value, modelObjId.ToString());
+    }
+
+    [Fact]
+    public async void DeleteObject()
+    {
+        Mocker.ObjectId = new ObjectID { Value = ByteString.CopyFrom(SHA256.HashData(Encoding.UTF8.GetBytes("test"))) }.ToModel();
+
+        await GetClient().DeleteObjectAsync(ContainerId, Mocker.ObjectId);
+
+        var request = Mocker.DeleteRequests.FirstOrDefault();
+        Assert.NotNull(request);
+        Assert.Equal(ContainerId.ToGrpcMessage(), request.Body.Address.ContainerId);
+        Assert.Equal(Mocker.ObjectId.ToGrpcMessage(), request.Body.Address.ObjectId);
+    }
+
+    [Fact]
+    public async void GetHeaderTest()
+    {
+        Mocker.ObjectId = new ObjectID { Value = ByteString.CopyFrom(SHA256.HashData(Encoding.UTF8.GetBytes("test"))) }.ToModel();
+
+        var response = await GetClient().GetObjectHeadAsync(ContainerId, Mocker.ObjectId);
+
+        var request = Mocker.HeadRequests.FirstOrDefault();
+        Assert.NotNull(request);
+        Assert.Equal(ContainerId.ToGrpcMessage(), request.Body.Address.ContainerId);
+        Assert.Equal(Mocker.ObjectId.ToGrpcMessage(), request.Body.Address.ObjectId);
+
+        Assert.NotNull(response);
+        Assert.Equal(ContainerId.Value, response.ContainerId.Value);
+
+        Assert.Equal(Mocker.ObjectHeader!.OwnerId!.ToGrpcMessage().ToString(), response.OwnerId!.Value);
+        Assert.Equal(Mocker.ObjectHeader!.Version!.ToString(), response.Version!.ToString());
+     
+        Assert.Equal(Mocker.HeadResponse!.PayloadLength, response.PayloadLength);
+
+        Assert.Equal(ObjectType.Regular, response.ObjectType);
+
+        Assert.Single(response.Attributes);
+
+        Assert.Equal(Mocker.HeadResponse.Attributes[0].Key, response.Attributes.First().Key);
+        Assert.Equal(Mocker.HeadResponse.Attributes[0].Value, response.Attributes.First().Value);
+
+        Assert.Null(response.Split);
     }
 }

src/FrostFS.SDK.Tests/SmokeTests.cs

@@ -5,14 +5,13 @@ using FrostFS.SDK.ModelsV2;
 using FrostFS.SDK.ModelsV2.Enums;
 using FrostFS.SDK.ModelsV2.Netmap;
 using Grpc.Core;
-using Grpc.Net.Client;
 using Microsoft.Extensions.Options;
 using Grpc.Core.Interceptors;
 using System.Diagnostics;
 
-namespace FrostFS.SDK.Tests;
+namespace FrostFS.SDK.SmokeTests;
 
-public class ClientTestLive
+public class SmokeTests
 {
     private readonly string key = "KwHDAJ66o8FoLBjVbjP2sWBmgBMGjt7Vv4boA7xQrBoAYBE397Aq";
     private readonly string url = "http://172.29.238.97:8080";
@@ -46,11 +45,24 @@ public class ClientTestLive
         Assert.Equal(2, result.Version.Major);
         Assert.Equal(13, result.Version.Minor);
         Assert.Equal(NodeState.Online, result.State);
-        Assert.True(result.PublicKey.Length > 0);
+        Assert.Equal(33, result.PublicKey.Length);
         Assert.Single(result.Addresses);
         Assert.Equal(9, result.Attributes.Count);
     }
 
+    [Fact]
+    public async void NodeInfo_Statictics_Test()
+    {
+        var ctx = new Context
+        {
+            Callback = (cs) => Console.WriteLine($"{cs.MethodName} took {cs.ElapsedMicroSeconds} microseconds")
+        };
+
+        using var fsClient = Client.GetInstance(GetOptions(this.key, this.url));
+
+        var result = await fsClient.GetNodeInfoAsync();       
+    }
+
     [Fact]
     public async void SimpleScenarioTest()
     {
@@ -76,9 +88,7 @@ public class ClientTestLive
 
         Assert.NotNull(container);
 
-        Random rnd = new();
-        var bytes = new byte[6 * 1024 * 1024 + 100];
-        rnd.NextBytes(bytes);
+        var bytes = GetRandomBytes(6 * 1024 * 1024 + 100);
 
         var param = new PutObjectParameters
         {
@@ -141,25 +151,21 @@ public class ClientTestLive
 
         await Cleanup(fsClient);
 
-        var containerId = await fsClient.CreateContainerAsync(
-            new ModelsV2.Container(BasicAcl.PublicRW, new PlacementPolicy(true, new Replica(1))));
+        var cnt = new ModelsV2.Container(BasicAcl.PublicRW, new PlacementPolicy(true, new Replica(1)));
 
-        var context = new Context 
-        { 
-            Timeout = TimeSpan.FromSeconds(10)
+        var containerId = await fsClient.CreateContainerAsync(cnt);
+
+        var context = new Context
+        {
+            Timeout = TimeSpan.FromSeconds(10),
+            Interceptors = new([new MetricsInterceptor()])
         };
 
-        var metrics = new MetricsInterceptor();
-
-        context.Interceptors.Add(metrics);
-
         var container = await GetContainer(fsClient, containerId, context);
 
         Assert.NotNull(container);
 
-        Random rnd = new();
-        var bytes = new byte[6 * 1024 * 1024 + 100];
-        rnd.NextBytes(bytes);
+        byte[] bytes = GetRandomBytes(150 * 1024 * 1024);
 
         var param = new PutObjectParameters
         {
@@ -200,6 +206,8 @@ public class ClientTestLive
             ms.Write(chunk);
         }
 
+        Assert.Equal(MD5.HashData(bytes), MD5.HashData(downloadedBytes));
+
         await Cleanup(fsClient);
 
         await Task.Delay(2000);
@@ -210,15 +218,21 @@ public class ClientTestLive
         }
     }
 
+    private static byte[] GetRandomBytes(int size)
+    {
+        Random rnd = new();
+        var bytes = new byte[size];
+        rnd.NextBytes(bytes);
+        return bytes;
+    }
+
     private static IOptions<ClientSettings> GetOptions(string key, string url)
     {
-        var settings = new ClientSettings
+        return Options.Create(new ClientSettings
         {
             Key = key,
             Host = url
-        };
-
-        return Options.Create(settings);
+        });
     }
 
     static async Task Cleanup(IFrostFSClient fsClient)
@@ -243,7 +257,7 @@ public class ClientTestLive
                 if (DateTime.UtcNow >= ctx.Deadline)
                     throw new TimeoutException();
             }
-            catch (Grpc.Core.RpcException)
+            catch (RpcException)
             {
                 throw;
             }
@@ -268,7 +282,7 @@ public class MetricsInterceptor() : Interceptor
             call.Dispose);
     }
   
-    private async Task<TResponse> HandleUnaryResponse<TResponse>(AsyncUnaryCall<TResponse> call)
+    private static async Task<TResponse> HandleUnaryResponse<TResponse>(AsyncUnaryCall<TResponse> call)
     {
         var watch = new Stopwatch();
         watch.Start();