@platformatic/rdkafka 4.0.0

package/deps/librdkafka/tests/0125-immediate_flush.c

@@ -0,0 +1,144 @@
+/*
+ * librdkafka - Apache Kafka C library
+ *
+ * Copyright (c) 2012-2022, Magnus Edenhill
+ *               2023, Confluent Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "test.h"
+
+
+/**
+ * Verify that flush() overrides the linger.ms time.
+ *
+ */
+void do_test_flush_overrides_linger_ms_time() {
+        rd_kafka_t *rk;
+        rd_kafka_conf_t *conf;
+        const char *topic = test_mk_topic_name("0125_immediate_flush", 1);
+        const int msgcnt  = 100;
+        int remains       = 0;
+        test_timing_t t_time;
+
+        test_conf_init(&conf, NULL, 30);
+
+        test_conf_set(conf, "linger.ms", "10000");
+        rd_kafka_conf_set_dr_msg_cb(conf, test_dr_msg_cb);
+        rk = test_create_handle(RD_KAFKA_PRODUCER, conf);
+
+        test_create_topic(rk, topic, 1, 1);
+
+        /* Produce half set of messages without waiting for delivery. */
+        test_produce_msgs2_nowait(rk, topic, 0, 0, 0, msgcnt / 2, NULL, 50,
+                                  &remains);
+
+        TIMING_START(&t_time, "NO_FLUSH");
+        do {
+                rd_kafka_poll(rk, 1000);
+        } while (remains > 0);
+        TIMING_ASSERT(&t_time, 10000, 15000);
+
+        /* Produce remaining messages without waiting for delivery. */
+        test_produce_msgs2_nowait(rk, topic, 0, 0, 0, msgcnt / 2, NULL, 50,
+                                  &remains);
+
+        /* The linger time should be overriden when flushing */
+        TIMING_START(&t_time, "FLUSH");
+        TEST_CALL_ERR__(rd_kafka_flush(rk, 2000));
+        TIMING_ASSERT(&t_time, 0, 2500);
+
+        rd_kafka_destroy(rk);
+
+
+        /* Verify messages were actually produced by consuming them back. */
+        test_consume_msgs_easy(topic, topic, 0, 1, msgcnt, NULL);
+}
+
+/**
+ * @brief Tests if the first metadata call is able to update leader for the
+ * topic or not. If it is not able to update the leader for some partitions,
+ * flush call waits for 1s to refresh the leader and then flush is completed.
+ * Ideally, it should update in the first call itself.
+ *
+ * Number of brokers in the cluster should be more than the number of
+ * brokers in the bootstrap.servers list for this test case to work correctly
+ *
+ */
+void do_test_first_flush_immediate() {
+        rd_kafka_mock_cluster_t *mock_cluster;
+        rd_kafka_t *produce_rk;
+        const char *brokers;
+        char *bootstrap_server;
+        test_timing_t t_time;
+        size_t i;
+        rd_kafka_conf_t *conf = NULL;
+        const char *topic     = test_mk_topic_name("0125_immediate_flush", 1);
+        size_t partition_cnt  = 9;
+        int remains           = 0;
+
+        mock_cluster = test_mock_cluster_new(3, &brokers);
+
+        for (i = 0; brokers[i]; i++)
+                if (brokers[i] == ',' || brokers[i] == ' ')
+                        break;
+        bootstrap_server = rd_strndup(brokers, i);
+
+        test_conf_init(&conf, NULL, 30);
+        rd_kafka_conf_set_dr_msg_cb(conf, test_dr_msg_cb);
+        test_conf_set(conf, "bootstrap.servers", bootstrap_server);
+        free(bootstrap_server);
+
+        rd_kafka_mock_topic_create(mock_cluster, topic, partition_cnt, 1);
+
+        produce_rk = test_create_handle(RD_KAFKA_PRODUCER, conf);
+
+        for (i = 0; i < partition_cnt; i++) {
+                test_produce_msgs2_nowait(produce_rk, topic, 0, i, 0, 1, NULL,
+                                          0, &remains);
+        }
+
+        TIMING_START(&t_time, "FLUSH");
+        TEST_CALL_ERR__(rd_kafka_flush(produce_rk, 5000));
+        TIMING_ASSERT(&t_time, 0, 999);
+
+        rd_kafka_destroy(produce_rk);
+        test_mock_cluster_destroy(mock_cluster);
+}
+
+int main_0125_immediate_flush(int argc, char **argv) {
+
+        do_test_flush_overrides_linger_ms_time();
+
+        return 0;
+}
+
+int main_0125_immediate_flush_mock(int argc, char **argv) {
+
+        TEST_SKIP_MOCK_CLUSTER(0);
+
+        do_test_first_flush_immediate();
+
+        return 0;
+}

