crates/nonstick: src/conv.rs comparison

comparison src/conv.rs @ 74:c7c596e6388f

Make conversations type-safe (last big reorg) (REAL) (NOT CLICKBAIT) In previous versions of Conversation, you could send messages and then return messages of the wrong type or in the wrong order or whatever. The receiver would then have to make sure that there were the right number of messages and that each message was the right type. That's annoying. This change makes the `Message` enum a two-way channel, where the asker puts their question into it, and then the answerer (the conversation) puts the answer in and returns control to the asker. The asker then only has to pull the Answer of the type they wanted out of the message.

author	Paul Fisher <paul@pfish.zone>
date	Fri, 06 Jun 2025 22:21:17 -0400
parents	ac6881304c78
children	e58d24849e82

comparison

equal deleted inserted replaced

-:ac6881304c78
+:c7c596e6388f
 #![allow(dead_code)]
 use crate::constants::Result;
 use crate::ErrorCode;
 use secure_string::SecureString;
-// TODO: In most cases, we should be passing around references to strings
+use std::cell::Cell;
-// or binary data. Right now we don't because that turns type inference and
-// trait definitions/implementations into a HUGE MESS.
-//
-// Ideally, we would be using some kind of `TD: TextData` and `BD: BinaryData`
-// associated types in the various Conversation traits to avoid copying
-// when unnecessary.
 /// The types of message and request that can be sent to a user.
 ///
 /// The data within each enum value is the prompt (or other information)
 /// that will be presented to the user.
-#[derive(Clone, Copy, Debug)]
 pub enum Message<'a> {
-/// Requests information from the user; will be masked when typing.
+MaskedPrompt(&'a MaskedPrompt<'a>),
+Prompt(&'a Prompt<'a>),
+RadioPrompt(&'a RadioPrompt<'a>),
+BinaryPrompt(&'a BinaryPrompt<'a>),
+InfoMsg(&'a InfoMsg<'a>),
+ErrorMsg(&'a ErrorMsg<'a>),
+}
+/// A question-and-answer pair that can be communicated in a [`Conversation`].
+///
+/// The asking side creates a `QAndA`, then converts it to a [`Message`]
+/// and sends it via a [`Conversation`]. The Conversation then retrieves
+/// the answer to the question (if needed) and sets the response.
+/// Once control returns to the asker, the asker gets the answer from this
+/// `QAndA` and uses it however it wants.
+///
+/// For a more detailed explanation of how this works,
+/// see [`Conversation::communicate`].
+pub trait QAndA<'a> {
+/// The type of the content of the question.
+type Question: Copy;
+/// The type of the answer to the question.
+type Answer;
+/// Converts this Q-and-A pair into a [`Message`] for the [`Conversation`].
+fn message(&self) -> Message;
+/// The contents of the question being asked.
 ///
