add zero commit process (#40)

* add zero commit process

* revert format

* revert format

* fix feedback

* remove redundant

* feedback

Author: ggmaleva

src/main/java/dev/vality/liminator/converter/CurrentLimitValuesToLimitResponsesConverter.java

@@ -1,7 +1,7 @@
 package dev.vality.liminator.converter;
 
-import dev.vality.liminator.model.CurrentLimitValue;
 import dev.vality.liminator.LimitResponse;
+import dev.vality.liminator.model.CurrentLimitValue;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.core.convert.converter.Converter;
@@ -34,6 +34,17 @@ private LimitResponse toLimitResponse(CurrentLimitValue value) {
                 .setLimitId(value.getLimitId())
                 .setLimitName(value.getLimitName())
                 .setCommitValue(value.getCommitValue())
-                .setTotalValue(value.getHoldValue() + value.getCommitValue());
+                .setTotalValue(calculateTotal(value));
+    }
+
+    private long calculateTotal(CurrentLimitValue value) {
+        if (isZeroCommit(value)) {
+            return 0;
+        }
+        return value.getHoldValue() + value.getCommitValue();
+    }
+
+    private boolean isZeroCommit(CurrentLimitValue value) {
+        return value.getCommitCount() > 0 && value.getCommitValue() == 0;
     }
 }

src/main/java/dev/vality/liminator/dao/impl/OperationStateHistoryDaoImpl.java

@@ -16,7 +16,7 @@
 
 import static dev.vality.liminator.domain.Tables.LIMIT_DATA;
 import static dev.vality.liminator.domain.Tables.OPERATION_STATE_HISTORY;
-import static org.jooq.impl.DSL.select;
+import static org.jooq.impl.DSL.*;
 
 @Component
 @RequiredArgsConstructor
@@ -112,7 +112,8 @@ public List<CurrentLimitValue> getCurrentValues(List<String> limitNames, String
                                         .or(DSL.coalesce(rollbackOps.OPERATION_VALUE, 0).notEqual(0)), zero)
                                         .otherwise(DSL.coalesce(holdOps.OPERATION_VALUE, 0).cast(Long.class))
                                 ).cast(Long.class),
-                        DSL.sum(DSL.coalesce(commitOps.OPERATION_VALUE, 0).cast(Long.class))
+                        DSL.sum(DSL.coalesce(commitOps.OPERATION_VALUE, 0).cast(Long.class)),
+                        field(DSL.count(commitOps.ID))
                 )
                 .from(
                         LIMIT_DATA
@@ -153,7 +154,8 @@ public List<CurrentLimitValue> getCurrentValues(List<String> limitNames, String
                                 record.value1(),
                                 record.value2(),
                                 record.value3().longValue(),
-                                record.value4().longValue()
+                                record.value4().longValue(),
+                                record.value5().intValue()
                         )
                 )
                 .toList();

src/main/java/dev/vality/liminator/model/CurrentLimitValue.java

@@ -11,4 +11,5 @@ public class CurrentLimitValue {
     private String limitName;
     private Long holdValue;
     private Long commitValue;
+    private Integer commitCount;
 }

src/main/java/dev/vality/liminator/service/LimitOperationsHistoryService.java

@@ -77,8 +77,12 @@ private List<LimitValue> checkExistedHoldOperations(LimitRequest request,
                 operationStateHistoryDao.getHoldLimitValues(limitNames, request.getOperationId());
         if (limitNames.size() != existedHoldOperations.size()) {
             log.error("[{}] Count of existed hold operations for limits is not equal to expected (existed size: {}, " +
-                            "expected size: {}, existedHoldOperations: {}, request: {})", state.getLiteral(),
-                    existedHoldOperations.size(), existedHoldOperations, limitNames.size(), request);
+                            "expected size: {}, existedHoldOperations: {}, request: {})",
+                    state.getLiteral(),
+                    existedHoldOperations.size(),
+                    limitNames.size(),
+                    existedHoldOperations,
+                    request);
             throw new OperationNotFound();
         }
         return existedHoldOperations;
@@ -96,7 +100,7 @@ private void checkCommitValueCorrectness(LimitRequest request,
                 .findAny();
         if (incorrectCommitValue.isPresent()) {
             log.error("[{}] Received incorrect commit value - hold is less than commit (existed size: {}, " +
-                            "expected size: {}, request: {})", state.getLiteral(), existedHoldOperations,
+                            "expected size: {}, request: {})", state.getLiteral(), existedHoldOperations.size(),
                     limitNamesMap.keySet().size(), request);
             throw new OperationNotFound();
         }

src/test/java/dev/vality/liminator/service/LiminatorServiceTest.java

@@ -181,6 +181,33 @@ void commitLessThanHoldPart3Test() throws TException {
         assertEquals(-1000L, response.getTotalValue());
     }
 
+    @Test
+    void commitWithZeroValueTest() throws TException {
+        String limitName = "TestZeroLimitCommit";
+        String operationId = "Op-123";
+        LimitRequest holdRequest = new LimitRequest()
+                .setOperationId(operationId)
+                .setLimitChanges(List.of(new LimitChange(limitName, 500L)));
+        liminatorService.hold(holdRequest);
+
+        List<LimitResponse> limitsBeforeCommit = liminatorService.getLastLimitsValues(List.of(limitName));
+        assertNotNull(limitsBeforeCommit);
+        LimitResponse responseBeforeCommit = limitsBeforeCommit.stream().findFirst().get();
+        assertEquals(500L, responseBeforeCommit.getTotalValue());
+        assertEquals(0, responseBeforeCommit.getCommitValue());
+
+        LimitRequest commitRequest = new LimitRequest()
+                .setOperationId(operationId)
+                .setLimitChanges(List.of(new LimitChange(limitName, 0L)));
+        liminatorService.commit(commitRequest);
+
+        List<LimitResponse> limitsAfterCommit = liminatorService.getLastLimitsValues(List.of(limitName));
+        assertNotNull(limitsAfterCommit);
+        LimitResponse response = limitsAfterCommit.stream().findFirst().get();
+        assertEquals(0L, response.getCommitValue());
+        assertEquals(0L, response.getTotalValue());
+    }
+
     @Test
     void commitGrossThanHoldTest() throws TException {
         String limitName = "TestLimitCommit";