use crate::error::{Failure, Result};
use std::io::Write;
pub fn write_line<W: Write>(writer: &mut W, value: &impl serde::Serialize) -> Result<()> {
let text = serde_json::to_string(value).map_err(|error| {
Failure::new(
crate::error::Category::Server,
"output.not_serialisable",
"the answer could not be serialised",
)
.with_cause(error.to_string())
})?;
writeln!(writer, "{text}").map_err(|error| classify_write(&error))
}
fn classify_write(error: &std::io::Error) -> Failure {
crate::output::format::classify(error)
}
#[cfg(test)]
pub(crate) fn classify_for_proof(error: &std::io::Error) -> Failure {
classify_write(error)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::output::Envelope;
use serde_json::json;
#[test]
fn an_envelope_writes_as_one_newline_terminated_line() {
let envelope = Envelope::new("meta version", json!({"version": "0.1.0"}));
let mut buffer = Vec::new();
write_line(&mut buffer, &envelope).expect("writes");
let text = String::from_utf8(buffer).expect("utf8");
assert_eq!(text.matches('\n').count(), 1);
assert!(text.ends_with('\n'));
}
#[test]
fn a_closed_reader_carries_its_own_category_and_number() {
struct ClosedReader;
impl Write for ClosedReader {
fn write(&mut self, _: &[u8]) -> std::io::Result<usize> {
Err(std::io::Error::new(
std::io::ErrorKind::BrokenPipe,
"closed",
))
}
fn flush(&mut self) -> std::io::Result<()> {
Ok(())
}
}
let envelope = Envelope::new("query run", json!({"rows": []}));
let failure = write_line(&mut ClosedReader, &envelope).expect_err("must fail");
assert_eq!(failure.code(), "output.broken_pipe");
assert_eq!(failure.category(), crate::error::Category::ChannelClosed);
assert_ne!(failure.category(), crate::error::Category::Limit);
assert_eq!(failure.exit_number().code(), 141);
}
}