@point3/node-rdkafka 3.6.0-1

package/deps/librdkafka/tests/0109-auto_create_topics.cpp

@@ -0,0 +1,278 @@
+/*
+ * 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"
+
+/**
+ * Test consumer allow.auto.create.topics by subscribing to a mix
+ * of available, unauthorized and non-existent topics.
+ *
+ * The same test is run with and without allow.auto.create.topics
+ * and with and without wildcard subscribes.
+ *
+ * With the KIP 848 consumer group protocol, topics aren't automatically
+ * created when subscribing and the topic authorization error
+ * applies to the whole subscription, not just the unauthorized topics.
+ */
+
+
+static void do_test_consumer(bool allow_auto_create_topics,
+                             bool with_wildcards,
+                             bool test_unauthorized_topic) {
+  Test::Say(tostr() << _C_MAG << "[ Test allow.auto.create.topics="
+                    << (allow_auto_create_topics ? "true" : "false")
+                    << " with_wildcards=" << (with_wildcards ? "true" : "false")
+                    << " test_unauthorized_topic="
+                    << (test_unauthorized_topic ? "true" : "false") << " ]\n");
+
+  bool has_acl_cli = test_broker_version >= TEST_BRKVER(2, 1, 0, 0) &&
+                     !test_needs_auth(); /* We can't bother passing Java
+                                          * security config to kafka-acls.sh */
+  if (test_unauthorized_topic && !has_acl_cli) {
+    Test::Say(
+        "Skipping unauthorized topic test since kafka-acls.sh is not "
+        "available\n");
+    return;
+  }
+  if (!test_consumer_group_protocol_classic() && allow_auto_create_topics) {
+    Test::Say(
+        "Skipping test as it would be duplicate "
+        "with KIP 848 consumer protocol\n");
+    return;
+  }
+
+  bool supports_allow = test_broker_version >= TEST_BRKVER(0, 11, 0, 0);
+  const int cgrp_consumer_expected_consecutive_error_cnt = 3;
+
+  std::string topic_exists    = Test::mk_topic_name("0109-exists", 1);
+  std::string topic_notexists = Test::mk_topic_name("0109-notexists", 1);
+  std::string topic_unauth    = Test::mk_topic_name("0109-unauthorized", 1);
+
+  /* Create consumer */
+  RdKafka::Conf *conf;
+  Test::conf_init(&conf, NULL, 20);
+  Test::conf_set(conf, "group.id", topic_exists);
+  Test::conf_set(conf, "enable.partition.eof", "true");
+  /* Quickly refresh metadata on topic auto-creation since the first
+   * metadata after auto-create hides the topic due to 0 partition count. */
+  Test::conf_set(conf, "topic.metadata.refresh.interval.ms", "1000");
+  if (allow_auto_create_topics)
+    Test::conf_set(conf, "allow.auto.create.topics", "true");
+
+  std::string bootstraps;
+  if (conf->get("bootstrap.servers", bootstraps) != RdKafka::Conf::CONF_OK)
+    Test::Fail("Failed to retrieve bootstrap.servers");
+
+  std::string errstr;
+  RdKafka::KafkaConsumer *c = RdKafka::KafkaConsumer::create(conf, errstr);
+  if (!c)
+    Test::Fail("Failed to create KafkaConsumer: " + errstr);
+  delete conf;
+
+  /* Create topics */
+  Test::create_topic(c, topic_exists.c_str(), 1, 1);
+
+  if (test_unauthorized_topic) {
+    Test::create_topic(c, topic_unauth.c_str(), 1, 1);
+
+    /* Add denying ACL for unauth topic */
+    test_kafka_cmd(
+        "kafka-acls.sh --bootstrap-server %s "
+        "--add --deny-principal 'User:*' "
+        "--operation All --deny-host '*' "
+        "--topic '%s'",
+        bootstraps.c_str(), topic_unauth.c_str());
+  }
+
+
+  /* Wait for topic to be fully created */
+  test_wait_topic_exists(NULL, topic_exists.c_str(), 10 * 1000);
+
+
+  /*
+   * Subscribe
+   */
+  std::vector<std::string> topics;
+  std::map<std::string, RdKafka::ErrorCode> exp_errors;
+
+  topics.push_back(topic_notexists);
+
+  if (test_unauthorized_topic)
+    topics.push_back(topic_unauth);
+
+  if (with_wildcards) {
+    topics.push_back("^" + topic_exists);
+    topics.push_back("^" + topic_notexists);
+  } else {
+    topics.push_back(topic_exists);
+  }
+
+  /* `classic` protocol case: if the subscription contains at least one
+   * wildcard/regex then no auto topic creation will take place (since the
+   * consumer requests all topics in metadata, and not specific ones, thus not
+   * triggering topic auto creation). We need to handle the expected error cases
+   * accordingly.
+   *
+   * `consumer` protocol case: there's no automatic topic creation. */
+  if (test_consumer_group_protocol_classic()) {
+    if (with_wildcards) {
+      exp_errors["^" + topic_notexists] = RdKafka::ERR_UNKNOWN_TOPIC_OR_PART;
+      exp_errors[topic_notexists]       = RdKafka::ERR_UNKNOWN_TOPIC_OR_PART;
+      if (test_unauthorized_topic) {
+        /* Unauthorized topics are not included in list-all-topics Metadata,
+         * which we use for wildcards, so in this case the error code for
+         * unauthorixed topics show up as unknown topic. */
+        exp_errors[topic_unauth] = RdKafka::ERR_UNKNOWN_TOPIC_OR_PART;
+      }
+    } else if (test_unauthorized_topic) {
+      exp_errors[topic_unauth] = RdKafka::ERR_TOPIC_AUTHORIZATION_FAILED;
+    }
+  } else if (test_unauthorized_topic) {
+    /* Authorization errors happen if even a single topic
+     * is unauthorized and an error is returned for the whole subscription
+     * without reference to the topic. */
+    exp_errors[""] = RdKafka::ERR_TOPIC_AUTHORIZATION_FAILED;
+  }
+
+  /* `classic` protocol case: expect an error only if the broker supports the
+   * property and the test disallowed it.
+   *
+   * `consumer` protocol case: there's no automatic topic creation. */
+  if (supports_allow && !allow_auto_create_topics &&
+      test_consumer_group_protocol_classic())
+    exp_errors[topic_notexists] = RdKafka::ERR_UNKNOWN_TOPIC_OR_PART;
+
+  RdKafka::ErrorCode err;
+  if ((err = c->subscribe(topics)))
+    Test::Fail("subscribe failed: " + RdKafka::err2str(err));
+
+  /* Start consuming until EOF is reached, which indicates that we have an
+   * assignment and any errors should have been reported. */
+  bool run                  = true;
+  int consecutive_error_cnt = 0;
+  while (run) {
+    RdKafka::Message *msg = c->consume(tmout_multip(1000));
+    switch (msg->err()) {
+    case RdKafka::ERR__TIMED_OUT:
+    case RdKafka::ERR_NO_ERROR:
+      break;
+
+    case RdKafka::ERR__PARTITION_EOF:
+      run = false;
+      break;
+
+    case RdKafka::ERR_TOPIC_AUTHORIZATION_FAILED:
+      if (test_consumer_group_protocol_classic()) {
+        run = true;
+      } else {
+        /* `consumer` rebalance protocol:
+         * wait for `unauthorized_error_cnt` consecutive errors. */
+        run = (++consecutive_error_cnt) <
+              cgrp_consumer_expected_consecutive_error_cnt;
+      }
+      /* FALLTHRU */
+
+    default:
+      Test::Say("Consume error on " + msg->topic_name() + ": " + msg->errstr() +
+                "\n");
+
+      std::map<std::string, RdKafka::ErrorCode>::iterator it =
+          exp_errors.find(msg->topic_name());
+
+      /* Temporary unknown-topic errors are okay for auto-created topics. */
+      bool unknown_is_ok = allow_auto_create_topics && !with_wildcards &&
+                           msg->err() == RdKafka::ERR_UNKNOWN_TOPIC_OR_PART &&
+                           msg->topic_name() == topic_notexists;
+
+      if (it == exp_errors.end()) {
+        if (unknown_is_ok)
+          Test::Say("Ignoring temporary auto-create error for topic " +
+                    msg->topic_name() + ": " + RdKafka::err2str(msg->err()) +
+                    "\n");
+        else
+          Test::Fail("Did not expect error for " + msg->topic_name() +
+                     ": got: " + RdKafka::err2str(msg->err()));
+      } else if (msg->err() != it->second) {
+        if (unknown_is_ok)
+          Test::Say("Ignoring temporary auto-create error for topic " +
+                    msg->topic_name() + ": " + RdKafka::err2str(msg->err()) +
+                    "\n");
+        else
+          Test::Fail("Expected '" + RdKafka::err2str(it->second) + "' for " +
+                     msg->topic_name() + ", got " +
+                     RdKafka::err2str(msg->err()));
+      } else {
+        exp_errors.erase(msg->topic_name());
+        if (!test_consumer_group_protocol_classic() &&
+            test_unauthorized_topic &&
+            consecutive_error_cnt <
+                cgrp_consumer_expected_consecutive_error_cnt) {
+          /* Expect same error on next HB */
+          exp_errors[""] = RdKafka::ERR_TOPIC_AUTHORIZATION_FAILED;
+        }
+      }
+
+      break;
+    }
+
+    delete msg;
+  }
+
+
+  /* Fail if not all expected errors were seen. */
+  if (!exp_errors.empty())
+    Test::Fail(tostr() << "Expecting " << exp_errors.size() << " more errors");
+
+  c->close();
+
+  delete c;
+}
+
+extern "C" {
+int main_0109_auto_create_topics(int argc, char **argv) {
+  /* Parameters:
+   *  allow auto create, with wildcards, test unauthorized topic */
+  do_test_consumer(true, false, false);
+  do_test_consumer(false, false, false);
+
+  do_test_consumer(true, true, false);
+  do_test_consumer(false, true, false);
+
+  do_test_consumer(true, false, true);
+  do_test_consumer(false, false, true);
+
+  do_test_consumer(true, true, true);
+  do_test_consumer(false, true, true);
+
+  return 0;
+}
+}

