| // Copyright 2022 The Fuchsia Authors. All rights reserved. | |
| // Use of this source code is governed by a BSD-style license that can be | |
| // found in the LICENSE file. | |
| use anyhow::{Result, bail, format_err}; | |
| use argh::FromArgs; | |
| use serde::Deserialize; | |
| use serde::de::DeserializeOwned; | |
| use std::fs::{File, OpenOptions}; | |
| use std::io::{BufRead, BufReader, Read, Write, stdin, stdout}; | |
| use std::path::PathBuf; | |
| use std::process::Command; | |
| #[derive(FromArgs, Debug, Default, PartialEq)] | |
| #[argh( | |
| description = "Creates a new RFC prepopulated with common fields. | |
| The command attempts to auto-populate the author sections from your git configuration.", | |
| example = "To create a new RFC run the following command and enter the requested information. | |
| You can also use options to provide values for parameters that you don't wish to provide | |
| interactively. | |
| ``` | |
| $ fx rfc --title 'Back to the Fuchsia' | |
| Description: Fuchsia is a modern OS | |
| ... | |
| Area(s): 1, 2 | |
| Issues: 123, 456 | |
| Reviewers: foo@google.com, bar@google.com | |
| ``` | |
| Your RFC markdown file and its metadata are added to //docs/contribute/governance/rfcs/", | |
| note = "To learn more about writing RFCs, see | |
| https://fuchsia.dev/fuchsia-src/contribute/governance/rfcs" | |
| )] | |
| pub struct CreateRfcArgs { | |
| /// title to use for the RFC. | |
| #[argh(option)] | |
| pub title: Option<String>, | |
| /// short description to use for the RFC. | |
| #[argh(option)] | |
| pub short_description: Option<String>, | |
| /// emails of the RFC authors. | |
| #[argh(option, long = "author")] | |
| pub authors: Vec<String>, | |
| /// areas of the RFC. | |
| #[argh(option, long = "area")] | |
| pub areas: Vec<String>, | |
| /// monorail issues associated with the RFC. | |
| #[argh(option, long = "issue")] | |
| pub issues: Vec<String>, | |
| /// emails of the anticipated RFC reviewers. | |
| #[argh(option, long = "reviewer")] | |
| pub reviewers: Vec<String>, | |
| } | |
| const AREAS_FILE: &str = "_rfc_areas.yaml"; | |
| const FX_RFC_GENERATED: &str = "<!-- Generated with `fx rfc` -->"; | |
| const META_FILE: &str = "_rfcs.yaml"; | |
| const RFC_NAME_PLACEHOLDER: &str = "RFC-0000"; | |
| const RFCS_PATH: &str = "docs/contribute/governance/rfcs"; | |
| const STATUS_PLACEHOLDER: &str = "Pending"; | |
| const TEMPLATE_FILE: &str = "TEMPLATE.md"; | |
| const TOC_FILE: &str = "_toc.yaml"; | |
| const TODO_COMMENT: &str = "# TODO: DO NOT SUBMIT, update."; | |
| fn main() -> Result<(), anyhow::Error> { | |
| let args: CreateRfcArgs = argh::from_env(); | |
| let handle = stdin().lock(); | |
| let cwd = std::env::current_dir()?; | |
| let author_email_provider = GitConfig::new(); | |
| rfc_impl( | |
| CommandLine { args, writer: &mut stdout(), reader: handle, author_email_provider }, | |
| cwd, | |
| ) | |
| } | |
| fn rfc_impl<A, R, W>(mut cli: CommandLine<'_, A, R, W>, cwd: PathBuf) -> Result<()> | |
| where | |
| A: AuthorEmailProvider, | |
| R: BufRead, | |
| W: Write, | |
| { | |
| let fuchsia_dir_root = get_fuchsia_dir_root(cwd)?.ok_or_else(|| { | |
| format_err!("This command must be run from within the Fuchsia Platform Source Tree") | |
| })?; | |
| let rfcs_dir = fuchsia_dir_root.join(RFCS_PATH); | |
| let title = cli.get_title()?; | |
| let short_description = cli.get_short_description()?; | |
| let authors = cli.get_authors()?; | |
| let valid_areas = load_yaml::<Vec<String>>(rfcs_dir.join(AREAS_FILE))?; | |
| let area = cli.get_areas(valid_areas)?; | |
| let issue = cli.get_issues()?; | |
| let reviewers = cli.get_reviewers()?; | |
| let file = filename_from_title(&title); | |
| let toc_meta = TocMetadata { | |
| title: format!("{}: {}", RFC_NAME_PLACEHOLDER, title), | |
| path: format!("/{}/{}", RFCS_PATH, file), | |
| }; | |
| let mut rfc_meta = RfcMetadata { | |
| name: RFC_NAME_PLACEHOLDER.to_string(), | |
| title, | |
| short_description, | |
| authors, | |
| file, | |
| area, | |
| issue, | |
| reviewers, | |
| status: STATUS_PLACEHOLDER.to_string(), | |
| gerrit_change_id: vec![], | |
| submitted: String::new(), | |
| reviewed: String::new(), | |
| }; | |
| rfc_meta.sort(); | |
| create_rfc(&rfc_meta, &rfcs_dir)?; | |
| append_rfc_meta(rfc_meta, rfcs_dir.join(META_FILE))?; | |
| append_rfc_meta(toc_meta, rfcs_dir.join(TOC_FILE))?; | |
| Ok(()) | |
| } | |
| struct CommandLine<'a, A, R, W> { | |
| args: CreateRfcArgs, | |
| author_email_provider: A, | |
| reader: R, | |
| writer: &'a mut W, | |
| } | |
| impl<'a, A, R, W> CommandLine<'a, A, R, W> | |
| where | |
| W: Write, | |
| R: BufRead, | |
| A: AuthorEmailProvider, | |
| { | |
| pub fn get_title(&mut self) -> Result<String> { | |
| match &self.args.title { | |
| Some(title) => Ok(title.clone()), | |
| None => self.prompt("Title"), | |
| } | |
| } | |
| pub fn get_short_description(&mut self) -> Result<String> { | |
| match &self.args.short_description { | |
| Some(description) => Ok(description.clone()), | |
| None => self.prompt("Short description"), | |
| } | |
| } | |
| pub fn get_authors(&mut self) -> Result<Vec<String>> { | |
| let default_author = self.author_email_provider.get_email().ok(); | |
| let mut authors = self.strings_or_prompt( | |
| self.args.authors.clone(), | |
| format!( | |
| "Authors (comma-separated){}", | |
| default_author.as_ref().map(|a| format!(" [default: {}]", a)).unwrap_or_default() | |
| ), | |
| )?; | |
| if authors.is_empty() && default_author.is_some() { | |
| authors.push(default_author.unwrap()); | |
| } | |
| Ok(authors) | |
| } | |
| pub fn get_areas(&mut self, valid_areas: Vec<String>) -> Result<Vec<String>> { | |
| if self.args.areas.is_empty() { | |
| return self.request_areas(valid_areas); | |
| } | |
| let args_areas_len = self.args.areas.len(); | |
| let input_areas = | |
| self.args.areas.clone().into_iter().map(|a| a.to_lowercase()).collect::<Vec<_>>(); | |
| let areas_found = valid_areas | |
| .iter() | |
| .filter(|a| input_areas.contains(&a.to_lowercase())) | |
| .cloned() | |
| .collect::<Vec<_>>(); | |
| if areas_found.len() == args_areas_len { | |
| Ok(areas_found) | |
| } else { | |
| self.println("Invalid areas provided. Please select valid ones.")?; | |
| self.request_areas(valid_areas) | |
| } | |
| } | |
| pub fn get_issues(&mut self) -> Result<Vec<String>> { | |
| self.strings_or_prompt(self.args.issues.clone(), "Monorail issue (comma-separated)") | |
| } | |
| pub fn get_reviewers(&mut self) -> Result<Vec<String>> { | |
| self.strings_or_prompt(self.args.reviewers.clone(), "Reviewers (comma-separated emails)") | |
| } | |
| fn strings_or_prompt( | |
| &mut self, | |
| list: Vec<String>, | |
| prompt: impl AsRef<str>, | |
| ) -> Result<Vec<String>> { | |
| if list.is_empty() { | |
| let input = self.prompt(prompt)?; | |
| if input.trim().is_empty() { | |
| return Ok(vec![]); | |
| } | |
| Ok(string_list(input)) | |
| } else { | |
| Ok(list) | |
| } | |
| } | |
| fn request_areas(&mut self, valid_areas: Vec<String>) -> Result<Vec<String>> { | |
| for (i, area) in valid_areas.iter().enumerate() { | |
| self.println(format!("[{:>2}] {}", i, area))?; | |
| } | |
| let areas = | |
| areas_from_numbers(valid_areas, self.prompt("Area (comma-separated numbers)")?)?; | |
| Ok(areas) | |
| } | |
| fn prompt(&mut self, text: impl AsRef<str>) -> Result<String> { | |
| write!(&mut self.writer, "{}: ", text.as_ref())?; | |
| self.writer.flush().unwrap(); | |
| let mut line = String::new(); | |
| self.reader.read_line(&mut line)?; | |
| Ok(line.trim().to_string()) | |
| } | |
| fn println(&mut self, text: impl AsRef<str>) -> Result<()> { | |
| writeln!(&mut self.writer, "{}", text.as_ref())?; | |
| Ok(()) | |
| } | |
| } | |
| // Note: not using serde_yaml since we have a bit of a special formatting for arrays. It doesn't | |
| // seem that serde_yaml supports formatting arrays as `[]` like we do in our YAML files. Using | |
| // serde_yaml would require updating the format of our YAML files, in particular _rfcs.yaml. | |
| trait AppendYaml { | |
| fn append_yaml(&self, w: impl Write) -> Result<()>; | |
| } | |
| struct RfcMetadata { | |
| name: String, | |
| title: String, | |
| short_description: String, | |
| authors: Vec<String>, | |
| file: String, | |
| area: Vec<String>, | |
| issue: Vec<String>, | |
| gerrit_change_id: Vec<String>, | |
| status: String, | |
| reviewers: Vec<String>, | |
| submitted: String, | |
| reviewed: String, | |
| } | |
| impl RfcMetadata { | |
| fn sort(&mut self) { | |
| self.authors.sort(); | |
| self.area.sort(); | |
| self.issue.sort(); | |
| self.gerrit_change_id.sort(); | |
| self.reviewers.sort(); | |
| } | |
| } | |
| impl AppendYaml for RfcMetadata { | |
| fn append_yaml(&self, mut w: impl Write) -> Result<()> { | |
| w.write_all(b"\n")?; | |
| write_one(&mut w, 0, "- name", &self.name, "'", true)?; | |
| write_one(&mut w, 2, "title", &self.title, "'", self.title.is_empty())?; | |
| write_one( | |
| &mut w, | |
| 2, | |
| "short_description", | |
| &self.short_description, | |
| "'", | |
| self.short_description.is_empty(), | |
| )?; | |
| write_list(&mut w, 2, "authors", &self.authors)?; | |
| write_one(&mut w, 2, "file", &self.file, "'", false)?; | |
| write_list(&mut w, 2, "area", &self.area)?; | |
| write_list(&mut w, 2, "issue", &self.issue)?; | |
| write_list(&mut w, 2, "gerrit_change_id", &self.gerrit_change_id)?; | |
| write_one(&mut w, 2, "status", &self.status, "'", true)?; | |
| write_list(&mut w, 2, "reviewers", &self.reviewers)?; | |
| write_one(&mut w, 2, "submitted", &self.submitted, "'", true)?; | |
| write_one(&mut w, 2, "reviewed", &self.reviewed, "'", true)?; | |
| Ok(()) | |
| } | |
| } | |
| #[derive(Deserialize)] | |
| struct TocMetadata { | |
| title: String, | |
| path: String, | |
| } | |
| impl AppendYaml for TocMetadata { | |
| fn append_yaml(&self, mut w: impl Write) -> Result<()> { | |
| write_one(&mut w, 2, "- title", &self.title, "\"", true)?; | |
| write_one(&mut w, 4, "path", &self.path, "", true)?; | |
| Ok(()) | |
| } | |
| } | |
| trait AuthorEmailProvider { | |
| fn get_email(&self) -> Result<String>; | |
| } | |
| struct GitConfig {} | |
| impl GitConfig { | |
| fn new() -> Self { | |
| Self {} | |
| } | |
| } | |
| impl AuthorEmailProvider for GitConfig { | |
| fn get_email(&self) -> Result<String> { | |
| let result = Command::new("sh").arg("-c").arg("git config --get user.email").output()?; | |
| Ok(String::from_utf8(result.stdout)?.trim().to_string()) | |
| } | |
| } | |
| fn write_one<T, W>( | |
| w: &mut W, | |
| spaces: usize, | |
| prefix: &str, | |
| value: T, | |
| quote_char: &str, | |
| comment: bool, | |
| ) -> Result<()> | |
| where | |
| W: Write, | |
| T: std::fmt::Display, | |
| { | |
| write!(w, "{}{}: {}{}{}", " ".repeat(spaces), prefix, quote_char, value, quote_char)?; | |
| if comment { | |
| writeln!(w, " {}", TODO_COMMENT)?; | |
| } else { | |
| write!(w, "\n")?; | |
| } | |
| Ok(()) | |
| } | |
| fn write_list<T, W>(w: &mut W, spaces: usize, prefix: &str, list: &[T]) -> Result<()> | |
| where | |
| W: Write, | |
| T: std::fmt::Display, | |
| { | |
| write!(w, "{}{}: [", " ".repeat(spaces), prefix)?; | |
| for (i, item) in list.iter().enumerate() { | |
| write!(w, "'{}'", item)?; | |
| if i < list.len() - 1 { | |
| write!(w, ", ")?; | |
| } | |
| } | |
| if list.is_empty() { | |
| writeln!(w, "''] {}", TODO_COMMENT)?; | |
| } else { | |
| writeln!(w, "]")?; | |
| } | |
| Ok(()) | |
| } | |
| fn filename_from_title(title: &str) -> String { | |
| let filename = format!( | |
| "0000_{}.md", | |
| title.to_lowercase().split(' ').map(|s| s.trim()).collect::<Vec<_>>().join("_"), | |
| ); | |
| filename.replace(std::path::is_separator, "_") | |
| } | |
| fn areas_from_numbers(valid_areas: Vec<String>, input_numbers: String) -> Result<Vec<String>> { | |
| let indexes = input_numbers | |
| .split(',') | |
| .map(|s| s.trim().parse::<usize>()) | |
| .collect::<Result<Vec<usize>, _>>() | |
| .map_err(|_| format_err!("Invalid area index found"))?; | |
| if !indexes.iter().all(|i| *i < valid_areas.len()) { | |
| bail!("Invalid area indexes"); | |
| } | |
| Ok(indexes.into_iter().map(|i| valid_areas[i].clone()).collect()) | |
| } | |
| fn string_list(input_authors: String) -> Vec<String> { | |
| input_authors.split(',').map(|s| s.trim().to_string()).collect() | |
| } | |
| fn get_fuchsia_dir_root(current_dir: PathBuf) -> Result<Option<PathBuf>> { | |
| let mut current_dir = current_dir; | |
| loop { | |
| let fx_root_path = current_dir.join(".fx-root"); | |
| if fx_root_path.is_file() { | |
| return Ok(Some(current_dir)); | |
| } | |
| if !current_dir.pop() { | |
| break; | |
| } | |
| } | |
| Ok(None) | |
| } | |
| fn load_yaml<T>(path: PathBuf) -> Result<T> | |
| where | |
| T: DeserializeOwned, | |
| { | |
| let file = File::open(path)?; | |
| let reader = BufReader::new(file); | |
| Ok(serde_yaml::from_reader(reader).expect("can read yaml")) | |
| } | |
| fn append_rfc_meta<T>(data: T, path: PathBuf) -> Result<()> | |
| where | |
| T: AppendYaml, | |
| { | |
| let file = OpenOptions::new().write(true).append(true).open(path)?; | |
| data.append_yaml(file)?; | |
| Ok(()) | |
| } | |
| fn create_rfc(meta: &RfcMetadata, path: &PathBuf) -> Result<()> { | |
| let mut template_file = File::open(path.join(TEMPLATE_FILE))?; | |
| let mut template = String::new(); | |
| template_file.read_to_string(&mut template)?; | |
| let template = template.replace("<!--\n// LINT.IfChange\n-->\n", ""); | |
| let template = template | |
| .replace("<!--\n// LINT.ThenChange(//tools/rfc/test_data/rfc.golden.md)\n-->\n", ""); | |
| let template = template.replace( | |
| r#"{% set rfcid = "RFC-0000" %}"#, | |
| r#"{% set rfcid = "RFC-0000" %} <!-- TODO: DO NOT SUBMIT, update number -->"#, | |
| ); | |
| let reviewers = | |
| meta.reviewers.iter().map(|r| format!("- {}", r)).collect::<Vec<_>>().join("\n"); | |
| let reviewers_index = template.find("_Reviewers:_").unwrap(); | |
| let consulted_index = template.find("_Consulted:_").unwrap(); | |
| let template = format!( | |
| "{}\n{}_Reviewers:_\n\n{}\n\n{}", | |
| FX_RFC_GENERATED, | |
| &template[..reviewers_index], | |
| reviewers, | |
| &template[consulted_index..] | |
| ); | |
| let mut rfc_file = File::create(path.join(&meta.file))?; | |
| rfc_file.write_all(template.as_bytes())?; | |
| Ok(()) | |
| } | |
| #[cfg(test)] | |
| mod test { | |
| use super::*; | |
| use pretty_assertions::assert_eq; | |
| use std::fs; | |
| use tempfile::{TempDir, tempdir}; | |
| const CMD_NAME: &'static [&'static str] = &["rfc"]; | |
| struct FakeEmailProvider {} | |
| impl AuthorEmailProvider for FakeEmailProvider { | |
| fn get_email(&self) -> Result<String> { | |
| Ok("fuchsia-hacker@google.com".to_string()) | |
| } | |
| } | |
| struct FakeDir { | |
| root: TempDir, | |
| rfcs_path: PathBuf, | |
| } | |
| impl FakeDir { | |
| pub fn new() -> Self { | |
| let root = tempdir().expect("create tempdir"); | |
| let rfcs_path = root.path().join(RFCS_PATH); | |
| fs::create_dir_all(&rfcs_path).expect("create root"); | |
| File::create(root.path().join(".fx-root")).expect("create .fx-root"); | |
| init_file(rfcs_path.join(META_FILE), include_str!("../test_data/rfcs.before.yaml")); | |
| init_file(rfcs_path.join(TOC_FILE), include_str!("../test_data/toc.before.yaml")); | |
| init_file(rfcs_path.join(AREAS_FILE), include_str!("../test_data/areas.yaml")); | |
| init_file( | |
| rfcs_path.join(TEMPLATE_FILE), | |
| include_str!("../../../docs/contribute/governance/rfcs/TEMPLATE.md"), | |
| ); | |
| Self { root, rfcs_path } | |
| } | |
| pub fn some_path(&self) -> PathBuf { | |
| let path = self.root.path().join("some/path"); | |
| fs::create_dir_all(&path).expect("create some path"); | |
| path | |
| } | |
| pub fn rfc_file_exists(&self, file: &str) -> bool { | |
| self.rfcs_path.join(file).exists() | |
| } | |
| pub fn validate_rfcs_file(&self, file: &str, expected: &str) { | |
| let path = self.rfcs_path.join(file); | |
| let mut file = | |
| File::open(&path).unwrap_or_else(|e| panic!("open: {}: {:?}", path.display(), e)); | |
| let mut contents = String::new(); | |
| file.read_to_string(&mut contents) | |
| .unwrap_or_else(|e| panic!("read file: {}: {:?}", path.display(), e)); | |
| assert_eq!(contents, expected); | |
| } | |
| } | |
| fn init_file(path: PathBuf, contents: &str) { | |
| let mut file = File::create(path).expect("created file"); | |
| file.write_all(contents.as_bytes()).expect("wrote file"); | |
| } | |
| fn full_args() -> CreateRfcArgs { | |
| CreateRfcArgs { | |
| title: Some("Back to the Fuchsia".to_string()), | |
| short_description: Some("Fuchsia is a modern OS".to_string()), | |
| authors: vec!["foo@google.com".to_string(), "bar@google.com".to_string()], | |
| areas: vec!["Pink".to_string()], | |
| issues: vec!["5678".to_string(), "1234".to_string()], | |
| reviewers: vec!["quux@google.com".to_string(), "baz@google.com".to_string()], | |
| } | |
| } | |
| #[test] | |
| fn empty_args() { | |
| assert_eq!(CreateRfcArgs::from_args(CMD_NAME, &[]), Ok(CreateRfcArgs::default())) | |
| } | |
| #[test] | |
| fn args_with_options() { | |
| assert_eq!( | |
| CreateRfcArgs::from_args( | |
| CMD_NAME, | |
| &[ | |
| "--title", | |
| "Back to the Fuchsia", | |
| "--short-description", | |
| "Fuchsia is a modern OS", | |
| "--author", | |
| "foo@google.com", | |
| "--author", | |
| "bar@google.com", | |
| "--area", | |
| "Pink", | |
| "--issue", | |
| "1234", | |
| "--issue", | |
| "5678", | |
| "--reviewer", | |
| "baz@google.com", | |
| ] | |
| ), | |
| Ok(CreateRfcArgs { | |
| title: Some("Back to the Fuchsia".to_string()), | |
| short_description: Some("Fuchsia is a modern OS".to_string()), | |
| authors: vec!["foo@google.com".to_string(), "bar@google.com".to_string(),], | |
| areas: vec!["Pink".to_string(),], | |
| issues: vec!["1234".to_string(), "5678".to_string(),], | |
| reviewers: vec!["baz@google.com".to_string()] | |
| }) | |
| ); | |
| } | |
| #[test] | |
| fn cli_with_all_optional_args() { | |
| let dir = FakeDir::new(); | |
| // When the CLI receives all parameters through arguments, we don't expect any input. | |
| let stdin = b""; | |
| let mut stdout = Vec::<u8>::new(); | |
| let args = full_args(); | |
| rfc_impl( | |
| CommandLine { | |
| args, | |
| writer: &mut stdout, | |
| reader: &stdin[..], | |
| author_email_provider: FakeEmailProvider {}, | |
| }, | |
| // Call this command from somewhere inside the fake fuchsia platform tree. | |
| dir.some_path(), | |
| ) | |
| .expect("succeeds"); | |
| // We don't expect any output when the CLI receives all parameters through arguments. | |
| assert!(stdout.is_empty()); | |
| dir.validate_rfcs_file(META_FILE, include_str!("../test_data/rfcs.golden.yaml")); | |
| dir.validate_rfcs_file(TOC_FILE, include_str!("../test_data/toc.golden.yaml")); | |
| dir.validate_rfcs_file( | |
| "0000_back_to_the_fuchsia.md", | |
| include_str!("../test_data/rfc.golden.md"), | |
| ); | |
| } | |
| #[test] | |
| fn cli_with_no_optional_args() { | |
| let dir = FakeDir::new(); | |
| let stdin = vec![ | |
| "Back to the Fuchsia", | |
| "Fuchsia is a modern OS", | |
| "foo@google.com,bar@google.com", | |
| "1", | |
| "5678, 1234", | |
| "quux@google.com, baz@google.com", | |
| ] | |
| .join("\n") | |
| .into_bytes(); | |
| let mut stdout = Vec::<u8>::new(); | |
| let args = CreateRfcArgs::default(); | |
| rfc_impl( | |
| CommandLine { | |
| args, | |
| writer: &mut stdout, | |
| reader: &stdin[..], | |
| author_email_provider: FakeEmailProvider {}, | |
| }, | |
| dir.root.path().to_path_buf(), | |
| ) | |
| .expect("succeeds"); | |
| assert_eq!( | |
| std::str::from_utf8(&stdout).expect("stdout bytes"), | |
| vec![ | |
| "Title: ", | |
| "Short description: ", | |
| "Authors (comma-separated) [default: fuchsia-hacker@google.com]: ", | |
| "[ 0] Magenta\n[ 1] Pink\n[ 2] Purple\n", | |
| "Area (comma-separated numbers): ", | |
| "Monorail issue (comma-separated): ", | |
| "Reviewers (comma-separated emails): " | |
| ] | |
| .join("") | |
| ); | |
| dir.validate_rfcs_file(META_FILE, include_str!("../test_data/rfcs.golden.yaml")); | |
| dir.validate_rfcs_file(TOC_FILE, include_str!("../test_data/toc.golden.yaml")); | |
| dir.validate_rfcs_file( | |
| "0000_back_to_the_fuchsia.md", | |
| include_str!("../test_data/rfc.golden.md"), | |
| ); | |
| } | |
| #[test] | |
| fn areas_are_validated_from_stdin() { | |
| let stdin = b"2"; | |
| let mut stdout = Vec::<u8>::new(); | |
| let args = CreateRfcArgs::default(); | |
| let mut cli = CommandLine { | |
| args, | |
| writer: &mut stdout, | |
| reader: &stdin[..], | |
| author_email_provider: FakeEmailProvider {}, | |
| }; | |
| assert!(cli.get_areas(vec!["A".to_string(), "B".to_string()]).is_err()); | |
| } | |
| #[test] | |
| fn areas_are_validated_from_args() { | |
| let stdin = b"1"; | |
| let mut stdout = Vec::<u8>::new(); | |
| let mut args = CreateRfcArgs::default(); | |
| args.areas = vec!["C".to_string()]; | |
| let mut cli = CommandLine { | |
| args, | |
| writer: &mut stdout, | |
| reader: &stdin[..], | |
| author_email_provider: FakeEmailProvider {}, | |
| }; | |
| assert_eq!( | |
| cli.get_areas(vec!["A".to_string(), "B".to_string()]).expect("got areas"), | |
| vec!["B".to_string()] | |
| ); | |
| assert_eq!( | |
| std::str::from_utf8(&stdout).expect("valid stdout"), | |
| vec![ | |
| "Invalid areas provided. Please select valid ones.", | |
| "[ 0] A", | |
| "[ 1] B", | |
| "Area (comma-separated numbers): ", | |
| ] | |
| .join("\n") | |
| ); | |
| } | |
| #[test] | |
| fn default_author_is_set_when_no_author_given() { | |
| let stdin = b""; | |
| let mut stdout = Vec::<u8>::new(); | |
| let mut cli = CommandLine { | |
| args: CreateRfcArgs::default(), | |
| writer: &mut stdout, | |
| reader: &stdin[..], | |
| author_email_provider: FakeEmailProvider {}, | |
| }; | |
| assert_eq!( | |
| cli.get_authors().expect("got authors"), | |
| vec!["fuchsia-hacker@google.com".to_string()] | |
| ); | |
| assert_eq!( | |
| std::str::from_utf8(&stdout).expect("valid stdout"), | |
| "Authors (comma-separated) [default: fuchsia-hacker@google.com]: " | |
| ); | |
| } | |
| #[test] | |
| fn accepts_a_title_with_slashes() { | |
| let dir = FakeDir::new(); | |
| let stdin = vec!["Hello/There"].join("\n").into_bytes(); | |
| let mut stdout = Vec::<u8>::new(); | |
| let mut args = full_args(); | |
| args.title = None; | |
| rfc_impl( | |
| CommandLine { | |
| args, | |
| writer: &mut stdout, | |
| reader: &stdin[..], | |
| author_email_provider: FakeEmailProvider {}, | |
| }, | |
| dir.root.path().to_path_buf(), | |
| ) | |
| .expect("succeeds"); | |
| assert_eq!(std::str::from_utf8(&stdout).expect("stdout bytes"), "Title: "); | |
| assert!(dir.rfc_file_exists("0000_hello_there.md")); | |
| } | |
| } |