Upstream commit 08ccf5ddfe9bcdd973df6cab8f89374e454af091, renamed by scripts/upstream-import.py.
321 lines
11 KiB
Rust
321 lines
11 KiB
Rust
/*
|
|
* SPDX-FileCopyrightText: 2020 Stalwart Labs LLC <[email protected]>
|
|
*
|
|
* SPDX-License-Identifier: Apache-2.0 OR MIT
|
|
*/
|
|
|
|
mod integration;
|
|
|
|
use integration::Account;
|
|
use integration::dovecot::{Dovecot, no_message_id_probe, shared_message_id_probe};
|
|
use integration::layouts::ImapSuite;
|
|
use integration::validate::{
|
|
blob_bytes, blob_id_for_hash, cleanup, common, count, email_rows_for_blob, open_archive,
|
|
tmp_archive,
|
|
};
|
|
|
|
use inbuxa_migrate::archive::sources::SourceChange;
|
|
use inbuxa_migrate::imap::client::ImapClient;
|
|
use inbuxa_migrate::import::imap::SaslAuth;
|
|
use inbuxa_migrate::import::managesieve::ManageSieveImport;
|
|
use inbuxa_migrate::logging::{Level, Logger};
|
|
use inbuxa_migrate::net::http::TlsPolicy;
|
|
use inbuxa_migrate::net::sasl::SaslPayload;
|
|
use inbuxa_migrate::net::stream::Cleartext;
|
|
use inbuxa_migrate::net::stream::ConnectMode;
|
|
use inbuxa_migrate::net::stream::Connector;
|
|
use rusqlite::Connection;
|
|
|
|
fn suite(d: &Dovecot) -> ImapSuite<'_> {
|
|
ImapSuite {
|
|
server: "dovecot",
|
|
imap: &d.imap,
|
|
cleartext: Cleartext::Forbid,
|
|
}
|
|
}
|
|
|
|
fn sieve_config(account: &Account, sieve: &integration::Endpoint) -> ManageSieveImport {
|
|
ManageSieveImport {
|
|
url: format!("sieve://{}:{}", sieve.host, sieve.port),
|
|
auth: SaslAuth::Basic {
|
|
user: account.username.clone(),
|
|
password: account.password.clone(),
|
|
},
|
|
cleartext: Cleartext::Allow,
|
|
source_change: SourceChange::Reject,
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
#[ignore = "requires Docker"]
|
|
fn dovecot_starts_seeds_and_imports() {
|
|
let d = Dovecot::start().expect("dovecot start");
|
|
let seeds = d.seed_all().expect("dovecot seed");
|
|
assert_eq!(
|
|
seeds.len(),
|
|
d.accounts.len(),
|
|
"seed should return stats for every account"
|
|
);
|
|
d.verify_seed(&seeds).expect("dovecot verify");
|
|
let suite = suite(&d);
|
|
|
|
for seed in &seeds {
|
|
let account = d
|
|
.accounts
|
|
.iter()
|
|
.find(|a| a.username == seed.username)
|
|
.expect("account");
|
|
assert!(
|
|
!seed.mailbox.paths.is_empty(),
|
|
"{}: expected mailboxes seeded",
|
|
seed.username
|
|
);
|
|
assert!(
|
|
seed.mailbox.total_appends > 0,
|
|
"{}: expected emails appended",
|
|
seed.username
|
|
);
|
|
|
|
let archive = tmp_archive(&format!("dovecot-{}", seed.username));
|
|
suite.import(account, &archive, "imap import");
|
|
|
|
let conn = open_archive(&archive);
|
|
suite.assert_seeded(&conn, account, &seed.mailbox);
|
|
|
|
let nomid_target = seed
|
|
.mailbox
|
|
.extras
|
|
.nomid_target
|
|
.clone()
|
|
.expect("nomid target");
|
|
let nomid_hash = blake3::hash(&no_message_id_probe()).as_bytes().to_vec();
|
|
let nomid_matches: Vec<String> = {
|
|
let mut nomid_stmt = conn
|
|
.prepare(
|
|
"SELECT message_match FROM emails
|
|
WHERE blob_id = (SELECT id FROM blobs WHERE hash = ?1)",
|
|
)
|
|
.expect("prepare nomid");
|
|
nomid_stmt
|
|
.query_map([nomid_hash.as_slice()], |r| r.get::<_, String>(0))
|
|
.expect("query nomid")
|
|
.filter_map(|r| r.ok())
|
|
.collect()
|
|
};
|
|
assert!(
|
|
!nomid_matches.is_empty(),
|
|
"{}: no-Message-ID probe missing in archive (target {nomid_target})",
|
|
seed.username
|
|
);
|
|
for m in &nomid_matches {
|
|
let parsed: serde_json::Value = serde_json::from_str(m).expect("message_match json");
|
|
let mids = parsed
|
|
.get("m")
|
|
.and_then(|v| v.as_array())
|
|
.cloned()
|
|
.unwrap_or_default();
|
|
assert!(
|
|
mids.is_empty(),
|
|
"{}: no-Message-ID probe should have empty Message-ID set, got {m}",
|
|
seed.username
|
|
);
|
|
let fb = parsed.get("f").and_then(|v| v.as_str()).unwrap_or("");
|
|
assert_eq!(
|
|
fb.len(),
|
|
64,
|
|
"{}: no-Message-ID probe must carry a BLAKE3 fallback hex, got {m}",
|
|
seed.username
|
|
);
|
|
}
|
|
|
|
if seed.mailbox.extras.mid_dedup_targets.is_some() {
|
|
let body = shared_message_id_probe();
|
|
let hash = blake3::hash(&body);
|
|
let blob_id = blob_id_for_hash(&conn, hash.as_bytes()).expect("shared-mid probe blob");
|
|
let rows_for_blob = email_rows_for_blob(&conn, blob_id);
|
|
assert_eq!(
|
|
rows_for_blob, 2,
|
|
"{}: shared-MID probe should produce 2 email rows for the dedup blob, got {rows_for_blob}",
|
|
seed.username
|
|
);
|
|
let matches: Vec<String> = {
|
|
let mut stmt = conn
|
|
.prepare("SELECT message_match FROM emails WHERE blob_id = ?1")
|
|
.expect("prepare matches");
|
|
stmt.query_map([blob_id], |r| r.get::<_, String>(0))
|
|
.expect("query matches")
|
|
.filter_map(|r| r.ok())
|
|
.collect()
|
|
};
|
|
assert_eq!(matches.len(), 2, "{}: expected 2 matches", seed.username);
|
|
assert_eq!(
|
|
matches[0], matches[1],
|
|
"{}: shared-MID emails must have identical message_match, got {matches:?}",
|
|
seed.username
|
|
);
|
|
}
|
|
|
|
assert_received_at_rfc3339_ish(&conn);
|
|
drop(conn);
|
|
|
|
suite.assert_incremental(account, &archive);
|
|
|
|
if !account.layout.sieve_scripts.is_empty() {
|
|
let sieve_archive = tmp_archive(&format!("dovecot-sieve-{}", seed.username));
|
|
let summary = sieve_config(account, &d.sieve)
|
|
.run(common(&sieve_archive))
|
|
.into_result()
|
|
.expect("sieve import");
|
|
assert!(
|
|
!summary.any_failed(),
|
|
"sieve import had failures for {}: {summary:?}",
|
|
seed.username
|
|
);
|
|
let conn = open_archive(&sieve_archive);
|
|
let script_count = count(&conn, "sieve_scripts") as usize;
|
|
assert_eq!(
|
|
script_count,
|
|
account.layout.sieve_scripts.len(),
|
|
"{}: sieve scripts count mismatch",
|
|
seed.username
|
|
);
|
|
let active_seed = account
|
|
.layout
|
|
.sieve_scripts
|
|
.iter()
|
|
.filter(|s| s.active)
|
|
.count();
|
|
let active_imported: i64 = conn
|
|
.query_row(
|
|
"SELECT count(*) FROM sieve_scripts WHERE is_active = 1",
|
|
[],
|
|
|r| r.get(0),
|
|
)
|
|
.unwrap();
|
|
assert_eq!(
|
|
active_imported as usize, active_seed,
|
|
"{}: active sieve script count mismatch",
|
|
seed.username
|
|
);
|
|
|
|
for seeded in account.layout.sieve_scripts {
|
|
let blob_id: i64 = conn
|
|
.query_row(
|
|
"SELECT blob_id FROM sieve_scripts WHERE name = ?1",
|
|
[seeded.name],
|
|
|r| r.get(0),
|
|
)
|
|
.unwrap();
|
|
let body = blob_bytes(&conn, blob_id);
|
|
assert_eq!(
|
|
body,
|
|
seeded.body.as_bytes(),
|
|
"{}: sieve script {} body round-trip",
|
|
seed.username,
|
|
seeded.name
|
|
);
|
|
let is_active: i64 = conn
|
|
.query_row(
|
|
"SELECT is_active FROM sieve_scripts WHERE name = ?1",
|
|
[seeded.name],
|
|
|r| r.get(0),
|
|
)
|
|
.unwrap();
|
|
assert_eq!(
|
|
is_active == 1,
|
|
seeded.active,
|
|
"{}: sieve script {} active flag mismatch",
|
|
seed.username,
|
|
seeded.name
|
|
);
|
|
}
|
|
let actives: i64 = conn
|
|
.query_row(
|
|
"SELECT count(*) FROM sieve_scripts WHERE is_active = 1",
|
|
[],
|
|
|r| r.get(0),
|
|
)
|
|
.unwrap();
|
|
assert!(
|
|
actives <= 1,
|
|
"{}: at most one sieve script may be active",
|
|
seed.username
|
|
);
|
|
drop(conn);
|
|
|
|
let summary2 = sieve_config(account, &d.sieve)
|
|
.run(common(&sieve_archive))
|
|
.into_result()
|
|
.expect("idempotent sieve re-import");
|
|
assert!(
|
|
!summary2.any_failed(),
|
|
"{}: idempotent sieve re-import had failures",
|
|
seed.username
|
|
);
|
|
|
|
cleanup(&sieve_archive);
|
|
}
|
|
|
|
cleanup(&archive);
|
|
}
|
|
|
|
suite.assert_source_change(&d.accounts[0], &d.accounts[1]);
|
|
d.stop().expect("dovecot stop");
|
|
}
|
|
|
|
fn assert_received_at_rfc3339_ish(conn: &Connection) {
|
|
let mut stmt = conn
|
|
.prepare("SELECT received_at FROM emails LIMIT 50")
|
|
.expect("prepare");
|
|
let rows: Vec<String> = stmt
|
|
.query_map([], |r| r.get::<_, String>(0))
|
|
.expect("query")
|
|
.filter_map(|r| r.ok())
|
|
.collect();
|
|
assert!(!rows.is_empty(), "no emails to check received_at");
|
|
for r in rows {
|
|
assert!(
|
|
r.contains('T') && (r.ends_with('Z') || r.contains('+') || r.contains('-')),
|
|
"received_at does not look like RFC 3339: {r}"
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
#[ignore = "requires Docker"]
|
|
fn dovecot_non_ascii_mailbox_names_round_trip() {
|
|
let d = Dovecot::start().expect("dovecot start");
|
|
let account = d.accounts.first().expect("account");
|
|
suite(&d).assert_non_ascii_round_trip(account);
|
|
}
|
|
|
|
#[test]
|
|
#[ignore = "requires Docker"]
|
|
fn dovecot_post_login_capability_with_imapsieve_url_is_parsed() {
|
|
let d = Dovecot::start().expect("dovecot start");
|
|
let account = d.accounts.first().expect("account");
|
|
let connector = Connector::new(TlsPolicy::AcceptInvalid).expect("connector");
|
|
let mut client = ImapClient::connect(
|
|
&connector,
|
|
&d.imap.host,
|
|
d.imap.port,
|
|
ConnectMode::StartTls,
|
|
Logger::new(Level::Default),
|
|
)
|
|
.expect("connect");
|
|
assert!(client.capabilities().contains("SASL-IR"));
|
|
client
|
|
.authenticate(SaslPayload::Plain {
|
|
authcid: &account.username,
|
|
password: &account.password,
|
|
})
|
|
.expect("AUTHENTICATE PLAIN must survive the untagged post-login CAPABILITY");
|
|
assert!(
|
|
client
|
|
.capabilities()
|
|
.contains("IMAPSIEVE=sieve://127.0.0.1:4190"),
|
|
"post-login capabilities must carry the IMAPSIEVE URL: {:?}",
|
|
client.capabilities()
|
|
);
|
|
}
|