Testing Trait Designs

use std::cell::RefCell;
use std::collections::HashMap;

pub trait Store {
    fn get(&self, key: &str) -> Option<String>;
    fn put(&self, key: &str, value: String);
}

pub fn remember_name(store: &dyn Store, user: &str, name: &str) -> bool {
    let key = format!("name:{user}");
    if store.get(&key).is_some() {
        return false;
    }
    store.put(&key, name.to_string());
    true
}

#[derive(Default)]
struct FakeStore {
    data: RefCell<HashMap<String, String>>,
    puts: RefCell<Vec<String>>,          // record calls for assertions
}

impl Store for FakeStore {
    fn get(&self, key: &str) -> Option<String> {
        self.data.borrow().get(key).cloned()
    }
    fn put(&self, key: &str, value: String) {
        self.puts.borrow_mut().push(key.to_string());
        self.data.borrow_mut().insert(key.to_string(), value);
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn stores_once() {
        let store = FakeStore::default();
        assert!(remember_name(&store, "u1", "Ada"));
        assert!(!remember_name(&store, "u1", "Bob"));
        assert_eq!(store.puts.borrow().as_slice(), ["name:u1"]);
    }
}

use mockall::{automock, predicate::eq};

#[cfg_attr(test, automock)]
pub trait Clock {
    fn now_ms(&self) -> u64;
}

#[cfg_attr(test, automock)]
pub trait Store {
    fn get(&self, key: &str) -> Option<String>;
}

pub fn is_fresh(clock: &dyn Clock, store: &dyn Store, key: &str) -> bool {
    store.get(key).and_then(|v| v.parse::<u64>().ok()).is_some_and(|t| clock.now_ms() - t < 60_000)
}

#[test]
fn fresh_within_a_minute() {
    let mut clock = MockClock::new();
    clock.expect_now_ms().return_const(100_000u64);
    let mut store = MockStore::new();
    store.expect_get().with(eq("k")).times(1).returning(|_| Some("90000".into()));
    assert!(is_fresh(&clock, &store, "k"));
}

use std::fmt::Debug;

pub trait Backend: Debug + Send + Sync {
    fn name(&self) -> &str;
}

#[derive(Debug)]
pub struct Memory;
impl Backend for Memory {
    fn name(&self) -> &str { "memory" }
}

// 1. The trait stays dyn compatible (fails with E0038 if someone adds a generic method).
#[allow(dead_code)]
fn assert_dyn_compatible(_: &dyn Backend) {}

// 2. Public types keep their auto traits (removing Send is a breaking change).
const _: () = {
    const fn send_sync<T: Send + Sync>() {}
    send_sync::<Memory>();
    send_sync::<Box<dyn Backend>>();
};

/// A typestate builder: `build()` is unavailable until a URL is set.
///
/// ```compile_fail
/// let client = mycrate::Client::builder().build(); // no `build` on ClientBuilder<Missing>
/// ```
///
/// Downstream crates cannot implement the sealed `Codec` trait:
///
/// ```compile_fail
/// struct Mine;
/// impl mycrate::Codec for Mine { fn name(&self) -> &'static str { "mine" } }
/// ```
pub struct Client;

#[test]
fn ui() {
    let t = trybuild::TestCases::new();
    t.compile_fail("tests/ui/*.rs"); // each file must fail; stderr compared to tests/ui/*.stderr
}

use proptest::prelude::*;
use std::hash::{BuildHasher, RandomState};

proptest! {
    #[test]
    fn eq_implies_same_hash(a in "[a-zA-Z]{0,8}", b in "[a-zA-Z]{0,8}") {
        let (ka, kb) = (CaseInsensitiveKey::new(&a), CaseInsensitiveKey::new(&b));
        if ka == kb {
            let s = RandomState::new();
            prop_assert_eq!(s.hash_one(&ka), s.hash_one(&kb));
        }
    }
}

use std::collections::hash_map::RandomState;
use std::hash::{BuildHasher, Hash, Hasher};

#[derive(Debug, Clone, Eq)]
pub struct Key(String);

impl PartialEq for Key {
    fn eq(&self, other: &Self) -> bool { self.0.eq_ignore_ascii_case(&other.0) }
}

impl Hash for Key {
    fn hash<H: Hasher>(&self, h: &mut H) {
        self.0.to_ascii_lowercase().hash(h); // hash what eq compares
    }
}

#[test]
fn eq_and_hash_agree() {
    let s = RandomState::new();
    for (a, b) in [("Ab", "aB"), ("x", "X"), ("", "")] {
        let (a, b) = (Key(a.into()), Key(b.into()));
        assert_eq!(a, b);
        assert_eq!(s.hash_one(&a), s.hash_one(&b));
    }
}

use std::future::Future;

pub trait Fetch: Sync {
    fn fetch(&self, key: &str) -> impl Future<Output = Option<Vec<u8>>> + Send;
}

pub struct Fake;
impl Fetch for Fake {
    async fn fetch(&self, _key: &str) -> Option<Vec<u8>> { Some(vec![1]) }
}

#[allow(dead_code)]
fn assert_send_future<F: Fetch>(f: &F) {
    fn is_send<T: Send>(_: T) {}
    is_send(f.fetch("k")); // fails to compile if an impl's future is not Send
}