#8539 Config preferences backend restructure

components/config/tests/opts.rs

@@ -2,8 +2,11 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
+#[macro_use]
+extern crate servo_config;
+
 use servo_config::opts::{parse_pref_from_command_line, parse_url_or_filename};
-use servo_config::prefs::{PrefValue, PREFS};
+use servo_config::{prefs, prefs::PrefValue};
 use std::path::Path;
 
 #[cfg(not(target_os = "windows"))]
@@ -86,25 +89,53 @@ fn test_argument_parsing_special() {
     assert_eq!(url.fragment(), None);
 }
 
+#[test]
+fn test_invalid_prefs_from_command_line_panics() {
+    let err_msg = std::panic::catch_unwind(|| {
+        parse_pref_from_command_line("doesntexist=true");
+    })
+    .err()
+    .and_then(|a| a.downcast_ref::<String>().cloned())
+    .expect("Should panic");
+    assert!(
+        err_msg.starts_with("Error setting preference"),
+        "Message should describe the problem"
+    );
+    assert!(
+        err_msg.contains("doesntexist"),
+        "Message should mention the name of the preference"
+    );
+}
+
 #[test]
 fn test_parse_pref_from_command_line() {
     // Test with boolean values.
-    parse_pref_from_command_line("testtrue=true");
-    assert_eq!(*PREFS.get("testtrue"), PrefValue::Boolean(true));
-    parse_pref_from_command_line("testfalse=false");
-    assert_eq!(*PREFS.get("testfalse"), PrefValue::Boolean(false));
+    parse_pref_from_command_line("dom.bluetooth.enabled=true");
+    assert_eq!(
+        prefs::pref_map().get("dom.bluetooth.enabled"),
+        PrefValue::Bool(true)
+    );
+    assert_eq!(pref!(dom.bluetooth.enabled), true);
 
-    // Test with numbers.
-    parse_pref_from_command_line("testint=42");
-    assert_eq!(*PREFS.get("testint"), PrefValue::Number(42 as f64));
-    parse_pref_from_command_line("testfloat=4.2");
-    assert_eq!(*PREFS.get("testfloat"), PrefValue::Number(4.2));
+    parse_pref_from_command_line("dom.bluetooth.enabled=false");
+    assert_eq!(
+        prefs::pref_map().get("dom.bluetooth.enabled"),
+        PrefValue::Bool(false)
+    );
+    assert_eq!(pref!(dom.bluetooth.enabled), false);
 
-    // Test default (string).
-    parse_pref_from_command_line("teststr=str");
-    assert_eq!(*PREFS.get("teststr"), PrefValue::String("str".to_owned()));
+    // Test with numbers
+    parse_pref_from_command_line("layout.threads=42");
+    assert_eq!(pref!(layout.threads), 42);
 
-    // Test with no value.
-    parse_pref_from_command_line("testempty");
-    assert_eq!(*PREFS.get("testempty"), PrefValue::Boolean(true));
+    // Test string.
+    parse_pref_from_command_line("shell.homepage=str");
+    assert_eq!(pref!(shell.homepage), "str");
+
+    // Test with no value (defaults to true).
+    prefs::pref_map()
+        .set("dom.bluetooth.enabled", false)
+        .unwrap();
+    parse_pref_from_command_line("dom.bluetooth.enabled");
+    assert_eq!(pref!(dom.bluetooth.enabled), true);
 }

components/config/tests/prefs.rs

@@ -2,60 +2,246 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
+#[macro_use]
+extern crate serde_derive;
+
 use servo_config::basedir;
-use servo_config::prefs::{read_prefs, PrefValue, PREFS};
+use servo_config::pref_util::Preferences;
+use servo_config::prefs::{read_prefs_map, PrefValue};
+use std::collections::HashMap;
+use std::error::Error;
 use std::fs::{self, File};
 use std::io::{Read, Write};
 
 #[test]
