cfprobe 0.1.0

Cloudflare reverse proxy and CDN detection engine
Documentation
mod support;

use std::time::Duration;

use cfprobe::{CacheConfig, CacheSource, CloudflareClient, CloudflareRangeProvider};

use support::mock_cloudflare::{MockCloudflareServer, MockMode};

#[tokio::test]
async fn cache_directory_is_created() {
    cfprobe::init_rustls_crypto();
    let temp_dir = tempfile::TempDir::new().unwrap();
    println!("temp_dir: {:?}", temp_dir.path());

    let http = reqwest::Client::builder()
        .user_agent("cfprobe-test")
        .build()
        .unwrap();

    let client = CloudflareClient::new(http);

    let provider = CloudflareRangeProvider::with_cache_dir(client, temp_dir.path());

    assert!(provider.is_ok());
}

#[tokio::test]
async fn fetch_from_network_on_empty_cache() {
    cfprobe::init_rustls_crypto();
    let server = MockCloudflareServer::start().await;

    let temp = tempfile::TempDir::new().unwrap();

    let http = reqwest::Client::builder()
        .user_agent("cfprobe-test")
        .build()
        .unwrap();

    let client =
        CloudflareClient::with_endpoint(http, format!("{}/client/v4/ips", server.endpoint));

    let provider = CloudflareRangeProvider::with_cache_dir(client, temp.path()).unwrap();

    let result = provider.get().await.unwrap();

    assert_eq!(result.source, CacheSource::Network);

    assert!(result.ranges.contains("104.16.1.1".parse().unwrap()));

    assert_eq!(server.state.request_count(), 1);
}

#[tokio::test]
async fn second_provider_uses_disk_cache() {
    cfprobe::init_rustls_crypto();
    let server = MockCloudflareServer::start().await;

    let temp = tempfile::TempDir::new().unwrap();

    let http = reqwest::Client::new();

    let endpoint = format!("{}/client/v4/ips", server.endpoint);

    let client = CloudflareClient::with_endpoint(http.clone(), endpoint.clone());

    let provider = CloudflareRangeProvider::with_cache_dir(client, temp.path()).unwrap();

    let first = provider.get().await.unwrap();

    assert_eq!(first.source, CacheSource::Network);

    let client2 = CloudflareClient::with_endpoint(http, endpoint);

    let provider2 = CloudflareRangeProvider::with_cache_dir(client2, temp.path()).unwrap();

    let second = provider2.get().await.unwrap();

    assert_eq!(second.source, CacheSource::Disk);

    assert_eq!(server.state.request_count(), 1);
}

#[tokio::test]
async fn stale_cache_uses_etag_and_handles_304() {
    cfprobe::init_rustls_crypto();
    let server = MockCloudflareServer::start().await;

    let temp = tempfile::TempDir::new().unwrap();

    let http = reqwest::Client::new();

    let endpoint = format!("{}/client/v4/ips", server.endpoint);

    let client = CloudflareClient::with_endpoint(http.clone(), endpoint.clone());

    let config = CacheConfig {
        refresh_interval: Duration::from_millis(0),

        stale_if_error: Duration::from_secs(60),

        ..CacheConfig::default()
    };

    let provider = CloudflareRangeProvider::with_cache_dir(client, temp.path())
        .unwrap()
        .with_config(config.clone());

    let first = provider.get().await.unwrap();

    assert_eq!(first.source, CacheSource::Network);

    tokio::time::sleep(Duration::from_millis(10)).await;

    let client2 = CloudflareClient::with_endpoint(http, endpoint);

    let provider2 = CloudflareRangeProvider::with_cache_dir(client2, temp.path())
        .unwrap()
        .with_config(config);

    let second = provider2.get().await.unwrap();

    assert_eq!(second.source, CacheSource::NotModified);

    assert_eq!(server.state.request_count(), 2);
}

#[tokio::test]
async fn http_error_uses_stale_cache() {
    cfprobe::init_rustls_crypto();
    let server = MockCloudflareServer::start().await;

    let temp = tempfile::TempDir::new().unwrap();

    let http = reqwest::Client::new();

    let endpoint = format!("{}/client/v4/ips", server.endpoint);

    let config = CacheConfig {
        refresh_interval: Duration::from_millis(0),

        stale_if_error: Duration::from_secs(60),

        ..CacheConfig::default()
    };

    let client = CloudflareClient::with_endpoint(http.clone(), endpoint.clone());

    let provider = CloudflareRangeProvider::with_cache_dir(client, temp.path())
        .unwrap()
        .with_config(config.clone());

    provider.get().await.unwrap();

    server.state.set_mode(MockMode::InternalServerError).await;

    tokio::time::sleep(Duration::from_millis(10)).await;

    let client2 = CloudflareClient::with_endpoint(http, endpoint);

    let provider2 = CloudflareRangeProvider::with_cache_dir(client2, temp.path())
        .unwrap()
        .with_config(config);

    let result = provider2.get().await.unwrap();

    assert_eq!(result.source, CacheSource::StaleFallback);

    assert!(result.ranges.contains("104.16.1.1".parse().unwrap()));
}

