@point3/node-rdkafka 3.6.0-1

package/deps/librdkafka/tests/0132-strategy_ordering.c

@@ -0,0 +1,179 @@
+/*
+ * librdkafka - Apache Kafka C library
+ *
+ * Copyright (c) 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"
+
+
+#define _PART_CNT 4
+
+static void verify_roundrobin_assignment(rd_kafka_t *c[]) {
+        rd_kafka_topic_partition_list_t *assignment1;
+        rd_kafka_topic_partition_list_t *assignment2;
+
+        TEST_CALL_ERR__(rd_kafka_assignment(c[0], &assignment1));
+
+        TEST_ASSERT(assignment1->cnt == _PART_CNT / 2,
+                    "Roundrobin: Assignment partitions for %s"
+                    "is %d, but the expected is %d\n",
+                    rd_kafka_name(c[0]), assignment1->cnt, _PART_CNT / 2);
+
+        TEST_ASSERT(assignment1->elems[0].partition == 0,
+                    "Roundrobin: First assignment partition for %s"
+                    "is %d, but the expectation is %d\n",
+                    rd_kafka_name(c[0]), assignment1->elems[0].partition, 0);
+        TEST_ASSERT(assignment1->elems[1].partition == 2,
+                    "Roundrobin: Second assignment partition for %s"
+                    "is %d, but the expectation is %d\n",
+                    rd_kafka_name(c[0]), assignment1->elems[1].partition, 2);
+
+        TEST_CALL_ERR__(rd_kafka_assignment(c[1], &assignment2));
+        TEST_ASSERT(assignment2->cnt == _PART_CNT / 2,
+                    "Roundrobin: Assignment partitions for %s"
+                    "is %d, but the expected is %d\n",
+                    rd_kafka_name(c[1]), assignment2->cnt, _PART_CNT / 2);
+
+        TEST_ASSERT(assignment2->elems[0].partition == 1,
+                    "Roundrobin: First assignment partition for %s"
+                    "is %d, but the expectation is %d\n",
+                    rd_kafka_name(c[1]), assignment2->elems[0].partition, 1);
+        TEST_ASSERT(assignment2->elems[1].partition == 3,
+                    "Roundrobin: Second assignment partition for %s"
+                    "is %d, but the expectation is %d\n",
+                    rd_kafka_name(c[1]), assignment2->elems[1].partition, 3);
+
+        rd_kafka_topic_partition_list_destroy(assignment1);
+        rd_kafka_topic_partition_list_destroy(assignment2);
+}
+
+static void verify_range_assignment(rd_kafka_t *c[]) {
+        rd_kafka_topic_partition_list_t *assignment1;
+        rd_kafka_topic_partition_list_t *assignment2;
+
+        TEST_CALL_ERR__(rd_kafka_assignment(c[0], &assignment1));
+
+        TEST_ASSERT(assignment1->cnt == _PART_CNT / 2,
+                    "Range: Assignment partition for %s"
+                    "is %d, but the expected is %d\n",
+                    rd_kafka_name(c[0]), assignment1->cnt, _PART_CNT / 2);
+
+        TEST_ASSERT(assignment1->elems[0].partition == 0,
+                    "Range: First assignment partition for %s"
+                    "is %d, but the expectation is %d\n",
+                    rd_kafka_name(c[0]), assignment1->elems[0].partition, 0);
+        TEST_ASSERT(assignment1->elems[1].partition == 1,
+                    "Range: Second assignment partition for %s"
+                    "is %d, but the expectation is %d\n",
+                    rd_kafka_name(c[0]), assignment1->elems[1].partition, 1);
+
+        TEST_CALL_ERR__(rd_kafka_assignment(c[1], &assignment2));
+        TEST_ASSERT(assignment2->cnt == _PART_CNT / 2,
+                    "Range: Assignment partition for %s"
+                    "is %d, but the expected is %d\n",
+                    rd_kafka_name(c[1]), assignment2->cnt, _PART_CNT / 2);
+
+        TEST_ASSERT(assignment2->elems[0].partition == 2,
+                    "Range: First assignment partition for %s"
+                    "is %d, but the expectation is %d\n",
+                    rd_kafka_name(c[1]), assignment2->elems[0].partition, 2);
+        TEST_ASSERT(assignment2->elems[1].partition == 3,
+                    "Range: Second assignment partition for %s"
+                    "is %d, but the expectation is %d\n",
+                    rd_kafka_name(c[1]), assignment2->elems[1].partition, 3);
+
+        rd_kafka_topic_partition_list_destroy(assignment1);
+        rd_kafka_topic_partition_list_destroy(assignment2);
+}
+
+static void do_test_strategy_ordering(const char *assignor,
+                                      const char *expected_assignor) {
+        rd_kafka_conf_t *conf;
+#define _C_CNT 2
+        rd_kafka_t *c[_C_CNT];
+
+        const char *topic;
+        const int msgcnt = 100;
+        int i;
+        uint64_t testid;
+
+        SUB_TEST("partition.assignment.strategy = %s", assignor);
+
+        testid = test_id_generate();
+
+        topic = test_mk_topic_name("0132-strategy_ordering", 1);
+        test_create_topic_wait_exists(NULL, topic, _PART_CNT, 1, 5000);
+        test_produce_msgs_easy(topic, testid, RD_KAFKA_PARTITION_UA, msgcnt);
+
+        test_conf_init(&conf, NULL, 30);
+        test_conf_set(conf, "partition.assignment.strategy", assignor);
+
+        for (i = 0; i < _C_CNT; i++) {
+                char name[16];
+
+                rd_snprintf(name, sizeof(name), "c%d", i);
+                test_conf_set(conf, "client.id", name);
+
+                c[i] = test_create_consumer(assignor, NULL,
+                                            rd_kafka_conf_dup(conf), NULL);
+
+                test_consumer_subscribe(c[i], topic);
+        }
+
+        rd_kafka_conf_destroy(conf);
+
+        /* Await assignments for all consumers */
+        for (i = 0; i < _C_CNT; i++) {
+                test_consumer_wait_assignment(c[i], rd_true);
+        }
+
+        if (!strcmp(expected_assignor, "range"))
+                verify_range_assignment(c);
+        else
+                verify_roundrobin_assignment(c);
+
+        for (i = 0; i < _C_CNT; i++) {
+                test_consumer_close(c[i]);
+                rd_kafka_destroy(c[i]);
+        }
+
+        SUB_TEST_PASS();
+}
+
+
+int main_0132_strategy_ordering(int argc, char **argv) {
+        if (!test_consumer_group_protocol_classic()) {
+                TEST_SKIP(
+                    "Test meaningful only with classic librdkafka"
+                    " assignors\n");
+                return 0;
+        }
+
+        do_test_strategy_ordering("roundrobin,range", "roundrobin");
+        do_test_strategy_ordering("range,roundrobin", "range");
+
+        return 0;
+}