package/deps/librdkafka/tests/0126-oauthbearer_oidc.c

@@ -0,0 +1,213 @@
+/*
+ * librdkafka - Apache Kafka C library
+ *
+ * Copyright (c) 2021-2022, Magnus Edenhill
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "test.h"
+/* Typical include path would be <librdkafka/rdkafka.h>, but this program
+ * is built from within the librdkafka source tree and thus differs. */
+#include "rdkafka.h" /* for Kafka driver */
+
+static rd_bool_t error_seen;
+/**
+ * @brief After config OIDC, make sure the producer and consumer
+ *        can work successfully.
+ *
+ */
+static void
+do_test_produce_consumer_with_OIDC(const rd_kafka_conf_t *base_conf) {
+        const char *topic;
+        uint64_t testid;
+        rd_kafka_t *p1;
+        rd_kafka_t *c1;
+        rd_kafka_conf_t *conf;
+
+        const char *url = test_getenv("VALID_OIDC_URL", NULL);
+
+        SUB_TEST("Test producer and consumer with oidc configuration");
+
+        if (!url) {
+                SUB_TEST_SKIP(
+                    "VALID_OIDC_URL environment variable is not set\n");
+                return;
+        }
+
+        conf = rd_kafka_conf_dup(base_conf);
+        test_conf_set(conf, "sasl.oauthbearer.token.endpoint.url", url);
+
+        testid = test_id_generate();
+
+        rd_kafka_conf_set_dr_msg_cb(conf, test_dr_msg_cb);
+
+        p1 = test_create_handle(RD_KAFKA_PRODUCER, rd_kafka_conf_dup(conf));
+
+        topic = test_mk_topic_name("0126-oauthbearer_oidc", 1);
+        test_create_topic(p1, topic, 1, 3);
+        TEST_SAY("Topic: %s is created\n", topic);
+
+        test_produce_msgs2(p1, topic, testid, 0, 0, 1, NULL, 0);
+
+        test_conf_set(conf, "auto.offset.reset", "earliest");
+        c1 = test_create_consumer(topic, NULL, rd_kafka_conf_dup(conf), NULL);
+        test_consumer_subscribe(c1, topic);
+
+        /* Give it some time to trigger the token refresh. */
+        rd_usleep(5 * 1000 * 1000, NULL);
+        test_consumer_poll("OIDC.C1", c1, testid, 1, -1, 1, NULL);
+
+        test_consumer_close(c1);
+
+        rd_kafka_destroy(p1);
+        rd_kafka_destroy(c1);
+        SUB_TEST_PASS();
+}
+
+
+static void
+auth_error_cb(rd_kafka_t *rk, int err, const char *reason, void *opaque) {
+        if (err == RD_KAFKA_RESP_ERR__AUTHENTICATION ||
+            err == RD_KAFKA_RESP_ERR__ALL_BROKERS_DOWN) {
+                TEST_SAY("Expected error: %s: %s\n", rd_kafka_err2str(err),
+                         reason);
+                error_seen = rd_true;
+        } else
+                TEST_FAIL("Unexpected error: %s: %s", rd_kafka_err2str(err),
+                          reason);
+        rd_kafka_yield(rk);
+}
+
+
+/**
+ * @brief After config OIDC, if the token is expired, make sure
+ *        the authentication fail as expected.
+ *
+ */
+static void do_test_produce_consumer_with_OIDC_expired_token_should_fail(
+    const rd_kafka_conf_t *base_conf) {
+        rd_kafka_t *c1;
+        uint64_t testid;
+        rd_kafka_conf_t *conf;
+
+        const char *expired_url = test_getenv("EXPIRED_TOKEN_OIDC_URL", NULL);
+
+        SUB_TEST("Test OAUTHBEARER/OIDC failing with expired JWT");
+
+        if (!expired_url) {
+                SUB_TEST_SKIP(
+                    "EXPIRED_TOKEN_OIDC_URL environment variable is not set\n");
+                return;
+        }
+
+        conf = rd_kafka_conf_dup(base_conf);
+
+        error_seen = rd_false;
+        test_conf_set(conf, "sasl.oauthbearer.token.endpoint.url", expired_url);
+
+        rd_kafka_conf_set_error_cb(conf, auth_error_cb);
+
+        testid = test_id_generate();
+
+        c1 = test_create_consumer("OIDC.fail.C1", NULL, conf, NULL);
+
+        test_consumer_poll_no_msgs("OIDC.fail.C1", c1, testid, 10 * 1000);
+        TEST_ASSERT(error_seen);
+
+        test_consumer_close(c1);
+        rd_kafka_destroy(c1);
+        SUB_TEST_PASS();
+}
+
+
+/**
+ * @brief After config OIDC, if the token is not valid, make sure the
+ *        authentication fail as expected.
+ *
+ */
+static void do_test_produce_consumer_with_OIDC_should_fail(
+    const rd_kafka_conf_t *base_conf) {
+        rd_kafka_t *c1;
+        uint64_t testid;
+        rd_kafka_conf_t *conf;
+
+        const char *invalid_url = test_getenv("INVALID_OIDC_URL", NULL);
+
+        SUB_TEST("Test OAUTHBEARER/OIDC failing with invalid JWT");
+
+        if (!invalid_url) {
+                SUB_TEST_SKIP(
+                    "INVALID_OIDC_URL environment variable is not set\n");
+                return;
+        }
+
+        conf = rd_kafka_conf_dup(base_conf);
+
+        error_seen = rd_false;
+
+        test_conf_set(conf, "sasl.oauthbearer.token.endpoint.url", invalid_url);
+
+        rd_kafka_conf_set_error_cb(conf, auth_error_cb);
+
+        testid = test_id_generate();
+
+        c1 = test_create_consumer("OIDC.fail.C1", NULL, conf, NULL);
+
+        test_consumer_poll_no_msgs("OIDC.fail.C1", c1, testid, 10 * 1000);
+
+        TEST_ASSERT(error_seen);
+
+        test_consumer_close(c1);
+        rd_kafka_destroy(c1);
+        SUB_TEST_PASS();
+}
+
+
+int main_0126_oauthbearer_oidc(int argc, char **argv) {
+        rd_kafka_conf_t *conf;
+        const char *sec;
+        const char *oidc;
+
+        test_conf_init(&conf, NULL, 60);
+
+        sec = test_conf_get(conf, "security.protocol");
+        if (!strstr(sec, "sasl")) {
+                TEST_SKIP("Apache Kafka cluster not configured for SASL\n");
+                return 0;
+        }
+
+        oidc = test_conf_get(conf, "sasl.oauthbearer.method");
+        if (rd_strcasecmp(oidc, "OIDC")) {
+                TEST_SKIP("`sasl.oauthbearer.method=OIDC` is required\n");
+                return 0;
+        }
+
+        do_test_produce_consumer_with_OIDC(conf);
+        do_test_produce_consumer_with_OIDC_should_fail(conf);
+        do_test_produce_consumer_with_OIDC_expired_token_should_fail(conf);
+
+        rd_kafka_conf_destroy(conf);
+
+        return 0;
+}