#[tokio::test]
async fn corrupted_cache_is_recovered() {
    cfprobe::init_rustls_crypto();
    let server = MockCloudflareServer::start().await;

    let temp = tempfile::TempDir::new().unwrap();

    let cache_file = temp.path().join("cloudflare-ip-ranges.json");

    tokio::fs::create_dir_all(temp.path()).await.unwrap();

    tokio::fs::write(&cache_file, b"{ invalid json !!!")
        .await
        .unwrap();

    let http = reqwest::Client::new();

    let client =
        CloudflareClient::with_endpoint(http, format!("{}/client/v4/ips", server.endpoint));

    let provider = CloudflareRangeProvider::with_cache_dir(client, temp.path()).unwrap();

    let result = provider.get().await.unwrap();

    assert_eq!(result.source, CacheSource::Network);

    assert!(result.ranges.contains("104.16.1.1".parse().unwrap()));

    assert_eq!(server.state.request_count(), 1);
}

#[tokio::test]
async fn invalid_cidr_cache_is_recovered() {
    cfprobe::init_rustls_crypto();
    let server = MockCloudflareServer::start().await;

    let temp = tempfile::TempDir::new().unwrap();

    let cache_file = temp.path().join("cloudflare-ip-ranges.json");

    let bad_cache = serde_json::json!({
        "schema_version": 2,
        "fetched_at_unix_ms": 1786623456000i64,
        "etag": "\"bad\"",
        "ipv4_cidrs": [
            "this-is-not-cidr"
        ],
        "ipv6_cidrs": []
    });

    tokio::fs::write(&cache_file, serde_json::to_vec(&bad_cache).unwrap())
        .await
        .unwrap();

    let client = CloudflareClient::with_endpoint(
        reqwest::Client::new(),
        format!("{}/client/v4/ips", server.endpoint),
    );

    let provider = CloudflareRangeProvider::with_cache_dir(client, temp.path()).unwrap();

    let result = provider.get().await.unwrap();

    assert_eq!(result.source, CacheSource::Network);

    assert_eq!(server.state.request_count(), 1);
}

#[tokio::test]
async fn concurrent_providers_only_fetch_once() {
    cfprobe::init_rustls_crypto();
    let server = MockCloudflareServer::start().await;

    server
        .state
        .set_delay(Some(Duration::from_millis(100)))
        .await;

    let temp = tempfile::TempDir::new().unwrap();

    let endpoint = format!("{}/client/v4/ips", server.endpoint);

    let client1 = CloudflareClient::with_endpoint(reqwest::Client::new(), endpoint.clone());

    let client2 = CloudflareClient::with_endpoint(reqwest::Client::new(), endpoint);

    let provider1 = CloudflareRangeProvider::with_cache_dir(client1, temp.path()).unwrap();

    let provider2 = CloudflareRangeProvider::with_cache_dir(client2, temp.path()).unwrap();

    let task1 = tokio::spawn(async move { provider1.get().await });

    let task2 = tokio::spawn(async move { provider2.get().await });

    let result1 = task1.await.unwrap().unwrap();

    let result2 = task2.await.unwrap().unwrap();

    assert_eq!(server.state.request_count(), 1);

    assert!(result1.ranges.contains("104.16.1.1".parse().unwrap()));

    assert!(result2.ranges.contains("104.16.1.1".parse().unwrap()));
}

#[tokio::test]
async fn timeout_without_cache_returns_error() {
    cfprobe::init_rustls_crypto();
    let server = MockCloudflareServer::start().await;

    server
        .state
        .set_delay(Some(Duration::from_millis(200)))
        .await;

    let temp = tempfile::TempDir::new().unwrap();

    let http = reqwest::Client::builder()
        .timeout(Duration::from_millis(50))
        .build()
        .unwrap();

    let client =
        CloudflareClient::with_endpoint(http, format!("{}/client/v4/ips", server.endpoint));

    let provider = CloudflareRangeProvider::with_cache_dir(client, temp.path()).unwrap();

    let result = provider.get().await;

    assert!(result.is_err());
}