@platformatic/rdkafka 4.0.0 → 4.1.0-alpha.1

package/deps/librdkafka/tests/0102-static_group_rebalance.c

@@ -2,6 +2,7 @@
  * librdkafka - Apache Kafka C library
  *
  * Copyright (c) 2019-2022, Magnus Edenhill
+ *               2025, Confluent Inc.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -28,6 +29,7 @@
 
 #include "test.h"
 
+#include "../src/rdkafka_proto.h"
 
 /**
  * @name KafkaConsumer static membership tests
@@ -160,13 +162,16 @@ static void do_test_static_group_rebalance(void) {
         c[0].mv = &mv;
         c[1].mv = &mv;
 
-        test_create_topic(NULL, topic, 3, 1);
+        test_create_topic_wait_exists(NULL, topic, 3, 1, 5000);
         test_produce_msgs_easy(topic, testid, RD_KAFKA_PARTITION_UA, msgcnt);
 
         test_conf_set(conf, "max.poll.interval.ms", "9000");
         test_conf_set(conf, "session.timeout.ms", "6000");
         test_conf_set(conf, "auto.offset.reset", "earliest");
-        test_conf_set(conf, "topic.metadata.refresh.interval.ms", "500");
+        /* Keep this interval higher than cluster metadata propagation
+         * time to make sure no additional rebalances are triggered
+         * when refreshing the full metadata with a regex subscription. */
+        test_conf_set(conf, "topic.metadata.refresh.interval.ms", "2000");
         test_conf_set(conf, "metadata.max.age.ms", "5000");
         test_conf_set(conf, "enable.partition.eof", "true");
         test_conf_set(conf, "group.instance.id", "consumer1");