package/deps/librdkafka/tests/0110-batch_size.cpp

@@ -0,0 +1,182 @@
+/*
+ * 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.
+ */
+
+/**
+ * Test batch.size producer property.
+ *
+ */
+
+#include <iostream>
+#include <fstream>
+#include <iterator>
+#include <string>
+#include "testcpp.h"
+
+#if WITH_RAPIDJSON
+#include <rapidjson/document.h>
+#include <rapidjson/pointer.h>
+#include <rapidjson/error/en.h>
+
+
+class myAvgStatsCb : public RdKafka::EventCb {
+ public:
+  myAvgStatsCb(std::string topic) :
+      avg_batchsize(0), min_batchsize(0), max_batchsize(0), topic_(topic) {
+  }
+
+  void event_cb(RdKafka::Event &event) {
+    switch (event.type()) {
+    case RdKafka::Event::EVENT_LOG:
+      Test::Say(event.str() + "\n");
+      break;
+    case RdKafka::Event::EVENT_STATS:
+      read_batch_stats(event.str());
+      break;
+    default:
+      break;
+    }
+  }
+
+  int avg_batchsize;
+  int min_batchsize;
+  int max_batchsize;
+
+ private:
+  void read_val(rapidjson::Document &d, const std::string &path, int &val) {
+    rapidjson::Pointer jpath(path.c_str());
+
+    if (!jpath.IsValid())
+      Test::Fail(tostr() << "json pointer parse " << path << " failed at "
+                         << jpath.GetParseErrorOffset() << " with error code "
+                         << jpath.GetParseErrorCode());
+
+    rapidjson::Value *pp = rapidjson::GetValueByPointer(d, jpath);
+    if (!pp) {
+      Test::Say(tostr() << "Could not find " << path << " in stats\n");
+      return;
+    }
+
+    val = pp->GetInt();
+  }
+
+  void read_batch_stats(const std::string &stats) {
+    rapidjson::Document d;
+
+    if (d.Parse(stats.c_str()).HasParseError())
+      Test::Fail(tostr() << "Failed to parse stats JSON: "
+                         << rapidjson::GetParseError_En(d.GetParseError())
+                         << " at " << d.GetErrorOffset());
+
+    read_val(d, "/topics/" + topic_ + "/batchsize/avg", avg_batchsize);
+    read_val(d, "/topics/" + topic_ + "/batchsize/min", min_batchsize);
+    read_val(d, "/topics/" + topic_ + "/batchsize/max", max_batchsize);
+  }
+
+  std::string topic_;
+};
+
+
+/**
+ * @brief Specify batch.size and parse stats to verify it takes effect.
+ *
+ */
+static void do_test_batch_size() {
+  std::string topic = Test::mk_topic_name(__FILE__, 0);
+
+  myAvgStatsCb event_cb(topic);
+
+  RdKafka::Conf *conf;
+  Test::conf_init(&conf, NULL, 0);
+
+  const int msgcnt      = 1000;
+  const int msgsize     = 1000;
+  int batchsize         = 5000;
+  int exp_min_batchsize = batchsize - msgsize - 100 /*~framing overhead*/;
+
+  Test::conf_set(conf, "batch.size", "5000");
+
+  /* Make sure batch.size takes precedence by setting the following high */
+  Test::conf_set(conf, "batch.num.messages", "100000");
+  Test::conf_set(conf, "linger.ms", "2000");
+
+  Test::conf_set(conf, "statistics.interval.ms", "7000");
+  std::string errstr;
+  if (conf->set("event_cb", &event_cb, errstr) != RdKafka::Conf::CONF_OK)
+    Test::Fail(errstr);
+
+  RdKafka::Producer *p = RdKafka::Producer::create(conf, errstr);
+  if (!p)
+    Test::Fail("Failed to create Producer: " + errstr);
+
+  delete conf;
+
+  /* Produce messages */
+  char val[msgsize];
+  memset(val, 'a', msgsize);
+
+  for (int i = 0; i < msgcnt; i++) {
+    RdKafka::ErrorCode err =
+        p->produce(topic, 0, RdKafka::Producer::RK_MSG_COPY, val, msgsize, NULL,
+                   0, -1, NULL);
+    if (err)
+      Test::Fail("Produce failed: " + RdKafka::err2str(err));
+  }
+
+  Test::Say(tostr() << "Produced " << msgcnt << " messages\n");
+  p->flush(5 * 1000);
+
+  Test::Say("Waiting for stats\n");
+  while (event_cb.avg_batchsize == 0)
+    p->poll(1000);
+
+  Test::Say(tostr() << "Batchsize: " << "configured " << batchsize << ", min "
+                    << event_cb.min_batchsize << ", max "
+                    << event_cb.max_batchsize << ", avg "
+                    << event_cb.avg_batchsize << "\n");
+
+  /* The average batchsize should within a message size from batch.size. */
+  if (event_cb.avg_batchsize < exp_min_batchsize ||
+      event_cb.avg_batchsize > batchsize)
+    Test::Fail(tostr() << "Expected avg batchsize to be within "
+                       << exp_min_batchsize << ".." << batchsize << " but got "
+                       << event_cb.avg_batchsize);
+
+  delete p;
+}
+#endif
+
+extern "C" {
+int main_0110_batch_size(int argc, char **argv) {
+#if WITH_RAPIDJSON
+  do_test_batch_size();
+#else
+  Test::Skip("RapidJSON >=1.1.0 not available\n");
+#endif
+  return 0;
+}
+}