-/// Response: [`MaskedText`](Response::MaskedText)
+/// For instance, this might say `"Username:"` to prompt the user
-MaskedPrompt(&'a str),
+/// for their name.
-/// Requests information from the user; will not be masked.
+fn question(&self) -> Self::Question;
+/// Sets the answer to the question.
 ///
-/// Response: [`Text`](Response::Text)
+/// The [`Conversation`] implementation calls this to set the answer.
-Prompt(&'a str),
+/// The conversation should *always call this function*, even for messages
-/// "Yes/No/Maybe conditionals" (a Linux-PAM extension).
+/// that don't have "an answer" (like error or info messages).
+fn set_answer(&self, answer: Result<Self::Answer>);
+/// Gets the answer to the question.
+fn answer(self) -> Result<Self::Answer>;
+}
+macro_rules! q_and_a {
+($name:ident<'a, Q=$qt:ty, A=$at:ty>, $($doc:literal)*) => {
+$(
+#[doc = $doc]
+)*
+pub struct $name<'a> {
+q: $qt,
+a: Cell<Result<$at>>,
+}
+impl<'a> QAndA<'a> for $name<'a> {
+type Question = $qt;
+type Answer = $at;
+fn question(&self) -> Self::Question {
+self.q
+}
+fn set_answer(&self, answer: Result<Self::Answer>) {
+self.a.set(answer)
+}
+fn answer(self) -> Result<Self::Answer> {
+self.a.into_inner()
+}
+fn message(&self) -> Message {
+Message::$name(self)
+}
+}
+};
+}
+macro_rules! ask {
+($t:ident) => {
+impl<'a> $t<'a> {
+#[doc = concat!("Creates a `", stringify!($t), "` to be sent to the user.")]
+fn ask(question: &'a str) -> Self {
+Self {
+q: question,
+a: Cell::new(Err(ErrorCode::ConversationError)),
+}
+}
+}
+};
+}
+q_and_a!(
+MaskedPrompt<'a, Q=&'a str, A=SecureString>,
+"Asks the user for data and does not echo it back while being entered."
+""
+"In other words, a password entry prompt."
+);
+ask!(MaskedPrompt);
+q_and_a!(
+Prompt<'a, Q=&'a str, A=String>,
+"Asks the user for data."
+""
+"This is the normal \"ask a person a question\" prompt."
+"When the user types, their input will be shown to them."
+"It can be used for things like usernames."
+);
+ask!(Prompt);
+q_and_a!(
+RadioPrompt<'a, Q=&'a str, A=String>,
+"Asks the user for \"radio button\"–style data. (Linux-PAM extension)"
+""
+"This message type is theoretically useful for \"yes/no/maybe\""
+"questions, but nowhere in the documentation is it specified"
+"what the format of the answer will be, or how this should be shown."
+);
+ask!(RadioPrompt);
+q_and_a!(
+BinaryPrompt<'a, Q=BinaryQuestion<'a>, A=BinaryData>,
+"Asks for binary data. (Linux-PAM extension)"
+""
+"This sends a binary message to the client application."
+"It can be used to communicate with non-human logins,"
+"or to enable things like security keys."
+""
+"The `data_type` tag is a value that is simply passed through"
+"to the application. PAM does not define any meaning for it."
+);
+impl<'a> BinaryPrompt<'a> {
+/// Creates a prompt for the given binary data.
 ///
-/// Response: [`Text`](Response::Text)
+/// The `data_type` is a tag you can use for communication between
-/// (Linux-PAM documentation doesn't define its contents.)
+/// the module and the application. Its meaning is undefined by PAM.
-RadioPrompt(&'a str),
+fn ask(data: &'a [u8], data_type: u8) -> Self {
-/// Raises an error message to the user.
+Self {
-///
+q: BinaryQuestion { data, data_type },
-/// Response: [`NoResponse`](Response::NoResponse)
+a: Cell::new(Err(ErrorCode::ConversationError)),
-Error(&'a str),
+}
-/// Sends an informational message to the user.
+}
-///
+}
-/// Response: [`NoResponse`](Response::NoResponse)
-Info(&'a str),
+/// The contents of a question requesting binary data.
-/// Requests binary data from the client (a Linux-PAM extension).
+///
-///
+/// A borrowed version of [`BinaryData`].
-/// This is used for non-human or non-keyboard prompts (security key?).
+#[derive(Copy, Clone, Debug)]
-/// NOT part of the X/Open PAM specification.
+pub struct BinaryQuestion<'a> {
-///
+data: &'a [u8],
-/// Response: [`Binary`](Response::Binary)
+data_type: u8,
-BinaryPrompt {
+}
-/// Some binary data.
-data: &'a [u8],
+impl BinaryQuestion<'_> {
-/// A "type" that you can use for signalling. Has no strict definition in PAM.
+/// Gets the data of this question.
-data_type: u8,
+pub fn data(&self) -> &[u8] {
-},
+self.data
 }
-/// The responses that PAM will return from a request.
+/// Gets the "type" of this data.
-#[derive(Debug, PartialEq, derive_more::From)]
+pub fn data_type(&self) -> u8 {
-pub enum Response {
+self.data_type
-/// Used to fill in list entries where there is no response expected.
+}
-///
+}
-/// Used in response to:
-///
+/// Owned binary data.
-/// - [`Error`](Message::Error)
+///
-/// - [`Info`](Message::Info)
+/// For borrowed data, see [`BinaryQuestion`].
-NoResponse,
+/// You can take ownership of the stored data with `.into::<Vec<u8>>()`.
-/// A response with text data from the user.
+#[derive(Debug, PartialEq)]
-///
+pub struct BinaryData {
-/// Used in response to:
+data: Vec<u8>,
-///
+data_type: u8,
-/// - [`Prompt`](Message::Prompt)
+}
-/// - [`RadioPrompt`](Message::RadioPrompt) (a Linux-PAM extension)
-Text(String),
+impl BinaryData {
-/// A response to a masked request with text data from the user.
+/// Creates a `BinaryData` with the given contents and type.
-///
+pub fn new(data: Vec<u8>, data_type: u8) -> Self {
-/// Used in response to:
+Self { data, data_type }
-///
+}
-/// - [`MaskedPrompt`](Message::MaskedPrompt)
+/// A borrowed view of the data here.
-MaskedText(SecureString),
+pub fn data(&self) -> &[u8] {
-/// A response to a binary request (a Linux-PAM extension).
+&self.data
-///
+}
-/// Used in response to:
+/// The type of the data stored in this.
-///
+pub fn data_type(&self) -> u8 {
-/// - [`BinaryPrompt`](Message::BinaryPrompt)
+self.data_type
-Binary(BinaryData),
+}
 }
-/// The function type for a conversation.
+impl From<BinaryData> for Vec<u8> {
-///
+/// Takes ownership of the data stored herein.
-/// A macro to save typing `FnMut(&[Message]) -> Result<Vec<Response>>`.
+fn from(value: BinaryData) -> Self {
-#[macro_export]
+value.data
-macro_rules! conv_type {
+}
-() => {FnMut(&[Message]) -> Result<Vec<Response>>};
+}
-(impl) => { impl FnMut(&[Message]) -> Result<Vec<Response>> }
+q_and_a!(
+InfoMsg<'a, Q = &'a str, A = ()>,
+"A message containing information to be passed to the user."
+""
+"While this does not have an answer, [`Conversation`] implementations"
+"should still call [`set_answer`][`QAndA::set_answer`] to verify that"
+"the message has been displayed (or actively discarded)."
+);
+impl<'a> InfoMsg<'a> {
+/// Creates an informational message to send to the user.
+fn new(message: &'a str) -> Self {
+Self {
+q: message,
+a: Cell::new(Err(ErrorCode::ConversationError)),
+}
+}
+}
+q_and_a!(
+ErrorMsg<'a, Q = &'a str, A = ()>,
+"An error message to be passed to the user."
+""
+"While this does not have an answer, [`Conversation`] implementations"
+"should still call [`set_answer`][`QAndA::set_answer`] to verify that"
+"the message has been displayed (or actively discarded)."
+);
+impl<'a> ErrorMsg<'a> {
+/// Creates an error message to send to the user.
+fn new(message: &'a str) -> Self {
+Self {
+q: message,
+a: Cell::new(Err(ErrorCode::ConversationError)),
+}
+}
 }
 /// A channel for PAM modules to request information from the user.
 ///
 /// This trait is used by both applications and PAM modules:
 pub trait Conversation {
 /// Sends messages to the user.
 ///
 /// The returned Vec of messages always contains exactly as many entries
 /// as there were messages in the request; one corresponding to each.
-fn converse(&mut self, messages: &[Message]) -> Result<Vec<Response>>;
+///
-}
+/// TODO: write detailed documentation about how to use this.
+fn communicate(&mut self, messages: &[Message]);
-fn conversation_func(func: conv_type!(impl)) -> impl Conversation {
+}
+/// Turns a simple function into a [`Conversation`].
+///
+/// This can be used to wrap a free-floating function for use as a
+/// Conversation:
+///
+/// ```
+/// use nonstick::conv::{Conversation, Message, conversation_func};
+/// mod some_library {
+/// #    use nonstick::Conversation;
+///     pub fn get_auth_data(conv: &mut impl Conversation) { /* ... */ }
+/// }
+///
+/// fn my_terminal_prompt(messages: &[Message]) {
+///     // ...
+/// #    todo!()
+/// }
+///
+/// fn main() {
+///     some_library::get_auth_data(&mut conversation_func(my_terminal_prompt));
+/// }
+/// ```
+pub fn conversation_func(func: impl FnMut(&[Message])) -> impl Conversation {
 Convo(func)
 }
-struct Convo<C: FnMut(&[Message]) -> Result<Vec<Response>>>(C);
+struct Convo<C: FnMut(&[Message])>(C);
-impl<C: FnMut(&[Message]) -> Result<Vec<Response>>> Conversation for Convo<C> {
+impl<C: FnMut(&[Message])> Conversation for Convo<C> {
-fn converse(&mut self, messages: &[Message]) -> Result<Vec<Response>> {
+fn communicate(&mut self, messages: &[Message]) {
 self.0(messages)
 }
 }
-/// Provides methods to make it easier to send exactly one message.
+/// A conversation trait for asking or answering one question at a time.
 ///
-/// This is primarily used by PAM modules, so that a module that only needs
+/// An implementation of this is provided for any [`Conversation`],
-/// one piece of information at a time doesn't have a ton of boilerplate.
+/// or a PAM application can implement this trait and handle messages
-/// You may also find it useful for testing PAM application libraries.
+/// one at a time.
+///
+/// For example, to use a `Conversation` as a `SimpleConversation`:
 ///
 /// ```
-/// # use nonstick::{PamHandleModule, Conversation, Result};
+/// # use nonstick::{Conversation, Result};
-/// # fn _do_test(mut pam_handle: impl PamHandleModule) -> Result<()> {
+/// # use secure_string::SecureString;
-/// use nonstick::ConversationMux;
+/// // Bring this trait into scope to get `masked_prompt`, among others.
-///
+/// use nonstick::SimpleConversation;
-/// let token = pam_handle.masked_prompt("enter your one-time token")?;
+///
-/// # Ok(())
+/// fn ask_for_token(convo: &mut impl Conversation) -> Result<SecureString> {
+///     convo.masked_prompt("enter your one-time token")
+/// }
+/// ```
+///
+/// or to use a `SimpleConversation` as a `Conversation`:
+///
+/// ```
+/// use secure_string::SecureString;
+/// use nonstick::{Conversation, SimpleConversation};
+/// # use nonstick::{BinaryData, Result};
+/// mod some_library {
+/// #    use nonstick::Conversation;
+///     pub fn get_auth_data(conv: &mut impl Conversation) { /* ... */ }
+/// }
+///
+/// struct MySimpleConvo { /* ... */ }
+/// # impl MySimpleConvo { fn new() -> Self { Self{} } }
+///
+/// impl SimpleConversation for MySimpleConvo {
+///     // ...
+/// # fn prompt(&mut self, request: &str) -> Result<String> {
+/// #     todo!()
 /// # }
-pub trait ConversationMux {
+/// #
+/// # fn masked_prompt(&mut self, request: &str) -> Result<SecureString> {
+/// #     todo!()
+/// # }
+/// #
+/// # fn radio_prompt(&mut self, request: &str) -> Result<String> {
+/// #     todo!()
+/// # }
+/// #
+/// # fn error_msg(&mut self, message: &str) {
+/// #     todo!()
+/// # }
+/// #
+/// # fn info_msg(&mut self, message: &str) {
+/// #     todo!()
+/// # }
+/// #
+/// # fn binary_prompt(&mut self, data: &[u8], data_type: u8) -> Result<BinaryData> {
+/// #     todo!()
+/// # }
+/// }
+///
+/// fn main() {
+///     let mut simple = MySimpleConvo::new();
+///     some_library::get_auth_data(&mut simple.as_conversation())
+/// }
+/// ```
+pub trait SimpleConversation {
+/// Lets you use this simple conversation as a full [Conversation].
+///
+/// The wrapper takes each message received in [`Conversation::communicate`]
+/// and passes them one-by-one to the appropriate method,
+/// then collects responses to return.
+fn as_conversation(&mut self) -> Demux<Self>
+where
+Self: Sized,
+{
+Demux(self)
+}
 /// Prompts the user for something.
 fn prompt(&mut self, request: &str) -> Result<String>;
 /// Prompts the user for something, but hides what the user types.
 fn masked_prompt(&mut self, request: &str) -> Result<SecureString>;
 /// Prompts the user for a yes/no/maybe conditional (a Linux-PAM extension).
 ///
 /// PAM documentation doesn't define the format of the response.
 fn radio_prompt(&mut self, request: &str) -> Result<String>;
 /// Alerts the user to an error.
-fn error(&mut self, message: &str);
+fn error_msg(&mut self, message: &str);
 /// Sends an informational message to the user.
-fn info(&mut self, message: &str);
+fn info_msg(&mut self, message: &str);
 /// Requests binary data from the user (a Linux-PAM extension).
 fn binary_prompt(&mut self, data: &[u8], data_type: u8) -> Result<BinaryData>;
 }
-impl<C: Conversation> ConversationMux for C {
+macro_rules! conv_fn {
-/// Prompts the user for something.
+($fn_name:ident($($param:ident: $pt:ty),+) -> $resp_type:ty { $ask:path }) => {
-fn prompt(&mut self, request: &str) -> Result<String> {
+fn $fn_name(&mut self, $($param: $pt),*) -> Result<$resp_type> {
-let resp = self.converse(&[Message::Prompt(request)])?.pop();
+let prompt = $ask($($param),*);
-match resp {
+self.communicate(&[prompt.message()]);
-Some(Response::Text(s)) => Ok(s),
+prompt.answer()
-_ => Err(ErrorCode::ConversationError),
+}
-}
+};
-}
+($fn_name:ident($($param:ident: $pt:ty),+) { $ask:path }) => {
+fn $fn_name(&mut self, $($param: $pt),*) {
-/// Prompts the user for something, but hides what the user types.
+self.communicate(&[$ask($($param),*).message()]);
-fn masked_prompt(&mut self, request: &str) -> Result<SecureString> {
+}
-let resp = self.converse(&[Message::MaskedPrompt(request)])?.pop();
+};
-match resp {
+}
-Some(Response::MaskedText(s)) => Ok(s),
-_ => Err(ErrorCode::ConversationError),
+impl<C: Conversation> SimpleConversation for C {
-}
+conv_fn!(prompt(message: &str) -> String { Prompt::ask });
-}
+conv_fn!(masked_prompt(message: &str) -> SecureString { MaskedPrompt::ask });
+conv_fn!(radio_prompt(message: &str) -> String { RadioPrompt::ask });
-/// Prompts the user for a yes/no/maybe conditional (a Linux-PAM extension).
+conv_fn!(error_msg(message: &str) { ErrorMsg::new });
-///
+conv_fn!(info_msg(message: &str) { InfoMsg::new });
-/// PAM documentation doesn't define the format of the response.
+conv_fn!(binary_prompt(data: &[u8], data_type: u8) -> BinaryData { BinaryPrompt::ask });
-fn radio_prompt(&mut self, request: &str) -> Result<String> {
+}
-let resp = self.converse(&[Message::RadioPrompt(request)])?.pop();
-match resp {
+/// A [`Conversation`] which asks the questions one at a time.
-Some(Response::Text(s)) => Ok(s),
+///
-_ => Err(ErrorCode::ConversationError),
+/// This is automatically created by [`SimpleConversation::as_conversation`].
-}
+pub struct Demux<'a, SC: SimpleConversation>(&'a mut SC);
-}
+impl<SC: SimpleConversation> Conversation for Demux<'_, SC> {
-/// Alerts the user to an error.
+fn communicate(&mut self, messages: &[Message]) {
-fn error(&mut self, message: &str) {
+for msg in messages {
-let _ = self.converse(&[Message::Error(message)]);
+match msg {
-}
+Message::Prompt(prompt) => prompt.set_answer(self.0.prompt(prompt.question())),
+Message::MaskedPrompt(prompt) => {
-/// Sends an informational message to the user.
+prompt.set_answer(self.0.masked_prompt(prompt.question()))
-fn info(&mut self, message: &str) {
+}
-let _ = self.converse(&[Message::Info(message)]);
+Message::RadioPrompt(prompt) => {
-}
+prompt.set_answer(self.0.radio_prompt(prompt.question()))
+}
-/// Requests binary data from the user (a Linux-PAM extension).
+Message::InfoMsg(prompt) => {
-fn binary_prompt(&mut self, data: &[u8], data_type: u8) -> Result<BinaryData> {
+self.0.info_msg(prompt.question());
-let resp = self
+prompt.set_answer(Ok(()))
-.converse(&[Message::BinaryPrompt { data, data_type }])?
+}
-.pop();
+Message::ErrorMsg(prompt) => {
-match resp {
+self.0.error_msg(prompt.question());
-Some(Response::Binary(d)) => Ok(d),
+prompt.set_answer(Ok(()))
-_ => Err(ErrorCode::ConversationError),
+}
-}
+Message::BinaryPrompt(prompt) => {
-}
+let q = prompt.question();
-}
+prompt.set_answer(self.0.binary_prompt(q.data, q.data_type))
+}
-/// Trait that an application can implement if they want to handle messages
+}
-/// one at a time.
+}
-pub trait DemuxedConversation {
-/// Prompts the user for some text.
-fn prompt(&mut self, request: &str) -> Result<String>;
-/// Prompts the user for some text, but hides their typing.
-fn masked_prompt(&mut self, request: &str) -> Result<SecureString>;
-/// Prompts the user for a radio option (a Linux-PAM extension).
-///
-/// The Linux-PAM documentation doesn't give the format of the response.
-fn radio_prompt(&mut self, request: &str) -> Result<String>;
-/// Alerts the user to an error.
-fn error(&mut self, message: &str);
-/// Sends an informational message to the user.
-fn info(&mut self, message: &str);
-/// Requests binary data from the user (a Linux-PAM extension).
-fn binary_prompt(&mut self, data: &[u8], data_type: u8) -> Result<BinaryData>;
-}
-impl<DM> Conversation for DM
-where
-DM: DemuxedConversation,
-{
-fn converse(&mut self, messages: &[Message]) -> Result<Vec<Response>> {
-messages
-.iter()
-.map(|msg| match *msg {
-Message::Prompt(prompt) => self.prompt(prompt).map(Response::from),
-Message::MaskedPrompt(prompt) => self.masked_prompt(prompt).map(Response::from),
-Message::RadioPrompt(prompt) => self.radio_prompt(prompt).map(Response::from),
-Message::Info(message) => {
-self.info(message);
-Ok(Response::NoResponse)
-}
-Message::Error(message) => {
-self.error(message);
-Ok(Response::NoResponse)
-}
-Message::BinaryPrompt { data_type, data } => {
-self.binary_prompt(data, data_type).map(Response::from)
-}
-})
-.collect()
-}
-}
-/// Owned binary data.
-#[derive(Debug, PartialEq)]
-pub struct BinaryData {
-data: Vec<u8>,
-data_type: u8,
-}
-impl BinaryData {
-pub fn new(data: Vec<u8>, data_type: u8) -> Self {
-Self { data, data_type }
-}
-pub fn data(&self) -> &[u8] {
-&self.data
-}
-pub fn data_type(&self) -> u8 {
-self.data_type
-}
-}
-impl From<BinaryData> for Vec<u8> {
-/// Extracts the inner vector from the BinaryData.
-fn from(value: BinaryData) -> Self {
-value.data
 }
 }
 #[cfg(test)]
 mod tests {
-use super::{Conversation, DemuxedConversation, Message, Response, SecureString};
+use super::{
+BinaryPrompt, Conversation, ErrorMsg, InfoMsg, MaskedPrompt, Message, Prompt, QAndA,
+RadioPrompt, Result, SecureString, SimpleConversation,
+};
 use crate::constants::ErrorCode;
+use crate::BinaryData;
 #[test]
 fn test_demux() {
 #[derive(Default)]
 struct DemuxTester {
 error_ran: bool,
 info_ran: bool,
 }
-impl DemuxedConversation for DemuxTester {
+impl SimpleConversation for DemuxTester {
-fn prompt(&mut self, request: &str) -> crate::Result<String> {
+fn prompt(&mut self, request: &str) -> Result<String> {
 match request {
 "what" => Ok("whatwhat".to_owned()),
 "give_err" => Err(ErrorCode::PermissionDenied),
 _ => panic!("unexpected prompt!"),
 }
 }
-fn masked_prompt(&mut self, request: &str) -> crate::Result<SecureString> {
+fn masked_prompt(&mut self, request: &str) -> Result<SecureString> {
 assert_eq!("reveal", request);
 Ok(SecureString::from("my secrets"))
 }
-fn radio_prompt(&mut self, request: &str) -> crate::Result<String> {
+fn radio_prompt(&mut self, request: &str) -> Result<String> {
 assert_eq!("channel?", request);
 Ok("zero".to_owned())
 }
-fn error(&mut self, message: &str) {
+fn error_msg(&mut self, message: &str) {
 self.error_ran = true;
 assert_eq!("whoopsie", message);
 }
-fn info(&mut self, message: &str) {
+fn info_msg(&mut self, message: &str) {
 self.info_ran = true;
 assert_eq!("did you know", message);
 }
-fn binary_prompt(
+fn binary_prompt(&mut self, data: &[u8], data_type: u8) -> Result<BinaryData> {
-&mut self,
-data: &[u8],
-data_type: u8,
-) -> crate::Result<super::BinaryData> {
 assert_eq!(&[10, 9, 8], data);
 assert_eq!(66, data_type);
-Ok(super::BinaryData::new(vec![5, 5, 5], 5))
+Ok(BinaryData::new(vec![5, 5, 5], 5))
 }
 }
 let mut tester = DemuxTester::default();
-assert_eq!(
+let what = Prompt::ask("what");
-vec![
+let pass = MaskedPrompt::ask("reveal");
-Response::Text("whatwhat".to_owned()),
+let err = ErrorMsg::new("whoopsie");
-Response::MaskedText("my secrets".into()),
+let info = InfoMsg::new("did you know");
-Response::NoResponse,
+let has_err = Prompt::ask("give_err");
-Response::NoResponse,
-],
+let mut conv = tester.as_conversation();
-tester
-.converse(&[
+// Basic tests.
-Message::Prompt("what"),
-Message::MaskedPrompt("reveal"),
+conv.communicate(&[
-Message::Error("whoopsie"),
+what.message(),
-Message::Info("did you know"),
+pass.message(),
-])
+err.message(),
-.unwrap()
+info.message(),
-);
+has_err.message(),
+]);
+assert_eq!("whatwhat", what.answer().unwrap());
+assert_eq!(SecureString::from("my secrets"), pass.answer().unwrap());
+assert_eq!(Ok(()), err.answer());
+assert_eq!(Ok(()), info.answer());
+assert_eq!(ErrorCode::PermissionDenied, has_err.answer().unwrap_err());
 assert!(tester.error_ran);
 assert!(tester.info_ran);
-assert_eq!(
+// Test the Linux extensions separately.
-ErrorCode::PermissionDenied,
-tester.converse(&[Message::Prompt("give_err")]).unwrap_err(),
+let mut conv = tester.as_conversation();
-);
+let radio = RadioPrompt::ask("channel?");
-// Test the Linux-PAM extensions separately.
+let bin = BinaryPrompt::ask(&[10, 9, 8], 66);
+conv.communicate(&[radio.message(), bin.message()]);
-assert_eq!(
-vec![
+assert_eq!("zero", radio.answer().unwrap());
-Response::Text("zero".to_owned()),
+assert_eq!(BinaryData::new(vec![5, 5, 5], 5), bin.answer().unwrap());
-Response::Binary(super::BinaryData::new(vec![5, 5, 5], 5)),
+}
-],
-tester
-.converse(&[
-Message::RadioPrompt("channel?"),
-Message::BinaryPrompt {
-data: &[10, 9, 8],
-data_type: 66
-},
-])
-.unwrap()
-);
-}
-#[test]
 fn test_mux() {
-use super::ConversationMux;
 struct MuxTester;
 impl Conversation for MuxTester {
-fn converse(&mut self, messages: &[Message]) -> crate::Result<Vec<Response>> {
+fn communicate(&mut self, messages: &[Message]) {
 if let [msg] = messages {
-match msg {
+match *msg {
-Message::Info(info) => {
+Message::InfoMsg(info) => {
-assert_eq!("let me tell you", *info);
+assert_eq!("let me tell you", info.question());
-Ok(vec![Response::NoResponse])
+info.set_answer(Ok(()))
 }
-Message::Error(error) => {
+Message::ErrorMsg(error) => {
-assert_eq!("oh no", *error);
+assert_eq!("oh no", error.question());
-Ok(vec![Response::NoResponse])
+error.set_answer(Ok(()))
 }
-Message::Prompt("should_error") => Err(ErrorCode::BufferError),
+Message::Prompt(prompt) => prompt.set_answer(match prompt.question() {
-Message::Prompt(ask) => {
+"should_err" => Err(ErrorCode::PermissionDenied),
-assert_eq!("question", *ask);
+"question" => Ok("answer".to_owned()),
-Ok(vec![Response::Text("answer".to_owned())])
+other => panic!("unexpected question {other:?}"),
+}),
+Message::MaskedPrompt(ask) => {
+assert_eq!("password!", ask.question());
+ask.set_answer(Ok("open sesame".into()))
 }
-Message::MaskedPrompt("return_wrong_type") => {
+Message::BinaryPrompt(prompt) => {
-Ok(vec![Response::NoResponse])
+assert_eq!(&[1, 2, 3], prompt.question().data);
-}
+assert_eq!(69, prompt.question().data_type);
-Message::MaskedPrompt(ask) => {
+prompt.set_answer(Ok(BinaryData::new(vec![3, 2, 1], 42)))
-assert_eq!("password!", *ask);
-Ok(vec![Response::MaskedText(SecureString::from(
-"open sesame",
-))])
-}
-Message::BinaryPrompt { data, data_type } => {
-assert_eq!(&[1, 2, 3], data);
-assert_eq!(69, *data_type);
-Ok(vec![Response::Binary(super::BinaryData::new(
-vec![3, 2, 1],
-42,
-))])
 }
 Message::RadioPrompt(ask) => {
-assert_eq!("radio?", *ask);
+assert_eq!("radio?", ask.question());
-Ok(vec![Response::Text("yes".to_owned())])
+ask.set_answer(Ok("yes".to_owned()))
 }
 }
 } else {
-panic!("messages is the wrong size ({len})", len = messages.len())
+panic!(
+"there should only be one message, not {len}",
+len = messages.len()
+)
 }
 }
 }
 let mut tester = MuxTester;
 assert_eq!("answer", tester.prompt("question").unwrap());
 assert_eq!(
 SecureString::from("open sesame"),
 tester.masked_prompt("password!").unwrap()
 );
-tester.error("oh no");
+tester.error_msg("oh no");
-tester.info("let me tell you");
+tester.info_msg("let me tell you");
 {
 assert_eq!("yes", tester.radio_prompt("radio?").unwrap());
 assert_eq!(
-super::BinaryData::new(vec![3, 2, 1], 42),
+BinaryData::new(vec![3, 2, 1], 42),
 tester.binary_prompt(&[1, 2, 3], 69).unwrap(),
 )
 }
 assert_eq!(
 ErrorCode::BufferError,

Mercurial > crates > nonstick

comparison src/conv.rs @ 74:c7c596e6388f