Source code
Revision control
Copy as Markdown
Other Tools
Test Info: Warnings
- This test gets skipped with pattern: os == 'android'
- Manifest: toolkit/modules/tests/xpcshell/xpcshell.toml
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
ChromeUtils.defineESModuleGetters(this, {
Region: "resource://gre/modules/Region.sys.mjs",
SharedRemoteSettingsService:
"resource://gre/modules/RustSharedRemoteSettingsService.sys.mjs",
});
// When the app's region or locale changes, `SharedRemoteSettingsService` should
// update its country and locale.
add_task(async function regionOrLocaleChanged() {
let tests = [
{ country: "US", locale: "en-US" },
{ country: "US", locale: "es-MX" },
{ country: "DE", locale: "de" },
{ country: "DE", locale: "en-US" },
];
for (let { country, locale } of tests) {
await withRegionAndLocale({
locale,
region: country,
callback: async () => {
await waitForServiceCountryAndLocale({ country, locale });
Assert.equal(
SharedRemoteSettingsService.country,
country,
"SharedRemoteSettingsService.country should be the expected country"
);
Assert.equal(
SharedRemoteSettingsService.locale,
locale,
"SharedRemoteSettingsService.locale should be the expected locale"
);
},
});
}
});
// When the app's region or locale changes, the service's server URL should not
// change. This task makes sure we use the correct server URL when we update the
// config in response to region or locale changes.
add_task(async function serverUrl() {
let countriesAndLocales = [
{ newLocale: "de" },
{ newCountry: "DE" },
{ newCountry: "DE", newLocale: "de" },
];
let serverUrls = [
undefined,
Utils.SERVER_URL,
];
for (let { newCountry, newLocale } of countriesAndLocales) {
for (let url of serverUrls) {
await doServerUrlTest({ newCountry, newLocale, url });
}
}
});
async function doServerUrlTest({
url,
newCountry = "US",
newLocale = "en-US",
}) {
// First, set an initial app country and locale.
await withRegionAndLocale({
region: "US",
locale: "en-US",
callback: async () => {
await waitForServiceCountryAndLocale({ country: "US", locale: "en-US" });
// Set the initial server URL.
SharedRemoteSettingsService.updateServer({ url });
// Now update the app country and locale.
await withRegionAndLocale({
region: newCountry,
locale: newLocale,
callback: async () => {
await waitForServiceCountryAndLocale({
country: newCountry,
locale: newLocale,
});
// The server URL set above should remain set.
if (!url || url == Utils.SERVER_URL) {
// A falsey URL should fall back to `Utils.SERVER_URL`, and during
// testing `Utils.SERVER_URL` is a cannot-be-a-base URL, so the
// server should be undefined.
Assert.ok(
!SharedRemoteSettingsService.server,
"SharedRemoteSettingsService.server should be undefined"
);
} else {
Assert.ok(
SharedRemoteSettingsService.server,
"SharedRemoteSettingsService.server should be defined"
);
Assert.equal(
SharedRemoteSettingsService.server.url,
url,
"SharedRemoteSettingsService.server.url should be as expected"
);
}
},
});
},
});
}
/**
* Sets the app's region (country) and locale, calls your callback, and restores
* the original region and locale.
*
* @param {string} region
* The app region to set.
* @param {string} locale
* The app locale to set.
* @param {function} callback
* Your callback.
*/
async function withRegionAndLocale({ region, locale, callback }) {
let originalRegion = Region.home;
info("Setting region: " + region);
Region._setHomeRegion(region, true);
Assert.equal(Region.home, region, "Region should now be the desired region");
let { availableLocales, requestedLocales } = Services.locale;
let localePromise = waitForLocaleChange(locale);
info("Setting locale: " + locale);
Services.locale.availableLocales = [locale];
Services.locale.requestedLocales = [locale];
info("Waiting for locale change");
await localePromise;
info("Done waiting for locale change");
Assert.equal(
Services.locale.appLocaleAsBCP47,
locale,
"App locale should now be the desired locale"
);
info("Calling callback");
await callback();
info("Done calling callback");
// Restore the original region and locales.
info("Resetting region to orginal: " + originalRegion);
Region._setHomeRegion(originalRegion, true);
Assert.equal(
Region.home,
originalRegion,
"Region should now be the original region"
);
let restoreLocalePromise = waitForLocaleChange(requestedLocales[0]);
Services.locale.availableLocales = availableLocales;
Services.locale.requestedLocales = requestedLocales;
info("Waiting for original locale to be restored");
await restoreLocalePromise;
info("Done waiting for original locale to be restored");
Assert.equal(
Services.locale.appLocaleAsBCP47,
requestedLocales[0],
"App locale should now be the original locale"
);
}
/**
* Waits for the app locale to be set to an expected value.
*
* @param {string} locale
* The expected locale.
*/
async function waitForLocaleChange(locale) {
// Nothing happens when the locale doesn't actually change.
if (locale == Services.locale.requestedLocales[0]) {
info("Locale is already set");
} else {
info("Waiting for intl:app-locales-changed");
await TestUtils.topicObserved("intl:app-locales-changed");
info("Got intl:app-locales-changed");
}
}
/**
* Waits for the country and locale of the `SharedRemoteSettingsService` to be
* set to some expected values.
*
* @param {string} country
* The expected country.
* @param {string} locale
* The expected locale.
*/
async function waitForServiceCountryAndLocale({ country, locale }) {
await TestUtils.waitForCondition(
() =>
SharedRemoteSettingsService.country == country &&
SharedRemoteSettingsService.locale == locale,
"Waiting for SharedRemoteSettingsService country and locale to be set: " +
JSON.stringify({ country, locale })
);
}