Radiancebobo commented on code in PR #24235:
URL: https://github.com/apache/kafka/pull/24235#discussion_r4642404051


##########
share-coordinator/src/test/java/org/apache/kafka/coordinator/share/ShareCoordinatorShardTest.java:
##########
@@ -1806,28 +1809,131 @@ public void testInitializeStateIdempotent() {
     }
 
     @Test
-    public void testInitializeStateNotIdempotentWhenStartOffsetChanges() {
-        InitializeShareGroupStateRequestData.PartitionData partitionData = new 
InitializeShareGroupStateRequestData.PartitionData()
+    public void testInitializeStateRetryPreservesConsumptionProgress() {
+        // New partitions of an already-known topic are initialized at offset 
zero.
+        InitializeShareGroupStateRequestData.PartitionData initializeRequest = 
new InitializeShareGroupStateRequestData.PartitionData()
             .setPartition(PARTITION)
-            .setStartOffset(10)
+            .setStartOffset(0)
             .setStateEpoch(5);
 
-        CoordinatorResult<InitializeShareGroupStateResponseData, 
CoordinatorRecord> result = shard.initializeState(GROUP_ID, TOPIC_ID, 
partitionData);
-        result.records().forEach(record -> shard.replay(0L, 0L, (short) 0, 
record));
-        assertEquals(1, result.records().size());
+        CoordinatorResult<InitializeShareGroupStateResponseData, 
CoordinatorRecord> initializeResult =
+            shard.initializeState(GROUP_ID, TOPIC_ID, initializeRequest);
+        
assertEquals(InitializeShareGroupStateResponse.toResponseData(TOPIC_ID, 
PARTITION), initializeResult.response());
+        initializeResult.records().forEach(record -> shard.replay(0L, 0L, 
(short) 0, record));
+
+        ReadShareGroupStateRequestData readRequest = new 
ReadShareGroupStateRequestData()
+            .setGroupId(GROUP_ID)
+            .setTopics(List.of(new 
ReadShareGroupStateRequestData.ReadStateData()
+                .setTopicId(TOPIC_ID)
+                .setPartitions(List.of(new 
ReadShareGroupStateRequestData.PartitionData()
+                    .setPartition(PARTITION)
+                    .setLeaderEpoch(1)))));
+        CoordinatorResult<ReadShareGroupStateResponseData, CoordinatorRecord> 
readResult =
+            shard.readStateAndMaybeUpdateLeaderEpoch(readRequest);
+        assertEquals(Errors.NONE.code(), 
readResult.response().results().get(0).partitions().get(0).errorCode());
+        readResult.records().forEach(record -> shard.replay(1L, 0L, (short) 0, 
record));
+
+        // Consumption advances the start offset and persists acknowledgements 
without changing the state epoch.
+        WriteShareGroupStateRequestData writeRequest = new 
WriteShareGroupStateRequestData()
+            .setGroupId(GROUP_ID)
+            .setTopics(List.of(new 
WriteShareGroupStateRequestData.WriteStateData()
+                .setTopicId(TOPIC_ID)
+                .setPartitions(List.of(new 
WriteShareGroupStateRequestData.PartitionData()
+                    .setPartition(PARTITION)
+                    .setStateEpoch(5)
+                    .setLeaderEpoch(1)
+                    .setStartOffset(20)
+                    .setDeliveryCompleteCount(5)
+                    .setStateBatches(List.of(new 
WriteShareGroupStateRequestData.StateBatch()
+                        .setFirstOffset(25)
+                        .setLastOffset(29)
+                        .setDeliveryState((byte) 2)
+                        .setDeliveryCount((short) 1)))))));
+        CoordinatorResult<WriteShareGroupStateResponseData, CoordinatorRecord> 
writeResult = shard.writeState(writeRequest);
+        assertEquals(WriteShareGroupStateResponse.toResponseData(TOPIC_ID, 
PARTITION), writeResult.response());
+        writeResult.records().forEach(record -> shard.replay(2L, 0L, (short) 
0, record));
+
+        ReadShareGroupStateResponseData.PartitionResult stateBeforeRetry =
+            
shard.readStateAndMaybeUpdateLeaderEpoch(readRequest).response().results().get(0).partitions().get(0);
+        assertEquals(20, stateBeforeRetry.startOffset());
+        assertEquals(1, stateBeforeRetry.stateBatches().size());
+
+        // A delayed retry from an overlapping initialization must preserve 
the state already consumed.
+        CoordinatorResult<InitializeShareGroupStateResponseData, 
CoordinatorRecord> retryResult =
+            shard.initializeState(GROUP_ID, TOPIC_ID, initializeRequest);
+        
assertEquals(InitializeShareGroupStateResponse.toResponseData(TOPIC_ID, 
PARTITION), retryResult.response());
+        retryResult.records().forEach(record -> shard.replay(3L, 0L, (short) 
0, record));
+
+        ReadShareGroupStateResponseData.PartitionResult stateAfterRetry =
+            
shard.readStateAndMaybeUpdateLeaderEpoch(readRequest).response().results().get(0).partitions().get(0);
+        assertAll(
+            () -> assertEquals(stateBeforeRetry.startOffset(), 
stateAfterRetry.startOffset(), "Start offset must not regress"),
+            () -> assertEquals(stateBeforeRetry.stateBatches(), 
stateAfterRetry.stateBatches(), "Persisted acknowledgements must be preserved")

Review Comment:
   Added assertions verifying that deliveryCompleteCount is 5 before the
   retry and remains unchanged afterward. These assertions inspect the
   shard state directly, since ReadShareGroupStateResponse does not expose
   this field.



-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: [email protected]

For queries about this service, please contact Infrastructure at:
[email protected]

Reply via email to