package/deps/librdkafka/tests/0133-ssl_keys.c

@@ -0,0 +1,150 @@
+/*
+ * librdkafka - Apache Kafka C library
+ *
+ * Copyright (c) 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"
+#include "rdstring.h"
+
+/**
+ * @brief Tests reading SSL PKCS#12 keystore or PEM certificate and key from
+ * file. Decoding it with the correct password or not.
+ *
+ * Ensures it's read correctly on Windows too.
+ * See https://github.com/confluentinc/librdkafka/issues/3992
+ */
+static void do_test_ssl_keys(const char *type, rd_bool_t correct_password) {
+#define TEST_FIXTURES_FOLDER            "./fixtures"
+#define TEST_FIXTURES_SSL_FOLDER        TEST_FIXTURES_FOLDER "/ssl/"
+#define TEST_FIXTURES_KEYSTORE_PASSWORD "use_strong_password_keystore_client"
+#define TEST_FIXTURES_KEY_PASSWORD      "use_strong_password_keystore_client2"
+#define TEST_KEYSTORE_LOCATION          TEST_FIXTURES_SSL_FOLDER "client.keystore.p12"
+#define TEST_CERTIFICATE_LOCATION                                              \
+        TEST_FIXTURES_SSL_FOLDER "client2.certificate.pem"
+#define TEST_KEY_LOCATION TEST_FIXTURES_SSL_FOLDER "client2.key"
+
+        rd_kafka_conf_t *conf;
+        rd_kafka_t *rk;
+        char errstr[256];
+
+        SUB_TEST_QUICK("keystore type = %s, correct password = %s", type,
+                       RD_STR_ToF(correct_password));
+
+        /* Don't use test_conf_init otherwise
+         * key file configuration value conflicts
+         * with PEM string configuration,
+         * when running in --ssl mode. */
+        conf = rd_kafka_conf_new();
+        test_conf_set(conf, "security.protocol", "SSL");
+
+        if (!strcmp(type, "PKCS12")) {
+                test_conf_set(conf, "ssl.keystore.location",
+                              TEST_KEYSTORE_LOCATION);
+                if (correct_password)
+                        test_conf_set(conf, "ssl.keystore.password",
+                                      TEST_FIXTURES_KEYSTORE_PASSWORD);
+                else
+                        test_conf_set(conf, "ssl.keystore.password",
+                                      TEST_FIXTURES_KEYSTORE_PASSWORD
+                                      " and more");
+        } else if (!strcmp(type, "PEM")) {
+                test_conf_set(conf, "ssl.certificate.location",
+                              TEST_CERTIFICATE_LOCATION);
+                test_conf_set(conf, "ssl.key.location", TEST_KEY_LOCATION);
+                if (correct_password)
+                        test_conf_set(conf, "ssl.key.password",
+                                      TEST_FIXTURES_KEY_PASSWORD);
+                else
+                        test_conf_set(conf, "ssl.key.password",
+                                      TEST_FIXTURES_KEY_PASSWORD " and more");
+        } else if (!strcmp(type, "PEM_STRING")) {
+                char buf[1024 * 50];
+                if (!test_read_file(TEST_CERTIFICATE_LOCATION, buf,
+                                    sizeof(buf)))
+                        TEST_FAIL("Failed to read certificate file\n");
+                test_conf_set(conf, "ssl.certificate.pem", buf);
+
+                if (!test_read_file(TEST_KEY_LOCATION, buf, sizeof(buf)))
+                        TEST_FAIL("Failed to read key file\n");
+                test_conf_set(conf, "ssl.key.pem", buf);
+
+                if (correct_password)
+                        test_conf_set(conf, "ssl.key.password",
+                                      TEST_FIXTURES_KEY_PASSWORD);
+                else
+                        test_conf_set(conf, "ssl.key.password",
+                                      TEST_FIXTURES_KEY_PASSWORD " and more");
+        } else {
+                TEST_FAIL("Unexpected key type\n");
+        }
+
+        rk = rd_kafka_new(RD_KAFKA_PRODUCER, conf, errstr, sizeof(errstr));
+        if ((rk != NULL) != correct_password) {
+                TEST_FAIL("Expected rd_kafka creation to %s: %s\n",
+                          correct_password ? "succeed" : "fail", errstr);
+        }
+
+        if (rk)
+                rd_kafka_destroy(rk);
+        else
+                rd_kafka_conf_destroy(conf);
+
+        SUB_TEST_PASS();
+
+#undef TEST_FIXTURES_KEYSTORE_PASSWORD
+#undef TEST_FIXTURES_KEY_PASSWORD
+#undef TEST_KEYSTORE_LOCATION
+#undef TEST_CERTIFICATE_LOCATION
+#undef TEST_KEY_LOCATION
+#undef TEST_FIXTURES_FOLDER
+#undef TEST_FIXTURES_SSL_FOLDER
+}
+
+
+int main_0133_ssl_keys(int argc, char **argv) {
+        rd_kafka_conf_t *conf;
+        char errstr[512];
+        rd_kafka_conf_res_t res;
+
+        test_conf_init(&conf, NULL, 10);
+
+        /* Check that we're linked/built with OpenSSL 3.x */
+        res = rd_kafka_conf_set(conf, "ssl.providers", "a,b", errstr,
+                                sizeof(errstr));
+        rd_kafka_conf_destroy(conf);
+        if (res == RD_KAFKA_CONF_INVALID) {
+                TEST_SKIP("%s\n", errstr);
+                return 0;
+        }
+
+        do_test_ssl_keys("PKCS12", rd_true);
+        do_test_ssl_keys("PKCS12", rd_false);
+        do_test_ssl_keys("PEM", rd_true);
+        do_test_ssl_keys("PEM", rd_false);
+        do_test_ssl_keys("PEM_STRING", rd_true);
+        do_test_ssl_keys("PEM_STRING", rd_false);
+        return 0;
+}