-fn test_create_pref() {
-    let json_str = "{\
-                    \"layout.writing-mode.enabled\": true,\
-                    \"network.mime.sniff\": false,\
-                    \"shell.homepage\": \"https://servo.org\"\
-                    }";
-
-    let prefs = read_prefs(json_str);
+fn test_create_prefs_map() {
+    let json_str = "{
+        \"layout.writing-mode.enabled\": true,
+        \"network.mime.sniff\": false,
+        \"shell.homepage\": \"https://servo.org\"
+    }";
+    let prefs = read_prefs_map(json_str);
     assert!(prefs.is_ok());
     let prefs = prefs.unwrap();
-
     assert_eq!(prefs.len(), 3);
 }
 
 #[test]
-fn test_get_set_reset_extend() {
-    let json_str = "{\
-                    \"layout.writing-mode.enabled\": true,\
-                    \"extra.stuff\": false,\
-                    \"shell.homepage\": \"https://google.com\"\
-                    }";
+fn test_generated_accessors_get() {
+    let prefs: gen::TestPrefs = serde_json::from_str(DEF_JSON_STR).unwrap();
+    let map: HashMap<String, PrefValue> = gen::TEST_PREF_ACCESSORS
+        .iter()
+        .map(move |(key, accessor)| {
+            let pref_value = (accessor.getter)(&prefs);
+            (key.clone(), pref_value)
+        })
+        .collect();
 
-    assert_eq!(*PREFS.get("test"), PrefValue::Missing);
-    PREFS.set("test", PrefValue::String("hi".to_owned()));
-    assert_eq!(*PREFS.get("test"), PrefValue::String("hi".to_owned()));
+    assert_eq!(&PrefValue::from("hello"), map.get("pref_string").unwrap());
+    assert_eq!(&PrefValue::from(23_i64), map.get("pref_i64").unwrap());
+    assert_eq!(&PrefValue::from(1.5_f64), map.get("pref_f64").unwrap());
+    assert_eq!(&PrefValue::from(true), map.get("pref_bool").unwrap());
     assert_eq!(
-        *PREFS.get("shell.homepage"),
-        PrefValue::String("https://servo.org".to_owned())
-    );
-    PREFS.set("shell.homepage", PrefValue::Boolean(true));
-    assert_eq!(*PREFS.get("shell.homepage"), PrefValue::Boolean(true));
-    PREFS.reset("shell.homepage");
-    assert_eq!(
-        *PREFS.get("shell.homepage"),
-        PrefValue::String("https://servo.org".to_owned())
+        &PrefValue::from(333_i64),
+        map.get("group.nested.nested_i64").unwrap()
     );
+    assert_eq!(&PrefValue::from(42_i64), map.get("a.renamed.pref").unwrap());
+}
 
-    let extension = read_prefs(json_str).unwrap();
-    PREFS.extend(extension);
-    assert_eq!(
-        *PREFS.get("shell.homepage"),
-        PrefValue::String("https://google.com".to_owned())
+#[test]
+fn test_generated_accessors_set() {
+    let mut prefs: gen::TestPrefs = serde_json::from_str(DEF_JSON_STR).unwrap();
+    let setters: HashMap<String, _> = gen::TEST_PREF_ACCESSORS
+        .iter()
+        .map(|(key, accessor)| (key.clone(), &accessor.setter))
+        .collect();
+
+    (setters.get("pref_string").unwrap())(&mut prefs, PrefValue::Str(String::from("boo")));
+    (setters.get("pref_i64").unwrap())(&mut prefs, PrefValue::Int(-25));
+    (setters.get("pref_f64").unwrap())(&mut prefs, PrefValue::Float(-1.9));
+    (setters.get("pref_bool").unwrap())(&mut prefs, PrefValue::Bool(false));
+    (setters.get("group.nested.nested_i64").unwrap())(&mut prefs, PrefValue::Int(10));
+    (setters.get("a.renamed.pref").unwrap())(&mut prefs, PrefValue::Int(11));
+
+    assert_eq!("boo", prefs.pref_string);
+    assert_eq!(-25, prefs.pref_i64);
+    assert_eq!(-1.9, prefs.pref_f64);
+    assert_eq!(false, prefs.pref_bool);
+    assert_eq!(10, prefs.group.nested.nested_i64);
+    assert_eq!(11, prefs.group.nested.renamed);
+}
+
+#[test]
+fn test_static_struct() {
+    let prefs: gen::TestPrefs = serde_json::from_str(DEF_JSON_STR).unwrap();
+    assert_eq!("hello", prefs.pref_string);
+    assert_eq!(23, prefs.pref_i64);
+    assert_eq!(1.5, prefs.pref_f64);
+    assert_eq!(true, prefs.pref_bool);
+    assert_eq!(333, prefs.group.nested.nested_i64);
+    assert_eq!(42, prefs.group.nested.renamed);
+}
+
+#[test]
+fn test_set_pref() {
+    let prefs = Preferences::new(gen::TestPrefs::default(), &gen::TEST_PREF_ACCESSORS);
+    assert_eq!(Some(0), prefs.get("group.nested.nested_i64").as_i64());
+    let result = prefs.set("group.nested.nested_i64", 1);
+    assert_eq!(true, result.is_ok());
+    assert_eq!(Some(1), prefs.get("group.nested.nested_i64").as_i64());
+    assert_eq!(1, prefs.values().read().unwrap().group.nested.nested_i64);
+}
+
+#[test]
+fn test_set_unknown_pref_is_err() -> Result<(), Box<dyn Error>> {
+    let prefs = Preferences::new(gen::TestPrefs::default(), &gen::TEST_PREF_ACCESSORS);
+    let result = prefs.set("unknown_pref", 1);
+    assert_eq!(true, result.is_err());
+    Ok(())
+}
+
+#[test]
+fn test_reset_pref() -> Result<(), Box<dyn Error>> {
+    let mut def_prefs = gen::TestPrefs::default();
+    def_prefs.group.nested.nested_i64 = 999;
+    let prefs = Preferences::new(def_prefs, &gen::TEST_PREF_ACCESSORS);
+    assert_eq!(Some(999), prefs.get("group.nested.nested_i64").as_i64());
+
+    prefs.set("group.nested.nested_i64", 1)?;
+    assert_eq!(Some(1), prefs.get("group.nested.nested_i64").as_i64());
+
+    prefs.reset("group.nested.nested_i64")?;
+    assert_eq!(Some(999), prefs.get("group.nested.nested_i64").as_i64());
+    assert_eq!(999, prefs.values().read().unwrap().group.nested.nested_i64);
+    Ok(())
+}
+
+#[test]
+fn test_default_values() -> Result<(), Box<dyn Error>> {
+    let def_prefs: gen::TestPrefs = serde_json::from_str(DEF_JSON_STR)?;
+    let prefs = Preferences::new(def_prefs, &gen::TEST_PREF_ACCESSORS);
+    assert_eq!(Some(0), prefs.get("default_value").as_i64());
+    assert_eq!(Some(555), prefs.get("computed_default_value").as_i64());
+    Ok(())
+}
+
+#[test]
+fn test_override_default_values() -> Result<(), Box<dyn Error>> {
+    let def_prefs: gen::TestPrefs = serde_json::from_str(WITHOUT_DEFAULTS_JSON_STR)?;
+    let prefs = Preferences::new(def_prefs, &gen::TEST_PREF_ACCESSORS);
+    assert_eq!(Some(-1), prefs.get("default_value").as_i64());
+    assert_eq!(Some(-1), prefs.get("computed_default_value").as_i64());
+    Ok(())
+}
+
+#[test]
+fn test_update_reset_default_values() -> Result<(), Box<dyn Error>> {
+    let def_prefs: gen::TestPrefs = serde_json::from_str(DEF_JSON_STR)?;
+    let prefs = Preferences::new(def_prefs, &gen::TEST_PREF_ACCESSORS);
+
+    prefs.set("default_value", 99)?;
+    prefs.set("computed_default_value", 199)?;
+    assert_eq!(Some(99), prefs.get("default_value").as_i64());
+    assert_eq!(Some(199), prefs.get("computed_default_value").as_i64());
+
+    prefs.reset("default_value")?;
+    prefs.reset("computed_default_value")?;
+    assert_eq!(Some(0), prefs.get("default_value").as_i64());
+    assert_eq!(Some(555), prefs.get("computed_default_value").as_i64());
+    Ok(())
+}
+
+#[test]
+fn test_update_reset_overridden_default_values() -> Result<(), Box<dyn Error>> {
+    let def_prefs: gen::TestPrefs = serde_json::from_str(WITHOUT_DEFAULTS_JSON_STR)?;
+    let prefs = Preferences::new(def_prefs, &gen::TEST_PREF_ACCESSORS);
+    prefs.set("default_value", 99)?;
+    prefs.set("computed_default_value", 199)?;
+    assert_eq!(Some(99), prefs.get("default_value").as_i64());
+    assert_eq!(Some(199), prefs.get("computed_default_value").as_i64());
+
+    prefs.reset("default_value")?;
+    prefs.reset("computed_default_value")?;
+    assert_eq!(Some(-1), prefs.get("default_value").as_i64());
+    assert_eq!(Some(-1), prefs.get("computed_default_value").as_i64());
+    Ok(())
+}
+
+#[test]
+fn test_user_prefs_override_and_reset() -> Result<(), Box<dyn Error>> {
+    let mut def_prefs = gen::TestPrefs::default();
+    def_prefs.group.nested.nested_i64 = 999;
+    let prefs = Preferences::new(def_prefs, &gen::TEST_PREF_ACCESSORS);
+
+    prefs.set("group.nested.nested_i64", 45)?;
+    assert_eq!(Some(45), prefs.get("group.nested.nested_i64").as_i64());
+
+    prefs.reset("group.nested.nested_i64")?;
+    assert_eq!(Some(999), prefs.get("group.nested.nested_i64").as_i64());
+    Ok(())
+}
+
+#[test]
+fn test_reset_all() -> Result<(), Box<dyn Error>> {
+    let def_prefs: gen::TestPrefs = serde_json::from_str(DEF_JSON_STR)?;
+    let prefs = Preferences::new(def_prefs, &gen::TEST_PREF_ACCESSORS);
+    prefs.set_all(read_prefs_map(USER_JSON_STR)?)?;
+
+    let values = prefs.values();
+    assert_eq!("bye", values.read().unwrap().pref_string);
+    assert_eq!(-1, values.read().unwrap().pref_i64);
+    assert_eq!(-1.0, values.read().unwrap().pref_f64);
+    assert_eq!(false, values.read().unwrap().pref_bool);
+    assert_eq!(-1, values.read().unwrap().group.nested.nested_i64);
+    assert_eq!(-1, values.read().unwrap().group.nested.renamed);
+
+    prefs.reset_all();
+
+    let values = prefs.values();
+    assert_eq!("hello", values.read().unwrap().pref_string);
+    assert_eq!(23, values.read().unwrap().pref_i64);
+    assert_eq!(1.5, values.read().unwrap().pref_f64);
+    assert_eq!(true, values.read().unwrap().pref_bool);
+    assert_eq!(333, values.read().unwrap().group.nested.nested_i64);
+    assert_eq!(42, values.read().unwrap().group.nested.renamed);
+    Ok(())
+}
+
+#[test]
+fn test_set_all_from_map() -> Result<(), Box<dyn Error>> {
+    let def_prefs: gen::TestPrefs = serde_json::from_str(DEF_JSON_STR)?;
+    let prefs = Preferences::new(def_prefs, &gen::TEST_PREF_ACCESSORS);
+    prefs.set_all(read_prefs_map(USER_JSON_STR)?)?;
+
+    let mut overrides = HashMap::new();
+    overrides.insert(String::from("pref_string"), PrefValue::from("new value"));
+    overrides.insert(
+        String::from("group.nested.nested_i64"),
+        PrefValue::from(1001),
     );
-    assert_eq!(
-        *PREFS.get("layout.writing-mode.enabled"),
-        PrefValue::Boolean(true)
-    );
-    assert_eq!(*PREFS.get("extra.stuff"), PrefValue::Boolean(false));
+    overrides.insert(String::from("a.renamed.pref"), PrefValue::from(47));
+
+    let result = prefs.set_all(overrides.into_iter());
+    assert_eq!(true, result.is_ok());
+
+    let values = prefs.values();
+    assert_eq!("new value", values.read().unwrap().pref_string);
+    assert_eq!(1001, values.read().unwrap().group.nested.nested_i64);
+    assert_eq!(47, values.read().unwrap().group.nested.renamed);
+    Ok(())
+}
+
+#[test]
+fn test_set_all_error_on_unknown_field() -> Result<(), Box<dyn Error>> {
+    let def_prefs: gen::TestPrefs = serde_json::from_str(DEF_JSON_STR)?;
+    let prefs = Preferences::new(def_prefs, &gen::TEST_PREF_ACCESSORS);
+
+    let mut overrides = HashMap::new();
+    overrides.insert(String::from("doesnt_exist"), PrefValue::from(1001));
+
+    let result = prefs.set_all(overrides.into_iter());
+    assert_eq!(true, result.is_err());
+    Ok(())
 }
 
 #[cfg(not(target_os = "android"))]
@@ -86,3 +272,63 @@ fn test_default_config_dir_create_read_write() {
 
     fs::remove_file(&json_path).unwrap();
 }
+
+static DEF_JSON_STR: &'static str = r#"{
+    "pref_string": "hello",
+    "pref_i64": 23,
+    "pref_f64": 1.5,
+    "pref_bool": true,
+    "group.nested.nested_i64": 333,
+    "a.renamed.pref": 42
+}"#;
+
+static USER_JSON_STR: &'static str = r#"{
+    "pref_string": "bye",
+    "pref_i64": -1,
+    "pref_f64": -1.0,
+    "pref_bool": false,
+    "group.nested.nested_i64": -1,
+    "a.renamed.pref": -1
+}"#;
+
+static WITHOUT_DEFAULTS_JSON_STR: &'static str = r#"{
+    "pref_string": "bye",
+    "pref_i64": -1,
+    "pref_f64": -1.0,
+    "pref_bool": false,
+    "group.nested.nested_i64": -1,
+    "a.renamed.pref": -1,
+    "computed_default_value": -1,
+    "default_value": -1
+}"#;
+
+mod gen {
+    use servo_config::pref_util::{Accessor, PrefValue};
+    use servo_config_plugins::build_structs;
+
+    fn compute_default() -> i64 {
+        555
+    }
+
+    build_structs! {
+        accessor_type = Accessor::<TestPrefs, PrefValue>,
+        gen_accessors = TEST_PREF_ACCESSORS,
+        gen_types = TestPrefs {
+            pref_string: String,
+            pref_i64: i64,
+            pref_f64: f64,
+            pref_bool: bool,
+            #[serde(default)]
+            default_value: i64,
+            #[serde(default = "compute_default")]
+            computed_default_value: i64,
+            group: {
+                nested: {
+                    nested_i64: i64,
+                    #[serde(rename = "a.renamed.pref")]
+                    renamed: i64,
+                }
+            }
+        }
+    }
+}