[#23] Update proto api

Add chain functionality
Add tests
Signed-off-by: Ori Bruk <o.bruk@yadro.com>

client/src/main/java/info/frostfs/sdk/FrostFSClient.java

@@ -1,6 +1,7 @@
 package info.frostfs.sdk;
 
-import frostfs.session.Types;
+import info.frostfs.sdk.dto.chain.Chain;
+import info.frostfs.sdk.dto.chain.ChainTarget;
 import info.frostfs.sdk.dto.container.Container;
 import info.frostfs.sdk.dto.container.ContainerId;
 import info.frostfs.sdk.dto.netmap.NetmapSnapshot;
@@ -30,10 +31,12 @@ import static info.frostfs.sdk.constants.ErrorConst.VERSION_UNSUPPORTED_TEMPLATE
 import static info.frostfs.sdk.tools.GrpcClient.initGrpcChannel;
 import static java.util.Objects.nonNull;
 
-public class FrostFSClient implements ContainerClient, ObjectClient, NetmapClient, SessionClient, ToolsClient {
+public class FrostFSClient
+        implements ContainerClient, ObjectClient, ApeManagerClient, NetmapClient, SessionClient, ToolsClient {
     private final ContainerClientImpl containerClientImpl;
-    private final NetmapClientImpl netmapClientImpl;
     private final ObjectClientImpl objectClientImpl;
+    private final ApeManagerClientImpl apeManagerClient;
+    private final NetmapClientImpl netmapClientImpl;
     private final SessionClientImpl sessionClientImpl;
     private final ObjectToolsImpl objectToolsImpl;
 
@@ -52,9 +55,10 @@ public class FrostFSClient implements ContainerClient, ObjectClient, NetmapClien
         Validator.validate(clientEnvironment);
 
         this.containerClientImpl = new ContainerClientImpl(clientEnvironment);
+        this.objectClientImpl = new ObjectClientImpl(clientEnvironment);
+        this.apeManagerClient = new ApeManagerClientImpl(clientEnvironment);
         this.netmapClientImpl = new NetmapClientImpl(clientEnvironment);
         this.sessionClientImpl = new SessionClientImpl(clientEnvironment);
-        this.objectClientImpl = new ObjectClientImpl(clientEnvironment);
         this.objectToolsImpl = new ObjectToolsImpl(clientEnvironment);
         checkFrostFsVersionSupport(clientEnvironment.getVersion());
     }
@@ -118,6 +122,21 @@ public class FrostFSClient implements ContainerClient, ObjectClient, NetmapClien
         return objectClientImpl.searchObjects(cid, filters);
     }
 
+    @Override
+    public byte[] addChain(Chain chain, ChainTarget chainTarget) {
+        return apeManagerClient.addChain(chain, chainTarget);
+    }
+
+    @Override
+    public void removeChain(Chain chain, ChainTarget chainTarget) {
+        apeManagerClient.removeChain(chain, chainTarget);
+    }
+
+    @Override
+    public List<Chain> listChains(ChainTarget chainTarget) {
+        return apeManagerClient.listChains(chainTarget);
+    }
+
     @Override
     public NetmapSnapshot getNetmapSnapshot() {
         return netmapClientImpl.getNetmapSnapshot();
@@ -138,7 +157,7 @@ public class FrostFSClient implements ContainerClient, ObjectClient, NetmapClien
         return sessionClientImpl.createSession(expiration);
     }
 
-    public Types.SessionToken createSessionInternal(long expiration) {
+    public frostfs.session.Types.SessionToken createSessionInternal(long expiration) {
         return sessionClientImpl.createSessionInternal(expiration);
     }
 

client/src/main/java/info/frostfs/sdk/services/ApeManagerClient.java

@@ -0,0 +1,14 @@
+package info.frostfs.sdk.services;
+
+import info.frostfs.sdk.dto.chain.Chain;
+import info.frostfs.sdk.dto.chain.ChainTarget;
+
+import java.util.List;
+
+public interface ApeManagerClient {
+    byte[] addChain(Chain chain, ChainTarget chainTarget);
+
+    void removeChain(Chain chain, ChainTarget chainTarget);
+
+    List<Chain> listChains(ChainTarget chainTarget);
+}

client/src/main/java/info/frostfs/sdk/services/impl/ApeManagerClientImpl.java

@@ -0,0 +1,134 @@
+package info.frostfs.sdk.services.impl;
+
+import com.google.protobuf.ByteString;
+import frostfs.ape.Types;
+import frostfs.apemanager.APEManagerServiceGrpc;
+import frostfs.apemanager.Service;
+import info.frostfs.sdk.dto.chain.Chain;
+import info.frostfs.sdk.dto.chain.ChainTarget;
+import info.frostfs.sdk.exceptions.ValidationFrostFSException;
+import info.frostfs.sdk.jdo.ClientEnvironment;
+import info.frostfs.sdk.mappers.chain.ChainMapper;
+import info.frostfs.sdk.mappers.chain.ChainTargetMapper;
+import info.frostfs.sdk.services.ApeManagerClient;
+import info.frostfs.sdk.services.ContextAccessor;
+import info.frostfs.sdk.tools.RequestConstructor;
+import info.frostfs.sdk.tools.RequestSigner;
+import info.frostfs.sdk.tools.Verifier;
+
+import java.util.List;
+import java.util.Map;
+
+import static info.frostfs.sdk.constants.ErrorConst.*;
+import static java.util.Objects.isNull;
+
+public class ApeManagerClientImpl extends ContextAccessor implements ApeManagerClient {
+    private final APEManagerServiceGrpc.APEManagerServiceBlockingStub apeManagerServiceClient;
+
+    public ApeManagerClientImpl(ClientEnvironment clientEnvironment) {
+        super(clientEnvironment);
+        this.apeManagerServiceClient = APEManagerServiceGrpc.newBlockingStub(getContext().getChannel());
+    }
+
+    @Override
+    public byte[] addChain(Chain chain, ChainTarget chainTarget) {
+        if (isNull(chain) || isNull(chainTarget)) {
+            throw new ValidationFrostFSException(
+                    String.format(
+                            PARAMS_ARE_MISSING_TEMPLATE,
+                            String.join(FIELDS_DELIMITER_COMMA, Chain.class.getName(), ChainTarget.class.getName())
+                    )
+            );
+        }
+
+        var request = createAddChainRequest(chain, chainTarget, null);
+
+        var response = apeManagerServiceClient.addChain(request);
+
+        Verifier.checkResponse(response);
+
+        return response.getBody().getChainId().toByteArray();
+    }
+
+    @Override
+    public void removeChain(Chain chain, ChainTarget chainTarget) {
+        if (isNull(chain) || isNull(chainTarget)) {
+            throw new ValidationFrostFSException(
+                    String.format(
+                            PARAMS_ARE_MISSING_TEMPLATE,
+                            String.join(FIELDS_DELIMITER_COMMA, Chain.class.getName(), ChainTarget.class.getName())
+                    )
+            );
+        }
+
+        var request = createRemoveChainRequest(chain, chainTarget, null);
+
+        var response = apeManagerServiceClient.removeChain(request);
+
+        Verifier.checkResponse(response);
+    }
+
+    @Override
+    public List<Chain> listChains(ChainTarget chainTarget) {
+        if (isNull(chainTarget)) {
+            throw new ValidationFrostFSException(String.format(PARAM_IS_MISSING_TEMPLATE, ChainTarget.class.getName()));
+        }
+
+        var request = createListChainsRequest(chainTarget, null);
+
+        var response = apeManagerServiceClient.listChains(request);
+
+        Verifier.checkResponse(response);
+
+        return ChainMapper.toModels(response.getBody().getChainsList());
+    }
+
+    private Service.AddChainRequest createAddChainRequest(Chain chain,
+                                                          ChainTarget chainTarget,
+                                                          Map<String, String> xHeaders) {
+        var chainGrpc = Types.Chain.newBuilder()
+                .setRaw(ByteString.copyFrom(chain.getRaw()))
+                .build();
+        var body = Service.AddChainRequest.Body.newBuilder()
+                .setChain(chainGrpc)
+                .setTarget(ChainTargetMapper.toGrpcMessage(chainTarget))
+                .build();
+        var request = Service.AddChainRequest.newBuilder()
+                .setBody(body);
+
+        RequestConstructor.addMetaHeader(request, xHeaders);
+        RequestSigner.sign(request, getContext().getKey());
+
+        return request.build();
+    }
+
+    private Service.RemoveChainRequest createRemoveChainRequest(Chain chain,
+                                                                ChainTarget chainTarget,
+                                                                Map<String, String> xHeaders) {
+        var body = Service.RemoveChainRequest.Body.newBuilder()
+                .setChainId(ByteString.copyFrom(chain.getRaw()))
+                .setTarget(ChainTargetMapper.toGrpcMessage(chainTarget))
+                .build();
+        var request = Service.RemoveChainRequest.newBuilder()
+                .setBody(body);
+
+        RequestConstructor.addMetaHeader(request, xHeaders);
+        RequestSigner.sign(request, getContext().getKey());
+
+        return request.build();
+    }
+
+    private Service.ListChainsRequest createListChainsRequest(ChainTarget chainTarget,
+                                                              Map<String, String> xHeaders) {
+        var body = Service.ListChainsRequest.Body.newBuilder()
+                .setTarget(ChainTargetMapper.toGrpcMessage(chainTarget))
+                .build();
+        var request = Service.ListChainsRequest.newBuilder()
+                .setBody(body);
+
+        RequestConstructor.addMetaHeader(request, xHeaders);
+        RequestSigner.sign(request, getContext().getKey());
+
+        return request.build();
+    }
+}

client/src/test/java/info/frostfs/sdk/FileUtils.java

@@ -0,0 +1,31 @@
+package info.frostfs.sdk;
+
+import com.google.common.io.ByteStreams;
+import lombok.SneakyThrows;
+import org.apache.commons.lang3.StringUtils;
+
+import java.io.InputStream;
+
+import static java.util.Objects.isNull;
+
+public class FileUtils {
+
+    @SneakyThrows
+    public static byte[] resourceToBytes(String resourcePath) {
+        if (StringUtils.isBlank(resourcePath)) {
+            throw new IllegalArgumentException("Blank filename!");
+        }
+
+        ClassLoader loader = FileUtils.class.getClassLoader();
+        if (isNull(loader)) {
+            throw new RuntimeException("Class loader is null!");
+        }
+
+        InputStream certStream = loader.getResourceAsStream(resourcePath);
+        if (isNull(certStream)) {
+            throw new RuntimeException("Resource could not be found!");
+        }
+
+        return ByteStreams.toByteArray(certStream);
+    }
+}

client/src/test/java/info/frostfs/sdk/services/ApeManagerClientTest.java

@@ -0,0 +1,216 @@
+package info.frostfs.sdk.services;
+
+import frostfs.apemanager.APEManagerServiceGrpc;
+import frostfs.apemanager.Service;
+import info.frostfs.sdk.FileUtils;
+import info.frostfs.sdk.dto.chain.Chain;
+import info.frostfs.sdk.dto.chain.ChainTarget;
+import info.frostfs.sdk.enums.TargetType;
+import info.frostfs.sdk.exceptions.ValidationFrostFSException;
+import info.frostfs.sdk.jdo.ClientEnvironment;
+import info.frostfs.sdk.services.impl.ApeManagerClientImpl;
+import info.frostfs.sdk.testgenerator.ApeManagerGenerator;
+import info.frostfs.sdk.tools.RequestConstructor;
+import info.frostfs.sdk.tools.RequestSigner;
+import info.frostfs.sdk.tools.Verifier;
+import io.grpc.Channel;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.platform.commons.util.ReflectionUtils;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mock;
+import org.mockito.MockedStatic;
+import org.mockito.Mockito;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import java.lang.reflect.Field;
+import java.util.stream.Collectors;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+class ApeManagerClientTest {
+    private ApeManagerClientImpl apeManagerClient;
+
+    @Mock
+    private APEManagerServiceGrpc.APEManagerServiceBlockingStub apeManagerServiceClient;
+    @Mock
+    private ClientEnvironment clientEnvironment;
+    @Mock
+    private Channel channel;
+
+    private MockedStatic<Verifier> verifierMock;
+    private MockedStatic<RequestConstructor> requestConstructorMock;
+    private MockedStatic<RequestSigner> requestSignerMock;
+
+    @BeforeEach
+    void setUp() throws IllegalAccessException {
+        when(clientEnvironment.getChannel()).thenReturn(channel);
+        apeManagerClient = new ApeManagerClientImpl(clientEnvironment);
+
+        Field field = ReflectionUtils.findFields(ApeManagerClientImpl.class,
+                        f -> f.getName().equals("apeManagerServiceClient"),
+                        ReflectionUtils.HierarchyTraversalMode.TOP_DOWN)
+                .get(0);
+
+        field.setAccessible(true);
+        field.set(apeManagerClient, apeManagerServiceClient);
+
+        verifierMock = Mockito.mockStatic(Verifier.class);
+        requestConstructorMock = Mockito.mockStatic(RequestConstructor.class);
+        requestSignerMock = Mockito.mockStatic(RequestSigner.class);
+    }
+
+    @AfterEach
+    void cleanUp() {
+        verifierMock.close();
+        requestConstructorMock.close();
+        requestSignerMock.close();
+    }
+
+    @Test
+    void addChain_success() {
+        //Given
+        Chain chain = generateChain();
+        ChainTarget chainTarget = generateChainTarget();
+
+        var response = ApeManagerGenerator.generateAddChainResponse();
+
+        var captor = ArgumentCaptor.forClass(Service.AddChainRequest.class);
+
+        when(apeManagerServiceClient.addChain(captor.capture())).thenReturn(response);
+
+        //When
+        var result = apeManagerClient.addChain(chain, chainTarget);
+
+        //Then
+        requestConstructorMock.verify(
+                () -> RequestConstructor.addMetaHeader(any(Service.AddChainRequest.Builder.class), eq(null)),
+                times(1)
+        );
+        requestSignerMock.verify(
+                () -> RequestSigner.sign(any(Service.AddChainRequest.Builder.class), eq(null)),
+                times(1)
+        );
+        verifierMock.verify(() -> Verifier.checkResponse(response), times(1));
+
+        assertThat(result).containsOnly(response.getBody().getChainId().toByteArray());
+
+        var request = captor.getValue();
+        assertThat(request.getBody().getChain().getRaw().toByteArray()).containsOnly(chain.getRaw());
+        assertEquals(chainTarget.getName(), request.getBody().getTarget().getName());
+        assertEquals(chainTarget.getType().value, request.getBody().getTarget().getType().getNumber());
+    }
+
+    @Test
+    void addChain_wrongParams() {
+        //Given
+        Chain chain = generateChain();
+        ChainTarget chainTarget = generateChainTarget();
+
+        //When + Then
+        assertThrows(ValidationFrostFSException.class, () -> apeManagerClient.addChain(null, chainTarget));
+        assertThrows(ValidationFrostFSException.class, () -> apeManagerClient.addChain(chain, null));
+        assertThrows(ValidationFrostFSException.class, () -> apeManagerClient.addChain(null, null));
+    }
+
+    @Test
+    void removeChain_success() {
+        //Given
+        Chain chain = generateChain();
+        ChainTarget chainTarget = generateChainTarget();
+
+        var response = ApeManagerGenerator.generateRemoveChainResponse();
+
+        var captor = ArgumentCaptor.forClass(Service.RemoveChainRequest.class);
+
+        when(apeManagerServiceClient.removeChain(captor.capture())).thenReturn(response);
+
+        //When
+        apeManagerClient.removeChain(chain, chainTarget);
+
+        //Then
+        requestConstructorMock.verify(
+                () -> RequestConstructor.addMetaHeader(any(Service.RemoveChainRequest.Builder.class), eq(null)),
+                times(1)
+        );
+        requestSignerMock.verify(
+                () -> RequestSigner.sign(any(Service.RemoveChainRequest.Builder.class), eq(null)),
+                times(1)
+        );
+        verifierMock.verify(() -> Verifier.checkResponse(response), times(1));
+
+        var request = captor.getValue();
+        assertThat(request.getBody().getChainId().toByteArray()).containsOnly(chain.getRaw());
+        assertEquals(chainTarget.getName(), request.getBody().getTarget().getName());
+        assertEquals(chainTarget.getType().value, request.getBody().getTarget().getType().getNumber());
+    }
+
+    @Test
+    void removeChain_wrongParams() {
+        //Given
+        Chain chain = generateChain();
+        ChainTarget chainTarget = generateChainTarget();
+
+        //When + Then
+        assertThrows(ValidationFrostFSException.class, () -> apeManagerClient.removeChain(null, chainTarget));
+        assertThrows(ValidationFrostFSException.class, () -> apeManagerClient.removeChain(chain, null));
+        assertThrows(ValidationFrostFSException.class, () -> apeManagerClient.removeChain(null, null));
+    }
+
+    @Test
+    void listChain_success() {
+        //Given
+        ChainTarget chainTarget = generateChainTarget();
+
+        var response = ApeManagerGenerator.generateListChainsResponse();
+
+        var captor = ArgumentCaptor.forClass(Service.ListChainsRequest.class);
+
+        when(apeManagerServiceClient.listChains(captor.capture())).thenReturn(response);
+
+        //When
+        var result = apeManagerClient.listChains(chainTarget);
+
+        //Then
+        requestConstructorMock.verify(
+                () -> RequestConstructor.addMetaHeader(any(Service.ListChainsRequest.Builder.class), eq(null)),
+                times(1)
+        );
+        requestSignerMock.verify(
+                () -> RequestSigner.sign(any(Service.ListChainsRequest.Builder.class), eq(null)),
+                times(1)
+        );
+        verifierMock.verify(() -> Verifier.checkResponse(response), times(1));
+
+        var actual = result.stream().map(Chain::getRaw).collect(Collectors.toList());
+        var expected = response.getBody().getChainsList().stream()
+                .map(chain -> chain.getRaw().toByteArray())
+                .collect(Collectors.toList());
+        assertThat(actual).hasSize(10).containsAll(expected);
+
+        var request = captor.getValue();
+        assertEquals(chainTarget.getName(), request.getBody().getTarget().getName());
+        assertEquals(chainTarget.getType().value, request.getBody().getTarget().getType().getNumber());
+    }
+
+    @Test
+    void listChain_wrongParams() {
+        //When + Then
+        assertThrows(ValidationFrostFSException.class, () -> apeManagerClient.listChains(null));
+    }
+
+    private Chain generateChain() {
+        byte[] chainRaw = FileUtils.resourceToBytes("test_chain_raw.json");
+        return new Chain(chainRaw);
+    }
+
+    private ChainTarget generateChainTarget() {
+        return new ChainTarget("BzQw5HH3feoxFDD5tCT87Y1726qzgLfxEE7wgtoRzB3R", TargetType.NAMESPACE);
+    }
+}

client/src/test/java/info/frostfs/sdk/testgenerator/ApeManagerGenerator.java

@@ -0,0 +1,124 @@
+package info.frostfs.sdk.testgenerator;
+
+import com.google.protobuf.ByteString;
+import frostfs.ape.Types;
+import frostfs.apemanager.Service;
+import info.frostfs.sdk.FileUtils;
+import info.frostfs.sdk.Helper;
+
+import java.util.ArrayList;
+
+public class ApeManagerGenerator {
+
+    private static ByteString generateChainID() {
+        return ByteString.copyFrom(Helper.getByteArrayFromHex("616c6c6f774f626a476574436e72"));
+    }
+
+    private static Types.Chain generateRawChain() {
+        byte[] chainRaw = FileUtils.resourceToBytes("test_chain_raw.json");
+
+        return Types.Chain.newBuilder()
+                .setRaw(ByteString.copyFrom(chainRaw))
+                .build();
+    }
+
+    private static Iterable<Types.Chain> generateRawChains(int size) {
+        var list = new ArrayList<Types.Chain>(size);
+        for (int i = 0; i < size; i++) {
+            list.add(generateRawChain());
+        }
+
+        return list;
+    }
+
+    private static Types.ChainTarget generateChainTarget() {
+        return Types.ChainTarget.newBuilder()
+                .setType(Types.TargetType.CONTAINER)
+                .setName("BzQw5HH3feoxFDD5tCT87Y1726qzgLfxEE7wgtoRzB3R")
+                .build();
+    }
+
+    public static Service.AddChainRequest.Body generateAddChainRequestBody() {
+        return Service.AddChainRequest.Body.newBuilder()
+                .setTarget(generateChainTarget())
+                .setChain(generateRawChain())
+                .build();
+    }
+
+    public static Service.AddChainRequest generateAddChainRequest() {
+        return Service.AddChainRequest.newBuilder()
+                .setBody(generateAddChainRequestBody())
+                .setMetaHeader(SessionGenerator.generateRequestMetaHeader())
+                .setVerifyHeader(SessionGenerator.generateRequestVerificationHeader())
+                .build();
+    }
+
+    public static Service.AddChainResponse.Body generateAddChainResponseBody() {
+        return Service.AddChainResponse.Body.newBuilder()
+                .setChainId(generateChainID())
+                .build();
+    }
+
+    public static Service.AddChainResponse generateAddChainResponse() {
+        return Service.AddChainResponse.newBuilder()
+                .setBody(generateAddChainResponseBody())
+                .setMetaHeader(SessionGenerator.generateResponseMetaHeader())
+                .setVerifyHeader(SessionGenerator.generateResponseVerificationHeader())
+                .build();
+    }
+
+    public static Service.RemoveChainRequest.Body generateRemoveChainRequestBody() {
+        return Service.RemoveChainRequest.Body.newBuilder()
+                .setChainId(generateChainID())
+                .setTarget(generateChainTarget())
+                .build();
+    }
+
+    public static Service.RemoveChainRequest generateRemoveChainRequest() {
+        return Service.RemoveChainRequest.newBuilder()
+                .setBody(generateRemoveChainRequestBody())
+                .setMetaHeader(SessionGenerator.generateRequestMetaHeader())
+                .setVerifyHeader(SessionGenerator.generateRequestVerificationHeader())
+                .build();
+    }
+
+    public static Service.RemoveChainResponse.Body generateRemoveChainResponseBody() {
+        return Service.RemoveChainResponse.Body.getDefaultInstance();
+    }
+
+    public static Service.RemoveChainResponse generateRemoveChainResponse() {
+        return Service.RemoveChainResponse.newBuilder()
+                .setBody(generateRemoveChainResponseBody())
+                .setMetaHeader(SessionGenerator.generateResponseMetaHeader())
+                .setVerifyHeader(SessionGenerator.generateResponseVerificationHeader())
+                .build();
+    }
+
+    public static Service.ListChainsRequest.Body generateListChainsRequestBody() {
+        return Service.ListChainsRequest.Body.newBuilder()
+                .setTarget(generateChainTarget())
+                .build();
+    }
+
+    public static Service.ListChainsRequest generateListChainsRequest() {
+        return Service.ListChainsRequest.newBuilder()
+                .setBody(generateListChainsRequestBody())
+                .setMetaHeader(SessionGenerator.generateRequestMetaHeader())
+                .setVerifyHeader(SessionGenerator.generateRequestVerificationHeader())
+                .build();
+    }
+
+    public static Service.ListChainsResponse.Body generateListChainsResponseBody() {
+        return Service.ListChainsResponse.Body.newBuilder()
+                .addAllChains(generateRawChains(10))
+                .build();
+    }
+
+    public static Service.ListChainsResponse generateListChainsResponse() {
+        return Service.ListChainsResponse.newBuilder()
+                .setBody(generateListChainsResponseBody())
+                .setMetaHeader(SessionGenerator.generateResponseMetaHeader())
+                .setVerifyHeader(SessionGenerator.generateResponseVerificationHeader())
+                .build();
+    }
+}

client/src/test/java/info/frostfs/sdk/testgenerator/RefsGenerator.java

@@ -0,0 +1,65 @@
+package info.frostfs.sdk.testgenerator;
+
+import com.google.protobuf.ByteString;
+import frostfs.refs.Types;
+
+import java.util.Arrays;
+import java.util.Random;
+
+public class RefsGenerator {
+
+    public static Types.Version generateVersion() {
+        return Types.Version.newBuilder()
+                .setMajor(2)
+                .setMinor(1)
+                .build();
+    }
+
+    public static Types.OwnerID generateOwnerID() {
+        return Types.OwnerID.newBuilder()
+                .setValue(ByteString.copyFrom(new byte[]{1, 2, 3}))
+                .build();
+    }
+
+    public static Types.Address generateAddress() {
+        return Types.Address.newBuilder()
+                .setObjectId(generateObjectID())
+                .setContainerId(generateContainerID())
+                .build();
+    }
+
+    public static Types.ObjectID generateObjectID() {
+        return Types.ObjectID.newBuilder()
+                .setValue(ByteString.copyFrom(new byte[]{1, 2, 3}))
+                .build();
+    }
+
+    public static Iterable<Types.ObjectID> generateObjectIDs() {
+        return Arrays.asList(generateObjectID(), generateObjectID());
+    }
+
+    public static Types.ContainerID generateContainerID() {
+        return Types.ContainerID.newBuilder()
+                .setValue(ByteString.copyFrom(new byte[]{1, 2, 3}))
+                .build();
+    }
+
+    public static Iterable<Types.ContainerID> generateContainerIDs() {
+        return Arrays.asList(generateContainerID(), generateContainerID());
+    }
+
+    public static Types.Signature generateSignature() {
+        return Types.Signature.newBuilder()
+                .setKey(ByteString.copyFrom(new byte[]{1}))
+                .setSign(ByteString.copyFrom(new byte[]{2}))
+                .setScheme(Types.SignatureScheme.forNumber(new Random().nextInt(3)))
+                .build();
+    }
+
+    public static Types.Checksum generateChecksum() {
+        return Types.Checksum.newBuilder()
+                .setType(Types.ChecksumType.SHA256)
+                .setSum(ByteString.copyFrom(new byte[]{1, 2, 3}))
+                .build();
+    }
+}

client/src/test/java/info/frostfs/sdk/testgenerator/SessionGenerator.java

@@ -0,0 +1,178 @@
+package info.frostfs.sdk.testgenerator;
+
+import com.google.protobuf.ByteString;
+import frostfs.session.Service;
+import frostfs.session.Types;
+
+import java.util.Arrays;
+import java.util.Random;
+
+public class SessionGenerator {
+
+    public static Service.CreateRequest.Body generateCreateRequestBody() {
+        return Service.CreateRequest.Body.newBuilder()
+                .setExpiration(555)
+                .setOwnerId(RefsGenerator.generateOwnerID())
+                .build();
+    }
+
+    public static Service.CreateRequest generateCreateRequest() {
+        return Service.CreateRequest.newBuilder()
+                .setBody(generateCreateRequestBody())
+                .setMetaHeader(generateRequestMetaHeader())
+                .setVerifyHeader(generateRequestVerificationHeader())
+                .build();
+    }
+
+    public static Service.CreateResponse.Body generateCreateResponseBody() {
+        return Service.CreateResponse.Body.newBuilder()
+                .setId(ByteString.copyFrom(new byte[]{1, 2, 3}))
+                .setSessionKey(ByteString.copyFrom(new byte[]{4, 5, 6}))
+                .build();
+    }
+
+    public static Service.CreateResponse generateCreateResponse() {
+        return Service.CreateResponse.newBuilder()
+                .setBody(generateCreateResponseBody())
+                .setMetaHeader(generateResponseMetaHeader())
+                .setVerifyHeader(generateResponseVerificationHeader())
+                .build();
+    }
+
+    public static Types.ResponseVerificationHeader generateResponseVerificationHeader() {
+        return generateResponseVerificationHeader(true);
+    }
+
+    public static Types.ResponseVerificationHeader generateResponseVerificationHeader(boolean withOrigin) {
+        var builder = Types.ResponseVerificationHeader.newBuilder()
+                .setBodySignature(RefsGenerator.generateSignature())
+                .setMetaSignature(RefsGenerator.generateSignature())
+                .setOriginSignature(RefsGenerator.generateSignature());
+
+        if (withOrigin) {
+            builder.setOrigin(generateResponseVerificationHeader(false));
+        }
+
+        return builder.build();
+    }
+
+    public static Types.ResponseMetaHeader generateResponseMetaHeader() {
+        return generateResponseMetaHeader(true);
+    }
+
+    public static Types.ResponseMetaHeader generateResponseMetaHeader(boolean withOrigin) {
+        var builder = Types.ResponseMetaHeader.newBuilder()
+                .setEpoch(13)
+                .setTtl(100)
+                .addAllXHeaders(generateXHeaders())
+                .setVersion(RefsGenerator.generateVersion())
+                .setStatus(StatusGenerator.generateStatus());
+
+        if (withOrigin) {
+            builder.setOrigin(generateResponseMetaHeader(false));
+        }
+
+        return builder.build();
+    }
+
+    public static Types.RequestVerificationHeader generateRequestVerificationHeader() {
+        return generateRequestVerificationHeader(true);
+    }
+
+    public static Types.RequestVerificationHeader generateRequestVerificationHeader(boolean withOrigin) {
+        var builder = Types.RequestVerificationHeader.newBuilder()
+                .setBodySignature(RefsGenerator.generateSignature())
+                .setMetaSignature(RefsGenerator.generateSignature())
+                .setOriginSignature(RefsGenerator.generateSignature());
+
+        if (withOrigin) {
+            builder.setOrigin(generateRequestVerificationHeader(false));
+        }
+
+        return builder.build();
+    }
+
+    public static Types.RequestMetaHeader generateRequestMetaHeader() {
+        return generateRequestMetaHeader(true);
+    }
+
+    public static Types.RequestMetaHeader generateRequestMetaHeader(boolean withOrigin) {
+        var builder = Types.RequestMetaHeader.newBuilder()
+                .setEpoch(13)
+                .setTtl(100)
+                .setMagicNumber(1337)
+                .addAllXHeaders(generateXHeaders())
+                .setVersion(RefsGenerator.generateVersion())
+                .setSessionToken(generateSessionToken());
+
+        if (withOrigin) {
+            builder.setOrigin(generateRequestMetaHeader(false));
+        }
+
+        return builder.build();
+    }
+
+    public static Types.SessionToken.Body.TokenLifetime generateTokenLifeTime() {
+        return Types.SessionToken.Body.TokenLifetime.newBuilder()
+                .setExp(1)
+                .setIat(2)
+                .setNbf(3)
+                .build();
+    }
+
+    public static Types.SessionToken.Body generateSessionTokenBody() {
+        var builder = Types.SessionToken.Body.newBuilder()
+                .setId(ByteString.copyFrom(new byte[]{1}))
+                .setSessionKey(ByteString.copyFrom(new byte[]{2}))
+                .setOwnerId(RefsGenerator.generateOwnerID())
+                .setLifetime(generateTokenLifeTime());
+
+        if (new Random().nextBoolean()) {
+            builder.setContainer(generateContainerSessionContext());
+        } else {
+            builder.setObject(generateObjectSessionContext());
+        }
+
+        return builder.build();
+    }
+
+    public static Types.SessionToken generateSessionToken() {
+        return Types.SessionToken.newBuilder()
+                .setBody(generateSessionTokenBody())
+                .setSignature(RefsGenerator.generateSignature())
+                .build();
+    }
+
+    public static Types.ObjectSessionContext.Target generateObjectSessionContextTarget() {
+        return Types.ObjectSessionContext.Target.newBuilder()
+                .setContainer(RefsGenerator.generateContainerID())
+                .addObjects(RefsGenerator.generateObjectID())
+                .build();
+    }
+
+    public static Types.ObjectSessionContext generateObjectSessionContext() {
+        return Types.ObjectSessionContext.newBuilder()
+                .setVerb(Types.ObjectSessionContext.Verb.HEAD)
+                .setTarget(generateObjectSessionContextTarget())
+                .build();
+    }
+
+    public static Types.ContainerSessionContext generateContainerSessionContext() {
+        return Types.ContainerSessionContext.newBuilder()
+                .setVerb(Types.ContainerSessionContext.Verb.DELETE)
+                .setWildcard(true)
+                .setContainerId(RefsGenerator.generateContainerID())
+                .build();
+    }
+
+    public static Types.XHeader generateXHeader() {
+        return Types.XHeader.newBuilder()
+                .setKey("key")
+                .setValue("val")
+                .build();
+    }
+
+    public static Iterable<Types.XHeader> generateXHeaders() {
+        return Arrays.asList(generateXHeader(), generateXHeader());
+    }
+}

client/src/test/java/info/frostfs/sdk/testgenerator/StatusGenerator.java

@@ -0,0 +1,29 @@
+package info.frostfs.sdk.testgenerator;
+
+import com.google.protobuf.ByteString;
+import frostfs.status.Types;
+
+import java.util.Arrays;
+
+public class StatusGenerator {
+
+    public static Types.Status.Detail generateDetail() {
+        return Types.Status.Detail.newBuilder()
+                .setId(345)
+                .setValue(ByteString.copyFrom("value".getBytes()))
+                .build();
+    }
+
+    public static Iterable<Types.Status.Detail> generateDetails() {
+        return Arrays.asList(generateDetail(), generateDetail());
+    }
+
+    public static Types.Status generateStatus() {
+        return Types.Status.newBuilder()
+                .setCode(2)
+                .setMessage("some string")
+                .addAllDetails(generateDetails())
+                .build();
+    }
+
+}

client/src/test/resources/test_chain_raw.json

@@ -0,0 +1,30 @@
+{
+  "ID": "",
+  "Rules": [
+    {
+      "Status": "Allow",
+      "Actions": {
+        "Inverted": false,
+        "Names": [
+          "GetObject"
+        ]
+      },
+      "Resources": {
+        "Inverted": false,
+        "Names": [
+          "native:object/*"
+        ]
+      },
+      "Any": false,
+      "Condition": [
+        {
+          "Op": "StringEquals",
+          "Object": "Resource",
+          "Key": "Department",
+          "Value": "HR"
+        }
+      ]
+    }
+  ],
+  "MatchType": "DenyPriority"
+}