| // Copyright 2025 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. | |
| // DESIGN | |
| // | |
| // TestConfigBuilder combines input from the command line, environment variables, and JSON files | |
| // to create a single, aggregate test configuration as a generic serde_json::Value tree. The | |
| // resulting Value tree is parsed into a specific type using serde_json::from_value. | |
| // | |
| // TestConfigBuilder relies heavily on the test configuration schema to validate the parameter | |
| // assignments it processes. Final validation includes validating the final Value against the | |
| // schema. | |
| // | |
| // Processing of the command line and environment variables employs the parsers module from | |
| // this crate. The parsers handle the particulars of those use cases (e.g. arrays don't have | |
| // brackets around them, naked integers qualify as strings, etc). In those cases, schema type | |
| // information is used to decide what parser to use. Various attempts were made to use serde_json | |
| // and valico::dsl for this parsing, but those proved inadequate or conterproductive for various | |
| // reasons. | |
| // | |
| // JSON files are not checked for type mismatches until final validation against the schema. | |
| // However, parameters assigned values in JSON files are checked against the schema to see if | |
| // the parameter name is allowed as a property of the top-level object. This is done simply | |
| // because more informative errors are generated this way. | |
| use crate::env::EnvLike; | |
| use crate::errors::{BuildError, UsageError}; | |
| use crate::logger::Logger; | |
| use crate::name::Name; | |
| use crate::parsers::parser_for_parameter; | |
| use crate::schema::{PropertyType, Schema}; | |
| use serde::Deserialize; | |
| use serde_json::Value; | |
| use serde_json5; | |
| use std::collections::{HashMap, HashSet, VecDeque}; | |
| use std::fs; | |
| use std::fs::File; | |
| use std::io::BufReader; | |
| use std::path::PathBuf; | |
| use valico::common::error::ValicoError; | |
| use valico::json_schema; | |
| use valico::json_schema::validators::ValidationState; | |
| const NO_STRICT_OPTION: &str = "no_strict"; | |
| const NO_OPTION_PREFIX: &str = "no_"; | |
| const FROM_ENV_KEYWORD: &str = "from_env"; | |
| const TRY_FROM_ENV_KEYWORD: &str = "try_from_env"; | |
| /// Builds a configuration from an `EnvLike`, an abstraction of `std::env`, and returns it. | |
| pub fn build_from_env_like<T: for<'a> Deserialize<'a>, E: EnvLike, L: Logger>( | |
| env_like: &E, | |
| schema: Schema, | |
| logger: &mut L, | |
| ) -> Result<T, BuildError> { | |
| let param_values_by_name = | |
| TestConfigBuilder::from_env_like(env_like, schema, logger)?.param_values_by_name; | |
| let param_values_by_string = | |
| param_values_by_name.into_iter().map(|(k, v)| (k.to_string(), v)).collect(); | |
| Ok(serde_json::from_value(Value::Object(param_values_by_string))?) | |
| } | |
| /// Builds a test configuration based on command line arguments, environment variables, and JSON | |
| /// files. | |
| #[derive(Debug, PartialEq, Default)] | |
| struct TestConfigBuilder { | |
| /// The validated test configuration schema in `Value` form. | |
| schema: Schema, | |
| /// Whether the builder is currently in strict mode. | |
| strict: bool, | |
| /// Test parameter values by name. The configuration is built here and later parsed into the | |
| /// target struct. | |
| param_values_by_name: HashMap<Name, Value>, | |
| /// Names of parameters in `param_values_by_name` that were assigned in non-strict mode and | |
| /// have not yet been assigned in strict mode. This collection is used to allow non-strict | |
| /// assignments to override a single strict assignment. | |
| overrides: HashSet<Name>, | |
| /// JSON files that have been included. | |
| include: Vec<PathBuf>, | |
| /// JSON files that should be included but which have not been processed. Every member of this | |
| /// collection also appears in `include`. | |
| unprocessed_includes: VecDeque<PathBuf>, | |
| /// Parameters that appear in the schema and are required for this test configuration. This | |
| /// mechanism is distinct from the 'required' section of the schema in that the parameters | |
| /// listed here are only required for this particular test configuration, whereas the schema | |
| /// required section lists parameters that are required in all test configurations. | |
| require: Vec<Name>, | |
| /// Parameters that appear in the schema and are prohibited for this test configuration. | |
| prohibit: Vec<Name>, | |
| } | |
| /// Used for deserializing an include file. | |
| #[derive(Debug, Deserialize)] | |
| struct IncludeFile { | |
| #[serde(flatten)] | |
| values_by_name: HashMap<Name, Value>, | |
| } | |
| /// Builds a test configuration based on the command line, referenced environment variables, and | |
| /// referenced JSON files. | |
| impl TestConfigBuilder { | |
| /// Creates a new `TestConfigBuilder` from an `EnvLike`, an abstraction of `std::env`. | |
| fn from_env_like<E: EnvLike, L: Logger>( | |
| env_like: &E, | |
| schema: Schema, | |
| logger: &mut L, | |
| ) -> Result<Self, BuildError> { | |
| let mut to_return = Self::from_arg_iter(env_like.args(), schema, logger)?; | |
| while let Some(include) = to_return.unprocessed_includes.pop_front() { | |
| to_return.process_include(include, env_like, logger)?; | |
| } | |
| to_return.validate()?; | |
| Ok(to_return) | |
| } | |
| /// Create a new `TestConfigBuilder` from an iterator over argument strings. | |
| fn from_arg_iter<L: Logger>( | |
| args: impl Iterator<Item = String>, | |
| schema: Schema, | |
| logger: &mut L, | |
| ) -> Result<Self, UsageError> { | |
| let mut to_return = TestConfigBuilder { schema, ..Default::default() }; | |
| logger.start_command_line(); | |
| for arg in args { | |
| if let Some(stripped_arg) = arg.strip_prefix("--") { | |
| if let Some((arg_name, value)) = stripped_arg.split_once('=') { | |
| // --name=value | |
| let name = Name::from_arg_name(arg_name); | |
| match &name { | |
| Name::Schema => { | |
| // Processed in `from_env`. | |
| logger.schema_option(value); | |
| } | |
| Name::Debug => { | |
| return Err(UsageError::UnexpectedOptionValue { | |
| option: name, | |
| got: Value::from(value), | |
| }); | |
| } | |
| Name::Strict | |
| | Name::Include | |
| | Name::Require | |
| | Name::Prohibit | |
| | Name::Parameter(_) => { | |
| to_return.add_name_and_text_value(name, value, logger)?; | |
| } | |
| } | |
| } else { | |
| // --name or --no-name | |
| let name = Name::from_arg_name(stripped_arg); | |
| match &name { | |
| Name::Schema => { | |
| return Err(UsageError::MissingValue(name)); | |
| } | |
| Name::Debug => { | |
| logger.debug_option(); | |
| } | |
| Name::Strict | |
| | Name::Include | |
| | Name::Require | |
| | Name::Prohibit | |
| | Name::Parameter(_) => { | |
| to_return.add_name_no_value(name, logger)?; | |
| } | |
| } | |
| } | |
| } else { | |
| return Err(UsageError::UnexpectedPositionalArgument(arg)); | |
| } | |
| } | |
| Ok(to_return) | |
| } | |
| /// Process a single JSON file. If new includes are encountered, they will get pushed to the | |
| /// back of `unprocessed_includes` and processed later. | |
| fn process_include<E: EnvLike, L: Logger>( | |
| &mut self, | |
| path: PathBuf, | |
| env_like: &E, | |
| logger: &mut L, | |
| ) -> Result<(), BuildError> { | |
| logger.start_include(&path); | |
| let file = File::open(&path) | |
| .map_err(|e| BuildError::FailedToOpenInclude { path: path.clone(), source: e })?; | |
| let mut reader = BufReader::new(file); | |
| let include_file: IncludeFile = serde_json5::from_reader(&mut reader) | |
| .map_err(|e| BuildError::FailedToParseInclude { path: path.clone(), source: e })?; | |
| for (name, value) in include_file.values_by_name { | |
| // Strictly speaking, we could leave this check to validation by schema, but the | |
| // errors produced by the validator are less useful than we get this way. | |
| if name.can_be_added(&self.schema) { | |
| if let Some(value) = self.maybe_subst_from_env(&name, value, env_like, logger)? { | |
| self.add_name_and_value(name, value, logger)?; | |
| } | |
| } else { | |
| return Err(UsageError::UnrecognizedParameter(name).into()); | |
| } | |
| } | |
| Ok(()) | |
| } | |
| /// Adds a name/value pair to `param_values_by_name`. The name must be in lower_snake_case. The value | |
| /// is parsed as appropriate. This function is used for parameters given on the command | |
| /// line with a value (e.g. --foo=bar). | |
| fn add_name_and_text_value<L: Logger>( | |
| &mut self, | |
| name: Name, | |
| value_str: &str, | |
| logger: &mut L, | |
| ) -> Result<(), UsageError> { | |
| let value = parser_for_parameter(&name, &self.schema)?.parse(&name, value_str)?; | |
| self.add_name_and_value(name, value, logger) | |
| } | |
| /// Adds a name/value pair as expressed by a command line option with no value. | |
| fn add_name_no_value<L: Logger>( | |
| &mut self, | |
| name: Name, | |
| logger: &mut L, | |
| ) -> Result<(), UsageError> { | |
| match name { | |
| Name::Parameter(p) if p == NO_STRICT_OPTION => { | |
| // Strict may not be turned off. | |
| return Err(UsageError::InvalidStrictValue(String::from("false"))); | |
| } | |
| Name::Strict => { | |
| // Strict may be turned on this way. | |
| return self.add_name_and_value(name, Value::Bool(true), logger); | |
| } | |
| Name::Include | Name::Require | Name::Prohibit => { | |
| // These options require values. | |
| return Err(UsageError::MissingValue(name)); | |
| } | |
| Name::Debug | Name::Schema | Name::Parameter(_) => {} | |
| } | |
| if let Some(scheme) = self.schema.properties.get(&name) { | |
| // The name is a valid parameter in the schema. Set it to true if its type | |
| // is boolean, otherwise, complain that the value was not provided. | |
| if scheme.property_type == PropertyType::Boolean { | |
| return self.add_name_and_value(name, Value::Bool(true), logger); | |
| } else { | |
| return Err(UsageError::MissingValue(name)); | |
| } | |
| } else if name.starts_with(NO_OPTION_PREFIX) { | |
| // The name starts with 'no_'. If the rest of the name is a valid boolean | |
| // parameter in the schema, set it to false. | |
| let name = name.strip_prefix(NO_OPTION_PREFIX).unwrap(); | |
| if let Some(scheme) = self.schema.properties.get(&name) { | |
| if scheme.property_type == PropertyType::Boolean { | |
| return self.add_name_and_value(name, Value::Bool(false), logger); | |
| } | |
| } | |
| } else { | |
| // The name does not start with 'no_'. If the name with 'no_' prepended is | |
| // a valid boolean parameter in the schema, set it to false. | |
| let mut no_name = String::from(NO_OPTION_PREFIX); | |
| no_name.push_str(name.as_str()); | |
| let name = Name::from(no_name); | |
| if let Some(scheme) = self.schema.properties.get(&name) { | |
| if scheme.property_type == PropertyType::Boolean { | |
| return self.add_name_and_value(name, Value::Bool(false), logger); | |
| } | |
| } | |
| } | |
| Err(UsageError::UnrecognizedParameter(name)) | |
| } | |
| /// Adds a name/value pair to `param_values_by_name`. The name must be in lower_snake_case. | |
| fn add_name_and_value<L: Logger>( | |
| &mut self, | |
| name: Name, | |
| mut value: Value, | |
| logger: &mut L, | |
| ) -> Result<(), UsageError> { | |
| match name { | |
| Name::Strict => match value { | |
| Value::Bool(true) => { | |
| logger.strict(); | |
| self.strict = true; | |
| } | |
| v => { | |
| return Err(UsageError::InvalidStrictValue(v.to_string())); | |
| } | |
| }, | |
| Name::Include => { | |
| for item_string in strings_in_option_array_value(Name::Include, value)? { | |
| let path = parse_include_path(item_string.as_str())?; | |
| if !self.include.contains(&path) { | |
| logger.add_include(&path); | |
| self.include.push(path.clone()); | |
| self.unprocessed_includes.push_back(path); | |
| } else { | |
| logger.include_already_added(&path); | |
| } | |
| } | |
| } | |
| Name::Require => { | |
| for item_string in strings_in_option_array_value(Name::Require, value)? { | |
| let item_name = Name::from_arg_name(item_string.as_str()); | |
| if !item_name.is_viable_parameter_name() { | |
| return Err(UsageError::InvalidParameterName { | |
| option: Name::Require, | |
| got: item_name, | |
| }); | |
| } | |
| if !self.require.contains(&item_name) { | |
| logger.add_require(&item_name); | |
| self.require.push(item_name); | |
| } else { | |
| logger.require_already_added(&item_name); | |
| } | |
| } | |
| } | |
| Name::Prohibit => { | |
| for item_string in strings_in_option_array_value(Name::Prohibit, value)? { | |
| let item_name = Name::from_str(item_string.as_str()); | |
| if !item_name.is_viable_parameter_name() { | |
| return Err(UsageError::InvalidParameterName { | |
| option: Name::Prohibit, | |
| got: item_name, | |
| }); | |
| } | |
| if !self.prohibit.contains(&item_name) { | |
| logger.add_prohibit(&item_name); | |
| self.prohibit.push(item_name); | |
| } else { | |
| logger.prohibit_already_added(&item_name); | |
| } | |
| } | |
| } | |
| _ => { | |
| if let Some(mut existing) = self.param_values_by_name.get_mut(&name) { | |
| // Parameter already assigned a value. | |
| if let Value::Array(vector) = &mut existing { | |
| // Array parameter already assigned a value. Append the new value. | |
| logger.add_to_array(&name, &value); | |
| vector.append( | |
| value.as_array_mut().expect("value merged into array is array"), | |
| ); | |
| } else { | |
| // Non-array parameter already assigned a value. | |
| if self.strict { | |
| // Strict mode. | |
| if !self.overrides.remove(&name) { | |
| // The name has been assigned previously in strict mode, so we fail. | |
| return Err(UsageError::ParamAlreadyStrictlyAssigned(name)); | |
| } else { | |
| // The name was assigned in non-strict mode and has not been | |
| // assigned previously in strict mode. We already removed the | |
| // name from `overrides` so any subsequent assignments in strict | |
| // mode will fail. | |
| logger.overridden_add_parameter_strict_ignored(&name, &value); | |
| } | |
| } else { | |
| // Non-strict mode. We make the assignment, overriding the previous | |
| // assignment, which was also made in non-strict mode. We know the | |
| // name is already in `overrides`, because that happened when it | |
| // was initially assigned in non-strict mode. | |
| logger.add_parameter_non_strict(&name, &value); | |
| let _ = self.param_values_by_name.insert(name, value); | |
| } | |
| } | |
| } else { | |
| // Parameter not already assigned a value. | |
| if value.is_array() { | |
| logger.add_to_array(&name, &value); | |
| } else if self.strict { | |
| logger.add_parameter_strict(&name, &value); | |
| } else { | |
| logger.add_parameter_non_strict(&name, &value); | |
| self.overrides.insert(name.clone()); | |
| } | |
| let _ = self.param_values_by_name.insert(name, value); | |
| } | |
| } | |
| } | |
| Ok(()) | |
| } | |
| // Determines if `value` calls for substitution from the environment and produces the | |
| // substitute value. Returns `Ok(Some(value))` if no substitution should occur. Returns | |
| // Ok(Some(env_value)) if a substitution should occur (env_value is the value to substitute). | |
| // Returns Ok(None) if a try_from_env substitution referenced an undefined environment | |
| // variable. | |
| fn maybe_subst_from_env<E: EnvLike, L: Logger>( | |
| &self, | |
| name: &Name, | |
| value: Value, | |
| env_like: &E, | |
| logger: &mut L, | |
| ) -> Result<Option<Value>, UsageError> { | |
| if let Some(obj) = value.as_object() { | |
| if obj.len() == 1 { | |
| match (obj.get(FROM_ENV_KEYWORD), obj.get(TRY_FROM_ENV_KEYWORD)) { | |
| (Some(var_name_value), None) => { | |
| if let Some(value) = self.get_subst_value(name, var_name_value, env_like)? { | |
| logger.from_env(var_name_value, &value); | |
| return Ok(Some(value)); | |
| } else { | |
| return Err(UsageError::FromEnvUndefined { | |
| parameter: name.clone(), | |
| var_name_value: var_name_value.clone(), | |
| }); | |
| } | |
| } | |
| (None, Some(var_name_value)) => { | |
| if let Some(value) = self.get_subst_value(name, var_name_value, env_like)? { | |
| logger.try_from_env(var_name_value, &value); | |
| return Ok(Some(value)); | |
| } else { | |
| logger.try_from_env_undefined(name, var_name_value); | |
| return Ok(None); | |
| } | |
| } | |
| (Some(_), Some(_)) => {} | |
| (None, None) => {} | |
| } | |
| } | |
| } | |
| Ok(Some(value)) | |
| } | |
| // Gets the value for a from_env/try_from_env construct where `name` is the property being | |
| // defined and `var_name_value` is the value of the from_env/try_from_env property. If | |
| // `var_name_value` is not a string, an error is returned. | |
| fn get_subst_value<E: EnvLike>( | |
| &self, | |
| name: &Name, | |
| var_name_value: &Value, | |
| env_like: &E, | |
| ) -> Result<Option<Value>, UsageError> { | |
| if let Some(var_name_string) = var_name_value.as_str() { | |
| if let Ok(var_value_string) = env_like.var(var_name_string) { | |
| Ok(Some( | |
| parser_for_parameter(name, &self.schema)? | |
| .parse(&name, var_value_string.as_str())?, | |
| )) | |
| } else { | |
| Ok(None) | |
| } | |
| } else { | |
| Err(UsageError::FromEnvNotString { | |
| parameter: name.clone(), | |
| var_name_value: var_name_value.clone(), | |
| }) | |
| } | |
| } | |
| /// Validates `self`. | |
| fn validate(&self) -> Result<(), BuildError> { | |
| assert!( | |
| self.unprocessed_includes.is_empty(), | |
| "TestConfigBuilder contains unprocessed includes." | |
| ); | |
| let mut errors = vec![]; | |
| // Ensure that all the parameters that have been required are in the schema and that | |
| // those parameters have been supplied. | |
| for required in &self.require { | |
| if !self.schema.properties.contains_key(required) { | |
| errors.push(UsageError::UnknownRequiredParameter(required.clone()).into()); | |
| } else if !self.param_values_by_name.contains_key(required) { | |
| errors.push(UsageError::MissingRequiredParameter(required.clone()).into()); | |
| } | |
| } | |
| // Ensure that all the parameters that have been prohibited are in the schema and that | |
| // those parameters have not been supplied. | |
| for prohibited in &self.prohibit { | |
| if !self.schema.properties.contains_key(prohibited) { | |
| errors.push(UsageError::UnknownProhibitedParameter(prohibited.clone()).into()); | |
| } else if self.param_values_by_name.contains_key(prohibited) { | |
| errors.push(UsageError::DefinedProhibitedParameter(prohibited.clone()).into()); | |
| } | |
| } | |
| let mut scope = json_schema::Scope::new(); | |
| let validator = scope | |
| .compile_and_return(self.schema.as_value.clone(), /*ban_unknown=*/ true) | |
| .expect("Schema to compile"); | |
| let param_values_by_string = | |
| self.param_values_by_name.iter().map(|(k, v)| (k.to_string(), v.clone())).collect(); | |
| let validation_state = validator.validate(&Value::Object(param_values_by_string)); | |
| if !validation_state.is_strictly_valid() { | |
| match validation_state_to_build_error(validation_state) { | |
| BuildError::ValidationMultiple(mut schema_errors) => { | |
| errors.append(&mut schema_errors); | |
| } | |
| schema_error => { | |
| errors.push(schema_error); | |
| } | |
| } | |
| } | |
| if errors.is_empty() { | |
| Ok(()) | |
| } else if errors.len() == 1 { | |
| Err(errors.remove(0)) | |
| } else { | |
| Err(BuildError::ValidationMultiple(errors)) | |
| } | |
| } | |
| } | |
| /// Returns an iterator for the strings in a `Value::Array` of `Value::String`. Returns an error | |
| /// if anything else is found. | |
| /// | |
| /// This is used for options 'include', 'require' and 'prohibit' only. Note that errors are only | |
| /// generated for JSON assignments, because command line and environment variable values were | |
| /// parsed with our parsers to be of the correct type. | |
| fn strings_in_option_array_value( | |
| option_name: Name, | |
| value: Value, | |
| ) -> Result<impl Iterator<Item = String>, UsageError> { | |
| let item_values = match value { | |
| Value::Array(vector) => vector, | |
| v => { | |
| return Err(UsageError::UnexpectedOptionValue { option: option_name, got: v }); | |
| } | |
| }; | |
| for item_value in &item_values { | |
| if !item_value.is_string() { | |
| return Err(UsageError::UnexpectedOptionValue { | |
| option: option_name, | |
| got: item_value.clone(), | |
| }); | |
| } | |
| } | |
| Ok(item_values.into_iter().map(|item_value| String::from(item_value.as_str().unwrap()))) | |
| } | |
| /// Parse an include file path, checking that the file exists and is a file. | |
| fn parse_include_path(path: &str) -> Result<PathBuf, UsageError> { | |
| let path = PathBuf::from(path); | |
| if !path.exists() { | |
| return Err(UsageError::IncludedPathDoesNotExist(path)); | |
| } | |
| if let Ok(metadata) = fs::metadata(&path) { | |
| if !metadata.is_file() { | |
| return Err(UsageError::IncludedPathIsNotAFile(path)); | |
| } | |
| } else { | |
| return Err(UsageError::IncludedPathUnreadable(path)); | |
| } | |
| Ok(path) | |
| } | |
| /// Creates a `UsageError` from a failed `ValidationState`. | |
| fn validation_state_to_build_error(validation_state: ValidationState) -> BuildError { | |
| let mut errors = vec![]; | |
| for missing in &validation_state.missing { | |
| errors.push(UsageError::MissingParameterRequiredBySchema(missing.to_string()).into()); | |
| } | |
| for e in &validation_state.errors { | |
| errors.push(validation_error_to_build_error(&e)); | |
| } | |
| if errors.is_empty() { | |
| BuildError::UnclassifiedSchemaState(Box::new(validation_state)) | |
| } else if errors.len() == 1 { | |
| errors.pop().unwrap() | |
| } else { | |
| BuildError::ValidationMultiple(errors) | |
| } | |
| } | |
| /// Creates a `UsageError` from a failed `ValicoError`. | |
| fn validation_error_to_build_error(validation_error: &Box<dyn ValicoError>) -> BuildError { | |
| match validation_error.get_code() { | |
| "required" => UsageError::MissingParameterRequiredBySchema(validation_error_simple_path( | |
| &validation_error, | |
| )) | |
| .into(), | |
| "wrong_type" => UsageError::SchemaTypeMismatch { | |
| parameter: validation_error_simple_path(&validation_error), | |
| detail: String::from( | |
| validation_error.get_detail().expect("WrongType error has detail"), | |
| ), | |
| } | |
| .into(), | |
| _ => BuildError::UnclassifiedSchemaError(format!("{:?}", validation_error)), | |
| } | |
| } | |
| fn validation_error_simple_path(validation_error: &Box<dyn ValicoError>) -> String { | |
| String::from(validation_error.get_path().split('/').next_back().unwrap()) | |
| } | |
| #[cfg(test)] | |
| mod tests { | |
| use super::*; | |
| use crate::env::testutils::FakeEnv; | |
| use crate::logger::NullLogger; | |
| use crate::schema::tests::fake_schema; | |
| use assert_matches::assert_matches; | |
| use serde_json::{Map, Number, json}; | |
| use std::fs; | |
| use std::str::FromStr; | |
| use tempfile::{NamedTempFile, tempdir}; | |
| fn option_name() -> Name { | |
| Name::from_str("test_option_name") | |
| } | |
| /// Asserts that a `Result<TestConfigBuilder, BuilderError>` wraps `usage_error` | |
| #[track_caller] | |
| fn assert_usage_error(result: Result<TestConfigBuilder, BuildError>, usage_error: UsageError) { | |
| assert_matches!(result, Err(BuildError::IncorrectUsage(e)) if e == usage_error) | |
| } | |
| #[test] | |
| fn test_strings_in_option_array_value() { | |
| assert_eq!( | |
| Err(UsageError::UnexpectedOptionValue { | |
| option: option_name(), | |
| got: Value::from_str("{}").unwrap(), | |
| }), | |
| strings_in_option_array_value(option_name(), json!({})).map(|_| ()) | |
| ); | |
| assert_eq!( | |
| Err(UsageError::UnexpectedOptionValue { | |
| option: option_name(), | |
| got: Value::from_str("4").unwrap(), | |
| }), | |
| strings_in_option_array_value(option_name(), json!(4)).map(|_| ()) | |
| ); | |
| assert_eq!( | |
| Err(UsageError::UnexpectedOptionValue { | |
| option: option_name(), | |
| got: Value::from_str("\"squint\"").unwrap(), | |
| }), | |
| strings_in_option_array_value(option_name(), json!("squint")).map(|_| ()) | |
| ); | |
| assert_eq!( | |
| Err(UsageError::UnexpectedOptionValue { | |
| option: option_name(), | |
| got: Value::from_str("{}").unwrap(), | |
| }), | |
| strings_in_option_array_value(option_name(), json!([{}])).map(|_| ()) | |
| ); | |
| assert_eq!( | |
| Err(UsageError::UnexpectedOptionValue { | |
| option: option_name(), | |
| got: Value::from_str("4").unwrap(), | |
| }), | |
| strings_in_option_array_value(option_name(), json!([4])).map(|_| ()) | |
| ); | |
| assert_eq!( | |
| Err(UsageError::UnexpectedOptionValue { | |
| option: option_name(), | |
| got: Value::from_str("4").unwrap(), | |
| }), | |
| strings_in_option_array_value(option_name(), json!(["squint", 4])).map(|_| ()) | |
| ); | |
| assert_eq!( | |
| vec![String::from("squint")], | |
| strings_in_option_array_value(option_name(), json!(["squint"])) | |
| .unwrap() | |
| .collect::<Vec<String>>() | |
| ); | |
| assert_eq!( | |
| vec![String::from("squint"), String::from("frown")], | |
| strings_in_option_array_value(option_name(), json!(["squint", "frown"])) | |
| .unwrap() | |
| .collect::<Vec<String>>() | |
| ); | |
| } | |
| #[test] | |
| fn test_parse_include_path() { | |
| // Existent file. | |
| let temp_file = NamedTempFile::new().expect("to create temporary file"); | |
| let temp_file_path = temp_file.path().to_str().unwrap().to_string(); | |
| assert!(parse_include_path(temp_file_path.as_str()).is_ok()); | |
| temp_file.close().expect("to close temporary file"); | |
| // Non-existent file. | |
| let result = parse_include_path("/non_existent_file"); | |
| assert_eq!( | |
| result, | |
| Err(UsageError::IncludedPathDoesNotExist(PathBuf::from("/non_existent_file"))) | |
| ); | |
| // Existent directory. | |
| let temp_dir = tempdir().expect("to create temporary directory"); | |
| let temp_dir_path = temp_dir.path(); | |
| let result = parse_include_path(temp_dir_path.to_str().unwrap()); | |
| assert_eq!( | |
| result, | |
| Err(UsageError::IncludedPathIsNotAFile(PathBuf::from(temp_dir_path.to_str().unwrap()))) | |
| ); | |
| temp_dir.close().expect("to close temporary directory"); | |
| } | |
| #[test] | |
| fn test_is_viable_parameter_name() { | |
| assert!(!Name::Schema.is_viable_parameter_name()); | |
| assert!(!Name::Debug.is_viable_parameter_name()); | |
| assert!(!Name::Strict.is_viable_parameter_name()); | |
| assert!(!Name::Include.is_viable_parameter_name()); | |
| assert!(!Name::Require.is_viable_parameter_name()); | |
| assert!(!Name::Prohibit.is_viable_parameter_name()); | |
| assert!(!Name::from_str("ahoy!").is_viable_parameter_name()); | |
| assert!(!Name::from_str("1_thing").is_viable_parameter_name()); | |
| assert!(Name::from_str("_one_thing").is_viable_parameter_name()); | |
| assert!(Name::from_str("snorkel").is_viable_parameter_name()); | |
| } | |
| #[test] | |
| // Tests the case in which no arguments are supplied. | |
| fn test_no_args() { | |
| let fake_env = FakeEnv::new("", ""); | |
| let under_test = | |
| TestConfigBuilder::from_env_like(&fake_env, fake_schema(), &mut NullLogger) | |
| .expect("Ok result"); | |
| assert!(under_test.param_values_by_name.is_empty()); | |
| } | |
| #[test] | |
| // Tests the case in which an unexpected positional argument is provided. | |
| fn test_unexpected_positional_arg() { | |
| let fake_env = FakeEnv::new("foo", ""); | |
| let under_test = | |
| TestConfigBuilder::from_env_like(&fake_env, fake_schema(), &mut NullLogger); | |
| assert_usage_error( | |
| under_test, | |
| UsageError::UnexpectedPositionalArgument(String::from("foo")), | |
| ); | |
| } | |
| #[test] | |
| // Tests cases in which values are missing for known parameters that require them. | |
| fn test_missing_values() { | |
| let fake_env = FakeEnv::new("--include", ""); | |
| let under_test = | |
| TestConfigBuilder::from_env_like(&fake_env, fake_schema(), &mut NullLogger); | |
| assert_usage_error(under_test, UsageError::MissingValue(Name::Include)); | |
| let fake_env = FakeEnv::new("--require", ""); | |
| let under_test = | |
| TestConfigBuilder::from_env_like(&fake_env, fake_schema(), &mut NullLogger); | |
| assert_usage_error(under_test, UsageError::MissingValue(Name::Require)); | |
| let fake_env = FakeEnv::new("--prohibit", ""); | |
| let under_test = | |
| TestConfigBuilder::from_env_like(&fake_env, fake_schema(), &mut NullLogger); | |
| assert_usage_error(under_test, UsageError::MissingValue(Name::Prohibit)); | |
| let fake_env = FakeEnv::new("--host-test-binary", ""); | |
| let under_test = | |
| TestConfigBuilder::from_env_like(&fake_env, fake_schema(), &mut NullLogger); | |
| assert_usage_error( | |
| under_test, | |
| UsageError::MissingValue(Name::from_str("host_test_binary")), | |
| ); | |
| let fake_env = FakeEnv::new("--host-test-args", ""); | |
| let under_test = | |
| TestConfigBuilder::from_env_like(&fake_env, fake_schema(), &mut NullLogger); | |
| assert_usage_error(under_test, UsageError::MissingValue(Name::from_str("host_test_args"))); | |
| let fake_env = FakeEnv::new("--output-directory", ""); | |
| let under_test = | |
| TestConfigBuilder::from_env_like(&fake_env, fake_schema(), &mut NullLogger); | |
| assert_usage_error( | |
| under_test, | |
| UsageError::MissingValue(Name::from_str("output_directory")), | |
| ); | |
| } | |
| #[test] | |
| // Tests cases in which disallowed values are supplied for known parameters. | |
| fn test_values_not_allowed() { | |
| let fake_env = FakeEnv::new("--require=include", ""); | |
| let under_test = | |
| TestConfigBuilder::from_env_like(&fake_env, fake_schema(), &mut NullLogger); | |
| assert_usage_error( | |
| under_test, | |
| UsageError::InvalidParameterName { option: Name::Require, got: Name::Include }, | |
| ); | |
| let fake_env = FakeEnv::new("--require=require", ""); | |
| let under_test = | |
| TestConfigBuilder::from_env_like(&fake_env, fake_schema(), &mut NullLogger); | |
| assert_usage_error( | |
| under_test, | |
| UsageError::InvalidParameterName { option: Name::Require, got: Name::Require }, | |
| ); | |
| let fake_env = FakeEnv::new("--require=prohibit", ""); | |
| let under_test = | |
| TestConfigBuilder::from_env_like(&fake_env, fake_schema(), &mut NullLogger); | |
| assert_usage_error( | |
| under_test, | |
| UsageError::InvalidParameterName { option: Name::Require, got: Name::Prohibit }, | |
| ); | |
| let fake_env = FakeEnv::new("--prohibit=include", ""); | |
| let under_test = | |
| TestConfigBuilder::from_env_like(&fake_env, fake_schema(), &mut NullLogger); | |
| assert_usage_error( | |
| under_test, | |
| UsageError::InvalidParameterName { option: Name::Prohibit, got: Name::Include }, | |
| ); | |
| let fake_env = FakeEnv::new("--prohibit=require", ""); | |
| let under_test = | |
| TestConfigBuilder::from_env_like(&fake_env, fake_schema(), &mut NullLogger); | |
| assert_usage_error( | |
| under_test, | |
| UsageError::InvalidParameterName { option: Name::Prohibit, got: Name::Require }, | |
| ); | |
| let fake_env = FakeEnv::new("--prohibit=prohibit", ""); | |
| let under_test = | |
| TestConfigBuilder::from_env_like(&fake_env, fake_schema(), &mut NullLogger); | |
| assert_usage_error( | |
| under_test, | |
| UsageError::InvalidParameterName { option: Name::Prohibit, got: Name::Prohibit }, | |
| ); | |
| } | |
| #[test] | |
| // Tests cases in which values of the wrong type are supplied for known parameters. | |
| fn test_values_wrong_type() { | |
| let fake_env = FakeEnv::new("--include=1", ""); | |
| let under_test = | |
| TestConfigBuilder::from_env_like(&fake_env, fake_schema(), &mut NullLogger); | |
| assert_usage_error(under_test, UsageError::IncludedPathDoesNotExist(PathBuf::from("1"))); | |
| let fake_env = FakeEnv::new("--include=1,something", ""); | |
| let under_test = | |
| TestConfigBuilder::from_env_like(&fake_env, fake_schema(), &mut NullLogger); | |
| assert_usage_error(under_test, UsageError::IncludedPathDoesNotExist(PathBuf::from("1"))); | |
| let fake_env = FakeEnv::new("--require=1", ""); | |
| let under_test = | |
| TestConfigBuilder::from_env_like(&fake_env, fake_schema(), &mut NullLogger); | |
| assert_usage_error( | |
| under_test, | |
| UsageError::InvalidParameterName { option: Name::Require, got: Name::from_str("1") }, | |
| ); | |
| let fake_env = FakeEnv::new("--require=1,something", ""); | |
| let under_test = | |
| TestConfigBuilder::from_env_like(&fake_env, fake_schema(), &mut NullLogger); | |
| assert_usage_error( | |
| under_test, | |
| UsageError::InvalidParameterName { option: Name::Require, got: Name::from_str("1") }, | |
| ); | |
| let fake_env = FakeEnv::new("--prohibit=1", ""); | |
| let under_test = | |
| TestConfigBuilder::from_env_like(&fake_env, fake_schema(), &mut NullLogger); | |
| assert_usage_error( | |
| under_test, | |
| UsageError::InvalidParameterName { option: Name::Prohibit, got: Name::from_str("1") }, | |
| ); | |
| let fake_env = FakeEnv::new("--prohibit=1,something", ""); | |
| let under_test = | |
| TestConfigBuilder::from_env_like(&fake_env, fake_schema(), &mut NullLogger); | |
| assert_usage_error( | |
| under_test, | |
| UsageError::InvalidParameterName { option: Name::Prohibit, got: Name::from_str("1") }, | |
| ); | |
| } | |
| #[test] | |
| // Tests the processing of parameters as args. | |
| fn test_args() { | |
| let fake_env = FakeEnv::new( | |
| "--true=true --false=false --true-simple --no-false-simple --negative-bool --zero=0 \ | |
| --string=foo --array_of_number=1,2,3,4", | |
| "", | |
| ); | |
| let under_test = | |
| TestConfigBuilder::from_env_like(&fake_env, fake_schema(), &mut NullLogger) | |
| .expect("Ok result"); | |
| assert_eq!( | |
| under_test.param_values_by_name, | |
| HashMap::from_iter( | |
| vec![ | |
| (Name::from_str("true"), Value::Bool(true)), | |
| (Name::from_str("false"), Value::Bool(false)), | |
| (Name::from_str("true_simple"), Value::Bool(true)), | |
| (Name::from_str("false_simple"), Value::Bool(false)), | |
| (Name::from_str("no_negative_bool"), Value::Bool(false)), | |
| (Name::from_str("zero"), Value::Number(Number::from(0))), | |
| (Name::from_str("string"), Value::String(String::from("foo"))), | |
| ( | |
| Name::from_str("array_of_number"), | |
| Value::Array(vec![ | |
| Value::Number(Number::from(1)), | |
| Value::Number(Number::from(2)), | |
| Value::Number(Number::from(3)), | |
| Value::Number(Number::from(4)) | |
| ]) | |
| ), | |
| ] | |
| .into_iter() | |
| ) | |
| ); | |
| let fake_env = FakeEnv::new("--zero-point-one=0.1 --negative-zero-point-one=-0.1", ""); | |
| let under_test = | |
| TestConfigBuilder::from_env_like(&fake_env, fake_schema(), &mut NullLogger) | |
| .expect("Ok result"); | |
| assert_eq!( | |
| under_test | |
| .param_values_by_name | |
| .get(&Name::from_str("zero_point_one")) | |
| .unwrap() | |
| .as_f64() | |
| .unwrap(), | |
| 0.1 | |
| ); | |
| assert_eq!( | |
| under_test | |
| .param_values_by_name | |
| .get(&Name::from_str("negative_zero_point_one")) | |
| .unwrap() | |
| .as_f64() | |
| .unwrap(), | |
| -0.1 | |
| ); | |
| let fake_env = FakeEnv::new("--squeak", ""); | |
| assert_usage_error( | |
| TestConfigBuilder::from_env_like(&fake_env, fake_schema(), &mut NullLogger), | |
| UsageError::UnrecognizedParameter(Name::from_str("squeak")), | |
| ); | |
| let fake_env = FakeEnv::new("--zero", ""); | |
| assert_usage_error( | |
| TestConfigBuilder::from_env_like(&fake_env, fake_schema(), &mut NullLogger), | |
| UsageError::MissingValue(Name::from_str("zero")), | |
| ); | |
| } | |
| #[test] | |
| // Tests the processing of include parameter in args. | |
| fn test_include() { | |
| // Successful reference from a command line. | |
| let temp_file = NamedTempFile::new().expect("Failed to create temporary file"); | |
| let temp_file_path = temp_file.path().to_str().unwrap(); | |
| fs::write(temp_file_path, "{}").expect("Failed to write to temporary file"); | |
| let fake_env = FakeEnv::new(format!("--include={}", temp_file_path).as_str(), ""); | |
| let under_test = | |
| TestConfigBuilder::from_env_like(&fake_env, fake_schema(), &mut NullLogger) | |
| .expect("Ok result"); | |
| assert_eq!(under_test.include, vec![PathBuf::from_str(temp_file_path).unwrap(),]); | |
| // Non-existent file. | |
| let fake_env = FakeEnv::new("--include=/non_existent_file", ""); | |
| assert_usage_error( | |
| TestConfigBuilder::from_env_like(&fake_env, fake_schema(), &mut NullLogger), | |
| UsageError::IncludedPathDoesNotExist(PathBuf::from("/non_existent_file")), | |
| ); | |
| // File containing non-JSON. | |
| let temp_file = NamedTempFile::new().expect("Able to create temporary file"); | |
| let temp_file_path = temp_file.path().to_str().unwrap(); | |
| fs::write(temp_file_path, "spagga!").expect("Able to write to temporary file"); | |
| let fake_env = FakeEnv::new(format!("--include={}", temp_file_path).as_str(), ""); | |
| assert_matches!( | |
| TestConfigBuilder::from_env_like(&fake_env, fake_schema(), &mut NullLogger), | |
| Err(BuildError::FailedToParseInclude { path: p, source: _ }) | |
| if p == PathBuf::from_str(temp_file_path).unwrap() | |
| ); | |
| temp_file.close().expect("Failed to close temporary file"); | |
| } | |
| #[test] | |
| // Tests the processing of require parameter in args. | |
| fn test_require() { | |
| let fake_env = FakeEnv::new("--require=a,b,c,d,e --a=a --b=b --c=c --d=d --e=e", ""); | |
| let under_test = | |
| TestConfigBuilder::from_env_like(&fake_env, fake_schema(), &mut NullLogger) | |
| .expect("Ok result"); | |
| let mut sorted = under_test.require.clone(); | |
| sorted.sort(); | |
| assert_eq!( | |
| sorted, | |
| vec![ | |
| Name::from_str("a"), | |
| Name::from_str("b"), | |
| Name::from_str("c"), | |
| Name::from_str("d"), | |
| Name::from_str("e"), | |
| ] | |
| ); | |
| } | |
| #[test] | |
| // Tests the processing of prohibit parameter in args. | |
| fn test_prohibit() { | |
| let fake_env = FakeEnv::new("--prohibit=a,b,c,d,e", ""); | |
| let under_test = | |
| TestConfigBuilder::from_env_like(&fake_env, fake_schema(), &mut NullLogger) | |
| .expect("Ok result"); | |
| let mut sorted = under_test.prohibit.clone(); | |
| sorted.sort(); | |
| assert_eq!( | |
| sorted, | |
| vec![ | |
| Name::from_str("a"), | |
| Name::from_str("b"), | |
| Name::from_str("c"), | |
| Name::from_str("d"), | |
| Name::from_str("e"), | |
| ] | |
| ); | |
| } | |
| #[test] | |
| // Tests the processing of an include. | |
| fn test_include_params() { | |
| let temp_file = NamedTempFile::new().expect("Failed to create temporary file"); | |
| let temp_file_path = temp_file.path().to_str().unwrap(); | |
| fs::write( | |
| temp_file_path, | |
| r#"{// JSON5 allows comments and trailing commas | |
| "true":true, "false":false, zero:0, "string":"foo", | |
| "array_of_number":[1,2,3,4,],}"#, | |
| ) | |
| .expect("Failed to write to temporary file"); | |
| let fake_env = FakeEnv::new(format!("--include={}", temp_file_path).as_str(), ""); | |
| let under_test = | |
| TestConfigBuilder::from_env_like(&fake_env, fake_schema(), &mut NullLogger) | |
| .expect("Ok result"); | |
| assert_eq!(under_test.include, vec![PathBuf::from_str(temp_file_path).unwrap()]); | |
| assert_eq!( | |
| under_test.param_values_by_name, | |
| HashMap::from_iter(vec![ | |
| (Name::from_str("true"), Value::Bool(true)), | |
| (Name::from_str("false"), Value::Bool(false)), | |
| (Name::from_str("zero"), Value::Number(Number::from(0))), | |
| (Name::from_str("string"), Value::String(String::from("foo"))), | |
| ( | |
| Name::from_str("array_of_number"), | |
| Value::Array(vec![ | |
| Value::Number(Number::from(1)), | |
| Value::Number(Number::from(2)), | |
| Value::Number(Number::from(3)), | |
| Value::Number(Number::from(4)) | |
| ]) | |
| ), | |
| ]) | |
| ); | |
| temp_file.close().expect("Failed to close temporary file"); | |
| } | |
| #[test] | |
| // Tests the processing of nested includes. | |
| fn test_nested_includes() { | |
| let temp_file_outer = NamedTempFile::new().expect("Failed to create temporary file"); | |
| let temp_file_outer_path = temp_file_outer.path().to_str().unwrap(); | |
| let temp_file_inner = NamedTempFile::new().expect("Failed to create temporary file"); | |
| let temp_file_inner_path = temp_file_inner.path().to_str().unwrap(); | |
| fs::write(temp_file_outer_path, format!("{{\"include\":[\"{}\"]}}", temp_file_inner_path)) | |
| .expect("Failed to write to temporary file"); | |
| fs::write(temp_file_inner_path, "{}").expect("Failed to write to temporary file"); | |
| let fake_env = FakeEnv::new(format!("--include={}", temp_file_outer_path).as_str(), ""); | |
| let under_test = | |
| TestConfigBuilder::from_env_like(&fake_env, fake_schema(), &mut NullLogger) | |
| .expect("Ok result"); | |
| assert_eq!( | |
| under_test.include, | |
| vec![ | |
| PathBuf::from_str(temp_file_outer_path).unwrap(), | |
| PathBuf::from_str(temp_file_inner_path).unwrap() | |
| ] | |
| ); | |
| temp_file_inner.close().expect("Failed to close temporary file"); | |
| temp_file_outer.close().expect("Failed to close temporary file"); | |
| } | |
| #[test] | |
| // Tests the processing of a JSON object in an include file. | |
| fn test_object() { | |
| let temp_file = NamedTempFile::new().expect("Failed to create temporary file"); | |
| let temp_file_path = temp_file.path().to_str().unwrap(); | |
| fs::write(temp_file_path, r#"{"object":{"foo":1,"bar":2}}"#) | |
| .expect("Failed to write to temporary file"); | |
| let fake_env = FakeEnv::new(format!("--include={}", temp_file_path).as_str(), ""); | |
| let under_test = | |
| TestConfigBuilder::from_env_like(&fake_env, fake_schema(), &mut NullLogger) | |
| .expect("Ok result"); | |
| let mut object_map = serde_json::Map::new(); | |
| object_map.insert(String::from("foo"), Value::Number(Number::from(1))); | |
| object_map.insert(String::from("bar"), Value::Number(Number::from(2))); | |
| assert_eq!(under_test.include, vec![PathBuf::from_str(temp_file_path).unwrap()]); | |
| assert_eq!( | |
| under_test.param_values_by_name, | |
| HashMap::from_iter(vec![(Name::from_str("object"), Value::Object(object_map)),]) | |
| ); | |
| temp_file.close().expect("Failed to close temporary file"); | |
| } | |
| #[test] | |
| // Tests strictness rules implementation. | |
| fn test_strict() { | |
| // Multiple non-strict assignments yields the last value assigned. | |
| let fake_env = FakeEnv::new("---foo=a --foo=b", ""); | |
| let under_test = | |
| TestConfigBuilder::from_env_like(&fake_env, fake_schema(), &mut NullLogger) | |
| .expect("Ok result"); | |
| assert_eq!( | |
| String::from("b"), | |
| under_test.param_values_by_name.get(&Name::from_str("foo")).unwrap().as_str().unwrap(), | |
| ); | |
| // One strict assignment after an override returns the override value. | |
| let fake_env = FakeEnv::new("---foo=a --strict --foo=b", ""); | |
| let under_test = | |
| TestConfigBuilder::from_env_like(&fake_env, fake_schema(), &mut NullLogger) | |
| .expect("Ok result"); | |
| assert_eq!( | |
| String::from("a"), | |
| under_test.param_values_by_name.get(&Name::from_str("foo")).unwrap().as_str().unwrap(), | |
| ); | |
| // Multiple strict assignments are not allowed. | |
| let fake_env = FakeEnv::new("--strict --foo=a --foo=b", ""); | |
| assert_usage_error( | |
| TestConfigBuilder::from_env_like(&fake_env, fake_schema(), &mut NullLogger), | |
| UsageError::ParamAlreadyStrictlyAssigned(Name::from_str("foo")), | |
| ); | |
| // Multiple strict assignments are not allowed, even for overridden parameters. | |
| let fake_env = FakeEnv::new("--foo=a --strict --foo=b --foo=c", ""); | |
| assert_usage_error( | |
| TestConfigBuilder::from_env_like(&fake_env, fake_schema(), &mut NullLogger), | |
| UsageError::ParamAlreadyStrictlyAssigned(Name::from_str("foo")), | |
| ); | |
| // Multiple stricts are ok. | |
| let fake_env = FakeEnv::new("--strict --strict", ""); | |
| let _ = TestConfigBuilder::from_env_like(&fake_env, fake_schema(), &mut NullLogger) | |
| .expect("Ok result"); | |
| // Can't set strict to false. | |
| let fake_env = FakeEnv::new("--no-strict", ""); | |
| assert_usage_error( | |
| TestConfigBuilder::from_env_like(&fake_env, fake_schema(), &mut NullLogger), | |
| UsageError::InvalidStrictValue(String::from("false")), | |
| ); | |
| } | |
| #[test] | |
| // Tests that an unknown parameter assigned in JSON causes an error. | |
| fn test_include_unknown() { | |
| let temp_file = NamedTempFile::new().expect("Failed to create temporary file"); | |
| let temp_file_path = temp_file.path().to_str().unwrap(); | |
| fs::write(temp_file_path, r#"{tunnels: 4}"#).expect("Failed to write to temporary file"); | |
| let fake_env = FakeEnv::new(format!("--include={}", temp_file_path).as_str(), ""); | |
| assert_usage_error( | |
| TestConfigBuilder::from_env_like(&fake_env, fake_schema(), &mut NullLogger), | |
| UsageError::UnrecognizedParameter(Name::from_str("tunnels")), | |
| ); | |
| temp_file.close().expect("Failed to close temporary file"); | |
| } | |
| #[test] | |
| // Tests that array assignments are aggregated. | |
| fn test_array_aggregation() { | |
| let fake_env = FakeEnv::new("--strict --array_of_number=1 --array_of_number=2,3", ""); | |
| let under_test = | |
| TestConfigBuilder::from_env_like(&fake_env, fake_schema(), &mut NullLogger) | |
| .expect("Ok result"); | |
| assert_eq!( | |
| under_test.param_values_by_name, | |
| HashMap::from_iter(vec![( | |
| Name::from_str("array_of_number"), | |
| Value::Array(vec![ | |
| Value::Number(Number::from(1)), | |
| Value::Number(Number::from(2)), | |
| Value::Number(Number::from(3)) | |
| ]) | |
| )]) | |
| ); | |
| } | |
| #[test] | |
| // Tests final builder validation. | |
| fn test_final_validation() { | |
| let fake_env = FakeEnv::new("--require=chunky", ""); | |
| assert_usage_error( | |
| TestConfigBuilder::from_env_like(&fake_env, fake_schema(), &mut NullLogger), | |
| UsageError::UnknownRequiredParameter(Name::from_str("chunky")), | |
| ); | |
| let fake_env = FakeEnv::new("--require=foo", ""); | |
| assert_usage_error( | |
| TestConfigBuilder::from_env_like(&fake_env, fake_schema(), &mut NullLogger), | |
| UsageError::MissingRequiredParameter(Name::from_str("foo")), | |
| ); | |
| let fake_env = FakeEnv::new("--prohibit=chunky", ""); | |
| assert_usage_error( | |
| TestConfigBuilder::from_env_like(&fake_env, fake_schema(), &mut NullLogger), | |
| UsageError::UnknownProhibitedParameter(Name::from_str("chunky")), | |
| ); | |
| let fake_env = FakeEnv::new("--prohibit=foo --foo=bar", ""); | |
| assert_usage_error( | |
| TestConfigBuilder::from_env_like(&fake_env, fake_schema(), &mut NullLogger), | |
| UsageError::DefinedProhibitedParameter(Name::from_str("foo")), | |
| ); | |
| // In order to test final validation against the schema, we need to assign the wrong | |
| // type of value to a parameter in a JSON file. Unknown parameter names are caught | |
| // earlier regardless of the source, and type mismatches are caught early when the | |
| // parsers are used (command line and environment variables). | |
| let temp_file = NamedTempFile::new().expect("Failed to create temporary file"); | |
| let temp_file_path = temp_file.path().to_str().unwrap(); | |
| fs::write(temp_file_path, r#"{true: "horse"}"#).expect("Failed to write to temporary file"); | |
| let fake_env = FakeEnv::new(format!("--include={}", temp_file_path).as_str(), ""); | |
| assert_usage_error( | |
| TestConfigBuilder::from_env_like(&fake_env, fake_schema(), &mut NullLogger), | |
| UsageError::SchemaTypeMismatch { | |
| parameter: String::from("true"), | |
| detail: String::from("The value must be boolean"), | |
| }, | |
| ); | |
| temp_file.close().expect("Failed to close temporary file"); | |
| } | |
| #[test] | |
| // Tests TestConfigBuilder::maybe_subst_from_env. | |
| fn test_maybe_subst_from_env() { | |
| let fake_env = FakeEnv::new("", "BOOL=false NUMBER=123 STRING=foo ARRAY=1,2"); | |
| let under_test = | |
| TestConfigBuilder::from_env_like(&fake_env, fake_schema(), &mut NullLogger) | |
| .expect("Ok result"); | |
| let name = Name::Parameter(String::from("test_name")); | |
| // No substitution. | |
| let result = | |
| under_test.maybe_subst_from_env(&name, json!(false), &fake_env, &mut NullLogger); | |
| assert_matches!(result, Ok(Some(Value::Bool(false)))); | |
| let result = under_test.maybe_subst_from_env(&name, json!(123), &fake_env, &mut NullLogger); | |
| assert_matches!(result, Ok(Some(v)) if v == Value::Number(Number::from(123))); | |
| let result = | |
| under_test.maybe_subst_from_env(&name, json!("foo"), &fake_env, &mut NullLogger); | |
| assert_matches!(result, Ok(Some(v)) if v == Value::String(String::from("foo"))); | |
| let result = | |
| under_test.maybe_subst_from_env(&name, json!([1, 2]), &fake_env, &mut NullLogger); | |
| assert_matches!(result,Ok(Some(v)) | |
| if v == Value::Array(vec![Value::Number(Number::from(1)), | |
| Value::Number(Number::from(2))])); | |
| let result = under_test.maybe_subst_from_env(&name, json!({}), &fake_env, &mut NullLogger); | |
| assert_matches!(result, Ok(Some(v)) if v == Value::Object(Map::new())); | |
| // Env var name not a string | |
| let result = under_test.maybe_subst_from_env( | |
| &name, | |
| json!({ "from_env": 123 }), | |
| &fake_env, | |
| &mut NullLogger, | |
| ); | |
| assert_matches!(result, Err(e) | |
| if e == UsageError::FromEnvNotString { | |
| parameter: name.clone(), | |
| var_name_value: Value::Number(Number::from(123)) | |
| } ); | |
| let result = under_test.maybe_subst_from_env( | |
| &name, | |
| json!({ "try_from_env": 123 }), | |
| &fake_env, | |
| &mut NullLogger, | |
| ); | |
| assert_matches!(result, Err(e) | |
| if e == UsageError::FromEnvNotString { | |
| parameter: name.clone(), | |
| var_name_value: Value::Number(Number::from(123)) | |
| } ); | |
| // Udefined env var. | |
| let result = under_test.maybe_subst_from_env( | |
| &name, | |
| json!({ "from_env": "undefined" }), | |
| &fake_env, | |
| &mut NullLogger, | |
| ); | |
| assert_matches!(result, Err(e)if e == UsageError::FromEnvUndefined { | |
| parameter: name.clone(), | |
| var_name_value: Value::String(String::from("undefined")) | |
| } ); | |
| let result = under_test.maybe_subst_from_env( | |
| &name, | |
| json!({ "try_from_env": "undefined" }), | |
| &fake_env, | |
| &mut NullLogger, | |
| ); | |
| assert_matches!(result, Ok(None)); | |
| // Successful substitution. | |
| let result = under_test.maybe_subst_from_env( | |
| &Name::Parameter(String::from("true")), // Declared in schema as bool | |
| json!({ "from_env": "BOOL" }), | |
| &fake_env, | |
| &mut NullLogger, | |
| ); | |
| assert_matches!(result, Ok(Some(Value::Bool(false)))); | |
| let result = under_test.maybe_subst_from_env( | |
| &Name::Parameter(String::from("zero")), // Declared in schema as number | |
| json!({ "from_env": "NUMBER" }), | |
| &fake_env, | |
| &mut NullLogger, | |
| ); | |
| assert_matches!(result, Ok(Some(v)) if v == Value::Number(Number::from(123))); | |
| let result = under_test.maybe_subst_from_env( | |
| &Name::Parameter(String::from("string")), // Declared in schema as number | |
| json!({ "from_env": "STRING" }), | |
| &fake_env, | |
| &mut NullLogger, | |
| ); | |
| assert_matches!(result, Ok(Some(v)) if v == Value::String(String::from("foo"))); | |
| let result = under_test.maybe_subst_from_env( | |
| &Name::Parameter(String::from("array_of_number")), // Declared in schema as array of numbers | |
| json!({ "from_env": "ARRAY" }), | |
| &fake_env, | |
| &mut NullLogger, | |
| ); | |
| assert_matches!(result,Ok(Some(v)) | |
| if v == Value::Array(vec![Value::Number(Number::from(1)), | |
| Value::Number(Number::from(2))])); | |
| let result = under_test.maybe_subst_from_env( | |
| &Name::Parameter(String::from("true")), // Declared in schema as bool | |
| json!({ "try_from_env": "BOOL" }), | |
| &fake_env, | |
| &mut NullLogger, | |
| ); | |
| assert_matches!(result, Ok(Some(Value::Bool(false)))); | |
| let result = under_test.maybe_subst_from_env( | |
| &Name::Parameter(String::from("zero")), // Declared in schema as number | |
| json!({ "try_from_env": "NUMBER" }), | |
| &fake_env, | |
| &mut NullLogger, | |
| ); | |
| assert_matches!(result, Ok(Some(v)) if v == Value::Number(Number::from(123))); | |
| let result = under_test.maybe_subst_from_env( | |
| &Name::Parameter(String::from("string")), // Declared in schema as number | |
| json!({ "try_from_env": "STRING" }), | |
| &fake_env, | |
| &mut NullLogger, | |
| ); | |
| assert_matches!(result, Ok(Some(v)) if v == Value::String(String::from("foo"))); | |
| let result = under_test.maybe_subst_from_env( | |
| &Name::Parameter(String::from("array_of_number")), // Declared in schema as array of numbers | |
| json!({ "try_from_env": "ARRAY" }), | |
| &fake_env, | |
| &mut NullLogger, | |
| ); | |
| assert_matches!(result,Ok(Some(v)) | |
| if v == Value::Array(vec![Value::Number(Number::from(1)), | |
| Value::Number(Number::from(2))])); | |
| } | |
| #[test] | |
| // Tests that from_env object works in a JSON file. | |
| fn test_from_env() { | |
| let temp_file = NamedTempFile::new().expect("Failed to create temporary file"); | |
| let temp_file_path = temp_file.path().to_str().unwrap(); | |
| let json = json!({"true": {"from_env": "BOOL"}}); | |
| fs::write(temp_file_path, serde_json::to_string(&json).expect("JSON can be serialized")) | |
| .expect("Failed to write to temporary file"); | |
| let fake_env = FakeEnv::new(format!("--include={}", temp_file_path).as_str(), "BOOL=false"); | |
| let under_test = | |
| TestConfigBuilder::from_env_like(&fake_env, fake_schema(), &mut NullLogger) | |
| .expect("Ok result"); | |
| assert_matches!( | |
| under_test.param_values_by_name.get(&Name::Parameter(String::from("true"))), | |
| Some(&Value::Bool(false)) | |
| ); | |
| } | |
| } |