use error_stack::Report;
use crate::kind::ErrorKind;
pub type ErrorReport<C> = Report<C>;
pub type Error = ErrorReport<ErrorKind>;
pub type Result<T, C = ErrorKind> = core::result::Result<T, ErrorReport<C>>;
pub type TypedResult<T, C> = Result<T, C>;
pub type RawResult<T, E> = core::result::Result<T, E>;
#[cfg(test)]
mod tests {
use super::{Error, ErrorKind, ErrorReport, RawResult, Result, TypedResult};
use error_stack::Report;
use thiserror::Error;
#[derive(Debug, Error)]
#[error("local test context")]
struct LocalContext;
#[derive(Debug, Error, Clone, PartialEq, Eq)]
#[error("local raw error")]
struct LocalRawError;
fn assert_send_sync<T: Send + Sync>() {}
#[test]
fn test_default_result_uses_public_error_kind() {
let report = Report::new(ErrorKind::Internal);
let value: Result<()> = Err(report);
let error = value.expect_err("expected report");
assert_eq!(error.current_context(), &ErrorKind::Internal);
}
#[test]
fn test_typed_result_uses_custom_context_type() {
let report = Report::new(LocalContext);
let value: TypedResult<(), LocalContext> = Err(report);
let error = value.expect_err("expected typed report");
assert_eq!(error.current_context().to_string(), "local test context");
}
#[test]
fn test_error_alias_equals_report_of_error_kind() {
let error: Error = Report::new(ErrorKind::Dependency);
let typed: ErrorReport<ErrorKind> = error;
assert_eq!(typed.current_context(), &ErrorKind::Dependency);
}
#[test]
fn test_raw_result_preserves_std_result_behavior() {
let value: RawResult<u32, LocalRawError> = Err(LocalRawError);
let cloned = value.clone();
assert_eq!(value, cloned);
assert_eq!(value.expect_err("expected raw error"), LocalRawError);
}
#[test]
fn test_public_error_is_send_and_sync() {
assert_send_sync::<Error>();
assert_send_sync::<ErrorReport<ErrorKind>>();
}
#[test]
fn test_result_alias_keeps_report_debug_and_display_support() {
let error: Error = Report::new(ErrorKind::Timeout);
let display = format!("{error}");
let alternate = format!("{error:#}");
let debug = format!("{error:?}");
assert_eq!(display, "timeout");
assert!(alternate.contains("timeout"));
assert!(debug.contains("timeout"));
}
}