package/deps/librdkafka/tests/0134-ssl_provider.c

@@ -0,0 +1,92 @@
+/*
+ * librdkafka - Apache Kafka C library
+ *
+ * Copyright (c) 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"
+
+
+static void test_providers(const char *providers,
+                           rd_bool_t must_pass,
+                           rd_bool_t must_fail) {
+        rd_kafka_conf_t *conf;
+        rd_kafka_t *rk;
+        char errstr[512];
+
+        SUB_TEST_QUICK("providers=%s, %s pass, %s fail", providers,
+                       must_pass ? "must" : "may", must_fail ? "must" : "may");
+
+        test_conf_init(&conf, NULL, 10);
+
+        /* Enable debugging so we get some extra information on
+         * OpenSSL version and provider versions in the test log. */
+        test_conf_set(conf, "debug", "security");
+        test_conf_set(conf, "ssl.providers", providers);
+        test_conf_set(conf, "security.protocol", "ssl");
+
+        rk = rd_kafka_new(RD_KAFKA_PRODUCER, conf, errstr, sizeof(errstr));
+
+        TEST_SAY("rd_kafka_new(ssl.providers=%s): %s\n", providers,
+                 rk ? "success" : errstr);
+
+        if (must_pass && !rk)
+                TEST_FAIL("Expected ssl.providers=%s to work, got %s",
+                          providers, errstr);
+        else if (must_fail && rk)
+                TEST_FAIL("Expected ssl.providers=%s to fail", providers);
+
+        if (!rk)
+                rd_kafka_conf_destroy(conf);
+        else
+                rd_kafka_destroy(rk);
+
+        SUB_TEST_PASS();
+}
+
+int main_0134_ssl_provider(int argc, char **argv) {
+        rd_kafka_conf_t *conf;
+        char errstr[512];
+        rd_kafka_conf_res_t res;
+
+        test_conf_init(&conf, NULL, 10);
+
+        /* Check that we're linked/built with OpenSSL 3.x */
+        res = rd_kafka_conf_set(conf, "ssl.providers", "a,b", errstr,
+                                sizeof(errstr));
+        rd_kafka_conf_destroy(conf);
+        if (res == RD_KAFKA_CONF_INVALID) {
+                TEST_SKIP("%s\n", errstr);
+                return 0;
+        }
+
+        /* Must pass since 'default' is always built in */
+        test_providers("default", rd_true, rd_false);
+        /* May fail, if legacy provider is not available. */
+        test_providers("default,legacy", rd_false, rd_false);
+        /* Must fail since non-existent provider */
+        test_providers("default,thisProviderDoesNotExist", rd_false, rd_true);
+        return 0;
+}

