source.rs (9938B)
1 use fluent_fallback::types::{ResourceType, ToResourceId}; 2 use futures::future::join_all; 3 use l10nregistry_tests::TestFileFetcher; 4 use unic_langid::LanguageIdentifier; 5 6 static FTL_RESOURCE_PRESENT: &str = "toolkit/global/textActions.ftl"; 7 static FTL_RESOURCE_MISSING: &str = "missing.ftl"; 8 9 #[test] 10 fn test_fetch_sync() { 11 let fetcher = TestFileFetcher::new(); 12 let en_us: LanguageIdentifier = "en-US".parse().unwrap(); 13 14 let fs1 = 15 fetcher.get_test_file_source("toolkit", None, vec![en_us.clone()], "toolkit/{locale}/"); 16 17 let file = fs1.fetch_file_sync(&en_us, &FTL_RESOURCE_PRESENT.into(), false); 18 assert!(file.is_some()); 19 assert!(!file.is_none()); 20 assert!(!file.is_required_and_missing()); 21 22 let file = fs1.fetch_file_sync( 23 &en_us, 24 &FTL_RESOURCE_PRESENT.to_resource_id(ResourceType::Required), 25 false, 26 ); 27 assert!(file.is_some()); 28 assert!(!file.is_none()); 29 assert!(!file.is_required_and_missing()); 30 31 let file = fs1.fetch_file_sync( 32 &en_us, 33 &FTL_RESOURCE_PRESENT.to_resource_id(ResourceType::Optional), 34 false, 35 ); 36 assert!(file.is_some()); 37 assert!(!file.is_none()); 38 assert!(!file.is_required_and_missing()); 39 40 let file = fs1.fetch_file_sync(&en_us, &FTL_RESOURCE_MISSING.into(), false); 41 assert!(!file.is_some()); 42 assert!(file.is_none()); 43 assert!(file.is_required_and_missing()); 44 45 let file = fs1.fetch_file_sync( 46 &en_us, 47 &FTL_RESOURCE_MISSING.to_resource_id(ResourceType::Required), 48 false, 49 ); 50 assert!(!file.is_some()); 51 assert!(file.is_none()); 52 assert!(file.is_required_and_missing()); 53 54 let file = fs1.fetch_file_sync( 55 &en_us, 56 &FTL_RESOURCE_MISSING.to_resource_id(ResourceType::Optional), 57 false, 58 ); 59 assert!(!file.is_some()); 60 assert!(file.is_none()); 61 assert!(!file.is_required_and_missing()); 62 } 63 64 #[tokio::test] 65 async fn test_fetch_async() { 66 let fetcher = TestFileFetcher::new(); 67 let en_us: LanguageIdentifier = "en-US".parse().unwrap(); 68 69 let fs1 = 70 fetcher.get_test_file_source("toolkit", None, vec![en_us.clone()], "toolkit/{locale}/"); 71 72 let file = fs1.fetch_file(&en_us, &FTL_RESOURCE_PRESENT.into()).await; 73 assert!(file.is_some()); 74 assert!(!file.is_none()); 75 assert!(!file.is_required_and_missing()); 76 77 let file = fs1 78 .fetch_file( 79 &en_us, 80 &FTL_RESOURCE_PRESENT.to_resource_id(ResourceType::Required), 81 ) 82 .await; 83 assert!(file.is_some()); 84 assert!(!file.is_none()); 85 assert!(!file.is_required_and_missing()); 86 87 let file = fs1 88 .fetch_file( 89 &en_us, 90 &FTL_RESOURCE_PRESENT.to_resource_id(ResourceType::Optional), 91 ) 92 .await; 93 assert!(file.is_some()); 94 assert!(!file.is_none()); 95 assert!(!file.is_required_and_missing()); 96 97 let file = fs1.fetch_file(&en_us, &FTL_RESOURCE_MISSING.into()).await; 98 assert!(!file.is_some()); 99 assert!(file.is_none()); 100 assert!(file.is_required_and_missing()); 101 102 let file = fs1 103 .fetch_file( 104 &en_us, 105 &FTL_RESOURCE_MISSING.to_resource_id(ResourceType::Required), 106 ) 107 .await; 108 assert!(!file.is_some()); 109 assert!(file.is_none()); 110 assert!(file.is_required_and_missing()); 111 112 let file = fs1 113 .fetch_file( 114 &en_us, 115 &FTL_RESOURCE_MISSING.to_resource_id(ResourceType::Optional), 116 ) 117 .await; 118 assert!(!file.is_some()); 119 assert!(file.is_none()); 120 assert!(!file.is_required_and_missing()); 121 } 122 123 #[tokio::test] 124 async fn test_fetch_sync_2_async() { 125 let fetcher = TestFileFetcher::new(); 126 let en_us: LanguageIdentifier = "en-US".parse().unwrap(); 127 128 let fs1 = 129 fetcher.get_test_file_source("toolkit", None, vec![en_us.clone()], "toolkit/{locale}/"); 130 131 assert!(fs1 132 .fetch_file_sync(&en_us, &FTL_RESOURCE_PRESENT.into(), false) 133 .is_some()); 134 assert!(fs1 135 .fetch_file(&en_us, &FTL_RESOURCE_PRESENT.into()) 136 .await 137 .is_some()); 138 assert!(fs1 139 .fetch_file_sync(&en_us, &FTL_RESOURCE_PRESENT.into(), false) 140 .is_some()); 141 } 142 143 #[tokio::test] 144 async fn test_fetch_async_2_sync() { 145 let fetcher = TestFileFetcher::new(); 146 let en_us: LanguageIdentifier = "en-US".parse().unwrap(); 147 148 let fs1 = 149 fetcher.get_test_file_source("toolkit", None, vec![en_us.clone()], "toolkit/{locale}/"); 150 151 assert!(fs1 152 .fetch_file(&en_us, &FTL_RESOURCE_PRESENT.into()) 153 .await 154 .is_some()); 155 assert!(fs1 156 .fetch_file_sync(&en_us, &FTL_RESOURCE_PRESENT.into(), false) 157 .is_some()); 158 } 159 160 #[test] 161 fn test_fetch_has_value_required_sync() { 162 let fetcher = TestFileFetcher::new(); 163 let en_us: LanguageIdentifier = "en-US".parse().unwrap(); 164 let path = FTL_RESOURCE_PRESENT.into(); 165 let path_missing = FTL_RESOURCE_MISSING.into(); 166 167 let fs1 = 168 fetcher.get_test_file_source("toolkit", None, vec![en_us.clone()], "toolkit/{locale}/"); 169 170 assert_eq!(fs1.has_file(&en_us, &path), None); 171 assert!(fs1.fetch_file_sync(&en_us, &path, false).is_some()); 172 assert_eq!(fs1.has_file(&en_us, &path), Some(true)); 173 174 assert_eq!(fs1.has_file(&en_us, &path_missing), None); 175 assert!(fs1.fetch_file_sync(&en_us, &path_missing, false).is_none()); 176 assert_eq!(fs1.has_file(&en_us, &path_missing), Some(false)); 177 } 178 179 #[test] 180 fn test_fetch_has_value_optional_sync() { 181 let fetcher = TestFileFetcher::new(); 182 let en_us: LanguageIdentifier = "en-US".parse().unwrap(); 183 let path = FTL_RESOURCE_PRESENT.to_resource_id(ResourceType::Optional); 184 let path_missing = FTL_RESOURCE_MISSING.to_resource_id(ResourceType::Optional); 185 186 let fs1 = 187 fetcher.get_test_file_source("toolkit", None, vec![en_us.clone()], "toolkit/{locale}/"); 188 189 assert_eq!(fs1.has_file(&en_us, &path), None); 190 assert!(fs1.fetch_file_sync(&en_us, &path, false).is_some()); 191 assert_eq!(fs1.has_file(&en_us, &path), Some(true)); 192 193 assert_eq!(fs1.has_file(&en_us, &path_missing), None); 194 assert!(fs1.fetch_file_sync(&en_us, &path_missing, false).is_none()); 195 assert_eq!(fs1.has_file(&en_us, &path_missing), Some(false)); 196 } 197 198 #[tokio::test] 199 async fn test_fetch_has_value_required_async() { 200 let fetcher = TestFileFetcher::new(); 201 let en_us: LanguageIdentifier = "en-US".parse().unwrap(); 202 let path = FTL_RESOURCE_PRESENT.into(); 203 let path_missing = FTL_RESOURCE_MISSING.into(); 204 205 let fs1 = 206 fetcher.get_test_file_source("toolkit", None, vec![en_us.clone()], "toolkit/{locale}/"); 207 208 assert_eq!(fs1.has_file(&en_us, &path), None); 209 assert!(fs1.fetch_file(&en_us, &path).await.is_some()); 210 println!("Completed"); 211 assert_eq!(fs1.has_file(&en_us, &path), Some(true)); 212 213 assert_eq!(fs1.has_file(&en_us, &path_missing), None); 214 215 assert!(fs1.fetch_file(&en_us, &path_missing).await.is_none()); 216 assert!(fs1 217 .fetch_file(&en_us, &path_missing) 218 .await 219 .is_required_and_missing()); 220 221 assert_eq!(fs1.has_file(&en_us, &path_missing), Some(false)); 222 223 assert!(fs1.fetch_file_sync(&en_us, &path_missing, false).is_none()); 224 assert!(fs1 225 .fetch_file_sync(&en_us, &path_missing, false) 226 .is_required_and_missing()); 227 } 228 229 #[tokio::test] 230 async fn test_fetch_has_value_optional_async() { 231 let fetcher = TestFileFetcher::new(); 232 let en_us: LanguageIdentifier = "en-US".parse().unwrap(); 233 let path = FTL_RESOURCE_PRESENT.to_resource_id(ResourceType::Optional); 234 let path_missing = FTL_RESOURCE_MISSING.to_resource_id(ResourceType::Optional); 235 236 let fs1 = 237 fetcher.get_test_file_source("toolkit", None, vec![en_us.clone()], "toolkit/{locale}/"); 238 239 assert_eq!(fs1.has_file(&en_us, &path), None); 240 assert!(fs1.fetch_file(&en_us, &path).await.is_some()); 241 println!("Completed"); 242 assert_eq!(fs1.has_file(&en_us, &path), Some(true)); 243 244 assert_eq!(fs1.has_file(&en_us, &path_missing), None); 245 assert!(fs1.fetch_file(&en_us, &path_missing).await.is_none()); 246 assert!(!fs1 247 .fetch_file(&en_us, &path_missing) 248 .await 249 .is_required_and_missing()); 250 251 assert_eq!(fs1.has_file(&en_us, &path_missing), Some(false)); 252 253 assert!(fs1.fetch_file_sync(&en_us, &path_missing, false).is_none()); 254 assert!(!fs1 255 .fetch_file_sync(&en_us, &path_missing, false) 256 .is_required_and_missing()); 257 } 258 259 #[tokio::test] 260 async fn test_fetch_async_consecutive() { 261 let fetcher = TestFileFetcher::new(); 262 let en_us: LanguageIdentifier = "en-US".parse().unwrap(); 263 264 let fs1 = 265 fetcher.get_test_file_source("toolkit", None, vec![en_us.clone()], "toolkit/{locale}/"); 266 267 let results = join_all(vec![ 268 fs1.fetch_file(&en_us, &FTL_RESOURCE_PRESENT.into()), 269 fs1.fetch_file(&en_us, &FTL_RESOURCE_PRESENT.into()), 270 ]) 271 .await; 272 assert!(results[0].is_some()); 273 assert!(results[1].is_some()); 274 275 assert!(fs1 276 .fetch_file(&en_us, &FTL_RESOURCE_PRESENT.into()) 277 .await 278 .is_some()); 279 } 280 281 #[test] 282 fn test_indexed() { 283 let fetcher = TestFileFetcher::new(); 284 let en_us: LanguageIdentifier = "en-US".parse().unwrap(); 285 let path = FTL_RESOURCE_PRESENT; 286 let path_missing = FTL_RESOURCE_MISSING; 287 288 let fs1 = fetcher.get_test_file_source_with_index( 289 "toolkit", 290 None, 291 vec![en_us.clone()], 292 "toolkit/{locale}/", 293 vec!["toolkit/en-US/toolkit/global/textActions.ftl"], 294 ); 295 296 assert_eq!(fs1.has_file(&en_us, &path.into()), Some(true)); 297 assert!(fs1.fetch_file_sync(&en_us, &path.into(), false).is_some()); 298 assert_eq!(fs1.has_file(&en_us, &path.into()), Some(true)); 299 300 assert_eq!(fs1.has_file(&en_us, &path_missing.into()), Some(false)); 301 assert!(fs1 302 .fetch_file_sync(&en_us, &path_missing.into(), false) 303 .is_none()); 304 assert_eq!(fs1.has_file(&en_us, &path_missing.into()), Some(false)); 305 }