Skip to content

refactor(http/retry): port some ReplayBody tests to Frame<T> #3564

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
cratelyn merged 2 commits into from
Jan 27, 2025
Merged

refactor(http/retry): port some ReplayBody tests to Frame<T> #3564

Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
28c80b8
refactor(http/retry): `replays_trailers()` uses `Frame<T>`
cratelyn Jan 13, 2025
cc7adcb
refactor(http/retry): `trailers_only()` uses `Frame<T>`
cratelyn Jan 13, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
67 changes: 45 additions & 22 deletions linkerd/http/retry/src/replay.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -547,8 +547,8 @@ mod tests {
async fn replays_trailers() {
let Test {
mut tx,
mut initial,
mut replay,
initial,
replay,
_trace,
} = Test::new();

Expand All @@ -560,30 +560,43 @@ mod tests {
tx.send_trailers(tlrs.clone()).await;
drop(tx);

while initial.data().await.is_some() {
// do nothing
}
let initial_tlrs = initial.trailers().await.expect("trailers should not error");
assert_eq!(initial_tlrs.as_ref(), Some(&tlrs));
let read_trailers = |body: ReplayBody<_>| async move {
let mut body = crate::compat::ForwardCompatibleBody::new(body);
let _ = body
.frame()
.await
.expect("should yield a result")
.expect("should yield a frame")
.into_data()
.expect("should yield data");
let trls = body
.frame()
.await
.expect("should yield a result")
.expect("should yield a frame")
.into_trailers()
.expect("should yield trailers");
assert!(body.frame().await.is_none());
trls
};

// drop the initial body to send the data to the replay
drop(initial);
let initial_tlrs = read_trailers(initial).await;
assert_eq!(&initial_tlrs, &tlrs);

while replay.data().await.is_some() {
// do nothing
}
let replay_tlrs = replay.trailers().await.expect("trailers should not error");
assert_eq!(replay_tlrs.as_ref(), Some(&tlrs));
let replay_tlrs = read_trailers(replay).await;
assert_eq!(&replay_tlrs, &tlrs);
}

#[tokio::test]
async fn trailers_only() {
let Test {
mut tx,
mut initial,
mut replay,
initial,
replay,
_trace,
} = Test::new();
let mut initial = crate::compat::ForwardCompatibleBody::new(initial);
let mut replay = crate::compat::ForwardCompatibleBody::new(replay);

let mut tlrs = HeaderMap::new();
tlrs.insert("x-hello", HeaderValue::from_str("world").unwrap());
Expand All @@ -593,16 +606,26 @@ mod tests {

drop(tx);

assert!(dbg!(initial.data().await).is_none(), "no data in body");
let initial_tlrs = initial.trailers().await.expect("trailers should not error");
assert_eq!(initial_tlrs.as_ref(), Some(&tlrs));
let initial_tlrs = initial
.frame()
.await
.expect("should yield a result")
.expect("should yield a frame")
.into_trailers()
.expect("should yield trailers");
assert_eq!(&initial_tlrs, &tlrs);

// drop the initial body to send the data to the replay
drop(initial);

assert!(dbg!(replay.data().await).is_none(), "no data in body");
let replay_tlrs = replay.trailers().await.expect("trailers should not error");
assert_eq!(replay_tlrs.as_ref(), Some(&tlrs));
let replay_tlrs = replay
.frame()
.await
.expect("should yield a result")
.expect("should yield a frame")
.into_trailers()
.expect("should yield trailers");
assert_eq!(&replay_tlrs, &tlrs);
}

#[tokio::test(flavor = "current_thread")]
Expand Down
Loading