TrueCloudLab/frostfs-sdk-java
17
0
Fork 3
Code Issues 4 Pull requests Releases Packages Activity Actions

[#43] Expanding the parameters for creating a container
All checks were successful
DCO / DCO (pull_request) Successful in 29s
Details
Verify code phase / Verify code (pull_request) Successful in 1m27s
Details

Browse source 
Signed-off-by: Ori Bruk <o.bruk@yadro.com>
This commit is contained in:
Ori Bruk 2025-02-20 14:32:20 +03:00
parent 3861eb0dc2
commit fe7d2968b8
34 changed files with 855 additions and 75 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
CHANGELOG.md
View file

@ -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

4
README.md
View file

@ -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 prmContainerCreate = new PrmContainerCreate(new Container(BasicAcl.PUBLIC_RW, placementPolicy));
var placementPolicy = new PlacementPolicy(new Replica[]{new Replica(1)}, true, 0);
var prmContainerCreate = new PrmContainerCreate(new Container(placementPolicy));
var containerId = frostFSClient.createContainer(prmContainerCreate, callContext);
// Get container

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

@ -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()
.setOwnerId(OwnerIdMapper.toGrpcMessage(getContext().getOwnerId()))
.setVersion(VersionMapper.toGrpcMessage(getContext().getVersion()))
.build();
var builder = ContainerMapper.toGrpcMessage(args.getContainer());
if (!builder.hasOwnerId()) {
builder.setOwnerId(OwnerIdMapper.toGrpcMessage(getContext().getOwnerId()));
}
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))

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

@ -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(oid, grpcHeader, args, ctx);
var initRequest = createInitPutRequest(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,
frostfs.object.Types.Header header,
private Service.PutRequest createInitPutRequest(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)

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

@ -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());

1
client/src/main/java/info/frostfs/sdk/tools/RequestConstructor.java
View file

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

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

@ -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;
}
}

15
models/src/main/java/info/frostfs/sdk/dto/netmap/Filter.java Normal file
View file

@ -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;
}

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

@ -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;
}
}

15
models/src/main/java/info/frostfs/sdk/dto/netmap/Selector.java Normal file
View file

@ -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;
}

40
models/src/main/java/info/frostfs/sdk/enums/FilterOperation.java Normal file
View file

@ -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);
}
}

32
models/src/main/java/info/frostfs/sdk/enums/SelectorClause.java Normal file
View file

@ -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);
}
}

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

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

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

@ -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()));
container.setNonce(asUuid(containerGrpc.getNonce().toByteArray()));
container.setVersion(VersionMapper.toModel(containerGrpc.getVersion()));
if (CollectionUtils.isNotEmpty(containerGrpc.getAttributesList())) {
var attributes = containerGrpc.getAttributesList().stream()
.collect(Collectors.toMap(Types.Container.Attribute::getKey, Types.Container.Attribute::getValue));
container.setAttributes(attributes);
}
return container;
return new Container(
asUuid(containerGrpc.getNonce().toByteArray()),
PlacementPolicyMapper.toModel(containerGrpc.getPlacementPolicy()),
VersionMapper.toModel(containerGrpc.getVersion()),
OwnerIdMapper.toModel(containerGrpc.getOwnerId()),
attributes
);
}
}

85
models/src/main/java/info/frostfs/sdk/mappers/netmap/FilterMapper.java Normal file
View file

@ -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())
);
}
}

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

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

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

@ -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()
.setUnique(placementPolicy.isUnique());
for (Replica replica : placementPolicy.getReplicas()) {
pp.addReplicas(ReplicaMapper.toGrpcMessage(replica));
}
return pp.build();
return Types.PlacementPolicy.newBuilder()
.setUnique(placementPolicy.isUnique())
.setContainerBackupFactor(placementPolicy.getBackupFactory())
.addAllFilters(FilterMapper.toGrpcMessages(placementPolicy.getFilters()))
.addAllSelectors(SelectorMapper.toGrpcMessages(placementPolicy.getSelectors()))
.addAllReplicas(ReplicaMapper.toGrpcMessages(placementPolicy.getReplicas()))
.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),
placementPolicy.getUnique()
ReplicaMapper.toModels(placementPolicy.getReplicasList()),
placementPolicy.getUnique(),
placementPolicy.getContainerBackupFactor(),
FilterMapper.toModels(placementPolicy.getFiltersList()),
SelectorMapper.toModels(placementPolicy.getSelectorsList())
);
}
}

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

@ -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;

85
models/src/main/java/info/frostfs/sdk/mappers/netmap/SelectorMapper.java Normal file
View file

@ -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()
);
}
}

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

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

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

@ -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());

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

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

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

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

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

@ -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()));
}
}

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

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

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

@ -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());

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

@ -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(),

209
models/src/test/java/info/frostfs/sdk/mappers/netmap/FilterMapperTest.java Normal file
View file

@ -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));
}
}
}

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

@ -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());

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

@ -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

191
models/src/test/java/info/frostfs/sdk/mappers/netmap/SelectorMapperTest.java Normal file
View file

@ -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));
}
}
}

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

@ -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

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

@ -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

2
pom.xml
View file

@ -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>