use crate::types::{Content, Mime, Sensitivity, PASSWORD_HINT};
pub fn select_mime(mimes: &[Mime]) -> Option<Mime> {
if let Some(image) = mimes.iter().find(|m| m.is_image()) {
return Some(image.clone());
}
const TEXT_PREFERENCE: [&str; 2] = ["text/plain;charset=utf-8", "text/plain"];
TEXT_PREFERENCE.iter().find_map(|wanted| {
mimes
.iter()
.find(|m| m.as_str().eq_ignore_ascii_case(wanted))
.cloned()
})
}
pub fn resolve_offer(
mimes: &[Mime],
mut receive_mime: impl FnMut(&Mime) -> Option<Vec<u8>>,
) -> Option<Content> {
let advertises_hint = mimes.iter().any(|m| m.as_str() == PASSWORD_HINT);
let hint_value: Option<String> = if advertises_hint {
receive_mime(&Mime::new(PASSWORD_HINT))
.map(|bytes| String::from_utf8_lossy(&bytes).trim().to_string())
} else {
None
};
if Sensitivity::classify(mimes, hint_value.as_deref()).is_secret() {
return None;
}
let chosen = select_mime(mimes)?;
let bytes = receive_mime(&chosen)?;
let content = if chosen.is_image() {
Content::Image {
bytes,
mime: chosen,
}
} else {
Content::Text(String::from_utf8_lossy(&bytes).into_owned())
};
if content.is_empty() {
return None;
}
Some(content)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::types::PASSWORD_HINT_SECRET;
use std::cell::RefCell;
fn mimes(list: &[&str]) -> Vec<Mime> {
list.iter().map(|m| Mime::new(*m)).collect()
}
#[test]
fn selection_prefers_an_image_over_any_text() {
let picked = select_mime(&mimes(&["text/plain", "text/html", "image/png"]));
assert_eq!(picked, Some(Mime::new("image/png")));
}
#[test]
fn selection_prefers_utf8_text_over_plain_text() {
let picked = select_mime(&mimes(&["text/plain", "text/plain;charset=utf-8"]));
assert_eq!(picked, Some(Mime::new("text/plain;charset=utf-8")));
}
#[test]
fn selection_never_prefers_html_over_plain_text() {
let picked = select_mime(&mimes(&["text/html", "text/plain"]));
assert_eq!(picked, Some(Mime::new("text/plain")));
}
#[test]
fn an_offer_of_only_html_has_no_usable_type() {
assert_eq!(select_mime(&mimes(&["text/html"])), None);
}
#[test]
fn an_offer_with_no_types_at_all_has_no_usable_type() {
assert_eq!(select_mime(&[]), None);
}
#[test]
fn a_secret_offer_is_never_read_for_content_only_for_its_hint() {
let offer = mimes(&["text/plain", PASSWORD_HINT]);
let read_log = RefCell::new(Vec::new());
let result = resolve_offer(&offer, |mime| {
read_log.borrow_mut().push(mime.clone());
Some(PASSWORD_HINT_SECRET.as_bytes().to_vec())
});
assert_eq!(result, None, "a secret offer must never be recorded");
assert_eq!(
read_log.into_inner(),
vec![Mime::new(PASSWORD_HINT)],
"the only read a secret offer may cause is the hint's own value"
);
}
#[test]
fn a_hint_that_cannot_be_read_still_blocks_every_further_read() {
let offer = mimes(&["text/plain", PASSWORD_HINT]);
let read_log = RefCell::new(Vec::new());
let result = resolve_offer(&offer, |mime| {
read_log.borrow_mut().push(mime.clone());
None });
assert_eq!(result, None);
assert_eq!(read_log.into_inner(), vec![Mime::new(PASSWORD_HINT)]);
}
#[test]
fn an_ordinary_offer_reads_only_its_chosen_type() {
let offer = mimes(&["text/html", "text/plain"]);
let read_log = RefCell::new(Vec::new());
let result = resolve_offer(&offer, |mime| {
read_log.borrow_mut().push(mime.clone());
Some(b"hello".to_vec())
});
assert_eq!(result, Some(Content::Text("hello".to_string())));
assert_eq!(read_log.into_inner(), vec![Mime::new("text/plain")]);
}
#[test]
fn an_offer_with_no_usable_type_is_skipped_and_never_read() {
let offer = mimes(&["text/html", "application/x-something-weird"]);
let read_log = RefCell::new(Vec::new());
let result = resolve_offer(&offer, |mime| {
read_log.borrow_mut().push(mime.clone());
Some(b"whatever".to_vec())
});
assert_eq!(result, None);
assert!(read_log.into_inner().is_empty());
}
#[test]
fn a_blank_read_is_skipped_rather_than_stored() {
let offer = mimes(&["text/plain"]);
let result = resolve_offer(&offer, |_| Some(b" \n\t".to_vec()));
assert_eq!(result, None);
}
#[test]
fn a_hint_present_with_a_benign_value_still_records() {
let offer = mimes(&["text/plain", PASSWORD_HINT]);
let result = resolve_offer(&offer, |mime| {
if mime.as_str() == PASSWORD_HINT {
Some(b"not-secret".to_vec())
} else {
Some(b"hello".to_vec())
}
});
assert_eq!(result, Some(Content::Text("hello".to_string())));
}
#[test]
fn an_image_offer_is_kept_as_image_content() {
let offer = mimes(&["text/plain", "image/png"]);
let result = resolve_offer(&offer, |mime| {
if mime.is_image() {
Some(vec![1, 2, 3])
} else {
Some(b"text".to_vec())
}
});
assert_eq!(
result,
Some(Content::Image {
bytes: vec![1, 2, 3],
mime: Mime::new("image/png")
})
);
}
}