[#16] Unit tests

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

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; } = [];
 }