26255824633

Committed 21 May 2026 10:04PM UTC coverage: 68.771% (+0.4%) from 68.351%

Build # 26255824633

Build Type

Pull #2266

github

Committed by

web-flow

Commit Message

Merge 29b686e3e into 4070d0a1f

Pull Request Pull Request #2266: Migrate from Trillium [part 9B]: Rewrite test infrastructure + remove all trillium deps

Coverage Stats

345 of 366 new or added lines in 14 files covered. (94.26%)

2 existing lines in 2 files now uncovered.

4422 of 6430 relevant lines covered (68.77%)

69.11 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

97.87

/src/api_mocks.rs

use axum::{
    extract::{Request, State},
    response::IntoResponse,
    Router,
};
use std::{collections::HashMap, sync::Arc};
use tower::ServiceExt;
use url::Url;

pub mod aggregator_api;
pub mod auth0;
pub mod postmark;

fn random_chars(n: usize) -> String {
    std::iter::repeat_with(fastrand::alphabetic)
        .take(n)
        .collect()
}

#[derive(Clone)]
struct HostMap {
    routers: HashMap<String, Router>,
    fallback: Router,
}

#[derive(Debug)]
pub struct ApiMocks {
    router: Router,
}

impl ApiMocks {
    pub fn new(postmark_url: &str, auth0_url: &str) -> Self {
        let mut routers = HashMap::new();
        routers.insert(extract_host(postmark_url), postmark::mock());
        routers.insert(extract_host(auth0_url), auth0::mock(auth0_url));

        let host_map = Arc::new(HostMap {
            routers,
            fallback: aggregator_api::mock(),
        });

        let router = Router::new()
            .fallback(dispatch_by_host)
            .with_state(host_map);

        Self { router }
    }

    pub fn into_router(self) -> Router {
        self.router
    }
}

// NB: Url::host_str() strips IPv6 brackets, but the Host header keeps them.
// Current callers only pass hostname URLs, so this doesn't bite today.
fn extract_host(url: &str) -> String {
    Url::parse(url)
        .ok()
        .and_then(|u| {
            u.host_str().map(|h| match u.port() {
                Some(p) => format!("{h}:{p}"),
                None => h.to_string(),
            })
        })
        .unwrap_or_default()
        .to_lowercase()
}

async fn dispatch_by_host(State(host_map): State<Arc<HostMap>>, req: Request) -> impl IntoResponse {
    let host = req
        .headers()
        .get("host")
        .and_then(|h| h.to_str().ok())
        .unwrap_or("")
        .to_lowercase();

    let router = host_map
        .routers
        .get(&host)
        .unwrap_or(&host_map.fallback)
        .clone();

    router.oneshot(req).await.into_response()
}

1	use axum::{
2	extract::{Request, State},
3	response::IntoResponse,
4	Router,
5	};
6	use std::{collections::HashMap, sync::Arc};
7	use tower::ServiceExt;
8	use url::Url;
9
10	pub mod aggregator_api;
11	pub mod auth0;
12	pub mod postmark;
13
14	fn random_chars(n: usize) -> String {	141✔
15	std::iter::repeat_with(fastrand::alphabetic)	141✔
16	.take(n)	141✔
17	.collect()	141✔
18	}	141✔
19
20	#[derive(Clone)]
21	struct HostMap {
22	routers: HashMap<String, Router>,
23	fallback: Router,
24	}
25
26	#[derive(Debug)]
27	pub struct ApiMocks {
28	router: Router,
29	}
30
31	impl ApiMocks {
32	pub fn new(postmark_url: &str, auth0_url: &str) -> Self {	274✔
33	let mut routers = HashMap::new();	274✔
34	routers.insert(extract_host(postmark_url), postmark::mock());	274✔
35	routers.insert(extract_host(auth0_url), auth0::mock(auth0_url));	274✔
36
37	let host_map = Arc::new(HostMap {	274✔
38	routers,	274✔
39	fallback: aggregator_api::mock(),	274✔
40	});	274✔
41
42	let router = Router::new()	274✔
43	.fallback(dispatch_by_host)	274✔
44	.with_state(host_map);	274✔
45
46	Self { router }	274✔
47	}	274✔
48
49	pub fn into_router(self) -> Router {	274✔
50	self.router	274✔
51	}	274✔
52	}
53
54	// NB: Url::host_str() strips IPv6 brackets, but the Host header keeps them.
55	// Current callers only pass hostname URLs, so this doesn't bite today.
56	fn extract_host(url: &str) -> String {	548✔
57	Url::parse(url)	548✔
58	.ok()	548✔
59	.and_then(\|u\| {	548✔
60	u.host_str().map(\|h\| match u.port() {	548✔
NEW 61	Some(p) => format!("{h}:{p}"),	×
62	None => h.to_string(),	548✔
63	})	548✔
64	})	548✔
65	.unwrap_or_default()	548✔
66	.to_lowercase()	548✔
67	}	548✔
68
69	async fn dispatch_by_host(State(host_map): State<Arc<HostMap>>, req: Request) -> impl IntoResponse {	79✔
70	let host = req	79✔
71	.headers()	79✔
72	.get("host")	79✔
73	.and_then(\|h\| h.to_str().ok())	79✔
74	.unwrap_or("")	79✔
75	.to_lowercase();	79✔
76
77	let router = host_map	79✔
78	.routers	79✔
79	.get(&host)	79✔
80	.unwrap_or(&host_map.fallback)	79✔
81	.clone();	79✔
82
83	router.oneshot(req).await.into_response()	79✔
84	}	79✔

divviup / divviup-api / 26255824633

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous