| // Copyright 2021 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. |
| |
| #![warn(missing_docs)] |
| |
| //! A library for creating configuration value files as described in [Fuchsia RFC-0127]. |
| //! |
| //! [Fuchsia RFC-0127]: https://fuchsia.dev/fuchsia-src/contribute/governance/rfcs/0127_structured_configuration |
| |
| mod field; |
| |
| use crate::field::{config_value_from_json_value, FieldError}; |
| use cm_rust::{ConfigDecl, ValueSpec, ValuesData}; |
| use serde_json::Value as JsonValue; |
| use std::collections::BTreeMap; |
| |
| /// Create a configuration value file from the compiled manifest's config declaration and a map of |
| /// configuration keys to JSON values. |
| // TODO(https://fxbug.dev/86797) decide on a better interface than json values? |
| pub fn populate_value_file( |
| config_decl: &ConfigDecl, |
| mut json_values: BTreeMap<String, JsonValue>, |
| ) -> Result<ValuesData, FileError> { |
| let values = config_decl |
| .fields |
| .iter() |
| .map(|field| { |
| let json_value = json_values |
| .remove(&field.key) |
| .ok_or_else(|| FileError::MissingValue { key: field.key.clone() })?; |
| let value = config_value_from_json_value(&json_value, &field.type_) |
| .map_err(|reason| FileError::InvalidField { key: field.key.clone(), reason })?; |
| Ok(ValueSpec { value }) |
| }) |
| .collect::<Result<Vec<ValueSpec>, _>>()?; |
| |
| // we remove the definitions from the values map above, so any remaining keys are undefined |
| // in the manifest |
| if !json_values.is_empty() { |
| return Err(FileError::ExtraValues { keys: json_values.into_keys().collect() }); |
| } |
| |
| Ok(ValuesData { values, checksum: config_decl.checksum.clone() }) |
| } |
| |
| /// Error from working with a configuration value file. |
| #[derive(Debug, thiserror::Error, PartialEq)] |
| #[allow(missing_docs)] |
| pub enum FileError { |
| #[error("Invalid config field `{key}`")] |
| InvalidField { |
| key: String, |
| #[source] |
| reason: FieldError, |
| }, |
| |
| #[error("`{key}` field in manifest does not have a value defined.")] |
| MissingValue { key: String }, |
| |
| #[error("Fields `{keys:?}` in value definition do not exist in manifest.")] |
| ExtraValues { keys: Vec<String> }, |
| } |
| |
| #[cfg(test)] |
| mod tests { |
| use super::{field::JsonTy, *}; |
| use cm_rust::{ConfigChecksum, SingleValue, Value, VectorValue}; |
| use fidl_fuchsia_component_config_ext::{config_decl, values_data}; |
| use serde_json::json; |
| |
| fn test_checksum() -> ConfigChecksum { |
| // sha256("Back to the Fuchsia") |
| ConfigChecksum::Sha256([ |
| 0xb5, 0xf9, 0x33, 0xe8, 0x94, 0x56, 0x3a, 0xf9, 0x61, 0x39, 0xe5, 0x05, 0x79, 0x4b, |
| 0x88, 0xa5, 0x3e, 0xd4, 0xd1, 0x5c, 0x32, 0xe2, 0xb4, 0x49, 0x9e, 0x42, 0xeb, 0xa3, |
| 0x32, 0xb1, 0xf5, 0xbb, |
| ]) |
| } |
| |
| #[test] |
| fn basic_success() { |
| let decl = config_decl! { |
| ck@ test_checksum(), |
| my_flag: { bool }, |
| my_uint8: { uint8 }, |
| my_uint16: { uint16 }, |
| my_uint32: { uint32 }, |
| my_uint64: { uint64 }, |
| my_int8: { int8 }, |
| my_int16: { int16 }, |
| my_int32: { int32 }, |
| my_int64: { int64 }, |
| my_string: { string, max_size: 100 }, |
| my_vector_of_flag: { vector, element: bool, max_count: 100 }, |
| my_vector_of_uint8: { vector, element: uint8, max_count: 100 }, |
| my_vector_of_uint16: { vector, element: uint16, max_count: 100 }, |
| my_vector_of_uint32: { vector, element: uint32, max_count: 100 }, |
| my_vector_of_uint64: { vector, element: uint64, max_count: 100 }, |
| my_vector_of_int8: { vector, element: int8, max_count: 100 }, |
| my_vector_of_int16: { vector, element: int16, max_count: 100 }, |
| my_vector_of_int32: { vector, element: int32, max_count: 100 }, |
| my_vector_of_int64: { vector, element: int64, max_count: 100 }, |
| my_vector_of_string: { |
| vector, |
| element: { string, max_size: 100 }, |
| max_count: 100 |
| }, |
| }; |
| |
| let values: BTreeMap<String, serde_json::Value> = serde_json::from_value(json!({ |
| "my_flag": false, |
| "my_uint8": 255u8, |
| "my_uint16": 65535u16, |
| "my_uint32": 4000000000u32, |
| "my_uint64": 8000000000u64, |
| "my_int8": -127i8, |
| "my_int16": -32766i16, |
| "my_int32": -2000000000i32, |
| "my_int64": -4000000000i64, |
| "my_string": "hello, world!", |
| "my_vector_of_flag": [ true, false ], |
| "my_vector_of_uint8": [ 1, 2, 3 ], |
| "my_vector_of_uint16": [ 2, 3, 4 ], |
| "my_vector_of_uint32": [ 3, 4, 5 ], |
| "my_vector_of_uint64": [ 4, 5, 6 ], |
| "my_vector_of_int8": [ -1, -2, 3 ], |
| "my_vector_of_int16": [ -2, -3, 4 ], |
| "my_vector_of_int32": [ -3, -4, 5 ], |
| "my_vector_of_int64": [ -4, -5, 6 ], |
| "my_vector_of_string": [ "hello, world!", "hello, again!" ], |
| })) |
| .unwrap(); |
| |
| let expected = values_data![ |
| ck@ test_checksum(), |
| Value::Single(SingleValue::Bool(false)), |
| Value::Single(SingleValue::Uint8(255u8)), |
| Value::Single(SingleValue::Uint16(65535u16)), |
| Value::Single(SingleValue::Uint32(4000000000u32)), |
| Value::Single(SingleValue::Uint64(8000000000u64)), |
| Value::Single(SingleValue::Int8(-127i8)), |
| Value::Single(SingleValue::Int16(-32766i16)), |
| Value::Single(SingleValue::Int32(-2000000000i32)), |
| Value::Single(SingleValue::Int64(-4000000000i64)), |
| Value::Single(SingleValue::String("hello, world!".into())), |
| Value::Vector(VectorValue::BoolVector(vec![true, false])), |
| Value::Vector(VectorValue::Uint8Vector(vec![1, 2, 3])), |
| Value::Vector(VectorValue::Uint16Vector(vec![2, 3, 4])), |
| Value::Vector(VectorValue::Uint32Vector(vec![3, 4, 5])), |
| Value::Vector(VectorValue::Uint64Vector(vec![4, 5, 6])), |
| Value::Vector(VectorValue::Int8Vector(vec![-1, -2, 3])), |
| Value::Vector(VectorValue::Int16Vector(vec![-2, -3, 4])), |
| Value::Vector(VectorValue::Int32Vector(vec![-3, -4, 5])), |
| Value::Vector(VectorValue::Int64Vector(vec![-4, -5, 6])), |
| Value::Vector(VectorValue::StringVector(vec!["hello, world!".into(), "hello, again!".into()])), |
| ]; |
| |
| let observed = populate_value_file(&decl, values).unwrap(); |
| assert_eq!(observed, expected); |
| } |
| |
| #[test] |
| fn invalid_field_is_correctly_identified() { |
| let decl = config_decl! { |
| ck@ test_checksum(), |
| my_flag: { bool }, |
| my_uint8: { uint8 }, |
| }; |
| |
| let values: BTreeMap<String, serde_json::Value> = serde_json::from_value(json!({ |
| "my_flag": false, |
| "my_uint8": true, |
| })) |
| .unwrap(); |
| |
| assert_eq!( |
| populate_value_file(&decl, values).unwrap_err(), |
| FileError::InvalidField { |
| key: "my_uint8".to_string(), |
| reason: FieldError::JsonTypeMismatch { |
| expected: JsonTy::Number, |
| received: JsonTy::Bool |
| } |
| } |
| ); |
| } |
| |
| #[test] |
| fn all_keys_must_be_defined() { |
| let decl = config_decl! { |
| ck@ test_checksum(), |
| my_flag: { bool }, |
| my_uint8: { uint8 }, |
| }; |
| |
| let values: BTreeMap<String, serde_json::Value> = serde_json::from_value(json!({ |
| "my_flag": false, |
| })) |
| .unwrap(); |
| |
| assert_eq!( |
| populate_value_file(&decl, values).unwrap_err(), |
| FileError::MissingValue { key: "my_uint8".to_string() } |
| ); |
| } |
| |
| #[test] |
| fn no_extra_keys_can_be_defined() { |
| let decl = config_decl! { |
| ck@ test_checksum(), |
| my_flag: { bool }, |
| }; |
| |
| let values: BTreeMap<String, serde_json::Value> = serde_json::from_value(json!({ |
| "my_flag": false, |
| "my_uint8": 1, |
| "my_uint16": 2, |
| })) |
| .unwrap(); |
| |
| assert_eq!( |
| populate_value_file(&decl, values).unwrap_err(), |
| FileError::ExtraValues { keys: vec!["my_uint16".into(), "my_uint8".into()] } |
| ); |
| } |
| } |
