frostfs-sdk-csharp/src/FrostFS.SDK.Tests/Mocks/ObjectMock.cs

using System.Security.Cryptography;

using FrostFS.Object;
using FrostFS.SDK.ClientV2;
using FrostFS.SDK.ClientV2.Mappers.GRPC;
using FrostFS.SDK.Cryptography;

using Google.Protobuf;

using Grpc.Core;

using Moq;

namespace FrostFS.SDK.Tests;

public class ObjectMocker(string key) : ObjectServiceBase(key)
{
    public override Mock<ObjectService.ObjectServiceClient> GetMock()
    {
        var mock = new Mock<ObjectService.ObjectServiceClient>();

        if (ObjectHeader != null)
        {
            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(StringKey, ObjectHeader),
                        Task.FromResult(ResponseMetaData),
                        () => new Grpc.Core.Status(StatusCode.OK, string.Empty),
                        () => ResponseMetaData,
                        () => { });
                });

            HeadResponse ??= new Header
            {
                CreationEpoch = 99,
                ContainerId = ObjectHeader.ContainerId.ToMessage(),
                ObjectType = ObjectType.Regular,
                OwnerId = ObjectHeader.OwnerId!.ToMessage(),
                PayloadLength = 1,
                PayloadHash = new Refs.Checksum { Type = Refs.ChecksumType.Sha256, Sum = ByteString.CopyFrom(SHA256.HashData([0xff])) },
                Version = ObjectHeader.Version!.ToMessage()
            };

            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 (ResultObjectIds != null)
        {
            PutResponse putResponse = new()
            {
                Body = new PutResponse.Types.Body
                {
                    ObjectId = new Refs.ObjectID
                    {
                        Value = ByteString.CopyFrom(ResultObjectIds.ElementAt(0))
                    }
                },
                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.ToMessage(),
                        ObjectId = ObjectId.ToMessage()
                    }
                },
                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 FrostFsObjectId? ObjectId { get; set; }

    public FrostFsObjectHeader? ObjectHeader { get; set; }

    public Header? HeadResponse { get; set; }

    public List<byte[]>? ResultObjectIds { 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; } = [];
}