//! Whole-crate properties: what is written reads back the same, and no text makes the reader panic. use crate::{Contact, Labeled, PostalAddress}; use chrono::NaiveDate; use proptest::prelude::*; use crate::{parse, write}; /// What reading back gives for a written contact: the name the card was written under. fn as_read(c: &Contact) -> Contact { Contact { display_name: c.name(), ..c.clone() } } fn round_trip(contacts: &[Contact]) -> Vec { parse(&write(&contacts.iter().collect::>())) } fn sample_contacts() -> Vec { let nadia = Contact { display_name: "Dr. Nadia Okafor".into(), first: "Nadia".into(), middle: "Chidi Rose".into(), last: "Okafor".into(), nickname: "Nadi, \"the planner\"".into(), company: "Example Research, Inc.".into(), title: "Lead Scientist; Field".into(), department: "Field Lab \\ Unit 7".into(), emails: vec![ Labeled::new("work", "nadia.okafor@example.org"), Labeled::new("", "nadia@example.org"), Labeled::new("Family", "nadia@family.example.org"), Labeled::new("mobile", "nadia@phone.example.org"), ], phones: vec![ Labeled::new("mobile", "+1 (555) 010-0142"), Labeled::new("work", "+1 555 010 0143"), Labeled::new("home", "+1 555 010 0144"), Labeled::new("fax", "+1 555 010 0145"), Labeled::new("pager", "+1 555 010 0146"), Labeled::new("other", "+1 555 010 0147"), Labeled::new("", "+1 555 010 0148"), Labeled::new("Car; old, blue", "+1 555 010 0149"), ], addresses: vec![ PostalAddress { label: "work".into(), street: "Suite 300, 41 Harbor Road".into(), city: "Riverton".into(), region: "CA".into(), postal_code: "94000".into(), country: "USA".into(), }, PostalAddress { label: "home".into(), street: "7; Rue de l'Étang".into(), city: "Saint-Rémy".into(), ..Default::default() }, PostalAddress { label: "Cabin".into(), country: "Norway".into(), ..Default::default() }, PostalAddress { postal_code: "12345".into(), ..Default::default() }, ], websites: vec!["https://example.org/~nadia?a=1,2;b=3".into(), "example.org".into()], birthday: NaiveDate::from_ymd_opt(1985, 4, 12), notes: "Met at the 2024 symposium.\nPrefers e-mail, not calls; never on Fridays.\n\n\tC:\\notes\\nadia.txt\n".into(), categories: vec!["Research".into(), "Field Team, West".into()], favorite: true, uid: "7f1c2f6e-0001-4a5b-9c3d-000000000042".into(), ..Default::default() }; let unnamed = Contact { first: "Jürgen".into(), last: "Müller".into(), phones: vec![Labeled::new("mobile", "+49 170 5550101")], ..Default::default() }; let company = Contact { company: "東京デザイン株式会社".into(), websites: vec!["https://design.example.org".into()], ..Default::default() }; let address_only = Contact { emails: vec![Labeled::new("other", "someone@example.org")], ..Default::default() }; let bare = Contact { favorite: true, ..Default::default() }; let emoji = Contact { display_name: "Zoë 🎉 “Zed” Ødegård".into(), notes: " leading and trailing spaces stay ".into(), birthday: NaiveDate::from_ymd_opt(2000, 2, 29), ..Default::default() }; vec![nadia, unnamed, company, address_only, bare, emoji] } #[test] fn sample_contacts_round_trip() { let contacts = sample_contacts(); let back = round_trip(&contacts); assert_eq!(back, contacts.iter().map(as_read).collect::>()); assert_eq!(back[1].display_name, "Jürgen Müller"); assert_eq!(back[3].display_name, "someone@example.org"); assert_eq!(back[4].display_name, ""); // What was read writes the same text again. let text = write(&back.iter().collect::>()); assert_eq!(parse(&text), back); assert_eq!(write(&parse(&text).iter().collect::>()), text); } #[test] fn an_empty_contact_does_not_come_back() { assert!(round_trip(&[Contact::default(), Contact::default()]).is_empty()); // Entries with nothing in them are left out. let hollow = Contact { display_name: "Ada".into(), emails: vec![Labeled::new("work", ""), Labeled::new("home", "ada@example.org")], phones: vec![Labeled::new("mobile", " ")], addresses: vec![PostalAddress { label: "home".into(), ..Default::default() }], websites: vec![String::new()], categories: vec![" ".into()], ..Default::default() }; let back = round_trip(std::slice::from_ref(&hollow)); assert_eq!(back, [Contact { display_name: "Ada".into(), emails: vec![Labeled::new("home", "ada@example.org")], ..Default::default() }]); } #[test] fn cards_from_other_programs_survive_a_round_trip() { // A 2.1 card read, written as 3.0 and read again says the same. let old = "BEGIN:VCARD\r\nVERSION:2.1\r\nN;CHARSET=UTF-8;ENCODING=QUOTED-PRINTABLE:M=C3=BCller;J=C3=BCrgen\r\nTEL;WORK;VOICE:+49 30 5550100\r\nTEL;CELL:+49 170 5550101\r\n\ EMAIL;PREF;INTERNET:jm@example.org\r\nADR;HOME:;;Gartenweg 12, Hinterhaus;Berlin;;10115;Deutschland\r\nNOTE;ENCODING=QUOTED-PRINTABLE:Zeile eins=0D=0AZeile =\r\nzwei\r\nEND:VCARD\r\n"; let first = parse(old); assert_eq!(first.len(), 1); assert_eq!(first[0].notes, "Zeile eins\nZeile zwei"); assert_eq!(first[0].addresses[0].street, "Gartenweg 12, Hinterhaus"); assert_eq!(round_trip(&first), first.iter().map(as_read).collect::>()); } /// One line of text as a contact field holds it: printable, trimmed. fn line() -> impl Strategy { prop_oneof!["(\\PC|[;,\\\\:\"^=.]){0,24}", "[ -~]{0,60}", Just(String::new())].prop_map(|s| s.trim().to_string()) } /// A line with something in it: an empty one gets a character. fn filled_line() -> impl Strategy { (line(), "[!-~]").prop_map(|(line, fallback)| if line.is_empty() { fallback } else { line }) } fn label(known: &'static [&'static str]) -> impl Strategy { prop_oneof![proptest::sample::select(known).prop_map(str::to_string), Just(String::new()), line()] } fn date() -> impl Strategy { (1i32..=9999, 1u32..=12, 1u32..=28).prop_map(|(y, m, day)| NaiveDate::from_ymd_opt(y, m, day).unwrap_or_default()) } fn address() -> impl Strategy { // One part, any of them, always says something. (label(&["work", "home", "other"]), [line(), line(), line(), line(), line()], 0usize..5, filled_line()).prop_map( |(label, mut parts, filled, text)| { parts[filled] = text; let [street, city, region, postal_code, country] = parts; PostalAddress { label, street, city, region, postal_code, country } }, ) } fn contact() -> impl Strategy { let names = (line(), line(), line(), line(), line(), line(), line(), line()); let emails = proptest::collection::vec((label(&["work", "home", "other"]), filled_line()), 0..4); let phones = proptest::collection::vec((label(&["mobile", "work", "home", "fax", "pager", "other"]), filled_line()), 0..4); let lists = ( emails, phones, proptest::collection::vec(address(), 0..3), proptest::collection::vec(filled_line(), 0..3), proptest::collection::vec(filled_line(), 0..3), ); let rest = (proptest::option::of(date()), "(\\PC|[\n\t;,\\\\:]){0,120}", any::(), line()); (names, lists, rest).prop_map(|(names, lists, rest)| { let (display_name, first, middle, last, nickname, company, title, department) = names; let (emails, phones, addresses, websites, categories) = lists; let (birthday, notes, favorite, uid) = rest; let labeled = |list: Vec<(String, String)>| list.into_iter().map(|(label, value)| Labeled { label, value }).collect(); Contact { display_name, first, middle, last, nickname, company, title, department, emails: labeled(emails), phones: labeled(phones), addresses, websites, birthday, notes, categories, favorite, uid, ..Default::default() } }) } /// Text that looks like a card without being one. fn soup() -> impl Strategy { let piece = prop_oneof![ proptest::sample::select(vec![ "BEGIN:VCARD", "END:VCARD", "BEGIN:", "END:", "BEGIN:X", "END:X", "VERSION:2.1", "VERSION:3.0", "VERSION:4.0", "FN", "N", "NICKNAME", "ORG", "TITLE", "EMAIL", "TEL", "ADR", "URL", "BDAY", "NOTE", "CATEGORIES", "UID", "PHOTO", "X-ABLabel", "X-FAVORITE", "item1.", "item2.", ".", ":", ";", ",", "=", "\"", "\\", "\r\n", "\n", "\r\n ", "\n\t", " ", "=\r\n", "=\n", "=C3=A9", "=C3", "=ZZ", "\\n", "\\;", "\\,", ";TYPE=WORK,VOICE", ";TYPE=\"cell,pref\"", ";HOME", ";CELL", ";ENCODING=QUOTED-PRINTABLE", ";QUOTED-PRINTABLE", ";ENCODING=b", ";BASE64", ";CHARSET=ISO-8859-1", ";CHARSET=UTF-8", ";CHARSET=x", "mailto:", "tel:", "a@example.org", "+1 555 0100", "1985-04-12", "19850412T101010Z", "--0412", "0000-00-00", "TRUE", "SGVsbG8=", "_$!!$_", "_$!<", ]) .prop_map(str::to_string), "\\PC{0,6}", any::(), ]; proptest::collection::vec(piece, 0..60).prop_map(|pieces| pieces.concat()) } fn valid_text() -> String { write(&sample_contacts().iter().collect::>()) } /// Whatever the reader gives must also be writable and readable again. fn survives(text: &str) -> Vec { let contacts = parse(text); let again = write(&contacts.iter().collect::>()); let _ = parse(&again); contacts } proptest! { #[test] fn any_contact_round_trips(contacts in proptest::collection::vec(contact(), 0..4)) { let back = round_trip(&contacts); // A contact with nothing in it isn't written back as one. let want: Vec = contacts.iter().map(as_read).filter(|c| *c != Contact::default()).collect(); prop_assert_eq!(back, want); } #[test] fn any_notes_and_names_round_trip(notes in "(\\PC|[\n\t]){0,400}", name in "\\PC{0,200}", street in "\\PC{0,100}") { let name = name.trim().to_string(); let street = street.trim().to_string(); let c = Contact { display_name: name.clone(), last: name.clone(), company: name.clone(), notes, addresses: vec![PostalAddress { street, city: "Riverton".into(), ..Default::default() }], uid: "u".into(), ..Default::default() }; prop_assert_eq!(round_trip(std::slice::from_ref(&c)), vec![as_read(&c)]); } #[test] fn text_with_control_characters_reads_back_clean_and_stable(name in any::(), notes in any::(), label in any::(), value in any::(), category in any::()) { let c = Contact { display_name: name.clone(), first: name, notes, emails: vec![Labeled::new(label.clone(), value.clone())], phones: vec![Labeled::new(label.clone(), value.clone())], addresses: vec![PostalAddress { label, street: value.clone(), ..Default::default() }], websites: vec![value], categories: vec![category], uid: "u".into(), ..Default::default() }; let once = round_trip(std::slice::from_ref(&c)); prop_assert_eq!(once.len(), 1); // The first pass cleans (control characters, stray spaces); after that nothing changes but a // display name that was empty. prop_assert_eq!(round_trip(&once), once.iter().map(as_read).collect::>()); prop_assert!(!once[0].display_name.contains(['\r', '\n']) && !once[0].notes.contains('\r')); } #[test] fn arbitrary_text_never_panics(text in any::()) { survives(&text); } #[test] fn arbitrary_bytes_never_panic(bytes in proptest::collection::vec(any::(), 0..2048)) { let contacts = crate::parse_bytes(&bytes); let _ = parse(&write(&contacts.iter().collect::>())); } #[test] fn card_shaped_bytes_never_panic(text in soup(), high in proptest::collection::vec((any::(), 0x80u8..=0xFF), 0..12), charset in proptest::sample::select(vec!["", "windows-1250", "UTF-8", "utf-16", "iso-2022-jp", "shift_jis", "x-unknown"])) { // Card-shaped text with a charset named and raw 8-bit bytes dropped in. let mut bytes = text.replace("FN:", &format!("FN;CHARSET={charset}:")).into_bytes(); for (at, byte) in high { if !bytes.is_empty() { let i = at.index(bytes.len()); bytes.insert(i, byte); } } let _ = crate::parse_bytes(&bytes); } #[test] fn utf8_bytes_read_as_the_text_does(text in soup()) { // (A value in UTF-8 that says it is Latin-1 is read as Latin-1 from bytes.) let text = text.replace("ISO-8859-1", "UTF-8"); prop_assert_eq!(crate::parse_bytes(text.as_bytes()), parse(&text)); } #[test] fn card_shaped_junk_never_panics(text in soup()) { survives(&text); } #[test] fn a_damaged_card_never_panics(cuts in proptest::collection::vec((any::(), 0usize..40, 0u8..5, "\\PC{0,8}|[\r\n:;,=\"\\\\ .]{1,4}"), 1..6)) { let mut chars: Vec = valid_text().chars().collect(); for (index, length, kind, junk) in cuts { let from = index.index(chars.len().max(1)).min(chars.len()); let to = from.saturating_add(length).min(chars.len()); match kind { // Cut a piece out, overwrite it, insert junk, double a piece, or stop the text there. 0 => drop(chars.drain(from..to)), 1 => drop(chars.splice(from..to, junk.chars())), 2 => drop(chars.splice(from..from, junk.chars())), 3 => { let piece: Vec = chars[from..to].to_vec(); drop(chars.splice(from..from, piece)); } _ => chars.truncate(from), } } let damaged: String = chars.into_iter().collect(); prop_assert!(survives(&damaged).len() <= 64); } } #[test] fn a_card_cut_anywhere_never_panics() { let text = valid_text(); for (cut, _) in text.char_indices().step_by(5) { survives(&text[..cut]); survives(&text[cut..]); } }