kape-testkit 0.1.2

Reusable backend contract tests for Kape adapters.
Documentation
use std::{
    collections::HashMap,
    sync::{Arc, Mutex},
};

use futures_lite::future::block_on;
use kape::{CacheBackend, CacheEntry, KapeError, KapeResult, SetItem};

#[derive(Default)]
struct ScalarBackend {
    entries: Mutex<HashMap<String, Arc<String>>>,
}

#[async_trait::async_trait]
impl CacheBackend<String, String> for ScalarBackend {
    async fn get(&self, key: &String) -> KapeResult<Option<CacheEntry<String>>> {
        Ok(self
            .entries
            .lock()
            .expect("entries mutex poisoned")
            .get(key)
            .cloned()
            .map(|value| CacheEntry::new(value, -1)))
    }

    async fn set(&self, key: &String, value: Arc<String>, ttl: i64) -> KapeResult<()> {
        if key == "fail" {
            return Err(KapeError::backend(std::io::Error::other("set failed")));
        }
        let mut entries = self.entries.lock().expect("entries mutex poisoned");
        if ttl == 0 {
            entries.remove(key);
        } else {
            entries.insert(key.clone(), value);
        }
        Ok(())
    }

    async fn remove(&self, key: &String) -> KapeResult<()> {
        self.entries
            .lock()
            .expect("entries mutex poisoned")
            .remove(key);
        Ok(())
    }

    async fn clear(&self) -> KapeResult<()> {
        self.entries.lock().expect("entries mutex poisoned").clear();
        Ok(())
    }
}

#[test]
fn default_batch_is_sequential_and_retains_earlier_effects() {
    block_on(async {
        let backend = ScalarBackend::default();
        let error = backend
            .set_many(&[
                SetItem::new(&"first".to_owned(), "stored".to_owned(), -1),
                SetItem::new(&"fail".to_owned(), "rejected".to_owned(), -1),
                SetItem::new(&"later".to_owned(), "unreached".to_owned(), -1),
            ])
            .await
            .expect_err("second scalar write should fail");
        assert!(matches!(error, KapeError::BackendSource { .. }));

        assert!(backend.get(&"first".to_owned()).await.unwrap().is_some());
        assert!(backend.get(&"later".to_owned()).await.unwrap().is_none());
    });
}