Files
jcoffey-dev 6afddcf43b Import upstream v1.1.0, renamed
Upstream commit 08ccf5ddfe9bcdd973df6cab8f89374e454af091, renamed by scripts/upstream-import.py.
2026-11-17 08:13:05 -07:00

779 lines
26 KiB
Rust

/*
* SPDX-FileCopyrightText: 2020 Stalwart Labs LLC <[email protected]>
*
* SPDX-License-Identifier: Apache-2.0 OR MIT
*/
use std::collections::HashSet;
use std::path::Path;
use inbuxa_migrate::archive::sources::SourceChange;
use inbuxa_migrate::error::Error;
use inbuxa_migrate::imap::automap::Automap;
use inbuxa_migrate::imap::session::Compress;
use inbuxa_migrate::import::imap::{
DeletedMessages, FolderScope, ImapImport, MimeKeywords, SaslAuth,
};
use inbuxa_migrate::net::stream::Cleartext;
use inbuxa_migrate::sync::Summary;
use rusqlite::Connection;
use serde_json::Value;
use super::imap_client::{ImapSeed, MailboxSeed, SeedTag};
use super::validate::{
all_contact_uids, all_event_uids, assert_message_round_trip, blob_bytes, blob_id_for_hash,
calendar_event_count, cleanup, collection_id_by_name, collection_names, common,
contact_card_count, count, emails_in_mailbox, keywords_for_blob, mailbox_id_by_name,
mailbox_id_by_path, mailbox_path, open_archive, tmp_archive,
};
use super::{Account, Endpoint};
#[derive(Debug, Clone, Copy)]
pub struct MailboxSpec {
pub key: &'static str,
pub name: &'static str,
pub parent: Option<&'static str>,
}
#[derive(Debug, Clone, Copy)]
pub struct FileSpec {
pub key: &'static str,
pub name: &'static str,
pub parent: Option<&'static str>,
pub directory: bool,
}
#[derive(Debug, Clone, Copy)]
pub struct SieveScript {
pub name: &'static str,
pub body: &'static str,
pub active: bool,
}
#[derive(Debug, Clone, Copy)]
pub struct Layout {
pub mailboxes: &'static [MailboxSpec],
pub files: &'static [FileSpec],
pub calendars: &'static [&'static str],
pub address_books: &'static [&'static str],
pub sieve_scripts: &'static [SieveScript],
pub email_count: usize,
pub contact_count: usize,
pub event_count: usize,
}
macro_rules! mailbox {
($k:expr, $n:expr, $p:expr) => {
MailboxSpec {
key: $k,
name: $n,
parent: $p,
}
};
}
macro_rules! node {
($k:expr, $n:expr, $p:expr, $d:expr) => {
FileSpec {
key: $k,
name: $n,
parent: $p,
directory: $d,
}
};
}
pub const ACCOUNT1: &str = "user1";
pub const ACCOUNT2: &str = "user2";
pub const ACCOUNT3: &str = "user3";
pub const PASSWORD: &str = "InbuxaUser#2026";
pub static MAILBOXES_DEEP: &[MailboxSpec] = &[
mailbox!("proj", "Projects", None),
mailbox!("y2024", "2024", Some("proj")),
mailbox!("q1", "Q1", Some("y2024")),
mailbox!("acme", "ClientAcme", Some("q1")),
mailbox!("acme_in", "Internal", Some("acme")),
mailbox!("q2", "Q2", Some("y2024")),
mailbox!("globex", "ClientGlobex", Some("q2")),
mailbox!("y2025", "2025", Some("proj")),
mailbox!("alpha", "Alpha", Some("y2025")),
mailbox!("beta", "Beta", Some("y2025")),
mailbox!("travel", "Travel", None),
mailbox!("asia", "Asia", Some("travel")),
mailbox!("jp", "Japan", Some("asia")),
mailbox!("tokyo", "Tokyo", Some("jp")),
mailbox!("eu", "Europe", Some("travel")),
mailbox!("it", "Italy", Some("eu")),
mailbox!("rome", "Rome", Some("it")),
mailbox!("arch", "Archive", None),
mailbox!("arch23", "2023", Some("arch")),
mailbox!("arch24", "2024", Some("arch")),
];
pub static MAILBOXES_MEDIUM: &[MailboxSpec] = &[
mailbox!("work", "Work", None),
mailbox!("clients", "Clients", Some("work")),
mailbox!("acme", "AcmeCorp", Some("clients")),
mailbox!("inv", "Invoices", Some("acme")),
mailbox!("globex", "Globex", Some("clients")),
mailbox!("internal", "Internal", Some("work")),
mailbox!("pers", "Personal", None),
mailbox!("rcpt", "Receipts", Some("pers")),
];
pub static MAILBOXES_FLAT: &[MailboxSpec] = &[
mailbox!("lists", "Lists", None),
mailbox!("news", "Newsletters", Some("lists")),
mailbox!("misc", "Misc", None),
];
pub static FILES_DEEP: &[FileSpec] = &[
node!("docs", "Documents", None, true),
node!("rep", "Reports", Some("docs"), true),
node!("d24", "2024", Some("rep"), true),
node!("q1f", "q1-results.bin", Some("d24"), false),
node!("q2f", "q2-results.bin", Some("d24"), false),
node!("d25", "2025", Some("rep"), true),
node!("q1f25", "q1-results.bin", Some("d25"), false),
node!("spec", "Specs", Some("docs"), true),
node!("ovr", "overview.bin", Some("spec"), false),
node!("notes", "notes.bin", Some("docs"), false),
node!("photos", "Photos", None, true),
node!("vac", "Vacations", Some("photos"), true),
node!("vit", "Italy", Some("vac"), true),
node!("vrome", "rome.bin", Some("vit"), false),
node!("vjp", "Japan", Some("vac"), true),
node!("vtokyo", "tokyo.bin", Some("vjp"), false),
node!("readme", "README.bin", None, false),
];
pub static FILES_MEDIUM: &[FileSpec] = &[
node!("media", "Media", None, true),
node!("audio", "Audio", Some("media"), true),
node!("song", "song.bin", Some("audio"), false),
node!("video", "Video", Some("media"), true),
node!("clip", "clip.bin", Some("video"), false),
node!("proj", "Projects", None, true),
node!("src", "src", Some("proj"), true),
node!("main", "main.bin", Some("src"), false),
];
pub static FILES_FLAT: &[FileSpec] = &[
node!("bak", "Backup", None, true),
node!("snap", "snapshot.bin", Some("bak"), false),
node!("scratch", "scratch.bin", None, false),
];
pub static CALENDARS_DEEP: &[&str] = &["Personal", "Work", "Birthdays", "Travel"];
pub static CALENDARS_MEDIUM: &[&str] = &["Personal", "Work"];
pub static CALENDARS_FLAT: &[&str] = &["Personal", "Holidays"];
pub static ADDRESS_BOOKS_DEEP: &[&str] = &["Personal", "Work", "Friends"];
pub static ADDRESS_BOOKS_MEDIUM: &[&str] = &["Personal", "Work"];
pub static ADDRESS_BOOKS_FLAT: &[&str] = &["Personal", "Family"];
pub static SIEVE_DEEP: &[SieveScript] = &[
SieveScript {
name: "spam",
body: "require [\"fileinto\"];\nif header :contains \"X-Spam\" \"YES\" {\n fileinto \"Junk\";\n stop;\n}\n",
active: true,
},
SieveScript {
name: "vacation",
body: "require [\"vacation\"];\nvacation :days 7 :subject \"Out of office\" \"I am away, will reply later.\";\n",
active: false,
},
SieveScript {
name: "organize",
body: "require [\"fileinto\",\"mailbox\"];\nif address :is \"from\" \"[email protected]\" {\n fileinto :create \"Projects/2025/Beta\";\n}\n",
active: false,
},
];
pub static SIEVE_MEDIUM: &[SieveScript] = &[
SieveScript {
name: "filter",
body: "require [\"fileinto\"];\nif address :is \"to\" \"[email protected]\" {\n fileinto \"Work\";\n}\n",
active: true,
},
SieveScript {
name: "draft",
body: "require [\"reject\"];\nif address :is \"from\" \"[email protected]\" {\n reject \"go away\";\n}\n",
active: false,
},
];
pub static SIEVE_FLAT: &[SieveScript] = &[];
pub fn layout_for(username: &str) -> Layout {
match username {
s if s == ACCOUNT1 => Layout {
mailboxes: MAILBOXES_DEEP,
files: FILES_DEEP,
calendars: CALENDARS_DEEP,
address_books: ADDRESS_BOOKS_DEEP,
sieve_scripts: SIEVE_DEEP,
email_count: 200,
contact_count: 40,
event_count: 40,
},
s if s == ACCOUNT2 => Layout {
mailboxes: MAILBOXES_MEDIUM,
files: FILES_MEDIUM,
calendars: CALENDARS_MEDIUM,
address_books: ADDRESS_BOOKS_MEDIUM,
sieve_scripts: SIEVE_MEDIUM,
email_count: 80,
contact_count: 15,
event_count: 15,
},
_ => Layout {
mailboxes: MAILBOXES_FLAT,
files: FILES_FLAT,
calendars: CALENDARS_FLAT,
address_books: ADDRESS_BOOKS_FLAT,
sieve_scripts: SIEVE_FLAT,
email_count: 20,
contact_count: 10,
event_count: 10,
},
}
}
pub fn accounts() -> [&'static str; 3] {
[ACCOUNT1, ACCOUNT2, ACCOUNT3]
}
pub fn collection_segment(prefix: &str, idx: usize, name: &str) -> String {
let mut out = format!("{prefix}-{:02}-", idx);
for c in name.chars() {
if c.is_ascii_alphanumeric() {
out.push(c.to_ascii_lowercase());
} else if !out.ends_with('-') {
out.push('-');
}
}
out.trim_end_matches('-').to_owned()
}
pub fn events_per_calendar(layout: &Layout, idx: usize) -> usize {
if layout.calendars.is_empty() {
return 0;
}
let base = layout.event_count / layout.calendars.len().max(1);
let extra = if idx == 0 {
layout.event_count % layout.calendars.len()
} else {
0
};
base + extra
}
pub fn events_offset(layout: &Layout, idx: usize) -> usize {
(0..idx).map(|i| events_per_calendar(layout, i)).sum()
}
pub fn contacts_per_book(layout: &Layout, idx: usize) -> usize {
if layout.address_books.is_empty() {
return 0;
}
let base = layout.contact_count / layout.address_books.len().max(1);
let extra = if idx == 0 {
layout.contact_count % layout.address_books.len()
} else {
0
};
base + extra
}
pub fn contacts_offset(layout: &Layout, idx: usize) -> usize {
(0..idx).map(|i| contacts_per_book(layout, i)).sum()
}
#[derive(Debug, Clone)]
pub struct SeededItem {
pub uid: String,
pub href: String,
pub source: Vec<u8>,
}
#[derive(Debug, Clone)]
pub struct CollectionPlan {
pub display_name: String,
pub base_href: String,
pub items: Vec<SeededItem>,
}
impl CollectionPlan {
pub fn new(display_name: String, base_href: String) -> Self {
Self {
display_name,
base_href,
items: Vec::new(),
}
}
}
#[derive(Debug, Clone)]
pub struct AccountSeed {
pub username: String,
pub calendars: Vec<CollectionPlan>,
pub address_books: Vec<CollectionPlan>,
}
impl AccountSeed {
pub fn new(username: String) -> Self {
Self {
username,
calendars: Vec::new(),
address_books: Vec::new(),
}
}
pub fn total_events(&self) -> usize {
self.calendars.iter().map(|c| c.items.len()).sum()
}
pub fn total_contacts(&self) -> usize {
self.address_books.iter().map(|c| c.items.len()).sum()
}
pub fn event_uids(&self) -> HashSet<String> {
self.calendars
.iter()
.flat_map(|c| c.items.iter().map(|i| i.uid.clone()))
.collect()
}
pub fn contact_uids(&self) -> HashSet<String> {
self.address_books
.iter()
.flat_map(|c| c.items.iter().map(|i| i.uid.clone()))
.collect()
}
}
pub fn assert_event_collection_exact(conn: &Connection, seed: &AccountSeed) {
let names = collection_names(conn, "calendars");
let expected: HashSet<String> = seed
.calendars
.iter()
.map(|c| c.display_name.clone())
.collect();
assert_eq!(
names, expected,
"{}: calendar displayname set mismatch",
seed.username
);
for plan in &seed.calendars {
let cal_id = collection_id_by_name(conn, "calendars", &plan.display_name)
.unwrap_or_else(|| panic!("calendar {} missing", plan.display_name));
let got = calendar_event_count(conn, cal_id);
assert_eq!(
got as usize,
plan.items.len(),
"{}: calendar {} event count {got} != seeded {}",
seed.username,
plan.display_name,
plan.items.len()
);
}
}
pub fn assert_contact_collection_exact(conn: &Connection, seed: &AccountSeed) {
let names = collection_names(conn, "address_books");
let expected: HashSet<String> = seed
.address_books
.iter()
.map(|c| c.display_name.clone())
.collect();
assert_eq!(
names, expected,
"{}: address book displayname set mismatch",
seed.username
);
for plan in &seed.address_books {
let book_id = collection_id_by_name(conn, "address_books", &plan.display_name)
.unwrap_or_else(|| panic!("address book {} missing", plan.display_name));
let got = contact_card_count(conn, book_id);
assert_eq!(
got as usize,
plan.items.len(),
"{}: book {} contact count {got} != seeded {}",
seed.username,
plan.display_name,
plan.items.len()
);
}
}
pub fn assert_event_uids_round_trip(conn: &Connection, seed: &AccountSeed) {
let imported = all_event_uids(conn);
let expected = seed.event_uids();
let missing: Vec<_> = expected.difference(&imported).collect();
assert!(
missing.is_empty(),
"{}: event uids missing from archive: {missing:?}",
seed.username
);
}
pub fn assert_contact_uids_round_trip(conn: &Connection, seed: &AccountSeed) {
let imported = all_contact_uids(conn);
let expected = seed.contact_uids();
let missing: Vec<_> = expected.difference(&imported).collect();
assert!(
missing.is_empty(),
"{}: contact uids missing from archive: {missing:?}",
seed.username
);
}
pub fn assert_event_data_well_formed(conn: &Connection) {
let mut stmt = conn
.prepare("SELECT data, data_type FROM calendar_events")
.expect("prepare");
let rows: Vec<(String, String)> = stmt
.query_map([], |r| Ok((r.get::<_, String>(0)?, r.get::<_, String>(1)?)))
.expect("query")
.filter_map(|r| r.ok())
.collect();
assert!(!rows.is_empty(), "no calendar_events rows");
for (raw, data_type) in rows {
assert_eq!(
data_type, "Event",
"all VEVENT seeds must land as Event, got data_type={data_type}, raw={raw}"
);
let v: Value = serde_json::from_str(&raw)
.unwrap_or_else(|e| panic!("calendar_events.data invalid JSON: {e}; raw={raw}"));
let obj = v.as_object().expect("event data is object");
let kind = obj
.get("@type")
.or_else(|| obj.get("type"))
.and_then(Value::as_str)
.unwrap_or("");
assert_eq!(kind, "Event", "JSCalendar @type must be Event, got {kind}");
assert!(obj.contains_key("uid"), "event JSON missing uid: {obj:?}");
assert!(
obj.contains_key("start"),
"event JSON missing start: {obj:?}"
);
}
}
pub fn assert_contact_data_well_formed(conn: &Connection) {
let mut stmt = conn
.prepare("SELECT uid, data FROM contact_cards")
.expect("prepare");
let rows: Vec<(String, String)> = stmt
.query_map([], |r| Ok((r.get::<_, String>(0)?, r.get::<_, String>(1)?)))
.expect("query")
.filter_map(|r| r.ok())
.collect();
assert!(!rows.is_empty(), "no contact_cards rows");
for (uid, raw) in rows {
assert!(!uid.is_empty(), "contact uid empty");
let v: Value = serde_json::from_str(&raw)
.unwrap_or_else(|e| panic!("contact_cards.data invalid JSON: {e}; raw={raw}"));
let obj = v.as_object().expect("contact data is object");
let kind = obj
.get("@type")
.or_else(|| obj.get("type"))
.and_then(Value::as_str)
.unwrap_or("");
assert_eq!(kind, "Card", "JSContact @type must be Card, got {kind}");
}
}
pub struct ImapSuite<'a> {
pub server: &'static str,
pub imap: &'a Endpoint,
pub cleartext: Cleartext,
}
impl ImapSuite<'_> {
pub fn config(&self, account: &Account) -> ImapImport {
ImapImport {
url: format!("imap://{}:{}", self.imap.host, self.imap.port),
auth: SaslAuth::Basic {
user: account.username.clone(),
password: account.password.clone(),
},
cleartext: self.cleartext,
compress: Compress::Off,
include: Vec::new(),
exclude: Vec::new(),
exclude_special: Vec::new(),
folder: Vec::new(),
scope: FolderScope::All,
automap: Automap::Enabled,
deleted: DeletedMessages::Skip,
mime_keywords: MimeKeywords::Skip,
fetch_batch: 64,
imap_connections: 2,
source_change: SourceChange::Reject,
}
}
pub fn import(&self, account: &Account, archive: &Path, what: &str) -> Summary {
let summary = self
.config(account)
.run(common(archive))
.into_result()
.unwrap_or_else(|e| panic!("{} {what}: {e:?}", self.server));
assert!(
!summary.any_failed(),
"{} {what} had failures for {}: {summary:?}",
self.server,
account.username
);
summary
}
pub fn assert_seeded(&self, conn: &Connection, account: &Account, seed: &MailboxSeed) {
let user = &account.username;
let mailbox_count = count(conn, "mailboxes") as usize;
let email_count = count(conn, "emails") as usize;
let expected_mailboxes = account.layout.mailboxes.len() + 1;
assert_eq!(
mailbox_count, expected_mailboxes,
"{user}: imported {mailbox_count} mailboxes, expected exactly {expected_mailboxes}"
);
assert_eq!(
email_count, seed.total_appends,
"{user}: every seeded email must land in archive (appended {}, imported {email_count})",
seed.total_appends
);
assert!(count(conn, "blobs") > 0, "{user}: blobs interned");
let bad_match: i64 = conn
.query_row(
"SELECT count(*) FROM emails WHERE message_match IS NULL OR message_match = ''",
[],
|r| r.get(0),
)
.unwrap();
assert_eq!(
bad_match, 0,
"{user}: every imported email must have a non-empty message_match"
);
if let Some(probe) = seed.appends.iter().find(|a| a.tag == SeedTag::FlagProbe) {
let blob_id = blob_id_for_hash(conn, blake3::hash(&probe.raw).as_bytes())
.expect("flag probe blob");
assert_eq!(
blob_bytes(conn, blob_id),
probe.raw,
"{user}: flag probe blob bytes mismatch"
);
let keywords = keywords_for_blob(conn, blob_id);
let kw_set: HashSet<_> = keywords.iter().map(String::as_str).collect();
for keyword in &probe.flags {
assert!(
kw_set.contains(keyword.as_str()),
"{user}: flag probe missing {keyword} in keywords {keywords:?}"
);
}
}
for path in &seed.paths {
let id = mailbox_id_by_path(conn, path, '/')
.unwrap_or_else(|| panic!("{user}: mailbox path {path} missing in archive"));
assert_eq!(mailbox_path(conn, id, '/'), *path);
let expected = seed.histogram.get(path).copied().unwrap_or(0);
let got = emails_in_mailbox(conn, id) as usize;
assert_eq!(
got, expected,
"{user}: mailbox {path} email count {got} != appended {expected}"
);
}
for append in &seed.appends {
assert_message_round_trip(
conn,
&append.raw,
&append.target,
&format!("{user}/append/{:?}", append.tag),
);
}
let inbox_role: Option<String> = conn
.query_row("SELECT role FROM mailboxes WHERE name = 'INBOX'", [], |r| {
r.get(0)
})
.unwrap();
assert_eq!(
inbox_role,
Some("inbox".to_owned()),
"{user}: INBOX role tagged"
);
let inbox_id = mailbox_id_by_name(conn, "INBOX").expect("INBOX");
let inbox_seeded = seed.histogram.get("INBOX").copied().unwrap_or(0);
assert_eq!(
emails_in_mailbox(conn, inbox_id) as usize,
inbox_seeded,
"{user}: INBOX email count mismatch"
);
}
pub fn assert_incremental(&self, account: &Account, archive: &Path) {
let user = &account.username;
let conn = open_archive(archive);
let email_count = count(&conn, "emails");
let mailbox_count = count(&conn, "mailboxes");
let blob_count = count(&conn, "blobs");
drop(conn);
self.import(account, archive, "idempotent imap re-import");
let conn = open_archive(archive);
assert_eq!(
count(&conn, "emails"),
email_count,
"{user}: idempotent re-import added emails"
);
assert_eq!(
count(&conn, "mailboxes"),
mailbox_count,
"{user}: idempotent re-import added mailboxes"
);
assert_eq!(
count(&conn, "blobs"),
blob_count,
"{user}: idempotent re-import added blobs"
);
drop(conn);
let mut client = ImapSeed::open(self.imap, account).expect("imap login");
client
.delete_and_expunge_first("INBOX")
.expect("expunge first INBOX message");
client.logout().expect("imap logout");
self.import(account, archive, "re-import after expunge");
let conn = open_archive(archive);
assert_eq!(
count(&conn, "emails"),
email_count - 1,
"{user}: expunged message was not pruned"
);
drop(conn);
let mut client = ImapSeed::open(self.imap, account).expect("imap login");
let (added_raw, added_mid) = client
.append_probe(account, "INBOX", "post-import")
.expect("append new INBOX message");
client.logout().expect("imap logout");
self.import(account, archive, "re-import after append");
let conn = open_archive(archive);
assert_eq!(
count(&conn, "emails"),
email_count,
"{user}: append-after-expunge should restore email count to baseline"
);
let added_blob = blob_id_for_hash(&conn, blake3::hash(&added_raw).as_bytes())
.expect("added message blob present");
assert_eq!(
blob_bytes(&conn, added_blob),
added_raw,
"{user}: added message blob bytes mismatch"
);
let mid_normalised = added_mid
.trim_matches(|c| c == '<' || c == '>')
.to_ascii_lowercase();
let mid_found: i64 = conn
.query_row(
"SELECT count(*) FROM emails
WHERE EXISTS (SELECT 1 FROM json_each(json_extract(message_match,'$.m')) j
WHERE j.value = ?1)",
[mid_normalised.as_str()],
|r| r.get(0),
)
.unwrap();
assert!(
mid_found >= 1,
"{user}: added Message-ID {added_mid} not found in message_match"
);
let inbox_id = mailbox_id_by_name(&conn, "INBOX").expect("INBOX id");
let added_in_inbox: bool = conn
.query_row(
"SELECT EXISTS (SELECT 1 FROM emails
WHERE blob_id = ?1
AND EXISTS (SELECT 1 FROM json_each(mailbox_ids) j
WHERE j.value = ?2))",
rusqlite::params![added_blob, inbox_id],
|r| r.get::<_, i64>(0).map(|n| n != 0),
)
.unwrap();
assert!(
added_in_inbox,
"{user}: added message blob not linked to INBOX"
);
}
pub fn assert_source_change(&self, primary: &Account, other: &Account) {
let shared_archive = tmp_archive(&format!("{}-source-change", self.server));
self.config(primary)
.run(common(&shared_archive))
.into_result()
.expect("seed archive with primary user");
let err = self
.config(other)
.run(common(&shared_archive))
.into_result()
.expect_err("expected source-change abort");
assert!(
matches!(err, Error::SourceChange(_)),
"expected SourceChange, got {err:?}"
);
cleanup(&shared_archive);
}
pub fn assert_non_ascii_round_trip(&self, account: &Account) {
let mutf7_name = "Envoy&AOk-s";
let utf8_name = "Envoyés";
let message = b"From: [email protected]\r\n\
To: [email protected]\r\n\
Subject: Accents\r\n\
Message-ID: <[email protected]>\r\n\
Date: Wed, 01 Jan 2025 12:00:00 +0000\r\n\
\r\n\
Accented folder probe.\r\n";
let mut client = ImapSeed::open(self.imap, account).expect("imap login");
client
.create_with_message(mutf7_name, message)
.expect("create accented mailbox");
client.logout().expect("imap logout");
let archive = tmp_archive(&format!("{}-non-ascii", self.server));
let summary = self
.config(account)
.run(common(&archive))
.into_result()
.expect("imap import");
assert!(
!summary.any_failed(),
"an accented folder name must not fail the import: {summary:?}"
);
let conn = open_archive(&archive);
let names: Vec<String> = {
let mut stmt = conn
.prepare("SELECT name FROM mailboxes ORDER BY name")
.unwrap();
stmt.query_map([], |r| r.get::<_, String>(0))
.unwrap()
.map(Result::unwrap)
.collect()
};
let mailbox_id = mailbox_id_by_name(&conn, utf8_name).unwrap_or_else(|| {
panic!("no mailbox named {utf8_name}; names must not be mojibake, got {names:?}")
});
assert_eq!(
emails_in_mailbox(&conn, mailbox_id),
1,
"the message inside the accented folder must be imported"
);
drop(conn);
cleanup(&archive);
}
}