summaryrefslogtreecommitdiffstats
path: root/intl/l10n/rust/l10nregistry-rs/tests/localization.rs
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--intl/l10n/rust/l10nregistry-rs/tests/localization.rs201
1 files changed, 201 insertions, 0 deletions
diff --git a/intl/l10n/rust/l10nregistry-rs/tests/localization.rs b/intl/l10n/rust/l10nregistry-rs/tests/localization.rs
new file mode 100644
index 0000000000..dd6d7d9c9f
--- /dev/null
+++ b/intl/l10n/rust/l10nregistry-rs/tests/localization.rs
@@ -0,0 +1,201 @@
+use std::borrow::Cow;
+
+use fluent_fallback::{
+ env::LocalesProvider,
+ types::{L10nKey, ResourceId},
+ Localization,
+};
+use l10nregistry::testing::{
+ FileSource, MockBundleAdapter, RegistrySetup, TestEnvironment, TestFileFetcher,
+};
+use serial_test::serial;
+use unic_langid::{langid, LanguageIdentifier};
+
+type L10nRegistry = l10nregistry::registry::L10nRegistry<TestEnvironment, MockBundleAdapter>;
+
+static LOCALES: &[LanguageIdentifier] = &[langid!("pl"), langid!("en-US")];
+static mut FILE_FETCHER: Option<TestFileFetcher> = None;
+static mut L10N_REGISTRY: Option<L10nRegistry> = None;
+
+const FTL_RESOURCE: &str = "toolkit/updates/history.ftl";
+const L10N_ID_PL_EN: (&str, Option<&str>) = ("history-title", Some("Historia aktualizacji"));
+const L10N_ID_MISSING: (&str, Option<&str>) = ("missing-id", None);
+const L10N_ID_ONLY_EN: (&str, Option<&str>) = (
+ "history-intro",
+ Some("The following updates have been installed"),
+);
+
+fn get_file_fetcher() -> &'static TestFileFetcher {
+ let fetcher: &mut Option<TestFileFetcher> = unsafe { &mut FILE_FETCHER };
+
+ fetcher.get_or_insert_with(|| TestFileFetcher::new())
+}
+
+fn get_l10n_registry() -> &'static L10nRegistry {
+ let reg: &mut Option<L10nRegistry> = unsafe { &mut L10N_REGISTRY };
+
+ reg.get_or_insert_with(|| {
+ let fetcher = get_file_fetcher();
+ let setup = RegistrySetup::new(
+ "test",
+ vec![
+ FileSource::new(
+ "toolkit",
+ None,
+ get_app_locales().to_vec(),
+ "toolkit/{locale}/",
+ ),
+ FileSource::new(
+ "browser",
+ None,
+ get_app_locales().to_vec(),
+ "browser/{locale}/",
+ ),
+ ],
+ get_app_locales().to_vec(),
+ );
+ fetcher.get_registry_and_environment(setup).1
+ })
+}
+
+fn get_app_locales() -> &'static [LanguageIdentifier] {
+ LOCALES
+}
+
+struct LocalesService;
+
+impl LocalesProvider for LocalesService {
+ type Iter = std::vec::IntoIter<LanguageIdentifier>;
+
+ fn locales(&self) -> Self::Iter {
+ get_app_locales().to_vec().into_iter()
+ }
+}
+
+fn sync_localization(
+ reg: &'static L10nRegistry,
+ res_ids: Vec<ResourceId>,
+) -> Localization<L10nRegistry, LocalesService> {
+ Localization::with_env(res_ids, true, LocalesService, reg.clone())
+}
+
+fn async_localization(
+ reg: &'static L10nRegistry,
+ res_ids: Vec<ResourceId>,
+) -> Localization<L10nRegistry, LocalesService> {
+ Localization::with_env(res_ids, false, LocalesService, reg.clone())
+}
+
+fn setup_sync_test() -> Localization<L10nRegistry, LocalesService> {
+ sync_localization(get_l10n_registry(), vec![FTL_RESOURCE.into()])
+}
+
+fn setup_async_test() -> Localization<L10nRegistry, LocalesService> {
+ async_localization(get_l10n_registry(), vec![FTL_RESOURCE.into()])
+}
+
+#[test]
+#[serial]
+fn localization_format_value_sync() {
+ let loc = setup_sync_test();
+ let bundles = loc.bundles();
+ let mut errors = vec![];
+
+ for query in &[L10N_ID_PL_EN, L10N_ID_MISSING, L10N_ID_ONLY_EN] {
+ let value = bundles
+ .format_value_sync(query.0, None, &mut errors)
+ .unwrap();
+ assert_eq!(value, query.1.map(|s| Cow::Borrowed(s)));
+ }
+
+ assert_eq!(errors.len(), 4);
+}
+
+#[test]
+#[serial]
+fn localization_format_values_sync() {
+ let loc = setup_sync_test();
+ let bundles = loc.bundles();
+ let mut errors = vec![];
+
+ let ids = &[L10N_ID_PL_EN, L10N_ID_MISSING, L10N_ID_ONLY_EN];
+ let keys = ids
+ .iter()
+ .map(|query| L10nKey {
+ id: query.0.into(),
+ args: None,
+ })
+ .collect::<Vec<_>>();
+
+ let values = bundles.format_values_sync(&keys, &mut errors).unwrap();
+
+ assert_eq!(values.len(), ids.len());
+
+ for (value, query) in values.iter().zip(ids) {
+ if let Some(expected) = query.1 {
+ assert_eq!(*value, Some(Cow::Borrowed(expected)));
+ }
+ }
+ assert_eq!(errors.len(), 4);
+}
+
+#[tokio::test]
+#[serial]
+async fn localization_format_value_async() {
+ let loc = setup_async_test();
+ let bundles = loc.bundles();
+ let mut errors = vec![];
+
+ for query in &[L10N_ID_PL_EN, L10N_ID_MISSING, L10N_ID_ONLY_EN] {
+ let value = bundles.format_value(query.0, None, &mut errors).await;
+ if let Some(expected) = query.1 {
+ assert_eq!(value, Some(Cow::Borrowed(expected)));
+ }
+ }
+}
+
+#[tokio::test]
+#[serial]
+async fn localization_format_values_async() {
+ let loc = setup_async_test();
+ let bundles = loc.bundles();
+ let mut errors = vec![];
+
+ let ids = &[L10N_ID_PL_EN, L10N_ID_MISSING, L10N_ID_ONLY_EN];
+ let keys = ids
+ .iter()
+ .map(|query| L10nKey {
+ id: query.0.into(),
+ args: None,
+ })
+ .collect::<Vec<_>>();
+
+ let values = bundles.format_values(&keys, &mut errors).await;
+
+ assert_eq!(values.len(), ids.len());
+
+ for (value, query) in values.iter().zip(ids) {
+ if let Some(expected) = query.1 {
+ assert_eq!(*value, Some(Cow::Borrowed(expected)));
+ }
+ }
+}
+
+#[tokio::test]
+#[serial]
+async fn localization_upgrade() {
+ let mut loc = setup_sync_test();
+ let bundles = loc.bundles();
+ let mut errors = vec![];
+ let value = bundles
+ .format_value_sync(L10N_ID_PL_EN.0, None, &mut errors)
+ .unwrap();
+ assert_eq!(value, L10N_ID_PL_EN.1.map(|s| Cow::Borrowed(s)));
+
+ loc.set_async();
+ let bundles = loc.bundles();
+ let value = bundles
+ .format_value(L10N_ID_PL_EN.0, None, &mut errors)
+ .await;
+ assert_eq!(value, L10N_ID_PL_EN.1.map(|s| Cow::Borrowed(s)));
+}