copia 0.1.3

Pure Rust rsync-style delta synchronization library
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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

//! Error types for copia operations.

use thiserror::Error;

/// Errors that can occur during copia operations.
#[derive(Error, Debug)]
pub enum CopiaError {
    /// I/O error during read/write operations.
    #[error("I/O error: {0}")]
    Io(#[from] std::io::Error),

    /// Invalid block size specified.
    #[error("Invalid block size: {0} (must be power of 2, 512-65536)")]
    InvalidBlockSize(usize),

    /// Invalid strong hash length specified.
    #[error("Invalid hash length: {0} (must be 4-32)")]
    InvalidHashLength(usize),

    /// Delta contains invalid copy bounds.
    #[error("Invalid copy bounds: offset {offset} + len {len} exceeds basis size {basis_size}")]
    InvalidCopyBounds {
        /// Copy offset in basis file
        offset: u64,
        /// Copy length
        len: u32,
        /// Total basis file size
        basis_size: u64,
    },

    /// Checksum mismatch after patch application.
    #[error("Checksum mismatch: expected {expected:?}, got {actual:?}")]
    ChecksumMismatch {
        /// Expected checksum
        expected: [u8; 32],
        /// Actual computed checksum
        actual: [u8; 32],
    },

    /// Empty signature provided.
    #[error("Empty signature: cannot compute delta without signatures")]
    EmptySignature,

    /// Delta application failed due to corrupted data.
    #[error("Corrupted delta data")]
    CorruptedDelta,

    /// Protocol error during network operations.
    #[error("Protocol error: {0}")]
    ProtocolError(String),
}

/// Result type for copia operations.
pub type Result<T> = std::result::Result<T, CopiaError>;

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

    #[test]
    fn error_display_io() {
        let io_err = std::io::Error::new(std::io::ErrorKind::NotFound, "file not found");
        let err = CopiaError::Io(io_err);
        assert!(err.to_string().contains("I/O error"));
    }

    #[test]
    fn error_display_invalid_block_size() {
        let err = CopiaError::InvalidBlockSize(100);
        assert!(err.to_string().contains("Invalid block size: 100"));
    }

    #[test]
    fn error_display_invalid_hash_length() {
        let err = CopiaError::InvalidHashLength(2);
        assert!(err.to_string().contains("Invalid hash length: 2"));
    }

    #[test]
    fn error_display_invalid_copy_bounds() {
        let err = CopiaError::InvalidCopyBounds {
            offset: 1000,
            len: 500,
            basis_size: 1200,
        };
        let msg = err.to_string();
        assert!(msg.contains("offset 1000"));
        assert!(msg.contains("len 500"));
        assert!(msg.contains("basis size 1200"));
    }

    #[test]
    fn error_display_checksum_mismatch() {
        let err = CopiaError::ChecksumMismatch {
            expected: [1u8; 32],
            actual: [2u8; 32],
        };
        assert!(err.to_string().contains("Checksum mismatch"));
    }

    #[test]
    fn error_display_empty_signature() {
        let err = CopiaError::EmptySignature;
        assert!(err.to_string().contains("Empty signature"));
    }

    #[test]
    fn error_display_corrupted_delta() {
        let err = CopiaError::CorruptedDelta;
        assert!(err.to_string().contains("Corrupted delta"));
    }

    #[test]
    fn error_display_protocol_error() {
        let err = CopiaError::ProtocolError("invalid frame".to_string());
        assert!(err.to_string().contains("Protocol error"));
        assert!(err.to_string().contains("invalid frame"));
    }

    #[test]
    fn result_type_ok() {
        let result: Result<i32> = Ok(42);
        assert_eq!(result.unwrap_or(0), 42);
    }

    #[test]
    fn result_type_err() {
        let result: Result<i32> = Err(CopiaError::EmptySignature);
        assert!(result.is_err());
    }
}