tea-coding-tools 0.1.0

Workspace-scoped native coding tool adapters for tea-rs
Documentation
use std::net::SocketAddr;
use std::sync::Arc;
use std::sync::atomic::{AtomicUsize, Ordering};
use std::time::Duration;

use tea_coding_tools::{
    FetchBodyDecoder, FetchBodyLimits, FetchCacheConfig, FetchCacheScope, FetchHttpConfig,
    FetchHttpLimits, FetchHttpTimeouts, FetchHttpTransport, FetchProvider, FetchProviderErrorCode,
    FetchRequest, FetchResultCache, FetchRetryDisposition, FetchUrlPolicy, HttpFetchProvider,
    SystemFetchDnsResolver,
};
use tea_control::CancellationScope;
use tea_provider_http::ProviderHttpConfig;
use tokio::io::{AsyncReadExt as _, AsyncWriteExt as _};
use tokio::net::{TcpListener, TcpStream};

#[derive(Clone)]
enum ResponseBody {
    Fixed(&'static str),
    RequestPath,
}

#[derive(Clone)]
struct FixtureResponse {
    status: u16,
    content_type: &'static str,
    body: ResponseBody,
}

struct FixtureServer {
    address: SocketAddr,
    requests: Arc<AtomicUsize>,
    task: tokio::task::JoinHandle<()>,
}

impl FixtureServer {
    async fn spawn(response: FixtureResponse) -> Self {
        let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
        let address = listener.local_addr().unwrap();
        let requests = Arc::new(AtomicUsize::new(0));
        let request_counter = requests.clone();
        let task = tokio::spawn(async move {
            loop {
                let Ok((mut stream, _)) = listener.accept().await else {
                    break;
                };
                let request = read_request(&mut stream).await;
                request_counter.fetch_add(1, Ordering::SeqCst);
                let path = request
                    .lines()
                    .next()
                    .and_then(|line| line.split_whitespace().nth(1))
                    .unwrap_or("/");
                let body = match response.body {
                    ResponseBody::Fixed(body) => body.to_owned(),
                    ResponseBody::RequestPath => path.to_owned(),
                };
                write_response(&mut stream, &response, &body).await;
            }
        });
        Self {
            address,
            requests,
            task,
        }
    }

    fn url(&self, path: &str) -> String {
        format!("http://127.0.0.1:{}{path}", self.address.port())
    }

