1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

use crate::TemplatingError;
use quaint::error::Error as QuaintError;
use std::env::VarError;
use thiserror::Error;

#[allow(clippy::large_enum_variant)]
#[derive(Debug, Error)]
pub enum TestError {
    #[error("Handler Error: {0}")]
    RequestHandlerError(request_handlers::HandlerError),

    #[error("Parse error: {0}")]
    ParseError(String),

    #[error("Configuration error: {0}")]
    ConfigError(String),

    #[error("Query core error: {0}")]
    QueryCoreError(#[from] query_core::CoreError),

    #[error("Migration core error: {0}")]
    MigrationCoreError(#[from] qe_setup::ConnectorError),

    #[error("Error processing schema template: {0}")]
    TemplatingError(#[from] TemplatingError),

    #[error("Error during interactive transaction processing: {}", _0)]
    InteractiveTransactionError(String),

    #[error("Raw execute error: {0}")]
    RawExecute(QuaintError),

    #[error("External process error: {0}")]
    External(#[from] Box<dyn std::error::Error + Send + Sync>),
}

impl TestError {
    pub fn parse_error<T>(reason: T) -> Self
    where
        T: Into<String>,
    {
        Self::ParseError(reason.into())
    }

    pub fn config_error<T>(reason: T) -> Self
    where
        T: Into<String>,
    {
        Self::ConfigError(reason.into())
    }
}

impl From<VarError> for TestError {
    fn from(err: VarError) -> Self {
        Self::ConfigError(err.to_string())
    }
}

impl From<QuaintError> for TestError {
    fn from(err: QuaintError) -> Self {
        Self::RawExecute(err)
    }
}