crymap 1.0.1

A simple, secure IMAP server with encrypted data at rest
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
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

//-
// Copyright (c) 2020, Jason Lingle
//
// This file is part of Crymap.
//
// Crymap is free software: you can  redistribute it and/or modify it under the
// terms of  the GNU General Public  License as published by  the Free Software
// Foundation, either version  3 of the License, or (at  your option) any later
// version.
//
// Crymap is distributed  in the hope that  it will be useful,  but WITHOUT ANY
// WARRANTY; without  even the implied  warranty of MERCHANTABILITY  or FITNESS
// FOR  A PARTICULAR  PURPOSE.  See the  GNU General  Public  License for  more
// details.
//
// You should have received a copy of the GNU General Public License along with
// Crymap. If not, see <http://www.gnu.org/licenses/>.

use super::defs::*;

#[test]
fn capability_declared() {
    test_require_capability("5182capa", "SEARCHRES");
}

#[test]
fn test_searchres() {
    let setup = set_up();
    let mut client = setup.connect("5182sres");
    quick_log_in(&mut client);
    quick_create(&mut client, "5182sres");
    quick_append_enron(&mut client, "5182sres", 5);
    quick_select(&mut client, "5182sres");

    ok_command!(client, c("XVANQUISH 3"));

    assert_searchres(
        &mut client,
        "SEARCH RETURN (SAVE) ALL",
        false,
        &[1, 2, 3, 4],
    );

    // UID search behaves the same way
    assert_searchres(
        &mut client,
        "UID SEARCH RETURN (SAVE) 1:2",
        false,
        &[1, 2],
    );

    // A different search without SAVE doesn't change the results
    assert_searchres(&mut client, "SEARCH RETURN (ALL) 4", true, &[1, 2]);

    // MIN and MAX exclude other results unless COUNT or ALL is present
    assert_searchres(&mut client, "SEARCH RETURN (MIN SAVE) ALL", true, &[1]);
    assert_searchres(&mut client, "SEARCH RETURN (MAX SAVE) ALL", true, &[4]);
    assert_searchres(
        &mut client,
        "SEARCH RETURN (MAX MIN SAVE) ALL",
        true,
        &[1, 4],
    );
    assert_searchres(
        &mut client,
        "SEARCH RETURN (MIN ALL SAVE) ALL",
        true,
        &[1, 2, 3, 4],
    );
    assert_searchres(
        &mut client,
        "SEARCH RETURN (MIN COUNT SAVE) ALL",
        true,
        &[1, 2, 3, 4],
    );

    // Special case when MIN and MAX are the same value
    assert_searchres(&mut client, "SEARCH RETURN (MIN MAX SAVE) 2", true, &[2]);

    // Empty results are handled properly
    assert_searchres(
        &mut client,
        "SEARCH RETURN (SAVE) KEYWORD nonexistent",
        false,
        &[],
    );

    // $ continues to work if one of its messages is expunged
    assert_searchres(
        &mut client,
        "SEARCH RETURN (SAVE) ALL",
        false,
        &[1, 2, 3, 4],
    );
    ok_command!(client, c("XVANQUISH 2"));
    assert_searchres(
        &mut client,
        // Doesn't change $
        "SEARCH 1",
        true,
        &[1, 2, 3],
    );

    // SELECT resets $
    quick_select(&mut client, "5182sres");
    assert_searchres(
        &mut client,
        // Doesn't change $
        "SEARCH RETURN (ALL) ALL",
        true,
        &[],
    );
}

fn assert_searchres(
    client: &mut PipeClient,
    search_command: &str,
    expect_search_result: bool,
    expected_seqnums: &[u32],
) {
    command!(mut responses = client, cb(search_command));
    if expect_search_result {
        assert_eq!(2, responses.len());
    } else {
        assert_eq!(1, responses.len());
    }
    assert_tagged_ok(responses.pop().unwrap());

    command!(responses = client, c("FETCH $ UID"));
    let actual_seqnums = responses
        .into_iter()
        .filter_map(|r| match r {
            s::ResponseLine {
                tag: None,
                response: s::Response::Fetch(fr),
            } => Some(fr.seqnum),
            _ => None,
        })
        .collect::<Vec<_>>();
    assert_eq!(expected_seqnums, &actual_seqnums[..]);

    // Using $ for UIDs emits the same results
    command!(responses = client, c("UID FETCH $ UID"));
    let actual_seqnums = responses
        .into_iter()
        .filter_map(|r| match r {
            s::ResponseLine {
                tag: None,
                response: s::Response::Fetch(fr),
            } => Some(fr.seqnum),
            _ => None,
        })
        .collect::<Vec<_>>();
    assert_eq!(expected_seqnums, &actual_seqnums[..]);
}