[#23] Update proto api

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

models/src/main/java/info/frostfs/sdk/dto/chain/Chain.java

@@ -0,0 +1,10 @@
+package info.frostfs.sdk.dto.chain;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public class Chain {
+    private final byte[] raw;
+}

models/src/main/java/info/frostfs/sdk/dto/chain/ChainTarget.java

@@ -0,0 +1,17 @@
+package info.frostfs.sdk.dto.chain;
+
+import info.frostfs.sdk.enums.TargetType;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+
+@Getter
+@EqualsAndHashCode
+public class ChainTarget {
+    private final TargetType type;
+    private final String name;
+
+    public ChainTarget(String name, TargetType type) {
+        this.name = name;
+        this.type = type;
+    }
+}

models/src/main/java/info/frostfs/sdk/enums/TargetType.java

@@ -0,0 +1,34 @@
+package info.frostfs.sdk.enums;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+public enum TargetType {
+    UNDEFINED(0),
+    NAMESPACE(1),
+    CONTAINER(2),
+    USER(3),
+    GROUP(4),
+    ;
+
+    private static final Map<Integer, TargetType> ENUM_MAP_BY_VALUE;
+
+    static {
+        Map<Integer, TargetType> map = new HashMap<>();
+        for (TargetType targetType : TargetType.values()) {
+            map.put(targetType.value, targetType);
+        }
+        ENUM_MAP_BY_VALUE = Collections.unmodifiableMap(map);
+    }
+
+    public final int value;
+
+    TargetType(int value) {
+        this.value = value;
+    }
+
+    public static TargetType get(int value) {
+        return ENUM_MAP_BY_VALUE.get(value);
+    }
+}

models/src/main/java/info/frostfs/sdk/mappers/chain/ChainMapper.java

@@ -0,0 +1,31 @@
+package info.frostfs.sdk.mappers.chain;
+
+import frostfs.ape.Types;
+import info.frostfs.sdk.dto.chain.Chain;
+import org.apache.commons.collections4.CollectionUtils;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+import static java.util.Objects.isNull;
+
+public class ChainMapper {
+    private ChainMapper() {
+    }
+
+    public static List<Chain> toModels(List<Types.Chain> chains) {
+        if (CollectionUtils.isEmpty(chains)) {
+            return null;
+        }
+
+        return chains.stream().map(ChainMapper::toModel).collect(Collectors.toList());
+    }
+
+    public static Chain toModel(Types.Chain chain) {
+        if (isNull(chain) || chain.getSerializedSize() == 0) {
+            return null;
+        }
+
+        return new Chain(chain.getRaw().toByteArray());
+    }
+}

models/src/main/java/info/frostfs/sdk/mappers/chain/ChainTargetMapper.java

@@ -0,0 +1,33 @@
+package info.frostfs.sdk.mappers.chain;
+
+import frostfs.ape.Types;
+import info.frostfs.sdk.dto.chain.ChainTarget;
+import info.frostfs.sdk.exceptions.ProcessFrostFSException;
+
+import static info.frostfs.sdk.constants.ErrorConst.UNKNOWN_ENUM_VALUE_TEMPLATE;
+import static java.util.Objects.isNull;
+
+public class ChainTargetMapper {
+    private ChainTargetMapper() {
+    }
+
+    public static Types.ChainTarget toGrpcMessage(ChainTarget chainTarget) {
+        if (isNull(chainTarget)) {
+            return null;
+        }
+
+        var targetType = Types.TargetType.forNumber(chainTarget.getType().value);
+        if (isNull(targetType)) {
+            throw new ProcessFrostFSException(String.format(
+                    UNKNOWN_ENUM_VALUE_TEMPLATE,
+                    Types.ChainTarget.class.getName(),
+                    chainTarget.getType().name()
+            ));
+        }
+
+        return Types.ChainTarget.newBuilder()
+                .setType(targetType)
+                .setName(chainTarget.getName())
+                .build();
+    }
+}

models/src/test/java/info/frostfs/sdk/mappers/chain/ChainMapperTest.java

@@ -0,0 +1,64 @@
+package info.frostfs.sdk.mappers.chain;
+
+import com.google.protobuf.ByteString;
+import frostfs.ape.Types;
+import org.junit.jupiter.api.Test;
+
+import java.util.Collections;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+
+public class ChainMapperTest {
+
+    @Test
+    void toModels_success() {
+        //Given
+        var chain1 = Types.Chain.newBuilder()
+                .setRaw(ByteString.copyFrom(new byte[]{1, 2, 3, 4, 5}))
+                .build();
+        var chain2 = Types.Chain.newBuilder()
+                .setRaw(ByteString.copyFrom(new byte[]{6, 7, 8, 9, 10}))
+                .build();
+
+        //When
+        var result = ChainMapper.toModels(List.of(chain1, chain2));
+
+        //Then
+        assertNotNull(result);
+        assertThat(result).hasSize(2);
+        assertThat(result.get(0).getRaw()).containsOnly(chain1.getRaw().toByteArray());
+        assertThat(result.get(1).getRaw()).containsOnly(chain2.getRaw().toByteArray());
+    }
+
+    @Test
+    void toModels_null() {
+        //When + Then
+        assertNull(ChainMapper.toModels(null));
+        assertNull(ChainMapper.toModels(Collections.emptyList()));
+    }
+
+    @Test
+    void toModel_success() {
+        //Given
+        var chain = Types.Chain.newBuilder()
+                .setRaw(ByteString.copyFrom(new byte[]{1, 2, 3, 4, 5}))
+                .build();
+
+        //When
+        var result = ChainMapper.toModel(chain);
+
+        //Then
+        assertNotNull(result);
+        assertThat(result.getRaw()).containsOnly(chain.getRaw().toByteArray());
+    }
+
+    @Test
+    void toModel_null() {
+        //When + Then
+        assertNull(ChainMapper.toModel(null));
+        assertNull(ChainMapper.toModel(Types.Chain.getDefaultInstance()));
+    }
+}

models/src/test/java/info/frostfs/sdk/mappers/chain/ChainTargetMapperTest.java

@@ -0,0 +1,52 @@
+package info.frostfs.sdk.mappers.chain;
+
+import frostfs.ape.Types;
+import info.frostfs.sdk.dto.chain.ChainTarget;
+import info.frostfs.sdk.enums.TargetType;
+import info.frostfs.sdk.exceptions.ProcessFrostFSException;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.EnumSource;
+import org.mockito.MockedStatic;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.mockStatic;
+
+public class ChainTargetMapperTest {
+
+    @ParameterizedTest
+    @EnumSource(value = TargetType.class)
+    void toGrpcMessage_success(TargetType targetType) {
+        //Given
+        var target = new ChainTarget("BzQw5HH3feoxFDD5tCT87Y1726qzgLfxEE7wgtoRzB3R", targetType);
+
+
+        //When
+        var result = ChainTargetMapper.toGrpcMessage(target);
+
+        //Then
+        assertNotNull(result);
+        assertEquals(target.getName(), result.getName());
+        assertEquals(target.getType().value, result.getTypeValue());
+    }
+
+    @Test
+    void toGrpcMessage_null() {
+        //When + Then
+        assertNull(ChainTargetMapper.toGrpcMessage(null));
+    }
+
+    @Test
+    void toGrpcMessage_notValidScheme() {
+        //Given
+        var target = new ChainTarget("BzQw5HH3feoxFDD5tCT87Y1726qzgLfxEE7wgtoRzB3R", TargetType.UNDEFINED);
+
+        //When + Then
+        try (MockedStatic<Types.TargetType> mockStatic = mockStatic(Types.TargetType.class)) {
+            mockStatic.when(() -> Types.TargetType.forNumber(target.getType().value))
+                    .thenReturn(null);
+
+            assertThrows(ProcessFrostFSException.class, () -> ChainTargetMapper.toGrpcMessage(target));
+        }
+    }
+}

models/src/test/java/info/frostfs/sdk/mappers/object/ObjectFilterMapperTest.java

@@ -39,7 +39,7 @@ public class ObjectFilterMapperTest {
     }
 
     @Test
-    void toGrpcMessage_notValidScheme() {
+    void toGrpcMessage_notValidType() {
         //Given
         var objectFilter = new ObjectFilter.FilterByAttribute(UNSPECIFIED, "key", "value");