package/deps/librdkafka/tests/0135-sasl_credentials.cpp

@@ -0,0 +1,143 @@
+/*
+ * librdkafka - Apache Kafka C library
+ *
+ * Copyright (c) 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 SASL credentials can be updated.
+ */
+#include "testcpp.h"
+
+
+
+class authErrorEventCb : public RdKafka::EventCb {
+ public:
+  authErrorEventCb() : error_seen(false) {
+  }
+
+  void event_cb(RdKafka::Event &event) {
+    switch (event.type()) {
+    case RdKafka::Event::EVENT_ERROR:
+      Test::Say(tostr() << "Error: " << RdKafka::err2str(event.err()) << ": "
+                        << event.str() << "\n");
+      if (event.err() == RdKafka::ERR__AUTHENTICATION)
+        error_seen = true;
+      break;
+
+    case RdKafka::Event::EVENT_LOG:
+      Test::Say(tostr() << "Log: " << event.str() << "\n");
+      break;
+
+    default:
+      break;
+    }
+  }
+
+  bool error_seen;
+};
+
+
+/**
+ * @brief Test setting SASL credentials.
+ *
+ * 1. Switch out the proper username/password for invalid ones.
+ * 2. Verify that we get an auth failure.
+ * 3. Set the proper username/passwords.
+ * 4. Verify that we can now connect.
+ */
+static void do_test(bool set_after_auth_failure) {
+  RdKafka::Conf *conf;
+  Test::conf_init(&conf, NULL, 30);
+
+  SUB_TEST_QUICK("set_after_auth_failure=%s",
+                 set_after_auth_failure ? "yes" : "no");
+
+  /* Get the correct sasl.username and sasl.password */
+  std::string username, password;
+  if (conf->get("sasl.username", username) ||
+      conf->get("sasl.password", password)) {
+    delete conf;
+    SUB_TEST_SKIP("sasl.username and/or sasl.password not configured\n");
+    return;
+  }
+
+  /* Replace with incorrect ones */
+  Test::conf_set(conf, "sasl.username", "ThisIsNotRight");
+  Test::conf_set(conf, "sasl.password", "Neither Is This");
+
+  /* Set up an event callback to track authentication errors */
+  authErrorEventCb pEvent = authErrorEventCb();
+  std::string errstr;
+  if (conf->set("event_cb", &pEvent, errstr) != RdKafka::Conf::CONF_OK)
+    Test::Fail(errstr);
+
+  /* Create client */
+  RdKafka::Producer *p = RdKafka::Producer::create(conf, errstr);
+  if (!p)
+    Test::Fail("Failed to create Producer: " + errstr);
+  delete conf;
+
+  if (set_after_auth_failure) {
+    Test::Say("Awaiting auth failure\n");
+
+    while (!pEvent.error_seen)
+      p->poll(1000);
+
+    Test::Say("Authentication error seen\n");
+  }
+
+  Test::Say("Setting proper credentials\n");
+  RdKafka::Error *error = p->sasl_set_credentials(username, password);
+  if (error)
+    Test::Fail("Failed to set credentials: " + error->str());
+
+  Test::Say("Expecting successful cluster authentication\n");
+  const std::string clusterid = p->clusterid(5 * 1000);
+
+  if (clusterid.empty())
+    Test::Fail("Expected clusterid() to succeed");
+
+  delete p;
+
+  SUB_TEST_PASS();
+}
+
+extern "C" {
+int main_0135_sasl_credentials(int argc, char **argv) {
+  const char *mech = test_conf_get(NULL, "sasl.mechanism");
+
+  if (strcmp(mech, "PLAIN") && strncmp(mech, "SCRAM", 5)) {
+    Test::Skip("Test requires SASL PLAIN or SASL SCRAM\n");
+    return 0;
+  }
+
+  do_test(false);
+  do_test(true);
+
+  return 0;
+}
+}