passivized_docker_engine_client 0.0.10-alpha

Docker Engine Client - manage and run containers, images, and volumes.
Documentation 
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 std::fmt::{Display, Formatter};
use crate::errors::{DecCreateError, DecUseError};

/// Aggregator for converging creation and usage errors into a single,
/// convenient error type.
///
/// Defines automatic Into conversions for each of its inner failure cases.
///
/// Use of this type is not required, but may be convenient for call sites
/// that both create a DockerEngineClient and use it.
#[derive(Debug, thiserror::Error)]
pub enum DecError {
    DuringCreation(DecCreateError),
    DuringUse(DecUseError)
}

impl From<DecCreateError> for DecError {
    fn from(other: DecCreateError) -> Self {
        DecError::DuringCreation(other)
    }
}

impl From<DecUseError> for DecError {
    fn from(other: DecUseError) -> Self {
        DecError::DuringUse(other)
    }
}

impl Display for DecError {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self {
            DecError::DuringCreation(inner) =>
                write!(f, "{}", inner),
            DecError::DuringUse(inner) =>
                write!(f, "{}", inner),
        }
    }
}

#[cfg(test)]
mod test_dec_error_display {
    use crate::errors::{DecCreateError, DecError, DecUseError};

    #[test]
    fn during_creation() {
        let creation_error = DecCreateError::UnsupportedUrlScheme;
        let expected = format!("{}", creation_error);

        let error = DecError::from(creation_error);

        assert_eq!(expected, format!("{}", error))
    }

    #[test]
    fn during_use() {
        let use_error = DecUseError::NotFound { message: "where is it".into() };
        let expected = format!("{}", use_error);

        let error = DecError::from(use_error);

        assert_eq!(expected, format!("{}", error))
    }
}