[#43] Expanding the parameters for creating a container

Signed-off-by: Ori Bruk <o.bruk@yadro.com>

models/src/test/java/info/frostfs/sdk/mappers/container/ContainerMapperTest.java

@@ -5,8 +5,11 @@ import frostfs.container.Types;
 import info.frostfs.sdk.dto.container.Container;
 import info.frostfs.sdk.dto.netmap.PlacementPolicy;
 import info.frostfs.sdk.dto.netmap.Replica;
+import info.frostfs.sdk.dto.netmap.Version;
+import info.frostfs.sdk.dto.object.OwnerId;
 import info.frostfs.sdk.enums.BasicAcl;
 import info.frostfs.sdk.exceptions.ProcessFrostFSException;
+import info.frostfs.sdk.mappers.object.OwnerIdMapper;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.EnumSource;
@@ -19,12 +22,54 @@ import static info.frostfs.sdk.constants.AttributeConst.DISABLE_HOMOMORPHIC_HASH
 import static org.junit.jupiter.api.Assertions.*;
 
 public class ContainerMapperTest {
+    private static final String OWNER_ID = "NVxUSpEEJzYXZZtUs18PrJTD9QZkLLNQ8S";
+
+    @Test
+    void toGrpcMessage_successFullMessage() {
+        //Given
+        var placementPolicy = new PlacementPolicy(new Replica[]{new Replica(3)}, true, 1);
+        var container = new Container(placementPolicy);
+        container.getAttributes().put("key1", "val1");
+        container.getAttributes().put(DISABLE_HOMOMORPHIC_HASHING_ATTRIBUTE, "false");
+        container.setVersion(new Version());
+        container.setOwnerId(new OwnerId(OWNER_ID));
+
+        //When
+        var result = ContainerMapper.toGrpcMessage(container);
+
+        //Then
+        assertNotNull(result);
+        assertEquals(container.getNonce(), asUuid(result.getNonce().toByteArray()));
+        assertEquals(container.getPlacementPolicy().isUnique(), result.getPlacementPolicy().getUnique());
+        assertEquals(
+                container.getPlacementPolicy().getBackupFactory(),
+                result.getPlacementPolicy().getContainerBackupFactor()
+        );
+        assertEquals(placementPolicy.getReplicas().length, result.getPlacementPolicy().getReplicasCount());
+        assertEquals(
+                container.getPlacementPolicy().getReplicas()[0].getCount(),
+                result.getPlacementPolicy().getReplicasList().get(0).getCount()
+        );
+        assertEquals(
+                container.getPlacementPolicy().getReplicas()[0].getSelector(),
+                result.getPlacementPolicy().getReplicasList().get(0).getSelector()
+        );
+
+        assertEquals("key1", result.getAttributes(0).getKey());
+        assertEquals("val1", result.getAttributes(0).getValue());
+        assertEquals(DISABLE_HOMOMORPHIC_HASHING_ATTRIBUTE, result.getAttributes(1).getKey());
+        assertEquals("false", result.getAttributes(1).getValue());
+
+        assertEquals(container.getVersion().getMajor(), result.getVersion().getMajor());
+        assertEquals(container.getVersion().getMinor(), result.getVersion().getMinor());
+        assertEquals(container.getOwnerId().toString(), OwnerIdMapper.toModel(result.getOwnerId()).toString());
+    }
 
     @Test
     void toGrpcMessage_success() {
         //Given
-        var placementPolicy = new PlacementPolicy(new Replica[]{new Replica(1)}, true);
-        var container = new Container(BasicAcl.PUBLIC_RW, placementPolicy);
+        var placementPolicy = new PlacementPolicy(new Replica[]{new Replica(3)}, true, 1);
+        var container = new Container(placementPolicy);
         container.getAttributes().put("key1", "val1");
         container.getAttributes().put(DISABLE_HOMOMORPHIC_HASHING_ATTRIBUTE, "false");
 
@@ -33,9 +78,12 @@ public class ContainerMapperTest {
 
         //Then
         assertNotNull(result);
-        assertEquals(container.getBasicAcl().value, result.getBasicAcl());
         assertEquals(container.getNonce(), asUuid(result.getNonce().toByteArray()));
         assertEquals(container.getPlacementPolicy().isUnique(), result.getPlacementPolicy().getUnique());
+        assertEquals(
+                container.getPlacementPolicy().getBackupFactory(),
+                result.getPlacementPolicy().getContainerBackupFactor()
+        );
         assertEquals(placementPolicy.getReplicas().length, result.getPlacementPolicy().getReplicasCount());
         assertEquals(
                 container.getPlacementPolicy().getReplicas()[0].getCount(),
@@ -75,6 +123,7 @@ public class ContainerMapperTest {
         var placementPolicy = frostfs.netmap.Types.PlacementPolicy.newBuilder()
                 .setUnique(true)
                 .addReplicas(replica)
+                .setContainerBackupFactor(2)
                 .build();
 
         var attribute1 = Types.Container.Attribute.newBuilder()
@@ -101,9 +150,12 @@ public class ContainerMapperTest {
 
         //Then
         assertNotNull(result);
-        assertEquals(container.getBasicAcl(), result.getBasicAcl().value);
         assertEquals(asUuid(container.getNonce().toByteArray()), result.getNonce());
         assertEquals(container.getPlacementPolicy().getUnique(), result.getPlacementPolicy().isUnique());
+        assertEquals(
+                container.getPlacementPolicy().getContainerBackupFactor(),
+                result.getPlacementPolicy().getBackupFactory()
+        );
         assertEquals(placementPolicy.getReplicasCount(), result.getPlacementPolicy().getReplicas().length);
         assertEquals(
                 container.getPlacementPolicy().getReplicasList().get(0).getCount(),

models/src/test/java/info/frostfs/sdk/mappers/netmap/FilterMapperTest.java

@@ -0,0 +1,209 @@
+package info.frostfs.sdk.mappers.netmap;
+
+import frostfs.netmap.Types;
+import info.frostfs.sdk.dto.netmap.Filter;
+import info.frostfs.sdk.enums.FilterOperation;
+import info.frostfs.sdk.exceptions.ProcessFrostFSException;
+import info.frostfs.sdk.exceptions.ValidationFrostFSException;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.EnumSource;
+import org.mockito.MockedStatic;
+
+import java.util.Collections;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.mockStatic;
+
+public class FilterMapperTest {
+
+    @ParameterizedTest
+    @EnumSource(value = FilterOperation.class)
+    void toGrpcMessages_success(FilterOperation operation) {
+        //Given
+        var filter1 = new Filter("name1", "key1", operation, "value1", null);
+        var filter2 = new Filter("name2", "key2", operation, "value2", null);
+
+        //When
+        var result = FilterMapper.toGrpcMessages(new Filter[]{filter1, filter2});
+
+        //Then
+        assertThat(result).isNotNull().hasSize(2);
+
+        assertEquals(filter1.getKey(), result.get(0).getKey());
+        assertEquals(filter1.getName(), result.get(0).getName());
+        assertEquals(filter1.getOperation().value, result.get(0).getOpValue());
+        assertEquals(filter1.getValue(), result.get(0).getValue());
+        assertEquals(0, result.get(0).getFiltersCount());
+
+        assertEquals(filter2.getKey(), result.get(1).getKey());
+        assertEquals(filter2.getName(), result.get(1).getName());
+        assertEquals(filter2.getOperation().value, result.get(1).getOpValue());
+        assertEquals(filter2.getValue(), result.get(1).getValue());
+        assertEquals(0, result.get(1).getFiltersCount());
+    }
+
+    @Test
+    void toGrpcMessages_null() {
+        //When + Then
+        assertEquals(Collections.emptyList(), FilterMapper.toGrpcMessages(null));
+        assertEquals(Collections.emptyList(), FilterMapper.toGrpcMessages(new Filter[]{}));
+    }
+
+    @ParameterizedTest
+    @EnumSource(value = FilterOperation.class)
+    void toGrpcMessage_success(FilterOperation operation) {
+        //Given
+        var filterChild = new Filter("name1", "key1", operation, "value1", null);
+        var filterParent = new Filter("name2", "key2", operation, "value2", new Filter[]{filterChild});
+
+        //When
+        var result = FilterMapper.toGrpcMessage(filterParent);
+
+        //Then
+        assertNotNull(result);
+        assertEquals(filterParent.getKey(), result.getKey());
+        assertEquals(filterParent.getName(), result.getName());
+        assertEquals(filterParent.getOperation().value, result.getOpValue());
+        assertEquals(filterParent.getValue(), result.getValue());
+        assertEquals(filterParent.getFilters().length, result.getFiltersCount());
+
+        var filterChildGrpc = result.getFilters(0);
+        assertEquals(filterChild.getKey(), filterChildGrpc.getKey());
+        assertEquals(filterChild.getName(), filterChildGrpc.getName());
+        assertEquals(filterChild.getOperation().value, filterChildGrpc.getOpValue());
+        assertEquals(filterChild.getValue(), filterChildGrpc.getValue());
+        assertEquals(0, filterChildGrpc.getFiltersCount());
+    }
+
+    @Test
+    void toGrpcMessage_null() {
+        //When + Then
+        assertThrows(ValidationFrostFSException.class, () -> FilterMapper.toGrpcMessage(null));
+    }
+
+    @Test
+    void toGrpcMessage_notValidOperation() {
+        //Given
+        var filter = new Filter("name1", "key1", FilterOperation.EQ, "value1", null);
+
+
+        //When + Then
+        try (MockedStatic<Types.Operation> mockStatic = mockStatic(Types.Operation.class)) {
+            mockStatic.when(() -> Types.Operation.forNumber(filter.getOperation().value))
+                    .thenReturn(null);
+
+            assertThrows(ProcessFrostFSException.class, () -> FilterMapper.toGrpcMessage(filter));
+        }
+    }
+
+    @ParameterizedTest
+    @EnumSource(value = Types.Operation.class, names = "UNRECOGNIZED", mode = EnumSource.Mode.EXCLUDE)
+    void toModels_success(Types.Operation operation) {
+        //Given
+        var filter1 = Types.Filter.newBuilder()
+                .setName("name1")
+                .setKey("key1")
+                .setOp(operation)
+                .setValue("value1")
+                .build();
+        var filter2 = Types.Filter.newBuilder()
+                .setName("name2")
+                .setKey("key2")
+                .setOp(operation)
+                .setValue("value2")
+                .build();
+
+        //When
+        var result = FilterMapper.toModels(List.of(filter1, filter2));
+
+        //Then
+        assertThat(result).isNotNull().hasSize(2);
+
+
+        assertNotNull(result);
+        assertEquals(filter1.getKey(), result[0].getKey());
+        assertEquals(filter1.getName(), result[0].getName());
+        assertEquals(filter1.getOpValue(), result[0].getOperation().value);
+        assertEquals(filter1.getValue(), result[0].getValue());
+        assertNull(result[0].getFilters());
+
+        assertEquals(filter2.getKey(), result[1].getKey());
+        assertEquals(filter2.getName(), result[1].getName());
+        assertEquals(filter2.getOpValue(), result[1].getOperation().value);
+        assertEquals(filter2.getValue(), result[1].getValue());
+        assertNull(result[1].getFilters());
+    }
+
+    @Test
+    void toModels_null() {
+        //When + Then
+        assertNull(FilterMapper.toModels(null));
+        assertNull(FilterMapper.toModels(Collections.emptyList()));
+    }
+
+    @ParameterizedTest
+    @EnumSource(value = Types.Operation.class, names = "UNRECOGNIZED", mode = EnumSource.Mode.EXCLUDE)
+    void toModel_success(Types.Operation operation) {
+        //Given
+        var filterChild = Types.Filter.newBuilder()
+                .setName("name1")
+                .setKey("key1")
+                .setOp(operation)
+                .setValue("value1")
+                .build();
+        var filterParent = Types.Filter.newBuilder()
+                .setName("name2")
+                .setKey("key2")
+                .setOp(operation)
+                .setValue("value2")
+                .addFilters(filterChild)
+                .build();
+
+        //When
+        var result = FilterMapper.toModel(filterParent);
+
+        //Then
+        assertNotNull(result);
+        assertEquals(filterParent.getKey(), result.getKey());
+        assertEquals(filterParent.getName(), result.getName());
+        assertEquals(filterParent.getOpValue(), result.getOperation().value);
+        assertEquals(filterParent.getValue(), result.getValue());
+        assertEquals(filterParent.getFiltersCount(), result.getFilters().length);
+
+        var filterChildModel = result.getFilters()[0];
+        assertEquals(filterChild.getKey(), filterChildModel.getKey());
+        assertEquals(filterChild.getName(), filterChildModel.getName());
+        assertEquals(filterChild.getOpValue(), filterChildModel.getOperation().value);
+        assertEquals(filterChild.getValue(), filterChildModel.getValue());
+        assertNull(filterChildModel.getFilters());
+    }
+
+    @Test
+    void toModel_null() {
+        //When + Then
+        assertNull(FilterMapper.toModel(null));
+        assertNull(FilterMapper.toModel(Types.Filter.getDefaultInstance()));
+    }
+
+    @Test
+    void toModel_notValidScheme() {
+        //Given
+        var filter = Types.Filter.newBuilder()
+                .setName("name1")
+                .setKey("key1")
+                .setOp(Types.Operation.EQ)
+                .setValue("value1")
+                .build();
+
+        //When + Then
+        try (MockedStatic<FilterOperation> mockStatic = mockStatic(FilterOperation.class)) {
+            mockStatic.when(() -> FilterOperation.get(Types.Operation.EQ.getNumber()))
+                    .thenReturn(null);
+
+            assertThrows(ProcessFrostFSException.class, () -> FilterMapper.toModel(filter));
+        }
+    }
+}

models/src/test/java/info/frostfs/sdk/mappers/netmap/PlacementPolicyMapperTest.java

@@ -15,7 +15,7 @@ public class PlacementPolicyMapperTest {
         var replica1 = new Replica(1, "test1");
         var replica2 = new Replica(2, "test2");
 
-        var placementPolicy = new PlacementPolicy(new Replica[]{replica1, replica2}, true);
+        var placementPolicy = new PlacementPolicy(new Replica[]{replica1, replica2}, true, 1);
 
         //When
         var result = PlacementPolicyMapper.toGrpcMessage(placementPolicy);
@@ -23,6 +23,7 @@ public class PlacementPolicyMapperTest {
         //Then
         assertNotNull(result);
         assertEquals(placementPolicy.isUnique(), result.getUnique());
+        assertEquals(placementPolicy.getBackupFactory(), result.getContainerBackupFactor());
         assertEquals(placementPolicy.getReplicas().length, result.getReplicasCount());
         assertEquals(replica1.getCount(), result.getReplicas(0).getCount());
         assertEquals(replica1.getSelector(), result.getReplicas(0).getSelector());
@@ -53,6 +54,7 @@ public class PlacementPolicyMapperTest {
                 .setUnique(true)
                 .addReplicas(replica1)
                 .addReplicas(replica2)
+                .setContainerBackupFactor(1)
                 .build();
 
         //When
@@ -61,6 +63,7 @@ public class PlacementPolicyMapperTest {
         //Then
         assertNotNull(result);
         assertEquals(placementPolicy.getUnique(), result.isUnique());
+        assertEquals(placementPolicy.getContainerBackupFactor(), result.getBackupFactory());
         assertEquals(placementPolicy.getReplicasCount(), result.getReplicas().length);
         assertEquals(replica1.getCount(), result.getReplicas()[0].getCount());
         assertEquals(replica1.getSelector(), result.getReplicas()[0].getSelector());

models/src/test/java/info/frostfs/sdk/mappers/netmap/ReplicaMapperTest.java

@@ -2,6 +2,7 @@ package info.frostfs.sdk.mappers.netmap;
 
 import frostfs.netmap.Types;
 import info.frostfs.sdk.dto.netmap.Replica;
+import info.frostfs.sdk.exceptions.ValidationFrostFSException;
 import org.junit.jupiter.api.Test;
 
 import static org.junit.jupiter.api.Assertions.*;
@@ -25,7 +26,7 @@ public class ReplicaMapperTest {
     @Test
     void toGrpcMessage_null() {
         //When + Then
-        assertNull(ReplicaMapper.toGrpcMessage(null));
+        assertThrows(ValidationFrostFSException.class, () -> ReplicaMapper.toGrpcMessage(null));
     }
 
     @Test

models/src/test/java/info/frostfs/sdk/mappers/netmap/SelectorMapperTest.java

@@ -0,0 +1,191 @@
+package info.frostfs.sdk.mappers.netmap;
+
+import frostfs.netmap.Types;
+import info.frostfs.sdk.dto.netmap.Selector;
+import info.frostfs.sdk.enums.SelectorClause;
+import info.frostfs.sdk.exceptions.ProcessFrostFSException;
+import info.frostfs.sdk.exceptions.ValidationFrostFSException;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.EnumSource;
+import org.mockito.MockedStatic;
+
+import java.util.Collections;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.mockStatic;
+
+public class SelectorMapperTest {
+
+    @ParameterizedTest
+    @EnumSource(value = SelectorClause.class)
+    void toGrpcMessages_success(SelectorClause clause) {
+        //Given
+        var selector1 = new Selector("name1", 1, clause, "attribute1", "filter1");
+        var selector2 = new Selector("name2", 2, clause, "attribute2", "filter2");
+
+        //When
+        var result = SelectorMapper.toGrpcMessages(new Selector[]{selector1, selector2});
+
+        //Then
+        assertThat(result).isNotNull().hasSize(2);
+
+        assertEquals(selector1.getName(), result.get(0).getName());
+        assertEquals(selector1.getCount(), result.get(0).getCount());
+        assertEquals(selector1.getClause().value, result.get(0).getClauseValue());
+        assertEquals(selector1.getAttribute(), result.get(0).getAttribute());
+        assertEquals(selector1.getFilter(), result.get(0).getFilter());
+
+        assertEquals(selector2.getName(), result.get(1).getName());
+        assertEquals(selector2.getCount(), result.get(1).getCount());
+        assertEquals(selector2.getClause().value, result.get(1).getClauseValue());
+        assertEquals(selector2.getAttribute(), result.get(1).getAttribute());
+        assertEquals(selector2.getFilter(), result.get(1).getFilter());
+    }
+
+    @Test
+    void toGrpcMessages_null() {
+        //When + Then
+        assertEquals(Collections.emptyList(), SelectorMapper.toGrpcMessages(null));
+        assertEquals(Collections.emptyList(), SelectorMapper.toGrpcMessages(new Selector[]{}));
+    }
+
+    @ParameterizedTest
+    @EnumSource(value = SelectorClause.class)
+    void toGrpcMessage_success(SelectorClause clause) {
+        //Given
+        var selector = new Selector("name", 1, clause, "attribute", "filter");
+
+        //When
+        var result = SelectorMapper.toGrpcMessage(selector);
+
+        //Then
+        assertNotNull(result);
+        assertEquals(selector.getName(), result.getName());
+        assertEquals(selector.getCount(), result.getCount());
+        assertEquals(selector.getClause().value, result.getClauseValue());
+        assertEquals(selector.getAttribute(), result.getAttribute());
+        assertEquals(selector.getFilter(), result.getFilter());
+    }
+
+    @Test
+    void toGrpcMessage_null() {
+        //When + Then
+        assertThrows(ValidationFrostFSException.class, () -> SelectorMapper.toGrpcMessage(null));
+    }
+
+    @Test
+    void toGrpcMessage_notValidOperation() {
+        //Given
+        var selector = new Selector("name", 1, SelectorClause.SAME, "attribute", "filter");
+
+
+        //When + Then
+        try (MockedStatic<Types.Clause> mockStatic = mockStatic(Types.Clause.class)) {
+            mockStatic.when(() -> Types.Clause.forNumber(selector.getClause().value))
+                    .thenReturn(null);
+
+            assertThrows(ProcessFrostFSException.class, () -> SelectorMapper.toGrpcMessage(selector));
+        }
+    }
+
+    @ParameterizedTest
+    @EnumSource(value = Types.Clause.class, names = "UNRECOGNIZED", mode = EnumSource.Mode.EXCLUDE)
+    void toModels_success(Types.Clause clause) {
+        //Given
+        var selector1 = Types.Selector.newBuilder()
+                .setName("name1")
+                .setCount(1)
+                .setClause(clause)
+                .setAttribute("attribute1")
+                .setFilter("filter1")
+                .build();
+        var selector2 = Types.Selector.newBuilder()
+                .setName("name2")
+                .setCount(2)
+                .setClause(clause)
+                .setAttribute("attribute2")
+                .setFilter("filter2")
+                .build();
+
+        //When
+        var result = SelectorMapper.toModels(List.of(selector1, selector2));
+
+        //Then
+        assertThat(result).isNotNull().hasSize(2);
+
+
+        assertNotNull(result);
+        assertEquals(selector1.getName(), result[0].getName());
+        assertEquals(selector1.getCount(), result[0].getCount());
+        assertEquals(selector1.getClauseValue(), result[0].getClause().value);
+        assertEquals(selector1.getAttribute(), result[0].getAttribute());
+        assertEquals(selector1.getFilter(), result[0].getFilter());
+
+        assertEquals(selector2.getName(), result[1].getName());
+        assertEquals(selector2.getCount(), result[1].getCount());
+        assertEquals(selector2.getClauseValue(), result[1].getClause().value);
+        assertEquals(selector2.getAttribute(), result[1].getAttribute());
+        assertEquals(selector2.getFilter(), result[1].getFilter());
+    }
+
+    @Test
+    void toModels_null() {
+        //When + Then
+        assertNull(SelectorMapper.toModels(null));
+        assertNull(SelectorMapper.toModels(Collections.emptyList()));
+    }
+
+    @ParameterizedTest
+    @EnumSource(value = Types.Clause.class, names = "UNRECOGNIZED", mode = EnumSource.Mode.EXCLUDE)
+    void toModel_success(Types.Clause clause) {
+        //Given
+        var selector = Types.Selector.newBuilder()
+                .setName("name")
+                .setCount(1)
+                .setClause(clause)
+                .setAttribute("attribute")
+                .setFilter("filter")
+                .build();
+
+        //When
+        var result = SelectorMapper.toModel(selector);
+
+        //Then
+        assertNotNull(result);
+        assertEquals(selector.getName(), result.getName());
+        assertEquals(selector.getCount(), result.getCount());
+        assertEquals(selector.getClauseValue(), result.getClause().value);
+        assertEquals(selector.getAttribute(), result.getAttribute());
+        assertEquals(selector.getFilter(), result.getFilter());
+    }
+
+    @Test
+    void toModel_null() {
+        //When + Then
+        assertNull(SelectorMapper.toModel(null));
+        assertNull(SelectorMapper.toModel(Types.Selector.getDefaultInstance()));
+    }
+
+    @Test
+    void toModel_notValidScheme() {
+        //Given
+        var selector = Types.Selector.newBuilder()
+                .setName("name")
+                .setCount(1)
+                .setClause(Types.Clause.SAME)
+                .setAttribute("attribute")
+                .setFilter("filter")
+                .build();
+
+        //When + Then
+        try (MockedStatic<SelectorClause> mockStatic = mockStatic(SelectorClause.class)) {
+            mockStatic.when(() -> SelectorClause.get(Types.Clause.SAME.getNumber()))
+                    .thenReturn(null);
+
+            assertThrows(ProcessFrostFSException.class, () -> SelectorMapper.toModel(selector));
+        }
+    }
+}

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

@@ -2,6 +2,7 @@ package info.frostfs.sdk.mappers.object;
 
 import frostfs.object.Types;
 import info.frostfs.sdk.dto.object.ObjectAttribute;
+import org.apache.commons.collections4.CollectionUtils;
 import org.junit.jupiter.api.Test;
 
 import java.util.Arrays;
@@ -33,8 +34,8 @@ public class ObjectAttributeMapperTest {
     @Test
     void toGrpcMessages_null() {
         //When + Then
-        assertNull(ObjectAttributeMapper.toGrpcMessages(null));
-        assertNull(ObjectAttributeMapper.toGrpcMessages(Collections.emptyList()));
+        assertTrue(CollectionUtils.isEmpty(ObjectAttributeMapper.toGrpcMessages(null)));
+        assertTrue(CollectionUtils.isEmpty(ObjectAttributeMapper.toGrpcMessages(Collections.emptyList())));
     }
 
     @Test

models/src/test/java/info/frostfs/sdk/mappers/object/patch/RangeMapperTest.java

@@ -1,6 +1,7 @@
 package info.frostfs.sdk.mappers.object.patch;
 
 import info.frostfs.sdk.dto.object.patch.Range;
+import org.apache.commons.collections4.CollectionUtils;
 import org.junit.jupiter.api.Test;
 
 import java.util.Arrays;
@@ -32,8 +33,8 @@ public class RangeMapperTest {
     @Test
     void toGrpcMessages_null() {
         //When + Then
-        assertNull(RangeMapper.toGrpcMessages(null));
-        assertNull(RangeMapper.toGrpcMessages(Collections.emptyList()));
+        assertTrue(CollectionUtils.isEmpty(RangeMapper.toGrpcMessages(null)));
+        assertTrue(CollectionUtils.isEmpty(RangeMapper.toGrpcMessages(Collections.emptyList())));
     }
 
     @Test