package/deps/librdkafka/tests/0111-delay_create_topics.cpp

@@ -0,0 +1,127 @@
+/*
+ * 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"
+
+/**
+ * Verify that the producer waits topic.metadata.propagation.max.ms
+ * before flagging a topic as non-existent, allowing asynchronous
+ * CreateTopics() to be used in non-auto-create scenarios.
+ *
+ * This tests the producer. The consumer behaviour is implicitly tested
+ * in 0109.
+ */
+
+
+namespace {
+class DrCb : public RdKafka::DeliveryReportCb {
+ public:
+  DrCb(RdKafka::ErrorCode exp_err) : ok(false), _exp_err(exp_err) {
+  }
+
+  void dr_cb(RdKafka::Message &msg) {
+    Test::Say("Delivery report: " + RdKafka::err2str(msg.err()) + "\n");
+    if (msg.err() != _exp_err)
+      Test::Fail("Delivery report: Expected " + RdKafka::err2str(_exp_err) +
+                 " but got " + RdKafka::err2str(msg.err()));
+    else if (ok)
+      Test::Fail("Too many delivery reports");
+    else
+      ok = true;
+  }
+
+  bool ok;
+
+ private:
+  RdKafka::ErrorCode _exp_err;
+};
+};  // namespace
+
+static void do_test_producer(bool timeout_too_short) {
+  Test::Say(tostr() << _C_MAG << "[ Test with timeout_too_short="
+                    << (timeout_too_short ? "true" : "false") << " ]\n");
+
+  std::string topic = Test::mk_topic_name("0110-delay_create_topics", 1);
+
+  /* Create Producer */
+  RdKafka::Conf *conf;
+  Test::conf_init(&conf, NULL, 20);
+
+  std::string errstr;
+
+  if (timeout_too_short) {
+    if (conf->set("topic.metadata.propagation.max.ms", "3", errstr))
+      Test::Fail(errstr);
+  }
+
+  DrCb dr_cb(timeout_too_short ? RdKafka::ERR_UNKNOWN_TOPIC_OR_PART
+                               : RdKafka::ERR_NO_ERROR);
+  conf->set("dr_cb", &dr_cb, errstr);
+
+  RdKafka::Producer *p = RdKafka::Producer::create(conf, errstr);
+  if (!p)
+    Test::Fail("Failed to create Producer: " + errstr);
+  delete conf;
+
+  /* Produce a message to the yet non-existent topic. */
+  RdKafka::ErrorCode err = p->produce(
+      topic, RdKafka::Topic::PARTITION_UA, RdKafka::Producer::RK_MSG_COPY,
+      (void *)"hello", 5, "hi", 2, 0, NULL, NULL);
+  if (err)
+    Test::Fail(tostr() << "produce failed: " << RdKafka::err2str(err));
+
+  int delay        = 5;
+  int64_t end_wait = test_clock() + (delay * 1000000);
+
+  while (test_clock() < end_wait)
+    p->poll(1000);
+
+  Test::create_topic(NULL, topic.c_str(), 1, 3);
+
+  p->flush(10 * 1000);
+
+  if (!dr_cb.ok)
+    Test::Fail("Did not get delivery report for message");
+
+  delete p;
+
+  Test::Say(tostr() << _C_GRN << "[ Test with timeout_too_short="
+                    << (timeout_too_short ? "true" : "false") << ": PASS ]\n");
+}
+
+extern "C" {
+int main_0111_delay_create_topics(int argc, char **argv) {
+  do_test_producer(false);
+  do_test_producer(true);
+  return 0;
+}
+}

