auths-infra-git 0.0.1-rc.10

Git client adapter for Auths - enables communication with Auths services over Git
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
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

use auths_core::ports::storage::StorageError;
use git2::{Error as Git2Error, ErrorClass, ErrorCode};

pub(crate) fn map_git2_error(err: Git2Error) -> StorageError {
    match err.class() {
        ErrorClass::Reference => map_reference_error(err),
        ErrorClass::Object | ErrorClass::Odb => map_object_error(err),
        ErrorClass::Os | ErrorClass::Repository => map_io_error(err),
        _ => map_by_code(err),
    }
}

pub(crate) fn map_reference_error(err: Git2Error) -> StorageError {
    if err.code() == ErrorCode::NotFound {
        StorageError::NotFound {
            path: extract_path_hint(&err),
        }
    } else {
        StorageError::Io(err.to_string())
    }
}

pub(crate) fn map_object_error(err: Git2Error) -> StorageError {
    if err.code() == ErrorCode::NotFound {
        StorageError::NotFound {
            path: extract_path_hint(&err),
        }
    } else {
        StorageError::Io(err.to_string())
    }
}

pub(crate) fn map_io_error(err: Git2Error) -> StorageError {
    if err.code() == ErrorCode::NotFound {
        StorageError::NotFound {
            path: extract_path_hint(&err),
        }
    } else if err.code() == ErrorCode::Exists {
        StorageError::AlreadyExists {
            path: extract_path_hint(&err),
        }
    } else {
        StorageError::Io(err.to_string())
    }
}

fn map_by_code(err: Git2Error) -> StorageError {
    match err.code() {
        ErrorCode::NotFound => StorageError::NotFound {
            path: extract_path_hint(&err),
        },
        ErrorCode::Exists => StorageError::AlreadyExists {
            path: extract_path_hint(&err),
        },
        _ => StorageError::Io(err.to_string()),
    }
}

fn extract_path_hint(err: &Git2Error) -> String {
    err.message().to_string()
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn map_reference_error_non_not_found_becomes_io() {
        let git_err = Git2Error::from_str("ref error");
        let result = map_reference_error(git_err);
        assert!(matches!(result, StorageError::Io(_)));
    }

    #[test]
    fn map_object_error_non_not_found_becomes_io() {
        let git_err = Git2Error::from_str("object error");
        let result = map_object_error(git_err);
        assert!(matches!(result, StorageError::Io(_)));
    }

    #[test]
    fn map_io_error_generic() {
        let git_err = Git2Error::from_str("disk full");
        let result = map_io_error(git_err);
        assert!(matches!(result, StorageError::Io(_)));
    }

    #[test]
    fn map_git2_error_generic() {
        let git_err = Git2Error::from_str("something went wrong");
        let storage_err = map_git2_error(git_err);
        assert!(matches!(storage_err, StorageError::Io(_)));
    }

    #[test]
    fn map_by_code_generic_becomes_io() {
        let git_err = Git2Error::from_str("unknown");
        let result = map_by_code(git_err);
        assert!(matches!(result, StorageError::Io(_)));
    }

    #[test]
    fn not_found_tested_via_real_repo() {
        let dir = tempfile::TempDir::new().unwrap();
        let repo = git2::Repository::init(dir.path()).unwrap();
        let err = repo
            .find_reference("refs/nonexistent")
            .err()
            .expect("should fail for nonexistent ref");
        let result = map_git2_error(err);
        assert!(matches!(result, StorageError::NotFound { .. }));
    }
}