ic-dbms-api 0.7.0

Public API types for ic-dbms-canister. This crate provides shared types for interacting and implementing the ic-dbms-canister.
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

/// IC DBMS error type (backward-compatible alias for [`wasm_dbms_api::error::DbmsError`]).
pub type IcDbmsError = wasm_dbms_api::error::DbmsError;

/// IC DBMS result type (backward-compatible alias for [`wasm_dbms_api::error::DbmsResult`]).
pub type IcDbmsResult<T> = wasm_dbms_api::error::DbmsResult<T>;

#[cfg(test)]
mod test {

    use wasm_dbms_api::prelude::{MemoryError, QueryError, TableError, TransactionError};

    use super::*;

    #[test]
    fn test_should_display_memory_error() {
        let error = IcDbmsError::Memory(MemoryError::OutOfBounds);
        assert_eq!(
            error.to_string(),
            "Memory error: Stable memory access out of bounds"
        );
    }

    #[test]
    fn test_should_display_query_error() {
        let error = IcDbmsError::Query(QueryError::UnknownColumn("foo".to_string()));
        assert_eq!(error.to_string(), "Query error: Unknown column: foo");
    }

    #[test]
    fn test_should_display_sanitize_error() {
        let error = IcDbmsError::Sanitize("invalid input".to_string());
        assert_eq!(error.to_string(), "Sanitize error: invalid input");
    }

    #[test]
    fn test_should_display_table_error() {
        let error = IcDbmsError::Table(TableError::TableNotFound);
        assert_eq!(error.to_string(), "Table error: Table not found");
    }

    #[test]
    fn test_should_display_transaction_error() {
        let error = IcDbmsError::Transaction(TransactionError::NoActiveTransaction);
        assert_eq!(
            error.to_string(),
            "Transaction error: No active transaction"
        );
    }

    #[test]
    fn test_should_display_validation_error() {
        let error = IcDbmsError::Validation("invalid email".to_string());
        assert_eq!(error.to_string(), "Validation error: invalid email");
    }

    #[test]
    fn test_should_convert_from_memory_error() {
        let error: IcDbmsError = MemoryError::OutOfBounds.into();
        assert!(matches!(
            error,
            IcDbmsError::Memory(MemoryError::OutOfBounds)
        ));
    }

    #[test]
    fn test_should_convert_from_query_error() {
        let error: IcDbmsError = QueryError::UnknownColumn("col".to_string()).into();
        assert!(matches!(error, IcDbmsError::Query(_)));
    }

    #[test]
    fn test_should_convert_from_table_error() {
        let error: IcDbmsError = TableError::TableNotFound.into();
        assert!(matches!(error, IcDbmsError::Table(_)));
    }

    #[test]
    fn test_should_convert_from_transaction_error() {
        let error: IcDbmsError = TransactionError::NoActiveTransaction.into();
        assert!(matches!(error, IcDbmsError::Transaction(_)));
    }
}