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

//! Contains the macro `cred_store_test_cases` which expands to a collection of test cases for
//! a credential store implementation.

/// Expands to a set of test cases for a credential store implementation.
///
/// This macro accepts a single argument which is an expression which creates a new instance of the
/// credential store being tested.
#[macro_export]
macro_rules! cred_store_test_cases {
    ($ctor:expr) => {
        use btlib::{
            crypto::{Creds, CredsPriv, Error},
            Epoch, Principaled,
        };
        use btserde::to_vec;
        use std::time::Duration;

        #[test]
        fn create_new() {
            let _ = $ctor;
        }

        #[test]
        fn node_creds() {
            let case = $ctor;

            let result = case.node_creds();

            assert!(result.is_ok());
        }

        #[test]
        fn root_creds_returns_same_as_gen_root_creds() {
            const PASSWORD: &str = "MaximalIrony";
            let case = $ctor;

            let expected = case.gen_root_creds(PASSWORD).unwrap();
            let actual = case.root_creds(PASSWORD).unwrap();

            assert!(std::ptr::eq(expected.as_ref(), actual.as_ref()));
        }

        #[test]
        fn root_creds_wrong_password_is_error() {
            let case = $ctor;

            case.gen_root_creds("right").unwrap();
            let result = case.root_creds("wrong");

            let passed = if let Some(err) = result.err() {
                if let Some(Error::WrongRootPassword) = err.downcast_ref::<Error>() {
                    true
                } else {
                    false
                }
            } else {
                false
            };
            assert!(passed);
        }

        #[test]
        fn storage_key() {
            let case = $ctor;

            let result = case.storage_key();

            assert!(result.is_ok());
        }

        #[test]
        fn export_import_root_creds() {
            const SRC_PASSWORD: &str = "FALLING_MAN";
            const DST_PASSWORD: &str = "RUNNING_MAN";
            let src = $ctor;
            let dst = $ctor;

            let expected = src.gen_root_creds(SRC_PASSWORD).unwrap();
            let previous = dst.gen_root_creds(DST_PASSWORD).unwrap();
            let storage_key = dst.storage_key().unwrap();
            let exported = src
                .export_root_creds(&expected, SRC_PASSWORD, &storage_key)
                .unwrap();
            let actual = dst.import_root_creds(SRC_PASSWORD, exported).unwrap();

            assert!(!std::ptr::eq(previous.as_ref(), actual.as_ref()));
            assert!(to_vec(expected.as_ref()).unwrap() == to_vec(actual.as_ref()).unwrap());
        }

        #[test]
        fn import_root_creds_wrong_password_is_error() {
            const RIGHT_PW: &str = "right";
            const WRONG_PW: &str = "wrong";
            let src = $ctor;
            let dst = $ctor;

            let root_creds = src.gen_root_creds("right").unwrap();
            let storage_key = dst.storage_key().unwrap();
            let exported = src
                .export_root_creds(&root_creds, RIGHT_PW, &storage_key)
                .unwrap();
            let result = dst.import_root_creds(WRONG_PW, exported);

            assert!(result.is_err());
        }

        #[test]
        fn assign_node_writecap() {
            let case = $ctor;

            let mut node_creds = case.node_creds().unwrap();
            let root_creds = case.gen_root_creds("password").unwrap();
            let expires = Epoch::now() + Duration::from_secs(3600);
            let expected = root_creds
                .issue_writecap(node_creds.principal(), &mut std::iter::empty(), expires)
                .unwrap();
            case.assign_node_writecap(&mut node_creds, expected.clone())
                .unwrap();
            let actual = node_creds.writecap().unwrap();

            assert_eq!(&expected, actual);
        }
    };
}