package/deps/librdkafka/tests/0127-fetch_queue_backoff.cpp

@@ -0,0 +1,165 @@
+/*
+ * librdkafka - Apache Kafka C library
+ *
+ * Copyright (c) 2020-2022, Magnus Edenhill
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <iostream>
+#include <map>
+#include <cstring>
+#include <cstdlib>
+#include "testcpp.h"
+extern "C" {
+#include "test.h"
+}
+
+/**
+ * Test consumer fetch.queue.backoff.ms behaviour.
+ *
+ * @param backoff_ms Backoff ms to configure, -1 to rely on default one.
+ *
+ * 1. Produce N messages, 1 message per batch.
+ * 2. Configure consumer with queued.min.messages=1 and
+ *    fetch.queue.backoff.ms=<backoff_ms>
+ * 3. Verify that the consume() latency is <= fetch.queue.backoff.ms.
+ */
+
+
+static void do_test_queue_backoff(const std::string &topic, int backoff_ms) {
+  SUB_TEST("backoff_ms = %d", backoff_ms);
+
+  /* Create consumer */
+  RdKafka::Conf *conf;
+  Test::conf_init(&conf, NULL, 60);
+  Test::conf_set(conf, "group.id", topic);
+  Test::conf_set(conf, "enable.auto.commit", "false");
+  Test::conf_set(conf, "auto.offset.reset", "beginning");
+  Test::conf_set(conf, "queued.min.messages", "1");
+  if (backoff_ms >= 0) {
+    Test::conf_set(conf, "fetch.queue.backoff.ms", tostr() << backoff_ms);
+  }
+  /* Make sure to include only one message in each fetch.
+   * Message size is 10000. */
+  Test::conf_set(conf, "fetch.message.max.bytes", "12000");
+
+  if (backoff_ms < 0)
+    /* default */
+    backoff_ms = 1000;
+
+  std::string errstr;
+
+  RdKafka::KafkaConsumer *c = RdKafka::KafkaConsumer::create(conf, errstr);
+  if (!c)
+    Test::Fail("Failed to create KafkaConsumer: " + errstr);
+  delete conf;
+
+  RdKafka::TopicPartition *rktpar = RdKafka::TopicPartition::create(topic, 0);
+  std::vector<RdKafka::TopicPartition *> parts;
+  parts.push_back(rktpar);
+
+  RdKafka::ErrorCode err;
+  if ((err = c->assign(parts)))
+    Test::Fail("assigned failed: " + RdKafka::err2str(err));
+  RdKafka::TopicPartition::destroy(parts);
+
+  int received       = 0;
+  int in_profile_cnt = 0;
+  int dmax           = backoff_ms + test_timeout_multiplier * 30;
+
+  int64_t ts_consume = test_clock();
+
+  while (received < 5) {
+    /* Wait more than dmax to count out of profile messages.
+     * Different for first message, that is skipped. */
+    int consume_timeout = received == 0 ? 1500 * test_timeout_multiplier : dmax;
+    RdKafka::Message *msg = c->consume(consume_timeout);
+    if (msg->err() == RdKafka::ERR__TIMED_OUT) {
+      delete msg;
+      continue;
+    }
+
+    rd_ts_t now     = test_clock();
+    int latency     = (now - ts_consume) / 1000;
+    ts_consume      = now;
+    bool in_profile = latency <= dmax;
+
+    if (!msg)
+      Test::Fail(tostr() << "No message for " << consume_timeout << "ms");
+    if (msg->err())
+      Test::Fail("Unexpected consumer error: " + msg->errstr());
+
+    Test::Say(tostr() << "Message #" << received << " consumed in " << latency
+                      << "ms (expecting <= " << dmax << "ms)"
+                      << (received == 0 ? ": skipping first" : "")
+                      << (in_profile ? ": in profile" : ": OUT OF PROFILE")
+                      << "\n");
+
+    if (received++ > 0 && in_profile)
+      in_profile_cnt++;
+
+    delete msg;
+  }
+
+  Test::Say(tostr() << in_profile_cnt << "/" << received << " messages were "
+                    << "in profile (<= " << dmax
+                    << ") for backoff_ms=" << backoff_ms << "\n");
+
+  /* first message isn't counted*/
+  const int expected_in_profile = received - 1;
+  TEST_ASSERT(expected_in_profile - in_profile_cnt == 0,
+              "Only %d/%d messages were in profile", in_profile_cnt,
+              expected_in_profile);
+
+  delete c;
+
+  SUB_TEST_PASS();
+}
+
+
+extern "C" {
+int main_0127_fetch_queue_backoff(int argc, char **argv) {
+  std::string topic = Test::mk_topic_name("0127_fetch_queue_backoff", 1);
+
+  /* Prime the topic with messages. */
+  RdKafka::Conf *conf;
+  Test::conf_init(&conf, NULL, 10);
+  Test::conf_set(conf, "batch.num.messages", "1");
+  std::string errstr;
+  RdKafka::Producer *p = RdKafka::Producer::create(conf, errstr);
+  if (!p)
+    Test::Fail(tostr() << __FUNCTION__
+                       << ": Failed to create producer: " << errstr);
+  delete conf;
+
+  Test::produce_msgs(p, topic, 0, 100, 10000, true /*flush*/);
+  delete p;
+
+  do_test_queue_backoff(topic, -1);
+  do_test_queue_backoff(topic, 500);
+  do_test_queue_backoff(topic, 10);
+  do_test_queue_backoff(topic, 0);
+  return 0;
+}
+}

