@platformatic/rdkafka 4.0.1 → 4.1.0-alpha.1

package/deps/librdkafka/tests/0047-partial_buf_tmout.c

@@ -81,6 +81,7 @@ int main_0047_partial_buf_tmout(int argc, char **argv) {
 
         rkt = test_create_producer_topic(rk, topic, "message.timeout.ms", "300",
                                          NULL);
+        test_wait_topic_exists(rk, topic, 5000);
 
         while (got_timeout_err == 0) {
                 test_produce_msgs_nowait(rk, rkt, 0, RD_KAFKA_PARTITION_UA, 0,

package/deps/librdkafka/tests/0048-partitioner.c

@@ -267,7 +267,7 @@ static void do_test_partitioners(void) {
         int pi;
         const char *topic = test_mk_topic_name(__FUNCTION__, 1);
 
-        test_create_topic(NULL, topic, part_cnt, 1);
+        test_create_topic_wait_exists(NULL, topic, part_cnt, 1, 5000);
 
         for (pi = 0; ptest[pi].partitioner; pi++) {
                 do_test_partitioner(topic, ptest[pi].partitioner, _MSG_CNT,

package/deps/librdkafka/tests/0050-subscribe_adds.c

@@ -74,6 +74,7 @@ test_no_duplicate_messages(const char *partition_assignment_strategy) {
                 rd_kafka_topic_t *rkt;
 
                 rkt = test_create_producer_topic(rk, topic[i], NULL);
+                test_wait_topic_exists(rk, topic[i], 5000);
 
                 test_produce_msgs(rk, rkt, testid, RD_KAFKA_PARTITION_UA,
                                   (msgcnt / TOPIC_CNT) * i,

package/deps/librdkafka/tests/0051-assign_adds.c

@@ -68,6 +68,7 @@ int main_0051_assign_adds(int argc, char **argv) {
                 rd_kafka_topic_t *rkt;
 
                 rkt = test_create_producer_topic(rk, topic[i], NULL);
+                test_wait_topic_exists(rk, topic[i], 5000);
 
                 test_produce_msgs(rk, rkt, testid, 0, (msgcnt / TOPIC_CNT) * i,
                                   (msgcnt / TOPIC_CNT), NULL, 100);

package/deps/librdkafka/tests/0052-msg_timestamps.c

@@ -2,6 +2,7 @@
  * librdkafka - Apache Kafka C library
  *
  * Copyright (c) 2012-2022, Magnus Edenhill
+ *               2025, Confluent Inc.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -165,6 +166,7 @@ static void test_timestamps(const char *broker_tstype,
             "--replication-factor 1 --partitions 1 "
             "--config message.timestamp.type=%s",
             topic, broker_tstype);
+        test_wait_topic_exists(NULL, topic, 5000);
 
         TEST_SAY(_C_MAG "Producing %d messages to %s\n", msgcnt, topic);
         produce_msgs(topic, 0, testid, msgcnt, broker_version, codec);
@@ -180,6 +182,7 @@ static void test_timestamps(const char *broker_tstype,
 
 
 int main_0052_msg_timestamps(int argc, char **argv) {
+        rd_bool_t test_with_apache_kafka_since_4_0 = rd_false;
 
         if (!test_can_create_topics(1))
                 return 0;
@@ -189,6 +192,13 @@ int main_0052_msg_timestamps(int argc, char **argv) {
                 return 0;
         }
 
+        if (test_broker_version >= TEST_BRKVER(4, 0, 0, 0)) {
+                /* Code using `broker.version.fallback` and
+                 * `api.version.request=false` won't work
+                 * against Apache Kafka 4.0 */
+                test_with_apache_kafka_since_4_0 = rd_true;
+        }
+
         /* Broker version limits the producer's feature set,
          * for 0.9.0.0 no timestamp will be transmitted,
          * but for 0.10.1.0 (or newer, api.version.request will be true)
@@ -207,13 +217,21 @@ int main_0052_msg_timestamps(int argc, char **argv) {
 
         test_timestamps("CreateTime", "0.10.1.0", "none", &my_timestamp);
         test_timestamps("LogAppendTime", "0.10.1.0", "none", &broker_timestamp);
-        test_timestamps("CreateTime", "0.9.0.0", "none", &invalid_timestamp);
-        test_timestamps("LogAppendTime", "0.9.0.0", "none", &broker_timestamp);
+        if (!test_with_apache_kafka_since_4_0) {
+                test_timestamps("CreateTime", "0.9.0.0", "none",
+                                &invalid_timestamp);
+                test_timestamps("LogAppendTime", "0.9.0.0", "none",
+                                &broker_timestamp);
+        }
 #if WITH_ZLIB
         test_timestamps("CreateTime", "0.10.1.0", "gzip", &my_timestamp);
         test_timestamps("LogAppendTime", "0.10.1.0", "gzip", &broker_timestamp);
-        test_timestamps("CreateTime", "0.9.0.0", "gzip", &invalid_timestamp);
-        test_timestamps("LogAppendTime", "0.9.0.0", "gzip", &broker_timestamp);
+        if (!test_with_apache_kafka_since_4_0) {
+                test_timestamps("CreateTime", "0.9.0.0", "gzip",
+                                &invalid_timestamp);
+                test_timestamps("LogAppendTime", "0.9.0.0", "gzip",
+                                &broker_timestamp);
+        }
 #endif
 
         return 0;

package/deps/librdkafka/tests/0053-stats_cb.cpp

@@ -324,17 +324,13 @@ static void verify_e2e_stats(const std::string &prod_stats,
     exp_tot_rxmsg_bytes += rxbytes;
 
     Test::Say(tostr() << "Producer partition: " << (*pp)["partition"].GetInt()
-                      << ": "
-                      << "txmsgs: " << txmsgs << " vs "
-                      << exp_parts[part].msgcnt << ", "
-                      << "txbytes: " << txbytes << " vs "
-                      << exp_parts[part].totsize << "\n");
+                      << ": " << "txmsgs: " << txmsgs << " vs "
+                      << exp_parts[part].msgcnt << ", " << "txbytes: "
+                      << txbytes << " vs " << exp_parts[part].totsize << "\n");
     Test::Say(tostr() << "Consumer partition: " << (*cp)["partition"].GetInt()
-                      << ": "
-                      << "rxmsgs: " << rxmsgs << " vs "
-                      << exp_parts[part].msgcnt << ", "
-                      << "rxbytes: " << rxbytes << " vs "
-                      << exp_parts[part].totsize << "\n");
+                      << ": " << "rxmsgs: " << rxmsgs << " vs "
+                      << exp_parts[part].msgcnt << ", " << "rxbytes: "
+                      << rxbytes << " vs " << exp_parts[part].totsize << "\n");
   }
 
   /* Check top-level total stats */
@@ -349,16 +345,12 @@ static void verify_e2e_stats(const std::string &prod_stats,
   int64_t tot_rxmsgs      = c["rxmsgs"].GetInt();
   int64_t tot_rxmsg_bytes = c["rxmsg_bytes"].GetInt();
 
-  Test::Say(tostr() << "Producer total: "
-                    << "txmsgs: " << tot_txmsgs << " vs " << exp_tot_txmsgs
-                    << ", "
-                    << "txbytes: " << tot_txmsg_bytes << " vs "
-                    << exp_tot_txmsg_bytes << "\n");
-  Test::Say(tostr() << "Consumer total: "
-                    << "rxmsgs: " << tot_rxmsgs << " vs " << exp_tot_rxmsgs
-                    << ", "
-                    << "rxbytes: " << tot_rxmsg_bytes << " vs "
-                    << exp_tot_rxmsg_bytes << "\n");
+  Test::Say(tostr() << "Producer total: " << "txmsgs: " << tot_txmsgs << " vs "
+                    << exp_tot_txmsgs << ", " << "txbytes: " << tot_txmsg_bytes
+                    << " vs " << exp_tot_txmsg_bytes << "\n");
+  Test::Say(tostr() << "Consumer total: " << "rxmsgs: " << tot_rxmsgs << " vs "
+                    << exp_tot_rxmsgs << ", " << "rxbytes: " << tot_rxmsg_bytes
+                    << " vs " << exp_tot_rxmsg_bytes << "\n");
 }
 
 /**

package/deps/librdkafka/tests/0055-producer_latency.c

@@ -2,6 +2,7 @@
  * librdkafka - Apache Kafka C library
  *
  * Copyright (c) 2012-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 "rdkafka.h"
+#include "../src/rdkafka_protocol.h"
 
 
 #define _MSG_COUNT 10
@@ -146,10 +148,10 @@ static int verify_latency(struct latconf *latconf) {
         }
 
         latconf->wakeups = tot_wakeups;
-        if (latconf->wakeups < 10 || latconf->wakeups > 1000) {
+        if (latconf->wakeups > 1000) {
                 TEST_FAIL_LATER(
                     "%s: broker wakeups out of range: %d, "
-                    "expected 10..1000",
+                    "expected 5..1000",
                     latconf->name, latconf->wakeups);
                 fails++;
         }
@@ -341,7 +343,7 @@ int main_0055_producer_latency(int argc, char **argv) {
         }
 
         /* Create topic without replicas to keep broker-side latency down */
-        test_create_topic(NULL, topic, 1, 1);
+        test_create_topic_wait_exists(NULL, topic, 1, 1, 5000);
 
         for (latconf = latconfs; latconf->name; latconf++)
                 test_producer_latency(topic, latconf);
@@ -364,3 +366,174 @@ int main_0055_producer_latency(int argc, char **argv) {
 
         return 0;
 }
+
+static void dr_msg_cb_first_message(rd_kafka_t *rk,
+                                    const rd_kafka_message_t *rkmessage,
+                                    void *opaque) {
+        test_timing_t *t_produce = (test_timing_t *)rkmessage->_private;
+        TIMING_STOP(t_produce);
+        /* The reason for setting such a low value is that both the mcluster and
+         * the producer are running locally, and there is no linger. This
+         * prevents the test from passing spuriously. */
+        TIMING_ASSERT_LATER(t_produce, 0, 100);
+
+        TEST_ASSERT(rkmessage->err == RD_KAFKA_RESP_ERR_NO_ERROR,
+                    "expected no error, got %s",
+                    rd_kafka_err2str(rkmessage->err));
+        TEST_ASSERT(rkmessage->offset == 0);
+}
+
+/**
+ * Test producer latency of the first message to 50 different topics.
+ *
+ * Cases:
+ * 0: rd_kafka_produce
+ * 1: rd_kafka_producev
+ * 2: rd_kafka_produceva
+ * 3: rd_kafka_produce_batch
+ */
+static void test_producer_latency_first_message(int case_number) {
+        rd_kafka_t *rk;
+        rd_kafka_conf_t *conf;
+        const char *topic;
+        test_timing_t t_produce;
+        rd_kafka_resp_err_t err;
+        rd_kafka_mock_cluster_t *mcluster;
+        rd_kafka_resp_err_t err_produce;
+        const char *bootstrap_servers;
+        const char *case_name = NULL;
+        int i;
+        size_t cnt;
+        rd_kafka_mock_request_t **reqs = NULL;
+        int metadata_request_cnt       = 0;
+        const int iterations           = 50;
+
+        if (case_number == 0) {
+                case_name = "rd_kafka_produce";
+        } else if (case_number == 1) {
+                case_name = "rd_kafka_producev";
+        } else if (case_number == 2) {
+                case_name = "rd_kafka_produceva";
+        } else if (case_number == 3) {
+                case_name = "rd_kafka_produce_batch";
+        }
+
+        SUB_TEST("Starting test for %s", case_name);
+        mcluster = test_mock_cluster_new(1, &bootstrap_servers);
+
+        test_conf_init(&conf, NULL, 60);
+        test_conf_set(conf, "bootstrap.servers", bootstrap_servers);
+        test_conf_set(conf, "linger.ms", "0");
+        rd_kafka_conf_set_dr_msg_cb(conf, dr_msg_cb_first_message);
+        rk = test_create_handle(RD_KAFKA_PRODUCER, conf);
+
+        rd_kafka_mock_start_request_tracking(mcluster);
+
+        /* Run the case 50 times. */
+        for (i = 0; i < iterations; i++) {
+                topic = test_mk_topic_name("0055_producer_latency_mock", 1);
+                rd_kafka_mock_topic_create(mcluster, topic, 1, 1);
+
+                switch (case_number) {
+                case 0: {
+                        char *payload = "value";
+                        rd_kafka_topic_t *rkt =
+                            rd_kafka_topic_new(rk, topic, NULL);
+                        int res;
+                        TIMING_START(&t_produce, "Produce message");
+
+                        res = rd_kafka_produce(rkt, 0, RD_KAFKA_MSG_F_COPY,
+                                               payload, 5, NULL, 0, &t_produce);
+                        rd_kafka_topic_destroy(rkt);
+                        TEST_ASSERT(res == 0, "expected no error");
+                        break;
+                }
+                case 1: {
+                        TIMING_START(&t_produce, "Produce message");
+                        err_produce = rd_kafka_producev(
+                            rk, RD_KAFKA_V_TOPIC(topic),
+                            RD_KAFKA_V_PARTITION(0),
+                            RD_KAFKA_V_VALUE("value", 5),
+                            RD_KAFKA_V_OPAQUE((&t_produce)), RD_KAFKA_V_END);
+                        TEST_ASSERT(err_produce == RD_KAFKA_RESP_ERR_NO_ERROR,
+                                    "expected no error, got %s",
+                                    rd_kafka_err2str(err_produce));
+                        break;
+                }
+                case 2: {
+                        rd_kafka_vu_t vus[3];
+                        vus[0].vtype      = RD_KAFKA_VTYPE_TOPIC;
+                        vus[0].u.cstr     = topic;
+                        vus[1].vtype      = RD_KAFKA_VTYPE_VALUE;
+                        vus[1].u.mem.ptr  = "value";
+                        vus[1].u.mem.size = 5;
+                        vus[2].vtype      = RD_KAFKA_VTYPE_OPAQUE;
+                        vus[2].u.ptr      = &t_produce;
+
+                        TIMING_START(&t_produce, "Produce message");
+                        TEST_CALL_ERROR__(rd_kafka_produceva(rk, vus, 3));
+                        break;
+                }
+                case 3: {
+                        rd_kafka_message_t rkmessages[1] = {0};
+                        rd_kafka_topic_t *rkt =
+                            rd_kafka_topic_new(rk, topic, NULL);
+                        int res;
+
+                        rkmessages[0].payload  = "value";
+                        rkmessages[0].len      = 5;
+                        rkmessages[0]._private = &t_produce;
+
+                        TIMING_START(&t_produce, "Produce message");
+                        res = rd_kafka_produce_batch(
+                            rkt, 0, RD_KAFKA_MSG_F_COPY, rkmessages, 1);
+                        rd_kafka_topic_destroy(rkt);
+                        TEST_ASSERT(res == 1, "expected 1 msg enqueued, got %d",
+                                    res);
+                        break;
+                }
+                }
+                rd_kafka_poll(rk, 0);
+                err = rd_kafka_flush(rk, 10000);
+                TEST_ASSERT(err == RD_KAFKA_RESP_ERR_NO_ERROR,
+                            "expected all messages to be flushed, got %s",
+                            rd_kafka_err2str(err));
+
+                /* The topic_scan_all timer runs every 1 second. Originally, the
+                 * issue was that the topic metadata was only fetched on the
+                 * topic scan rather than when we were queueing the message.
+                 * Running a loop and waiting 1ms between iterations means we
+                 * will avoid passing tests due to coincidence. */
+                rd_usleep(1 * 1000ll, 0);
+        }
+        rd_kafka_destroy(rk);
+
+        reqs = rd_kafka_mock_get_requests(mcluster, &cnt);
+        for (i = 0; i < (int)cnt; i++) {
+                if (rd_kafka_mock_request_api_key(reqs[i]) ==
+                    RD_KAFKAP_Metadata) {
+                        metadata_request_cnt++;
+                }
+        }
+        TEST_ASSERT(metadata_request_cnt == iterations,
+                    "Expected exactly %d MetadataRequest, got %d", iterations,
+                    metadata_request_cnt);
+        rd_kafka_mock_request_destroy_array(reqs, cnt);
+        rd_kafka_mock_stop_request_tracking(mcluster);
+
+        test_mock_cluster_destroy(mcluster);
+
+        TEST_LATER_CHECK();
+        SUB_TEST_PASS();
+}
+
+int main_0055_producer_latency_mock(int argc, char **argv) {
+        TEST_SKIP_MOCK_CLUSTER(0);
+
+        int case_number;
+        for (case_number = 0; case_number < 4; case_number++) {
+                test_producer_latency_first_message(case_number);
+        }
+
+        return 0;
+}

package/deps/librdkafka/tests/0056-balanced_group_mt.c

@@ -2,6 +2,7 @@
  * librdkafka - Apache Kafka C library
  *
  * Copyright (c) 2012-2022, Magnus Edenhill
+ *               2025, Confluent Inc.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -152,7 +153,8 @@ static void rebalance_cb(rd_kafka_t *rk,
         case RD_KAFKA_RESP_ERR__ASSIGN_PARTITIONS:
                 assign_cnt++;
 
-                rd_kafka_assign(rk, partitions);
+                test_consumer_assign_by_rebalance_protocol("rebalance", rk,
+                                                           partitions);
                 mtx_lock(&lock);
                 consumers_running = 1;
                 mtx_unlock(&lock);
@@ -177,7 +179,8 @@ static void rebalance_cb(rd_kafka_t *rk,
                 if (assign_cnt == 0)
                         TEST_FAIL("asymetric rebalance_cb");
                 assign_cnt--;
-                rd_kafka_assign(rk, NULL);
+                test_consumer_unassign_by_rebalance_protocol("rebalance", rk,
+                                                             partitions);
                 mtx_lock(&lock);
                 consumers_running = 0;
                 mtx_unlock(&lock);
@@ -222,6 +225,7 @@ int main_0056_balanced_group_mt(int argc, char **argv) {
         /* Produce messages */
         rk_p  = test_create_producer();
         rkt_p = test_create_producer_topic(rk_p, topic, NULL);
+        test_wait_topic_exists(rk_p, topic, 5000);
 
         for (partition = 0; partition < partition_cnt; partition++) {
                 test_produce_msgs(rk_p, rkt_p, testid, partition,

package/deps/librdkafka/tests/0058-log.cpp

@@ -52,9 +52,9 @@ class myLogCb : public RdKafka::EventCb {
     switch (event.type()) {
     case RdKafka::Event::EVENT_LOG:
       cnt_++;
-      Test::Say(tostr() << "Log: "
-                        << "level " << event.severity() << ", facility "
-                        << event.fac() << ", str " << event.str() << "\n");
+      Test::Say(tostr() << "Log: " << "level " << event.severity()
+                        << ", facility " << event.fac() << ", str "
+                        << event.str() << "\n");
       if (state_ != _EXP_LOG)
         Test::Fail(
             "Received unexpected "

package/deps/librdkafka/tests/0059-bsearch.cpp

@@ -2,6 +2,7 @@
  * librdkafka - Apache Kafka C library
  *
  * Copyright (c) 2016-2022, Magnus Edenhill
+ *               2025, Confluent Inc.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -27,6 +28,7 @@
  */
 
 #include <iostream>
+#include <ctime>
 #include "testcpp.h"
 
 /**
@@ -110,7 +112,7 @@ class MyDeliveryReportCb : public RdKafka::DeliveryReportCb {
 static void do_test_bsearch(void) {
   RdKafka::Conf *conf, *tconf;
   int msgcnt = 1000;
-  int64_t timestamp;
+  int64_t timestamp_ms;
   std::string errstr;
   RdKafka::ErrorCode err;
   MyDeliveryReportCb my_dr;
@@ -128,14 +130,16 @@ static void do_test_bsearch(void) {
   delete conf;
   delete tconf;
 
-  timestamp = 1000;
+  /* Start with now() - 1h */
+  timestamp_ms = std::time(0) * 1000LL - 3600LL * 1000LL;
+
   for (int i = 0; i < msgcnt; i++) {
     err = p->produce(topic, partition, RdKafka::Producer::RK_MSG_COPY,
-                     (void *)topic.c_str(), topic.size(), NULL, 0, timestamp,
+                     (void *)topic.c_str(), topic.size(), NULL, 0, timestamp_ms,
                      i == 357 ? (void *)1 /*golden*/ : NULL);
     if (err != RdKafka::ERR_NO_ERROR)
       Test::Fail("Produce failed: " + RdKafka::err2str(err));
-    timestamp += 100 + (timestamp % 9);
+    timestamp_ms += 100 + (i % 10);
   }
 
   if (p->flush(tmout_multip(5000)) != 0)

package/deps/librdkafka/tests/0061-consumer_lag.cpp

@@ -2,6 +2,7 @@
  * librdkafka - Apache Kafka C library
  *
  * Copyright (c) 2016-2022, Magnus Edenhill
+ *               2025, Confluent Inc.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -39,18 +40,33 @@ static std::string topic;
 
 class StatsCb : public RdKafka::EventCb {
  public:
-  int64_t calc_lag;  // calculated lag
-  int lag_valid;     // number of times lag has been valid
+  int64_t calc_lag;          // calculated lag
+  int lag_valid;             // number of times lag has been valid
+  bool partitions_assigned;  // partitions were assigned
+  bool skip_first;           // skip first event after assignment
 
   StatsCb() {
-    calc_lag  = -1;
-    lag_valid = 0;
+    calc_lag            = -1;
+    lag_valid           = 0;
+    partitions_assigned = false;
+    skip_first          = true;
   }
 
   /**
    * @brief Event callback
    */
   void event_cb(RdKafka::Event &event) {
+    if (!partitions_assigned) {
+      /* It means we won't find the topic in the stats JSON. */
+      return;
+    }
+
+    if (skip_first) {
+      skip_first = false;
+      /* First JSON after assignment could be created before the assignment. */
+      return;
+    }
+
     if (event.type() == RdKafka::Event::EVENT_LOG) {
       Test::Say(tostr() << "LOG-" << event.severity() << "-" << event.fac()
                         << ": " << event.str() << "\n");
@@ -200,19 +216,23 @@ static void do_test_consumer_lag(bool with_txns) {
   Test::conf_set(conf, "group.id", topic);
   Test::conf_set(conf, "enable.auto.commit", "false");
   Test::conf_set(conf, "auto.offset.reset", "earliest");
-  Test::conf_set(conf, "statistics.interval.ms", "100");
+  Test::conf_set(conf, "statistics.interval.ms", "500");
 
   RdKafka::KafkaConsumer *c = RdKafka::KafkaConsumer::create(conf, errstr);
   if (!c)
     Test::Fail("Failed to create KafkaConsumer: " + errstr);
   delete conf;
 
+  /* Execute callbacks for statistics enqueued before assignment. */
+  c->poll(0);
+
   /* Assign partitions */
   std::vector<RdKafka::TopicPartition *> parts;
   parts.push_back(RdKafka::TopicPartition::create(topic, 0));
   if ((err = c->assign(parts)))
     Test::Fail("assign failed: " + RdKafka::err2str(err));
   RdKafka::TopicPartition::destroy(parts);
+  stats.partitions_assigned = true;
 
   /* Start consuming */
   Test::Say("Consuming topic " + topic + "\n");

package/deps/librdkafka/tests/0067-empty_topic.cpp

@@ -70,6 +70,9 @@ static void do_test_empty_topic_consumer() {
                RdKafka::err2str(err));
   delete md;
 
+  /* Await propagation to the whole cluster */
+  test_wait_topic_exists(consumer->c_ptr(), topic.c_str(), 1 * 1000);
+
   /* Start consumer */
   err = consumer->start(rkt, partition, RdKafka::Topic::OFFSET_BEGINNING);
   if (err)

package/deps/librdkafka/tests/0068-produce_timeout.c

@@ -2,6 +2,7 @@
  * librdkafka - Apache Kafka C library
  *
  * Copyright (c) 2012-2022, Magnus Edenhill
+ *               2025, Confluent Inc.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -28,26 +29,11 @@
 
 #include "test.h"
 
-#if WITH_SOCKEM
 #include "rdkafka.h"
+#include "../src/rdkafka_protocol.h"
 
 #include <stdarg.h>
 
-/**
- * Force produce requests to timeout to test error handling.
- */
-
-/**
- * @brief Sockem connect, called from **internal librdkafka thread** through
- *        librdkafka's connect_cb
- */
-static int connect_cb(struct test *test, sockem_t *skm, const char *id) {
-
-        /* Let delay be high to trigger the local timeout */
-        sockem_set(skm, "delay", 10000, NULL);
-        return 0;
-}
-
 static int
 is_fatal_cb(rd_kafka_t *rk, rd_kafka_resp_err_t err, const char *reason) {
         /* Ignore connectivity errors since we'll be bringing down
@@ -95,17 +81,25 @@ int main_0068_produce_timeout(int argc, char **argv) {
         rd_kafka_conf_t *conf;
         rd_kafka_topic_t *rkt;
         int msgcounter = 0;
+        const char *bootstraps;
+
+        TEST_SKIP_MOCK_CLUSTER(0);
+
+        rd_kafka_mock_cluster_t *mcluster =
+            test_mock_cluster_new(3, &bootstraps);
+        rd_kafka_mock_topic_create(mcluster, topic, 1, 3);
+        rd_kafka_mock_partition_set_leader(mcluster, topic, 0, 1);
 
         testid = test_id_generate();
 
         test_conf_init(&conf, NULL, 60);
+        test_conf_set(conf, "bootstrap.servers", bootstraps);
         rd_kafka_conf_set_dr_msg_cb(conf, dr_msg_cb);
 
-        test_socket_enable(conf);
-        test_curr->connect_cb  = connect_cb;
         test_curr->is_fatal_cb = is_fatal_cb;
 
-        rk  = test_create_handle(RD_KAFKA_PRODUCER, conf);
+        rk = test_create_handle(RD_KAFKA_PRODUCER, conf);
+        /* message timeout should be less that rtt */
         rkt = test_create_producer_topic(rk, topic, "message.timeout.ms",
                                          "2000", NULL);
 
@@ -113,10 +107,13 @@ int main_0068_produce_timeout(int argc, char **argv) {
         test_auto_create_topic_rkt(rk, rkt, tmout_multip(5000));
 
         TEST_SAY("Producing %d messages that should timeout\n", msgcnt);
+        rd_kafka_mock_broker_push_request_error_rtts(
+            mcluster, 1, RD_KAFKAP_Produce, 1, RD_KAFKA_RESP_ERR_NO_ERROR,
+            6000);
+
         test_produce_msgs_nowait(rk, rkt, testid, 0, 0, msgcnt, NULL, 0, 0,
                                  &msgcounter);
 
-
         TEST_SAY("Flushing..\n");
         rd_kafka_flush(rk, 10000);
 
@@ -131,8 +128,9 @@ int main_0068_produce_timeout(int argc, char **argv) {
         rd_kafka_topic_destroy(rkt);
         rd_kafka_destroy(rk);
 
-        return 0;
-}
+        test_mock_cluster_destroy(mcluster);
 
+        TEST_LATER_CHECK();
 
-#endif
+        return 0;
+}

package/deps/librdkafka/tests/0069-consumer_add_parts.c

@@ -2,6 +2,7 @@
  * librdkafka - Apache Kafka C library
  *
  * Copyright (c) 2012-2022, Magnus Edenhill
+ *               2025, Confluent Inc.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -58,10 +59,7 @@ static void rebalance_cb(rd_kafka_t *rk,
                  rd_kafka_err2str(err));
         test_print_partition_list(parts);
 
-        if (err == RD_KAFKA_RESP_ERR__ASSIGN_PARTITIONS)
-                rd_kafka_assign(rk, parts);
-        else if (err == RD_KAFKA_RESP_ERR__REVOKE_PARTITIONS)
-                rd_kafka_assign(rk, NULL);
+        test_rebalance_cb(rk, err, parts, opaque);
 
         *statep = err;
 }
@@ -79,9 +77,7 @@ int main_0069_consumer_add_parts(int argc, char **argv) {
         c2 = test_create_consumer(topic, rebalance_cb, NULL, NULL);
 
         TEST_SAY("Creating topic %s with 2 partitions\n", topic);
-        test_create_topic(c1, topic, 2, 1);
-
-        test_wait_topic_exists(c1, topic, 10 * 1000);
+        test_create_topic_wait_exists(c1, topic, 2, 1, 10 * 5000);
 
         TEST_SAY("Subscribing\n");
         test_consumer_subscribe(c1, topic);