beavers 0.0.2

Typed message processing for Kafka, Pulsar, RabbitMQ, SQS, Azure Service Bus, and HTTP with explicit delivery semantics
Documentation
use super::{deliveries::Deliveries, record::TestRecord};
use crate::{
    codec::Decoder,
    error::BoxError,
    message::{OrderingKey, SourceMessage},
    source::{Receive, ReceiveError, Source},
};
use std::{collections::VecDeque, sync::Arc};

#[cfg(feature = "kafka")]
use crate::adapters::kafka::KafkaRecord;
#[cfg(feature = "pubsub")]
use crate::adapters::pubsub::PubSubRecord;
#[cfg(feature = "pulsar")]
use crate::adapters::pulsar::PulsarRecord;
#[cfg(feature = "rabbitmq")]
use crate::adapters::rabbitmq::RabbitMqRecord;
#[cfg(feature = "servicebus")]
use crate::adapters::servicebus::ServiceBusRecord;
#[cfg(feature = "sqs")]
use crate::adapters::sqs::SqsRecord;

/// A finite source of fabricated records that decodes them with a codec.
///
/// Each record becomes one delivery whose handler input is the record decoded
/// by `C`, whose raw form is the record itself, and whose ordering key and
/// trace-context fields follow the adapter the record type belongs to. The
/// source ends after the last record. [`deliveries`](Self::deliveries) reports
/// which records were acknowledged.
///
/// ```
/// use beavers::{
///     App, DeadLetter, ErrorPolicy, FailureKind, HandlerError, InMemorySink, Json, Result,
///     Subscription, testing::TestSource,
/// };
///
/// async fn halve(value: u32) -> Result<u32> {
///     if value % 2 == 1 {
///         return Err(HandlerError::Reject("odd value".into()));
///     }
///     Ok(value / 2)
/// }
///
/// # #[tokio::main] async fn main() -> std::result::Result<(), beavers::Error> {
/// let source = TestSource::<Json<u32>, Vec<u8>>::new([b"4".to_vec(), b"3".to_vec(), b"x".to_vec()]);
/// let deliveries = source.deliveries();
/// let sink = InMemorySink::default();
/// let dlq = InMemorySink::<DeadLetter<u32, Vec<u8>>>::default();
/// App::new()
///     .subscription(
///         Subscription::new("halve", source, sink.clone(), halve)
///             .dlq(dlq.clone())
///             .error_policy(ErrorPolicy::dead_letter_all()),
///     )
///     .run()
///     .await?;
///
/// assert_eq!(sink.values(), [2]);
/// let failures: Vec<_> = dlq.values().into_iter().map(|dead| (dead.failure, dead.raw)).collect();
/// assert_eq!(
///     failures,
///     [(FailureKind::Rejected, b"3".to_vec()), (FailureKind::Decode, b"x".to_vec())]
/// );
/// assert!(deliveries.all_acknowledged());
/// # Ok(()) }
/// ```
pub struct TestSource<C, R> {
    records: VecDeque<(usize, R)>,
    codec: Arc<C>,
    deliveries: Deliveries<R>,
}

/// A [`TestSource`] of Kafka records, delivering `KafkaRecord<T>` inputs.
#[cfg(feature = "kafka")]
pub type KafkaTestSource<C> = TestSource<C, KafkaRecord<Vec<u8>>>;

/// A [`TestSource`] of Pulsar messages, delivering `PulsarRecord<T>` inputs.
#[cfg(feature = "pulsar")]
pub type PulsarTestSource<C> = TestSource<C, PulsarRecord<Vec<u8>>>;

/// A [`TestSource`] of Pub/Sub messages, delivering `PubSubRecord<T>` inputs.
#[cfg(feature = "pubsub")]
pub type PubSubTestSource<C> = TestSource<C, PubSubRecord<Vec<u8>>>;

/// A [`TestSource`] of RabbitMQ messages, delivering `RabbitMqRecord<T>` inputs.
#[cfg(feature = "rabbitmq")]
pub type RabbitMqTestSource<C> = TestSource<C, RabbitMqRecord<Vec<u8>>>;

/// A [`TestSource`] of Service Bus messages, delivering `ServiceBusRecord<T>`
/// inputs.
#[cfg(feature = "servicebus")]
pub type ServiceBusTestSource<C> = TestSource<C, ServiceBusRecord<Vec<u8>>>;

/// A [`TestSource`] of SQS messages, delivering `SqsRecord<T>` inputs.
#[cfg(feature = "sqs")]
pub type SqsTestSource<C> = TestSource<C, SqsRecord<Vec<u8>>>;

impl<C: Default, R: TestRecord> TestSource<C, R> {
    /// A source that delivers `records` in order, decoding them with the codec's default
    /// value, and then ends.
    pub fn new(records: impl IntoIterator<Item = R>) -> Self {
        Self::with_codec(records, C::default())
    }
}

impl<C, R: TestRecord> TestSource<C, R> {
    /// A source that delivers `records` in order, decoding them with `codec`, and then ends.
    pub fn with_codec(records: impl IntoIterator<Item = R>, codec: C) -> Self {
        let records: Vec<R> = records.into_iter().collect();
        Self {
            deliveries: Deliveries::new(records.clone()),
            records: records.into_iter().enumerate().collect(),
            codec: Arc::new(codec),
        }
    }

    /// A shared view of each record's delivery state.
    pub fn deliveries(&self) -> Deliveries<R> {
        self.deliveries.clone()
    }
}

impl<C, R> Source for TestSource<C, R>
where
    C: Decoder<Value: Clone + Send + Sync + 'static>,
    R: TestRecord,
{
    type Message = TestMessage<C, R>;

    async fn receive(&mut self) -> Result<Receive<Self::Message>, ReceiveError> {
        Ok(match self.records.pop_front() {
            Some((index, record)) => {
                self.deliveries.receive(index);
                Receive::Message(TestMessage {
                    record,
                    index,
                    codec: self.codec.clone(),
                    deliveries: self.deliveries.clone(),
                })
            }
            None => Receive::End,
        })
    }
}

/// A delivery of [`TestSource`]. Acknowledging it records the acknowledgement.
pub struct TestMessage<C, R> {
    record: R,
    index: usize,
    codec: Arc<C>,
    deliveries: Deliveries<R>,
}

impl<C, R> SourceMessage for TestMessage<C, R>
where
    C: Decoder<Value: Clone + Send + Sync + 'static>,
    R: TestRecord,
{
    type Item = R::Decoded<C::Value>;
    type Raw = R;

    fn decode(&self) -> Result<Self::Item, BoxError> {
        self.record.decode(&*self.codec)
    }

    fn raw(&self) -> R {
        self.record.clone()
    }

    async fn ack(self) -> Result<(), BoxError> {
        self.deliveries.acknowledge(self.index);
        Ok(())
    }

    fn ordering_key(&self) -> Option<OrderingKey> {
        self.record.ordering_key()
    }

    fn propagation_fields(&self) -> Vec<(&str, &str)> {
        self.record.propagation_fields()
    }
}