pulled out tests and validated them
This commit is contained in:
1 parent
dc8d62da30
commit
435a54a02d
67 files changed
+6927
-6957
No files matched your search
+2
-125
@@ -455,128 +455,5 @@ fn parse_line(stream: LogStream, raw: &[u8]) -> LogLine {
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn frame_out(s: &str) -> LogOutput {
|
||||
LogOutput::StdOut {
|
||||
message: s.to_owned().into(),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn names() {
|
||||
assert_eq!(normalize_name("/web-1").unwrap(), "web-1");
|
||||
assert_eq!(normalize_name("web.1_x").unwrap(), "web.1_x");
|
||||
assert!(normalize_name("").is_err());
|
||||
assert!(normalize_name("a/b").is_err());
|
||||
assert!(normalize_name("..").is_err());
|
||||
assert!(normalize_name("-x").is_err());
|
||||
assert!(normalize_name("a?b").is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn line_parsing_and_splitting() {
|
||||
let mut sp = LineSplitter::default();
|
||||
let mut got = Vec::new();
|
||||
sp.push(frame_out("2026-10-15T12:00:00.123456789Z hel"), &mut |l| {
|
||||
got.push(l)
|
||||
});
|
||||
assert!(got.is_empty());
|
||||
sp.push(
|
||||
frame_out("lo\n2026-10-15T12:00:01Z two\npartial"),
|
||||
&mut |l| got.push(l),
|
||||
);
|
||||
assert_eq!(got.len(), 2);
|
||||
assert_eq!(got[0].message, "hello");
|
||||
assert!(got[0].ts.is_some());
|
||||
assert_eq!(got[1].message, "two");
|
||||
sp.finish(&mut |l| got.push(l));
|
||||
assert_eq!(got[2].message, "partial");
|
||||
assert_eq!(got[2].ts, None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn error_mapping() {
|
||||
let nf = BollardError::DockerResponseServerError {
|
||||
status_code: 404,
|
||||
message: "no such".into(),
|
||||
};
|
||||
assert!(matches!(
|
||||
map_container_error(&nf, "s", "c"),
|
||||
AppError::NotFound(_)
|
||||
));
|
||||
let denied = BollardError::IOError {
|
||||
err: std::io::Error::from(ErrorKind::PermissionDenied),
|
||||
};
|
||||
assert!(matches!(map_error(&denied, "s"), AppError::Unavailable(_)));
|
||||
let refused = BollardError::IOError {
|
||||
err: std::io::Error::from(ErrorKind::ConnectionRefused),
|
||||
};
|
||||
assert!(matches!(map_error(&refused, "s"), AppError::Unavailable(_)));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn summary_mapping() {
|
||||
use bollard::models::{ContainerState, Health, HealthStatusEnum};
|
||||
let i = ContainerInspectResponse {
|
||||
id: Some("abc".into()),
|
||||
name: Some("/web".into()),
|
||||
restart_count: Some(2),
|
||||
state: Some(ContainerState {
|
||||
status: Some(ContainerStateStatusEnum::RUNNING),
|
||||
started_at: Some("2026-10-15T12:00:00Z".into()),
|
||||
health: Some(Health {
|
||||
status: Some(HealthStatusEnum::HEALTHY),
|
||||
..Default::default()
|
||||
}),
|
||||
..Default::default()
|
||||
}),
|
||||
..Default::default()
|
||||
};
|
||||
let now: Timestamp = "2026-10-15T12:01:00Z".parse().unwrap();
|
||||
let s = summary_from_inspect(&i, now);
|
||||
assert_eq!(s.name, "web");
|
||||
assert_eq!(s.state, "running");
|
||||
assert_eq!(s.health.as_deref(), Some("healthy"));
|
||||
assert_eq!(s.uptime_seconds, Some(60));
|
||||
assert_eq!(s.restart_count, Some(2));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn log_driver_check() {
|
||||
let mut i = ContainerInspectResponse::default();
|
||||
assert!(check_log_driver(&i, "c").is_ok());
|
||||
i.host_config = Some(bollard::models::HostConfig {
|
||||
log_config: Some(bollard::models::HostConfigLogConfig {
|
||||
typ: Some("syslog".into()),
|
||||
config: None,
|
||||
}),
|
||||
..Default::default()
|
||||
});
|
||||
match check_log_driver(&i, "c") {
|
||||
Err(AppError::BadRequest(m)) => assert!(m.contains("syslog")),
|
||||
other => panic!("unexpected {other:?}"),
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn missing_socket_is_unavailable() {
|
||||
let mut cfg = Config::default();
|
||||
cfg.sources.docker_socket = PathBuf::from("/nonexistent/docker.sock");
|
||||
let d = BollardDocker::new(&cfg, CancellationToken::new());
|
||||
assert!(matches!(d.ps(true).await, Err(AppError::Unavailable(_))));
|
||||
assert!(matches!(
|
||||
d.container_status("x").await,
|
||||
Err(AppError::Unavailable(_))
|
||||
));
|
||||
assert!(matches!(
|
||||
d.logs("x", &LogOptions::default()).await,
|
||||
Err(AppError::Unavailable(_))
|
||||
));
|
||||
assert!(matches!(
|
||||
d.follow_logs("x", &LogOptions::default()).await,
|
||||
Err(AppError::Unavailable(_))
|
||||
));
|
||||
}
|
||||
}
|
||||
#[path = "docker_tests.rs"]
|
||||
mod tests;
|
||||
@@ -0,0 +1,123 @@
|
||||
use super::*;
|
||||
|
||||
fn frame_out(s: &str) -> LogOutput {
|
||||
LogOutput::StdOut {
|
||||
message: s.to_owned().into(),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn names() {
|
||||
assert_eq!(normalize_name("/web-1").unwrap(), "web-1");
|
||||
assert_eq!(normalize_name("web.1_x").unwrap(), "web.1_x");
|
||||
assert!(normalize_name("").is_err());
|
||||
assert!(normalize_name("a/b").is_err());
|
||||
assert!(normalize_name("..").is_err());
|
||||
assert!(normalize_name("-x").is_err());
|
||||
assert!(normalize_name("a?b").is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn line_parsing_and_splitting() {
|
||||
let mut sp = LineSplitter::default();
|
||||
let mut got = Vec::new();
|
||||
sp.push(frame_out("2026-10-15T12:00:00.123456789Z hel"), &mut |l| {
|
||||
got.push(l)
|
||||
});
|
||||
assert!(got.is_empty());
|
||||
sp.push(
|
||||
frame_out("lo\n2026-10-15T12:00:01Z two\npartial"),
|
||||
&mut |l| got.push(l),
|
||||
);
|
||||
assert_eq!(got.len(), 2);
|
||||
assert_eq!(got[0].message, "hello");
|
||||
assert!(got[0].ts.is_some());
|
||||
assert_eq!(got[1].message, "two");
|
||||
sp.finish(&mut |l| got.push(l));
|
||||
assert_eq!(got[2].message, "partial");
|
||||
assert_eq!(got[2].ts, None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn error_mapping() {
|
||||
let nf = BollardError::DockerResponseServerError {
|
||||
status_code: 404,
|
||||
message: "no such".into(),
|
||||
};
|
||||
assert!(matches!(
|
||||
map_container_error(&nf, "s", "c"),
|
||||
AppError::NotFound(_)
|
||||
));
|
||||
let denied = BollardError::IOError {
|
||||
err: std::io::Error::from(ErrorKind::PermissionDenied),
|
||||
};
|
||||
assert!(matches!(map_error(&denied, "s"), AppError::Unavailable(_)));
|
||||
let refused = BollardError::IOError {
|
||||
err: std::io::Error::from(ErrorKind::ConnectionRefused),
|
||||
};
|
||||
assert!(matches!(map_error(&refused, "s"), AppError::Unavailable(_)));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn summary_mapping() {
|
||||
use bollard::models::{ContainerState, Health, HealthStatusEnum};
|
||||
let i = ContainerInspectResponse {
|
||||
id: Some("abc".into()),
|
||||
name: Some("/web".into()),
|
||||
restart_count: Some(2),
|
||||
state: Some(ContainerState {
|
||||
status: Some(ContainerStateStatusEnum::RUNNING),
|
||||
started_at: Some("2026-10-15T12:00:00Z".into()),
|
||||
health: Some(Health {
|
||||
status: Some(HealthStatusEnum::HEALTHY),
|
||||
..Default::default()
|
||||
}),
|
||||
..Default::default()
|
||||
}),
|
||||
..Default::default()
|
||||
};
|
||||
let now: Timestamp = "2026-10-15T12:01:00Z".parse().unwrap();
|
||||
let s = summary_from_inspect(&i, now);
|
||||
assert_eq!(s.name, "web");
|
||||
assert_eq!(s.state, "running");
|
||||
assert_eq!(s.health.as_deref(), Some("healthy"));
|
||||
assert_eq!(s.uptime_seconds, Some(60));
|
||||
assert_eq!(s.restart_count, Some(2));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn log_driver_check() {
|
||||
let mut i = ContainerInspectResponse::default();
|
||||
assert!(check_log_driver(&i, "c").is_ok());
|
||||
i.host_config = Some(bollard::models::HostConfig {
|
||||
log_config: Some(bollard::models::HostConfigLogConfig {
|
||||
typ: Some("syslog".into()),
|
||||
config: None,
|
||||
}),
|
||||
..Default::default()
|
||||
});
|
||||
match check_log_driver(&i, "c") {
|
||||
Err(AppError::BadRequest(m)) => assert!(m.contains("syslog")),
|
||||
other => panic!("unexpected {other:?}"),
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn missing_socket_is_unavailable() {
|
||||
let mut cfg = Config::default();
|
||||
cfg.sources.docker_socket = PathBuf::from("/nonexistent/docker.sock");
|
||||
let d = BollardDocker::new(&cfg, CancellationToken::new());
|
||||
assert!(matches!(d.ps(true).await, Err(AppError::Unavailable(_))));
|
||||
assert!(matches!(
|
||||
d.container_status("x").await,
|
||||
Err(AppError::Unavailable(_))
|
||||
));
|
||||
assert!(matches!(
|
||||
d.logs("x", &LogOptions::default()).await,
|
||||
Err(AppError::Unavailable(_))
|
||||
));
|
||||
assert!(matches!(
|
||||
d.follow_logs("x", &LogOptions::default()).await,
|
||||
Err(AppError::Unavailable(_))
|
||||
));
|
||||
}
|
||||
+2
-30
@@ -316,33 +316,5 @@ impl DockerSource for FakeDocker {
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[tokio::test]
|
||||
async fn fakes_behave() {
|
||||
let st = fake_state(Config::default());
|
||||
assert_eq!(
|
||||
st.systemd.list_units(Some("failed")).await.unwrap().len(),
|
||||
1
|
||||
);
|
||||
assert!(matches!(
|
||||
st.systemd.unit_status("nope.service").await,
|
||||
Err(AppError::NotFound(_))
|
||||
));
|
||||
let q = JournalQuery {
|
||||
priority: Some(Priority::Err),
|
||||
..Default::default()
|
||||
};
|
||||
assert_eq!(st.journal.query(&q).await.unwrap().len(), 2);
|
||||
assert_eq!(st.docker.ps(false).await.unwrap().len(), 2);
|
||||
let mut rx = st
|
||||
.docker
|
||||
.follow_logs("web", &LogOptions::default())
|
||||
.await
|
||||
.unwrap();
|
||||
assert!(rx.recv().await.is_some());
|
||||
st.shutdown.cancel();
|
||||
while rx.recv().await.is_some() {}
|
||||
}
|
||||
}
|
||||
#[path = "fake_tests.rs"]
|
||||
mod tests;
|
||||
@@ -0,0 +1,28 @@
|
||||
use super::*;
|
||||
|
||||
#[tokio::test]
|
||||
async fn fakes_behave() {
|
||||
let st = fake_state(Config::default());
|
||||
assert_eq!(
|
||||
st.systemd.list_units(Some("failed")).await.unwrap().len(),
|
||||
1
|
||||
);
|
||||
assert!(matches!(
|
||||
st.systemd.unit_status("nope.service").await,
|
||||
Err(AppError::NotFound(_))
|
||||
));
|
||||
let q = JournalQuery {
|
||||
priority: Some(Priority::Err),
|
||||
..Default::default()
|
||||
};
|
||||
assert_eq!(st.journal.query(&q).await.unwrap().len(), 2);
|
||||
assert_eq!(st.docker.ps(false).await.unwrap().len(), 2);
|
||||
let mut rx = st
|
||||
.docker
|
||||
.follow_logs("web", &LogOptions::default())
|
||||
.await
|
||||
.unwrap();
|
||||
assert!(rx.recv().await.is_some());
|
||||
st.shutdown.cancel();
|
||||
while rx.recv().await.is_some() {}
|
||||
}
|
||||
+2
-129
@@ -281,132 +281,5 @@ impl JournalSource for SdJournal {
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn entry(sec: i64) -> JournalEntry {
|
||||
JournalEntry {
|
||||
timestamp: Timestamp::from_second(sec).unwrap(),
|
||||
priority: None,
|
||||
unit: None,
|
||||
identifier: None,
|
||||
pid: None,
|
||||
hostname: None,
|
||||
message: sec.to_string(),
|
||||
cursor: None,
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn plan_repeats_priority_in_each_unit_disjunct() {
|
||||
let q = JournalQuery {
|
||||
unit: Some("a.service".into()),
|
||||
priority: Some(Priority::Crit),
|
||||
..Default::default()
|
||||
};
|
||||
let plan = match_plan(&q);
|
||||
assert_eq!(plan.len(), 2);
|
||||
assert_eq!(plan[0][0], ("_SYSTEMD_UNIT".into(), "a.service".into()));
|
||||
assert_eq!(plan[1][0], ("UNIT".into(), "a.service".into()));
|
||||
for g in &plan {
|
||||
let p: Vec<_> = g.iter().filter(|(k, _)| k == "PRIORITY").collect();
|
||||
assert_eq!(p.len(), 3); // 0,1,2
|
||||
assert_eq!(p[2].1, "2");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn plan_without_unit_or_priority() {
|
||||
assert!(match_plan(&JournalQuery::default()).is_empty());
|
||||
let q = JournalQuery {
|
||||
priority: Some(Priority::Emerg),
|
||||
..Default::default()
|
||||
};
|
||||
assert_eq!(match_plan(&q), vec![vec![("PRIORITY".into(), "0".into())]]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn backlog_is_oldest_first_capped_and_since_filtered() {
|
||||
let mut src = vec![entry(5), entry(4), entry(3), entry(2), entry(1)].into_iter();
|
||||
let out = collect_backlog(|| Ok(src.next()), None, 3).unwrap();
|
||||
let t: Vec<_> = out.iter().map(|e| e.message.as_str()).collect();
|
||||
assert_eq!(t, ["3", "4", "5"]);
|
||||
|
||||
let mut src = vec![entry(5), entry(4), entry(3)].into_iter();
|
||||
let since = Timestamp::from_second(4).unwrap();
|
||||
let out = collect_backlog(|| Ok(src.next()), Some(since), 10).unwrap();
|
||||
assert_eq!(out.len(), 2);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn backlog_skips_unreadable_timestamps() {
|
||||
let mut bad = entry(0);
|
||||
bad.timestamp = Timestamp::UNIX_EPOCH;
|
||||
let mut src = vec![entry(3), bad, entry(1)].into_iter();
|
||||
let since = Timestamp::from_second(1).unwrap();
|
||||
let out = collect_backlog(|| Ok(src.next()), Some(since), 10).unwrap();
|
||||
assert_eq!(out.len(), 2);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn send_stops_when_receiver_dropped() {
|
||||
let (tx, rx) = mpsc::channel(1);
|
||||
let token = CancellationToken::new();
|
||||
assert!(send(&tx, &token, 1));
|
||||
let t = std::thread::spawn({
|
||||
let tx = tx.clone();
|
||||
let token = token.clone();
|
||||
move || send(&tx, &token, 2) // full: blocks until rx dropped
|
||||
});
|
||||
std::thread::sleep(Duration::from_millis(150));
|
||||
drop(rx);
|
||||
assert!(!t.join().unwrap());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn send_stops_on_cancel_while_full() {
|
||||
let (tx, _rx) = mpsc::channel(1);
|
||||
let token = CancellationToken::new();
|
||||
assert!(send(&tx, &token, 1));
|
||||
let t = std::thread::spawn({
|
||||
let token = token.clone();
|
||||
move || send(&tx, &token, 2)
|
||||
});
|
||||
std::thread::sleep(Duration::from_millis(150));
|
||||
token.cancel();
|
||||
assert!(!t.join().unwrap());
|
||||
}
|
||||
|
||||
// Live-journal tests: `cargo test -- --ignored live_`.
|
||||
#[tokio::test]
|
||||
#[ignore = "needs a readable journal: cargo test -- --ignored live_"]
|
||||
async fn live_follow_thread_exits_when_receiver_dropped() {
|
||||
let src = SdJournal::new(&Config::default(), CancellationToken::new());
|
||||
let q = JournalQuery {
|
||||
lines: Some(1),
|
||||
..Default::default()
|
||||
};
|
||||
let (rx, handle) = src.spawn_follow(&q).await.expect("journal must open");
|
||||
drop(rx);
|
||||
tokio::time::timeout(Duration::from_millis(1500), handle)
|
||||
.await
|
||||
.expect("follow thread did not exit")
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
#[ignore = "needs a readable journal: cargo test -- --ignored live_"]
|
||||
async fn live_follow_thread_exits_on_shutdown() {
|
||||
let token = CancellationToken::new();
|
||||
let src = SdJournal::new(&Config::default(), token.clone());
|
||||
let (_rx, handle) = src
|
||||
.spawn_follow(&JournalQuery::default())
|
||||
.await
|
||||
.expect("journal must open");
|
||||
token.cancel();
|
||||
tokio::time::timeout(Duration::from_millis(1500), handle)
|
||||
.await
|
||||
.expect("follow thread did not exit")
|
||||
.unwrap();
|
||||
}
|
||||
}
|
||||
#[path = "journal_tests.rs"]
|
||||
mod tests;
|
||||
@@ -0,0 +1,127 @@
|
||||
use super::*;
|
||||
|
||||
fn entry(sec: i64) -> JournalEntry {
|
||||
JournalEntry {
|
||||
timestamp: Timestamp::from_second(sec).unwrap(),
|
||||
priority: None,
|
||||
unit: None,
|
||||
identifier: None,
|
||||
pid: None,
|
||||
hostname: None,
|
||||
message: sec.to_string(),
|
||||
cursor: None,
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn plan_repeats_priority_in_each_unit_disjunct() {
|
||||
let q = JournalQuery {
|
||||
unit: Some("a.service".into()),
|
||||
priority: Some(Priority::Crit),
|
||||
..Default::default()
|
||||
};
|
||||
let plan = match_plan(&q);
|
||||
assert_eq!(plan.len(), 2);
|
||||
assert_eq!(plan[0][0], ("_SYSTEMD_UNIT".into(), "a.service".into()));
|
||||
assert_eq!(plan[1][0], ("UNIT".into(), "a.service".into()));
|
||||
for g in &plan {
|
||||
let p: Vec<_> = g.iter().filter(|(k, _)| k == "PRIORITY").collect();
|
||||
assert_eq!(p.len(), 3); // 0,1,2
|
||||
assert_eq!(p[2].1, "2");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn plan_without_unit_or_priority() {
|
||||
assert!(match_plan(&JournalQuery::default()).is_empty());
|
||||
let q = JournalQuery {
|
||||
priority: Some(Priority::Emerg),
|
||||
..Default::default()
|
||||
};
|
||||
assert_eq!(match_plan(&q), vec![vec![("PRIORITY".into(), "0".into())]]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn backlog_is_oldest_first_capped_and_since_filtered() {
|
||||
let mut src = vec![entry(5), entry(4), entry(3), entry(2), entry(1)].into_iter();
|
||||
let out = collect_backlog(|| Ok(src.next()), None, 3).unwrap();
|
||||
let t: Vec<_> = out.iter().map(|e| e.message.as_str()).collect();
|
||||
assert_eq!(t, ["3", "4", "5"]);
|
||||
|
||||
let mut src = vec![entry(5), entry(4), entry(3)].into_iter();
|
||||
let since = Timestamp::from_second(4).unwrap();
|
||||
let out = collect_backlog(|| Ok(src.next()), Some(since), 10).unwrap();
|
||||
assert_eq!(out.len(), 2);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn backlog_skips_unreadable_timestamps() {
|
||||
let mut bad = entry(0);
|
||||
bad.timestamp = Timestamp::UNIX_EPOCH;
|
||||
let mut src = vec![entry(3), bad, entry(1)].into_iter();
|
||||
let since = Timestamp::from_second(1).unwrap();
|
||||
let out = collect_backlog(|| Ok(src.next()), Some(since), 10).unwrap();
|
||||
assert_eq!(out.len(), 2);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn send_stops_when_receiver_dropped() {
|
||||
let (tx, rx) = mpsc::channel(1);
|
||||
let token = CancellationToken::new();
|
||||
assert!(send(&tx, &token, 1));
|
||||
let t = std::thread::spawn({
|
||||
let tx = tx.clone();
|
||||
let token = token.clone();
|
||||
move || send(&tx, &token, 2) // full: blocks until rx dropped
|
||||
});
|
||||
std::thread::sleep(Duration::from_millis(150));
|
||||
drop(rx);
|
||||
assert!(!t.join().unwrap());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn send_stops_on_cancel_while_full() {
|
||||
let (tx, _rx) = mpsc::channel(1);
|
||||
let token = CancellationToken::new();
|
||||
assert!(send(&tx, &token, 1));
|
||||
let t = std::thread::spawn({
|
||||
let token = token.clone();
|
||||
move || send(&tx, &token, 2)
|
||||
});
|
||||
std::thread::sleep(Duration::from_millis(150));
|
||||
token.cancel();
|
||||
assert!(!t.join().unwrap());
|
||||
}
|
||||
|
||||
// Live-journal tests: `cargo test -- --ignored live_`.
|
||||
#[tokio::test]
|
||||
#[ignore = "needs a readable journal: cargo test -- --ignored live_"]
|
||||
async fn live_follow_thread_exits_when_receiver_dropped() {
|
||||
let src = SdJournal::new(&Config::default(), CancellationToken::new());
|
||||
let q = JournalQuery {
|
||||
lines: Some(1),
|
||||
..Default::default()
|
||||
};
|
||||
let (rx, handle) = src.spawn_follow(&q).await.expect("journal must open");
|
||||
drop(rx);
|
||||
tokio::time::timeout(Duration::from_millis(1500), handle)
|
||||
.await
|
||||
.expect("follow thread did not exit")
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
#[ignore = "needs a readable journal: cargo test -- --ignored live_"]
|
||||
async fn live_follow_thread_exits_on_shutdown() {
|
||||
let token = CancellationToken::new();
|
||||
let src = SdJournal::new(&Config::default(), token.clone());
|
||||
let (_rx, handle) = src
|
||||
.spawn_follow(&JournalQuery::default())
|
||||
.await
|
||||
.expect("journal must open");
|
||||
token.cancel();
|
||||
tokio::time::timeout(Duration::from_millis(1500), handle)
|
||||
.await
|
||||
.expect("follow thread did not exit")
|
||||
.unwrap();
|
||||
}
|
||||
+2
-46
@@ -326,49 +326,5 @@ pub fn clamp_count(requested: Option<usize>, cap: usize) -> usize {
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn priority_parse() {
|
||||
assert_eq!("err".parse::<Priority>().unwrap(), Priority::Err);
|
||||
assert_eq!("3".parse::<Priority>().unwrap(), Priority::Err);
|
||||
assert_eq!("WARN".parse::<Priority>().unwrap(), Priority::Warning);
|
||||
assert!("8".parse::<Priority>().is_err());
|
||||
assert!("loud".parse::<Priority>().is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn priority_serde() {
|
||||
assert_eq!(serde_json::to_string(&Priority::Crit).unwrap(), "\"crit\"");
|
||||
assert_eq!(
|
||||
serde_json::from_str::<Priority>("4").unwrap(),
|
||||
Priority::Warning
|
||||
);
|
||||
assert_eq!(
|
||||
serde_json::from_str::<Priority>("\"info\"").unwrap(),
|
||||
Priority::Info
|
||||
);
|
||||
assert!(serde_json::from_str::<Priority>("9").is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn timestamps_are_rfc3339() {
|
||||
let ts: Timestamp = "2026-10-15T12:00:00Z".parse().unwrap();
|
||||
let line = LogLine {
|
||||
stream: LogStream::Stderr,
|
||||
ts: Some(ts),
|
||||
message: "x".into(),
|
||||
};
|
||||
let v = serde_json::to_value(&line).unwrap();
|
||||
assert_eq!(v["ts"], "2026-10-15T12:00:00Z");
|
||||
assert_eq!(v["stream"], "stderr");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn clamp() {
|
||||
assert_eq!(clamp_count(None, 1000), 100);
|
||||
assert_eq!(clamp_count(Some(5000), 1000), 1000);
|
||||
assert_eq!(clamp_count(None, 50), 50);
|
||||
}
|
||||
}
|
||||
#[path = "mod_tests.rs"]
|
||||
mod tests;
|
||||
@@ -0,0 +1,44 @@
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn priority_parse() {
|
||||
assert_eq!("err".parse::<Priority>().unwrap(), Priority::Err);
|
||||
assert_eq!("3".parse::<Priority>().unwrap(), Priority::Err);
|
||||
assert_eq!("WARN".parse::<Priority>().unwrap(), Priority::Warning);
|
||||
assert!("8".parse::<Priority>().is_err());
|
||||
assert!("loud".parse::<Priority>().is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn priority_serde() {
|
||||
assert_eq!(serde_json::to_string(&Priority::Crit).unwrap(), "\"crit\"");
|
||||
assert_eq!(
|
||||
serde_json::from_str::<Priority>("4").unwrap(),
|
||||
Priority::Warning
|
||||
);
|
||||
assert_eq!(
|
||||
serde_json::from_str::<Priority>("\"info\"").unwrap(),
|
||||
Priority::Info
|
||||
);
|
||||
assert!(serde_json::from_str::<Priority>("9").is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn timestamps_are_rfc3339() {
|
||||
let ts: Timestamp = "2026-10-15T12:00:00Z".parse().unwrap();
|
||||
let line = LogLine {
|
||||
stream: LogStream::Stderr,
|
||||
ts: Some(ts),
|
||||
message: "x".into(),
|
||||
};
|
||||
let v = serde_json::to_value(&line).unwrap();
|
||||
assert_eq!(v["ts"], "2026-10-15T12:00:00Z");
|
||||
assert_eq!(v["stream"], "stderr");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn clamp() {
|
||||
assert_eq!(clamp_count(None, 1000), 100);
|
||||
assert_eq!(clamp_count(Some(5000), 1000), 1000);
|
||||
assert_eq!(clamp_count(None, 50), 50);
|
||||
}
|
||||
+2
-64
@@ -361,67 +361,5 @@ impl SystemdSource for DbusSystemd {
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn usec_conversion() {
|
||||
let ts = usec_to_ts(1_700_000_000_123_456).unwrap();
|
||||
assert_eq!(ts.to_string(), "2023-11-14T22:13:20.123456Z");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn usec_sentinels() {
|
||||
assert!(usec_to_ts(0).is_none());
|
||||
assert!(usec_to_ts(u64::MAX).is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn tuple_mapping() {
|
||||
let p = OwnedObjectPath::try_from("/org/freedesktop/systemd1/unit/a_2eservice").unwrap();
|
||||
let row: UnitRow = (
|
||||
"a.service".into(),
|
||||
"A".into(),
|
||||
"loaded".into(),
|
||||
"active".into(),
|
||||
"running".into(),
|
||||
String::new(),
|
||||
p.clone(),
|
||||
0,
|
||||
String::new(),
|
||||
p,
|
||||
);
|
||||
let s = row_to_summary(row);
|
||||
assert_eq!(s.name, "a.service");
|
||||
assert_eq!(s.description, "A");
|
||||
assert_eq!(s.load_state, "loaded");
|
||||
assert_eq!(s.active_state, "active");
|
||||
assert_eq!(s.sub_state, "running");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn name_validation() {
|
||||
assert!(validate_unit_name("sshd.service").is_ok());
|
||||
assert!(validate_unit_name("getty@tty1.service").is_ok());
|
||||
assert!(validate_unit_name("dev-disk-by\\x2did.device").is_ok());
|
||||
assert!(validate_unit_name("a.timer").is_ok());
|
||||
for bad in ["", "..", "../etc", "foo", "a.b", ".service", "x/y.service"] {
|
||||
assert!(
|
||||
matches!(validate_unit_name(bad), Err(AppError::BadRequest(_))),
|
||||
"{bad}"
|
||||
);
|
||||
}
|
||||
assert!(validate_unit_name(&format!("{}.service", "a".repeat(250))).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn state_validation() {
|
||||
assert!(validate_state("failed").is_ok());
|
||||
assert!(validate_state("running").is_ok());
|
||||
assert!(matches!(
|
||||
validate_state("Failed"),
|
||||
Err(AppError::BadRequest(_))
|
||||
));
|
||||
assert!(validate_state("bogus").is_err());
|
||||
}
|
||||
}
|
||||
#[path = "systemd_tests.rs"]
|
||||
mod tests;
|
||||
@@ -0,0 +1,62 @@
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn usec_conversion() {
|
||||
let ts = usec_to_ts(1_700_000_000_123_456).unwrap();
|
||||
assert_eq!(ts.to_string(), "2023-11-14T22:13:20.123456Z");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn usec_sentinels() {
|
||||
assert!(usec_to_ts(0).is_none());
|
||||
assert!(usec_to_ts(u64::MAX).is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn tuple_mapping() {
|
||||
let p = OwnedObjectPath::try_from("/org/freedesktop/systemd1/unit/a_2eservice").unwrap();
|
||||
let row: UnitRow = (
|
||||
"a.service".into(),
|
||||
"A".into(),
|
||||
"loaded".into(),
|
||||
"active".into(),
|
||||
"running".into(),
|
||||
String::new(),
|
||||
p.clone(),
|
||||
0,
|
||||
String::new(),
|
||||
p,
|
||||
);
|
||||
let s = row_to_summary(row);
|
||||
assert_eq!(s.name, "a.service");
|
||||
assert_eq!(s.description, "A");
|
||||
assert_eq!(s.load_state, "loaded");
|
||||
assert_eq!(s.active_state, "active");
|
||||
assert_eq!(s.sub_state, "running");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn name_validation() {
|
||||
assert!(validate_unit_name("sshd.service").is_ok());
|
||||
assert!(validate_unit_name("getty@tty1.service").is_ok());
|
||||
assert!(validate_unit_name("dev-disk-by\\x2did.device").is_ok());
|
||||
assert!(validate_unit_name("a.timer").is_ok());
|
||||
for bad in ["", "..", "../etc", "foo", "a.b", ".service", "x/y.service"] {
|
||||
assert!(
|
||||
matches!(validate_unit_name(bad), Err(AppError::BadRequest(_))),
|
||||
"{bad}"
|
||||
);
|
||||
}
|
||||
assert!(validate_unit_name(&format!("{}.service", "a".repeat(250))).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn state_validation() {
|
||||
assert!(validate_state("failed").is_ok());
|
||||
assert!(validate_state("running").is_ok());
|
||||
assert!(matches!(
|
||||
validate_state("Failed"),
|
||||
Err(AppError::BadRequest(_))
|
||||
));
|
||||
assert!(validate_state("bogus").is_err());
|
||||
}
|
||||
Reference in new issue
Block a user