kafka-python 3.0.0__tar.gz → 3.0.1__tar.gz

{kafka_python-3.0.0 → kafka_python-3.0.1}/CHANGES.md

@@ -1,3 +1,22 @@
+# 3.0.1 (Jun 17, 2026)
+
+### Fixes
+* receive_message_max_bytes default 100MiB (consumer/producer/admin); check against fetch_max_bytes and max_partition_fetch_bytes in Consumer (#3075)
+
+### Consumer
+* Add MemberState to ConsumerGroupMetadata / consumer.group_metadata() (#3071)
+
+### Tests
+* Add ConsumerGroupRunner fixture to manage multi-consumer group integration tests (#3072)
+* Add MockGroup and test coordinator rebalance / metadata snapshot changes (#3069)
+* Use 4.3 api_version for producer tests; fixup inadvertent sender thread leak in test (#3068)
+* Add test coverage for producer acks (#3067)
+* Fill-in empty sender tests (#3066)
+* Add MockCluster; test failover on CoordinatorNotAvailableError (#3065)
+
+### Documentation
+* Add ConsumerRecord, RecordMetadata, and FutureRecordMetadata to docs (#3070)
+
 # 3.0.0 (Jun 11, 2026)
 
 This is a major release with significant changes to kafka-python internals to simplify networking and feature development. It introduces a new networking layer (`kafka.net`) and a dynamic protocol system that uses JSON schema files imported from Apache Kafka. It substantially refactors and expands the Admin client, including breaking changes to some API signatures, and it lands a long list of KIP features/changes across the producer, consumer, admin, and networking/metadata clients. Protocol support across kafka-python is now at or beyond the apache kafka 3.0 baseline.

{kafka_python-3.0.0 → kafka_python-3.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kafka-python
-Version: 3.0.0
+Version: 3.0.1
 Summary: Pure Python client for Apache Kafka
 Author-email: Dana Powers <dana.powers@gmail.com>
 License-Expression: Apache-2.0

{kafka_python-3.0.0 → kafka_python-3.0.1}/kafka/admin/client.py

@@ -75,7 +75,7 @@ class KafkaAdminClient(
             broker connection. Default: 5.
         receive_message_max_bytes (int): Maximum allowed network frame size.
             Used to avoid OOM when decoding malformed network message header.
-            Default: 1000000.
+            Default: 100_000_000.
         receive_buffer_bytes (int): The size of the TCP receive buffer
             (SO_RCVBUF) to use when reading data. Default: None (relies on
             system defaults). Java client defaults to 32768.
@@ -177,7 +177,7 @@ class KafkaAdminClient(
         'reconnect_backoff_ms': 50,
         'reconnect_backoff_max_ms': 30000,
         'max_in_flight_requests_per_connection': 5,
-        'receive_message_max_bytes': 1000000,
+        'receive_message_max_bytes': 100_000_000,
         'receive_buffer_bytes': None,
         'send_buffer_bytes': None,
         'socket_options': [(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)],

{kafka_python-3.0.0 → kafka_python-3.0.1}/kafka/consumer/fetcher.py

@@ -26,6 +26,36 @@ _LOGGED_DESERIALIZE_WARNING = False
 ConsumerRecord = collections.namedtuple("ConsumerRecord",
     ["topic", "partition", "leader_epoch", "offset", "timestamp", "timestamp_type",
      "key", "value", "headers", "checksum", "serialized_key_size", "serialized_value_size", "serialized_header_size"])
+ConsumerRecord.__doc__ = """A single record (message) consumed from a topic partition.
+
+Yielded by :meth:`~kafka.KafkaConsumer.poll` (inside the returned
+``{TopicPartition: [ConsumerRecord, ...]}`` mapping) and by iterating
+over a :class:`~kafka.KafkaConsumer`. ``key`` and ``value`` are decoded
+by the consumer's configured deserializers.
+
+Keyword Arguments:
+    topic (str): The topic this record was received from.
+    partition (int): The partition this record was received from.
+    leader_epoch (int): The partition leader epoch for this record, or -1
+        if unknown.
+    offset (int): The position of this record in the topic partition.
+    timestamp (int): The timestamp of this record, in milliseconds since
+        the epoch (UTC), or -1 if unknown.
+    timestamp_type (int): The type of the timestamp: 0 for CreateTime (set
+        by the producer) or 1 for LogAppendTime (set by the broker).
+    key: The (deserialized) key of the record, or None.
+    value: The (deserialized) value of the record, or None.
+    headers (list): A list of ``(key, value)`` header tuples, where key is
+        a str and value is bytes.
+    checksum (int): Deprecated. The CRC32 checksum of the record, or None.
+        Removed in message format v2 (Kafka 0.11+).
+    serialized_key_size (int): The size of the serialized, uncompressed key
+        in bytes, or -1 if the key is None.
+    serialized_value_size (int): The size of the serialized, uncompressed
+        value in bytes, or -1 if the value is None.
+    serialized_header_size (int): The size of the serialized, uncompressed
+        headers in bytes, or -1 if there are no headers.
+"""
 
 
 CompletedFetch = collections.namedtuple("CompletedFetch",

{kafka_python-3.0.0 → kafka_python-3.0.1}/kafka/consumer/group.py

@@ -180,7 +180,9 @@ class KafkaConsumer:
             rebalances. Default: 3000
         receive_message_max_bytes (int): Maximum allowed network frame size.
             Used to avoid OOM when decoding malformed network message header.
-            Default: 1000000.
+            Automatically raised to ``fetch_max_bytes + max_partition_fetch_bytes``
+            if configured lower, since a FetchResponse frame may be that large.
+            Default: 100_000_000.
         receive_buffer_bytes (int): The size of the TCP receive buffer
             (SO_RCVBUF) to use when reading data. Default: None (relies on
             system defaults). The java client defaults to 32768.
@@ -328,7 +330,7 @@ class KafkaConsumer:
         'heartbeat_interval_ms': 3000,
         'receive_buffer_bytes': None,
         'send_buffer_bytes': None,
-        'receive_message_max_bytes': 1000000,
+        'receive_message_max_bytes': 100_000_000,
         'socket_options': [(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)],
         'consumer_timeout_ms': float('inf'),
         'security_protocol': 'PLAINTEXT',
@@ -389,6 +391,20 @@ class KafkaConsumer:
                 "fetch_max_wait_ms ({})."
                 .format(connections_max_idle_ms, request_timeout_ms, fetch_max_wait_ms))
 
+        # fetch_max_bytes (KIP-74) is a soft cap the broker applies to the
+        # *record data* in a FetchResponse body, not to the whole frame. The
+        # frame also carries the response header + per-topic/per-partition
+        # metadata, and the broker returns at least the first record batch even
+        # when it alone exceeds fetch_max_bytes. So a FetchResponse frame can be
+        # somewhat larger than fetch_max_bytes; give the frame-size guard
+        # max_partition_fetch_bytes of headroom over it so legitimate responses
+        # aren't rejected as InvalidReceiveError. Auto-raise so the guard tracks
+        # the fetch sizing unless the user explicitly configured a larger value.
+        fetch_response_max_bytes = (
+            self.config['fetch_max_bytes'] + self.config['max_partition_fetch_bytes'])
+        if self.config['receive_message_max_bytes'] < fetch_response_max_bytes:
+            self.config['receive_message_max_bytes'] = fetch_response_max_bytes
+
         if self.config['metrics_enabled']:
             metrics_tags = {'client-id': self.config['client_id']}
             metric_config = MetricConfig(samples=self.config['metrics_num_samples'],
@@ -662,13 +678,17 @@ class KafkaConsumer:
         self._coordinator.commit_offsets_sync(offsets, timeout_ms=timeout_ms)
 
     def group_metadata(self):
-        """Return a snapshot of this consumer's group membership (KIP-447).
+        """Return a snapshot of this consumer's group membership.
 
         Pass the result to KafkaProducer.send_offsets_to_transaction() so the
         broker can fence stale instances of this consumer when committing
-        offsets inside a transaction. The snapshot is always safe to call:
-        if no group_id is configured (manual assignment) the returned
-        ConsumerGroupMetadata has group_id=None.
+        offsets inside a transaction (KIP-447). The snapshot also exposes the
+        current MemberState (``state``), so callers can observe whether the
+        consumer has converged on a stable assignment.
+
+        The snapshot is always safe to call: if no group_id is configured
+        (manual assignment) the returned ConsumerGroupMetadata has
+        group_id=None and is permanently unjoined.
 
         Returns:
             ConsumerGroupMetadata

{kafka_python-3.0.0 → kafka_python-3.0.1}/kafka/coordinator/base.py

@@ -16,19 +16,13 @@ from kafka.protocol.consumer import (
     HeartbeatRequest, JoinGroupRequest, LeaveGroupRequest, SyncGroupRequest,
     DEFAULT_GENERATION_ID, UNKNOWN_MEMBER_ID,
 )
-from kafka.structs import ConsumerGroupMetadata
+from kafka.structs import ConsumerGroupMetadata, MemberState
 from kafka.util import Timer
 
 log = logging.getLogger('kafka.coordinator')
 heartbeat_log = logging.getLogger('kafka.coordinator.heartbeat')
 
 
-class MemberState:
-    UNJOINED = '<unjoined>'  # the client is not part of a group
-    REBALANCING = '<rebalancing>'  # the client has begun rebalancing
-    STABLE = '<stable>'  # the client has joined and is sending heartbeats
-
-
 class Generation:
     def __init__(self, generation_id, member_id, protocol):
         self.generation_id = generation_id
@@ -891,13 +885,16 @@ class BaseCoordinator(ABC):
             return self._generation
 
     def group_metadata(self):
-        """Return a snapshot of this member's group identity (KIP-447).
+        """Return a snapshot of this member's group membership.
 
         Returns the current generation_id / member_id / group_instance_id even
         when the group is not stable; the caller (typically
         KafkaProducer.send_offsets_to_transaction) needs whatever is current
-        so the broker can fence stale instances. If the consumer has never
-        joined, the snapshot has the no-generation defaults.
+        so the broker can fence stale instances (KIP-447). If the consumer has
+        never joined, the snapshot has the no-generation defaults.
+
+        Also carries the live MemberState (``state``) so callers can observe
+        whether the group has converged (it is ignored by the fencing path).
         """
         with self._lock:
             return ConsumerGroupMetadata(
@@ -905,6 +902,7 @@ class BaseCoordinator(ABC):
                 generation_id=self._generation.generation_id,
                 member_id=self._generation.member_id,
                 group_instance_id=self.group_instance_id,
+                state=self.state,
             )
 
     # deprecated

kafka_python-3.0.1/kafka/partitioner/abc.py

@@ -0,0 +1,52 @@
+from abc import ABC, abstractmethod
+
+
+class Partitioner(ABC):
+    """Base class for pluggable partition selection strategies.
+
+    A :class:`~kafka.KafkaProducer` consults its configured partitioner to
+    choose a partition for each record whose ``partition`` was not supplied
+    explicitly to :meth:`~kafka.KafkaProducer.send`. Subclass this and
+    implement :meth:`partition`, then pass an instance via the
+    ``partitioner`` config argument.
+
+    Two built-in implementations are provided: ``DefaultPartitioner``
+    (murmur2-hash keyed records, random partition for null keys) and
+    ``StickyPartitioner`` (KIP-480; null-key records stick to one partition
+    per topic until a new batch is started, then rotate).
+
+    Sticky-style partitioners may additionally implement an optional
+    ``on_new_batch(self, topic, cluster, prev_partition)`` hook, which the
+    producer calls when a null-key record would have triggered a fresh
+    batch, giving the partitioner a chance to rotate off its current sticky
+    choice. The hook is looked up with ``getattr``, so it is entirely
+    optional.
+    """
+
+    @abstractmethod
+    def partition(self, topic, key, serialized_key, value, serialized_value, cluster):
+        """Choose a partition for a record.
+
+        Arguments:
+            topic (str): The topic the record is destined for.
+            key: The user-supplied key, before serialization. May be None.
+            serialized_key (bytes): The post-serializer key bytes, or None
+                when the caller passed ``key=None``.
+            value: The user-supplied value, before serialization.
+            serialized_value (bytes): The post-serializer value bytes, or
+                None when the caller passed ``value=None``.
+            cluster (ClusterMetadata): A live cluster snapshot. Use
+                ``cluster.partitions_for_topic(topic)`` for all partitions
+                and ``cluster.available_partitions_for_topic(topic)`` for
+                those whose leader is currently known.
+
+        Returns:
+            int: The partition id to assign the record to.
+
+        Raises:
+            ValueError: If the topic is not present in cluster metadata.
+                Partitioner exceptions surface to the caller via the
+                returned :class:`~kafka.producer.future.FutureRecordMetadata`.
+        """
+        pass
+

{kafka_python-3.0.0 → kafka_python-3.0.1}/kafka/producer/future.py

@@ -30,6 +30,19 @@ class FutureProduceResult(Future):
 
 
 class FutureRecordMetadata(Future):
+    """An asynchronous handle to the result of a single :meth:`~kafka.KafkaProducer.send`.
+
+    :meth:`~kafka.KafkaProducer.send` returns one of these immediately,
+    before the record has been transmitted to the broker. Call :meth:`get`
+    to block until the record is acknowledged and obtain its
+    :class:`RecordMetadata`, or register callbacks via
+    :meth:`~kafka.future.Future.add_callback` /
+    :meth:`~kafka.future.Future.add_errback` to be notified without
+    blocking. The future resolves successfully once the containing batch is
+    acknowledged according to the producer's ``acks`` configuration, or
+    fails with the relevant exception (for example
+    :class:`~kafka.errors.KafkaTimeoutError`).
+    """
     __slots__ = ('_produce_future', 'args')
     def __init__(self, produce_future, batch_index, timestamp_ms, checksum, serialized_key_size, serialized_value_size, serialized_header_size):
         super().__init__()
@@ -99,3 +112,28 @@ class FutureRecordMetadata(Future):
 RecordMetadata = collections.namedtuple(
     'RecordMetadata', ['topic', 'partition', 'topic_partition', 'offset', 'timestamp',
                        'checksum', 'serialized_key_size', 'serialized_value_size', 'serialized_header_size'])
+RecordMetadata.__doc__ = """Metadata about a record that has been acknowledged by the broker.
+
+Returned by :meth:`FutureRecordMetadata.get`, which resolves once the
+batch containing the record has been acknowledged according to the
+producer's ``acks`` configuration.
+
+Keyword Arguments:
+    topic (str): The topic the record was appended to.
+    partition (int): The partition the record was appended to.
+    topic_partition (TopicPartition): The ``(topic, partition)`` the record
+        was appended to.
+    offset (int): The offset of the record in the topic partition, or -1 if
+        the broker did not assign one (e.g. ``acks=0``).
+    timestamp (int): The timestamp of the record, in milliseconds since the
+        epoch (UTC). For CreateTime this is the producer-supplied timestamp;
+        for LogAppendTime it is the broker-assigned timestamp.
+    checksum (int): Deprecated. The CRC32 checksum of the record, or None.
+        Removed in message format v2 (Kafka 0.11+).
+    serialized_key_size (int): The size of the serialized, uncompressed key
+        in bytes, or -1 if the key is None.
+    serialized_value_size (int): The size of the serialized, uncompressed
+        value in bytes, or -1 if the value is None.
+    serialized_header_size (int): The size of the serialized, uncompressed
+        headers in bytes, or -1 if there are no headers.
+"""

{kafka_python-3.0.0 → kafka_python-3.0.1}/kafka/producer/kafka.py

@@ -282,7 +282,7 @@ class KafkaProducer:
             Default: 30000.
         receive_message_max_bytes (int): Maximum allowed network frame size.
             Used to avoid OOM when decoding malformed network message header.
-            Default: 1000000.
+            Default: 100_000_000.
         receive_buffer_bytes (int): The size of the TCP receive buffer
             (SO_RCVBUF) to use when reading data. Default: None (relies on
             system defaults). Java client defaults to 32768.
@@ -425,7 +425,7 @@ class KafkaProducer:
         'client_dns_lookup': 'use_all_dns_ips',
         'retry_backoff_ms': 100,
         'request_timeout_ms': 30000,
-        'receive_message_max_bytes': 1000000,
+        'receive_message_max_bytes': 100_000_000,
         'receive_buffer_bytes': None,
         'send_buffer_bytes': None,
         'socket_options': [(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)],

{kafka_python-3.0.0 → kafka_python-3.0.1}/kafka/structs.py

@@ -51,19 +51,33 @@ Keyword Arguments:
 """
 
 
+class MemberState:
+    UNJOINED = '<unjoined>'  # the client is not part of a group
+    REBALANCING = '<rebalancing>'  # the client has begun rebalancing
+    STABLE = '<stable>'  # the client has joined and is sending heartbeats
+
+
 ConsumerGroupMetadata = namedtuple("ConsumerGroupMetadata",
-    ["group_id", "generation_id", "member_id", "group_instance_id"],
-    defaults=[-1, '', None])
-ConsumerGroupMetadata.__doc__ = """A snapshot of a consumer's group membership (KIP-447).
+    ["group_id", "generation_id", "member_id", "group_instance_id", "state"],
+    defaults=[None, -1, '', None, MemberState.UNJOINED])
+ConsumerGroupMetadata.__doc__ = """A snapshot of a consumer's group membership.
+
+The first four fields are the KIP-447 fencing identity: pass the snapshot to
+KafkaProducer.send_offsets_to_transaction() so the broker can fence stale
+consumer instances when committing offsets inside a transaction. The broker
+uses member_id + generation_id + group_instance_id to verify the producer is
+acting on behalf of the current group generation.
 
-Passed to KafkaProducer.send_offsets_to_transaction() so the broker can fence
-stale consumer instances when committing offsets inside a transaction. The
-broker uses member_id + generation_id + group_instance_id to verify the
-producer is acting on behalf of the current group generation.
+The ``state`` field exposes the live MemberState (it is ignored by the
+producer/fencing path). It lets callers observe whether the consumer has
+converged on a stable assignment - useful for monitoring and for tests that
+wait for a group to finish rebalancing.
 
 Keyword Arguments:
-    group_id (str): The consumer group id.
+    group_id (str): The consumer group id, or None for manual assignment.
     generation_id (int): The current generation id (-1 if unjoined).
     member_id (str): The current member id ('' if unjoined).
     group_instance_id (str): The static membership instance id, or None.
+    state (str): The current MemberState (one of MemberState.UNJOINED,
+        MemberState.REBALANCING, MemberState.STABLE).
 """

kafka_python-3.0.1/kafka/version.py

@@ -0,0 +1 @@
+__version__ = '3.0.1'

{kafka_python-3.0.0 → kafka_python-3.0.1}/kafka_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kafka-python
-Version: 3.0.0
+Version: 3.0.1
 Summary: Pure Python client for Apache Kafka
 Author-email: Dana Powers <dana.powers@gmail.com>
 License-Expression: Apache-2.0

{kafka_python-3.0.0 → kafka_python-3.0.1}/test/integration/conftest.py

@@ -1,5 +1,8 @@
+import collections
 import contextlib
 import os
+import threading
+import time
 from urllib.parse import urlparse
 import uuid
 
@@ -7,6 +10,7 @@ import pytest
 
 from kafka import KafkaAdminClient, KafkaConsumer, KafkaProducer
 from kafka.net.compat import KafkaNetClient
+from kafka.structs import MemberState
 from kafka.util import TOPIC_LEGAL_CHARS, TOPIC_MAX_LENGTH, ensure_valid_topic_name
 from test.testutil import env_kafka_version, random_string
 from test.integration.fixtures import KafkaFixture, ZookeeperFixture, create_topics, client_params
@@ -248,3 +252,121 @@ def send_messages(topic, producer, request):
         return [msg for (msg, f) in messages_and_futures]
 
     return _send_messages
+
+
+class ConsumerGroupRunner:
+    """Manage pools of group-consuming threads for integration tests.
+
+    Each spawned consumer runs ``poll()`` in its own background thread until
+    the runner is torn down. Use :meth:`wait_for_stable` to block until every
+    member has joined and the group has finished rebalancing. Threads are
+    stopped and joined automatically when the ``consumer_group`` fixture tears
+    down, so tests don't need their own ``try/finally`` bookkeeping.
+
+        consumers = consumer_group.spawn(group_id='g', count=4)
+        consumer_group.wait_for_stable()
+        # ... assert on consumers[i].assignment() ...
+
+    ``wait_for_stable`` reads ``consumer.group_metadata()`` / ``assignment()``
+    from the test thread while each consumer polls on its own thread. Both
+    reads are lock-protected snapshots, so this cross-thread observation is
+    safe even though KafkaConsumer is otherwise single-threaded.
+    """
+    def __init__(self, consumer_factory):
+        self._factory = consumer_factory
+        self._members = []  # [{thread, stop, ready, consumer, error}, ...]
+
+    @property
+    def consumers(self):
+        """Live consumers in spawn order (across all groups)."""
+        return [m['consumer'] for m in self._members]
+
+    def spawn(self, group_id, count=1, client_id_prefix='consumer', **consumer_params):
+        """Start ``count`` consumer threads in ``group_id``; return their consumers.
+
+        Blocks until each consumer has been constructed (or re-raises whatever
+        the consumer thread failed with during startup). Extra keyword args are
+        passed through to ``kafka_consumer_factory``.
+        """
+        started = []
+        for _ in range(count):
+            member = {
+                'stop': threading.Event(),
+                'ready': threading.Event(),
+                'consumer': None,
+                'error': None,
+            }
+            client_id = '%s-%d' % (client_id_prefix, len(self._members))
+
+            def run(member=member, client_id=client_id):
+                try:
+                    with self._factory(group_id=group_id, client_id=client_id,
+                                       **consumer_params) as c:
+                        member['consumer'] = c
+                        member['ready'].set()
+                        while not member['stop'].is_set():
+                            c.poll(timeout_ms=200)
+                except Exception as e:  # surfaced via spawn() / stop()
+                    member['error'] = e
+                finally:
+                    member['ready'].set()
+
+            member['thread'] = threading.Thread(target=run, name=client_id, daemon=True)
+            self._members.append(member)
+            member['thread'].start()
+            assert member['ready'].wait(timeout=15), \
+                'consumer %s failed to start within 15s' % client_id
+            if member['error'] is not None:
+                raise member['error']  # pylint: disable=raising-bad-type
+            started.append(member['consumer'])
+        return started
+
+    def wait_for_stable(self, timeout=30, poll_interval=1):
+        """Block until every member is STABLE, assigned, and on one generation.
+
+        "One generation" is checked per group_id: a fully converged group has
+        all of its members reporting the same generation_id, which means the
+        most recent rebalance has propagated to everyone.
+        """
+        deadline = time.monotonic() + timeout
+        while True:
+            generations = collections.defaultdict(set)
+            converged = True
+            for c in self.consumers:
+                meta = c.group_metadata()
+                if meta.state != MemberState.STABLE or not c.assignment():
+                    converged = False
+                    break
+                generations[meta.group_id].add(meta.generation_id)
+            if converged and all(len(g) == 1 for g in generations.values()):
+                return
+            assert time.monotonic() < deadline, 'timeout waiting for stable group'
+            time.sleep(poll_interval)
+
+    def stop(self):
+        """Signal all threads to stop, then join them (called at teardown)."""
+        for member in self._members:
+            member['stop'].set()
+        for member in self._members:
+            member['thread'].join(timeout=5)
+            assert not member['thread'].is_alive(), \
+                'consumer thread %s did not exit' % member['thread'].name
+
+
+@pytest.fixture
+def consumer_group(kafka_consumer_factory):
+    """Return a ConsumerGroupRunner for multi-threaded consumer group tests.
+
+    Spawns group-consuming threads on demand and tears them all down (stop +
+    join) when the test finishes::
+
+        def test_something(consumer_group, topic):
+            consumer_group.spawn(group_id='g', count=3)
+            consumer_group.wait_for_stable()
+            ...
+    """
+    runner = ConsumerGroupRunner(kafka_consumer_factory)
+    try:
+        yield runner
+    finally:
+        runner.stop()

{kafka_python-3.0.0 → kafka_python-3.0.1}/test/integration/test_admin_integration.py

@@ -1,5 +1,4 @@
 from logging import info
-from threading import Event, Thread
 from time import monotonic as time, sleep
 
 import pytest
@@ -170,95 +169,31 @@ def test_describe_configs_invalid_broker_id_raises(kafka_admin_client):
 
 
 @pytest.mark.skipif(env_kafka_version() < (0, 11), reason='Describe consumer group requires broker >=0.11')
-def test_describe_group_exists(kafka_admin_client, kafka_consumer_factory, topic):
-    """Tests that the describe consumer group call returns valid consumer group information
-    This test takes inspiration from the test 'test_group' in test_consumer_group.py.
-    """
-    consumers = {}
-    stop = {}
-    threads = {}
+def test_describe_group_exists(kafka_admin_client, consumer_group, topic):
+    """Tests that the describe consumer group call returns valid consumer group information"""
     random_group_id = 'test-group-' + random_string(6)
     group_id_list = [random_group_id, random_group_id + '_2']
-    generations = {group_id_list[0]: set(), group_id_list[1]: set()}
-    def consumer_thread(i, group_id):
-        assert i not in consumers
-        assert i not in stop
-        stop[i] = Event()
-        with kafka_consumer_factory(group_id=group_id) as c:
-            consumers[i] = c
-            while not stop[i].is_set():
-                consumers[i].poll(timeout_ms=200)
-        consumers[i] = None
-        stop[i] = None
-
-    num_consumers = 3
-    for i in range(num_consumers):
-        group_id = group_id_list[i % 2]
-        t = Thread(target=consumer_thread, args=(i, group_id,))
-        t.start()
-        threads[i] = t
-
-    try:
-        timeout = time() + 35
-        while True:
-            info('Checking consumers...')
-            for c in range(num_consumers):
-
-                # Verify all consumers have been created
-                if c not in consumers:
-                    break
-
-                # Verify all consumers have an assignment
-                elif not consumers[c].assignment():
-                    break
-
-            # If all consumers exist and have an assignment
-            else:
-
-                info('All consumers have assignment... checking for stable group')
-                # Verify all consumers are in the same generation
-                # then log state and break while loop
-
-                for consumer in consumers.values():
-                    generations[consumer.config['group_id']].add(consumer._coordinator._generation.generation_id)
-
-                is_same_generation = any([len(consumer_generation) == 1 for consumer_generation in generations.values()])
-
-                # New generation assignment is not complete until
-                # coordinator.rejoining = False
-                rejoining = any([consumer._coordinator.rejoining
-                                 for consumer in list(consumers.values())])
-
-                if not rejoining and is_same_generation:
-                    break
-            assert time() < timeout, "timeout waiting for assignments"
-            info('sleeping...')
-            sleep(1)
 
-        info('Group stabilized; verifying assignment')
-        output = kafka_admin_client.describe_groups(group_id_list)
-        assert len(output) == 2
-        groups = set()
-        for group in output.values():
-            assert(group['group_id'] in group_id_list)
-            if group['group_id'] == group_id_list[0]:
-                assert(len(group['members']) == 2)
-            else:
-                assert(len(group['members']) == 1)
-            for member in group['members']:
-                    assert(member['member_metadata']['topics'] == [topic])
-                    assert(member['member_assignment']['assigned_partitions'][0]['topic'] == topic)
-            groups.add(group['group_id'])
-        assert(sorted(list(groups)) == group_id_list)
-    finally:
-        info('Shutting down %s consumers', num_consumers)
-        for c in range(num_consumers):
-            info('Stopping consumer %s', c)
-            stop[c].set()
-        for c in range(num_consumers):
-            info('Waiting for consumer thread %s', c)
-            threads[c].join()
-            threads[c] = None
+    # Two members in the first group, one in the second.
+    consumer_group.spawn(group_id=group_id_list[0], count=2)
+    consumer_group.spawn(group_id=group_id_list[1], count=1)
+    consumer_group.wait_for_stable(timeout=35)
+
+    info('Group stabilized; verifying assignment')
+    output = kafka_admin_client.describe_groups(group_id_list)
+    assert len(output) == 2
+    groups = set()
+    for group in output.values():
+        assert(group['group_id'] in group_id_list)
+        if group['group_id'] == group_id_list[0]:
+            assert(len(group['members']) == 2)
+        else:
+            assert(len(group['members']) == 1)
+        for member in group['members']:
+            assert(member['member_metadata']['topics'] == [topic])
+            assert(member['member_assignment']['assigned_partitions'][0]['topic'] == topic)
+        groups.add(group['group_id'])
+    assert(sorted(list(groups)) == group_id_list)
 
 
 @pytest.mark.skipif(env_kafka_version() < (1, 1), reason="Delete consumer groups requires broker >=1.1")