package/deps/librdkafka/tests/0128-sasl_callback_queue.cpp

@@ -0,0 +1,125 @@
+/*
+ * librdkafka - Apache Kafka C library
+ *
+ * Copyright (c) 2021-2022, Magnus Edenhill
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+
+/**
+ * Verify that background SASL callback queues work by calling
+ * a non-polling API after client creation.
+ */
+#include "testcpp.h"
+#include "rdatomic.h"
+
+namespace {
+/* Provide our own token refresh callback */
+class MyCb : public RdKafka::OAuthBearerTokenRefreshCb {
+ public:
+  MyCb() {
+    rd_atomic32_init(&called_, 0);
+  }
+
+  bool called() {
+    return rd_atomic32_get(&called_) > 0;
+  }
+
+  void oauthbearer_token_refresh_cb(RdKafka::Handle *handle,
+                                    const std::string &oauthbearer_config) {
+    handle->oauthbearer_set_token_failure(
+        "Not implemented by this test, "
+        "but that's okay");
+    rd_atomic32_add(&called_, 1);
+    Test::Say("Callback called!\n");
+  }
+
+  rd_atomic32_t called_;
+};
+};  // namespace
+
+
+static void do_test(bool use_background_queue) {
+  SUB_TEST("Use background queue = %s", use_background_queue ? "yes" : "no");
+
+  bool expect_called = use_background_queue;
+
+  RdKafka::Conf *conf = RdKafka::Conf::create(RdKafka::Conf::CONF_GLOBAL);
+
+  Test::conf_set(conf, "security.protocol", "SASL_PLAINTEXT");
+  Test::conf_set(conf, "sasl.mechanism", "OAUTHBEARER");
+
+  std::string errstr;
+
+  MyCb mycb;
+  if (conf->set("oauthbearer_token_refresh_cb", &mycb, errstr))
+    Test::Fail("Failed to set refresh callback: " + errstr);
+
+  if (use_background_queue)
+    if (conf->enable_sasl_queue(true, errstr))
+      Test::Fail("Failed to enable SASL queue: " + errstr);
+
+  RdKafka::Producer *p = RdKafka::Producer::create(conf, errstr);
+  if (!p)
+    Test::Fail("Failed to create Producer: " + errstr);
+  delete conf;
+
+  if (use_background_queue) {
+    RdKafka::Error *error = p->sasl_background_callbacks_enable();
+    if (error)
+      Test::Fail("sasl_background_callbacks_enable() failed: " + error->str());
+  }
+
+  /* This call should fail since the refresh callback fails,
+   * and there are no brokers configured anyway. */
+  const std::string clusterid = p->clusterid(5 * 1000);
+
+  TEST_ASSERT(clusterid.empty(),
+              "Expected clusterid() to fail since the token was not set");
+
+  if (expect_called)
+    TEST_ASSERT(mycb.called(),
+                "Expected refresh callback to have been called by now");
+  else
+    TEST_ASSERT(!mycb.called(),
+                "Did not expect refresh callback to have been called");
+
+  delete p;
+
+  SUB_TEST_PASS();
+}
+
+extern "C" {
+int main_0128_sasl_callback_queue(int argc, char **argv) {
+  if (!test_check_builtin("sasl_oauthbearer")) {
+    Test::Skip("Test requires OAUTHBEARER support\n");
+    return 0;
+  }
+
+  do_test(true);
+  do_test(false);
+
+  return 0;
+}
+}