136 lines
3.2 KiB
Rust
136 lines
3.2 KiB
Rust
use std::{error::Error, fmt};
|
|
|
|
#[derive(Clone, Debug)]
|
|
pub enum ErrorCode {
|
|
// General
|
|
Undefined(String),
|
|
// Cache
|
|
IDNotFound(String),
|
|
// Store
|
|
DuplicateDatabase(String),
|
|
// Database
|
|
DuplicateTable(String),
|
|
}
|
|
|
|
impl fmt::Display for ErrorCode {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
match self {
|
|
ErrorCode::Undefined(msg) => write!(f, "{}", msg),
|
|
ErrorCode::IDNotFound(id) => write!(f, "ID '{}' not found", id),
|
|
ErrorCode::DuplicateDatabase(name) => write!(f, "database '{}' already exists", name),
|
|
ErrorCode::DuplicateTable(name) => write!(f, "table '{}' already exists", name),
|
|
}
|
|
}
|
|
}
|
|
|
|
mod errorcodes {
|
|
use super::*;
|
|
|
|
const ITEMS: [&str; 2] = ["one", "two"];
|
|
|
|
#[test]
|
|
fn undefined_display() {
|
|
for item in ITEMS {
|
|
let err = ErrorCode::Undefined(item.to_string());
|
|
assert_eq!(err.to_string(), item);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn cache_missing() {
|
|
for item in ITEMS {
|
|
let err = ErrorCode::IDNotFound(item.to_string());
|
|
assert_eq!(err.to_string(), format!("ID '{}' not found", item));
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn duplicate_database() {
|
|
for item in ITEMS {
|
|
let err = ErrorCode::DuplicateDatabase(item.to_string());
|
|
assert_eq!(
|
|
err.to_string(),
|
|
format!("database '{}' already exists", item)
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn duplicate_table() {
|
|
for item in ITEMS {
|
|
let err = ErrorCode::DuplicateTable(item.to_string());
|
|
assert_eq!(err.to_string(), format!("table '{}' already exists", item));
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Debug)]
|
|
pub struct MTTError {
|
|
pub code: ErrorCode,
|
|
}
|
|
|
|
impl MTTError {
|
|
pub fn new<S>(msg: S) -> Self
|
|
where
|
|
S: Into<String>,
|
|
{
|
|
let text = msg.into();
|
|
Self {
|
|
code: ErrorCode::Undefined(text),
|
|
}
|
|
}
|
|
|
|
pub fn from_code(code: ErrorCode) -> Self {
|
|
Self { code: code }
|
|
}
|
|
}
|
|
|
|
impl Error for MTTError {}
|
|
|
|
impl fmt::Display for MTTError {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
write!(f, "{}", self.code)
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod errors {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn create_with_str() {
|
|
let msgs = ["one", "two"];
|
|
for msg in msgs {
|
|
let err = MTTError::new(msg);
|
|
assert_eq!(err.to_string(), msg);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn create_with_string() {
|
|
let msg = "three";
|
|
let err = MTTError::new(msg.to_string());
|
|
assert_eq!(err.to_string(), msg);
|
|
}
|
|
|
|
#[test]
|
|
fn create_from_code() {
|
|
let code = ErrorCode::Undefined("oops".to_string());
|
|
let err = MTTError::from_code(code);
|
|
match err.code {
|
|
ErrorCode::Undefined(_) => (),
|
|
_ => assert!(false, "{:?} is not undefined", err.code),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn create_missing_id_from_code() {
|
|
let code = ErrorCode::IDNotFound("123".to_string());
|
|
let err = MTTError::from_code(code);
|
|
match err.code {
|
|
ErrorCode::IDNotFound(_) => (),
|
|
_ => assert!(false, "{:?} is not undefined", err.code),
|
|
}
|
|
}
|
|
}
|