Partition takes a message and partition count and chooses a partition

Successes is the success output channel back to the user when Return.Successes is enabled. If Return.Successes is true, you MUST read from this channe

decode takes bytes and a decoder and fills the fields of the decoder from the bytes, interpreted using Kafka's encoding rules.

not specific to request tests, just helper functions for testing structures that implement the encoder or decoder interfaces that needed somewhere to

Leader returns the broker object that is the leader of the current topic/partition, as determined by querying the cluster metadata.

Validate checks a Config instance. It will return a ConfigurationError if the specified values don't make sense. nolint:gocyclo // This function's cy

Close closes the broker resources

Close shuts down the producer and waits for any buffered messages to be flushed. You must call this function before a producer object passes out of sc

Connected returns true if the broker is connected and false otherwise. If the broker is not connected but it had tried to connect, the error from that

Errors is the error output channel back to the user. You MUST read from this channel or the Producer will deadlock when the channel is full. Alternati

NewSyncProducer instantiates a new SyncProducer mock. The t argument should be the *testing.T instance of your test method. An error will be written t

setHandler sets the specified function as the request handler. Whenever a mock broker reads a request from the wire it passes the request to the funct

--------------------------------------------------------------------

Close shuts down the consumer. It must be called after all child PartitionConsumers have already been closed.

NewAsyncProducerFromClient creates a new Producer using the given client. It is still necessary to call Close() on the underlying client when shutting

subsets

NewConsumer returns a new mock Consumer instance. The t argument should be the *testing.T instance of your test method. An error will be written to it

Collections

Collections

BeginTxn mark current transaction as ready.

Close stops the ConsumerGroup and detaches any running sessions. It is required to call this function before the object passes out of scope, as it wil

Coordinator returns the coordinating broker for a consumer group. It will return a locally cached value if it's available. You can call RefreshCoordin

Subsets

Close shuts down the producer; you must call this function before a producer object passes out of scope, as it may otherwise leak memory. You must cal

DescribeTransactions returns the current state of the given transactional ids, querying each transaction's coordinator. Requires Kafka 3.0.0.0 or high

HighWaterMarkOffset returns the high water mark offset of the partition, i.e. the offset that will be used for the next message that will be produced.

ManagePartition creates a PartitionOffsetManager on the given topic/partition. It will return an error if this OffsetManager is already managing the g

NewAsyncProducer instantiates a new Producer mock. The t argument should be the *testing.T instance of your test method. An error will be written to i

-------------------------------------------------------------------- NewBalanceStrategyRange returns a range balance strategy, which is the default an

NewConsumerGroup creates a new consumer group the given broker addresses and configuration.

Partitions returns the sorted list of all partition IDs for the given topic.

Stacks, see PushEncoder

verify that the plan is fully balanced, assumes that all consumers can consume from the same set of topics

Close implements the Close method from the sarama.Consumer interface. It will close all registered PartitionConsumer instances.

Commit commits the offsets. This method can be used if AutoCommit.Enable is set to false.

CommitTxn commit current transaction.

Consume joins a cluster of consumers for a given list of topics and starts a blocking ConsumerGroupSession through the ConsumerGroupHandler. The life

Context returns the session context.

GetMetadata send a metadata request and returns a metadata response or error

MarkOffset marks the provided offset, alongside a metadata string that represents the state of the partition consumer at that point in time. The metad

NewClusterAdminFromClient creates a new ClusterAdmin using the given client. Note that underlying client will also be closed on admin's Close() call.

NewOffsetManagerFromClient creates a new OffsetManager from the given client. It is still necessary to call Close() on the underlying client when fini

NextOffset returns the next offset that should be consumed for the managed partition, accompanied by metadata which can be used to reconstruct the sta

RefreshCoordinator retrieves the coordinator for a consumer group and stores it in local cache. This function only works on Kafka 0.8.2 and higher.

SetHandlerFuncByMap defines mapping of Request types to RequestHandlerFunc. When a request is received by the broker, it looks up the request type in

isRetriableControllerError returns `true` if the given error type unwraps to an `ErrNotController` or `EOF` response from Kafka

Try to transition to a valid status and return an error otherwise.

unmute decrements the in-flight counter for all partitions in the set.

Consumer interface implementation ConsumePartition implements the ConsumePartition method from the sarama.Consumer interface. Before you can start c

ExpectConsumePartition will register a topic/partition, so you can set expectations on it. The registered PartitionConsumer will be returned, so you c

ListTransactions lists the transactions known to the cluster, optionally filtered by state, producer id, or (Kafka 3.8.0.0+) minimum duration in milli

tryMute checks if any of the partitions in the given produceSet are already muted, returning false if they are, otherwise it reserves every partition

Testing API

DescribeProducers lists the active producers for the given topic partitions, querying each partition's leader. Requires Kafka 2.8.0.0 or higher.

ExpectInputAndSucceed sets an expectation on the mock producer that a message will be provided on the input channel. The mock producer will handle the

History returns a slice of RequestResponse pairs in the order they were processed by the broker. Note that in case of multiple connections to the brok

NewRandomPartitioner returns a Partitioner which chooses a random partition each time.

Port returns the TCP port number the broker is listening for requests on.