    fn request_count(&self) -> usize {
        self.requests.load(Ordering::SeqCst)
    }
}

impl Drop for FixtureServer {
    fn drop(&mut self) {
        self.task.abort();
    }
}

async fn read_request(stream: &mut TcpStream) -> String {
    let mut request = Vec::new();
    let mut buffer = [0_u8; 1024];
    loop {
        let read = stream.read(&mut buffer).await.unwrap();
        if read == 0 {
            break;
        }
        request.extend_from_slice(&buffer[..read]);
        if request.windows(4).any(|window| window == b"\r\n\r\n") {
            break;
        }
    }
    String::from_utf8(request).unwrap()
}

async fn write_response(stream: &mut TcpStream, response: &FixtureResponse, body: &str) {
    let reason = match response.status {
        200 => "OK",
        404 => "Not Found",
        500 => "Internal Server Error",
        _ => "Fixture",
    };
    let head = format!(
        "HTTP/1.1 {} {reason}\r\nContent-Type: {}\r\nContent-Length: {}\r\nConnection: close\r\n\r\n",
        response.status,
        response.content_type,
        body.len(),
    );
    stream.write_all(head.as_bytes()).await.unwrap();
    stream.write_all(body.as_bytes()).await.unwrap();
    stream.shutdown().await.unwrap();
}

fn transport() -> FetchHttpTransport {
    let timeouts = FetchHttpTimeouts::new(
        Duration::from_millis(250),
        Duration::from_millis(250),
        Duration::from_millis(500),
        Duration::from_secs(2),
        Duration::from_millis(500),
        1,
    )
    .unwrap();
    let limits = FetchHttpLimits::new(5, 16 * 1024).unwrap();
    FetchHttpTransport::new(
        FetchHttpConfig::loopback_tests(timeouts, limits),
        Arc::new(SystemFetchDnsResolver),
        ProviderHttpConfig::new(),
    )
}

fn scope(workspace: &str, profile: &str) -> FetchCacheScope {
    FetchCacheScope::new(workspace, profile).unwrap()
}

fn make_provider(scope: FetchCacheScope, cache: Arc<FetchResultCache>) -> HttpFetchProvider {
    HttpFetchProvider::new(transport(), FetchBodyDecoder::default(), scope, cache)
}

fn make_provider_with_decoder(
    scope: FetchCacheScope,
    cache: Arc<FetchResultCache>,
    decoder: FetchBodyDecoder,
) -> HttpFetchProvider {
    HttpFetchProvider::new(transport(), decoder, scope, cache)
}

fn request(server: &FixtureServer, path: &str, max_chars: usize) -> FetchRequest {
    FetchRequest::new_with_policy(
        server.url(path),
        max_chars,
        &FetchUrlPolicy::loopback_tests(),
    )
    .unwrap()
}

#[tokio::test(flavor = "current_thread")]
async fn provider_normalizes_success_and_reuses_only_normalized_cache_entries() {
    let server = FixtureServer::spawn(FixtureResponse {
        status: 200,
        content_type: "text/html; charset=utf-8",
        body: ResponseBody::Fixed(
            "<html><head><title>Tea docs</title></head><body>cached body</body></html>",
        ),
    })
    .await;
    let cache = Arc::new(FetchResultCache::new(FetchCacheConfig::default()));
    let provider = make_provider(scope("private-workspace", "private-profile"), cache.clone());
    let request = request(&server, "/guide?token=secret", 100);

    let first = provider
        .fetch(request.clone(), CancellationScope::new())
        .await
        .unwrap();
    let second = provider
        .fetch(request, CancellationScope::new())
        .await
        .unwrap();

    assert_eq!(first, second);
    assert_eq!(first.title(), Some("Tea docs"));
    assert_eq!(first.body(), "cached body");
    assert_eq!(server.request_count(), 1);
    assert_eq!(cache.stats().entries(), 1);
    let debug = format!("{provider:?}");
    assert!(!debug.contains("private-workspace"));
    assert!(!debug.contains("private-profile"));
    assert!(!debug.contains("secret"));
    assert!(!debug.contains("cached body"));
}

#[tokio::test(flavor = "current_thread")]
async fn shared_cache_is_isolated_by_workspace_and_profile() {
    let server = FixtureServer::spawn(FixtureResponse {
        status: 200,
        content_type: "text/plain",
        body: ResponseBody::Fixed("isolated"),
    })
    .await;
    let cache = Arc::new(FetchResultCache::new(FetchCacheConfig::default()));
    let providers = [
        make_provider(scope("workspace-a", "profile-a"), cache.clone()),
        make_provider(scope("workspace-b", "profile-a"), cache.clone()),
        make_provider(scope("workspace-a", "profile-b"), cache.clone()),
    ];
    let request = request(&server, "/same", 100);

    for provider in &providers {
        provider
            .fetch(request.clone(), CancellationScope::new())
            .await
            .unwrap();
    }
    for provider in &providers {
        provider
            .fetch(request.clone(), CancellationScope::new())
            .await
            .unwrap();
    }

    let stricter_decoder = FetchBodyDecoder::new(FetchBodyLimits::new(1024, 1024, 100).unwrap());
    make_provider_with_decoder(
        scope("workspace-a", "profile-a"),
        cache.clone(),
        stricter_decoder,
    )
    .fetch(request.clone(), CancellationScope::new())
    .await
    .unwrap();

    assert_eq!(server.request_count(), 4);
    assert_eq!(cache.stats().entries(), 4);
}

#[tokio::test(flavor = "current_thread")]
async fn cache_evicts_least_recently_used_and_skips_oversized_entries() {
    let server = FixtureServer::spawn(FixtureResponse {
        status: 200,
        content_type: "text/plain",
        body: ResponseBody::RequestPath,
    })
    .await;
    let cache = Arc::new(FetchResultCache::new(
        FetchCacheConfig::new(Duration::from_mins(1), 2, 4096, 2048).unwrap(),
    ));
    let provider = make_provider(scope("workspace", "profile"), cache.clone());

    for path in ["/one", "/two", "/one", "/three", "/two"] {
        provider
            .fetch(request(&server, path, 100), CancellationScope::new())
            .await
            .unwrap();
    }
    assert_eq!(server.request_count(), 4);
    assert_eq!(cache.stats().entries(), 2);
    assert!(cache.stats().logical_bytes() <= 4096);

    let tiny_cache = Arc::new(FetchResultCache::new(
        FetchCacheConfig::new(Duration::from_mins(1), 2, 128, 128).unwrap(),
    ));
    let tiny_provider = make_provider(scope("workspace", "tiny"), tiny_cache.clone());
    let oversized = request(&server, "/oversized", 100);
    tiny_provider
        .fetch(oversized.clone(), CancellationScope::new())
        .await
        .unwrap();
    tiny_provider
        .fetch(oversized, CancellationScope::new())
        .await
        .unwrap();
    assert_eq!(server.request_count(), 6);
    assert_eq!(tiny_cache.stats().entries(), 0);
}

#[tokio::test(flavor = "current_thread")]
async fn cancellation_wins_even_when_a_normalized_result_is_cached() {
    let server = FixtureServer::spawn(FixtureResponse {
        status: 200,
        content_type: "text/plain",
        body: ResponseBody::Fixed("cached"),
    })
    .await;
    let cache = Arc::new(FetchResultCache::new(FetchCacheConfig::default()));
    let provider = make_provider(scope("workspace", "profile"), cache);
    let request = request(&server, "/cancel", 100);
    provider
        .fetch(request.clone(), CancellationScope::new())
        .await
        .unwrap();

    let cancellation = CancellationScope::new();
    cancellation.cancel();
    let error = provider.fetch(request, cancellation).await.unwrap_err();
    assert_eq!(error.code(), FetchProviderErrorCode::Cancelled);
    assert_eq!(server.request_count(), 1);
}

#[tokio::test(flavor = "current_thread")]
async fn only_pre_response_transport_failures_allow_explicit_retry() {
    let unused = TcpListener::bind("127.0.0.1:0").await.unwrap();
    let unavailable_address = unused.local_addr().unwrap();
    drop(unused);
    let cache = Arc::new(FetchResultCache::new(FetchCacheConfig::default()));
    let provider = make_provider(scope("workspace", "profile"), cache.clone());
    let unavailable = FetchRequest::new_with_policy(
        format!("http://127.0.0.1:{}/", unavailable_address.port()),
        100,
        &FetchUrlPolicy::loopback_tests(),
    )
    .unwrap();
    let error = provider
        .fetch(unavailable, CancellationScope::new())
        .await
        .unwrap_err();
    assert_eq!(error.code(), FetchProviderErrorCode::Transport);
    assert_eq!(error.retry_disposition(), FetchRetryDisposition::Explicit);

    let server = FixtureServer::spawn(FixtureResponse {
        status: 500,
        content_type: "text/plain",
        body: ResponseBody::Fixed("failure body"),
    })
    .await;
    let failed_request = request(&server, "/failure", 100);
    for _ in 0..2 {
        let error = provider
            .fetch(failed_request.clone(), CancellationScope::new())
            .await
            .unwrap_err();
        assert_eq!(error.code(), FetchProviderErrorCode::Transport);
        assert_eq!(error.retry_disposition(), FetchRetryDisposition::Never);
        assert!(!format!("{error:?}").contains("failure body"));
    }
    assert_eq!(server.request_count(), 2);
    assert_eq!(cache.stats().entries(), 0);
}