@point3/node-rdkafka 3.6.0-1

package/deps/librdkafka/src/rdkafka_mock_handlers.c

@@ -0,0 +1,3113 @@
+/*
+ * librdkafka - Apache Kafka C library
+ *
+ * Copyright (c) 2019-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.
+ */
+
+/**
+ * Mocks - protocol request handlers
+ *
+ */
+
+#include "rdkafka_int.h"
+#include "rdbuf.h"
+#include "rdrand.h"
+#include "rdkafka_interceptor.h"
+#include "rdkafka_mock_int.h"
+#include "rdkafka_transport_int.h"
+#include "rdkafka_offset.h"
+#include "rdkafka_telemetry_decode.h"
+
+
+
+void rd_kafka_mock_Produce_reply_tags_partition_write(
+    rd_kafka_buf_t *rkbuf,
+    int tagtype,
+    rd_kafka_mock_partition_t *mpart) {
+        switch (tagtype) {
+        case 0: /* CurrentLeader */
+                /* Leader id */
+                rd_kafka_buf_write_i32(rkbuf, mpart->leader->id);
+                /* Leader epoch */
+                rd_kafka_buf_write_i32(rkbuf, mpart->leader_epoch);
+                /* Field tags */
+                rd_kafka_buf_write_tags_empty(rkbuf);
+                break;
+        default:
+                break;
+        }
+}
+
+void rd_kafka_mock_Produce_reply_tags_write(
+    rd_kafka_buf_t *rkbuf,
+    int tagtype,
+    rd_kafka_mock_broker_t **changed_leaders,
+    int changed_leader_cnt) {
+        int i;
+        switch (tagtype) {
+        case 0: /* NodeEndpoints */
+                /* #NodeEndpoints */
+                rd_kafka_buf_write_arraycnt(rkbuf, changed_leader_cnt);
+                for (i = 0; i < changed_leader_cnt; i++) {
+                        rd_kafka_mock_broker_t *changed_leader =
+                            changed_leaders[i];
+                        /* Leader id */
+                        rd_kafka_buf_write_i32(rkbuf, changed_leader->id);
+                        /* Leader Hostname */
+                        rd_kafka_buf_write_str(
+                            rkbuf, changed_leader->advertised_listener, -1);
+
+                        /* Leader Port number */
+                        rd_kafka_buf_write_i32(rkbuf,
+                                               (int32_t)changed_leader->port);
+
+                        /* Leader Rack */
+                        rd_kafka_buf_write_str(rkbuf, changed_leader->rack, -1);
+
+                        /* Field tags */
+                        rd_kafka_buf_write_tags_empty(rkbuf);
+                }
+        default:
+                break;
+        }
+}
+
+/**
+ * @brief Handle ProduceRequest
+ */
+static int rd_kafka_mock_handle_Produce(rd_kafka_mock_connection_t *mconn,
+                                        rd_kafka_buf_t *rkbuf) {
+        const rd_bool_t log_decode_errors = rd_true;
+        rd_kafka_mock_cluster_t *mcluster = mconn->broker->cluster;
+        rd_kafka_buf_t *resp = rd_kafka_mock_buf_new_response(rkbuf);
+        int32_t TopicsCnt;
+        rd_kafkap_str_t TransactionalId = RD_KAFKAP_STR_INITIALIZER;
+        int16_t Acks;
+        int32_t TimeoutMs;
+        rd_kafka_resp_err_t all_err;
+        int32_t tags_to_write[1] = {0};
+        size_t tags_to_write_cnt = 0;
+        int changed_leaders_cnt  = 0;
+        rd_kafka_mock_broker_t **changed_leaders =
+            rd_calloc(mcluster->broker_cnt, sizeof(*changed_leaders));
+
+
+        if (rkbuf->rkbuf_reqhdr.ApiVersion >= 3)
+                rd_kafka_buf_read_str(rkbuf, &TransactionalId);
+
+        rd_kafka_buf_read_i16(rkbuf, &Acks);
+        rd_kafka_buf_read_i32(rkbuf, &TimeoutMs);
+        /* #Topics */
+        rd_kafka_buf_read_arraycnt(rkbuf, &TopicsCnt, RD_KAFKAP_TOPICS_MAX);
+
+        /* Response: #Topics */
+        rd_kafka_buf_write_arraycnt(resp, TopicsCnt);
+
+        /* Inject error, if any */
+        all_err = rd_kafka_mock_next_request_error(mconn, resp);
+
+        while (TopicsCnt-- > 0) {
+                rd_kafkap_str_t Topic;
+                int32_t PartitionCnt;
+                rd_kafka_mock_topic_t *mtopic;
+
+                rd_kafka_buf_read_str(rkbuf, &Topic);
+                rd_kafka_buf_read_arraycnt(rkbuf, &PartitionCnt,
+                                           RD_KAFKAP_PARTITIONS_MAX);
+                mtopic = rd_kafka_mock_topic_find_by_kstr(mcluster, &Topic);
+
+                /* Response: Topic */
+                rd_kafka_buf_write_kstr(resp, &Topic);
+                /* Response: #Partitions */
+                rd_kafka_buf_write_arraycnt(resp, PartitionCnt);
+
+                while (PartitionCnt-- > 0) {
+                        int32_t Partition;
+                        rd_kafka_mock_partition_t *mpart = NULL;
+                        rd_kafkap_bytes_t records;
+                        rd_kafka_resp_err_t err = RD_KAFKA_RESP_ERR_NO_ERROR;
+                        int64_t BaseOffset      = -1;
+                        int32_t partition_tags_to_write[1] = {0};
+                        size_t partition_tags_to_write_cnt = 0;
+
+                        rd_kafka_buf_read_i32(rkbuf, &Partition);
+
+                        if (mtopic)
+                                mpart = rd_kafka_mock_partition_find(mtopic,
+                                                                     Partition);
+
+                        rd_kafka_buf_read_kbytes(rkbuf, &records);
+                        /* Partition Tags */
+                        rd_kafka_buf_skip_tags(rkbuf);
+                        /* Response: Partition */
+                        rd_kafka_buf_write_i32(resp, Partition);
+
+                        if (all_err)
+                                err = all_err;
+                        else if (!mpart)
+                                err = RD_KAFKA_RESP_ERR_UNKNOWN_TOPIC_OR_PART;
+                        else if (mpart->leader != mconn->broker)
+                                err =
+                                    RD_KAFKA_RESP_ERR_NOT_LEADER_FOR_PARTITION;
+
+                        /* Append to partition log */
+                        if (!err)
+                                err = rd_kafka_mock_partition_log_append(
+                                    mpart, &records, &TransactionalId,
+                                    &BaseOffset);
+
+                        /* Response: ErrorCode */
+                        rd_kafka_buf_write_i16(resp, err);
+
+                        if (err) {
+                                /* Response: BaseOffset */
+                                rd_kafka_buf_write_i64(resp, BaseOffset);
+
+                                if (rkbuf->rkbuf_reqhdr.ApiVersion >= 2) {
+                                        /* Response: LogAppendTimeMs */
+                                        rd_kafka_buf_write_i64(resp, -1);
+                                }
+                                if (rkbuf->rkbuf_reqhdr.ApiVersion >= 6) {
+                                        /* Response: LogStartOffset */
+                                        rd_kafka_buf_write_i64(resp, -1);
+                                }
+
+                        } else {
+                                /* Response: BaseOffset */
+                                rd_kafka_buf_write_i64(resp, BaseOffset);
+
+                                if (rkbuf->rkbuf_reqhdr.ApiVersion >= 2) {
+                                        /* Response: LogAppendTimeMs */
+                                        rd_kafka_buf_write_i64(resp, 1234);
+                                }
+                                if (rkbuf->rkbuf_reqhdr.ApiVersion >= 6) {
+                                        /* Response: LogStartOffset */
+                                        rd_kafka_buf_write_i64(
+                                            resp, mpart->start_offset);
+                                }
+                        }
+
+                        if (rkbuf->rkbuf_reqhdr.ApiVersion >= 8) {
+                                /* Response: #RecordErrors
+                                 * TODO: Add support for injecting RecordErrors
+                                 * 0 record errors for now */
+                                rd_kafka_buf_write_arraycnt(resp, 0);
+
+                                /* Response: ErrorMessage */
+                                rd_kafka_buf_write_str(resp, NULL, 0);
+                        }
+
+                        if (rkbuf->rkbuf_reqhdr.ApiVersion >= 10 &&
+                            err == RD_KAFKA_RESP_ERR_NOT_LEADER_FOR_PARTITION) {
+                                int changed_leader_idx;
+                                /* See if this leader is already included */
+                                for (changed_leader_idx = 0;
+                                     changed_leader_idx < changed_leaders_cnt;
+                                     changed_leader_idx++) {
+                                        if (changed_leaders[changed_leader_idx]
+                                                ->id == mpart->leader->id)
+                                                break;
+                                }
+                                if (changed_leader_idx == changed_leaders_cnt) {
+                                        /* Add the new leader that wasn't
+                                         * present */
+                                        changed_leaders[changed_leaders_cnt] =
+                                            mpart->leader;
+                                        changed_leaders_cnt++;
+                                }
+
+                                partition_tags_to_write
+                                    [partition_tags_to_write_cnt] =
+                                        0 /* CurrentLeader */;
+                                partition_tags_to_write_cnt++;
+                        }
+
+                        /* Response: Partition tags */
+                        rd_kafka_buf_write_tags(
+                            resp,
+                            rd_kafka_mock_Produce_reply_tags_partition_write,
+                            partition_tags_to_write,
+                            partition_tags_to_write_cnt, mpart);
+                }
+
+                /* Topic tags */
+                rd_kafka_buf_skip_tags(rkbuf);
+                /* Response: Topic tags */
+                rd_kafka_buf_write_tags_empty(resp);
+        }
+
+        if (rkbuf->rkbuf_reqhdr.ApiVersion >= 1) {
+                /* Response: ThrottleTime */
+                rd_kafka_buf_write_i32(resp, 0);
+        }
+
+        /* Response: Top level tags */
+        if (changed_leaders_cnt) {
+                tags_to_write[tags_to_write_cnt] = 0 /* NodeEndpoints */;
+                tags_to_write_cnt++;
+        }
+
+        rd_kafka_buf_write_tags(resp, rd_kafka_mock_Produce_reply_tags_write,
+                                tags_to_write, tags_to_write_cnt,
+                                changed_leaders, changed_leaders_cnt);
+
+        rd_kafka_mock_connection_send_response0(mconn, resp, rd_true);
+        rd_free(changed_leaders);
+        return 0;
+
+err_parse:
+        rd_free(changed_leaders);
+        rd_kafka_buf_destroy(resp);
+        return -1;
+}
+
+void rd_kafka_mock_Fetch_reply_tags_partition_write(
+    rd_kafka_buf_t *rkbuf,
+    int tagtype,
+    rd_kafka_mock_partition_t *mpart) {
+        switch (tagtype) {
+        case 1: /* CurrentLeader */
+        {
+                int32_t leader_id    = mpart->leader->id,
+                        leader_epoch = mpart->leader_epoch;
+                rd_kafka_mock_partition_leader_t *mpart_leader =
+                    rd_kafka_mock_partition_next_leader_response(mpart);
+                if (mpart_leader) {
+                        leader_id    = mpart_leader->leader_id;
+                        leader_epoch = mpart_leader->leader_epoch;
+                        rd_kafka_mock_partition_leader_destroy(mpart,
+                                                               mpart_leader);
+                }
+
+                /* Leader id */
+                rd_kafka_buf_write_i32(rkbuf, leader_id);
+                /* Leader epoch */
+                rd_kafka_buf_write_i32(rkbuf, leader_epoch);
+                /* Field tags */
+                rd_kafka_buf_write_tags_empty(rkbuf);
+                break;
+        }
+        default:
+                break;
+        }
+}
+
+void rd_kafka_mock_Fetch_reply_tags_write(
+    rd_kafka_buf_t *rkbuf,
+    int tagtype,
+    rd_kafka_mock_broker_t **changed_leaders,
+    int changed_leader_cnt) {
+        int i;
+        switch (tagtype) {
+        case 0: /* NodeEndpoints */
+                /* #NodeEndpoints */
+                rd_kafka_buf_write_arraycnt(rkbuf, changed_leader_cnt);
+                for (i = 0; i < changed_leader_cnt; i++) {
+                        rd_kafka_mock_broker_t *changed_leader =
+                            changed_leaders[i];
+                        /* Leader id */
+                        rd_kafka_buf_write_i32(rkbuf, changed_leader->id);
+                        /* Leader Hostname */
+                        rd_kafka_buf_write_str(
+                            rkbuf, changed_leader->advertised_listener, -1);
+
+                        /* Leader Port number */
+                        rd_kafka_buf_write_i32(rkbuf,
+                                               (int32_t)changed_leader->port);
+
+                        /* Leader Rack */
+                        rd_kafka_buf_write_str(rkbuf, changed_leader->rack, -1);
+
+                        /* Field tags */
+                        rd_kafka_buf_write_tags_empty(rkbuf);
+                }
+        default:
+                break;
+        }
+}
+
+
+/**
+ * @brief Handle FetchRequest
+ */
+static int rd_kafka_mock_handle_Fetch(rd_kafka_mock_connection_t *mconn,
+                                      rd_kafka_buf_t *rkbuf) {
+        const rd_bool_t log_decode_errors = rd_true;
+        rd_kafka_mock_cluster_t *mcluster = mconn->broker->cluster;
+        rd_kafka_buf_t *resp = rd_kafka_mock_buf_new_response(rkbuf);
+        rd_kafka_resp_err_t all_err;
+        int32_t ReplicaId = -1, MaxWait, MinBytes, MaxBytes = -1,
+                SessionId = -1, Epoch, TopicsCnt;
+        int8_t IsolationLevel;
+        size_t totsize = 0;
+
+        int32_t tags_to_write[1]   = {0};
+        uint64_t tags_to_write_cnt = 0;
+
+        int changed_leaders_cnt = 0;
+        rd_kafka_mock_broker_t **changed_leaders =
+            rd_calloc(mcluster->broker_cnt, sizeof(*changed_leaders));
+
+        if (rkbuf->rkbuf_reqhdr.ApiVersion <= 14) {
+                rd_kafka_buf_read_i32(rkbuf, &ReplicaId);
+        }
+        rd_kafka_buf_read_i32(rkbuf, &MaxWait);
+        rd_kafka_buf_read_i32(rkbuf, &MinBytes);
+        if (rkbuf->rkbuf_reqhdr.ApiVersion >= 3)
+                rd_kafka_buf_read_i32(rkbuf, &MaxBytes);
+        if (rkbuf->rkbuf_reqhdr.ApiVersion >= 4)
+                rd_kafka_buf_read_i8(rkbuf, &IsolationLevel);
+        if (rkbuf->rkbuf_reqhdr.ApiVersion >= 7) {
+                rd_kafka_buf_read_i32(rkbuf, &SessionId);
+                rd_kafka_buf_read_i32(rkbuf, &Epoch);
+        }
+
+        if (rkbuf->rkbuf_reqhdr.ApiVersion >= 1) {
+                /* Response: ThrottleTime */
+                rd_kafka_buf_write_i32(resp, 0);
+        }
+
+
+        /* Inject error, if any */
+        all_err = rd_kafka_mock_next_request_error(mconn, resp);
+
+        if (rkbuf->rkbuf_reqhdr.ApiVersion >= 7) {
+                /* Response: ErrorCode */
+                rd_kafka_buf_write_i16(resp, all_err);
+
+                /* Response: SessionId */
+                rd_kafka_buf_write_i32(resp, SessionId);
+        }
+
+        rd_kafka_buf_read_arraycnt(rkbuf, &TopicsCnt, RD_KAFKAP_TOPICS_MAX);
+
+        /* Response: #Topics */
+        rd_kafka_buf_write_arraycnt(resp, TopicsCnt);
+
+        while (TopicsCnt-- > 0) {
+                rd_kafkap_str_t Topic   = RD_KAFKAP_STR_INITIALIZER;
+                rd_kafka_Uuid_t TopicId = RD_KAFKA_UUID_ZERO;
+                int32_t PartitionCnt;
+                rd_kafka_mock_topic_t *mtopic;
+                rd_bool_t find_topic_by_id = rd_true;
+
+                if (rkbuf->rkbuf_reqhdr.ApiVersion <= 12) {
+                        rd_kafka_buf_read_str(rkbuf, &Topic);
+                        find_topic_by_id = rd_false;
+                }
+
+                if (rkbuf->rkbuf_reqhdr.ApiVersion >= 13) {
+                        rd_kafka_buf_read_uuid(rkbuf, &TopicId);
+                }
+
+                rd_kafka_buf_read_arraycnt(rkbuf, &PartitionCnt,
+                                           RD_KAFKAP_PARTITIONS_MAX);
+
+                if (find_topic_by_id) {
+                        mtopic =
+                            rd_kafka_mock_topic_find_by_id(mcluster, TopicId);
+                        /* Response: TopicId */
+                        rd_kafka_buf_write_uuid(resp, &TopicId);
+                } else {
+                        mtopic =
+                            rd_kafka_mock_topic_find_by_kstr(mcluster, &Topic);
+                        /* Response: Topic */
+                        rd_kafka_buf_write_kstr(resp, &Topic);
+                }
+
+                /* Response: #Partitions */
+                rd_kafka_buf_write_arraycnt(resp, PartitionCnt);
+
+                while (PartitionCnt-- > 0) {
+                        int32_t Partition, CurrentLeaderEpoch = -1,
+                                           LastFetchedEpoch = -1, PartMaxBytes;
+                        int64_t FetchOffset, LogStartOffset;
+                        rd_kafka_mock_partition_t *mpart = NULL;
+                        rd_kafka_resp_err_t err          = all_err;
+                        rd_bool_t on_follower;
+                        size_t partsize                      = 0;
+                        const rd_kafka_mock_msgset_t *mset   = NULL;
+                        int32_t partition_tags_to_write[1]   = {0};
+                        uint64_t partition_tags_to_write_cnt = 0;
+
+                        rd_kafka_buf_read_i32(rkbuf, &Partition);
+
+                        if (rkbuf->rkbuf_reqhdr.ApiVersion >= 9)
+                                rd_kafka_buf_read_i32(rkbuf,
+                                                      &CurrentLeaderEpoch);
+
+                        rd_kafka_buf_read_i64(rkbuf, &FetchOffset);
+
+                        if (rkbuf->rkbuf_reqhdr.ApiVersion >= 12)
+                                rd_kafka_buf_read_i32(rkbuf, &LastFetchedEpoch);
+
+                        if (rkbuf->rkbuf_reqhdr.ApiVersion >= 5)
+                                rd_kafka_buf_read_i64(rkbuf, &LogStartOffset);
+
+                        rd_kafka_buf_read_i32(rkbuf, &PartMaxBytes);
+
+                        /* Partition tags */
+                        rd_kafka_buf_skip_tags(rkbuf);
+
+                        if (mtopic)
+                                mpart = rd_kafka_mock_partition_find(mtopic,
+                                                                     Partition);
+                        else if (find_topic_by_id)
+                                err = RD_KAFKA_RESP_ERR_UNKNOWN_TOPIC_ID;
+
+                        /* Response: Partition */
+                        rd_kafka_buf_write_i32(resp, Partition);
+
+                        /* Fetch is directed at follower and this is
+                         * the follower broker. */
+                        on_follower =
+                            mpart && mpart->follower_id == mconn->broker->id;
+
+                        if (!err) {
+                                if (!all_err && !mpart)
+                                        err =
+                                            RD_KAFKA_RESP_ERR_UNKNOWN_TOPIC_OR_PART;
+                                else if (!all_err &&
+                                         mpart->leader != mconn->broker &&
+                                         !on_follower)
+                                        err =
+                                            RD_KAFKA_RESP_ERR_NOT_LEADER_OR_FOLLOWER;
+                        }
+
+                        if (!err && mpart)
+                                err =
+                                    rd_kafka_mock_partition_leader_epoch_check(
+                                        mpart, CurrentLeaderEpoch);
+
+                        /* Find MessageSet for FetchOffset */
+                        if (!err && FetchOffset != mpart->end_offset) {
+                                /* Kafka currently only returns
+                                 * OFFSET_NOT_AVAILABLE
+                                 * in ListOffsets calls */
+                                if (!(mset = rd_kafka_mock_msgset_find(
+                                          mpart, FetchOffset, on_follower)))
+                                        err =
+                                            RD_KAFKA_RESP_ERR_OFFSET_OUT_OF_RANGE;
+                                rd_kafka_dbg(
+                                    mcluster->rk, MOCK, "MOCK",
+                                    "Topic %.*s [%" PRId32
+                                    "] fetch err %s for offset %" PRId64
+                                    " mset %p, on_follower %d, "
+                                    "start %" PRId64 ", end_offset %" PRId64
+                                    ", current epoch %" PRId32,
+                                    RD_KAFKAP_STR_PR(&Topic), Partition,
+                                    rd_kafka_err2name(err), FetchOffset, mset,
+                                    on_follower, mpart->start_offset,
+                                    mpart->end_offset, mpart->leader_epoch);
+                        }
+
+
+                        /* Response: ErrorCode */
+                        rd_kafka_buf_write_i16(resp, err);
+
+                        /* Response: Highwatermark */
+                        rd_kafka_buf_write_i64(
+                            resp,
+                            mpart ? (on_follower ? mpart->follower_end_offset
+                                                 : mpart->end_offset)
+                                  : -1);
+
+                        if (rkbuf->rkbuf_reqhdr.ApiVersion >= 4) {
+                                /* Response: LastStableOffset */
+                                rd_kafka_buf_write_i64(
+                                    resp, mpart ? mpart->end_offset : -1);
+                        }
+
+                        if (rkbuf->rkbuf_reqhdr.ApiVersion >= 5) {
+                                /* Response: LogStartOffset */
+                                rd_kafka_buf_write_i64(
+                                    resp,
+                                    !mpart ? -1
+                                           : (on_follower
+                                                  ? mpart->follower_start_offset
+                                                  : mpart->start_offset));
+                        }
+
+                        if (rkbuf->rkbuf_reqhdr.ApiVersion >= 4) {
+                                /* Response: #Aborted */
+                                rd_kafka_buf_write_arraycnt(resp, 0);
+                        }
+
+
+                        if (rkbuf->rkbuf_reqhdr.ApiVersion >= 11) {
+                                int32_t PreferredReadReplica =
+                                    mpart && mpart->leader == mconn->broker &&
+                                            mpart->follower_id != -1
+                                        ? mpart->follower_id
+                                        : -1;
+
+                                /* Response: PreferredReplica */
+                                rd_kafka_buf_write_i32(resp,
+                                                       PreferredReadReplica);
+
+                                if (PreferredReadReplica != -1) {
+                                        /* Don't return any data when
+                                         * PreferredReadReplica is set */
+                                        mset    = NULL;
+                                        MaxWait = 0;
+                                }
+                        }
+
+
+                        if (mset && partsize < (size_t)PartMaxBytes &&
+                            totsize < (size_t)MaxBytes) {
+                                /* Response: Records */
+                                size_t written = rd_kafka_buf_write_kbytes(
+                                    resp, &mset->bytes);
+                                partsize += written;
+                                totsize += written;
+
+                                /* FIXME: Multiple messageSets ? */
+                        } else {
+                                /* Empty Response: Records: Null */
+                                rd_kafka_buf_write_arraycnt(resp, 0);
+                        }
+
+                        if (rkbuf->rkbuf_reqhdr.ApiVersion >= 12 &&
+                            err == RD_KAFKA_RESP_ERR_NOT_LEADER_OR_FOLLOWER) {
+                                int changed_leader_idx;
+                                for (changed_leader_idx = 0;
+                                     changed_leader_idx < changed_leaders_cnt;
+                                     changed_leader_idx++) {
+                                        if (changed_leaders[changed_leader_idx]
+                                                ->id == mpart->leader->id)
+                                                break;
+                                }
+                                if (changed_leader_idx == changed_leaders_cnt) {
+                                        changed_leaders[changed_leaders_cnt] =
+                                            mpart->leader;
+                                        changed_leaders_cnt++;
+                                }
+                                /* CurrentLeader */
+                                partition_tags_to_write
+                                    [partition_tags_to_write_cnt] = 1;
+                                partition_tags_to_write_cnt++;
+                        }
+
+                        /* Response: Partition tags */
+                        rd_kafka_buf_write_tags(
+                            resp,
+                            rd_kafka_mock_Fetch_reply_tags_partition_write,
+                            partition_tags_to_write,
+                            partition_tags_to_write_cnt, mpart);
+                }
+
+                /* Topic tags */
+                rd_kafka_buf_skip_tags(rkbuf);
+                /* Response: Topic tags */
+                rd_kafka_buf_write_tags_empty(resp);
+        }
+
+        if (rkbuf->rkbuf_reqhdr.ApiVersion >= 7) {
+                int32_t ForgottenTopicCnt;
+                rd_kafka_buf_read_arraycnt(rkbuf, &ForgottenTopicCnt,
+                                           RD_KAFKAP_TOPICS_MAX);
+                while (ForgottenTopicCnt-- > 0) {
+                        rd_kafkap_str_t Topic   = RD_KAFKAP_STR_INITIALIZER;
+                        rd_kafka_Uuid_t TopicId = RD_KAFKA_UUID_ZERO;
+                        int32_t ForgPartCnt;
+                        if (rkbuf->rkbuf_reqhdr.ApiVersion <= 12) {
+                                rd_kafka_buf_read_str(rkbuf, &Topic);
+                        }
+                        if (rkbuf->rkbuf_reqhdr.ApiVersion >= 13) {
+                                rd_kafka_buf_read_uuid(rkbuf, &TopicId);
+                        }
+                        rd_kafka_buf_read_arraycnt(rkbuf, &ForgPartCnt,
+                                                   RD_KAFKAP_PARTITIONS_MAX);
+                        while (ForgPartCnt-- > 0) {
+                                int32_t Partition;
+                                rd_kafka_buf_read_i32(rkbuf, &Partition);
+                        }
+
+                        /* ForgottenTopic tags */
+                        rd_kafka_buf_skip_tags(rkbuf);
+                }
+        }
+
+        if (rkbuf->rkbuf_reqhdr.ApiVersion >= 11) {
+                rd_kafkap_str_t RackId;
+                char *rack;
+                rd_kafka_buf_read_str(rkbuf, &RackId);
+                RD_KAFKAP_STR_DUPA(&rack, &RackId);
+                /* Matt might do something sensible with this */
+        }
+
+        if (rkbuf->rkbuf_reqhdr.ApiVersion >= 16 && changed_leaders_cnt) {
+                tags_to_write[tags_to_write_cnt] = 0 /* NodeEndpoints */;
+                tags_to_write_cnt++;
+        }
+
+        /* Response: Top level tags */
+        rd_kafka_buf_write_tags(resp, rd_kafka_mock_Fetch_reply_tags_write,
+                                tags_to_write, tags_to_write_cnt,
+                                changed_leaders, changed_leaders_cnt);
+
+        /* If there was no data, delay up to MaxWait.
+         * This isn't strictly correct since we should cut the wait short
+         * and feed newly produced data if a producer writes to the
+         * partitions, but that is too much of a hassle here since we
+         * can't block the thread. */
+        if (!totsize && MaxWait > 0)
+                resp->rkbuf_ts_retry = rd_clock() + (MaxWait * 1000);
+
+        rd_kafka_mock_connection_send_response0(mconn, resp, rd_true);
+        rd_free(changed_leaders);
+        return 0;
+
+err_parse:
+        rd_kafka_buf_destroy(resp);
+        rd_free(changed_leaders);
+        return -1;
+}
+
+
+
+/**
+ * @brief Handle ListOffsets
+ */
+static int rd_kafka_mock_handle_ListOffsets(rd_kafka_mock_connection_t *mconn,
+                                            rd_kafka_buf_t *rkbuf) {
+        const rd_bool_t log_decode_errors = rd_true;
+        rd_kafka_mock_cluster_t *mcluster = mconn->broker->cluster;
+        rd_kafka_buf_t *resp = rd_kafka_mock_buf_new_response(rkbuf);
+        rd_kafka_resp_err_t all_err;
+        int32_t ReplicaId, TopicsCnt;
+        int8_t IsolationLevel;
+
+        rd_kafka_buf_read_i32(rkbuf, &ReplicaId);
+        if (rkbuf->rkbuf_reqhdr.ApiVersion >= 2)
+                rd_kafka_buf_read_i8(rkbuf, &IsolationLevel);
+
+        if (rkbuf->rkbuf_reqhdr.ApiVersion >= 2) {
+                /* Response: ThrottleTime */
+                rd_kafka_buf_write_i32(resp, 0);
+        }
+
+
+        /* Inject error, if any */
+        all_err = rd_kafka_mock_next_request_error(mconn, resp);
+
+        rd_kafka_buf_read_arraycnt(rkbuf, &TopicsCnt, RD_KAFKAP_TOPICS_MAX);
+
+        /* Response: #Topics */
+        rd_kafka_buf_write_arraycnt(resp, TopicsCnt);
+
+        while (TopicsCnt-- > 0) {
+                rd_kafkap_str_t Topic;
+                int32_t PartitionCnt;
+                rd_kafka_mock_topic_t *mtopic;
+
+                rd_kafka_buf_read_str(rkbuf, &Topic);
+                rd_kafka_buf_read_arraycnt(rkbuf, &PartitionCnt,
+                                           RD_KAFKAP_PARTITIONS_MAX);
+
+                mtopic = rd_kafka_mock_topic_find_by_kstr(mcluster, &Topic);
+
+                /* Response: Topic */
+                rd_kafka_buf_write_kstr(resp, &Topic);
+                /* Response: #Partitions */
+                rd_kafka_buf_write_arraycnt(resp, PartitionCnt);
+
+                while (PartitionCnt-- > 0) {
+                        int32_t Partition, CurrentLeaderEpoch = -1;
+                        int64_t Timestamp, Offset             = -1;
+                        int32_t MaxNumOffsets;
+                        rd_kafka_mock_partition_t *mpart = NULL;
+                        rd_kafka_resp_err_t err          = all_err;
+
+                        rd_kafka_buf_read_i32(rkbuf, &Partition);
+
+                        if (rkbuf->rkbuf_reqhdr.ApiVersion >= 4)
+                                rd_kafka_buf_read_i32(rkbuf,
+                                                      &CurrentLeaderEpoch);
+
+                        rd_kafka_buf_read_i64(rkbuf, &Timestamp);
+
+                        if (rkbuf->rkbuf_reqhdr.ApiVersion == 0)
+                                rd_kafka_buf_read_i32(rkbuf, &MaxNumOffsets);
+
+                        /* Partition tags */
+                        rd_kafka_buf_skip_tags(rkbuf);
+
+                        if (mtopic)
+                                mpart = rd_kafka_mock_partition_find(mtopic,
+                                                                     Partition);
+
+                        /* Response: Partition */
+                        rd_kafka_buf_write_i32(resp, Partition);
+
+                        if (!all_err && !mpart)
+                                err = RD_KAFKA_RESP_ERR_UNKNOWN_TOPIC_OR_PART;
+                        else if (!all_err && mpart->leader != mconn->broker)
+                                err =
+                                    RD_KAFKA_RESP_ERR_NOT_LEADER_FOR_PARTITION;
+
+                        if (!err && mpart)
+                                err =
+                                    rd_kafka_mock_partition_leader_epoch_check(
+                                        mpart, CurrentLeaderEpoch);
+
+                        /* Response: ErrorCode */
+                        rd_kafka_buf_write_i16(resp, err);
+
+                        if (!err && mpart) {
+                                if (Timestamp == RD_KAFKA_OFFSET_BEGINNING)
+                                        Offset = mpart->start_offset;
+                                else if (Timestamp == RD_KAFKA_OFFSET_END)
+                                        Offset = mpart->end_offset;
+                                else if (Timestamp < 0)
+                                        Offset = -1;
+                                else /* FIXME: by timestamp */
+                                        Offset = -1;
+                        }
+
+                        if (rkbuf->rkbuf_reqhdr.ApiVersion == 0) {
+                                /* Response: #OldStyleOffsets */
+                                rd_kafka_buf_write_i32(resp,
+                                                       Offset != -1 ? 1 : 0);
+                                /* Response: OldStyleOffsets[0] */
+                                if (Offset != -1)
+                                        rd_kafka_buf_write_i64(resp, Offset);
+                        } else {
+                                /* Response: Timestamp (FIXME) */
+                                rd_kafka_buf_write_i64(resp, -1);
+
+                                /* Response: Offset */
+                                rd_kafka_buf_write_i64(resp, Offset);
+                        }
+
+                        if (rkbuf->rkbuf_reqhdr.ApiVersion >= 4) {
+                                /* Response: LeaderEpoch */
+                                const rd_kafka_mock_msgset_t *mset = NULL;
+                                int32_t leader_epoch               = -1;
+                                rd_bool_t on_follower              = rd_false;
+
+                                if (mpart) {
+                                        on_follower =
+                                            mpart && mpart->follower_id ==
+                                                         mconn->broker->id;
+
+                                        if (Offset >= 0 &&
+                                            (mset = rd_kafka_mock_msgset_find(
+                                                 mpart, Offset, on_follower))) {
+                                                leader_epoch =
+                                                    mset->leader_epoch;
+                                        }
+                                }
+
+                                rd_kafka_buf_write_i32(resp, leader_epoch);
+                        }
+
+                        /* Response: Partition tags */
+                        rd_kafka_buf_write_tags_empty(resp);
+
+                        rd_kafka_dbg(mcluster->rk, MOCK, "MOCK",
+                                     "Topic %.*s [%" PRId32
+                                     "] returning "
+                                     "offset %" PRId64 " (leader epoch %" PRId32
+                                     ") for %s: %s",
+                                     RD_KAFKAP_STR_PR(&Topic), Partition,
+                                     Offset, mpart ? mpart->leader_epoch : -1,
+                                     rd_kafka_offset2str(Timestamp),
+                                     rd_kafka_err2str(err));
+                }
+
+                /* Topic tags */
+                rd_kafka_buf_skip_tags(rkbuf);
+                /* Response: Topic tags */
+                rd_kafka_buf_write_tags_empty(resp);
+        }
+
+
+        rd_kafka_mock_connection_send_response(mconn, resp);
+
+        return 0;
+
+err_parse:
+        rd_kafka_buf_destroy(resp);
+        return -1;
+}
+
+
+/**
+ * @brief Handle OffsetFetch (fetch committed offsets)
+ */
+static int rd_kafka_mock_handle_OffsetFetch(rd_kafka_mock_connection_t *mconn,
+                                            rd_kafka_buf_t *rkbuf) {
+        const rd_bool_t log_decode_errors = rd_true;
+        rd_kafka_mock_cluster_t *mcluster = mconn->broker->cluster;
+        rd_kafka_buf_t *resp = rd_kafka_mock_buf_new_response(rkbuf);
+        rd_kafka_mock_broker_t *mrkb;
+        rd_kafka_resp_err_t all_err;
+        int32_t TopicsCnt;
+        rd_kafkap_str_t GroupId;
+
+        if (rkbuf->rkbuf_reqhdr.ApiVersion >= 3) {
+                /* Response: ThrottleTime */
+                rd_kafka_buf_write_i32(resp, 0);
+        }
+
+        rd_kafka_buf_read_str(rkbuf, &GroupId);
+
+        /* Inject error, if any */
+        all_err = rd_kafka_mock_next_request_error(mconn, resp);
+
+        mrkb = rd_kafka_mock_cluster_get_coord(mcluster, RD_KAFKA_COORD_GROUP,
+                                               &GroupId);
+        if (!mrkb && !all_err)
+                all_err = RD_KAFKA_RESP_ERR_NOT_COORDINATOR;  // FIXME? check if
+                                                              // its this mrkb?
+
+
+        rd_kafka_buf_read_arraycnt(rkbuf, &TopicsCnt, 100000);
+
+        /* Response: #Topics */
+        rd_kafka_buf_write_arraycnt(resp, TopicsCnt);
+
+        while (TopicsCnt-- > 0) {
+                rd_kafkap_str_t Topic;
+                int32_t PartitionCnt;
+                rd_kafka_mock_topic_t *mtopic;
+
+                rd_kafka_buf_read_str(rkbuf, &Topic);
+                rd_kafka_buf_read_arraycnt(rkbuf, &PartitionCnt, 100000);
+
+                mtopic = rd_kafka_mock_topic_find_by_kstr(mcluster, &Topic);
+
+                /* Response: Topic */
+                rd_kafka_buf_write_kstr(resp, &Topic);
+                /* Response: #Partitions */
+                rd_kafka_buf_write_arraycnt(resp, PartitionCnt);
+
+                while (PartitionCnt-- > 0) {
+                        int32_t Partition;
+                        rd_kafka_mock_partition_t *mpart             = NULL;
+                        const rd_kafka_mock_committed_offset_t *coff = NULL;
+                        rd_kafka_resp_err_t err                      = all_err;
+
+                        rd_kafka_buf_read_i32(rkbuf, &Partition);
+
+                        if (mtopic)
+                                mpart = rd_kafka_mock_partition_find(mtopic,
+                                                                     Partition);
+
+                        /* Response: Partition */
+                        rd_kafka_buf_write_i32(resp, Partition);
+
+                        if (!all_err && !mpart)
+                                err = RD_KAFKA_RESP_ERR_UNKNOWN_TOPIC_OR_PART;
+
+                        if (!err)
+                                coff = rd_kafka_mock_committed_offset_find(
+                                    mpart, &GroupId);
+
+                        /* Response: CommittedOffset */
+                        rd_kafka_buf_write_i64(resp, coff ? coff->offset : -1);
+
+                        if (rkbuf->rkbuf_reqhdr.ApiVersion >= 5) {
+                                /* Response: CommittedLeaderEpoch */
+                                rd_kafka_buf_write_i32(
+                                    resp, mpart ? mpart->leader_epoch : -1);
+                        }
+
+                        /* Response: Metadata */
+                        rd_kafka_buf_write_kstr(resp,
+                                                coff ? coff->metadata : NULL);
+
+                        /* Response: ErrorCode */
+                        rd_kafka_buf_write_i16(resp, err);
+
+                        /* Response: Struct tags */
+                        rd_kafka_buf_write_tags_empty(resp);
+
+                        if (coff)
+                                rd_kafka_dbg(mcluster->rk, MOCK, "MOCK",
+                                             "Topic %s [%" PRId32
+                                             "] returning "
+                                             "committed offset %" PRId64
+                                             " for group %s",
+                                             mtopic->name, mpart->id,
+                                             coff->offset, coff->group);
+                        else
+                                rd_kafka_dbg(mcluster->rk, MOCK, "MOCK",
+                                             "Topic %.*s [%" PRId32
+                                             "] has no "
+                                             "committed offset for group %.*s: "
+                                             "%s",
+                                             RD_KAFKAP_STR_PR(&Topic),
+                                             Partition,
+                                             RD_KAFKAP_STR_PR(&GroupId),
+                                             rd_kafka_err2str(err));
+                }
+
+                /* Request: Skip struct tags */
+                rd_kafka_buf_skip_tags(rkbuf);
+
+                /* Response: Struct tags */
+                rd_kafka_buf_write_tags_empty(resp);
+        }
+
+        if (rkbuf->rkbuf_reqhdr.ApiVersion >= 2) {
+                /* Response: Outer ErrorCode */
+                rd_kafka_buf_write_i16(resp, all_err);
+        }
+
+
+        rd_kafka_mock_connection_send_response(mconn, resp);
+
+        return 0;
+
+err_parse:
+        rd_kafka_buf_destroy(resp);
+        return -1;
+}
+
+
+
+/**
+ * @brief Handle OffsetCommit
+ */
+static int rd_kafka_mock_handle_OffsetCommit(rd_kafka_mock_connection_t *mconn,
+                                             rd_kafka_buf_t *rkbuf) {
+        const rd_bool_t log_decode_errors = rd_true;
+        rd_kafka_mock_cluster_t *mcluster = mconn->broker->cluster;
+        rd_kafka_buf_t *resp = rd_kafka_mock_buf_new_response(rkbuf);
+        rd_kafka_mock_broker_t *mrkb;
+        rd_kafka_resp_err_t all_err;
+        int32_t GenerationIdOrMemberEpoch = -1, TopicsCnt;
+        rd_kafkap_str_t GroupId, MemberId, GroupInstanceId;
+
+        if (rkbuf->rkbuf_reqhdr.ApiVersion >= 3) {
+                /* Response: ThrottleTime */
+                rd_kafka_buf_write_i32(resp, 0);
+        }
+
+        rd_kafka_buf_read_str(rkbuf, &GroupId);
+
+        if (rkbuf->rkbuf_reqhdr.ApiVersion >= 1) {
+                rd_kafka_buf_read_i32(rkbuf, &GenerationIdOrMemberEpoch);
+                rd_kafka_buf_read_str(rkbuf, &MemberId);
+        }
+
+        if (rkbuf->rkbuf_reqhdr.ApiVersion >= 7)
+                rd_kafka_buf_read_str(rkbuf, &GroupInstanceId);
+
+        if (rkbuf->rkbuf_reqhdr.ApiVersion >= 2 &&
+            rkbuf->rkbuf_reqhdr.ApiVersion <= 4) {
+                int64_t RetentionTimeMs;
+                rd_kafka_buf_read_i64(rkbuf, &RetentionTimeMs);
+        }
+
+
+        /* Inject error, if any */
+        all_err = rd_kafka_mock_next_request_error(mconn, resp);
+
+        mrkb = rd_kafka_mock_cluster_get_coord(mcluster, RD_KAFKA_COORD_GROUP,
+                                               &GroupId);
+        if (!mrkb && !all_err)
+                all_err = RD_KAFKA_RESP_ERR_NOT_COORDINATOR;
+
+
+        if (!all_err) {
+                rd_kafka_mock_cgrp_classic_t *mcgrp_classic;
+
+                mcgrp_classic =
+                    rd_kafka_mock_cgrp_classic_find(mcluster, &GroupId);
+                if (mcgrp_classic) {
+                        rd_kafka_mock_cgrp_classic_member_t *member = NULL;
+
+                        if (!RD_KAFKAP_STR_IS_NULL(&MemberId))
+                                member = rd_kafka_mock_cgrp_classic_member_find(
+                                    mcgrp_classic, &MemberId);
+
+                        if (!member)
+                                all_err = RD_KAFKA_RESP_ERR_UNKNOWN_MEMBER_ID;
+                        else
+                                all_err =
+                                    rd_kafka_mock_cgrp_classic_check_state(
+                                        mcgrp_classic, member, rkbuf,
+                                        GenerationIdOrMemberEpoch);
+                } else {
+                        rd_kafka_mock_cgrp_consumer_t *mcgrp_consumer;
+                        rd_kafka_mock_cgrp_consumer_member_t *member = NULL;
+
+                        mcgrp_consumer = rd_kafka_mock_cgrp_consumer_find(
+                            mcluster, &GroupId);
+                        if (mcgrp_consumer) {
+                                if (!RD_KAFKAP_STR_IS_NULL(&MemberId))
+                                        member =
+                                            rd_kafka_mock_cgrp_consumer_member_find(
+                                                mcgrp_consumer, &MemberId);
+
+                                if (!member)
+                                        all_err =
+                                            RD_KAFKA_RESP_ERR_UNKNOWN_MEMBER_ID;
+                                else
+                                        all_err =
+                                            GenerationIdOrMemberEpoch !=
+                                                    member->current_member_epoch
+                                                ? RD_KAFKA_RESP_ERR_STALE_MEMBER_EPOCH
+                                                : RD_KAFKA_RESP_ERR_NO_ERROR;
+                        }
+                }
+
+                /* As happens here, a real broker doesn't check that partitions
+                 * are assigned to the member, but only the GenerationId. */
+        }
+
+        rd_kafka_buf_read_arraycnt(rkbuf, &TopicsCnt, RD_KAFKAP_TOPICS_MAX);
+
+        /* Response: #Topics */
+        rd_kafka_buf_write_arraycnt(resp, TopicsCnt);
+
+        while (TopicsCnt-- > 0) {
+                rd_kafkap_str_t Topic;
+                int32_t PartitionCnt;
+                rd_kafka_mock_topic_t *mtopic;
+
+                rd_kafka_buf_read_str(rkbuf, &Topic);
+                rd_kafka_buf_read_arraycnt(rkbuf, &PartitionCnt,
+                                           RD_KAFKAP_PARTITIONS_MAX);
+
+                mtopic = rd_kafka_mock_topic_find_by_kstr(mcluster, &Topic);
+
+                /* Response: Topic */
+                rd_kafka_buf_write_kstr(resp, &Topic);
+                /* Response: #Partitions */
+                rd_kafka_buf_write_arraycnt(resp, PartitionCnt);
+
+                while (PartitionCnt-- > 0) {
+                        int32_t Partition;
+                        rd_kafka_mock_partition_t *mpart = NULL;
+                        rd_kafka_resp_err_t err          = all_err;
+                        int64_t CommittedOffset;
+                        rd_kafkap_str_t Metadata;
+
+                        rd_kafka_buf_read_i32(rkbuf, &Partition);
+
+                        if (mtopic)
+                                mpart = rd_kafka_mock_partition_find(mtopic,
+                                                                     Partition);
+
+                        /* Response: Partition */
+                        rd_kafka_buf_write_i32(resp, Partition);
+
+                        if (!all_err && !mpart)
+                                err = RD_KAFKA_RESP_ERR_UNKNOWN_TOPIC_OR_PART;
+
+                        rd_kafka_buf_read_i64(rkbuf, &CommittedOffset);
+
+                        if (rkbuf->rkbuf_reqhdr.ApiVersion >= 6) {
+                                int32_t CommittedLeaderEpoch;
+                                rd_kafka_buf_read_i32(rkbuf,
+                                                      &CommittedLeaderEpoch);
+
+                                if (!err && mpart)
+                                        err =
+                                            rd_kafka_mock_partition_leader_epoch_check(
+                                                mpart, CommittedLeaderEpoch);
+                        }
+
+                        if (rkbuf->rkbuf_reqhdr.ApiVersion == 1) {
+                                int64_t CommitTimestamp;
+                                rd_kafka_buf_read_i64(rkbuf, &CommitTimestamp);
+                        }
+
+                        rd_kafka_buf_read_str(rkbuf, &Metadata);
+                        rd_kafka_buf_skip_tags(rkbuf);
+
+                        if (!err)
+                                rd_kafka_mock_commit_offset(mpart, &GroupId,
+                                                            CommittedOffset,
+                                                            &Metadata);
+
+                        /* Response: ErrorCode */
+                        rd_kafka_buf_write_i16(resp, err);
+                        rd_kafka_buf_write_tags_empty(resp);
+                }
+                rd_kafka_buf_skip_tags(rkbuf);
+                rd_kafka_buf_write_tags_empty(resp);
+        }
+
+        rd_kafka_mock_connection_send_response(mconn, resp);
+
+        return 0;
+
+err_parse:
+        rd_kafka_buf_destroy(resp);
+        return -1;
+}
+
+
+
+/**
+ * @brief Handle ApiVersionRequest
+ */
+static int rd_kafka_mock_handle_ApiVersion(rd_kafka_mock_connection_t *mconn,
+                                           rd_kafka_buf_t *rkbuf);
+
+
+/**
+ * @brief Write a MetadataResponse.Topics. entry to \p resp.
+ *
+ * @param mtopic may be NULL
+ */
+static void
+rd_kafka_mock_buf_write_Metadata_Topic(rd_kafka_mock_cluster_t *mcluster,
+                                       rd_kafka_buf_t *resp,
+                                       int16_t ApiVersion,
+                                       rd_kafka_Uuid_t topic_id,
+                                       const char *topic,
+                                       const rd_kafka_mock_topic_t *mtopic,
+                                       rd_kafka_resp_err_t err) {
+        int i;
+        int partition_cnt =
+            (!mtopic || err == RD_KAFKA_RESP_ERR_UNKNOWN_TOPIC_OR_PART ||
+             err == RD_KAFKA_RESP_ERR_UNKNOWN_TOPIC_ID)
+                ? 0
+                : mtopic->partition_cnt;
+
+        /* Response: Topics.ErrorCode */
+        rd_kafka_buf_write_i16(resp, err);
+        /* Response: Topics.Name */
+        rd_kafka_buf_write_str(resp, topic, -1);
+
+        if (ApiVersion >= 10) {
+                /* Response: Topics.TopicId */
+                rd_kafka_buf_write_uuid(resp, &topic_id);
+        }
+
+        if (ApiVersion >= 1) {
+                /* Response: Topics.IsInternal */
+                rd_kafka_buf_write_bool(resp, rd_false);
+        }
+        /* Response: Topics.#Partitions */
+        rd_kafka_buf_write_arraycnt(resp, partition_cnt);
+
+        for (i = 0; mtopic && i < partition_cnt; i++) {
+                rd_kafka_mock_partition_leader_t *mpart_leader;
+                rd_kafka_mock_partition_t *mpart = &mtopic->partitions[i];
+                int r;
+
+                /* Response: ..Partitions.ErrorCode */
+                rd_kafka_buf_write_i16(resp, 0);
+                /* Response: ..Partitions.PartitionIndex */
+                rd_kafka_buf_write_i32(resp, mpart->id);
+
+                mpart_leader =
+                    rd_kafka_mock_partition_next_leader_response(mpart);
+                if (mpart_leader) {
+                        rd_kafka_dbg(
+                            mcluster->rk, MOCK, "MOCK",
+                            "MetadataRequest: using next leader response "
+                            "(%" PRId32 ", %" PRId32 ")",
+                            mpart_leader->leader_id,
+                            mpart_leader->leader_epoch);
+
+                        /* Response: ..Partitions.Leader */
+                        rd_kafka_buf_write_i32(resp, mpart_leader->leader_id);
+
+                        if (ApiVersion >= 7) {
+                                /* Response: ..Partitions.LeaderEpoch */
+                                rd_kafka_buf_write_i32(
+                                    resp, mpart_leader->leader_epoch);
+                        }
+                        rd_kafka_mock_partition_leader_destroy(mpart,
+                                                               mpart_leader);
+                        mpart_leader = NULL;
+                } else {
+                        /* Response: ..Partitions.Leader */
+                        rd_kafka_buf_write_i32(
+                            resp, mpart->leader ? mpart->leader->id : -1);
+
+                        if (ApiVersion >= 7) {
+                                /* Response: ..Partitions.LeaderEpoch */
+                                rd_kafka_buf_write_i32(resp,
+                                                       mpart->leader_epoch);
+                        }
+                }
+
+                /* Response: ..Partitions.#ReplicaNodes */
+                rd_kafka_buf_write_arraycnt(resp, mpart->replica_cnt);
+                for (r = 0; r < mpart->replica_cnt; r++)
+                        rd_kafka_buf_write_i32(resp, mpart->replicas[r]->id);
+
+                /* Response: ..Partitions.#IsrNodes */
+                /* Let Replicas == ISRs for now */
+                rd_kafka_buf_write_arraycnt(resp, mpart->replica_cnt);
+                for (r = 0; r < mpart->replica_cnt; r++)
+                        rd_kafka_buf_write_i32(resp, mpart->replicas[r]->id);
+
+                if (ApiVersion >= 5) {
+                        /* Response: ...OfflineReplicas */
+                        rd_kafka_buf_write_arraycnt(resp, 0);
+                }
+
+                rd_kafka_buf_write_tags_empty(resp);
+        }
+
+        if (ApiVersion >= 8) {
+                /* Response: Topics.TopicAuthorizedOperations */
+                rd_kafka_buf_write_i32(resp, INT32_MIN);
+        }
+
+        rd_kafka_buf_write_tags_empty(resp);
+}
+
+
+/**
+ * @brief Handle MetadataRequest
+ */
+static int rd_kafka_mock_handle_Metadata(rd_kafka_mock_connection_t *mconn,
+                                         rd_kafka_buf_t *rkbuf) {
+        const rd_bool_t log_decode_errors = rd_true;
+        rd_kafka_mock_cluster_t *mcluster = mconn->broker->cluster;
+        rd_bool_t AllowAutoTopicCreation  = rd_true;
+        rd_kafka_buf_t *resp = rd_kafka_mock_buf_new_response(rkbuf);
+        const rd_kafka_mock_broker_t *mrkb;
+        rd_kafka_topic_partition_list_t *requested_topics = NULL;
+        rd_bool_t list_all_topics                         = rd_false;
+        int32_t TopicsCnt;
+        int i;
+        size_t of_Brokers_cnt;
+        int32_t response_Brokers_cnt = 0;
+
+        if (rkbuf->rkbuf_reqhdr.ApiVersion >= 3) {
+                /* Response: ThrottleTime */
+                rd_kafka_buf_write_i32(resp, 0);
+        }
+
+        /* Response: #Brokers */
+        of_Brokers_cnt = rd_kafka_buf_write_arraycnt_pos(resp);
+
+        TAILQ_FOREACH(mrkb, &mcluster->brokers, link) {
+                if (!mrkb->up)
+                        continue;
+                /* Response: Brokers.Nodeid */
+                rd_kafka_buf_write_i32(resp, mrkb->id);
+                /* Response: Brokers.Host */
+                rd_kafka_buf_write_str(resp, mrkb->advertised_listener, -1);
+                /* Response: Brokers.Port */
+                rd_kafka_buf_write_i32(resp, (int32_t)mrkb->port);
+                if (rkbuf->rkbuf_reqhdr.ApiVersion >= 1) {
+                        /* Response: Brokers.Rack (Matt's going to love this) */
+                        rd_kafka_buf_write_str(resp, mrkb->rack, -1);
+                }
+                rd_kafka_buf_write_tags_empty(resp);
+                response_Brokers_cnt++;
+        }
+        rd_kafka_buf_finalize_arraycnt(resp, of_Brokers_cnt,
+                                       response_Brokers_cnt);
+
+        if (rkbuf->rkbuf_reqhdr.ApiVersion >= 2) {
+                /* Response: ClusterId */
+                rd_kafka_buf_write_str(resp, mcluster->id, -1);
+        }
+
+        if (rkbuf->rkbuf_reqhdr.ApiVersion >= 1) {
+                /* Response: ControllerId */
+                rd_kafka_buf_write_i32(resp, mcluster->controller_id);
+        }
+
+        /* #Topics */
+        rd_kafka_buf_read_arraycnt(rkbuf, &TopicsCnt, RD_KAFKAP_TOPICS_MAX);
+
+        if (TopicsCnt > 0)
+                requested_topics = rd_kafka_topic_partition_list_new(TopicsCnt);
+        else if (rkbuf->rkbuf_reqhdr.ApiVersion == 0 || TopicsCnt == -1)
+                list_all_topics = rd_true;
+
+        for (i = 0; i < TopicsCnt; i++) {
+                rd_kafkap_str_t Topic;
+                rd_kafka_Uuid_t TopicId = RD_KAFKA_UUID_ZERO;
+                rd_kafka_topic_partition_t *rktpar;
+                char *topic = NULL;
+
+                if (rkbuf->rkbuf_reqhdr.ApiVersion >= 10) {
+                        /* TopicId */
+                        rd_kafka_buf_read_uuid(rkbuf, &TopicId);
+                }
+                rd_kafka_buf_read_str(rkbuf, &Topic);
+                RD_KAFKAP_STR_DUPA(&topic, &Topic);
+
+                rktpar = rd_kafka_topic_partition_list_add(
+                    requested_topics, topic, RD_KAFKA_PARTITION_UA);
+                if (rkbuf->rkbuf_reqhdr.ApiVersion >= 10)
+                        rd_kafka_topic_partition_set_topic_id(rktpar, TopicId);
+                rd_kafka_buf_skip_tags(rkbuf);
+        }
+
+        if (rkbuf->rkbuf_reqhdr.ApiVersion >= 4)
+                rd_kafka_buf_read_bool(rkbuf, &AllowAutoTopicCreation);
+
+        if (rkbuf->rkbuf_reqhdr.ApiVersion >= 8) {
+                rd_bool_t IncludeClusterAuthorizedOperations;
+                rd_bool_t IncludeTopicAuthorizedOperations;
+                if (rkbuf->rkbuf_reqhdr.ApiVersion <= 10)
+                        rd_kafka_buf_read_bool(
+                            rkbuf, &IncludeClusterAuthorizedOperations);
+                rd_kafka_buf_read_bool(rkbuf,
+                                       &IncludeTopicAuthorizedOperations);
+        }
+
+        if (list_all_topics) {
+                rd_kafka_mock_topic_t *mtopic;
+                /* Response: #Topics */
+                rd_kafka_buf_write_arraycnt(resp, mcluster->topic_cnt);
+
+                TAILQ_FOREACH(mtopic, &mcluster->topics, link) {
+                        rd_kafka_mock_buf_write_Metadata_Topic(
+                            mcluster, resp, rkbuf->rkbuf_reqhdr.ApiVersion,
+                            mtopic->id, mtopic->name, mtopic, mtopic->err);
+                }
+
+        } else if (requested_topics) {
+                /* Response: #Topics */
+                rd_kafka_buf_write_arraycnt(resp, requested_topics->cnt);
+
+                for (i = 0; i < requested_topics->cnt; i++) {
+                        const rd_kafka_topic_partition_t *rktpar =
+                            &requested_topics->elems[i];
+                        rd_kafka_mock_topic_t *mtopic = NULL;
+                        rd_kafka_resp_err_t err = RD_KAFKA_RESP_ERR_NO_ERROR;
+                        char *topic_name        = rktpar->topic;
+                        rd_kafka_Uuid_t topic_id =
+                            rd_kafka_topic_partition_get_topic_id(rktpar);
+                        rd_bool_t invalid_before_12 =
+                            rkbuf->rkbuf_reqhdr.ApiVersion < 12 &&
+                            (!RD_KAFKA_UUID_IS_ZERO(topic_id) || !topic_name);
+                        rd_bool_t invalid_after_12 =
+                            rkbuf->rkbuf_reqhdr.ApiVersion >= 12 &&
+                            RD_KAFKA_UUID_IS_ZERO(topic_id) && !topic_name;
+                        if (invalid_before_12 || invalid_after_12) {
+                                err = RD_KAFKA_RESP_ERR_INVALID_REQUEST;
+                        }
+
+                        if (!err) {
+                                rd_bool_t use_topic_id =
+                                    !RD_KAFKA_UUID_IS_ZERO(topic_id);
+                                if (use_topic_id) {
+                                        mtopic = rd_kafka_mock_topic_find_by_id(
+                                            mcluster, topic_id);
+                                } else
+                                        mtopic = rd_kafka_mock_topic_find(
+                                            mcluster, topic_name);
+
+                                if (mtopic) {
+                                        topic_name = mtopic->name;
+                                        topic_id   = mtopic->id;
+                                } else if (!use_topic_id) {
+                                        topic_name = rktpar->topic;
+                                } else {
+                                        topic_name = NULL;
+                                }
+
+                                if (!mtopic && topic_name &&
+                                    AllowAutoTopicCreation) {
+                                        mtopic =
+                                            rd_kafka_mock_topic_auto_create(
+                                                mcluster, topic_name, -1, &err);
+                                        topic_id = mtopic->id;
+                                } else if (!mtopic) {
+                                        err =
+                                            use_topic_id
+                                                ? RD_KAFKA_RESP_ERR_UNKNOWN_TOPIC_ID
+                                                : RD_KAFKA_RESP_ERR_UNKNOWN_TOPIC_OR_PART;
+                                }
+                        }
+
+                        rd_kafka_mock_buf_write_Metadata_Topic(
+                            mcluster, resp, rkbuf->rkbuf_reqhdr.ApiVersion,
+                            topic_id, topic_name, mtopic,
+                            err ? err : mtopic->err);
+                }
+
+        } else {
+                /* Response: #Topics: brokers only */
+                rd_kafka_buf_write_arraycnt(resp, 0);
+        }
+
+        if (rkbuf->rkbuf_reqhdr.ApiVersion >= 8 &&
+            rkbuf->rkbuf_reqhdr.ApiVersion <= 10) {
+                /* ClusterAuthorizedOperations */
+                rd_kafka_buf_write_i32(resp, INT32_MIN);
+        }
+
+        rd_kafka_buf_skip_tags(rkbuf);
+        rd_kafka_buf_write_tags_empty(resp);
+
+        if (requested_topics)
+                rd_kafka_topic_partition_list_destroy(requested_topics);
+
+        rd_kafka_mock_connection_send_response(mconn, resp);
+
+        return 0;
+
+err_parse:
+        if (requested_topics)
+                rd_kafka_topic_partition_list_destroy(requested_topics);
+
+        rd_kafka_buf_destroy(resp);
+        return -1;
+}
+
+
+/**
+ * @brief Handle FindCoordinatorRequest
+ */
+static int
+rd_kafka_mock_handle_FindCoordinator(rd_kafka_mock_connection_t *mconn,
+                                     rd_kafka_buf_t *rkbuf) {
+        rd_kafka_mock_cluster_t *mcluster = mconn->broker->cluster;
+        const rd_bool_t log_decode_errors = rd_true;
+        rd_kafka_buf_t *resp = rd_kafka_mock_buf_new_response(rkbuf);
+        rd_kafkap_str_t Key;
+        int8_t KeyType                     = RD_KAFKA_COORD_GROUP;
+        const rd_kafka_mock_broker_t *mrkb = NULL;
+        rd_kafka_resp_err_t err;
+
+        /* Key */
+        rd_kafka_buf_read_str(rkbuf, &Key);
+
+        if (rkbuf->rkbuf_reqhdr.ApiVersion >= 1) {
+                /* KeyType */
+                rd_kafka_buf_read_i8(rkbuf, &KeyType);
+        }
+
+
+        /*
+         * Construct response
+         */
+        if (rkbuf->rkbuf_reqhdr.ApiVersion >= 1) {
+                /* Response: Throttle */
+                rd_kafka_buf_write_i32(resp, 0);
+        }
+
+        /* Inject error, if any */
+        err = rd_kafka_mock_next_request_error(mconn, resp);
+
+        if (!err && RD_KAFKAP_STR_LEN(&Key) > 0) {
+                mrkb = rd_kafka_mock_cluster_get_coord(mcluster, KeyType, &Key);
+                rd_assert(mrkb);
+        }
+
+        if (!mrkb && !err)
+                err = RD_KAFKA_RESP_ERR_COORDINATOR_NOT_AVAILABLE;
+
+        if (err) {
+                /* Response: ErrorCode and ErrorMessage */
+                rd_kafka_buf_write_i16(resp, err);
+                if (rkbuf->rkbuf_reqhdr.ApiVersion >= 1)
+                        rd_kafka_buf_write_str(resp, rd_kafka_err2str(err), -1);
+
+                /* Response: NodeId, Host, Port */
+                rd_kafka_buf_write_i32(resp, -1);
+                rd_kafka_buf_write_str(resp, NULL, -1);
+                rd_kafka_buf_write_i32(resp, -1);
+        } else {
+                /* Response: ErrorCode and ErrorMessage */
+                rd_kafka_buf_write_i16(resp, 0);
+                if (rkbuf->rkbuf_reqhdr.ApiVersion >= 1)
+                        rd_kafka_buf_write_str(resp, NULL, -1);
+
+                /* Response: NodeId, Host, Port */
+                rd_kafka_buf_write_i32(resp, mrkb->id);
+                rd_kafka_buf_write_str(resp, mrkb->advertised_listener, -1);
+                rd_kafka_buf_write_i32(resp, (int32_t)mrkb->port);
+        }
+
+        rd_kafka_mock_connection_send_response(mconn, resp);
+        return 0;
+
+err_parse:
+        rd_kafka_buf_destroy(resp);
+        return -1;
+}
+
+
+
+/**
+ * @brief Handle JoinGroupRequest
+ */
+static int rd_kafka_mock_handle_JoinGroup(rd_kafka_mock_connection_t *mconn,
+                                          rd_kafka_buf_t *rkbuf) {
+        rd_kafka_mock_cluster_t *mcluster = mconn->broker->cluster;
+        rd_kafka_mock_broker_t *mrkb;
+        const rd_bool_t log_decode_errors = rd_true;
+        rd_kafka_buf_t *resp = rd_kafka_mock_buf_new_response(rkbuf);
+        rd_kafkap_str_t GroupId, MemberId, ProtocolType;
+        rd_kafkap_str_t GroupInstanceId = RD_KAFKAP_STR_INITIALIZER;
+        int32_t SessionTimeoutMs;
+        int32_t MaxPollIntervalMs = -1;
+        int32_t ProtocolCnt       = 0;
+        int32_t i;
+        rd_kafka_resp_err_t err;
+        rd_kafka_mock_cgrp_classic_t *mcgrp;
+        rd_kafka_mock_cgrp_classic_proto_t *protos = NULL;
+
+        rd_kafka_buf_read_str(rkbuf, &GroupId);
+        rd_kafka_buf_read_i32(rkbuf, &SessionTimeoutMs);
+        if (rkbuf->rkbuf_reqhdr.ApiVersion >= 1)
+                rd_kafka_buf_read_i32(rkbuf, &MaxPollIntervalMs);
+        rd_kafka_buf_read_str(rkbuf, &MemberId);
+        if (rkbuf->rkbuf_reqhdr.ApiVersion >= 5)
+                rd_kafka_buf_read_str(rkbuf, &GroupInstanceId);
+        rd_kafka_buf_read_str(rkbuf, &ProtocolType);
+        rd_kafka_buf_read_i32(rkbuf, &ProtocolCnt);
+
+        if (ProtocolCnt > 1000) {
+                rd_kafka_dbg(mcluster->rk, MOCK, "MOCK",
+                             "JoinGroupRequest: ProtocolCnt %" PRId32
+                             " > max allowed 1000",
+                             ProtocolCnt);
+                rd_kafka_buf_destroy(resp);
+                return -1;
+        }
+
+        protos = rd_malloc(sizeof(*protos) * ProtocolCnt);
+        for (i = 0; i < ProtocolCnt; i++) {
+                rd_kafkap_str_t ProtocolName;
+                rd_kafkap_bytes_t Metadata;
+                rd_kafka_buf_read_str(rkbuf, &ProtocolName);
+                rd_kafka_buf_read_kbytes(rkbuf, &Metadata);
+                protos[i].name     = rd_kafkap_str_copy(&ProtocolName);
+                protos[i].metadata = rd_kafkap_bytes_copy(&Metadata);
+        }
+
+        /*
+         * Construct response
+         */
+        if (rkbuf->rkbuf_reqhdr.ApiVersion >= 2) {
+                /* Response: Throttle */
+                rd_kafka_buf_write_i32(resp, 0);
+        }
+
+        /* Inject error, if any */
+        err = rd_kafka_mock_next_request_error(mconn, resp);
+
+        if (!err) {
+                mrkb = rd_kafka_mock_cluster_get_coord(
+                    mcluster, RD_KAFKA_COORD_GROUP, &GroupId);
+
+                if (!mrkb)
+                        err = RD_KAFKA_RESP_ERR_COORDINATOR_NOT_AVAILABLE;
+                else if (mrkb != mconn->broker)
+                        err = RD_KAFKA_RESP_ERR_NOT_COORDINATOR;
+        }
+
+        if (!err) {
+                mcgrp = rd_kafka_mock_cgrp_classic_get(mcluster, &GroupId,
+                                                       &ProtocolType);
+                rd_assert(mcgrp);
+
+                /* This triggers an async rebalance, the response will be
+                 * sent later. */
+                err = rd_kafka_mock_cgrp_classic_member_add(
+                    mcgrp, mconn, resp, &MemberId, &ProtocolType,
+                    &GroupInstanceId, protos, ProtocolCnt, SessionTimeoutMs);
+                if (!err) {
+                        /* .._add() assumes ownership of resp and protos */
+                        protos = NULL;
+                        rd_kafka_mock_connection_set_blocking(mconn, rd_true);
+                        return 0;
+                }
+        }
+
+        rd_kafka_mock_cgrp_classic_protos_destroy(protos, ProtocolCnt);
+
+        /* Error case */
+        rd_kafka_buf_write_i16(resp, err);      /* ErrorCode */
+        rd_kafka_buf_write_i32(resp, -1);       /* GenerationId */
+        rd_kafka_buf_write_str(resp, NULL, -1); /* ProtocolName */
+        rd_kafka_buf_write_str(resp, NULL, -1); /* LeaderId */
+        rd_kafka_buf_write_kstr(resp, NULL);    /* MemberId */
+        rd_kafka_buf_write_i32(resp, 0);        /* MemberCnt */
+
+        rd_kafka_mock_connection_send_response(mconn, resp);
+
+        return 0;
+
+err_parse:
+        rd_kafka_buf_destroy(resp);
+        if (protos)
+                rd_kafka_mock_cgrp_classic_protos_destroy(protos, ProtocolCnt);
+        return -1;
+}
+
+
+/**
+ * @brief Handle HeartbeatRequest
+ */
+static int rd_kafka_mock_handle_Heartbeat(rd_kafka_mock_connection_t *mconn,
+                                          rd_kafka_buf_t *rkbuf) {
+        rd_kafka_mock_cluster_t *mcluster = mconn->broker->cluster;
+        rd_kafka_mock_broker_t *mrkb;
+        const rd_bool_t log_decode_errors = rd_true;
+        rd_kafka_buf_t *resp = rd_kafka_mock_buf_new_response(rkbuf);
+        rd_kafkap_str_t GroupId, MemberId;
+        rd_kafkap_str_t GroupInstanceId = RD_KAFKAP_STR_INITIALIZER;
+        int32_t GenerationId;
+        rd_kafka_resp_err_t err;
+        rd_kafka_mock_cgrp_classic_t *mcgrp;
+        rd_kafka_mock_cgrp_classic_member_t *member = NULL;
+
+        rd_kafka_buf_read_str(rkbuf, &GroupId);
+        rd_kafka_buf_read_i32(rkbuf, &GenerationId);
+        rd_kafka_buf_read_str(rkbuf, &MemberId);
+        if (rkbuf->rkbuf_reqhdr.ApiVersion >= 3)
+                rd_kafka_buf_read_str(rkbuf, &GroupInstanceId);
+
+        /*
+         * Construct response
+         */
+        if (rkbuf->rkbuf_reqhdr.ApiVersion >= 1) {
+                /* Response: Throttle */
+                rd_kafka_buf_write_i32(resp, 0);
+        }
+
+        /* Inject error, if any */
+        err = rd_kafka_mock_next_request_error(mconn, resp);
+        if (!err) {
+                mrkb = rd_kafka_mock_cluster_get_coord(
+                    mcluster, RD_KAFKA_COORD_GROUP, &GroupId);
+
+                if (!mrkb)
+                        err = RD_KAFKA_RESP_ERR_COORDINATOR_NOT_AVAILABLE;
+                else if (mrkb != mconn->broker)
+                        err = RD_KAFKA_RESP_ERR_NOT_COORDINATOR;
+        }
+
+        if (!err) {
+                mcgrp = rd_kafka_mock_cgrp_classic_find(mcluster, &GroupId);
+                if (!mcgrp)
+                        err = RD_KAFKA_RESP_ERR_GROUP_ID_NOT_FOUND;
+        }
+
+        if (!err) {
+                member =
+                    rd_kafka_mock_cgrp_classic_member_find(mcgrp, &MemberId);
+                if (!member)
+                        err = RD_KAFKA_RESP_ERR_UNKNOWN_MEMBER_ID;
+        }
+
+        if (!err)
+                err = rd_kafka_mock_cgrp_classic_check_state(
+                    mcgrp, member, rkbuf, GenerationId);
+
+        if (!err)
+                rd_kafka_mock_cgrp_classic_member_active(mcgrp, member);
+
+        rd_kafka_buf_write_i16(resp, err); /* ErrorCode */
+
+        rd_kafka_mock_connection_send_response(mconn, resp);
+
+        return 0;
+
+err_parse:
+        rd_kafka_buf_destroy(resp);
+        return -1;
+}
+
+
+/**
+ * @brief Handle LeaveGroupRequest
+ */
+static int rd_kafka_mock_handle_LeaveGroup(rd_kafka_mock_connection_t *mconn,
+                                           rd_kafka_buf_t *rkbuf) {
+        rd_kafka_mock_cluster_t *mcluster = mconn->broker->cluster;
+        rd_kafka_mock_broker_t *mrkb;
+        const rd_bool_t log_decode_errors = rd_true;
+        rd_kafka_buf_t *resp = rd_kafka_mock_buf_new_response(rkbuf);
+        rd_kafkap_str_t GroupId, MemberId;
+        rd_kafka_resp_err_t err;
+        rd_kafka_mock_cgrp_classic_t *mcgrp;
+        rd_kafka_mock_cgrp_classic_member_t *member = NULL;
+
+        rd_kafka_buf_read_str(rkbuf, &GroupId);
+        rd_kafka_buf_read_str(rkbuf, &MemberId);
+
+        /*
+         * Construct response
+         */
+
+        if (rkbuf->rkbuf_reqhdr.ApiVersion >= 1) {
+                /* Response: Throttle */
+                rd_kafka_buf_write_i32(resp, 0);
+        }
+
+        /* Inject error, if any */
+        err = rd_kafka_mock_next_request_error(mconn, resp);
+        if (!err) {
+                mrkb = rd_kafka_mock_cluster_get_coord(
+                    mcluster, RD_KAFKA_COORD_GROUP, &GroupId);
+
+                if (!mrkb)
+                        err = RD_KAFKA_RESP_ERR_COORDINATOR_NOT_AVAILABLE;
+                else if (mrkb != mconn->broker)
+                        err = RD_KAFKA_RESP_ERR_NOT_COORDINATOR;
+        }
+
+        if (!err) {
+                mcgrp = rd_kafka_mock_cgrp_classic_find(mcluster, &GroupId);
+                if (!mcgrp)
+                        err = RD_KAFKA_RESP_ERR_GROUP_ID_NOT_FOUND;
+        }
+
+        if (!err) {
+                member =
+                    rd_kafka_mock_cgrp_classic_member_find(mcgrp, &MemberId);
+                if (!member)
+                        err = RD_KAFKA_RESP_ERR_UNKNOWN_MEMBER_ID;
+        }
+
+        if (!err)
+                err = rd_kafka_mock_cgrp_classic_check_state(mcgrp, member,
+                                                             rkbuf, -1);
+
+        if (!err)
+                rd_kafka_mock_cgrp_classic_member_leave(mcgrp, member);
+
+        rd_kafka_buf_write_i16(resp, err); /* ErrorCode */
+
+        rd_kafka_mock_connection_send_response(mconn, resp);
+
+        return 0;
+
+err_parse:
+        rd_kafka_buf_destroy(resp);
+        return -1;
+}
+
+
+
+/**
+ * @brief Handle SyncGroupRequest
+ */
+static int rd_kafka_mock_handle_SyncGroup(rd_kafka_mock_connection_t *mconn,
+                                          rd_kafka_buf_t *rkbuf) {
+        rd_kafka_mock_cluster_t *mcluster = mconn->broker->cluster;
+        rd_kafka_mock_broker_t *mrkb;
+        const rd_bool_t log_decode_errors = rd_true;
+        rd_kafka_buf_t *resp = rd_kafka_mock_buf_new_response(rkbuf);
+        rd_kafkap_str_t GroupId, MemberId;
+        rd_kafkap_str_t GroupInstanceId = RD_KAFKAP_STR_INITIALIZER;
+        int32_t GenerationId, AssignmentCnt;
+        int32_t i;
+        rd_kafka_resp_err_t err;
+        rd_kafka_mock_cgrp_classic_t *mcgrp         = NULL;
+        rd_kafka_mock_cgrp_classic_member_t *member = NULL;
+
+        rd_kafka_buf_read_str(rkbuf, &GroupId);
+        rd_kafka_buf_read_i32(rkbuf, &GenerationId);
+        rd_kafka_buf_read_str(rkbuf, &MemberId);
+        if (rkbuf->rkbuf_reqhdr.ApiVersion >= 3)
+                rd_kafka_buf_read_str(rkbuf, &GroupInstanceId);
+        rd_kafka_buf_read_i32(rkbuf, &AssignmentCnt);
+
+        /*
+         * Construct response
+         */
+        if (rkbuf->rkbuf_reqhdr.ApiVersion >= 1) {
+                /* Response: Throttle */
+                rd_kafka_buf_write_i32(resp, 0);
+        }
+
+        /* Inject error, if any */
+        err = rd_kafka_mock_next_request_error(mconn, resp);
+        if (!err) {
+                mrkb = rd_kafka_mock_cluster_get_coord(
+                    mcluster, RD_KAFKA_COORD_GROUP, &GroupId);
+
+                if (!mrkb)
+                        err = RD_KAFKA_RESP_ERR_COORDINATOR_NOT_AVAILABLE;
+                else if (mrkb != mconn->broker)
+                        err = RD_KAFKA_RESP_ERR_NOT_COORDINATOR;
+        }
+
+        if (!err) {
+                mcgrp = rd_kafka_mock_cgrp_classic_find(mcluster, &GroupId);
+                if (!mcgrp)
+                        err = RD_KAFKA_RESP_ERR_GROUP_ID_NOT_FOUND;
+        }
+
+        if (!err) {
+                member =
+                    rd_kafka_mock_cgrp_classic_member_find(mcgrp, &MemberId);
+                if (!member)
+                        err = RD_KAFKA_RESP_ERR_UNKNOWN_MEMBER_ID;
+        }
+
+        if (!err)
+                err = rd_kafka_mock_cgrp_classic_check_state(
+                    mcgrp, member, rkbuf, GenerationId);
+
+        if (!err)
+                rd_kafka_mock_cgrp_classic_member_active(mcgrp, member);
+
+        if (!err) {
+                rd_bool_t is_leader = mcgrp->leader && mcgrp->leader == member;
+
+                if (AssignmentCnt > 0 && !is_leader)
+                        err =
+                            RD_KAFKA_RESP_ERR_NOT_LEADER_FOR_PARTITION; /* FIXME
+                                                                         */
+                else if (AssignmentCnt == 0 && is_leader)
+                        err = RD_KAFKA_RESP_ERR_INVALID_PARTITIONS; /* FIXME */
+        }
+
+        for (i = 0; i < AssignmentCnt; i++) {
+                rd_kafkap_str_t MemberId2;
+                rd_kafkap_bytes_t Metadata;
+                rd_kafka_mock_cgrp_classic_member_t *member2;
+
+                rd_kafka_buf_read_str(rkbuf, &MemberId2);
+                rd_kafka_buf_read_kbytes(rkbuf, &Metadata);
+
+                if (err)
+                        continue;
+
+                /* Find member */
+                member2 =
+                    rd_kafka_mock_cgrp_classic_member_find(mcgrp, &MemberId2);
+                if (!member2)
+                        continue;
+
+                rd_kafka_mock_cgrp_classic_member_assignment_set(mcgrp, member2,
+                                                                 &Metadata);
+        }
+
+        if (!err) {
+                err = rd_kafka_mock_cgrp_classic_member_sync_set(mcgrp, member,
+                                                                 mconn, resp);
+                /* .._sync_set() assumes ownership of resp */
+                if (!err)
+                        return 0; /* Response will be sent when all members
+                                   * are synchronized */
+        }
+
+        /* Error case */
+        rd_kafka_buf_write_i16(resp, err);        /* ErrorCode */
+        rd_kafka_buf_write_bytes(resp, NULL, -1); /* MemberState */
+
+        rd_kafka_mock_connection_send_response(mconn, resp);
+
+        return 0;
+
+err_parse:
+        rd_kafka_buf_destroy(resp);
+        return -1;
+}
+
+
+
+/**
+ * @brief Generate a unique ProducerID
+ */
+static const rd_kafka_pid_t
+rd_kafka_mock_pid_new(rd_kafka_mock_cluster_t *mcluster,
+                      const rd_kafkap_str_t *TransactionalId) {
+        size_t tidlen =
+            TransactionalId ? RD_KAFKAP_STR_LEN(TransactionalId) : 0;
+        rd_kafka_mock_pid_t *mpid = rd_malloc(sizeof(*mpid) + tidlen);
+        rd_kafka_pid_t ret;
+
+        mpid->pid.id    = rd_jitter(1, 900000) * 1000;
+        mpid->pid.epoch = 0;
+
+        if (tidlen > 0)
+                memcpy(mpid->TransactionalId, TransactionalId->str, tidlen);
+        mpid->TransactionalId[tidlen] = '\0';
+
+        mtx_lock(&mcluster->lock);
+        rd_list_add(&mcluster->pids, mpid);
+        ret = mpid->pid;
+        mtx_unlock(&mcluster->lock);
+
+        return ret;
+}
+
+
+/**
+ * @brief Finds a matching mcluster mock PID for the given \p pid.
+ *
+ * @locks_required mcluster->lock
+ */
+rd_kafka_resp_err_t
+rd_kafka_mock_pid_find(rd_kafka_mock_cluster_t *mcluster,
+                       const rd_kafkap_str_t *TransactionalId,
+                       const rd_kafka_pid_t pid,
+                       rd_kafka_mock_pid_t **mpidp) {
+        rd_kafka_mock_pid_t *mpid;
+        rd_kafka_mock_pid_t skel = {pid};
+
+        *mpidp = NULL;
+        mpid = rd_list_find(&mcluster->pids, &skel, rd_kafka_mock_pid_cmp_pid);
+
+        if (!mpid)
+                return RD_KAFKA_RESP_ERR_UNKNOWN_PRODUCER_ID;
+        else if (((TransactionalId != NULL) !=
+                  (*mpid->TransactionalId != '\0')) ||
+                 (TransactionalId &&
+                  rd_kafkap_str_cmp_str(TransactionalId,
+                                        mpid->TransactionalId)))
+                return RD_KAFKA_RESP_ERR_INVALID_PRODUCER_ID_MAPPING;
+
+        *mpidp = mpid;
+        return RD_KAFKA_RESP_ERR_NO_ERROR;
+}
+
+
+/**
+ * @brief Checks if the given pid is known, else returns an error.
+ */
+static rd_kafka_resp_err_t
+rd_kafka_mock_pid_check(rd_kafka_mock_cluster_t *mcluster,
+                        const rd_kafkap_str_t *TransactionalId,
+                        const rd_kafka_pid_t check_pid) {
+        rd_kafka_mock_pid_t *mpid;
+        rd_kafka_resp_err_t err = RD_KAFKA_RESP_ERR_NO_ERROR;
+
+        mtx_lock(&mcluster->lock);
+        err =
+            rd_kafka_mock_pid_find(mcluster, TransactionalId, check_pid, &mpid);
+        if (!err && check_pid.epoch != mpid->pid.epoch)
+                err = RD_KAFKA_RESP_ERR_INVALID_PRODUCER_EPOCH;
+        mtx_unlock(&mcluster->lock);
+
+        if (unlikely(err))
+                rd_kafka_dbg(mcluster->rk, MOCK, "MOCK",
+                             "PID check failed for TransactionalId=%.*s: "
+                             "expected %s, not %s: %s",
+                             RD_KAFKAP_STR_PR(TransactionalId),
+                             mpid ? rd_kafka_pid2str(mpid->pid) : "none",
+                             rd_kafka_pid2str(check_pid),
+                             rd_kafka_err2name(err));
+        return err;
+}
+
+
+/**
+ * @brief Bump the epoch for an existing pid, or return an error
+ *        if the current_pid does not match an existing pid.
+ */
+static rd_kafka_resp_err_t
+rd_kafka_mock_pid_bump(rd_kafka_mock_cluster_t *mcluster,
+                       const rd_kafkap_str_t *TransactionalId,
+                       rd_kafka_pid_t *current_pid) {
+        rd_kafka_mock_pid_t *mpid;
+        rd_kafka_resp_err_t err;
+
+        mtx_lock(&mcluster->lock);
+        err = rd_kafka_mock_pid_find(mcluster, TransactionalId, *current_pid,
+                                     &mpid);
+        if (err) {
+                mtx_unlock(&mcluster->lock);
+                return err;
+        }
+
+        if (current_pid->epoch != mpid->pid.epoch) {
+                mtx_unlock(&mcluster->lock);
+                return RD_KAFKA_RESP_ERR_INVALID_PRODUCER_EPOCH;
+        }
+
+        mpid->pid.epoch++;
+        *current_pid = mpid->pid;
+        mtx_unlock(&mcluster->lock);
+
+        rd_kafka_dbg(mcluster->rk, MOCK, "MOCK", "Bumped PID %s",
+                     rd_kafka_pid2str(*current_pid));
+
+        return RD_KAFKA_RESP_ERR_NO_ERROR;
+}
+
+
+/**
+ * @brief Handle InitProducerId
+ */
+static int
+rd_kafka_mock_handle_InitProducerId(rd_kafka_mock_connection_t *mconn,
+                                    rd_kafka_buf_t *rkbuf) {
+        rd_kafka_mock_cluster_t *mcluster = mconn->broker->cluster;
+        const rd_bool_t log_decode_errors = rd_true;
+        rd_kafka_buf_t *resp = rd_kafka_mock_buf_new_response(rkbuf);
+        rd_kafkap_str_t TransactionalId;
+        rd_kafka_pid_t pid         = RD_KAFKA_PID_INITIALIZER;
+        rd_kafka_pid_t current_pid = RD_KAFKA_PID_INITIALIZER;
+        int32_t TxnTimeoutMs;
+        rd_kafka_resp_err_t err;
+
+        /* TransactionalId */
+        rd_kafka_buf_read_str(rkbuf, &TransactionalId);
+        /* TransactionTimeoutMs */
+        rd_kafka_buf_read_i32(rkbuf, &TxnTimeoutMs);
+
+        if (rkbuf->rkbuf_reqhdr.ApiVersion >= 3) {
+                /* ProducerId */
+                rd_kafka_buf_read_i64(rkbuf, &current_pid.id);
+                /* ProducerEpoch */
+                rd_kafka_buf_read_i16(rkbuf, &current_pid.epoch);
+        }
+
+        /*
+         * Construct response
+         */
+
+        /* ThrottleTimeMs */
+        rd_kafka_buf_write_i32(resp, 0);
+
+        /* Inject error */
+        err = rd_kafka_mock_next_request_error(mconn, resp);
+
+        if (!err && !RD_KAFKAP_STR_IS_NULL(&TransactionalId)) {
+                if (RD_KAFKAP_STR_LEN(&TransactionalId) == 0)
+                        err = RD_KAFKA_RESP_ERR_INVALID_REQUEST;
+                else if (rd_kafka_mock_cluster_get_coord(
+                             mcluster, RD_KAFKA_COORD_TXN, &TransactionalId) !=
+                         mconn->broker)
+                        err = RD_KAFKA_RESP_ERR_NOT_COORDINATOR;
+        }
+
+        if (!err) {
+                if (rd_kafka_pid_valid(current_pid)) {
+                        /* Producer is asking for the transactional coordinator
+                         * to bump the epoch (KIP-360).
+                         * Verify that current_pid matches and then
+                         * bump the epoch. */
+                        err = rd_kafka_mock_pid_bump(mcluster, &TransactionalId,
+                                                     &current_pid);
+                        if (!err)
+                                pid = current_pid;
+
+                } else {
+                        /* Generate a new pid */
+                        pid = rd_kafka_mock_pid_new(mcluster, &TransactionalId);
+                }
+        }
+
+        /* ErrorCode */
+        rd_kafka_buf_write_i16(resp, err);
+
+        /* ProducerId */
+        rd_kafka_buf_write_i64(resp, pid.id);
+        /* ProducerEpoch */
+        rd_kafka_buf_write_i16(resp, pid.epoch);
+
+        rd_kafka_mock_connection_send_response(mconn, resp);
+
+        return 0;
+
+err_parse:
+        rd_kafka_buf_destroy(resp);
+        return -1;
+}
+
+
+
+/**
+ * @brief Handle AddPartitionsToTxn
+ */
+static int
+rd_kafka_mock_handle_AddPartitionsToTxn(rd_kafka_mock_connection_t *mconn,
+                                        rd_kafka_buf_t *rkbuf) {
+        rd_kafka_mock_cluster_t *mcluster = mconn->broker->cluster;
+        const rd_bool_t log_decode_errors = rd_true;
+        rd_kafka_buf_t *resp = rd_kafka_mock_buf_new_response(rkbuf);
+        rd_kafka_resp_err_t all_err;
+        rd_kafkap_str_t TransactionalId;
+        rd_kafka_pid_t pid;
+        int32_t TopicsCnt;
+
+        /* Response: ThrottleTimeMs */
+        rd_kafka_buf_write_i32(resp, 0);
+
+        /* TransactionalId */
+        rd_kafka_buf_read_str(rkbuf, &TransactionalId);
+        /* ProducerId */
+        rd_kafka_buf_read_i64(rkbuf, &pid.id);
+        /* Epoch */
+        rd_kafka_buf_read_i16(rkbuf, &pid.epoch);
+        /* #Topics */
+        rd_kafka_buf_read_i32(rkbuf, &TopicsCnt);
+
+        /* Response: #Results */
+        rd_kafka_buf_write_i32(resp, TopicsCnt);
+
+        /* Inject error */
+        all_err = rd_kafka_mock_next_request_error(mconn, resp);
+
+        if (!all_err &&
+            rd_kafka_mock_cluster_get_coord(mcluster, RD_KAFKA_COORD_TXN,
+                                            &TransactionalId) != mconn->broker)
+                all_err = RD_KAFKA_RESP_ERR_NOT_COORDINATOR;
+
+        if (!all_err)
+                all_err =
+                    rd_kafka_mock_pid_check(mcluster, &TransactionalId, pid);
+
+        while (TopicsCnt-- > 0) {
+                rd_kafkap_str_t Topic;
+                int32_t PartsCnt;
+                const rd_kafka_mock_topic_t *mtopic;
+
+                /* Topic */
+                rd_kafka_buf_read_str(rkbuf, &Topic);
+                /* Response: Topic */
+                rd_kafka_buf_write_kstr(resp, &Topic);
+
+                /* #Partitions */
+                rd_kafka_buf_read_i32(rkbuf, &PartsCnt);
+                /* Response: #Partitions */
+                rd_kafka_buf_write_i32(resp, PartsCnt);
+
+                mtopic = rd_kafka_mock_topic_find_by_kstr(mcluster, &Topic);
+
+                while (PartsCnt--) {
+                        int32_t Partition;
+                        rd_kafka_resp_err_t err = all_err;
+
+                        /* Partition */
+                        rd_kafka_buf_read_i32(rkbuf, &Partition);
+                        /* Response: Partition */
+                        rd_kafka_buf_write_i32(resp, Partition);
+
+                        if (!mtopic || Partition < 0 ||
+                            Partition >= mtopic->partition_cnt)
+                                err = RD_KAFKA_RESP_ERR_UNKNOWN_TOPIC_OR_PART;
+                        else if (mtopic && mtopic->err)
+                                err = mtopic->err;
+
+                        /* Response: ErrorCode */
+                        rd_kafka_buf_write_i16(resp, err);
+                }
+        }
+
+        rd_kafka_mock_connection_send_response(mconn, resp);
+
+        return 0;
+
+err_parse:
+        rd_kafka_buf_destroy(resp);
+        return -1;
+}
+
+
+/**
+ * @brief Handle AddOffsetsToTxn
+ */
+static int
+rd_kafka_mock_handle_AddOffsetsToTxn(rd_kafka_mock_connection_t *mconn,
+                                     rd_kafka_buf_t *rkbuf) {
+        rd_kafka_mock_cluster_t *mcluster = mconn->broker->cluster;
+        const rd_bool_t log_decode_errors = rd_true;
+        rd_kafka_buf_t *resp = rd_kafka_mock_buf_new_response(rkbuf);
+        rd_kafka_resp_err_t err;
+        rd_kafkap_str_t TransactionalId, GroupId;
+        rd_kafka_pid_t pid;
+
+        /* TransactionalId */
+        rd_kafka_buf_read_str(rkbuf, &TransactionalId);
+        /* ProducerId */
+        rd_kafka_buf_read_i64(rkbuf, &pid.id);
+        /* Epoch */
+        rd_kafka_buf_read_i16(rkbuf, &pid.epoch);
+        /* GroupIdId */
+        rd_kafka_buf_read_str(rkbuf, &GroupId);
+
+        /* Response: ThrottleTimeMs */
+        rd_kafka_buf_write_i32(resp, 0);
+
+        /* Inject error */
+        err = rd_kafka_mock_next_request_error(mconn, resp);
+
+        if (!err &&
+            rd_kafka_mock_cluster_get_coord(mcluster, RD_KAFKA_COORD_TXN,
+                                            &TransactionalId) != mconn->broker)
+                err = RD_KAFKA_RESP_ERR_NOT_COORDINATOR;
+
+        if (!err)
+                err = rd_kafka_mock_pid_check(mcluster, &TransactionalId, pid);
+
+        /* Response: ErrorCode */
+        rd_kafka_buf_write_i16(resp, err);
+
+        rd_kafka_mock_connection_send_response(mconn, resp);
+
+        return 0;
+
+err_parse:
+        rd_kafka_buf_destroy(resp);
+        return -1;
+}
+
+
+/**
+ * @brief Handle TxnOffsetCommit
+ */
+static int
+rd_kafka_mock_handle_TxnOffsetCommit(rd_kafka_mock_connection_t *mconn,
+                                     rd_kafka_buf_t *rkbuf) {
+        rd_kafka_mock_cluster_t *mcluster = mconn->broker->cluster;
+        const rd_bool_t log_decode_errors = rd_true;
+        rd_kafka_buf_t *resp = rd_kafka_mock_buf_new_response(rkbuf);
+        rd_kafka_resp_err_t err;
+        rd_kafkap_str_t TransactionalId, GroupId;
+        rd_kafka_pid_t pid;
+        int32_t TopicsCnt;
+
+        /* Response: ThrottleTimeMs */
+        rd_kafka_buf_write_i32(resp, 0);
+
+        /* TransactionalId */
+        rd_kafka_buf_read_str(rkbuf, &TransactionalId);
+        /* GroupId */
+        rd_kafka_buf_read_str(rkbuf, &GroupId);
+        /* ProducerId */
+        rd_kafka_buf_read_i64(rkbuf, &pid.id);
+        /* Epoch */
+        rd_kafka_buf_read_i16(rkbuf, &pid.epoch);
+
+        if (rkbuf->rkbuf_reqhdr.ApiVersion >= 3) {
+                int32_t GenerationId;
+                rd_kafkap_str_t kMemberId, kGroupInstanceId;
+
+                /* GenerationId */
+                rd_kafka_buf_read_i32(rkbuf, &GenerationId);
+                /* MemberId */
+                rd_kafka_buf_read_str(rkbuf, &kMemberId);
+                /* GroupInstanceId */
+                rd_kafka_buf_read_str(rkbuf, &kGroupInstanceId);
+        }
+
+        /* #Topics */
+        rd_kafka_buf_read_arraycnt(rkbuf, &TopicsCnt, 100000);
+
+        /* Response: #Results */
+        rd_kafka_buf_write_arraycnt(resp, TopicsCnt);
+
+        /* Inject error */
+        err = rd_kafka_mock_next_request_error(mconn, resp);
+
+        if (!err &&
+            rd_kafka_mock_cluster_get_coord(mcluster, RD_KAFKA_COORD_GROUP,
+                                            &GroupId) != mconn->broker)
+                err = RD_KAFKA_RESP_ERR_NOT_COORDINATOR;
+
+        if (!err)
+                err = rd_kafka_mock_pid_check(mcluster, &TransactionalId, pid);
+
+        while (TopicsCnt-- > 0) {
+                rd_kafkap_str_t Topic;
+                int32_t PartsCnt;
+                rd_kafka_mock_topic_t *mtopic;
+
+                /* Topic */
+                rd_kafka_buf_read_str(rkbuf, &Topic);
+                /* Response: Topic */
+                rd_kafka_buf_write_kstr(resp, &Topic);
+
+                mtopic = rd_kafka_mock_topic_find_by_kstr(mcluster, &Topic);
+
+                /* #Partitions */
+                rd_kafka_buf_read_arraycnt(rkbuf, &PartsCnt, 100000);
+
+                /* Response: #Partitions */
+                rd_kafka_buf_write_arraycnt(resp, PartsCnt);
+
+                while (PartsCnt-- > 0) {
+                        int32_t Partition;
+                        int64_t Offset;
+                        rd_kafkap_str_t Metadata;
+                        rd_kafka_mock_partition_t *mpart;
+
+                        /* Partition */
+                        rd_kafka_buf_read_i32(rkbuf, &Partition);
+                        /* Response: Partition */
+                        rd_kafka_buf_write_i32(resp, Partition);
+
+                        mpart = rd_kafka_mock_partition_find(mtopic, Partition);
+                        if (!err && !mpart)
+                                err = RD_KAFKA_RESP_ERR_UNKNOWN_TOPIC_OR_PART;
+
+                        /* CommittedOffset */
+                        rd_kafka_buf_read_i64(rkbuf, &Offset);
+
+                        if (rkbuf->rkbuf_reqhdr.ApiVersion >= 2) {
+                                /* CommittedLeaderEpoch */
+                                int32_t CommittedLeaderEpoch;
+                                rd_kafka_buf_read_i32(rkbuf,
+                                                      &CommittedLeaderEpoch);
+                                if (!err && mpart)
+                                        err =
+                                            rd_kafka_mock_partition_leader_epoch_check(
+                                                mpart, CommittedLeaderEpoch);
+                        }
+
+                        /* CommittedMetadata */
+                        rd_kafka_buf_read_str(rkbuf, &Metadata);
+
+                        /* Response: ErrorCode */
+                        rd_kafka_buf_write_i16(resp, err);
+
+                        /* Request: Struct tags */
+                        rd_kafka_buf_skip_tags(rkbuf);
+
+                        /* Response: Struct tags */
+                        rd_kafka_buf_write_tags_empty(resp);
+                }
+
+                /* Request: Struct tags */
+                rd_kafka_buf_skip_tags(rkbuf);
+
+                /* Response: Struct tags */
+                rd_kafka_buf_write_tags_empty(resp);
+        }
+
+        rd_kafka_mock_connection_send_response(mconn, resp);
+
+        return 0;
+
+err_parse:
+        rd_kafka_buf_destroy(resp);
+        return -1;
+}
+
+
+/**
+ * @brief Handle EndTxn
+ */
+static int rd_kafka_mock_handle_EndTxn(rd_kafka_mock_connection_t *mconn,
+                                       rd_kafka_buf_t *rkbuf) {
+        rd_kafka_mock_cluster_t *mcluster = mconn->broker->cluster;
+        const rd_bool_t log_decode_errors = rd_true;
+        rd_kafka_buf_t *resp = rd_kafka_mock_buf_new_response(rkbuf);
+        rd_kafka_resp_err_t err;
+        rd_kafkap_str_t TransactionalId;
+        rd_kafka_pid_t pid;
+        rd_bool_t committed;
+
+        /* TransactionalId */
+        rd_kafka_buf_read_str(rkbuf, &TransactionalId);
+        /* ProducerId */
+        rd_kafka_buf_read_i64(rkbuf, &pid.id);
+        /* ProducerEpoch */
+        rd_kafka_buf_read_i16(rkbuf, &pid.epoch);
+        /* Committed */
+        rd_kafka_buf_read_bool(rkbuf, &committed);
+
+        /*
+         * Construct response
+         */
+
+        /* ThrottleTimeMs */
+        rd_kafka_buf_write_i32(resp, 0);
+
+        /* Inject error */
+        err = rd_kafka_mock_next_request_error(mconn, resp);
+
+        if (!err &&
+            rd_kafka_mock_cluster_get_coord(mcluster, RD_KAFKA_COORD_TXN,
+                                            &TransactionalId) != mconn->broker)
+                err = RD_KAFKA_RESP_ERR_NOT_COORDINATOR;
+
+        if (!err)
+                err = rd_kafka_mock_pid_check(mcluster, &TransactionalId, pid);
+
+        /* ErrorCode */
+        rd_kafka_buf_write_i16(resp, err);
+
+        rd_kafka_mock_connection_send_response(mconn, resp);
+
+        return 0;
+
+err_parse:
+        rd_kafka_buf_destroy(resp);
+        return -1;
+}
+
+static int
+rd_kafka_mock_handle_OffsetForLeaderEpoch(rd_kafka_mock_connection_t *mconn,
+                                          rd_kafka_buf_t *rkbuf) {
+        const rd_bool_t log_decode_errors = rd_true;
+        rd_kafka_mock_cluster_t *mcluster = mconn->broker->cluster;
+        rd_kafka_buf_t *resp = rd_kafka_mock_buf_new_response(rkbuf);
+        rd_kafka_resp_err_t err;
+        int32_t TopicsCnt, i;
+
+        /* Response: ThrottleTimeMs */
+        rd_kafka_buf_write_i32(resp, 0);
+
+        /* #Topics */
+        rd_kafka_buf_read_arraycnt(rkbuf, &TopicsCnt, RD_KAFKAP_TOPICS_MAX);
+
+        /* Response: #Topics */
+        rd_kafka_buf_write_arraycnt(resp, TopicsCnt);
+
+        /* Inject error */
+        err = rd_kafka_mock_next_request_error(mconn, resp);
+
+        for (i = 0; i < TopicsCnt; i++) {
+                rd_kafkap_str_t Topic;
+                int32_t PartitionsCnt, j;
+                rd_kafka_mock_topic_t *mtopic;
+
+                /* Topic */
+                rd_kafka_buf_read_str(rkbuf, &Topic);
+
+                mtopic = rd_kafka_mock_topic_find_by_kstr(mcluster, &Topic);
+
+                /* Response: Topic */
+                rd_kafka_buf_write_kstr(resp, &Topic);
+
+                /* #Partitions */
+                rd_kafka_buf_read_arraycnt(rkbuf, &PartitionsCnt,
+                                           RD_KAFKAP_PARTITIONS_MAX);
+
+                /* Response: #Partitions */
+                rd_kafka_buf_write_arraycnt(resp, PartitionsCnt);
+
+                for (j = 0; j < PartitionsCnt; j++) {
+                        rd_kafka_mock_partition_t *mpart;
+                        int32_t Partition, CurrentLeaderEpoch, LeaderEpoch;
+                        int64_t EndOffset = -1;
+
+                        /* Partition */
+                        rd_kafka_buf_read_i32(rkbuf, &Partition);
+                        /* CurrentLeaderEpoch */
+                        rd_kafka_buf_read_i32(rkbuf, &CurrentLeaderEpoch);
+                        /* LeaderEpoch */
+                        rd_kafka_buf_read_i32(rkbuf, &LeaderEpoch);
+
+                        mpart = rd_kafka_mock_partition_find(mtopic, Partition);
+                        if (!err && !mpart)
+                                err = RD_KAFKA_RESP_ERR_UNKNOWN_TOPIC_OR_PART;
+
+                        if (!err && mpart)
+                                err =
+                                    rd_kafka_mock_partition_leader_epoch_check(
+                                        mpart, CurrentLeaderEpoch);
+
+                        if (!err && mpart) {
+                                EndOffset =
+                                    rd_kafka_mock_partition_offset_for_leader_epoch(
+                                        mpart, LeaderEpoch);
+                        }
+
+                        /* Response: ErrorCode */
+                        rd_kafka_buf_write_i16(resp, err);
+                        /* Response: Partition */
+                        rd_kafka_buf_write_i32(resp, Partition);
+                        /* Response: LeaderEpoch */
+                        rd_kafka_buf_write_i32(resp, LeaderEpoch);
+                        /* Response: Partition */
+                        rd_kafka_buf_write_i64(resp, EndOffset);
+                }
+        }
+
+        rd_kafka_mock_connection_send_response(mconn, resp);
+
+        return 0;
+
+err_parse:
+        rd_kafka_buf_destroy(resp);
+        return -1;
+}
+
+/**
+ * @brief Handle GetTelemetrySubscriptions
+ */
+static int rd_kafka_mock_handle_GetTelemetrySubscriptions(
+    rd_kafka_mock_connection_t *mconn,
+    rd_kafka_buf_t *rkbuf) {
+        const rd_bool_t log_decode_errors = rd_true;
+        rd_kafka_mock_cluster_t *mcluster = mconn->broker->cluster;
+        rd_kafka_buf_t *resp = rd_kafka_mock_buf_new_response(rkbuf);
+        rd_kafka_resp_err_t err;
+        size_t i;
+        rd_kafka_Uuid_t ClientInstanceId;
+        rd_kafka_Uuid_t zero_uuid = RD_KAFKA_UUID_ZERO;
+
+        /* Request: ClientInstanceId */
+        rd_kafka_buf_read_uuid(rkbuf, &ClientInstanceId);
+        if (ClientInstanceId.least_significant_bits ==
+                zero_uuid.least_significant_bits &&
+            ClientInstanceId.most_significant_bits ==
+                zero_uuid.most_significant_bits) {
+                /* Some random numbers */
+                ClientInstanceId.least_significant_bits = 129;
+                ClientInstanceId.most_significant_bits  = 298;
+        }
+
+        /* Response: ThrottleTimeMs */
+        rd_kafka_buf_write_i32(resp, 0);
+
+        /* Inject error */
+        err = rd_kafka_mock_next_request_error(mconn, resp);
+
+        /* Response: ErrorCode */
+        rd_kafka_buf_write_i16(resp, err);
+
+        /* Response: ClientInstanceId*/
+        rd_kafka_buf_write_uuid(resp, &ClientInstanceId);
+
+        /* Response: SubscriptionId */
+        // TODO: Calculate subscription ID.
+        rd_kafka_buf_write_i32(resp, 0);
+
+        /* Response: #AcceptedCompressionTypes */
+        rd_kafka_buf_write_arraycnt(resp, 4);
+
+        /* Response: AcceptedCompressionTypes */
+        rd_kafka_buf_write_i8(resp, RD_KAFKA_COMPRESSION_ZSTD);
+        rd_kafka_buf_write_i8(resp, RD_KAFKA_COMPRESSION_LZ4);
+        rd_kafka_buf_write_i8(resp, RD_KAFKA_COMPRESSION_GZIP);
+        rd_kafka_buf_write_i8(resp, RD_KAFKA_COMPRESSION_SNAPPY);
+
+        /* Response: PushIntervalMs */
+        /* We use the value in telemetry_push_interval_ms, and if not set, the
+         * default of 5 minutes. */
+        rd_kafka_buf_write_i32(resp, mcluster->telemetry_push_interval_ms > 0
+                                         ? mcluster->telemetry_push_interval_ms
+                                         : (5 * 60 * 1000));
+
+        /* Response: TelemetryMaxBytes */
+        rd_kafka_buf_write_i32(resp, 10000);
+
+        /* Response: DeltaTemporality */
+        rd_kafka_buf_write_bool(resp, rd_true);
+
+        /* Response: #RequestedMetrics */
+        rd_kafka_buf_write_arraycnt(resp, mcluster->metrics_cnt);
+
+        for (i = 0; i < mcluster->metrics_cnt; i++)
+                rd_kafka_buf_write_str(resp, mcluster->metrics[i], -1);
+
+        rd_kafka_mock_connection_send_response(mconn, resp);
+
+        return 0;
+
+err_parse:
+        rd_kafka_buf_destroy(resp);
+        return -1;
+}
+
+/**
+ * @brief Handle PushTelemetry
+ */
+
+static void rd_kafka_mock_handle_PushTelemetry_decoded_NumberDataPoint(
+    void *opaque,
+    const opentelemetry_proto_metrics_v1_NumberDataPoint *decoded) {
+        rd_kafka_broker_t *rkb = opaque;
+        if (decoded->which_value ==
+            opentelemetry_proto_metrics_v1_NumberDataPoint_as_int_tag)
+                rd_rkb_log(rkb, LOG_INFO, "MOCKTELEMETRY",
+                           "NumberDataPoint int value: %" PRId64
+                           " time: %" PRIu64,
+                           decoded->value.as_int, decoded->time_unix_nano);
+        else if (decoded->which_value ==
+                 opentelemetry_proto_metrics_v1_NumberDataPoint_as_double_tag)
+                rd_rkb_log(rkb, LOG_INFO, "MOCKTELEMETRY",
+                           "NumberDataPoint double value: %f time: %" PRIu64,
+                           decoded->value.as_double, decoded->time_unix_nano);
+}
+
+static void
+rd_kafka_mock_handle_PushTelemetry_decoded_int64(void *opaque,
+                                                 int64_t int64_value) {
+        rd_kafka_broker_t *rkb = opaque;
+        rd_rkb_log(rkb, LOG_INFO, "MOCKTELEMETRY", "int64 value: %" PRId64,
+                   int64_value);
+}
+
+static void
+rd_kafka_mock_handle_PushTelemetry_decoded_string(void *opaque,
+                                                  const uint8_t *decoded) {
+        rd_kafka_broker_t *rkb = opaque;
+        rd_rkb_log(rkb, LOG_INFO, "MOCKTELEMETRY", "string value: %s", decoded);
+}
+
+static void rd_kafka_mock_handle_PushTelemetry_decoded_type(
+    void *opaque,
+    rd_kafka_telemetry_metric_type_t type) {
+        rd_kafka_broker_t *rkb = opaque;
+        rd_rkb_log(rkb, LOG_INFO, "MOCKTELEMETRY", "Metric type: %d", type);
+}
+
+static void rd_kafka_mock_handle_PushTelemetry_decode_error(void *opaque,
+                                                            const char *error,
+                                                            ...) {
+        rd_kafka_broker_t *rkb = opaque;
+        va_list ap;
+        va_start(ap, error);
+        rd_rkb_log(rkb, LOG_ERR, "MOCKTELEMETRY", error, ap);
+        va_end(ap);
+        rd_assert(!*"Failure while decoding telemetry data");
+}
+
+void rd_kafka_mock_handle_PushTelemetry_payload(rd_kafka_broker_t *rkb,
+                                                void *payload,
+                                                size_t size) {
+        rd_kafka_telemetry_decode_interface_t decode_interface = {
+            .decoded_string = rd_kafka_mock_handle_PushTelemetry_decoded_string,
+            .decoded_NumberDataPoint =
+                rd_kafka_mock_handle_PushTelemetry_decoded_NumberDataPoint,
+            .decoded_int64 = rd_kafka_mock_handle_PushTelemetry_decoded_int64,
+            .decoded_type  = rd_kafka_mock_handle_PushTelemetry_decoded_type,
+            .decode_error  = rd_kafka_mock_handle_PushTelemetry_decode_error,
+            .opaque        = rkb,
+        };
+        rd_kafka_telemetry_decode_metrics(&decode_interface, payload, size);
+}
+
+static int rd_kafka_mock_handle_PushTelemetry(rd_kafka_mock_connection_t *mconn,
+                                              rd_kafka_buf_t *rkbuf) {
+        rd_kafka_broker_t *rkb            = mconn->broker->cluster->dummy_rkb;
+        const rd_bool_t log_decode_errors = rd_true;
+        rd_kafka_mock_cluster_t *mcluster = mconn->broker->cluster;
+        rd_kafka_buf_t *resp = rd_kafka_mock_buf_new_response(rkbuf);
+        rd_kafka_Uuid_t ClientInstanceId;
+        int32_t SubscriptionId;
+        rd_bool_t terminating;
+        int8_t CompressionType;
+        rd_kafka_compression_t compression_type = RD_KAFKA_COMPRESSION_NONE;
+        rd_kafkap_bytes_t metrics;
+        rd_kafka_resp_err_t err;
+
+        rd_kafka_buf_read_uuid(rkbuf, &ClientInstanceId);
+        rd_kafka_buf_read_i32(rkbuf, &SubscriptionId);
+        rd_kafka_buf_read_bool(rkbuf, &terminating);
+        rd_kafka_buf_read_i8(rkbuf, &CompressionType);
+        compression_type = CompressionType;
+        rd_kafka_buf_read_kbytes(rkbuf, &metrics);
+
+        void *uncompressed_payload      = NULL;
+        size_t uncompressed_payload_len = 0;
+        rd_assert(metrics.data != NULL);
+
+        if (compression_type != RD_KAFKA_COMPRESSION_NONE) {
+                rd_rkb_log(rkb, LOG_DEBUG, "MOCKTELEMETRY",
+                           "Compression type %s",
+                           rd_kafka_compression2str(compression_type));
+                int err_uncompress =
+                    rd_kafka_telemetry_uncompress_metrics_payload(
+                        rkb, compression_type, (void *)metrics.data,
+                        metrics.len, &uncompressed_payload,
+                        &uncompressed_payload_len);
+                if (err_uncompress) {
+                        rd_kafka_dbg(mcluster->rk, MOCK, "MOCKTELEMETRY",
+                                     "Failed to uncompress "
+                                     "telemetry payload.");
+                        goto err_parse;
+                }
+        } else {
+                uncompressed_payload     = (void *)metrics.data;
+                uncompressed_payload_len = metrics.len;
+        }
+
+        rd_assert(uncompressed_payload != NULL);
+        rd_kafka_mock_handle_PushTelemetry_payload(rkb, uncompressed_payload,
+                                                   uncompressed_payload_len);
+        if (compression_type != RD_KAFKA_COMPRESSION_NONE)
+                rd_free(uncompressed_payload);
+
+        /* ThrottleTime */
+        rd_kafka_buf_write_i32(resp, 0);
+
+        /* ErrorCode */
+        err = rd_kafka_mock_next_request_error(mconn, resp);
+        rd_kafka_buf_write_i16(resp, err);
+
+        rd_kafka_mock_connection_send_response(mconn, resp);
+
+        return 0;
+
+err_parse:
+        rd_kafka_buf_destroy(resp);
+        return -1;
+}
+static void rd_kafka_mock_handle_ConsumerGroupHeartbeat_write_TopicPartitions(
+    rd_kafka_buf_t *rkbuf,
+    rd_kafka_topic_partition_list_t *rktparlist) {
+        const rd_kafka_topic_partition_field_t fields[] = {
+            RD_KAFKA_TOPIC_PARTITION_FIELD_PARTITION,
+            RD_KAFKA_TOPIC_PARTITION_FIELD_END};
+        rd_kafka_topic_partition_list_sort_by_topic_id(rktparlist);
+        rd_kafka_buf_write_topic_partitions(
+            rkbuf, rktparlist, rd_false /*don't skip invalid offsets*/,
+            rd_false /*any offset*/, rd_true /* use_topic id */,
+            rd_false /* don't use topic name */, fields);
+}
+
+static int
+rd_kafka_mock_handle_ConsumerGroupHeartbeat(rd_kafka_mock_connection_t *mconn,
+                                            rd_kafka_buf_t *rkbuf) {
+        const rd_bool_t log_decode_errors   = rd_true;
+        rd_bool_t sent_assignment_parse_err = rd_false;
+        rd_kafka_mock_cluster_t *mcluster   = mconn->broker->cluster;
+        rd_kafka_buf_t *resp = rd_kafka_mock_buf_new_response(rkbuf);
+        rd_kafka_topic_partition_list_t *sent_assignment     = NULL,
+                                        *existing_assignment = NULL,
+                                        *next_assignment     = NULL;
+        rd_kafka_topic_partition_t *rktpar;
+        rd_kafkap_str_t GroupId, MemberId, InstanceId, RackId, ServerAssignor,
+            SubscribedTopicRegex;
+        rd_kafkap_str_t *SubscribedTopicNames = NULL;
+        int32_t MemberEpoch, RebalanceTimeoutMs, SubscribedTopicNamesCnt;
+        int32_t i;
+        rd_kafka_resp_err_t err;
+        rd_kafka_mock_cgrp_consumer_t *mcgrp         = NULL;
+        rd_kafka_mock_broker_t *mrkb                 = NULL;
+        rd_kafka_mock_cgrp_consumer_member_t *member = NULL;
+
+        /* GroupId */
+        rd_kafka_buf_read_str(rkbuf, &GroupId);
+        rd_assert(!RD_KAFKAP_STR_IS_NULL(&GroupId));
+
+        /* MemberId */
+        rd_kafka_buf_read_str(rkbuf, &MemberId);
+        rd_assert(!RD_KAFKAP_STR_IS_NULL(&MemberId));
+
+        /* MemberEpoch */
+        rd_kafka_buf_read_i32(rkbuf, &MemberEpoch);
+        rd_assert(MemberEpoch >= -2);
+
+        /* InstanceId */
+        rd_kafka_buf_read_str(rkbuf, &InstanceId);
+
+        /* RackId */
+        rd_kafka_buf_read_str(rkbuf, &RackId);
+
+        /* RebalanceTimeoutMs */
+        rd_kafka_buf_read_i32(rkbuf, &RebalanceTimeoutMs);
+        rd_assert(RebalanceTimeoutMs >= -1);
+
+        /* #SubscribedTopicNames */
+        rd_kafka_buf_read_arraycnt(rkbuf, &SubscribedTopicNamesCnt,
+                                   RD_KAFKAP_TOPICS_MAX);
+        if (SubscribedTopicNamesCnt >= 0) {
+                SubscribedTopicNames = rd_calloc(
+                    SubscribedTopicNamesCnt > 0 ? SubscribedTopicNamesCnt : 1,
+                    sizeof(rd_kafkap_str_t));
+                for (i = 0; i < SubscribedTopicNamesCnt; i++) {
+                        /* SubscribedTopicNames[i] */
+                        rd_kafka_buf_read_str(rkbuf, &SubscribedTopicNames[i]);
+                }
+        }
+
+        rd_kafka_buf_read_str(rkbuf, &SubscribedTopicRegex);
+
+        /* ServerAssignor */
+        rd_kafka_buf_read_str(rkbuf, &ServerAssignor);
+
+        /* #TopicPartitions */
+        const rd_kafka_topic_partition_field_t sent_assignment_fields[] = {
+            RD_KAFKA_TOPIC_PARTITION_FIELD_PARTITION,
+            RD_KAFKA_TOPIC_PARTITION_FIELD_END};
+        sent_assignment = rd_kafka_buf_read_topic_partitions_nullable(
+            rkbuf, rd_true, rd_false, 0, sent_assignment_fields,
+            &sent_assignment_parse_err);
+        if (sent_assignment_parse_err)
+                goto err_parse;
+
+        if (sent_assignment) {
+                rd_kafka_Uuid_t last_topic_id = RD_KAFKA_UUID_ZERO;
+                rd_kafka_mock_topic_t *mtopic = NULL;
+                existing_assignment =
+                    rd_kafka_topic_partition_list_new(sent_assignment->cnt);
+                RD_KAFKA_TPLIST_FOREACH(rktpar, sent_assignment) {
+                        rd_kafka_Uuid_t current_topic_id =
+                            rd_kafka_topic_partition_get_topic_id(rktpar);
+
+                        if (rd_kafka_Uuid_cmp(current_topic_id,
+                                              last_topic_id) != 0) {
+                                last_topic_id = current_topic_id;
+                                mtopic        = rd_kafka_mock_topic_find_by_id(
+                                    mcluster, current_topic_id);
+                        }
+
+                        if (mtopic) {
+                                rd_kafka_topic_partition_t *added =
+                                    rd_kafka_topic_partition_list_add(
+                                        existing_assignment, "",
+                                        rktpar->partition);
+                                rd_kafka_topic_partition_set_topic_id(
+                                    added, last_topic_id);
+                        }
+                }
+        }
+
+        /* Inject error, if any */
+        err = rd_kafka_mock_next_request_error(mconn, resp);
+
+        if (!err) {
+                mrkb = rd_kafka_mock_cluster_get_coord(
+                    mcluster, RD_KAFKA_COORD_GROUP, &GroupId);
+
+                if (!mrkb)
+                        err = RD_KAFKA_RESP_ERR_COORDINATOR_NOT_AVAILABLE;
+                else if (mrkb != mconn->broker)
+                        err = RD_KAFKA_RESP_ERR_NOT_COORDINATOR;
+        }
+
+        if (!err) {
+                mtx_lock(&mcluster->lock);
+                mcgrp = rd_kafka_mock_cgrp_consumer_get(mcluster, &GroupId);
+                rd_assert(mcgrp);
+
+                member = rd_kafka_mock_cgrp_consumer_member_add(
+                    mcgrp, mconn, &MemberId, &InstanceId, SubscribedTopicNames,
+                    SubscribedTopicNamesCnt, &SubscribedTopicRegex);
+
+                if (member) {
+                        if (MemberEpoch >= 0) {
+                                next_assignment =
+                                    rd_kafka_mock_cgrp_consumer_member_next_assignment(
+                                        member, existing_assignment,
+                                        &MemberEpoch);
+                                if (MemberEpoch < 0) {
+                                        err =
+                                            RD_KAFKA_RESP_ERR_FENCED_MEMBER_EPOCH;
+                                }
+                        } else {
+                                rd_kafka_mock_cgrp_consumer_member_leave(
+                                    mcgrp, member, MemberEpoch == -2);
+                                member = NULL;
+                        }
+                } else {
+                        err = RD_KAFKA_RESP_ERR_UNKNOWN_MEMBER_ID;
+                }
+                mtx_unlock(&mcluster->lock);
+        } else {
+                switch (err) {
+                case RD_KAFKA_RESP_ERR_UNKNOWN_MEMBER_ID:
+                case RD_KAFKA_RESP_ERR_FENCED_MEMBER_EPOCH:
+                        /* In case the error was set
+                         * by `rd_kafka_mock_next_request_error`. */
+                        MemberEpoch = -1;
+                        mtx_lock(&mcluster->lock);
+                        mcgrp = rd_kafka_mock_cgrp_consumer_find(mcluster,
+                                                                 &GroupId);
+                        if (!mcgrp) {
+                                mtx_unlock(&mcluster->lock);
+                                break;
+                        }
+
+                        rd_kafka_mock_cgrp_consumer_member_t *member =
+                            rd_kafka_mock_cgrp_consumer_member_find(mcgrp,
+                                                                    &MemberId);
+                        if (member) {
+                                rd_kafka_mock_cgrp_consumer_member_fenced(
+                                    mcgrp, member);
+                                member = NULL;
+                        }
+                        mtx_unlock(&mcluster->lock);
+                default:
+                        break;
+                }
+        }
+
+        /*
+         * Construct response
+         */
+        /* Response: Throttle */
+        rd_kafka_buf_write_i32(resp, 0);
+
+        /* Response: ErrorCode */
+        rd_kafka_buf_write_i16(resp, err);
+
+        /* Response: ErrorMessage */
+        rd_kafka_buf_write_str(resp, rd_kafka_err2str(err), -1);
+
+        /* Response: MemberId */
+        if (!err && member)
+                rd_kafka_buf_write_str(resp, member->id, -1);
+        else
+                rd_kafka_buf_write_str(resp, NULL, -1);
+
+        /* Response: MemberEpoch */
+        rd_kafka_buf_write_i32(resp, MemberEpoch);
+
+        /* Response: HeartbeatIntervalMs */
+        if (mcgrp) {
+                rd_kafka_buf_write_i32(resp, mcgrp->heartbeat_interval_ms);
+        } else {
+                rd_kafka_buf_write_i32(resp, 0);
+        }
+
+        if (next_assignment) {
+                /* Response: Assignment */
+                rd_kafka_buf_write_i8(resp, 1);
+
+                /* Response: TopicPartitions */
+                rd_kafka_mock_handle_ConsumerGroupHeartbeat_write_TopicPartitions(
+                    resp, next_assignment);
+
+                rd_kafka_buf_write_tags_empty(resp);
+        } else {
+                /* Response: Assignment */
+                rd_kafka_buf_write_i8(resp, -1);
+        }
+
+        rd_kafka_mock_connection_send_response(mconn, resp);
+
+        rd_free(SubscribedTopicNames);
+        RD_IF_FREE(sent_assignment, rd_kafka_topic_partition_list_destroy);
+        RD_IF_FREE(existing_assignment, rd_kafka_topic_partition_list_destroy);
+        RD_IF_FREE(next_assignment, rd_kafka_topic_partition_list_destroy);
+        return 0;
+
+err_parse:
+        RD_IF_FREE(SubscribedTopicNames, rd_free);
+        RD_IF_FREE(sent_assignment, rd_kafka_topic_partition_list_destroy);
+        RD_IF_FREE(existing_assignment, rd_kafka_topic_partition_list_destroy);
+        RD_IF_FREE(next_assignment, rd_kafka_topic_partition_list_destroy);
+        rd_kafka_buf_destroy(resp);
+        return -1;
+}
+
+/**
+ * @brief Default request handlers
+ */
+const struct rd_kafka_mock_api_handler
+    rd_kafka_mock_api_handlers[RD_KAFKAP__NUM] = {
+        /* [request-type] = { MinVersion, MaxVersion, FlexVersion, callback } */
+        [RD_KAFKAP_Produce]      = {0, 10, 9, rd_kafka_mock_handle_Produce},
+        [RD_KAFKAP_Fetch]        = {0, 16, 12, rd_kafka_mock_handle_Fetch},
+        [RD_KAFKAP_ListOffsets]  = {0, 7, 6, rd_kafka_mock_handle_ListOffsets},
+        [RD_KAFKAP_OffsetFetch]  = {0, 6, 6, rd_kafka_mock_handle_OffsetFetch},
+        [RD_KAFKAP_OffsetCommit] = {0, 9, 8, rd_kafka_mock_handle_OffsetCommit},
+        [RD_KAFKAP_ApiVersion]   = {0, 2, 3, rd_kafka_mock_handle_ApiVersion},
+        [RD_KAFKAP_Metadata]     = {0, 12, 9, rd_kafka_mock_handle_Metadata},
+        [RD_KAFKAP_FindCoordinator] = {0, 3, 3,
+                                       rd_kafka_mock_handle_FindCoordinator},
+        [RD_KAFKAP_InitProducerId]  = {0, 4, 2,
+                                       rd_kafka_mock_handle_InitProducerId},
+        [RD_KAFKAP_JoinGroup]       = {0, 6, 6, rd_kafka_mock_handle_JoinGroup},
+        [RD_KAFKAP_Heartbeat]       = {0, 5, 4, rd_kafka_mock_handle_Heartbeat},
+        [RD_KAFKAP_LeaveGroup] = {0, 4, 4, rd_kafka_mock_handle_LeaveGroup},
+        [RD_KAFKAP_SyncGroup]  = {0, 4, 4, rd_kafka_mock_handle_SyncGroup},
+        [RD_KAFKAP_AddPartitionsToTxn] =
+            {0, 1, -1, rd_kafka_mock_handle_AddPartitionsToTxn},
+        [RD_KAFKAP_AddOffsetsToTxn] = {0, 1, -1,
+                                       rd_kafka_mock_handle_AddOffsetsToTxn},
+        [RD_KAFKAP_TxnOffsetCommit] = {0, 3, 3,
+                                       rd_kafka_mock_handle_TxnOffsetCommit},
+        [RD_KAFKAP_EndTxn]          = {0, 1, -1, rd_kafka_mock_handle_EndTxn},
+        [RD_KAFKAP_OffsetForLeaderEpoch] =
+            {2, 2, -1, rd_kafka_mock_handle_OffsetForLeaderEpoch},
+        [RD_KAFKAP_ConsumerGroupHeartbeat] =
+            {1, 1, 1, rd_kafka_mock_handle_ConsumerGroupHeartbeat},
+        [RD_KAFKAP_GetTelemetrySubscriptions] =
+            {0, 0, 0, rd_kafka_mock_handle_GetTelemetrySubscriptions},
+        [RD_KAFKAP_PushTelemetry] = {0, 0, 0,
+                                     rd_kafka_mock_handle_PushTelemetry},
+};
+
+
+
+/**
+ * @brief Handle ApiVersionRequest.
+ *
+ * @remark This is the only handler that needs to handle unsupported
+ * ApiVersions.
+ */
+static int rd_kafka_mock_handle_ApiVersion(rd_kafka_mock_connection_t *mconn,
+                                           rd_kafka_buf_t *rkbuf) {
+        rd_kafka_mock_cluster_t *mcluster = mconn->broker->cluster;
+        rd_kafka_buf_t *resp = rd_kafka_mock_buf_new_response(rkbuf);
+        size_t of_ApiKeysCnt;
+        int cnt                 = 0;
+        rd_kafka_resp_err_t err = RD_KAFKA_RESP_ERR_NO_ERROR;
+        int i;
+
+        /* Inject error */
+        err = rd_kafka_mock_next_request_error(mconn, resp);
+
+        if (!err && !rd_kafka_mock_cluster_ApiVersion_check(
+                        mcluster, rkbuf->rkbuf_reqhdr.ApiKey,
+                        rkbuf->rkbuf_reqhdr.ApiVersion))
+                err = RD_KAFKA_RESP_ERR_UNSUPPORTED_VERSION;
+
+        /* ApiVersionRequest/Response with flexver (>=v3) has a mix
+         * of flexver and standard fields for backwards compatibility reasons,
+         * so we handcraft the response instead. */
+        resp->rkbuf_flags &= ~RD_KAFKA_OP_F_FLEXVER;
+
+        /* ErrorCode */
+        rd_kafka_buf_write_i16(resp, err);
+
+        /* #ApiKeys (updated later) */
+        /* FIXME: FLEXVER: This is a uvarint and will require more than 1 byte
+         *        if the array count exceeds 126. */
+        if (rkbuf->rkbuf_flags & RD_KAFKA_OP_F_FLEXVER)
+                of_ApiKeysCnt = rd_kafka_buf_write_i8(resp, 0);
+        else
+                of_ApiKeysCnt = rd_kafka_buf_write_i32(resp, 0);
+
+        for (i = 0; i < RD_KAFKAP__NUM; i++) {
+                if (!mcluster->api_handlers[i].cb ||
+                    mcluster->api_handlers[i].MaxVersion == -1)
+                        continue;
+
+
+                if (rkbuf->rkbuf_reqhdr.ApiVersion >= 3) {
+                        if (err && i != RD_KAFKAP_ApiVersion)
+                                continue;
+                }
+
+                /* ApiKey */
+                rd_kafka_buf_write_i16(resp, (int16_t)i);
+                /* MinVersion */
+                rd_kafka_buf_write_i16(resp,
+                                       mcluster->api_handlers[i].MinVersion);
+                /* MaxVersion */
+                rd_kafka_buf_write_i16(resp,
+                                       mcluster->api_handlers[i].MaxVersion);
+
+                cnt++;
+        }
+
+        /* FIXME: uvarint */
+        if (rkbuf->rkbuf_flags & RD_KAFKA_OP_F_FLEXVER) {
+                rd_assert(cnt <= 126);
+                rd_kafka_buf_update_i8(resp, of_ApiKeysCnt, cnt);
+        } else
+                rd_kafka_buf_update_i32(resp, of_ApiKeysCnt, cnt);
+
+        if (rkbuf->rkbuf_reqhdr.ApiVersion >= 1) {
+                /* ThrottletimeMs */
+                rd_kafka_buf_write_i32(resp, 0);
+        }
+
+        rd_kafka_mock_connection_send_response(mconn, resp);
+
+        return 0;
+}