new plan

server/tests/support/fake_cursor.rs

@@ -1,9 +0,0 @@
-use bytes::Bytes;
-use cursor_server::{cursor::connect, Result};
-use prost::Message;
-
-pub fn decode_single<M: Message + Default>(frame: &Bytes) -> Result<M> {
-    let frames = connect::decode_frames(frame)?;
-    assert_eq!(frames.len(), 1);
-    Ok(M::decode(frames[0].1.clone())?)
-}

server/tests/support/fake_provider.rs

@@ -1,91 +0,0 @@
-#![allow(dead_code)]
-
-use std::{
-    collections::VecDeque,
-    sync::{Arc, Mutex},
-};
-
-use cursor_server::{
-    model::{ModelInvocation, ModelRequest},
-    provider::{ModelEvent, Provider, ProviderStream},
-    Error,
-};
-use futures_util::{stream, StreamExt};
-use tokio_util::sync::CancellationToken;
-
-enum FakeResponse {
-    Events(Vec<Result<ModelEvent, Error>>),
-    Gated {
-        ready: Arc<tokio::sync::Notify>,
-        events: Vec<Result<ModelEvent, Error>>,
-    },
-    Pending,
-}
-
-#[derive(Clone, Default)]
-pub struct FakeProvider {
-    responses: Arc<Mutex<VecDeque<FakeResponse>>>,
-    requests: Arc<Mutex<Vec<ModelRequest>>>,
-}
-
-impl FakeProvider {
-    pub fn push(&self, events: Vec<ModelEvent>) {
-        self.responses
-            .lock()
-            .unwrap()
-            .push_back(FakeResponse::Events(events.into_iter().map(Ok).collect()));
-    }
-    pub fn push_error(&self, error: Error) {
-        self.responses
-            .lock()
-            .unwrap()
-            .push_back(FakeResponse::Events(vec![Err(error)]));
-    }
-    pub fn push_pending(&self) {
-        self.responses
-            .lock()
-            .unwrap()
-            .push_back(FakeResponse::Pending);
-    }
-    pub fn push_gated(&self, events: Vec<ModelEvent>) -> Arc<tokio::sync::Notify> {
-        let ready = Arc::new(tokio::sync::Notify::new());
-        self.responses
-            .lock()
-            .unwrap()
-            .push_back(FakeResponse::Gated {
-                ready: ready.clone(),
-                events: events.into_iter().map(Ok).collect(),
-            });
-        ready
-    }
-    pub fn requests(&self) -> Vec<ModelRequest> {
-        self.requests.lock().unwrap().clone()
-    }
-}
-
-impl Provider for FakeProvider {
-    fn stream(
-        &self,
-        invocation: ModelInvocation,
-        _cancellation: CancellationToken,
-    ) -> ProviderStream {
-        self.requests.lock().unwrap().push(invocation.request);
-        let events = self
-            .responses
-            .lock()
-            .unwrap()
-            .pop_front()
-            .expect("fake response configured");
-        match events {
-            FakeResponse::Events(events) => Box::pin(stream::iter(events)),
-            FakeResponse::Gated { ready, events } => Box::pin(
-                stream::once(async move {
-                    ready.notified().await;
-                    events
-                })
-                .flat_map(stream::iter),
-            ),
-            FakeResponse::Pending => Box::pin(stream::pending()),
-        }
-    }
-}

server/tests/support/fixtures.rs

@@ -1,17 +0,0 @@
-#![allow(dead_code)]
-
-use cursor_server::{
-    model::{CanonicalMessage, Origin, Role},
-    store::Store,
-};
-
-pub async fn temp_store() -> (tempfile::TempDir, Store) {
-    let directory = tempfile::tempdir().unwrap();
-    let url = format!("sqlite://{}", directory.path().join("test.db").display());
-    let store = Store::connect(&url).await.unwrap();
-    (directory, store)
-}
-
-pub fn user(id: &str, text: &str) -> CanonicalMessage {
-    CanonicalMessage::text(id, Role::User, Origin::User, text)
-}