iwcore 0.1.25

IntelliWallet Core - Password manager library with AES-256 encryption
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

//! Error types for IntelliWallet Core

use thiserror::Error;

/// Main error type for wallet operations
#[derive(Error, Debug)]
pub enum WalletError {
    /// Database file not found at the specified path
    #[error("Database not found: {0}")]
    DatabaseNotFound(String),

    /// Invalid password provided
    #[error("Invalid password")]
    InvalidPassword,

    /// Wallet is locked, unlock required before operation
    #[error("Wallet is locked")]
    Locked,

    /// Encryption or decryption failed
    #[error("Encryption error: {0}")]
    EncryptionError(String),

    /// Decryption failed - data may be corrupted
    #[error("Decryption error: {0}")]
    DecryptionError(String),

    /// Database operation failed
    #[error("Database error: {0}")]
    DatabaseError(String),

    /// Backup operation failed
    #[error("Backup error: {0}")]
    BackupError(String),

    /// Item not found
    #[error("Item not found: {0}")]
    ItemNotFound(String),

    /// Field not found
    #[error("Field not found: {0}")]
    FieldNotFound(String),

    /// Label not found
    #[error("Label not found: {0}")]
    LabelNotFound(String),

    /// Invalid database version
    #[error("Invalid database version: {0}")]
    InvalidVersion(String),

    /// IO error
    #[error("IO error: {0}")]
    IoError(#[from] std::io::Error),

    /// Invalid operation
    #[error("Invalid operation: {0}")]
    InvalidOperation(String),

    /// Localization error
    #[error("Localization error: {0}")]
    LocalizationError(String),

    /// Export error
    #[error("Export error: {0}")]
    ExportError(String),
}

impl From<rusqlite::Error> for WalletError {
    fn from(err: rusqlite::Error) -> Self {
        WalletError::DatabaseError(err.to_string())
    }
}

impl From<zip::result::ZipError> for WalletError {
    fn from(err: zip::result::ZipError) -> Self {
        WalletError::BackupError(err.to_string())
    }
}

/// Result type alias for wallet operations
pub type Result<T> = std::result::Result<T, WalletError>;

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

    #[test]
    fn test_error_display() {
        let err = WalletError::DatabaseNotFound("/path/to/db".to_string());
        assert!(err.to_string().contains("/path/to/db"));

        let err = WalletError::InvalidPassword;
        assert_eq!(err.to_string(), "Invalid password");

        let err = WalletError::Locked;
        assert_eq!(err.to_string(), "Wallet is locked");

        let err = WalletError::EncryptionError("test error".to_string());
        assert!(err.to_string().contains("test error"));

        let err = WalletError::ItemNotFound("item123".to_string());
        assert!(err.to_string().contains("item123"));

        let err = WalletError::InvalidVersion("999".to_string());
        assert!(err.to_string().contains("999"));
    }

    #[test]
    fn test_error_from_rusqlite() {
        let sqlite_err = rusqlite::Error::QueryReturnedNoRows;
        let wallet_err: WalletError = sqlite_err.into();
        match wallet_err {
            WalletError::DatabaseError(msg) => assert!(!msg.is_empty()),
            _ => panic!("Expected DatabaseError"),
        }
    }

    #[test]
    fn test_error_from_zip() {
        let zip_err = zip::result::ZipError::FileNotFound;
        let wallet_err: WalletError = zip_err.into();
        match wallet_err {
            WalletError::BackupError(msg) => assert!(!msg.is_empty()),
            _ => panic!("Expected BackupError"),
        }
    }
}