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;
pub struct TestSource<C, R> {
records: VecDeque<(usize, R)>,
codec: Arc<C>,
deliveries: Deliveries<R>,
}
#[cfg(feature = "kafka")]
pub type KafkaTestSource<C> = TestSource<C, KafkaRecord<Vec<u8>>>;
#[cfg(feature = "pulsar")]
pub type PulsarTestSource<C> = TestSource<C, PulsarRecord<Vec<u8>>>;
#[cfg(feature = "pubsub")]
pub type PubSubTestSource<C> = TestSource<C, PubSubRecord<Vec<u8>>>;
#[cfg(feature = "rabbitmq")]
pub type RabbitMqTestSource<C> = TestSource<C, RabbitMqRecord<Vec<u8>>>;
#[cfg(feature = "servicebus")]
pub type ServiceBusTestSource<C> = TestSource<C, ServiceBusRecord<Vec<u8>>>;
#[cfg(feature = "sqs")]
pub type SqsTestSource<C> = TestSource<C, SqsRecord<Vec<u8>>>;
impl<C: Default, R: TestRecord> TestSource<C, R> {
pub fn new(records: impl IntoIterator<Item = R>) -> Self {
Self::with_codec(records, C::default())
}
}
impl<C, R: TestRecord> TestSource<C, R> {
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),
}
}
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,
})
}
}
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()
}
}