CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## [0.7.0] - 2025-02-20
+
+### Added
+- Expanding the parameters for creating a container
+
+### Fixed
+- Creating a session for working with objects 
+
 ## [0.6.0] - 2025-02-13
 
 ### Added
@@ -8,6 +16,6 @@
 ## [0.5.0] - 2025-02-11
 
 ### Fixed
-- Loading large objects in chunks.
+- Loading large objects in chunks
 - .gitignore
 - pom revision

README.md

@@ -41,8 +41,8 @@ public class ContainerExample {
         FrostFSClient frostFSClient = new FrostFSClient(clientSettings);
 
         // Create container
-        var placementPolicy = new PlacementPolicy(new Replica[]{new Replica(1)}, true);
+        var placementPolicy = new PlacementPolicy(new Replica[]{new Replica(1)}, true, 0);
-        var prmContainerCreate = new PrmContainerCreate(new Container(BasicAcl.PUBLIC_RW, placementPolicy));
+        var prmContainerCreate = new PrmContainerCreate(new Container(placementPolicy));
         var containerId = frostFSClient.createContainer(prmContainerCreate, callContext);
 
         // Get container

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

@@ -186,11 +186,15 @@ public class ContainerClientImpl extends ContextAccessor implements ContainerCli
 
     private Service.PutRequest createPutRequest(PrmContainerCreate args, CallContext ctx) {
         syncContainerWithNetwork(args.getContainer(), ctx);
-        var container = ContainerMapper.toGrpcMessage(args.getContainer()).toBuilder()
+        var builder = ContainerMapper.toGrpcMessage(args.getContainer());
-                .setOwnerId(OwnerIdMapper.toGrpcMessage(getContext().getOwnerId()))
+        if (!builder.hasOwnerId()) {
-                .setVersion(VersionMapper.toGrpcMessage(getContext().getVersion()))
+            builder.setOwnerId(OwnerIdMapper.toGrpcMessage(getContext().getOwnerId()));
-                .build();
+        }
+        if (!builder.hasVersion()) {
+            builder.setVersion(VersionMapper.toGrpcMessage(getContext().getVersion()));
+        }
 
+        var container = builder.build();
         var body = Service.PutRequest.Body.newBuilder()
                 .setContainer(container)
                 .setSignature(RequestSigner.signRFC6979(getContext().getKey(), container))

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

@@ -35,7 +35,6 @@ import java.io.InputStream;
 import java.util.ArrayList;
 import java.util.List;
 
-import static info.frostfs.sdk.Helper.getSha256;
 import static info.frostfs.sdk.constants.ErrorConst.PROTO_MESSAGE_IS_EMPTY_TEMPLATE;
 import static info.frostfs.sdk.tools.RequestSigner.sign;
 import static info.frostfs.sdk.utils.DeadLineUtil.deadLineAfter;
@@ -335,6 +334,7 @@ public class ObjectClientImpl extends ContextAccessor implements ObjectClient {
                     .setBody(body)
                     .clearVerifyHeader();
 
+            RequestConstructor.addMetaHeader(chunkRequest, args.getXHeaders());
             sign(chunkRequest, getContext().getKey());
 
             stream.write(chunkRequest.build());
@@ -359,9 +359,7 @@ public class ObjectClientImpl extends ContextAccessor implements ObjectClient {
             grpcHeader = objectToolsImpl.updateSplitValues(grpcHeader, header.getSplit());
         }
 
-        var oid = Types.ObjectID.newBuilder().setValue(getSha256(grpcHeader)).build();
+        var initRequest = createInitPutRequest(grpcHeader, args, ctx);
-
-        var initRequest = createInitPutRequest(oid, grpcHeader, args, ctx);
 
         return putObjectInit(initRequest, ctx);
     }
@@ -527,13 +525,11 @@ public class ObjectClientImpl extends ContextAccessor implements ObjectClient {
         return request.build();
     }
 
-    private Service.PutRequest createInitPutRequest(Types.ObjectID oid,
+    private Service.PutRequest createInitPutRequest(frostfs.object.Types.Header header,
-                                                    frostfs.object.Types.Header header,
                                                     PrmObjectPutBase args,
                                                     CallContext ctx) {
         var address = Types.Address.newBuilder()
                 .setContainerId(header.getContainerId())
-                .setObjectId(oid)
                 .build();
         var init = Service.PutRequest.Body.Init.newBuilder()
                 .setHeader(header)
@@ -563,7 +559,6 @@ public class ObjectClientImpl extends ContextAccessor implements ObjectClient {
                                                             CallContext ctx) {
         var address = Types.Address.newBuilder()
                 .setContainerId(grpcObject.getHeader().getContainerId())
-                .setObjectId(grpcObject.getObjectId())
                 .build();
         var body = Service.PutSingleRequest.Body.newBuilder()
                 .setObject(grpcObject)

client/src/main/java/info/frostfs/sdk/services/impl/rwhelper/ObjectWriter.java

@@ -5,6 +5,7 @@ import frostfs.object.Service;
 import info.frostfs.sdk.dto.object.ObjectId;
 import info.frostfs.sdk.jdo.ClientEnvironment;
 import info.frostfs.sdk.jdo.parameters.object.PrmObjectPutBase;
+import info.frostfs.sdk.tools.RequestConstructor;
 import info.frostfs.sdk.tools.Verifier;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
@@ -27,6 +28,7 @@ public class ObjectWriter {
                 .setBody(body)
                 .clearVerifyHeader();
 
+        RequestConstructor.addMetaHeader(chunkRequest, args.getXHeaders());
         sign(chunkRequest, environment.getKey());
 
         streamer.write(chunkRequest.build());

client/src/main/java/info/frostfs/sdk/tools/RequestConstructor.java

@@ -86,7 +86,6 @@ public class RequestConstructor {
                 .build();
         var body = protoToken.getBody().toBuilder()
                 .setObject(ctx)
-                .setSessionKey(ByteString.copyFrom(key.getPublicKeyByte()))
                 .build();
 
         return protoToken.toBuilder()

models/src/main/java/info/frostfs/sdk/dto/container/Container.java

@@ -2,7 +2,8 @@ package info.frostfs.sdk.dto.container;
 
 import info.frostfs.sdk.dto.netmap.PlacementPolicy;
 import info.frostfs.sdk.dto.netmap.Version;
-import info.frostfs.sdk.enums.BasicAcl;
+import info.frostfs.sdk.dto.object.OwnerId;
+import lombok.AllArgsConstructor;
 import lombok.Getter;
 import lombok.Setter;
 
@@ -12,16 +13,16 @@ import java.util.UUID;
 
 @Getter
 @Setter
+@AllArgsConstructor
 public class Container {
     private UUID nonce;
-    private BasicAcl basicAcl;
     private PlacementPolicy placementPolicy;
     private Version version;
+    private OwnerId ownerId;
     private Map<String, String> attributes = new HashMap<>();
 
-    public Container(BasicAcl basicAcl, PlacementPolicy placementPolicy) {
+    public Container(PlacementPolicy placementPolicy) {
         this.nonce = UUID.randomUUID();
-        this.basicAcl = basicAcl;
         this.placementPolicy = placementPolicy;
     }
 }

models/src/main/java/info/frostfs/sdk/dto/netmap/Filter.java

@@ -0,0 +1,15 @@
+package info.frostfs.sdk.dto.netmap;
+
+import info.frostfs.sdk.enums.FilterOperation;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public class Filter {
+    private final String name;
+    private final String key;
+    private final FilterOperation operation;
+    private final String value;
+    private final Filter[] filters;
+}

models/src/main/java/info/frostfs/sdk/dto/netmap/PlacementPolicy.java

@@ -8,4 +8,15 @@ import lombok.Getter;
 public class PlacementPolicy {
     private final Replica[] replicas;
     private final boolean unique;
+    private final int backupFactory;
+    private final Filter[] filters;
+    private final Selector[] selectors;
+
+    public PlacementPolicy(Replica[] replicas, boolean unique, int backupFactory) {
+        this.replicas = replicas;
+        this.unique = unique;
+        this.backupFactory = backupFactory;
+        this.filters = null;
+        this.selectors = null;
+    }
 }

models/src/main/java/info/frostfs/sdk/dto/netmap/Selector.java

@@ -0,0 +1,15 @@
+package info.frostfs.sdk.dto.netmap;
+
+import info.frostfs.sdk.enums.SelectorClause;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public class Selector {
+    private final String name;
+    private final int count;
+    private final SelectorClause clause;
+    private final String attribute;
+    private final String filter;
+}

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

@@ -0,0 +1,40 @@
+package info.frostfs.sdk.enums;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+public enum FilterOperation {
+    OPERATION_UNSPECIFIED(0),
+    EQ(1),
+    NE(2),
+    GT(3),
+    GE(4),
+    LT(5),
+    LE(6),
+    OR(7),
+    AND(8),
+    NOT(9),
+    LIKE(10),
+    ;
+
+    private static final Map<Integer, FilterOperation> ENUM_MAP_BY_VALUE;
+
+    static {
+        Map<Integer, FilterOperation> map = new HashMap<>();
+        for (FilterOperation nodeState : FilterOperation.values()) {
+            map.put(nodeState.value, nodeState);
+        }
+        ENUM_MAP_BY_VALUE = Collections.unmodifiableMap(map);
+    }
+
+    public final int value;
+
+    FilterOperation(int value) {
+        this.value = value;
+    }
+
+    public static FilterOperation get(int value) {
+        return ENUM_MAP_BY_VALUE.get(value);
+    }
+}

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

@@ -0,0 +1,32 @@
+package info.frostfs.sdk.enums;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+public enum SelectorClause {
+    CLAUSE_UNSPECIFIED(0),
+    SAME(1),
+    DISTINCT(2),
+    ;
+
+    private static final Map<Integer, SelectorClause> ENUM_MAP_BY_VALUE;
+
+    static {
+        Map<Integer, SelectorClause> map = new HashMap<>();
+        for (SelectorClause nodeState : SelectorClause.values()) {
+            map.put(nodeState.value, nodeState);
+        }
+        ENUM_MAP_BY_VALUE = Collections.unmodifiableMap(map);
+    }
+
+    public final int value;
+
+    SelectorClause(int value) {
+        this.value = value;
+    }
+
+    public static SelectorClause get(int value) {
+        return ENUM_MAP_BY_VALUE.get(value);
+    }
+}

models/src/main/java/info/frostfs/sdk/mappers/container/ContainerIdMapper.java

@@ -7,7 +7,6 @@ import info.frostfs.sdk.dto.container.ContainerId;
 import static java.util.Objects.isNull;
 
 public class ContainerIdMapper {
-
     private ContainerIdMapper() {
     }
 

models/src/main/java/info/frostfs/sdk/mappers/container/ContainerMapper.java

@@ -7,8 +7,9 @@ import info.frostfs.sdk.enums.BasicAcl;
 import info.frostfs.sdk.exceptions.ProcessFrostFSException;
 import info.frostfs.sdk.mappers.netmap.PlacementPolicyMapper;
 import info.frostfs.sdk.mappers.netmap.VersionMapper;
-import org.apache.commons.collections4.CollectionUtils;
+import info.frostfs.sdk.mappers.object.OwnerIdMapper;
 
+import java.util.Optional;
 import java.util.stream.Collectors;
 
 import static info.frostfs.sdk.UuidExtension.asBytes;
@@ -20,16 +21,11 @@ public class ContainerMapper {
     private ContainerMapper() {
     }
 
-    public static Types.Container toGrpcMessage(Container container) {
+    public static Types.Container.Builder toGrpcMessage(Container container) {
         if (isNull(container)) {
             return null;
         }
 
-        var containerGrpc = Types.Container.newBuilder()
-                .setBasicAcl(container.getBasicAcl().value)
-                .setPlacementPolicy(PlacementPolicyMapper.toGrpcMessage(container.getPlacementPolicy()))
-                .setNonce(ByteString.copyFrom(asBytes(container.getNonce())));
-
         var attributes = container.getAttributes().entrySet().stream()
                 .map(entry ->
                         Types.Container.Attribute.newBuilder()
@@ -38,9 +34,16 @@ public class ContainerMapper {
                                 .build()
                 )
                 .collect(Collectors.toList());
-        containerGrpc.addAllAttributes(attributes);
 
-        return containerGrpc.build();
+        var containerGrpc = Types.Container.newBuilder()
+                .setPlacementPolicy(PlacementPolicyMapper.toGrpcMessage(container.getPlacementPolicy()))
+                .setNonce(ByteString.copyFrom(asBytes(container.getNonce())))
+                .addAllAttributes(attributes);
+
+        Optional.ofNullable(OwnerIdMapper.toGrpcMessage(container.getOwnerId())).ifPresent(containerGrpc::setOwnerId);
+        Optional.ofNullable(VersionMapper.toGrpcMessage(container.getVersion())).ifPresent(containerGrpc::setVersion);
+
+        return containerGrpc;
     }
 
     public static Container toModel(Types.Container containerGrpc) {
@@ -55,17 +58,15 @@ public class ContainerMapper {
             );
         }
 
+        var attributes = containerGrpc.getAttributesList().stream()
+                .collect(Collectors.toMap(Types.Container.Attribute::getKey, Types.Container.Attribute::getValue));
 
-        var container = new Container(basicAcl, PlacementPolicyMapper.toModel(containerGrpc.getPlacementPolicy()));
+        return new Container(
-        container.setNonce(asUuid(containerGrpc.getNonce().toByteArray()));
+                asUuid(containerGrpc.getNonce().toByteArray()),
-        container.setVersion(VersionMapper.toModel(containerGrpc.getVersion()));
+                PlacementPolicyMapper.toModel(containerGrpc.getPlacementPolicy()),
-
+                VersionMapper.toModel(containerGrpc.getVersion()),
-        if (CollectionUtils.isNotEmpty(containerGrpc.getAttributesList())) {
+                OwnerIdMapper.toModel(containerGrpc.getOwnerId()),
-            var attributes = containerGrpc.getAttributesList().stream()
+                attributes
-                    .collect(Collectors.toMap(Types.Container.Attribute::getKey, Types.Container.Attribute::getValue));
+        );
-            container.setAttributes(attributes);
-        }
-
-        return container;
     }
 }

models/src/main/java/info/frostfs/sdk/mappers/netmap/FilterMapper.java

@@ -0,0 +1,85 @@
+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.apache.commons.collections4.CollectionUtils;
+import org.apache.commons.lang3.ArrayUtils;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import static info.frostfs.sdk.constants.ErrorConst.INPUT_PARAM_IS_MISSING_TEMPLATE;
+import static info.frostfs.sdk.constants.ErrorConst.UNKNOWN_ENUM_VALUE_TEMPLATE;
+import static java.util.Objects.isNull;
+
+public class FilterMapper {
+    private FilterMapper() {
+    }
+
+    public static List<Types.Filter> toGrpcMessages(Filter[] filters) {
+        if (ArrayUtils.isEmpty(filters)) {
+            return Collections.emptyList();
+        }
+
+        return Arrays.stream(filters).map(FilterMapper::toGrpcMessage).collect(Collectors.toList());
+    }
+
+    public static Types.Filter toGrpcMessage(Filter filter) {
+        if (isNull(filter)) {
+            throw new ValidationFrostFSException(
+                    String.format(INPUT_PARAM_IS_MISSING_TEMPLATE, Filter.class.getName())
+            );
+        }
+
+        var operation = Types.Operation.forNumber(filter.getOperation().value);
+        if (isNull(operation)) {
+            throw new ProcessFrostFSException(String.format(
+                    UNKNOWN_ENUM_VALUE_TEMPLATE,
+                    Types.Operation.class.getName(),
+                    filter.getOperation().name()
+            ));
+        }
+
+        return Types.Filter.newBuilder()
+                .setName(filter.getName())
+                .setKey(filter.getKey())
+                .setOp(operation)
+                .setValue(filter.getValue())
+                .addAllFilters(toGrpcMessages(filter.getFilters()))
+                .build();
+    }
+
+    public static Filter[] toModels(List<Types.Filter> filters) {
+        if (CollectionUtils.isEmpty(filters)) {
+            return null;
+        }
+
+        return filters.stream().map(FilterMapper::toModel).toArray(Filter[]::new);
+    }
+
+    public static Filter toModel(Types.Filter filter) {
+        if (isNull(filter) || filter.getSerializedSize() == 0) {
+            return null;
+        }
+
+        var operation = FilterOperation.get(filter.getOpValue());
+        if (isNull(operation)) {
+            throw new ProcessFrostFSException(
+                    String.format(UNKNOWN_ENUM_VALUE_TEMPLATE, FilterOperation.class.getName(), filter.getOp())
+            );
+        }
+
+        return new Filter(
+                filter.getName(),
+                filter.getKey(),
+                operation,
+                filter.getValue(),
+                toModels(filter.getFiltersList())
+        );
+    }
+}

models/src/main/java/info/frostfs/sdk/mappers/netmap/NetmapSnapshotMapper.java

@@ -8,7 +8,6 @@ import java.util.stream.Collectors;
 import static java.util.Objects.isNull;
 
 public class NetmapSnapshotMapper {
-
     private NetmapSnapshotMapper() {
     }
 

models/src/main/java/info/frostfs/sdk/mappers/netmap/PlacementPolicyMapper.java

@@ -2,7 +2,6 @@ package info.frostfs.sdk.mappers.netmap;
 
 import frostfs.netmap.Types;
 import info.frostfs.sdk.dto.netmap.PlacementPolicy;
-import info.frostfs.sdk.dto.netmap.Replica;
 
 import static java.util.Objects.isNull;
 
@@ -15,14 +14,13 @@ public class PlacementPolicyMapper {
             return null;
         }
 
-        var pp = Types.PlacementPolicy.newBuilder()
+        return Types.PlacementPolicy.newBuilder()
-                .setUnique(placementPolicy.isUnique());
+                .setUnique(placementPolicy.isUnique())
-
+                .setContainerBackupFactor(placementPolicy.getBackupFactory())
-        for (Replica replica : placementPolicy.getReplicas()) {
+                .addAllFilters(FilterMapper.toGrpcMessages(placementPolicy.getFilters()))
-            pp.addReplicas(ReplicaMapper.toGrpcMessage(replica));
+                .addAllSelectors(SelectorMapper.toGrpcMessages(placementPolicy.getSelectors()))
-        }
+                .addAllReplicas(ReplicaMapper.toGrpcMessages(placementPolicy.getReplicas()))
-
+                .build();
-        return pp.build();
     }
 
     public static PlacementPolicy toModel(Types.PlacementPolicy placementPolicy) {
@@ -31,8 +29,11 @@ public class PlacementPolicyMapper {
         }
 
         return new PlacementPolicy(
-                placementPolicy.getReplicasList().stream().map(ReplicaMapper::toModel).toArray(Replica[]::new),
+                ReplicaMapper.toModels(placementPolicy.getReplicasList()),
-                placementPolicy.getUnique()
+                placementPolicy.getUnique(),
+                placementPolicy.getContainerBackupFactor(),
+                FilterMapper.toModels(placementPolicy.getFiltersList()),
+                SelectorMapper.toModels(placementPolicy.getSelectorsList())
         );
     }
 }

models/src/main/java/info/frostfs/sdk/mappers/netmap/ReplicaMapper.java

@@ -2,17 +2,35 @@ 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.apache.commons.collections4.CollectionUtils;
+import org.apache.commons.lang3.ArrayUtils;
 
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import static info.frostfs.sdk.constants.ErrorConst.INPUT_PARAM_IS_MISSING_TEMPLATE;
 import static java.util.Objects.isNull;
 
 public class ReplicaMapper {
-
     private ReplicaMapper() {
     }
 
+    public static List<Types.Replica> toGrpcMessages(Replica[] replicas) {
+        if (ArrayUtils.isEmpty(replicas)) {
+            return Collections.emptyList();
+        }
+
+        return Arrays.stream(replicas).map(ReplicaMapper::toGrpcMessage).collect(Collectors.toList());
+    }
+
     public static Types.Replica toGrpcMessage(Replica replica) {
         if (isNull(replica)) {
-            return null;
+            throw new ValidationFrostFSException(
+                    String.format(INPUT_PARAM_IS_MISSING_TEMPLATE, Replica.class.getName())
+            );
         }
 
         return Types.Replica.newBuilder()
@@ -21,6 +39,14 @@ public class ReplicaMapper {
                 .build();
     }
 
+    public static Replica[] toModels(List<Types.Replica> filters) {
+        if (CollectionUtils.isEmpty(filters)) {
+            return null;
+        }
+
+        return filters.stream().map(ReplicaMapper::toModel).toArray(Replica[]::new);
+    }
+
     public static Replica toModel(Types.Replica replica) {
         if (isNull(replica) || replica.getSerializedSize() == 0) {
             return null;

models/src/main/java/info/frostfs/sdk/mappers/netmap/SelectorMapper.java

@@ -0,0 +1,85 @@
+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.apache.commons.collections4.CollectionUtils;
+import org.apache.commons.lang3.ArrayUtils;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import static info.frostfs.sdk.constants.ErrorConst.INPUT_PARAM_IS_MISSING_TEMPLATE;
+import static info.frostfs.sdk.constants.ErrorConst.UNKNOWN_ENUM_VALUE_TEMPLATE;
+import static java.util.Objects.isNull;
+
+public class SelectorMapper {
+    private SelectorMapper() {
+    }
+
+    public static List<Types.Selector> toGrpcMessages(Selector[] selectors) {
+        if (ArrayUtils.isEmpty(selectors)) {
+            return Collections.emptyList();
+        }
+
+        return Arrays.stream(selectors).map(SelectorMapper::toGrpcMessage).collect(Collectors.toList());
+    }
+
+    public static Types.Selector toGrpcMessage(Selector selector) {
+        if (isNull(selector)) {
+            throw new ValidationFrostFSException(
+                    String.format(INPUT_PARAM_IS_MISSING_TEMPLATE, Selector.class.getName())
+            );
+        }
+
+        var clause = Types.Clause.forNumber(selector.getClause().value);
+        if (isNull(clause)) {
+            throw new ProcessFrostFSException(String.format(
+                    UNKNOWN_ENUM_VALUE_TEMPLATE,
+                    Types.Clause.class.getName(),
+                    selector.getClause().name()
+            ));
+        }
+
+        return Types.Selector.newBuilder()
+                .setName(selector.getName())
+                .setCount(selector.getCount())
+                .setClause(clause)
+                .setAttribute(selector.getAttribute())
+                .setFilter(selector.getFilter())
+                .build();
+    }
+
+    public static Selector[] toModels(List<Types.Selector> selectors) {
+        if (CollectionUtils.isEmpty(selectors)) {
+            return null;
+        }
+
+        return selectors.stream().map(SelectorMapper::toModel).toArray(Selector[]::new);
+    }
+
+    public static Selector toModel(Types.Selector selector) {
+        if (isNull(selector) || selector.getSerializedSize() == 0) {
+            return null;
+        }
+
+        var clause = SelectorClause.get(selector.getClauseValue());
+        if (isNull(clause)) {
+            throw new ProcessFrostFSException(
+                    String.format(UNKNOWN_ENUM_VALUE_TEMPLATE, SelectorClause.class.getName(), selector.getClause())
+            );
+        }
+
+        return new Selector(
+                selector.getName(),
+                selector.getCount(),
+                clause,
+                selector.getAttribute(),
+                selector.getFilter()
+        );
+    }
+}

models/src/main/java/info/frostfs/sdk/mappers/netmap/VersionMapper.java

@@ -6,7 +6,6 @@ import info.frostfs.sdk.dto.netmap.Version;
 import static java.util.Objects.isNull;
 
 public class VersionMapper {
-
     private VersionMapper() {
     }
 

models/src/main/java/info/frostfs/sdk/mappers/object/ObjectAttributeMapper.java

@@ -4,19 +4,19 @@ import frostfs.object.Types;
 import info.frostfs.sdk.dto.object.ObjectAttribute;
 import org.apache.commons.collections4.CollectionUtils;
 
+import java.util.Collections;
 import java.util.List;
 import java.util.stream.Collectors;
 
 import static java.util.Objects.isNull;
 
 public class ObjectAttributeMapper {
-
     private ObjectAttributeMapper() {
     }
 
     public static List<Types.Header.Attribute> toGrpcMessages(List<ObjectAttribute> attributes) {
         if (CollectionUtils.isEmpty(attributes)) {
-            return null;
+            return Collections.emptyList();
         }
 
         return attributes.stream().map(ObjectAttributeMapper::toGrpcMessage).collect(Collectors.toList());

models/src/main/java/info/frostfs/sdk/mappers/object/ObjectFrostFSMapper.java

@@ -7,7 +7,6 @@ import info.frostfs.sdk.dto.object.ObjectId;
 import static java.util.Objects.isNull;
 
 public class ObjectFrostFSMapper {
-
     private ObjectFrostFSMapper() {
     }
 

models/src/main/java/info/frostfs/sdk/mappers/object/ObjectIdMapper.java

@@ -7,7 +7,6 @@ import info.frostfs.sdk.dto.object.ObjectId;
 import static java.util.Objects.isNull;
 
 public class ObjectIdMapper {
-
     private ObjectIdMapper() {
     }
 

models/src/main/java/info/frostfs/sdk/mappers/object/OwnerIdMapper.java

@@ -2,12 +2,12 @@ package info.frostfs.sdk.mappers.object;
 
 import com.google.protobuf.ByteString;
 import frostfs.refs.Types;
+import info.frostfs.sdk.Base58;
 import info.frostfs.sdk.dto.object.OwnerId;
 
 import static java.util.Objects.isNull;
 
 public class OwnerIdMapper {
-
     private OwnerIdMapper() {
     }
 
@@ -20,4 +20,12 @@ public class OwnerIdMapper {
                 .setValue(ByteString.copyFrom(ownerId.toHash()))
                 .build();
     }
+
+    public static OwnerId toModel(Types.OwnerID ownerId) {
+        if (isNull(ownerId) || ownerId.getSerializedSize() == 0) {
+            return null;
+        }
+
+        return new OwnerId(Base58.encode(ownerId.getValue().toByteArray()));
+    }
 }

models/src/main/java/info/frostfs/sdk/mappers/object/patch/AddressMapper.java

@@ -8,7 +8,6 @@ import info.frostfs.sdk.mappers.object.ObjectIdMapper;
 import static java.util.Objects.isNull;
 
 public class AddressMapper {
-
     private AddressMapper() {
     }
 

models/src/main/java/info/frostfs/sdk/mappers/object/patch/RangeMapper.java

@@ -4,19 +4,19 @@ import frostfs.object.Service;
 import info.frostfs.sdk.dto.object.patch.Range;
 import org.apache.commons.collections4.CollectionUtils;
 
+import java.util.Collections;
 import java.util.List;
 import java.util.stream.Collectors;
 
 import static java.util.Objects.isNull;
 
 public class RangeMapper {
-
     private RangeMapper() {
     }
 
     public static List<Service.Range> toGrpcMessages(List<Range> ranges) {
         if (CollectionUtils.isEmpty(ranges)) {
-            return null;
+            return Collections.emptyList();
         }
 
         return ranges.stream().map(RangeMapper::toGrpcMessage).collect(Collectors.toList());

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 placementPolicy = new PlacementPolicy(new Replica[]{new Replica(3)}, true, 1);
-        var container = new Container(BasicAcl.PUBLIC_RW, placementPolicy);
+        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));
+        assertTrue(CollectionUtils.isEmpty(ObjectAttributeMapper.toGrpcMessages(null)));
-        assertNull(ObjectAttributeMapper.toGrpcMessages(Collections.emptyList()));
+        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));
+        assertTrue(CollectionUtils.isEmpty(RangeMapper.toGrpcMessages(null)));
-        assertNull(RangeMapper.toGrpcMessages(Collections.emptyList()));
+        assertTrue(CollectionUtils.isEmpty(RangeMapper.toGrpcMessages(Collections.emptyList())));
     }
 
     @Test

pom.xml

@@ -17,7 +17,7 @@
     </modules>
 
     <properties>
-        <revision>0.6.0</revision>
+        <revision>0.7.0</revision>
 
         <maven.compiler.source>11</maven.compiler.source>
         <maven.compiler.target>11</maven.compiler.target>