@platformatic/rdkafka 4.0.1 → 4.1.0-alpha.1

package/deps/librdkafka/tests/0139-offset_validation_mock.c

@@ -192,14 +192,14 @@ static void do_test_permanent_error_retried(rd_kafka_resp_err_t err) {
         rktpar         = rd_kafka_topic_partition_list_add(rktpars, topic, 0);
         rktpar->offset = 0;
 
-        /* Will validate the offset at start fetching again
+        /* Will validate the offset and start fetching again
          * from offset 0. */
         rd_kafka_topic_partition_set_leader_epoch(rktpar, 0);
         rd_kafka_seek_partitions(c1, rktpars, -1);
         rd_kafka_topic_partition_list_destroy(rktpars);
 
         /* Read all messages after seek to zero.
-         * In case of permanent error instead it reset to latest and
+         * In case of permanent error, instead, it resets to latest and
          * gets an EOF. */
         test_consumer_poll("MSG_ALL", c1, testid, 0, 0, 5, NULL);
 
@@ -424,6 +424,505 @@ static void do_test_store_offset_without_leader_epoch(void) {
         SUB_TEST_PASS();
 }
 
+static rd_bool_t is_broker_fetch_request(rd_kafka_mock_request_t *request,
+                                         void *opaque) {
+        return rd_kafka_mock_request_id(request) == *(int *)(opaque) &&
+               rd_kafka_mock_request_api_key(request) == RD_KAFKAP_Fetch;
+}
+
+static rd_bool_t
+is_offset_for_leader_epoch_request(rd_kafka_mock_request_t *request,
+                                   void *opaque) {
+        return rd_kafka_mock_request_id(request) == *(int *)(opaque) &&
+               rd_kafka_mock_request_api_key(request) ==
+                   RD_KAFKAP_OffsetForLeaderEpoch;
+}
+
+static rd_bool_t is_metadata_request(rd_kafka_mock_request_t *request,
+                                     void *opaque) {
+        return rd_kafka_mock_request_api_key(request) == RD_KAFKAP_Metadata;
+}
+
+/**
+ * @brief A second leader change is triggered after first one switches
+ * to a leader supporting KIP-320, the second leader either:
+ *
+ * - variation 0: doesn't support KIP-320 (leader epoch -1).
+ *   This can happed during a cluster roll for upgrading the cluster.
+ *   See #4796.
+ * - variation 1: the leader epoch is the same as previous leader.
+ *   This can happen when the broker doesn't need that a validation
+ *   should be performed after a leader change.
+ *
+ * In both cases no validation should be performed
+ * and it should continue fetching messages on the new leader.
+ */
+static void do_test_leader_change_no_validation(int variation) {
+        const char *topic      = test_mk_topic_name(__FUNCTION__, 1);
+        const char *c1_groupid = topic;
+        rd_kafka_t *c1;
+        const char *bootstraps;
+        rd_kafka_mock_cluster_t *mcluster;
+        int msg_cnt     = 5;
+        uint64_t testid = test_id_generate();
+        rd_kafka_conf_t *conf;
+        int i, leader = 1;
+        size_t matching_requests;
+        /* No KIP-320 support on second leader change */
+        int32_t leader_epoch = -1;
+        if (variation == 1) {
+                /* Same leader epoch on second leader change */
+                leader_epoch = 2;
+        }
+
+        SUB_TEST_QUICK("variation: %d", variation);
+
+        mcluster = test_mock_cluster_new(2, &bootstraps);
+        rd_kafka_mock_topic_create(mcluster, topic, 1, 2);
+        rd_kafka_mock_partition_set_leader(mcluster, topic, 0, 1);
+
+        /* Seed the topic with messages */
+        test_produce_msgs_easy_v(topic, testid, 0, 0, msg_cnt, 10,
+                                 "bootstrap.servers", bootstraps,
+                                 "batch.num.messages", "1", NULL);
+
+        test_conf_init(&conf, NULL, 60);
+        test_conf_set(conf, "bootstrap.servers", bootstraps);
+        test_conf_set(conf, "auto.offset.reset", "earliest");
+        test_conf_set(conf, "enable.auto.commit", "false");
+
+        c1 = test_create_consumer(c1_groupid, NULL, conf, NULL);
+        test_consumer_subscribe(c1, topic);
+
+        rd_kafka_mock_start_request_tracking(mcluster);
+        TEST_SAY("Consume initial messages and join the group, etc.\n");
+        test_consumer_poll("MSG_INIT", c1, testid, 0, 0, msg_cnt, NULL);
+
+        TEST_SAY("Wait Fetch request to broker 1\n");
+        matching_requests = test_mock_wait_matching_requests(
+            mcluster, 1, 1000, is_broker_fetch_request, &leader);
+        TEST_ASSERT_LATER(matching_requests > 0,
+                          "Expected at least one Fetch request to broker 1");
+
+        /* No validation is performed on first fetch. */
+        TEST_SAY("Wait no OffsetForLeaderEpoch request to broker 1\n");
+        matching_requests = test_mock_wait_matching_requests(
+            mcluster, 0, 1000, is_offset_for_leader_epoch_request, &leader);
+        TEST_ASSERT_LATER(matching_requests == 0,
+                          "Expected no OffsetForLeaderEpoch request"
+                          " to broker 1, got %" PRIusz,
+                          matching_requests);
+        rd_kafka_mock_stop_request_tracking(mcluster);
+
+        /* The leader will change from 1->2, and the OffsetForLeaderEpoch will
+         * be sent to broker 2. Leader epoch becomes 1. */
+        rd_kafka_mock_start_request_tracking(mcluster);
+        TEST_SAY("Changing leader to broker 2\n");
+        rd_kafka_mock_partition_set_leader(mcluster, topic, 0, 2);
+        leader = 2;
+        rd_kafka_poll(c1, 1000);
+
+        TEST_SAY("Wait Fetch request to broker 2\n");
+        matching_requests = test_mock_wait_matching_requests(
+            mcluster, 1, 1000, is_broker_fetch_request, &leader);
+        TEST_ASSERT_LATER(matching_requests > 0,
+                          "Expected at least one fetch request to broker 2");
+
+        TEST_SAY("Wait OffsetForLeaderEpoch request to broker 2\n");
+        matching_requests = test_mock_wait_matching_requests(
+            mcluster, 1, 1000, is_offset_for_leader_epoch_request, &leader);
+        TEST_ASSERT_LATER(matching_requests == 1,
+                          "Expected one OffsetForLeaderEpoch request"
+                          " to broker 2, got %" PRIusz,
+                          matching_requests);
+        rd_kafka_mock_stop_request_tracking(mcluster);
+
+        /* Reset leader, set leader epoch to `leader_epoch`
+         * to trigger this special case. */
+        TEST_SAY("Changing leader to broker 1\n");
+        for (i = 0; i < 5; i++) {
+                rd_kafka_mock_partition_push_leader_response(mcluster, topic, 0,
+                                                             1, leader_epoch);
+        }
+        rd_kafka_mock_partition_set_leader(mcluster, topic, 0, 1);
+        leader = 1;
+        rd_kafka_mock_start_request_tracking(mcluster);
+        rd_kafka_poll(c1, 1000);
+
+        TEST_SAY("Wait Fetch request to broker 1\n");
+        /* 0 is correct here as second parameter as we don't wait to receive
+         * at least one Fetch request, given in the failure case it'll take more
+         * than 1s and it's possible a OffsetForLeaderEpoch is received after
+         * that, because we ran out of overridden leader responses. */
+        matching_requests = test_mock_wait_matching_requests(
+            mcluster, 0, 1000, is_broker_fetch_request, &leader);
+        TEST_ASSERT_LATER(matching_requests > 0,
+                          "Expected at least one fetch request to broker 1");
+
+        /* Given same leader epoch, or -1, is returned,
+         * no validation is performed */
+        TEST_SAY("Wait no OffsetForLeaderEpoch request to broker 1\n");
+        matching_requests = test_mock_wait_matching_requests(
+            mcluster, 0, 1000, is_offset_for_leader_epoch_request, &leader);
+        TEST_ASSERT_LATER(matching_requests == 0,
+                          "Expected no OffsetForLeaderEpoch request"
+                          " to broker 1, got %" PRIusz,
+                          matching_requests);
+        rd_kafka_mock_stop_request_tracking(mcluster);
+
+        rd_kafka_destroy(c1);
+        test_mock_cluster_destroy(mcluster);
+
+        TEST_LATER_CHECK();
+        SUB_TEST_PASS();
+}
+
+static int
+is_fatal_cb(rd_kafka_t *rk, rd_kafka_resp_err_t err, const char *reason) {
+        /* Ignore UNKNOWN_TOPIC_OR_PART errors. */
+        TEST_SAY("is_fatal?: %s: %s\n", rd_kafka_err2str(err), reason);
+        if (err == RD_KAFKA_RESP_ERR__UNKNOWN_PARTITION ||
+            err == RD_KAFKA_RESP_ERR_UNKNOWN_TOPIC_OR_PART)
+                return 0;
+        return 1;
+}
+
+/**
+ * @brief Test partition validation when it's temporarily delegated to
+ * the internal broker. There are two variations:
+ *
+ * variation 1: leader epoch bump is simultaneous to the partition
+ *              delegation returning from the internal broker to the
+ *              new leader.
+ * variation 2: leader epoch bump is triggered immediately by KIP-951
+ *              and validation fails, later metadata request fails
+ *              and partition is delegated to the internal broker.
+ *              When partition is delegated back to the leader,
+ *              it finds the same leader epoch but validation must
+ *              be completed as state is still VALIDATE_EPOCH_WAIT.
+ *
+ * In both cases, fetch must continue with the new leader and
+ * after the validation is completed.
+ *
+ * See #4804.
+ */
+static void do_test_leader_change_from_internal_broker(int variation) {
+        const char *topic      = test_mk_topic_name(__FUNCTION__, 1);
+        const char *c1_groupid = topic;
+        rd_kafka_t *c1;
+        const char *bootstraps;
+        rd_kafka_mock_cluster_t *mcluster;
+        int msg_cnt     = 5;
+        uint64_t testid = test_id_generate();
+        rd_kafka_conf_t *conf;
+        int leader = 1;
+        size_t matching_requests, expected_offset_for_leader_epoch_requests = 1;
+
+        SUB_TEST_QUICK("variation: %d", variation);
+
+        mcluster = test_mock_cluster_new(2, &bootstraps);
+        rd_kafka_mock_topic_create(mcluster, topic, 1, 2);
+        rd_kafka_mock_partition_set_leader(mcluster, topic, 0, 1);
+
+        /* Seed the topic with messages */
+        test_produce_msgs_easy_v(topic, testid, 0, 0, msg_cnt, 10,
+                                 "bootstrap.servers", bootstraps,
+                                 "batch.num.messages", "1", NULL);
+
+        test_conf_init(&conf, NULL, 60);
+        test_conf_set(conf, "bootstrap.servers", bootstraps);
+        test_conf_set(conf, "auto.offset.reset", "earliest");
+        test_conf_set(conf, "enable.auto.commit", "false");
+
+        c1 = test_create_consumer(c1_groupid, NULL, conf, NULL);
+        test_consumer_subscribe(c1, topic);
+        test_curr->is_fatal_cb = is_fatal_cb;
+
+        rd_kafka_mock_start_request_tracking(mcluster);
+        TEST_SAY("Consume initial messages and join the group, etc.\n");
+        test_consumer_poll("MSG_INIT", c1, testid, 0, 0, msg_cnt, NULL);
+
+        TEST_SAY("Wait Fetch request to broker 1\n");
+        matching_requests = test_mock_wait_matching_requests(
+            mcluster, 1, 1000, is_broker_fetch_request, &leader);
+        TEST_ASSERT_LATER(matching_requests > 0,
+                          "Expected at least one Fetch request to broker 1");
+
+        /* No validation is performed on first fetch. */
+        TEST_SAY("Wait no OffsetForLeaderEpoch request to broker 1\n");
+        matching_requests = test_mock_wait_matching_requests(
+            mcluster, 0, 1000, is_offset_for_leader_epoch_request, &leader);
+        TEST_ASSERT_LATER(matching_requests == 0,
+                          "Expected no OffsetForLeaderEpoch request"
+                          " to broker 1, got %" PRIusz,
+                          matching_requests);
+        rd_kafka_mock_stop_request_tracking(mcluster);
+
+        /* The leader will change from 1->2, and the OffsetForLeaderEpoch will
+         * be sent to broker 2. Leader epoch becomes 1. */
+        rd_kafka_mock_start_request_tracking(mcluster);
+        TEST_SAY("Changing leader to broker 2\n");
+        rd_kafka_mock_partition_set_leader(mcluster, topic, 0, 2);
+        leader = 2;
+        rd_kafka_poll(c1, 1000);
+
+        TEST_SAY("Wait Fetch request to broker 2\n");
+        matching_requests = test_mock_wait_matching_requests(
+            mcluster, 1, 1000, is_broker_fetch_request, &leader);
+        TEST_ASSERT_LATER(matching_requests > 0,
+                          "Expected at least one fetch request to broker 2");
+
+        TEST_SAY("Wait OffsetForLeaderEpoch request to broker 2\n");
+        matching_requests = test_mock_wait_matching_requests(
+            mcluster, 1, 1000, is_offset_for_leader_epoch_request, &leader);
+        TEST_ASSERT_LATER(matching_requests == 1,
+                          "Expected one OffsetForLeaderEpoch request"
+                          " to broker 2, got %" PRIusz,
+                          matching_requests);
+        rd_kafka_mock_stop_request_tracking(mcluster);
+
+        /* Reset leader, Metadata request fails in between and delegates
+         * the partition to the internal broker. */
+        TEST_SAY("Changing leader to broker 1\n");
+        if (variation == 0) {
+                /* Fail Fetch request too, otherwise KIP-951 mechanism is faster
+                 * than the Metadata request. */
+                rd_kafka_mock_push_request_errors(
+                    mcluster, RD_KAFKAP_Fetch, 1,
+                    RD_KAFKA_RESP_ERR_UNKNOWN_TOPIC_OR_PART);
+        } else if (variation == 1) {
+                /* First OffsetForLeaderEpoch is triggered by KIP-951,
+                 * it updates leader epoch, then it fails, triggers metadata
+                 * refresh,
+                 * Metadata fails too and partition is delegated to the internal
+                 * broker.
+                 * Validation is retried three times during this period
+                 * and it should fail because we want to see what happens
+                 * next when partition isn't delegated to the internal
+                 * broker anymore. */
+                rd_kafka_mock_push_request_errors(
+                    mcluster, RD_KAFKAP_OffsetForLeaderEpoch, 3,
+                    RD_KAFKA_RESP_ERR_UNKNOWN_TOPIC_OR_PART,
+                    RD_KAFKA_RESP_ERR_UNKNOWN_TOPIC_OR_PART,
+                    RD_KAFKA_RESP_ERR_UNKNOWN_TOPIC_OR_PART);
+        }
+
+        /* This causes a Metadata request error. */
+        rd_kafka_mock_topic_set_error(mcluster, topic,
+                                      RD_KAFKA_RESP_ERR_UNKNOWN_TOPIC_OR_PART);
+        rd_kafka_mock_partition_set_leader(mcluster, topic, 0, 1);
+        leader = 1;
+        rd_kafka_mock_start_request_tracking(mcluster);
+        rd_kafka_poll(c1, 1000);
+
+        TEST_SAY(
+            "Wait a Metadata request that fails and delegates partition to"
+            " the internal broker.\n");
+        matching_requests = test_mock_wait_matching_requests(
+            mcluster, 1, 1000, is_metadata_request, NULL);
+        TEST_ASSERT_LATER(matching_requests > 0,
+                          "Expected at least one Metadata request");
+        TEST_SAY(
+            "Reset partition error status."
+            " Partition is delegated to broker 1.\n");
+        rd_kafka_mock_topic_set_error(mcluster, topic,
+                                      RD_KAFKA_RESP_ERR_NO_ERROR);
+
+        TEST_SAY("Wait Fetch request to broker 1\n");
+        matching_requests = test_mock_wait_matching_requests(
+            mcluster, 1, 2000, is_broker_fetch_request, &leader);
+        TEST_ASSERT_LATER(matching_requests > 0,
+                          "Expected at least one fetch request to broker 1");
+
+        TEST_SAY("Wait OffsetForLeaderEpoch request to broker 1\n");
+        if (variation == 1) {
+                /* There's three OffsetForLeaderEpoch requests more in
+                 * variation 1. See previous comment. */
+                expected_offset_for_leader_epoch_requests += 3;
+        }
+        matching_requests = test_mock_wait_matching_requests(
+            mcluster, 1, 1000, is_offset_for_leader_epoch_request, &leader);
+        TEST_ASSERT_LATER(
+            matching_requests == expected_offset_for_leader_epoch_requests,
+            "Expected %" PRIusz
+            " OffsetForLeaderEpoch request"
+            " to broker 1, got %" PRIusz,
+            expected_offset_for_leader_epoch_requests, matching_requests);
+        rd_kafka_mock_stop_request_tracking(mcluster);
+
+        rd_kafka_destroy(c1);
+        test_mock_cluster_destroy(mcluster);
+
+        TEST_LATER_CHECK();
+        SUB_TEST_PASS();
+        test_curr->is_fatal_cb = NULL;
+}
+
+/**
+ * @brief Opaque for do_test_list_offsets_leader_change.
+ */
+typedef struct do_test_list_offsets_leader_change_s {
+        rd_kafka_mock_cluster_t *mcluster;
+        const char *topic;
+        int msg_cnt;
+        int variation;
+} do_test_list_offsets_leader_change_t;
+
+/**
+ * @brief Rebalance callback for do_test_list_offsets_leader_change.
+ */
+static void do_test_list_offsets_leader_change_rebalance_cb(
+    rd_kafka_t *rk,
+    rd_kafka_resp_err_t err,
+    rd_kafka_topic_partition_list_t *partitions,
+    void *opaque) {
+        TEST_SAY("Rebalance callback: %s with %d partition(s)\n",
+                 rd_kafka_err2str(err), partitions->cnt);
+        do_test_list_offsets_leader_change_t *test = opaque;
+        switch (err) {
+        case RD_KAFKA_RESP_ERR__ASSIGN_PARTITIONS: {
+                int retries = 0;
+                int64_t low, high;
+                rd_kafka_resp_err_t list_offsets_err =
+                    RD_KAFKA_RESP_ERR_NO_ERROR;
+
+                TEST_ASSERT(partitions->cnt == 1,
+                            "Expected 1 assigned partition, got %d",
+                            partitions->cnt);
+
+                /* Change leader to 2 */
+                rd_kafka_mock_partition_set_leader(test->mcluster, test->topic,
+                                                   0, 2);
+
+                do {
+                        /* Set a wrong leader epoch that should not be used
+                         * for listing offsets. */
+                        rd_kafka_topic_partition_set_leader_epoch(
+                            &partitions->elems[0], 1234);
+
+                        if (test->variation == 0) {
+                                partitions->elems[0].offset = 1;
+                                list_offsets_err = rd_kafka_offsets_for_times(
+                                    rk, partitions, 1000);
+                        } else {
+                                list_offsets_err =
+                                    rd_kafka_query_watermark_offsets(
+                                        rk, partitions->elems[0].topic,
+                                        partitions->elems[0].partition, &low,
+                                        &high, 1000);
+                        }
+                        retries++;
+                        if (retries == 1) {
+                                TEST_ASSERT(
+                                    list_offsets_err ==
+                                        RD_KAFKA_RESP_ERR_NOT_LEADER_FOR_PARTITION,
+                                    "Expected NOT_LEADER_FOR_PARTITION, got %s",
+                                    rd_kafka_err2str(list_offsets_err));
+                        }
+                        if (retries > 2)
+                                TEST_FAIL(
+                                    "Offsets for times failed %d times "
+                                    " during the rebalance callback",
+                                    retries);
+                } while (list_offsets_err != RD_KAFKA_RESP_ERR_NO_ERROR);
+
+                TEST_ASSERT(retries == 2,
+                            "There must be exactly 2 retries, "
+                            "got %d",
+                            retries);
+
+
+                if (test->variation == 0) {
+                        /* Mock handler currently returns
+                         * RD_KAFKA_OFFSET_SPEC_LATEST
+                         * in the offsets for times case */
+                        TEST_ASSERT(partitions->elems[0].offset ==
+                                        RD_KAFKA_OFFSET_SPEC_LATEST,
+                                    "Expected offset for times LATEST,"
+                                    " got %" PRId64,
+                                    partitions->elems[0].offset);
+                } else {
+                        TEST_ASSERT(0 == low,
+                                    "Expected low offset 0"
+                                    ", got %" PRId64,
+                                    low);
+                        TEST_ASSERT(10 == high,
+                                    "Expected high offset 10"
+                                    ", got %" PRId64,
+                                    high);
+                        partitions->elems[0].offset = high;
+                }
+
+                test_consumer_assign_by_rebalance_protocol("rebalance", rk,
+                                                           partitions);
+
+                break;
+        }
+        case RD_KAFKA_RESP_ERR__REVOKE_PARTITIONS:
+                test_consumer_unassign_by_rebalance_protocol("rebalance", rk,
+                                                             partitions);
+                break;
+        default:
+                break;
+        }
+}
+
+/**
+ * @brief Test that listing offsets during a leader change works as expected.
+ *        by returning a NOT_LEADER_FOR_PARTITION error and clearing the cache.
+ *
+ *        There are two variations:
+ *        - variation 0: uses rd_kafka_offsets_for_times
+ *        - variation 1: uses rd_kafka_query_watermark_offsets
+ */
+static void do_test_list_offsets_leader_change(int variation) {
+        const char *topic      = test_mk_topic_name(__FUNCTION__, 1);
+        const char *c1_groupid = topic;
+        rd_kafka_t *c1;
+        const char *bootstraps;
+        rd_kafka_mock_cluster_t *mcluster;
+        int msg_cnt     = 10;
+        uint64_t testid = test_id_generate();
+        rd_kafka_conf_t *conf;
+        do_test_list_offsets_leader_change_t opaque;
+
+        SUB_TEST_QUICK("%s", variation == 0 ? "offsets_for_times"
+                                            : "query_watermark_offsets");
+
+        mcluster = test_mock_cluster_new(2, &bootstraps);
+        rd_kafka_mock_topic_create(mcluster, topic, 1, 2);
+        rd_kafka_mock_partition_set_leader(mcluster, topic, 0, 1);
+
+        /* Seed the topic with messages */
+        test_produce_msgs_easy_v(topic, testid, 0, 0, msg_cnt, 10,
+                                 "bootstrap.servers", bootstraps, NULL);
+
+        test_conf_init(&conf, NULL, 60);
+        test_conf_set(conf, "bootstrap.servers", bootstraps);
+        test_conf_set(conf, "auto.offset.reset", "earliest");
+        rd_kafka_conf_set_rebalance_cb(
+            conf, do_test_list_offsets_leader_change_rebalance_cb);
+        opaque.mcluster  = mcluster;
+        opaque.topic     = topic;
+        opaque.msg_cnt   = msg_cnt;
+        opaque.variation = variation;
+        rd_kafka_conf_set_opaque(conf, &opaque);
+
+        c1 = test_create_consumer(c1_groupid, NULL, conf, NULL);
+        test_consumer_subscribe(c1, topic);
+
+        /* Consumes no messages if assignment starts from
+         * latest as set in the rebalance callback,
+         * otherwise it's configured as earliest. */
+        test_consumer_poll_no_msgs("MSG_INIT", c1, testid, 5000);
+
+        rd_kafka_destroy(c1);
+
+        test_mock_cluster_destroy(mcluster);
+
+        TEST_LATER_CHECK();
+        SUB_TEST_PASS();
+}
 
 int main_0139_offset_validation_mock(int argc, char **argv) {
 
@@ -438,5 +937,14 @@ int main_0139_offset_validation_mock(int argc, char **argv) {
 
         do_test_store_offset_without_leader_epoch();
 
+        do_test_leader_change_no_validation(0);
+        do_test_leader_change_no_validation(1);
+
+        do_test_leader_change_from_internal_broker(0);
+        do_test_leader_change_from_internal_broker(1);
+
+        do_test_list_offsets_leader_change(0);
+        do_test_list_offsets_leader_change(1);
+
         return 0;
 }

package/deps/librdkafka/tests/0140-commit_metadata.cpp

@@ -54,7 +54,7 @@ static void test_commit_metadata() {
   delete conf;
 
   Test::Say("Create topic.\n");
-  Test::create_topic(consumer, topic.c_str(), 1, 1);
+  Test::create_topic_wait_exists(consumer, topic.c_str(), 1, 1, 5000);
 
   Test::Say("Commit offsets.\n");
   std::vector<RdKafka::TopicPartition *> offsets;

package/deps/librdkafka/tests/0142-reauthentication.c

@@ -83,6 +83,7 @@ void do_test_producer(int64_t reauth_time, const char *topic) {
 
         rk  = test_create_handle(RD_KAFKA_PRODUCER, conf);
         rkt = test_create_producer_topic(rk, topic, NULL);
+        test_wait_topic_exists(rk, topic, 5000);
 
         /* Create the topic to make sure connections are up and ready. */
         err = test_auto_create_topic_rkt(rk, rkt, tmout_multip(5000));
@@ -129,7 +130,7 @@ void do_test_consumer(int64_t reauth_time, const char *topic) {
 
         p1 = test_create_handle(RD_KAFKA_PRODUCER, rd_kafka_conf_dup(conf));
 
-        test_create_topic(p1, topic, 1, 3);
+        test_create_topic_wait_exists(p1, topic, 1, 3, 5000);
         TEST_SAY("Topic: %s is created\n", topic);
 
         test_conf_set(conf, "auto.offset.reset", "earliest");
@@ -207,6 +208,7 @@ void do_test_txn_producer(int64_t reauth_time,
 
         rk  = test_create_handle(RD_KAFKA_PRODUCER, conf);
         rkt = test_create_producer_topic(rk, topic, NULL);
+        test_wait_topic_exists(rk, topic, 5000);
 
         err = test_auto_create_topic_rkt(rk, rkt, tmout_multip(5000));
         TEST_ASSERT(!err, "topic creation failed: %s", rd_kafka_err2str(err));
@@ -268,7 +270,7 @@ void do_test_oauthbearer(int64_t reauth_time,
         rd_kafka_t *rk        = NULL;
         uint64_t testid       = test_id_generate();
         rd_kafka_resp_err_t err;
-        char *mechanism;
+        char *mechanism, *oauthbearer_method;
         int msgrate, msgcnt, sent_msg;
         test_timing_t t_produce;
         int token_lifetime_s = token_lifetime_ms / 1000;
@@ -290,11 +292,16 @@ void do_test_oauthbearer(int64_t reauth_time,
                     mechanism);
         }
 
-        test_conf_set(
-            conf, "sasl.oauthbearer.config",
-            tsprintf("principal=admin scope=requiredScope lifeSeconds=%d",
-                     token_lifetime_s));
-        test_conf_set(conf, "enable.sasl.oauthbearer.unsecure.jwt", "true");
+        oauthbearer_method = test_conf_get(conf, "sasl.oauthbearer.method");
+        if (rd_strcasecmp(oauthbearer_method, "oidc")) {
+                test_conf_set(
+                    conf, "sasl.oauthbearer.config",
+                    tsprintf(
+                        "principal=admin scope=requiredScope lifeSeconds=%d",
+                        token_lifetime_s));
+                test_conf_set(conf, "enable.sasl.oauthbearer.unsecure.jwt",
+                              "true");
+        }
         rk = test_create_handle(RD_KAFKA_PRODUCER, conf);
 
         /* Enable to background queue since we don't want to poll the SASL
@@ -303,6 +310,7 @@ void do_test_oauthbearer(int64_t reauth_time,
                 rd_kafka_sasl_background_callbacks_enable(rk);
 
         rkt = test_create_producer_topic(rk, topic, NULL);
+        test_wait_topic_exists(rk, topic, 5000);
 
         /* Create the topic to make sure connections are up and ready. */
         err = test_auto_create_topic_rkt(rk, rkt, tmout_multip(5000));
@@ -372,6 +380,7 @@ void do_test_reauth_failure(int64_t reauth_time, const char *topic) {
 
         rk  = test_create_handle(RD_KAFKA_PRODUCER, conf);
         rkt = test_create_producer_topic(rk, topic, NULL);
+        test_wait_topic_exists(rk, topic, 5000);
 
         /* Create the topic to make sure connections are up and ready. */
         err = test_auto_create_topic_rkt(rk, rkt, tmout_multip(5000));
@@ -403,7 +412,9 @@ int main_0142_reauthentication(int argc, char **argv) {
         size_t broker_id_cnt;
         int32_t *broker_ids   = NULL;
         rd_kafka_conf_t *conf = NULL;
-        const char *security_protocol, *sasl_mechanism;
+        const char *security_protocol;
+        rd_bool_t sasl_mechanism_oauthbearer = rd_false;
+        rd_bool_t oauthbearer_method_default = rd_false;
 
         size_t i;
         int64_t reauth_time = INT64_MAX;
@@ -419,8 +430,11 @@ int main_0142_reauthentication(int argc, char **argv) {
                 return 0;
         }
 
-        sasl_mechanism = test_conf_get(NULL, "sasl.mechanism");
-        if (!rd_strcasecmp(sasl_mechanism, "oauthbearer"))
+        sasl_mechanism_oauthbearer = !rd_strcasecmp(
+            test_conf_get(NULL, "sasl.mechanism"), "oauthbearer");
+        oauthbearer_method_default = !rd_strcasecmp(
+            test_conf_get(NULL, "sasl.oauthbearer.method"), "default");
+        if (sasl_mechanism_oauthbearer && oauthbearer_method_default)
                 test_conf_set(conf, "enable.sasl.oauthbearer.unsecure.jwt",
                               "true");
 
@@ -481,13 +495,19 @@ int main_0142_reauthentication(int argc, char **argv) {
          * reauth time. */
         do_test_oauthbearer(reauth_time, topic, reauth_time / 2, rd_true);
         do_test_oauthbearer(reauth_time, topic, reauth_time / 2, rd_false);
-        /* Case when the token_lifetime is greater than the maximum reauth time
-         * configured.
-         * In this case, the broker returns the maximum reauth time configured.
-         * We don't need to recreate the token, but we need to reauthenticate
-         * using the same token. */
-        do_test_oauthbearer(reauth_time, topic, reauth_time * 2, rd_true);
-        do_test_oauthbearer(reauth_time, topic, reauth_time * 2, rd_false);
+
+        /* With OIDC the expiration time is fixed so do the testing only
+         * once. */
+        if (oauthbearer_method_default) {
+                /* Case when the token_lifetime is greater than the maximum
+                 * reauth time configured. In this case, the broker returns the
+                 * maximum reauth time configured. We don't need to recreate the
+                 * token, but we need to reauthenticate using the same token. */
+                do_test_oauthbearer(reauth_time, topic, reauth_time * 2,
+                                    rd_true);
+                do_test_oauthbearer(reauth_time, topic, reauth_time * 2,
+                                    rd_false);
+        }
 
         do_test_reauth_failure(reauth_time, topic);