@@ -179,7 +184,6 @@ static void do_test_static_group_rebalance(void) {
         test_conf_set(conf, "group.instance.id", "consumer2");
         c[1].rk = test_create_consumer(topic, rebalance_cb,
                                        rd_kafka_conf_dup(conf), NULL);
-        rd_kafka_conf_destroy(conf);
 
         test_wait_topic_exists(c[1].rk, topic, 5000);
 
@@ -222,15 +226,15 @@ static void do_test_static_group_rebalance(void) {
         test_msgver_verify("first.verify", &mv, TEST_MSGVER_ALL, 0, msgcnt);
 
         TEST_SAY("== Testing consumer restart ==\n");
-        conf = rd_kafka_conf_dup(rd_kafka_conf(c[1].rk));
 
         /* Only c[1] should exhibit rebalance behavior */
         c[1].expected_rb_event = RD_KAFKA_RESP_ERR__REVOKE_PARTITIONS;
         TIMING_START(&t_close, "consumer restart");
         test_consumer_close(c[1].rk);
         rd_kafka_destroy(c[1].rk);
-
-        c[1].rk = test_create_handle(RD_KAFKA_CONSUMER, conf);
+        c[1].rk = test_create_consumer(topic, rebalance_cb,
+                                       rd_kafka_conf_dup(conf), NULL);
+        rd_kafka_conf_destroy(conf);
         rd_kafka_poll_set_consumer(c[1].rk);
 
         test_consumer_subscribe(c[1].rk, topics);
@@ -255,7 +259,8 @@ static void do_test_static_group_rebalance(void) {
          * New topics matching the subscription pattern should cause
          * group rebalance
          */
-        test_create_topic(c->rk, tsprintf("%snew", topic), 1, 1);
+        test_create_topic_wait_exists(c->rk, tsprintf("%snew", topic), 1, 1,
+                                      5000);
 
         /* Await revocation */
         rebalance_start        = test_clock();
@@ -328,16 +333,25 @@ static void do_test_static_group_rebalance(void) {
         /* max.poll.interval.ms should still be enforced by the consumer */
 
         /*
-         * Block long enough for consumer 2 to be evicted from the group
-         * `max.poll.interval.ms` + `session.timeout.ms`
+         * Stop polling consumer 2 until we reach
+         * `max.poll.interval.ms` and is evicted from the group.
          */
         rebalance_start        = test_clock();
         c[1].expected_rb_event = RD_KAFKA_RESP_ERR__REVOKE_PARTITIONS;
         c[0].expected_rb_event = RD_KAFKA_RESP_ERR__REVOKE_PARTITIONS;
         c[0].curr_line         = __LINE__;
-        test_consumer_poll_no_msgs("wait.max.poll", c[0].rk, testid,
-                                   6000 + 9000);
-        c[1].curr_line = __LINE__;
+        /* consumer 2 will time out and all partitions will be assigned to
+         * consumer 1. */
+        static_member_expect_rebalance(&c[0], rebalance_start, &c[0].revoked_at,
+                                       -1);
+        c[0].expected_rb_event = RD_KAFKA_RESP_ERR__ASSIGN_PARTITIONS;
+        static_member_expect_rebalance(&c[0], rebalance_start,
+                                       &c[0].assigned_at, -1);
+
+        /* consumer 2 restarts polling and re-joins the group */
+        rebalance_start        = test_clock();
+        c[0].expected_rb_event = RD_KAFKA_RESP_ERR__REVOKE_PARTITIONS;
+        c[1].curr_line         = __LINE__;
         test_consumer_poll_expect_err(c[1].rk, testid, 1000,
                                       RD_KAFKA_RESP_ERR__MAX_POLL_EXCEEDED);
 
@@ -440,9 +454,9 @@ is_fatal_cb(rd_kafka_t *rk, rd_kafka_resp_err_t err, const char *reason) {
 }
 
 /**
- * @brief Test that consumer fencing raises a fatal error
+ * @brief Test that consumer fencing raises a fatal error, classic protocol
  */
-static void do_test_fenced_member(void) {
+static void do_test_fenced_member_classic(void) {
         rd_kafka_t *c[3]; /* 0: consumer2b, 1: consumer1, 2: consumer2a */
         rd_kafka_conf_t *conf;
         const char *topic =
@@ -458,9 +472,11 @@ static void do_test_fenced_member(void) {
         test_create_topic(NULL, topic, 3, 1);
 
         test_conf_set(conf, "group.instance.id", "consumer1");
+        test_conf_set(conf, "client.id", "consumer1");
         c[1] = test_create_consumer(topic, NULL, rd_kafka_conf_dup(conf), NULL);
 
         test_conf_set(conf, "group.instance.id", "consumer2");
+        test_conf_set(conf, "client.id", "consumer2a");
         c[2] = test_create_consumer(topic, NULL, rd_kafka_conf_dup(conf), NULL);
 
         test_wait_topic_exists(c[2], topic, 5000);
@@ -473,6 +489,7 @@ static void do_test_fenced_member(void) {
         /* Create conflicting consumer */
         TEST_SAY("Creating conflicting consumer2 instance\n");
         test_conf_set(conf, "group.instance.id", "consumer2");
+        test_conf_set(conf, "client.id", "consumer2b");
         c[0] = test_create_consumer(topic, NULL, rd_kafka_conf_dup(conf), NULL);
         rd_kafka_conf_destroy(conf);
 
@@ -523,13 +540,297 @@ static void do_test_fenced_member(void) {
         SUB_TEST_PASS();
 }
 
+/**
+ * @brief Test that consumer fencing raises a fatal error,
+ *        consumer protocol (KIP-848).
+ *        The difference with the behavior of the classic one is that
+ *        the member that is fenced is the one that is joining the group
+ *        and not the one that was already in the group.
+ *        Also the error is ERR_UNRELEASED_INSTANCE_ID instead of
+ *        ERR_FENCED_INSTANCE_ID.
+ */
+static void do_test_fenced_member_consumer(void) {
+        rd_kafka_t *c[3]; /* 0: consumer2b, 1: consumer1, 2: consumer2a */
+        rd_kafka_conf_t *conf;
+        const char *topic =
+            test_mk_topic_name("0102_static_group_rebalance", 1);
+        rd_kafka_message_t *rkm;
+        char errstr[512];
+        rd_kafka_resp_err_t err;
+
+        SUB_TEST();
 
+        test_conf_init(&conf, NULL, 30);
+
+        test_create_topic(NULL, topic, 3, 1);
+
+        test_conf_set(conf, "group.instance.id", "consumer1");
+        test_conf_set(conf, "client.id", "consumer1");
+        c[1] = test_create_consumer(topic, NULL, rd_kafka_conf_dup(conf), NULL);
+
+        test_conf_set(conf, "group.instance.id", "consumer2");
+        test_conf_set(conf, "client.id", "consumer2a");
+        c[2] = test_create_consumer(topic, NULL, rd_kafka_conf_dup(conf), NULL);
+
+        test_wait_topic_exists(c[2], topic, 5000);
+
+        test_consumer_subscribe(c[1], topic);
+        test_consumer_subscribe(c[2], topic);
+
+        await_assignment_multi("Awaiting initial assignments", &c[1], 2);
+
+        /* Create conflicting consumer */
+        TEST_SAY("Creating conflicting consumer 2 instance\n");
+        test_conf_set(conf, "group.instance.id", "consumer2");
+        test_conf_set(conf, "client.id", "consumer2b");
+        c[0] = test_create_consumer(topic, NULL, rd_kafka_conf_dup(conf), NULL);
+        rd_kafka_conf_destroy(conf);
+
+        test_curr->is_fatal_cb = is_fatal_cb;
+        valid_fatal_rk = c[0]; /* consumer2b is the consumer that should fail */
+
+        test_consumer_subscribe(c[0], topic);
+
+        /* consumer1 should not be affected (other than a rebalance which
+         * we ignore here)... */
+        test_consumer_poll_no_msgs("consumer1", c[1], 0, 5000);
+
+        /* consumer2b should be fenced off on joining */
+        rkm = rd_kafka_consumer_poll(c[0], 5000);
+        TEST_ASSERT(rkm != NULL, "Expected error, not timeout");
+        TEST_ASSERT(rkm->err == RD_KAFKA_RESP_ERR__FATAL,
+                    "Expected ERR__FATAL, not %s: %s",
+                    rd_kafka_err2str(rkm->err), rd_kafka_message_errstr(rkm));
+        TEST_SAY("Fenced consumer returned expected: %s: %s\n",
+                 rd_kafka_err2name(rkm->err), rd_kafka_message_errstr(rkm));
+        rd_kafka_message_destroy(rkm);
+
+
+        /* Read the actual error */
+        err = rd_kafka_fatal_error(c[0], errstr, sizeof(errstr));
+        TEST_SAY("%s fatal error: %s: %s\n", rd_kafka_name(c[0]),
+                 rd_kafka_err2name(err), errstr);
+        TEST_ASSERT(
+            err == RD_KAFKA_RESP_ERR_UNRELEASED_INSTANCE_ID,
+            "Expected ERR_UNRELEASED_INSTANCE_ID as fatal error, not %s",
+            rd_kafka_err2name(err));
+
+        TEST_SAY("close\n");
+        /* Close consumer2b, should also return a fatal error */
+        err = rd_kafka_consumer_close(c[0]);
+        TEST_ASSERT(err == RD_KAFKA_RESP_ERR__FATAL,
+                    "Expected close on %s to return ERR__FATAL, not %s",
+                    rd_kafka_name(c[0]), rd_kafka_err2name(err));
+
+        rd_kafka_destroy(c[0]);
+
+        /* consumer1 and consumer2a should be fine and get their
+         * assignments */
+        await_assignment_multi("Awaiting post-fencing assignment", &c[1], 2);
+
+        rd_kafka_destroy(c[1]);
+        rd_kafka_destroy(c[2]);
+
+        SUB_TEST_PASS();
+}
+/**
+ * @brief Create a new consumer with given \p boostraps
+ *        \p group_id and \p group_instance_id .
+ */
+static rd_kafka_t *create_consumer(const char *bootstraps,
+                                   const char *group_id,
+                                   const char *group_instance_id) {
+        rd_kafka_conf_t *conf;
+        test_conf_init(&conf, NULL, 0);
+        test_conf_set(conf, "bootstrap.servers", bootstraps);
+        test_conf_set(conf, "group.instance.id", group_instance_id);
+        test_conf_set(conf, "auto.offset.reset", "earliest");
+        test_conf_set(conf, "enable.partition.eof", "true");
+        return test_create_consumer(group_id, NULL, conf, NULL);
+}
+
+/**
+ * @brief Get generation id of consumer \p consumer .
+ */
+static int32_t consumer_generation_id(rd_kafka_t *consumer) {
+        rd_kafka_consumer_group_metadata_t *group_metadata;
+        int32_t generation_id;
+
+        group_metadata = rd_kafka_consumer_group_metadata(consumer);
+        generation_id =
+            rd_kafka_consumer_group_metadata_generation_id(group_metadata);
+        rd_kafka_consumer_group_metadata_destroy(group_metadata);
+        return generation_id;
+}
+
+/**
+ * @brief Check if the API key in \p request is the same as that
+ *        pointed by \p opaque .
+ */
+static rd_bool_t is_api_key(rd_kafka_mock_request_t *request, void *opaque) {
+        int32_t api_key = *(int32_t *)opaque;
+        return rd_kafka_mock_request_api_key(request) == api_key;
+}
+
+/**
+ * @enum do_test_static_membership_mock_variation_t
+ * @brief Variations of the static membership mock test.
+ */
+typedef enum do_test_static_membership_mock_variation_t {
+        /** Consumer 1 leaves with unsubscribe and rejoins the group */
+        DO_TEST_STATIC_MEMBERSHIP_MOCK_VARIATION_SAME_INSTANCE = 0,
+        /** Consumer 1 leaves with unsubscribe and a new consumer with same
+         *  group.instance.id joins the group */
+        DO_TEST_STATIC_MEMBERSHIP_MOCK_VARIATION_NEW_INSTANCE = 1,
+        DO_TEST_STATIC_MEMBERSHIP_MOCK_VARIATION__CNT
+} do_test_static_membership_mock_variation_t;
+
+/**
+ * @brief Static group membership tests with the mock cluster.
+ *        Checks that consumer returns the same assignment
+ *        and generation id after re-joining.
+ *
+ * @param variation Test variation to run.
+ *
+ * @sa `do_test_static_membership_mock_variation_t`
+ */
+static void do_test_static_membership_mock(
+    do_test_static_membership_mock_variation_t variation) {
+        const char *bootstraps;
+        rd_kafka_mock_cluster_t *mcluster;
+        int32_t api_key   = RD_KAFKAP_ConsumerGroupHeartbeat;
+        const char *topic = test_mk_topic_name(__FUNCTION__, 0);
+        rd_kafka_t *consumer1, *consumer2, *consumer_1_to_destroy = NULL;
+        int32_t prev_generation_id1, next_generation_id1, prev_generation_id2,
+            next_generation_id2;
+        rd_kafka_topic_partition_list_t *prev_assignment1, *prev_assignment2,
+            *next_assignment1, *next_assignment2;
+
+        SUB_TEST_QUICK(
+            "%s",
+            variation == DO_TEST_STATIC_MEMBERSHIP_MOCK_VARIATION_SAME_INSTANCE
+                ? "with same instance"
+                : "with new instance");
+
+        mcluster = test_mock_cluster_new(3, &bootstraps);
+        rd_kafka_mock_topic_create(mcluster, topic, 2, 3);
+
+        TEST_SAY("Creating consumers\n");
+        consumer1 = create_consumer(bootstraps, topic, "c1");
+        consumer2 = create_consumer(bootstraps, topic, "c2");
+
+        TEST_SAY("Subscribing consumers to topic \"%s\"\n", topic);
+        test_consumer_subscribe(consumer1, topic);
+        test_consumer_subscribe(consumer2, topic);
+
+        TEST_SAY("Waiting one EOF of consumer 1\n");
+        test_consumer_poll_exact("first consumer", consumer1, 0, 1, 0, 0,
+                                 rd_true, NULL);
+        TEST_SAY("Waiting one EOF of consumer 2\n");
+        test_consumer_poll_exact("second consumer", consumer2, 0, 1, 0, 0,
+                                 rd_true, NULL);
+
+        prev_generation_id1 = consumer_generation_id(consumer1);
+        prev_generation_id2 = consumer_generation_id(consumer2);
+        TEST_CALL_ERR__(rd_kafka_assignment(consumer1, &prev_assignment1));
+        TEST_CALL_ERR__(rd_kafka_assignment(consumer2, &prev_assignment2));
+        TEST_ASSERT(prev_assignment1 != NULL,
+                    "Expected assignment for consumer 1 before the change");
+        TEST_ASSERT(prev_assignment2 != NULL,
+                    "Expected assignment for consumer 2 before the change");
+
+        TEST_SAY("Unsubscribing consumer 1\n");
+        rd_kafka_mock_start_request_tracking(mcluster);
+        TEST_CALL_ERR__(rd_kafka_unsubscribe(consumer1));
+        test_mock_wait_matching_requests(mcluster, 1, 1000, is_api_key,
+                                         &api_key);
+        rd_kafka_mock_stop_request_tracking(mcluster);
+
+        if (variation ==
+            DO_TEST_STATIC_MEMBERSHIP_MOCK_VARIATION_NEW_INSTANCE) {
+                /* Don't destroy it immediately because the
+                 * topic partition lists still hold a reference. */
+                consumer_1_to_destroy = consumer1;
+
+                TEST_SAY("Re-creating consumer 1\n");
+                /* Re-create the consumer with same group and instance id. */
+                consumer1 = create_consumer(bootstraps, topic, "c1");
+        }
+
+        TEST_SAY("Subscribing consumer 1 again\n");
+        test_consumer_subscribe(consumer1, topic);
+        test_consumer_wait_assignment(consumer1, rd_false);
+
+        next_generation_id1 = consumer_generation_id(consumer1);
+        next_generation_id2 = consumer_generation_id(consumer2);
+
+        TEST_ASSERT(next_generation_id1 == prev_generation_id1,
+                    "Expected same generation id for consumer 1, "
+                    "got %d != %d",
+                    prev_generation_id1, next_generation_id1);
+        TEST_ASSERT(next_generation_id2 == prev_generation_id2,
+                    "Expected same generation id for consumer 2, "
+                    "got %d != %d",
+                    prev_generation_id2, next_generation_id2);
+
+        TEST_CALL_ERR__(rd_kafka_assignment(consumer1, &next_assignment1));
+        TEST_CALL_ERR__(rd_kafka_assignment(consumer2, &next_assignment2));
+        TEST_ASSERT(next_assignment1 != NULL,
+                    "Expected assignment for consumer 1 after the change");
+        TEST_ASSERT(next_assignment2 != NULL,
+                    "Expected assignment for consumer 2 after the change");
+        TEST_ASSERT(!test_partition_list_and_offsets_cmp(prev_assignment1,
+                                                         next_assignment1),
+                    "Expected same assignment for consumer 1 after the change");
+        TEST_ASSERT(!test_partition_list_and_offsets_cmp(prev_assignment2,
+                                                         next_assignment2),
+                    "Expected same assignment for consumer 2 after the change");
+
+        rd_kafka_topic_partition_list_destroy(prev_assignment1);
+        rd_kafka_topic_partition_list_destroy(prev_assignment2);
+        rd_kafka_topic_partition_list_destroy(next_assignment1);
+        rd_kafka_topic_partition_list_destroy(next_assignment2);
+
+        RD_IF_FREE(consumer_1_to_destroy, rd_kafka_destroy);
+        rd_kafka_destroy(consumer1);
+        rd_kafka_destroy(consumer2);
+        test_mock_cluster_destroy(mcluster);
+
+        SUB_TEST_PASS();
+}
 
 int main_0102_static_group_rebalance(int argc, char **argv) {
+        /* TODO: check again when regexes
+         * will be supported by KIP-848 */
+        if (test_consumer_group_protocol_classic()) {
+                do_test_static_group_rebalance();
+        }
+
+        if (test_consumer_group_protocol_classic()) {
+                do_test_fenced_member_classic();
+        } else {
+                do_test_fenced_member_consumer();
+        }
+
+        return 0;
+}
 
-        do_test_static_group_rebalance();
+int main_0102_static_group_rebalance_mock(int argc, char **argv) {
+        TEST_SKIP_MOCK_CLUSTER(0);
+        int variation;
 
-        do_test_fenced_member();
+        if (test_consumer_group_protocol_classic()) {
+                TEST_SKIP(
+                    "Static membership isn't implemented "
+                    "in mock cluster for classic protocol\n");
+                return 0;
+        }
+
+        for (variation = DO_TEST_STATIC_MEMBERSHIP_MOCK_VARIATION_SAME_INSTANCE;
+             variation < DO_TEST_STATIC_MEMBERSHIP_MOCK_VARIATION__CNT;
+             variation++) {
+                do_test_static_membership_mock(variation);
+        }
 
         return 0;
 }

package/deps/librdkafka/tests/0103-transactions.c

@@ -143,7 +143,7 @@ static void do_test_basic_producer_txn(rd_bool_t enable_compression) {
         // FIXME: add testing were the txn id is reused (and thus fails)
 
         /* Create topic */
-        test_create_topic(p, topic, partition_cnt, 3);
+        test_create_topic_wait_exists(p, topic, partition_cnt, 3, 5000);
 
         /* Create consumer */
         c_conf = conf;
@@ -348,8 +348,8 @@ void do_test_consumer_producer_txn(void) {
         p1 = test_create_handle(RD_KAFKA_PRODUCER, tmpconf);
 
         /* Create input and output topics */
-        test_create_topic(p1, input_topic, 4, 3);
-        test_create_topic(p1, output_topic, 4, 3);
+        test_create_topic_wait_exists(p1, input_topic, 4, 3, 5000);
+        test_create_topic_wait_exists(p1, output_topic, 4, 3, 5000);
 
         /* Seed input topic with messages */
         TEST_CALL_ERROR__(rd_kafka_init_transactions(p1, 30 * 1000));
@@ -879,7 +879,7 @@ static void do_test_fatal_idempo_error_without_kip360(void) {
 
         p = test_create_handle(RD_KAFKA_PRODUCER, conf);
 
-        test_create_topic(p, topic, 1, 3);
+        test_create_topic_wait_exists(p, topic, 1, 3, 5000);
 
 
         TEST_CALL_ERROR__(rd_kafka_init_transactions(p, 30 * 1000));
@@ -1029,7 +1029,7 @@ static void do_test_empty_txn(rd_bool_t send_offsets, rd_bool_t do_commit) {
         rd_kafka_conf_set_dr_msg_cb(conf, test_dr_msg_cb);
         p = test_create_handle(RD_KAFKA_PRODUCER, conf);
 
-        test_create_topic(p, topic, 1, 3);
+        test_create_topic_wait_exists(p, topic, 1, 3, 5000);
 
         /* Produce some non-txnn messages for the consumer to read and commit */
         test_produce_msgs_easy(topic, testid, 0, msgcnt);
@@ -1130,7 +1130,7 @@ static void do_test_txn_abort_control_message_leader_epoch(void) {
         rd_kafka_conf_set_dr_msg_cb(p_conf, test_dr_msg_cb);
         p = test_create_handle(RD_KAFKA_PRODUCER, p_conf);
 
-        test_create_topic(p, topic, 1, 3);
+        test_create_topic_wait_exists(p, topic, 1, 3, 5000);
 
         TEST_CALL_ERROR__(rd_kafka_init_transactions(p, 5000));
 
@@ -1225,7 +1225,7 @@ static void do_test_wmark_isolation_level(void) {
         rd_kafka_conf_set_dr_msg_cb(conf, test_dr_msg_cb);
         p = test_create_handle(RD_KAFKA_PRODUCER, rd_kafka_conf_dup(conf));
 
-        test_create_topic(p, topic, 1, 3);
+        test_create_topic_wait_exists(p, topic, 1, 3, 5000);
 
         /* Produce some non-txn messages to avoid 0 as the committed hwmark */
         test_produce_msgs_easy(topic, testid, 0, 100);

package/deps/librdkafka/tests/0104-fetch_from_follower_mock.c

@@ -584,6 +584,7 @@ static void do_test_seek_to_offset_with_previous_epoch(void) {
          * from offset 'msgcnt'. */
         rd_kafka_topic_partition_set_leader_epoch(rktpar, 0);
         rd_kafka_seek_partitions(c, rktpars, -1);
+        rd_kafka_topic_partition_list_destroy(rktpars);
 
         test_consumer_poll("third", c, 0, 0, msgcnt, msgcnt, NULL);
 

package/deps/librdkafka/tests/0105-transactions_mock.c

@@ -2,6 +2,7 @@
  * librdkafka - Apache Kafka C library
  *
  * Copyright (c) 2019-2022, Magnus Edenhill
+ *               2025, Confluent Inc.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -44,13 +45,14 @@
 
 
 static int allowed_error;
+static int allowed_error_2;
 
 /**
  * @brief Decide what error_cb's will cause the test to fail.
  */
 static int
 error_is_fatal_cb(rd_kafka_t *rk, rd_kafka_resp_err_t err, const char *reason) {
-        if (err == allowed_error ||
+        if (err == allowed_error || err == allowed_error_2 ||
             /* If transport errors are allowed then it is likely
              * that we'll also see ALL_BROKERS_DOWN. */
             (allowed_error == RD_KAFKA_RESP_ERR__TRANSPORT &&
@@ -1926,8 +1928,8 @@ retry:
                 /* The retry should succeed */
                 test_curr->ignore_dr_err = rd_false;
                 test_curr->exp_dr_err    = is_retry
-                                            ? RD_KAFKA_RESP_ERR_NO_ERROR
-                                            : RD_KAFKA_RESP_ERR__MSG_TIMED_OUT;
+                                               ? RD_KAFKA_RESP_ERR_NO_ERROR
+                                               : RD_KAFKA_RESP_ERR__MSG_TIMED_OUT;
 
                 rd_kafka_mock_partition_set_leader(mcluster, topic, 0, 1);
                 rd_kafka_mock_partition_set_leader(mcluster, topic, 1, 1);
@@ -2062,7 +2064,9 @@ static void do_test_txn_coord_req_destroy(void) {
 
                 rd_kafka_mock_push_request_errors(
                     mcluster, RD_KAFKAP_AddOffsetsToTxn,
-                    1, /* first request + number of internal retries */
+                    3, /* first request + number of internal retries */
+                    RD_KAFKA_RESP_ERR_CONCURRENT_TRANSACTIONS,
+                    RD_KAFKA_RESP_ERR_CONCURRENT_TRANSACTIONS,
                     RD_KAFKA_RESP_ERR_CONCURRENT_TRANSACTIONS);
 
                 err = rd_kafka_producev(rk, RD_KAFKA_V_TOPIC("mytopic"),
@@ -2125,6 +2129,7 @@ static void do_test_txn_coord_req_destroy(void) {
                 TEST_CALL_ERROR__(rd_kafka_abort_transaction(rk, 5000));
         }
 
+        TEST_SAY("Got %d errors\n", errcnt);
         TEST_ASSERT(errcnt > 0,
                     "Expected at least one send_offets_to_transaction() "
                     "failure");
@@ -2222,12 +2227,12 @@ static void do_test_txn_coord_req_multi_find(void) {
 
         on_response_received_cb = multi_find_on_response_received_cb;
         rk                      = create_txn_producer(&mcluster, txnid, 3,
-                                 /* Need connections to all brokers so we
-                                  * can trigger coord_req_fsm events
-                                  * by toggling connections. */
-                                 "enable.sparse.connections", "false",
-                                 /* Set up on_response_received interceptor */
-                                 "on_response_received", "", NULL);
+                                                      /* Need connections to all brokers so we
+                                                       * can trigger coord_req_fsm events
+                                                       * by toggling connections. */
+                                                      "enable.sparse.connections", "false",
+                                                      /* Set up on_response_received interceptor */
+                                                      "on_response_received", "", NULL);
 
         /* Let broker 1 be both txn and group coordinator
          * so that the group coordinator connection is up when it is time
@@ -3042,6 +3047,7 @@ static void do_test_txn_coordinator_null_not_fatal(void) {
 
         /* Broker down is not a test-failing error */
         allowed_error          = RD_KAFKA_RESP_ERR__TRANSPORT;
+        allowed_error_2        = RD_KAFKA_RESP_ERR__TIMED_OUT;
         test_curr->is_fatal_cb = error_is_fatal_cb;
         test_curr->exp_dr_err  = RD_KAFKA_RESP_ERR__MSG_TIMED_OUT;
 
@@ -3113,6 +3119,7 @@ static void do_test_txn_coordinator_null_not_fatal(void) {
         rd_kafka_destroy(rk);
 
         allowed_error          = RD_KAFKA_RESP_ERR_NO_ERROR;
+        allowed_error_2        = RD_KAFKA_RESP_ERR_NO_ERROR;
         test_curr->exp_dr_err  = RD_KAFKA_RESP_ERR_NO_ERROR;
         test_curr->is_fatal_cb = NULL;
 
@@ -3795,7 +3802,7 @@ do_test_txn_offset_commit_doesnt_retry_too_quickly(rd_bool_t times_out) {
          * 2000ms for this call to succeed. */
         timeout = times_out ? 500 : 4000;
         error   = rd_kafka_send_offsets_to_transaction(rk, offsets, cgmetadata,
-                                                     timeout);
+                                                       timeout);
         rd_kafka_consumer_group_metadata_destroy(cgmetadata);
         rd_kafka_topic_partition_list_destroy(offsets);