Struct MockProducer 

pub struct MockProducer<K, V> { /* private fields */ }

A mock of the producer interface for testing code that uses Kafka.

By default this mock will synchronously complete each send call successfully. However it can be configured to allow the user to control the completion of the call and supply an optional error for the producer to return.

Implementations

impl<K, V> MockProducer<K, V>

pub fn with_cluster_auto_complete(cluster: Cluster, auto_complete: bool) -> Self

Create a mock producer

Arguments

• cluster - The cluster holding metadata for this producer
• auto_complete - If true automatically complete all requests successfully and execute the callback. Otherwise the user must call complete_next or error_next after send to complete the call and resolve the returned future.

Translation notes

Java’s MockProducer(Cluster, boolean, Partitioner, Serializer, Serializer) with a null partitioner and null serializers.

pub fn with_options(options: MockProducerOptions<K, V>) -> Self

Create a mock producer

Arguments

• options - The cluster holding metadata for this producer (unset: an empty cluster), whether to automatically complete all requests successfully and execute the callback (otherwise the user must call complete_next or error_next after send), the partition strategy, and the serializers for key and value.

Translation notes

Java’s MockProducer(Cluster, boolean, Partitioner, Serializer, Serializer) and, with cluster unset, MockProducer(boolean, Partitioner, Serializer, Serializer), which passes Cluster.empty().

pub fn with_auto_complete(auto_complete: bool) -> Self

Create a new mock producer with invented metadata and the given auto_complete setting.

Arguments

• auto_complete - If true automatically complete all requests successfully and execute the callback. Otherwise the user must call complete_next or error_next after send to complete the call and resolve the returned future.

pub fn history(&self) -> Vec<ProducerRecord<K, V>>

where K: Clone, V: Clone,

Returns the list of sent records since the last call to clear.

pub fn uncommitted_records(&self) -> Vec<ProducerRecord<K, V>>

where K: Clone, V: Clone,

Gets the list of records sent in the current transaction that have not yet been committed.

Returns

A list of uncommitted producer records

pub fn consumer_group_offsets_history( &self, ) -> Vec<HashMap<String, HashMap<TopicPartition, OffsetAndMetadata>>>

Returns the list of committed consumer group offsets since the last call to clear.

pub fn uncommitted_offsets( &self, ) -> HashMap<String, HashMap<TopicPartition, OffsetAndMetadata>>

Gets the consumer group offsets sent in the current transaction that have not yet been committed.

Returns

A map of consumer group IDs to their uncommitted offsets

pub fn clear(&self)

Clear the stored history of sent records, consumer group offsets

pub fn complete_next(&self) -> bool

Complete the earliest uncompleted call successfully.

Returns

true if there was an uncompleted call to complete

pub fn error_next(&self, error: Error) -> bool

Complete the earliest uncompleted call with the given error.

Arguments

• error - the error

Returns

true if there was an uncompleted call to complete

pub fn fence_producer(&self) -> Result<(), Error>

Fences this mock producer, causing it to return a producer-fenced error on subsequent transactional operations.

Errors

• Error::is_local_illegal_state_error if closed or not initialized for transactions.
• Error::is_producer_fenced_error if already fenced.

pub fn transaction_initialized(&self) -> bool

Returns true if init_transactions() has completed successfully.

pub fn transaction_in_flight(&self) -> bool

Returns true if a transaction has been begun and neither committed nor aborted.

pub fn transaction_committed(&self) -> bool

Returns true if the most recent transaction was committed.

pub fn transaction_aborted(&self) -> bool

Returns true if the most recent transaction was aborted.

pub fn sent_offsets(&self) -> bool

Checks whether offsets have been sent to the current transaction.

Returns

true if offsets were sent in the current transaction, false otherwise

pub fn commit_count(&self) -> i64

Gets the total number of transactions committed by this mock producer.

Returns

The commit count

pub fn closed(&self) -> bool

Returns true if the producer is closed.

pub fn flushed(&self) -> bool

Returns true if there are no pending completions.

pub fn set_send_error(&self, error: Option<Error>)