package/deps/librdkafka/tests/0112-assign_unknown_part.c

@@ -0,0 +1,87 @@
+/*
+ * librdkafka - Apache Kafka C library
+ *
+ * Copyright (c) 2012-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 "rdkafka.h"
+
+/**
+ * Assign consumer to single partition topic and consume a message.
+ * Then add a new partition to the topic (i.e., one that will not
+ * be in the consumer's metadata) and assign the consumer to it.
+ * Verify that partition 0 is not incorrectly reported as missing.
+ * See #2915.
+ */
+
+int main_0112_assign_unknown_part(int argc, char **argv) {
+        const char *topic = test_mk_topic_name(__FUNCTION__ + 5, 1);
+        int64_t offset    = RD_KAFKA_OFFSET_BEGINNING;
+        uint64_t testid   = test_id_generate();
+        rd_kafka_t *c;
+        rd_kafka_topic_partition_list_t *tpl;
+
+        test_conf_init(NULL, NULL, 60);
+
+        TEST_SAY("Creating consumer\n");
+        c = test_create_consumer(topic, NULL, NULL, NULL);
+
+        TEST_SAY("Creating topic %s with 1 partition\n", topic);
+        test_create_topic_wait_exists(c, topic, 1, 1, 10 * 1000);
+
+        TEST_SAY("Producing message to partition 0\n");
+        test_produce_msgs_easy(topic, testid, 0, 1);
+
+        TEST_SAY("Assigning partition 0\n");
+        tpl = rd_kafka_topic_partition_list_new(1);
+        rd_kafka_topic_partition_list_add(tpl, topic, 0)->offset = offset;
+        test_consumer_assign("ASSIGN", c, tpl);
+
+        TEST_SAY("Waiting for message\n");
+        test_consumer_poll("CONSUME 0", c, testid, -1, 0, 1, NULL);
+
+        TEST_SAY("Changing partition count for topic %s\n", topic);
+        test_create_partitions(NULL, topic, 2);
+
+        /* Allow the partition to propagate */
+        rd_sleep(1);
+
+        TEST_SAY("Producing message to partition 1\n");
+        test_produce_msgs_easy(topic, testid, 1, 1);
+
+        TEST_SAY("Assigning partitions 1\n");
+        rd_kafka_topic_partition_list_add(tpl, topic, 1)->offset = offset;
+        test_consumer_assign("ASSIGN", c, tpl);
+
+        TEST_SAY("Waiting for messages\n");
+        test_consumer_poll("CONSUME", c, testid, -1, 0, 2, NULL);
+
+        rd_kafka_topic_partition_list_destroy(tpl);
+        test_consumer_close(c);
+        rd_kafka_destroy(c);
+
+        return 0;
+}