Add test coverage for fluent-resmgr (#294)

Author: gregtatum

fluent-resmgr/examples/simple-resmgr.rs

@@ -79,7 +79,7 @@ fn main() {
             .collect()
     });
 
-    // 3. Negotiate it against the avialable ones
+    // 3. Negotiate it against the available ones
     let default_locale: LanguageIdentifier = "en-US".parse().expect("Parsing failed.");
     let available = get_available_locales().expect("Retrieving available locales failed.");
     let resolved_locales = negotiate_languages(

fluent-resmgr/src/resource_manager.rs

@@ -15,24 +15,44 @@ fn read_file(path: &str) -> Result<String, io::Error> {
     fs::read_to_string(path)
 }
 
+/// [ResourceManager] provides a standalone solution for managing localization resources which
+/// can be used by `fluent-fallback` or other higher level bindings.
 pub struct ResourceManager {
     resources: FrozenMap<String, Box<FluentResource>>,
     path_scheme: String,
 }
 
 impl ResourceManager {
+    /// Create a new and empty [`ResourceManager`]. As resources are added they will be
+    /// retained in the `resources` [`FrozenMap`]. The `path_scheme` argument defines
+    /// how the files are organized.
+    ///
+    /// For instance `"./translations/{locale}/{res_id}"` will load files with the
+    /// following structure:
+    ///
+    /// .
+    /// └── translations
+    ///     ├── en-US
+    ///     │   ├── app.ftl
+    ///     │   └── errors.ftl
+    ///     └── pl
+    ///         ├── app.ftl
+    ///         └── errors.ftl
+    ///
     pub fn new(path_scheme: String) -> Self {
         ResourceManager {
             resources: FrozenMap::new(),
             path_scheme,
         }
     }
 
-    fn get_resource(&self, res_id: &str, locale: &str) -> &FluentResource {
+    /// Returns a [`FluentResource`], by either reading the file and loading it into
+    /// memory, or retrieving it from an in-memory cache.
+    fn get_resource(&self, resource_id: &str, locale: &str) -> &FluentResource {
         let path = self
             .path_scheme
             .replace("{locale}", locale)
-            .replace("{res_id}", res_id);
+            .replace("{res_id}", resource_id);
         if let Some(res) = self.resources.get(&path) {
             res
         } else {
@@ -45,34 +65,44 @@ impl ResourceManager {
         }
     }
 
+    /// Gets a [`FluentBundle`] from a list of resources. The bundle will only contain the
+    /// resources from the first locale in the locales list. The other locales will be
+    /// stored in the [`FluentBundle`] and will only be used for custom formatters such
+    /// date time format, or plural rules. The message formatting will not fall back
+    /// to other locales.
     pub fn get_bundle(
         &self,
         locales: Vec<LanguageIdentifier>,
         resource_ids: Vec<String>,
     ) -> FluentBundle<&FluentResource> {
         let mut bundle = FluentBundle::new(locales.clone());
         for res_id in &resource_ids {
+            println!("res_id {:?}", res_id);
             let res = self.get_resource(res_id, &locales[0].to_string());
             bundle.add_resource(res).unwrap();
         }
         bundle
     }
 
+    /// Returns an iterator for a [`FluentBundle`] for each locale provided. Each
+    /// iteration will load all of the resources for that single locale. i18n formatters
+    /// such as date time format and plural rules will ignore the list of locales,
+    /// unlike `get_bundle` and only use the single locale of the bundle.
     pub fn get_bundles(
         &self,
         locales: Vec<LanguageIdentifier>,
         resource_ids: Vec<String>,
     ) -> impl Iterator<Item = FluentBundle<&FluentResource>> {
         let res_mgr = self;
-        let mut ptr = 0;
+        let mut idx = 0;
 
         iter::from_fn(move || {
-            locales.get(ptr).map(|locale| {
-                ptr += 1;
+            locales.get(idx).map(|locale| {
+                idx += 1;
                 let mut bundle = FluentBundle::new(vec![locale.clone()]);
-                for res_id in &resource_ids {
-                    let res = res_mgr.get_resource(res_id, &locale.to_string());
-                    bundle.add_resource(res).unwrap();
+                for resource_id in &resource_ids {
+                    let resource = res_mgr.get_resource(resource_id, &locale.to_string());
+                    bundle.add_resource(resource).unwrap();
                 }
                 bundle
             })
@@ -105,6 +135,10 @@ impl Iterator for BundleIter {
     }
 }
 
+// TODO - These need to be implemented.
+// https://github.com/projectfluent/fluent-rs/issues/281
+
+// coverage(off)
 impl Stream for BundleIter {
     type Item = FluentBundleResult<FluentResource>;
 
@@ -138,3 +172,72 @@ impl BundleGenerator for ResourceManager {
         todo!()
     }
 }
+// coverage(on)
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use unic_langid::langid;
+
+    #[test]
+    fn caching() {
+        let res_mgr = ResourceManager::new("./tests/resources/{locale}/{res_id}".into());
+
+        let _bundle = res_mgr.get_bundle(vec![langid!("en-US")], vec!["test.ftl".into()]);
+        let res_1 = res_mgr.get_resource("test.ftl", "en-US");
+
+        let _bundle2 = res_mgr.get_bundle(vec![langid!("en-US")], vec!["test.ftl".into()]);
+        let res_2 = res_mgr.get_resource("test.ftl", "en-US");
+
+        assert!(
+            std::ptr::eq(res_1, res_2),
+            "The resources are cached in memory and reference the same thing."
+        );
+    }
+
+    // TODO - This API should return a Result instead.
+    // https://github.com/projectfluent/fluent-rs/issues/278
+    #[test]
+    #[should_panic]
+    fn get_resource_error() {
+        let res_mgr = ResourceManager::new("./tests/resources/{locale}/{res_id}".into());
+
+        let _bundle = res_mgr.get_bundle(vec![langid!("en-US")], vec!["test.ftl".into()]);
+        res_mgr.get_resource("nonexistent.ftl", "en-US");
+    }
+
+    // TODO - This API should return a Result instead.
+    // https://github.com/projectfluent/fluent-rs/issues/278
+    #[test]
+    #[should_panic]
+    fn get_bundle_error() {
+        let res_mgr = ResourceManager::new("./tests/resources/{locale}/{res_id}".into());
+        let _bundle = res_mgr.get_bundle(vec![langid!("en-US")], vec!["nonexistent.ftl".into()]);
+    }
+
+    // TODO - Syntax errors should be surfaced. This test has an invalid resource that
+    // should fail, but currently isn't.
+    // https://github.com/projectfluent/fluent-rs/issues/280
+    #[test]
+    fn get_bundle_ignores_errors() {
+        let res_mgr = ResourceManager::new("./tests/resources/{locale}/{res_id}".into());
+        let bundle = res_mgr.get_bundle(
+            vec![langid!("en-US")],
+            vec!["test.ftl".into(), "invalid.ftl".into()],
+        );
+
+        let mut errors = vec![];
+        let msg = bundle.get_message("hello-world").expect("Message exists");
+        let pattern = msg.value().expect("Message has a value");
+        let value = bundle.format_pattern(&pattern, None, &mut errors);
+        assert_eq!(value, "Hello World");
+        assert!(errors.is_empty());
+
+        let mut errors = vec![];
+        let msg = bundle.get_message("valid-message").expect("Message exists");
+        let pattern = msg.value().expect("Message has a value");
+        let value = bundle.format_pattern(&pattern, None, &mut errors);
+        assert_eq!(value, "This is a valid message");
+        assert!(errors.is_empty());
+    }
+}

fluent-resmgr/tests/localization_test.rs

@@ -44,3 +44,33 @@ fn resmgr_get_bundle() {
     let value = bundle.format_pattern(pattern, None, &mut errors);
     assert_eq!(value, "Hello World");
 }
+
+#[test]
+fn resmgr_get_bundles() {
+    let res_mgr = ResourceManager::new("./tests/resources/{locale}/{res_id}".into());
+
+    let locales = vec![langid!("en-US"), langid!("pl")];
+    let mut bundles_iter = res_mgr.get_bundles(locales.clone(), vec!["test.ftl".into()]);
+
+    {
+        let bundle = bundles_iter.next().expect("Failed to get en-US bundle.");
+
+        let mut errors = vec![];
+        let msg = bundle.get_message("hello-world").expect("Message exists");
+        let pattern = msg.value().expect("Message has a value");
+        let value = bundle.format_pattern(&pattern, None, &mut errors);
+        assert_eq!(value, "Hello World");
+    }
+
+    {
+        let bundle = bundles_iter.next().expect("Failed to get pl bundle.");
+
+        let mut errors = vec![];
+        let msg = bundle.get_message("hello-world").expect("Witaj Świecie");
+        let pattern = msg.value().expect("Message has a value");
+        let value = bundle.format_pattern(&pattern, None, &mut errors);
+        assert_eq!(value, "Witaj Świecie");
+    }
+
+    assert!(bundles_iter.next().is_none(), "The iterator is consumed.");
+}

fluent-resmgr/tests/resources/en-US/invalid.ftl

@@ -0,0 +1,3 @@
+valid-message = This is a valid message
+
+However, this will be a syntax error.