test.rs

use forced_collaboration::{
    corpus::key_value_store::{Operation, Response},
    proptest::*,
    test_key_value_store, transport, Host, Simulation,
};

use async_trait::async_trait;
use dashmap::DashMap;
use eyre::Result;
use turmoil::net::TcpStream;

#[derive(Debug, Clone, Default)]
pub struct Server {
    pub inner: DashMap<String, String>,
}

#[async_trait]
impl Host for Server {
    async fn on_connection(&self, stream: TcpStream) -> Result<TcpStream> {
        let (mut reader, mut writer) = transport::<Operation, Response>(stream);

        while let Ok(event) = reader.read().await {
            let response = match event {
                Operation::Set(key, value) => {
                    let response = match self.inner.get(&key).as_ref() {
                        Some(old) => Response::replaced(&key, (*old).clone()),
                        None => Response::ack(),
                    };

                    self.inner.insert(key, value);

                    response
                }
                Operation::Get(key) => match self.inner.get(&key) {
                    Some(v) => Response::value(v.clone()),
                    None => Response::empty(key),
                },
                Operation::Delete(key) => match self.inner.remove(&key) {
                    Some(_) => Response::ack(),
                    None => Response::empty(key),
                },
            };

            writer.write(response).await?;
        }

        Ok(reader.reunite(writer)?)
    }
}

test_key_value_store!(Server);