Error to return when send or send_with_callback is called

Arguments

• error - None clears it

pub fn set_flush_error(&self, error: Option<Error>)

Error to return when flush is called

Arguments

• error - None clears it

pub fn set_partitions_for_error(&self, error: Option<Error>)

Error to return when partitions_for is called

Arguments

• error - None clears it

pub fn set_close_error(&self, error: Option<Error>)

Error to return when close or close_with_timeout is called

Arguments

• error - None clears it

pub fn set_mock_metrics(&self, name: MetricName, metric: Arc<KafkaMetric>)

Set a mock metric for testing

Arguments

• name - key
• metric - value

pub fn set_init_transaction_error(&self, error: Option<Error>)

Error to return when init_transactions is called

Arguments

• error - None clears it

pub fn set_begin_transaction_error(&self, error: Option<Error>)

Error to return when begin_transaction is called

Arguments

• error - None clears it

pub fn set_send_offsets_to_transaction_error(&self, error: Option<Error>)

Error to return when send_offsets_to_transaction is called

Arguments

• error - None clears it

pub fn set_commit_transaction_error(&self, error: Option<Error>)

Error to return when commit_transaction is called

Arguments

• error - None clears it

pub fn set_abort_transaction_error(&self, error: Option<Error>)

Error to return when abort_transaction is called

Arguments

• error - None clears it

Trait Implementations

impl<K, V> Debug for MockProducer<K, V>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<K, V> Default for MockProducer<K, V>

fn default() -> Self

Returns the “default value” for a type.

impl<K: Send + Sync, V: Send + Sync> Producer<K, V> for MockProducer<K, V>

async fn init_transactions(&self) -> Result<(), Error>

Needs to be called before any other methods when the transactional.id is set in the configuration.

fn begin_transaction(&self) -> Result<(), Error>

Should be called before the start of each new transaction. Note that prior to the first invocation of this method, you must invoke init_transactions exactly one time.

async fn send_offsets_to_transaction( &self, offsets: HashMap<TopicPartition, OffsetAndMetadata>, group_metadata: &dyn ConsumerGroupMetadata, ) -> Result<(), Error>

Sends a list of specified offsets to the consumer group coordinator, and also marks those offsets as part of the current transaction. These offsets will be considered committed only if the transaction is committed successfully.

async fn commit_transaction(&self) -> Result<(), Error>

Commits the ongoing transaction. This method will flush any unsent records before actually committing the transaction.

async fn abort_transaction(&self) -> Result<(), Error>

Aborts the ongoing transaction. Any unflushed produce messages will be aborted when this call is made.

async fn send( &self, record: ProducerRecord<K, V>, ) -> Result<KafkaFuture<RecordMetadata>, Error>

Asynchronously send a record to a topic. Equivalent to send_with_callback(record, None). See send_with_callback for details.

async fn send_with_callback( &self, record: ProducerRecord<K, V>, callback: Option<Box<dyn Callback>>, ) -> Result<KafkaFuture<RecordMetadata>, Error>

Asynchronously send a record to a topic and invoke the provided callback when the send has been acknowledged.

async fn flush(&self) -> Result<(), Error>

Invoking this method makes all buffered records immediately available to send (even if linger.ms is greater than 0) and blocks on the completion of the requests associated with these records. The post-condition of flush() is that any previously sent record will have completed (e.g. its future is done and callbacks passed to Self::send_with_callback have been called). A request is considered completed when it is successfully acknowledged according to the acks configuration you have specified or else it results in an error.

async fn partitions_for(&self, topic: &str) -> Result<Vec<PartitionInfo>, Error>

Get the partition metadata for the given topic. This can be used for custom partitioning.

fn metrics(&self) -> MetricsView

Get the full set of internal metrics maintained by the producer.

async fn close(&self) -> Result<(), Error>

Close this producer. This method blocks until all previously sent requests complete. This method is equivalent to close_with_timeout(Duration::MAX).

async fn close_with_timeout(&self, _timeout: Duration) -> Result<(), Error>

This method waits up to timeout for the producer to complete the sending of all incomplete requests.