You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@kafka.apache.org by li...@apache.org on 2026/06/10 17:59:00 UTC
(kafka) branch trunk updated: KAFKA-18862: Consolidate shared heartbeat request manager tests (#22425)
This is an automated email from the ASF dual-hosted git repository.
lianetm pushed a commit to branch trunk
in repository https://gitbox.apache.org/repos/asf/kafka.git
The following commit(s) were added to refs/heads/trunk by this push:
new e7b0cb79087 KAFKA-18862: Consolidate shared heartbeat request manager tests (#22425)
e7b0cb79087 is described below
commit e7b0cb79087e381dae566e735f41062175099132
Author: nileshkumar3 <ni...@gmail.com>
AuthorDate: Wed Jun 10 12:58:53 2026 -0500
KAFKA-18862: Consolidate shared heartbeat request manager tests (#22425)
## Summary
Duplicate heartbeat poll/timing and error-handling tests in
`ConsumerHeartbeatRequestManagerTest` and
`ShareHeartbeatRequestManagerTest` had drifted out of sync
(KAFKA-18862). This consolidates shared behavior into
`AbstractHeartbeatRequestManagerTest`, which both subclasses extend.
Shared tests now live in one place; Consumer and Share only implement
`createHeartbeatResponse()` for their respective RPC types and retain
their manager-specific tests.
Moved to the base class:
- `testTimerNotDue`
- `testHeartbeatOutsideInterval`
- `testNoCoordinator`
-
`testPollTimerExpirationShouldNotMarkMemberStaleIfMemberAlreadyLeaving`
- `testSuccessfulHeartbeatTiming`
- `testGroupIdNotFoundExceptionWhileUnsubscribed`
- `testGroupIdNotFoundWhileStableIsFatal`
- `testHeartbeatResponseOnErrorHandling` (with shared `errorProvider()`)
This also aligns Share error coverage with Consumer (e.g.
`FENCED_INSTANCE_ID`, `TOPIC_AUTHORIZATION_FAILED`).
Reviewers: Lianet Magrans <lm...@confluent.io>, Lianet Magrans
(github:lianetm)
---
.../AbstractHeartbeatRequestManagerTest.java | 330 +++++++++++++++++++++
.../ConsumerHeartbeatRequestManagerTest.java | 306 ++-----------------
.../ShareHeartbeatRequestManagerTest.java | 294 +-----------------
3 files changed, 366 insertions(+), 564 deletions(-)
diff --git a/clients/src/test/java/org/apache/kafka/clients/consumer/internals/AbstractHeartbeatRequestManagerTest.java b/clients/src/test/java/org/apache/kafka/clients/consumer/internals/AbstractHeartbeatRequestManagerTest.java
new file mode 100644
index 00000000000..21d183e65b0
--- /dev/null
+++ b/clients/src/test/java/org/apache/kafka/clients/consumer/internals/AbstractHeartbeatRequestManagerTest.java
@@ -0,0 +1,330 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.kafka.clients.consumer.internals;
+
+import org.apache.kafka.clients.ClientResponse;
+import org.apache.kafka.clients.consumer.internals.events.BackgroundEventHandler;
+import org.apache.kafka.clients.consumer.internals.events.ErrorEvent;
+import org.apache.kafka.common.protocol.Errors;
+import org.apache.kafka.common.requests.AbstractResponse;
+import org.apache.kafka.common.utils.Time;
+import org.apache.kafka.common.utils.Timer;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.mockito.ArgumentCaptor;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Optional;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyBoolean;
+import static org.mockito.ArgumentMatchers.anyLong;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+/**
+ * Base test class for {@link AbstractHeartbeatRequestManager}. Tests defined here exercise
+ * behavior implemented in the abstract manager and must produce the same outcome for every
+ * concrete subclass.
+ */
+abstract class AbstractHeartbeatRequestManagerTest {
+
+ protected static final String DEFAULT_GROUP_ID = "groupId";
+ protected static final String DEFAULT_MEMBER_ID = "member-id";
+ protected static final int DEFAULT_MEMBER_EPOCH = 1;
+ protected static final int DEFAULT_HEARTBEAT_INTERVAL_MS = 1000;
+ protected static final int DEFAULT_MAX_POLL_INTERVAL_MS = 10000;
+ protected static final long DEFAULT_RETRY_BACKOFF_MS = 80;
+ protected static final long DEFAULT_RETRY_BACKOFF_MAX_MS = 1000;
+ protected static final double DEFAULT_HEARTBEAT_JITTER_MS = 0.0;
+
+ protected Time time;
+ protected Timer pollTimer;
+ protected CoordinatorRequestManager coordinatorRequestManager;
+ protected SubscriptionState subscriptions;
+ protected BackgroundEventHandler backgroundEventHandler;
+ protected HeartbeatRequestState heartbeatRequestState;
+ protected AbstractMembershipManager membershipManager;
+ protected AbstractHeartbeatRequestManager heartbeatRequestManager;
+
+ protected abstract ClientResponse createHeartbeatResponse(
+ NetworkClientDelegate.UnsentRequest request, Errors error);
+
+ @Test
+ public void testTimerNotDue() {
+ time.sleep(100); // before heartbeatInterval, no heartbeat should be sent
+ NetworkClientDelegate.PollResult result = heartbeatRequestManager.poll(time.milliseconds());
+
+ assertEquals(0, result.unsentRequests.size());
+ assertEquals(DEFAULT_HEARTBEAT_INTERVAL_MS - 100, result.timeUntilNextPollMs);
+ assertEquals(DEFAULT_HEARTBEAT_INTERVAL_MS - 100, heartbeatRequestManager.maximumTimeToWait(time.milliseconds()));
+
+ // Member in state where it should not send Heartbeat anymore
+ when(subscriptions.hasAutoAssignedPartitions()).thenReturn(true);
+ when(membershipManager.shouldSkipHeartbeat()).thenReturn(true);
+ result = heartbeatRequestManager.poll(time.milliseconds());
+ assertEquals(Long.MAX_VALUE, result.timeUntilNextPollMs);
+ }
+
+ @Test
+ public void testHeartbeatOutsideInterval() {
+ when(membershipManager.shouldSkipHeartbeat()).thenReturn(false);
+ when(membershipManager.shouldHeartbeatNow()).thenReturn(true);
+ NetworkClientDelegate.PollResult result = heartbeatRequestManager.poll(time.milliseconds());
+
+ assertEquals(1, result.unsentRequests.size());
+ assertEquals(DEFAULT_HEARTBEAT_INTERVAL_MS, result.timeUntilNextPollMs);
+ assertEquals(DEFAULT_HEARTBEAT_INTERVAL_MS, heartbeatRequestManager.maximumTimeToWait(time.milliseconds()));
+ verify(membershipManager).onHeartbeatRequestGenerated();
+ }
+
+ @Test
+ public void testNoCoordinator() {
+ when(coordinatorRequestManager.coordinator()).thenReturn(Optional.empty());
+ NetworkClientDelegate.PollResult result = heartbeatRequestManager.poll(time.milliseconds());
+
+ assertEquals(Long.MAX_VALUE, result.timeUntilNextPollMs);
+ assertEquals(DEFAULT_HEARTBEAT_INTERVAL_MS, heartbeatRequestManager.maximumTimeToWait(time.milliseconds()));
+ assertEquals(0, result.unsentRequests.size());
+ }
+
+ /**
+ * This is expected to be the case where a member is already leaving the group and the
+ * poll timer expires. The poll timer expiration should not transition the member to
+ * STALE, and the member should continue to send heartbeats while the ongoing leaving
+ * operation completes (send heartbeats while waiting for callbacks before leaving, or
+ * send last heartbeat to leave).
+ */
+ @Test
+ public void testPollTimerExpirationShouldNotMarkMemberStaleIfMemberAlreadyLeaving() {
+ when(membershipManager.shouldSkipHeartbeat()).thenReturn(false);
+ when(membershipManager.isLeavingGroup()).thenReturn(true);
+
+ time.sleep(DEFAULT_MAX_POLL_INTERVAL_MS);
+ NetworkClientDelegate.PollResult result = heartbeatRequestManager.poll(time.milliseconds());
+
+ // No transition to leave due to stale member should be triggered, because the member
+ // is already leaving the group.
+ verify(membershipManager, never()).transitionToSendingLeaveGroup(anyBoolean());
+
+ assertEquals(1, result.unsentRequests.size(), "A heartbeat request should be generated to" +
+ " complete the ongoing leaving operation that was triggered before the poll timer expired.");
+ }
+
+ @Test
+ public void testSuccessfulHeartbeatTiming() {
+ NetworkClientDelegate.PollResult result = heartbeatRequestManager.poll(time.milliseconds());
+ assertEquals(0, result.unsentRequests.size(),
+ "No heartbeat should be sent while interval has not expired");
+ assertEquals(heartbeatRequestState.timeToNextHeartbeatMs(time.milliseconds()), result.timeUntilNextPollMs);
+ assertNextHeartbeatTiming(DEFAULT_HEARTBEAT_INTERVAL_MS);
+
+ result = heartbeatRequestManager.poll(time.milliseconds());
+ assertEquals(1, result.unsentRequests.size(), "A heartbeat should be sent when interval expires");
+ NetworkClientDelegate.UnsentRequest inflightReq = result.unsentRequests.get(0);
+ assertEquals(DEFAULT_HEARTBEAT_INTERVAL_MS,
+ heartbeatRequestState.timeToNextHeartbeatMs(time.milliseconds()),
+ "Heartbeat timer was not reset to the interval when the heartbeat request was sent.");
+
+ long partOfInterval = DEFAULT_HEARTBEAT_INTERVAL_MS / 3;
+ time.sleep(partOfInterval);
+ result = heartbeatRequestManager.poll(time.milliseconds());
+ assertEquals(0, result.unsentRequests.size(),
+ "No heartbeat should be sent while only part of the interval has passed");
+ assertEquals(DEFAULT_HEARTBEAT_INTERVAL_MS - partOfInterval,
+ heartbeatRequestState.timeToNextHeartbeatMs(time.milliseconds()),
+ "Time to next interval was not properly updated.");
+
+ inflightReq.handler().onComplete(createHeartbeatResponse(inflightReq, Errors.NONE));
+ assertNextHeartbeatTiming(DEFAULT_HEARTBEAT_INTERVAL_MS - partOfInterval);
+ }
+
+ /**
+ * Test that GROUP_ID_NOT_FOUND error while unsubscribed is not treated as fatal. This can
+ * happen when the consumer never successfully joined the group (e.g., due to an
+ * InvalidTopicException during poll() and close() sends a leave heartbeat for a group
+ * that was never created).
+ */
+ @Test
+ public void testGroupIdNotFoundExceptionWhileUnsubscribed() {
+ when(membershipManager.state()).thenReturn(MemberState.UNSUBSCRIBED);
+ when(membershipManager.memberEpoch()).thenReturn(-1);
+
+ time.sleep(DEFAULT_HEARTBEAT_INTERVAL_MS);
+ NetworkClientDelegate.PollResult result = heartbeatRequestManager.poll(time.milliseconds());
+ assertEquals(1, result.unsentRequests.size());
+
+ ClientResponse response = createHeartbeatResponse(result.unsentRequests.get(0), Errors.GROUP_ID_NOT_FOUND);
+ result.unsentRequests.get(0).handler().onComplete(response);
+
+ verify(membershipManager, never()).transitionToFatal();
+ verify(membershipManager).onHeartbeatRequestSkipped();
+ verify(backgroundEventHandler, never()).add(any());
+ }
+
+ /**
+ * Test that GROUP_ID_NOT_FOUND error while stable is treated as fatal. This would indicate
+ * the group was unexpectedly deleted while the member was actively participating.
+ */
+ @Test
+ public void testGroupIdNotFoundWhileStableIsFatal() {
+ when(membershipManager.state()).thenReturn(MemberState.STABLE);
+ when(membershipManager.memberEpoch()).thenReturn(DEFAULT_MEMBER_EPOCH);
+
+ time.sleep(DEFAULT_HEARTBEAT_INTERVAL_MS);
+ NetworkClientDelegate.PollResult result = heartbeatRequestManager.poll(time.milliseconds());
+ assertEquals(1, result.unsentRequests.size());
+
+ when(coordinatorRequestManager.coordinator()).thenReturn(Optional.empty());
+ ClientResponse response = createHeartbeatResponse(result.unsentRequests.get(0), Errors.GROUP_ID_NOT_FOUND);
+ result.unsentRequests.get(0).handler().onComplete(response);
+
+ verify(membershipManager).transitionToFatal();
+ verify(backgroundEventHandler).add(any());
+ }
+
+ @ParameterizedTest
+ @MethodSource("errorProvider")
+ public void testHeartbeatResponseOnErrorHandling(final Errors error, final boolean isFatal) {
+ // Handling errors on the second heartbeat
+ time.sleep(DEFAULT_HEARTBEAT_INTERVAL_MS);
+ NetworkClientDelegate.PollResult result = heartbeatRequestManager.poll(time.milliseconds());
+ assertEquals(1, result.unsentRequests.size());
+
+ // Manually completing the response to test error handling
+ when(subscriptions.hasAutoAssignedPartitions()).thenReturn(true);
+ ClientResponse response = createHeartbeatResponse(
+ result.unsentRequests.get(0),
+ error);
+ result.unsentRequests.get(0).handler().onComplete(response);
+ AbstractResponse mockResponse = response.responseBody();
+
+ assertHeartbeatErrorHandling(error, isFatal, mockResponse);
+ }
+
+ protected void assertHeartbeatErrorHandling(final Errors error,
+ final boolean isFatal,
+ final AbstractResponse response) {
+ switch (error) {
+ case NONE:
+ verify(membershipManager).onHeartbeatSuccess(response);
+ assertNextHeartbeatTiming(DEFAULT_HEARTBEAT_INTERVAL_MS);
+ break;
+
+ case COORDINATOR_LOAD_IN_PROGRESS:
+ verify(backgroundEventHandler, never()).add(any());
+ assertNextHeartbeatTiming(DEFAULT_RETRY_BACKOFF_MS);
+ break;
+
+ case COORDINATOR_NOT_AVAILABLE:
+ case NOT_COORDINATOR:
+ verify(backgroundEventHandler, never()).add(any());
+ verify(coordinatorRequestManager).markCoordinatorUnknown(any(), anyLong());
+ assertNextHeartbeatTiming(0);
+ break;
+ case UNKNOWN_MEMBER_ID:
+ case FENCED_MEMBER_EPOCH:
+ verify(backgroundEventHandler, never()).add(any());
+ assertNextHeartbeatTiming(0);
+ break;
+
+ case TOPIC_AUTHORIZATION_FAILED:
+ verify(backgroundEventHandler).add(any(ErrorEvent.class));
+ assertNextHeartbeatTiming(DEFAULT_RETRY_BACKOFF_MS);
+ verify(membershipManager, never()).transitionToFatal();
+ break;
+
+ default:
+ if (isFatal) {
+ // Drop the coordinator so the follow-up poll inside ensureFatalError() does
+ // not produce another heartbeat request.
+ when(coordinatorRequestManager.coordinator()).thenReturn(Optional.empty());
+ ensureFatalError(error);
+ } else {
+ verify(backgroundEventHandler, never()).add(any());
+ assertNextHeartbeatTiming(0);
+ }
+ break;
+ }
+
+ if (error != Errors.NONE) {
+ verify(membershipManager).onHeartbeatFailure(false);
+ }
+
+ if (!isFatal) {
+ // Make sure a next heartbeat is sent for all non-fatal errors (to retry or rejoin)
+ time.sleep(DEFAULT_HEARTBEAT_INTERVAL_MS);
+ NetworkClientDelegate.PollResult result = heartbeatRequestManager.poll(time.milliseconds());
+ assertEquals(1, result.unsentRequests.size(),
+ "A follow-up heartbeat should be sent after a non-fatal error " + error);
+ }
+ }
+
+ protected void assertNextHeartbeatTiming(long expectedTimeToNextHeartbeatMs) {
+ long currentTimeMs = time.milliseconds();
+ assertEquals(expectedTimeToNextHeartbeatMs, heartbeatRequestState.timeToNextHeartbeatMs(currentTimeMs));
+ if (expectedTimeToNextHeartbeatMs != 0) {
+ assertFalse(heartbeatRequestState.canSendRequest(currentTimeMs));
+ time.sleep(expectedTimeToNextHeartbeatMs);
+ }
+ assertTrue(heartbeatRequestState.canSendRequest(time.milliseconds()));
+ }
+
+ private void ensureFatalError(Errors expectedError) {
+ verify(membershipManager).transitionToFatal();
+
+ ArgumentCaptor<ErrorEvent> errorEventArgumentCaptor = ArgumentCaptor.forClass(ErrorEvent.class);
+ verify(backgroundEventHandler).add(errorEventArgumentCaptor.capture());
+ ErrorEvent errorEvent = errorEventArgumentCaptor.getValue();
+ assertInstanceOf(expectedError.exception().getClass(), errorEvent.error(),
+ "The fatal error propagated to the app thread does not match the error received in the heartbeat response.");
+
+ // Ensure no further heartbeat is generated after the fatal error.
+ time.sleep(DEFAULT_HEARTBEAT_INTERVAL_MS);
+ NetworkClientDelegate.PollResult result = heartbeatRequestManager.poll(time.milliseconds());
+ assertEquals(0, result.unsentRequests.size(),
+ "No further heartbeat should be sent after a fatal " + expectedError + " error.");
+ }
+
+ // error, isFatal
+ private static Collection<Arguments> errorProvider() {
+ return Arrays.asList(
+ Arguments.of(Errors.NONE, false),
+ Arguments.of(Errors.COORDINATOR_NOT_AVAILABLE, false),
+ Arguments.of(Errors.COORDINATOR_LOAD_IN_PROGRESS, false),
+ Arguments.of(Errors.NOT_COORDINATOR, false),
+ Arguments.of(Errors.GROUP_AUTHORIZATION_FAILED, true),
+ Arguments.of(Errors.INVALID_REQUEST, true),
+ Arguments.of(Errors.UNKNOWN_MEMBER_ID, false),
+ Arguments.of(Errors.FENCED_MEMBER_EPOCH, false),
+ Arguments.of(Errors.UNSUPPORTED_ASSIGNOR, true),
+ Arguments.of(Errors.UNSUPPORTED_VERSION, true),
+ Arguments.of(Errors.UNRELEASED_INSTANCE_ID, true),
+ Arguments.of(Errors.FENCED_INSTANCE_ID, true),
+ Arguments.of(Errors.GROUP_MAX_SIZE_REACHED, true),
+ Arguments.of(Errors.TOPIC_AUTHORIZATION_FAILED, false));
+ }
+}
diff --git a/clients/src/test/java/org/apache/kafka/clients/consumer/internals/ConsumerHeartbeatRequestManagerTest.java b/clients/src/test/java/org/apache/kafka/clients/consumer/internals/ConsumerHeartbeatRequestManagerTest.java
index 62f819dc600..03ebf4ae0ba 100644
--- a/clients/src/test/java/org/apache/kafka/clients/consumer/internals/ConsumerHeartbeatRequestManagerTest.java
+++ b/clients/src/test/java/org/apache/kafka/clients/consumer/internals/ConsumerHeartbeatRequestManagerTest.java
@@ -43,8 +43,6 @@ import org.apache.kafka.common.requests.ConsumerGroupHeartbeatResponse;
import org.apache.kafka.common.requests.RequestHeader;
import org.apache.kafka.common.serialization.StringDeserializer;
import org.apache.kafka.common.utils.MockTime;
-import org.apache.kafka.common.utils.Time;
-import org.apache.kafka.common.utils.Timer;
import org.apache.kafka.common.utils.annotation.ApiKeyVersionsSource;
import org.apache.kafka.common.utils.internals.LogContext;
@@ -57,8 +55,6 @@ import org.junit.jupiter.params.provider.ValueSource;
import org.mockito.ArgumentCaptor;
import org.mockito.InOrder;
-import java.util.Arrays;
-import java.util.Collection;
import java.util.Collections;
import java.util.Map;
import java.util.Optional;
@@ -81,7 +77,6 @@ import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyBoolean;
import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.Mockito.clearInvocations;
import static org.mockito.Mockito.inOrder;
@@ -92,28 +87,19 @@ import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-public class ConsumerHeartbeatRequestManagerTest {
- private static final String DEFAULT_GROUP_ID = "groupId";
+public class ConsumerHeartbeatRequestManagerTest
+ extends AbstractHeartbeatRequestManagerTest {
+
private static final String DEFAULT_REMOTE_ASSIGNOR = "uniform";
private static final String DEFAULT_GROUP_INSTANCE_ID = "group-instance-id";
- private static final int DEFAULT_HEARTBEAT_INTERVAL_MS = 1000;
- private static final int DEFAULT_MAX_POLL_INTERVAL_MS = 10000;
- private static final long DEFAULT_RETRY_BACKOFF_MS = 80;
- private static final long DEFAULT_RETRY_BACKOFF_MAX_MS = 1000;
- private static final double DEFAULT_HEARTBEAT_JITTER_MS = 0.0;
- private static final String DEFAULT_MEMBER_ID = "member-id";
- private static final int DEFAULT_MEMBER_EPOCH = 1;
-
- private Time time;
- private Timer pollTimer;
- private CoordinatorRequestManager coordinatorRequestManager;
- private SubscriptionState subscriptions;
- private Metadata metadata;
- private ConsumerHeartbeatRequestManager heartbeatRequestManager;
+
+ // Shadows the base field so subclass-only tests can access ConsumerMembershipManager-typed
+ // methods (groupInstanceId, rackId, serverAssignor). The subclass setUp() assigns the same
+ // mock to super.membershipManager so inherited tests see the same instance.
private ConsumerMembershipManager membershipManager;
- private HeartbeatRequestState heartbeatRequestState;
+ private ConsumerHeartbeatRequestManager heartbeatRequestManager;
+ private Metadata metadata;
private HeartbeatState heartbeatState;
- private BackgroundEventHandler backgroundEventHandler;
private LogContext logContext;
@BeforeEach
@@ -126,7 +112,7 @@ public class ConsumerHeartbeatRequestManagerTest {
this.backgroundEventHandler = mock(BackgroundEventHandler.class);
this.subscriptions = mock(SubscriptionState.class);
this.membershipManager = mock(ConsumerMembershipManager.class);
- this.metadata = mock(ConsumerMetadata.class);
+ super.membershipManager = this.membershipManager;
Metrics metrics = new Metrics(time);
ConsumerConfig config = mock(ConsumerConfig.class);
@@ -149,6 +135,9 @@ public class ConsumerHeartbeatRequestManagerTest {
backgroundEventHandler,
metrics);
+ super.heartbeatRequestManager = this.heartbeatRequestManager;
+ this.metadata = mock(ConsumerMetadata.class);
+
when(coordinatorRequestManager.coordinator()).thenReturn(Optional.of(mock(Node.class)));
}
@@ -230,34 +219,6 @@ public class ConsumerHeartbeatRequestManagerTest {
assertEquals(0, result2.unsentRequests.size());
}
- @Test
- public void testSuccessfulHeartbeatTiming() {
- NetworkClientDelegate.PollResult result = heartbeatRequestManager.poll(time.milliseconds());
- assertEquals(0, result.unsentRequests.size(),
- "No heartbeat should be sent while interval has not expired");
- assertEquals(heartbeatRequestState.timeToNextHeartbeatMs(time.milliseconds()), result.timeUntilNextPollMs);
- assertNextHeartbeatTiming(DEFAULT_HEARTBEAT_INTERVAL_MS);
-
- result = heartbeatRequestManager.poll(time.milliseconds());
- assertEquals(1, result.unsentRequests.size(), "A heartbeat should be sent when interval expires");
- NetworkClientDelegate.UnsentRequest inflightReq = result.unsentRequests.get(0);
- assertEquals(DEFAULT_HEARTBEAT_INTERVAL_MS,
- heartbeatRequestState.timeToNextHeartbeatMs(time.milliseconds()),
- "Heartbeat timer was not reset to the interval when the heartbeat request was sent.");
-
- long partOfInterval = DEFAULT_HEARTBEAT_INTERVAL_MS / 3;
- time.sleep(partOfInterval);
- result = heartbeatRequestManager.poll(time.milliseconds());
- assertEquals(0, result.unsentRequests.size(),
- "No heartbeat should be sent while only part of the interval has passed");
- assertEquals(DEFAULT_HEARTBEAT_INTERVAL_MS - partOfInterval,
- heartbeatRequestState.timeToNextHeartbeatMs(time.milliseconds()),
- "Time to next interval was not properly updated.");
-
- inflightReq.handler().onComplete(createHeartbeatResponse(inflightReq, Errors.NONE));
- assertNextHeartbeatTiming(DEFAULT_HEARTBEAT_INTERVAL_MS - partOfInterval);
- }
-
@ParameterizedTest
@ApiKeyVersionsSource(apiKey = ApiKeys.CONSUMER_GROUP_HEARTBEAT)
public void testFirstHeartbeatIncludesRequiredInfoToJoinGroupAndGetAssignments(short version) {
@@ -341,22 +302,6 @@ public class ConsumerHeartbeatRequestManagerTest {
}
}
- @Test
- public void testTimerNotDue() {
- time.sleep(100); // time elapsed < heartbeatInterval, no heartbeat should be sent
- NetworkClientDelegate.PollResult result = heartbeatRequestManager.poll(time.milliseconds());
-
- assertEquals(0, result.unsentRequests.size());
- assertEquals(DEFAULT_HEARTBEAT_INTERVAL_MS - 100, result.timeUntilNextPollMs);
- assertEquals(DEFAULT_HEARTBEAT_INTERVAL_MS - 100, heartbeatRequestManager.maximumTimeToWait(time.milliseconds()));
-
- // Member in state where it should not send Heartbeat anymore
- when(subscriptions.hasAutoAssignedPartitions()).thenReturn(true);
- when(membershipManager.shouldSkipHeartbeat()).thenReturn(true);
- result = heartbeatRequestManager.poll(time.milliseconds());
- assertEquals(Long.MAX_VALUE, result.timeUntilNextPollMs);
- }
-
@Test
public void testHeartbeatNotSentIfAnotherOneInFlight() {
time.sleep(DEFAULT_HEARTBEAT_INTERVAL_MS);
@@ -386,21 +331,6 @@ public class ConsumerHeartbeatRequestManagerTest {
"waiting only for the minimal backoff.");
}
- @Test
- public void testHeartbeatOutsideInterval() {
- when(membershipManager.shouldSkipHeartbeat()).thenReturn(false);
- when(membershipManager.shouldHeartbeatNow()).thenReturn(true);
- NetworkClientDelegate.PollResult result = heartbeatRequestManager.poll(time.milliseconds());
-
- // Heartbeat should be sent
- assertEquals(1, result.unsentRequests.size());
- // Interval timer reset
- assertEquals(DEFAULT_HEARTBEAT_INTERVAL_MS, result.timeUntilNextPollMs);
- assertEquals(DEFAULT_HEARTBEAT_INTERVAL_MS, heartbeatRequestManager.maximumTimeToWait(time.milliseconds()));
- // Membership manager updated (to transition out of the heartbeating state)
- verify(membershipManager).onHeartbeatRequestGenerated();
- }
-
@Test
public void testNetworkTimeout() {
// The initial heartbeatInterval is set to 0
@@ -456,57 +386,6 @@ public class ConsumerHeartbeatRequestManagerTest {
verify(backgroundEventHandler).add(any());
}
- /**
- * Test that GROUP_ID_NOT_FOUND error while unsubscribed is not a fatal error.
- * This can happen when the consumer never successfully joined the group
- * (e.g., due to an InvalidTopicException during poll() and close() sends
- * a leave heartbeat for a group that was never created.
- */
- @Test
- public void testGroupIdNotFoundExceptionWhileUnsubscribed() {
- // Setup: member is in UNSUBSCRIBED state with epoch -1
- when(membershipManager.state()).thenReturn(MemberState.UNSUBSCRIBED);
- when(membershipManager.memberEpoch()).thenReturn(-1);
-
- time.sleep(DEFAULT_HEARTBEAT_INTERVAL_MS);
- NetworkClientDelegate.PollResult result = heartbeatRequestManager.poll(time.milliseconds());
- assertEquals(1, result.unsentRequests.size());
-
- // Complete the heartbeat with GROUP_ID_NOT_FOUND error
- ClientResponse response = createHeartbeatResponse(result.unsentRequests.get(0), Errors.GROUP_ID_NOT_FOUND);
- result.unsentRequests.get(0).handler().onComplete(response);
-
- // Verify: no fatal error, heartbeat skipped (benign)
- verify(membershipManager, never()).transitionToFatal();
- verify(membershipManager).onHeartbeatRequestSkipped();
- verify(backgroundEventHandler, never()).add(any());
- }
-
- /**
- * Test that GROUP_ID_NOT_FOUND error while stable is treated as fatal.
- * This would indicate the group was unexpectedly deleted while the member
- * was actively participating.
- */
- @Test
- public void testGroupIdNotFoundWhileStableIsFatal() {
- // Setup: member is in STABLE state with positive epoch
- when(membershipManager.state()).thenReturn(MemberState.STABLE);
- when(membershipManager.memberEpoch()).thenReturn(DEFAULT_MEMBER_EPOCH);
-
- time.sleep(DEFAULT_HEARTBEAT_INTERVAL_MS);
- NetworkClientDelegate.PollResult result = heartbeatRequestManager.poll(time.milliseconds());
- assertEquals(1, result.unsentRequests.size());
-
- // Complete the heartbeat with GROUP_ID_NOT_FOUND error
- when(coordinatorRequestManager.coordinator()).thenReturn(Optional.empty());
- ClientResponse response = createHeartbeatResponse(result.unsentRequests.get(0), Errors.GROUP_ID_NOT_FOUND);
- result.unsentRequests.get(0).handler().onComplete(response);
-
- // Verify: fatal error
- verify(membershipManager).transitionToFatal();
- verify(backgroundEventHandler).add(any());
- }
-
@Test
public void testHeartbeatResponseErrorNotifiedToGroupManagerAfterErrorPropagated() {
time.sleep(DEFAULT_HEARTBEAT_INTERVAL_MS);
@@ -537,16 +416,6 @@ public class ConsumerHeartbeatRequestManagerTest {
inOrder.verify(membershipManager).onHeartbeatFailure(false);
}
- @Test
- public void testNoCoordinator() {
- when(coordinatorRequestManager.coordinator()).thenReturn(Optional.empty());
- NetworkClientDelegate.PollResult result = heartbeatRequestManager.poll(time.milliseconds());
-
- assertEquals(Long.MAX_VALUE, result.timeUntilNextPollMs);
- assertEquals(DEFAULT_HEARTBEAT_INTERVAL_MS, heartbeatRequestManager.maximumTimeToWait(time.milliseconds()));
- assertEquals(0, result.unsentRequests.size());
- }
-
@ParameterizedTest
@ApiKeyVersionsSource(apiKey = ApiKeys.CONSUMER_GROUP_HEARTBEAT)
public void testValidateConsumerGroupHeartbeatRequest(final short version) {
@@ -618,7 +487,9 @@ public class ConsumerHeartbeatRequestManagerTest {
assertEquals(Collections.singletonList(expectedTopicPartitions), heartbeatRequest3.data().topicPartitions());
}
- private ConsumerGroupHeartbeatRequest getHeartbeatRequest(ConsumerHeartbeatRequestManager heartbeatRequestManager, final short version) {
+ private ConsumerGroupHeartbeatRequest getHeartbeatRequest(
+ AbstractHeartbeatRequestManager<ConsumerGroupHeartbeatResponse> heartbeatRequestManager,
+ final short version) {
NetworkClientDelegate.PollResult pollResult = heartbeatRequestManager.poll(time.milliseconds());
assertEquals(1, pollResult.unsentRequests.size());
NetworkClientDelegate.UnsentRequest request = pollResult.unsentRequests.get(0);
@@ -626,72 +497,6 @@ public class ConsumerHeartbeatRequestManagerTest {
return (ConsumerGroupHeartbeatRequest) request.requestBuilder().build(version);
}
- @ParameterizedTest
- @MethodSource("errorProvider")
- public void testHeartbeatResponseOnErrorHandling(final Errors error, final boolean isFatal) {
- // Handling errors on the second heartbeat
- time.sleep(DEFAULT_HEARTBEAT_INTERVAL_MS);
- NetworkClientDelegate.PollResult result = heartbeatRequestManager.poll(time.milliseconds());
- assertEquals(1, result.unsentRequests.size());
-
- // Manually completing the response to test error handling
- when(subscriptions.hasAutoAssignedPartitions()).thenReturn(true);
- ClientResponse response = createHeartbeatResponse(
- result.unsentRequests.get(0),
- error);
- result.unsentRequests.get(0).handler().onComplete(response);
- ConsumerGroupHeartbeatResponse mockResponse = (ConsumerGroupHeartbeatResponse) response.responseBody();
-
- switch (error) {
- case NONE:
- verify(membershipManager).onHeartbeatSuccess(mockResponse);
- assertNextHeartbeatTiming(DEFAULT_HEARTBEAT_INTERVAL_MS);
- break;
-
- case COORDINATOR_LOAD_IN_PROGRESS:
- verify(backgroundEventHandler, never()).add(any());
- assertNextHeartbeatTiming(DEFAULT_RETRY_BACKOFF_MS);
- break;
-
- case COORDINATOR_NOT_AVAILABLE:
- case NOT_COORDINATOR:
- verify(backgroundEventHandler, never()).add(any());
- verify(coordinatorRequestManager).markCoordinatorUnknown(any(), anyLong());
- assertNextHeartbeatTiming(0);
- break;
- case UNKNOWN_MEMBER_ID:
- case FENCED_MEMBER_EPOCH:
- verify(backgroundEventHandler, never()).add(any());
- assertNextHeartbeatTiming(0);
- break;
- case TOPIC_AUTHORIZATION_FAILED:
- verify(backgroundEventHandler).add(any(ErrorEvent.class));
- assertNextHeartbeatTiming(DEFAULT_RETRY_BACKOFF_MS);
- verify(membershipManager, never()).transitionToFatal();
- break;
- default:
- if (isFatal) {
- when(coordinatorRequestManager.coordinator()).thenReturn(Optional.empty());
- ensureFatalError(error);
- } else {
- verify(backgroundEventHandler, never()).add(any());
- assertNextHeartbeatTiming(0);
- }
- break;
- }
-
- if (error != Errors.NONE) {
- verify(membershipManager).onHeartbeatFailure(false);
- }
-
- if (!isFatal) {
- // Make sure a next heartbeat is sent for all non-fatal errors (to retry or rejoin)
- time.sleep(DEFAULT_HEARTBEAT_INTERVAL_MS);
- result = heartbeatRequestManager.poll(time.milliseconds());
- assertEquals(1, result.unsentRequests.size());
- }
- }
-
/**
* This validates the UnsupportedApiVersion the client generates while building a HB if:
* 1. HB API is not supported.
@@ -736,16 +541,6 @@ public class ConsumerHeartbeatRequestManagerTest {
result.unsentRequests.get(0).handler().onComplete(response);
}
- private void assertNextHeartbeatTiming(long expectedTimeToNextHeartbeatMs) {
- long currentTimeMs = time.milliseconds();
- assertEquals(expectedTimeToNextHeartbeatMs, heartbeatRequestState.timeToNextHeartbeatMs(currentTimeMs));
- if (expectedTimeToNextHeartbeatMs != 0) {
- assertFalse(heartbeatRequestState.canSendRequest(currentTimeMs));
- time.sleep(expectedTimeToNextHeartbeatMs);
- }
- assertTrue(heartbeatRequestState.canSendRequest(time.milliseconds()));
- }
-
@Test
public void testHeartbeatState() {
mockJoiningMemberData(null);
@@ -872,29 +667,6 @@ public class ConsumerHeartbeatRequestManagerTest {
}
- /**
- * This is expected to be the case where a member is already leaving the group and the poll
- * timer expires. The poll timer expiration should not transition the member to STALE, and
- * the member should continue to send heartbeats while the ongoing leaving operation
- * completes (send heartbeats while waiting for callbacks before leaving, or send last
- * heartbeat to leave).
- */
- @Test
- public void testPollTimerExpirationShouldNotMarkMemberStaleIfMemberAlreadyLeaving() {
- when(membershipManager.shouldSkipHeartbeat()).thenReturn(false);
- when(membershipManager.isLeavingGroup()).thenReturn(true);
-
- time.sleep(DEFAULT_MAX_POLL_INTERVAL_MS);
- NetworkClientDelegate.PollResult result = heartbeatRequestManager.poll(time.milliseconds());
-
- // No transition to leave due to stale member should be triggered, because the member is
- // already leaving the group
- verify(membershipManager, never()).transitionToSendingLeaveGroup(anyBoolean());
-
- assertEquals(1, result.unsentRequests.size(), "A heartbeat request should be generated to" +
- " complete the ongoing leaving operation that was triggered before the poll timer expired.");
- }
-
@Test
public void testisExpiredByUsedForLogging() {
when(membershipManager.shouldSkipHeartbeat()).thenReturn(false);
@@ -1115,7 +887,7 @@ public class ConsumerHeartbeatRequestManagerTest {
assertNull(data.rackId());
}
- private void assertHeartbeat(ConsumerHeartbeatRequestManager hrm, int nextPollMs) {
+ private void assertHeartbeat(AbstractHeartbeatRequestManager<ConsumerGroupHeartbeatResponse> hrm, int nextPollMs) {
NetworkClientDelegate.PollResult pollResult = hrm.poll(time.milliseconds());
assertEquals(1, pollResult.unsentRequests.size());
assertEquals(nextPollMs, pollResult.timeUntilNextPollMs);
@@ -1123,50 +895,14 @@ public class ConsumerHeartbeatRequestManagerTest {
Errors.NONE));
}
- private void assertNoHeartbeat(ConsumerHeartbeatRequestManager hrm) {
+ private void assertNoHeartbeat(AbstractHeartbeatRequestManager<ConsumerGroupHeartbeatResponse> hrm) {
NetworkClientDelegate.PollResult pollResult = hrm.poll(time.milliseconds());
assertEquals(0, pollResult.unsentRequests.size());
}
- private void ensureFatalError(Errors expectedError) {
- verify(membershipManager).transitionToFatal();
-
- final ArgumentCaptor<ErrorEvent> errorEventArgumentCaptor = ArgumentCaptor.forClass(ErrorEvent.class);
- verify(backgroundEventHandler).add(errorEventArgumentCaptor.capture());
- ErrorEvent errorEvent = errorEventArgumentCaptor.getValue();
- assertInstanceOf(expectedError.exception().getClass(), errorEvent.error(),
- "The fatal error propagated to the app thread does not match the error received in the heartbeat response.");
-
- ensureHeartbeatStopped();
- }
-
- private void ensureHeartbeatStopped() {
- time.sleep(DEFAULT_HEARTBEAT_INTERVAL_MS);
- NetworkClientDelegate.PollResult result = heartbeatRequestManager.poll(time.milliseconds());
- assertEquals(0, result.unsentRequests.size());
- }
-
- // error, isFatal
- private static Collection<Arguments> errorProvider() {
- return Arrays.asList(
- Arguments.of(Errors.NONE, false),
- Arguments.of(Errors.COORDINATOR_NOT_AVAILABLE, false),
- Arguments.of(Errors.COORDINATOR_LOAD_IN_PROGRESS, false),
- Arguments.of(Errors.NOT_COORDINATOR, false),
- Arguments.of(Errors.GROUP_AUTHORIZATION_FAILED, true),
- Arguments.of(Errors.INVALID_REQUEST, true),
- Arguments.of(Errors.UNKNOWN_MEMBER_ID, false),
- Arguments.of(Errors.FENCED_MEMBER_EPOCH, false),
- Arguments.of(Errors.UNSUPPORTED_ASSIGNOR, true),
- Arguments.of(Errors.UNSUPPORTED_VERSION, true),
- Arguments.of(Errors.UNRELEASED_INSTANCE_ID, true),
- Arguments.of(Errors.FENCED_INSTANCE_ID, true),
- Arguments.of(Errors.GROUP_MAX_SIZE_REACHED, true),
- Arguments.of(Errors.TOPIC_AUTHORIZATION_FAILED, false));
- }
-
- private ClientResponse createHeartbeatResponse(NetworkClientDelegate.UnsentRequest request,
- Errors error) {
+ @Override
+ protected ClientResponse createHeartbeatResponse(NetworkClientDelegate.UnsentRequest request,
+ Errors error) {
return createHeartbeatResponse(request, error, "stubbed error message");
}
diff --git a/clients/src/test/java/org/apache/kafka/clients/consumer/internals/ShareHeartbeatRequestManagerTest.java b/clients/src/test/java/org/apache/kafka/clients/consumer/internals/ShareHeartbeatRequestManagerTest.java
index 201aad088e7..26e9e795ffc 100644
--- a/clients/src/test/java/org/apache/kafka/clients/consumer/internals/ShareHeartbeatRequestManagerTest.java
+++ b/clients/src/test/java/org/apache/kafka/clients/consumer/internals/ShareHeartbeatRequestManagerTest.java
@@ -37,21 +37,15 @@ import org.apache.kafka.common.requests.ShareGroupHeartbeatRequest;
import org.apache.kafka.common.requests.ShareGroupHeartbeatResponse;
import org.apache.kafka.common.serialization.StringDeserializer;
import org.apache.kafka.common.utils.MockTime;
-import org.apache.kafka.common.utils.Time;
-import org.apache.kafka.common.utils.Timer;
import org.apache.kafka.common.utils.annotation.ApiKeyVersionsSource;
import org.apache.kafka.common.utils.internals.LogContext;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
import org.junit.jupiter.params.provider.ValueSource;
import org.mockito.ArgumentCaptor;
-import java.util.Arrays;
-import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Optional;
@@ -63,14 +57,11 @@ import java.util.concurrent.TimeUnit;
import static org.apache.kafka.clients.consumer.internals.ShareHeartbeatRequestManager.SHARE_PROTOCOL_NOT_SUPPORTED_MSG;
import static org.apache.kafka.clients.consumer.internals.ShareHeartbeatRequestManager.SHARE_PROTOCOL_VERSION_NOT_SUPPORTED_MSG;
import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertInstanceOf;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyBoolean;
-import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.Mockito.clearInvocations;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
@@ -78,27 +69,18 @@ import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-public class ShareHeartbeatRequestManagerTest {
- private static final String DEFAULT_GROUP_ID = "groupId";
- private static final String DEFAULT_MEMBER_ID = "member-id";
- private static final int DEFAULT_MEMBER_EPOCH = 1;
- private static final int DEFAULT_HEARTBEAT_INTERVAL_MS = 1000;
- private static final int DEFAULT_MAX_POLL_INTERVAL_MS = 10000;
- private static final long DEFAULT_RETRY_BACKOFF_MS = 80;
- private static final long DEFAULT_RETRY_BACKOFF_MAX_MS = 1000;
- private static final double DEFAULT_HEARTBEAT_JITTER_MS = 0.0;
+public class ShareHeartbeatRequestManagerTest
+ extends AbstractHeartbeatRequestManagerTest {
+
private static final String SHARE_CONSUMER_COORDINATOR_METRICS = "consumer-share-coordinator-metrics";
- private Time time;
- private Timer pollTimer;
- private CoordinatorRequestManager coordinatorRequestManager;
- private SubscriptionState subscriptions;
- private Metadata metadata;
- private ShareHeartbeatRequestManager heartbeatRequestManager;
+ // Shadows the base field so subclass-only tests can access ShareMembershipManager-typed
+ // methods. The subclass setUp() assigns the same mock to super.membershipManager so
+ // inherited tests see the same instance.
private ShareMembershipManager membershipManager;
- private HeartbeatRequestState heartbeatRequestState;
+ private ShareHeartbeatRequestManager heartbeatRequestManager;
+ private Metadata metadata;
private ShareHeartbeatRequestManager.HeartbeatState heartbeatState;
- private BackgroundEventHandler backgroundEventHandler;
private Metrics metrics;
private LogContext logContext;
@@ -110,6 +92,7 @@ public class ShareHeartbeatRequestManagerTest {
subscriptions = mock(SubscriptionState.class);
backgroundEventHandler = mock(BackgroundEventHandler.class);
membershipManager = mock(ShareMembershipManager.class);
+ super.membershipManager = membershipManager;
heartbeatState = mock(ShareHeartbeatRequestManager.HeartbeatState.class);
metadata = mock(ConsumerMetadata.class);
metrics = new Metrics(time);
@@ -135,6 +118,8 @@ public class ShareHeartbeatRequestManagerTest {
backgroundEventHandler,
metrics);
+ super.heartbeatRequestManager = this.heartbeatRequestManager;
+
when(coordinatorRequestManager.coordinator()).thenReturn(Optional.of(new Node(1, "localhost", 9999)));
}
@@ -182,34 +167,6 @@ public class ShareHeartbeatRequestManagerTest {
assertEquals(0, result2.unsentRequests.size());
}
- @Test
- public void testSuccessfulHeartbeatTiming() {
- NetworkClientDelegate.PollResult result = heartbeatRequestManager.poll(time.milliseconds());
- assertEquals(0, result.unsentRequests.size(),
- "No heartbeat should be sent while interval has not expired");
- assertEquals(heartbeatRequestState.timeToNextHeartbeatMs(time.milliseconds()), result.timeUntilNextPollMs);
- assertNextHeartbeatTiming(DEFAULT_HEARTBEAT_INTERVAL_MS);
-
- result = heartbeatRequestManager.poll(time.milliseconds());
- assertEquals(1, result.unsentRequests.size(), "A heartbeat should be sent when interval expires");
- NetworkClientDelegate.UnsentRequest inflightReq = result.unsentRequests.get(0);
- assertEquals(DEFAULT_HEARTBEAT_INTERVAL_MS,
- heartbeatRequestState.timeToNextHeartbeatMs(time.milliseconds()),
- "Heartbeat timer was not reset to the interval when the heartbeat request was sent.");
-
- long partOfInterval = DEFAULT_HEARTBEAT_INTERVAL_MS / 3;
- time.sleep(partOfInterval);
- result = heartbeatRequestManager.poll(time.milliseconds());
- assertEquals(0, result.unsentRequests.size(),
- "No heartbeat should be sent while only part of the interval has passed");
- assertEquals(DEFAULT_HEARTBEAT_INTERVAL_MS - partOfInterval,
- heartbeatRequestState.timeToNextHeartbeatMs(time.milliseconds()),
- "Time to next interval was not properly updated.");
-
- inflightReq.handler().onComplete(createHeartbeatResponse(inflightReq, Errors.NONE));
- assertNextHeartbeatTiming(DEFAULT_HEARTBEAT_INTERVAL_MS - partOfInterval);
- }
-
@ParameterizedTest
@ApiKeyVersionsSource(apiKey = ApiKeys.SHARE_GROUP_HEARTBEAT)
public void testFirstHeartbeatIncludesRequiredInfoToJoinGroupAndGetAssignments(short version) {
@@ -261,22 +218,6 @@ public class ShareHeartbeatRequestManagerTest {
}
}
- @Test
- public void testTimerNotDue() {
- time.sleep(100); // time elapsed < heartbeatInterval, no heartbeat should be sent
- NetworkClientDelegate.PollResult result = heartbeatRequestManager.poll(time.milliseconds());
-
- assertEquals(0, result.unsentRequests.size());
- assertEquals(DEFAULT_HEARTBEAT_INTERVAL_MS - 100, result.timeUntilNextPollMs);
- assertEquals(DEFAULT_HEARTBEAT_INTERVAL_MS - 100, heartbeatRequestManager.maximumTimeToWait(time.milliseconds()));
-
- // Member in state where it should not send Heartbeat anymore
- when(subscriptions.hasAutoAssignedPartitions()).thenReturn(true);
- when(membershipManager.shouldSkipHeartbeat()).thenReturn(true);
- result = heartbeatRequestManager.poll(time.milliseconds());
- assertEquals(Long.MAX_VALUE, result.timeUntilNextPollMs);
- }
-
@Test
public void testHeartbeatNotSentIfAnotherOneInFlight() {
time.sleep(DEFAULT_HEARTBEAT_INTERVAL_MS);
@@ -306,21 +247,6 @@ public class ShareHeartbeatRequestManagerTest {
"waiting only for the minimal backoff.");
}
- @Test
- public void testHeartbeatOutsideInterval() {
- when(membershipManager.shouldSkipHeartbeat()).thenReturn(false);
- when(membershipManager.shouldHeartbeatNow()).thenReturn(true);
- NetworkClientDelegate.PollResult result = heartbeatRequestManager.poll(time.milliseconds());
-
- // Heartbeat should be sent
- assertEquals(1, result.unsentRequests.size());
- // Interval timer reset
- assertEquals(DEFAULT_HEARTBEAT_INTERVAL_MS, result.timeUntilNextPollMs);
- assertEquals(DEFAULT_HEARTBEAT_INTERVAL_MS, heartbeatRequestManager.maximumTimeToWait(time.milliseconds()));
- // Membership manager updated (to transition out of the heartbeating state)
- verify(membershipManager).onHeartbeatRequestGenerated();
- }
-
@Test
public void testNetworkTimeout() {
// The initial heartbeatInterval is set to 0
@@ -355,129 +281,6 @@ public class ShareHeartbeatRequestManagerTest {
verify(backgroundEventHandler).add(any());
}
- /**
- * Test that GROUP_ID_NOT_FOUND error while unsubscribed is not treated as fatal.
- * This can happen when the consumer never successfully joined the group
- * (e.g., due to an InvalidTopicException during poll() and close() sends
- * a leave heartbeat for a group that was never created.
- */
- @Test
- public void testGroupIdNotFoundExceptionWhileUnsubscribed() {
- // Setup: member is in UNSUBSCRIBED state with epoch -1
- when(membershipManager.state()).thenReturn(MemberState.UNSUBSCRIBED);
- when(membershipManager.memberEpoch()).thenReturn(-1);
-
- time.sleep(DEFAULT_HEARTBEAT_INTERVAL_MS);
- NetworkClientDelegate.PollResult result = heartbeatRequestManager.poll(time.milliseconds());
- assertEquals(1, result.unsentRequests.size());
-
- // Complete the heartbeat with GROUP_ID_NOT_FOUND error
- ClientResponse response = createHeartbeatResponse(result.unsentRequests.get(0), Errors.GROUP_ID_NOT_FOUND);
- result.unsentRequests.get(0).handler().onComplete(response);
-
- // Verify: no fatal error, heartbeat skipped (benign)
- verify(membershipManager, never()).transitionToFatal();
- verify(membershipManager).onHeartbeatRequestSkipped();
- verify(backgroundEventHandler, never()).add(any());
- }
-
- /**
- * Test that GROUP_ID_NOT_FOUND error while stable is treated as fatal.
- * This would indicate the group was unexpectedly deleted while the member
- * was actively participating.
- */
- @Test
- public void testGroupIdNotFoundWhileStableIsFatal() {
- // Setup: member is in STABLE state with positive epoch
- when(membershipManager.state()).thenReturn(MemberState.STABLE);
- when(membershipManager.memberEpoch()).thenReturn(DEFAULT_MEMBER_EPOCH);
-
- time.sleep(DEFAULT_HEARTBEAT_INTERVAL_MS);
- NetworkClientDelegate.PollResult result = heartbeatRequestManager.poll(time.milliseconds());
- assertEquals(1, result.unsentRequests.size());
-
- // Complete the heartbeat with GROUP_ID_NOT_FOUND error
- when(coordinatorRequestManager.coordinator()).thenReturn(Optional.empty());
- ClientResponse response = createHeartbeatResponse(result.unsentRequests.get(0), Errors.GROUP_ID_NOT_FOUND);
- result.unsentRequests.get(0).handler().onComplete(response);
-
- // Verify: fatal error
- verify(membershipManager).transitionToFatal();
- verify(backgroundEventHandler).add(any());
- }
-
- @Test
- public void testNoCoordinator() {
- when(coordinatorRequestManager.coordinator()).thenReturn(Optional.empty());
- NetworkClientDelegate.PollResult result = heartbeatRequestManager.poll(time.milliseconds());
-
- assertEquals(Long.MAX_VALUE, result.timeUntilNextPollMs);
- assertEquals(DEFAULT_HEARTBEAT_INTERVAL_MS, heartbeatRequestManager.maximumTimeToWait(time.milliseconds()));
- assertEquals(0, result.unsentRequests.size());
- }
-
- @ParameterizedTest
- @MethodSource("errorProvider")
- public void testHeartbeatResponseOnErrorHandling(final Errors error, final boolean isFatal) {
- // Handling errors on the second heartbeat
- time.sleep(DEFAULT_HEARTBEAT_INTERVAL_MS);
- NetworkClientDelegate.PollResult result = heartbeatRequestManager.poll(time.milliseconds());
- assertEquals(1, result.unsentRequests.size());
-
- // Manually completing the response to test error handling
- when(subscriptions.hasAutoAssignedPartitions()).thenReturn(true);
- ClientResponse response = createHeartbeatResponse(
- result.unsentRequests.get(0),
- error);
- result.unsentRequests.get(0).handler().onComplete(response);
- ShareGroupHeartbeatResponse mockResponse = (ShareGroupHeartbeatResponse) response.responseBody();
-
- switch (error) {
- case NONE:
- verify(membershipManager).onHeartbeatSuccess(mockResponse);
- assertNextHeartbeatTiming(DEFAULT_HEARTBEAT_INTERVAL_MS);
- break;
-
- case COORDINATOR_LOAD_IN_PROGRESS:
- verify(backgroundEventHandler, never()).add(any());
- assertNextHeartbeatTiming(DEFAULT_RETRY_BACKOFF_MS);
- break;
-
- case COORDINATOR_NOT_AVAILABLE:
- case NOT_COORDINATOR:
- verify(backgroundEventHandler, never()).add(any());
- verify(coordinatorRequestManager).markCoordinatorUnknown(any(), anyLong());
- assertNextHeartbeatTiming(0);
- break;
-
- case UNKNOWN_MEMBER_ID:
- verify(backgroundEventHandler, never()).add(any());
- assertNextHeartbeatTiming(0);
- break;
-
- default:
- if (isFatal) {
- when(coordinatorRequestManager.coordinator()).thenReturn(Optional.empty());
- ensureFatalError(error);
- } else {
- verify(backgroundEventHandler, never()).add(any());
- assertNextHeartbeatTiming(0);
- }
- break;
- }
-
- if (error != Errors.NONE) {
- verify(membershipManager).onHeartbeatFailure(false);
- }
-
- if (!isFatal) {
- // Make sure a next heartbeat is sent for all non-fatal errors (to retry or rejoin)
- time.sleep(DEFAULT_HEARTBEAT_INTERVAL_MS);
- result = heartbeatRequestManager.poll(time.milliseconds());
- assertEquals(1, result.unsentRequests.size());
- }
- }
-
@ParameterizedTest
@ValueSource(strings = {SHARE_PROTOCOL_NOT_SUPPORTED_MSG})
public void testUnsupportedVersionGeneratedOnTheBroker(String errorMsg) {
@@ -612,29 +415,6 @@ public class ShareHeartbeatRequestManagerTest {
assertHeartbeat(heartbeatRequestManager, DEFAULT_HEARTBEAT_INTERVAL_MS);
}
- /**
- * This is expected to be the case where a member is already leaving the group and the poll
- * timer expires. The poll timer expiration should not transition the member to STALE, and
- * the member should continue to send heartbeats while the ongoing leaving operation
- * completes (send heartbeats while waiting for callbacks before leaving, or send last
- * heartbeat to leave).
- */
- @Test
- public void testPollTimerExpirationShouldNotMarkMemberStaleIfMemberAlreadyLeaving() {
- when(membershipManager.shouldSkipHeartbeat()).thenReturn(false);
- when(membershipManager.isLeavingGroup()).thenReturn(true);
-
- time.sleep(DEFAULT_MAX_POLL_INTERVAL_MS);
- NetworkClientDelegate.PollResult result = heartbeatRequestManager.poll(time.milliseconds());
-
- // No transition to leave due to stale member should be triggered, because the member is
- // already leaving the group
- verify(membershipManager, never()).transitionToSendingLeaveGroup(anyBoolean());
-
- assertEquals(1, result.unsentRequests.size(), "A heartbeat request should be generated to" +
- " complete the ongoing leaving operation that was triggered before the poll timer expired.");
- }
-
@Test
public void testHeartbeatMetrics() {
assertNotNull(getMetric("heartbeat-response-time-max"));
@@ -660,7 +440,7 @@ public class ShareHeartbeatRequestManagerTest {
assertEquals((double) randomSleepS, getMetric("last-heartbeat-seconds-ago").metricValue());
}
- private void assertHeartbeat(ShareHeartbeatRequestManager hrm, int nextPollMs) {
+ private void assertHeartbeat(AbstractHeartbeatRequestManager<ShareGroupHeartbeatResponse> hrm, int nextPollMs) {
NetworkClientDelegate.PollResult pollResult = hrm.poll(time.milliseconds());
assertEquals(1, pollResult.unsentRequests.size());
assertEquals(nextPollMs, pollResult.timeUntilNextPollMs);
@@ -668,57 +448,13 @@ public class ShareHeartbeatRequestManagerTest {
Errors.NONE));
}
- private void assertNoHeartbeat(ShareHeartbeatRequestManager hrm) {
+ private void assertNoHeartbeat(AbstractHeartbeatRequestManager<ShareGroupHeartbeatResponse> hrm) {
NetworkClientDelegate.PollResult pollResult = hrm.poll(time.milliseconds());
assertEquals(0, pollResult.unsentRequests.size());
}
- private void assertNextHeartbeatTiming(long expectedTimeToNextHeartbeatMs) {
- long currentTimeMs = time.milliseconds();
- assertEquals(expectedTimeToNextHeartbeatMs, heartbeatRequestState.timeToNextHeartbeatMs(currentTimeMs));
- if (expectedTimeToNextHeartbeatMs != 0) {
- assertFalse(heartbeatRequestState.canSendRequest(currentTimeMs));
- time.sleep(expectedTimeToNextHeartbeatMs);
- }
- assertTrue(heartbeatRequestState.canSendRequest(time.milliseconds()));
- }
-
- private void ensureFatalError(Errors expectedError) {
- verify(membershipManager).transitionToFatal();
-
- final ArgumentCaptor<ErrorEvent> errorEventArgumentCaptor = ArgumentCaptor.forClass(ErrorEvent.class);
- verify(backgroundEventHandler).add(errorEventArgumentCaptor.capture());
- ErrorEvent errorEvent = errorEventArgumentCaptor.getValue();
- assertInstanceOf(expectedError.exception().getClass(), errorEvent.error(),
- "The fatal error propagated to the app thread does not match the error received in the heartbeat response.");
-
- ensureHeartbeatStopped();
- }
-
- private void ensureHeartbeatStopped() {
- time.sleep(DEFAULT_HEARTBEAT_INTERVAL_MS);
- NetworkClientDelegate.PollResult result = heartbeatRequestManager.poll(time.milliseconds());
- assertEquals(0, result.unsentRequests.size());
- }
-
- // error, isFatal
- private static Collection<Arguments> errorProvider() {
- return Arrays.asList(
- Arguments.of(Errors.NONE, false),
- Arguments.of(Errors.COORDINATOR_NOT_AVAILABLE, false),
- Arguments.of(Errors.COORDINATOR_LOAD_IN_PROGRESS, false),
- Arguments.of(Errors.NOT_COORDINATOR, false),
- Arguments.of(Errors.GROUP_AUTHORIZATION_FAILED, true),
- Arguments.of(Errors.INVALID_REQUEST, true),
- Arguments.of(Errors.UNKNOWN_MEMBER_ID, false),
- Arguments.of(Errors.FENCED_MEMBER_EPOCH, false),
- Arguments.of(Errors.UNSUPPORTED_ASSIGNOR, true),
- Arguments.of(Errors.UNSUPPORTED_VERSION, true),
- Arguments.of(Errors.UNRELEASED_INSTANCE_ID, true),
- Arguments.of(Errors.GROUP_MAX_SIZE_REACHED, true));
- }
-
- private ClientResponse createHeartbeatResponse(
+ @Override
+ protected ClientResponse createHeartbeatResponse(
final NetworkClientDelegate.UnsentRequest request,
final Errors error) {
ShareGroupHeartbeatResponseData data = new ShareGroupHeartbeatResponseData()