summaryrefslogtreecommitdiffstats
path: root/toolkit/modules/tests/xpcshell/test_Region.js
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 19:33:14 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 19:33:14 +0000
commit36d22d82aa202bb199967e9512281e9a53db42c9 (patch)
tree105e8c98ddea1c1e4784a60a5a6410fa416be2de /toolkit/modules/tests/xpcshell/test_Region.js
parentInitial commit. (diff)
downloadfirefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.tar.xz
firefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.zip
Adding upstream version 115.7.0esr.upstream/115.7.0esr
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'toolkit/modules/tests/xpcshell/test_Region.js')
-rw-r--r--toolkit/modules/tests/xpcshell/test_Region.js331
1 files changed, 331 insertions, 0 deletions
diff --git a/toolkit/modules/tests/xpcshell/test_Region.js b/toolkit/modules/tests/xpcshell/test_Region.js
new file mode 100644
index 0000000000..709e6c4500
--- /dev/null
+++ b/toolkit/modules/tests/xpcshell/test_Region.js
@@ -0,0 +1,331 @@
+"use strict";
+
+const { AppConstants } = ChromeUtils.importESModule(
+ "resource://gre/modules/AppConstants.sys.mjs"
+);
+const { HttpServer } = ChromeUtils.import("resource://testing-common/httpd.js");
+const { Region } = ChromeUtils.importESModule(
+ "resource://gre/modules/Region.sys.mjs"
+);
+const { setTimeout } = ChromeUtils.importESModule(
+ "resource://gre/modules/Timer.sys.mjs"
+);
+const { TestUtils } = ChromeUtils.importESModule(
+ "resource://testing-common/TestUtils.sys.mjs"
+);
+
+ChromeUtils.defineESModuleGetters(this, {
+ RegionTestUtils: "resource://testing-common/RegionTestUtils.sys.mjs",
+});
+
+const INTERVAL_PREF = "browser.region.update.interval";
+
+const RESPONSE_DELAY = 500;
+const RESPONSE_TIMEOUT = 100;
+
+const histogram = Services.telemetry.getHistogramById(
+ "SEARCH_SERVICE_COUNTRY_FETCH_RESULT"
+);
+
+// Region.sys.mjs will call init() on startup and sent a background
+// task to fetch the region, ensure we have completed this before
+// running the rest of the tests.
+add_task(async function test_startup() {
+ RegionTestUtils.setNetworkRegion("UK");
+ await checkTelemetry(Region.TELEMETRY.SUCCESS);
+ await cleanup();
+});
+
+add_task(async function test_basic() {
+ let srv = useHttpServer(RegionTestUtils.REGION_URL_PREF);
+ srv.registerPathHandler("/", (req, res) => {
+ res.setStatusLine("1.1", 200, "OK");
+ send(res, { country_code: "UK" });
+ });
+ // start to listen the notification
+ let updateRegion = TestUtils.topicObserved("browser-region-updated");
+ await Region._fetchRegion();
+ let [subject] = await updateRegion;
+
+ Assert.ok(true, "Region fetch should succeed");
+ Assert.equal(Region.home, "UK", "Region fetch should return correct result");
+ Assert.equal(
+ subject,
+ Region.home,
+ "Notification should be sent with the correct region"
+ );
+
+ await cleanup(srv);
+});
+
+add_task(async function test_invalid_url() {
+ histogram.clear();
+ Services.prefs.setIntPref("browser.region.retry-timeout", 0);
+ Services.prefs.setCharPref(
+ RegionTestUtils.REGION_URL_PREF,
+ "http://localhost:0"
+ );
+ let result = await Region._fetchRegion();
+ Assert.ok(!result, "Should return no result");
+ await checkTelemetry(Region.TELEMETRY.NO_RESULT);
+});
+
+add_task(async function test_invalid_json() {
+ histogram.clear();
+ Services.prefs.setCharPref(
+ RegionTestUtils.REGION_URL_PREF,
+ 'data:application/json,{"country_code"'
+ );
+ let result = await Region._fetchRegion();
+ Assert.ok(!result, "Should return no result");
+ await checkTelemetry(Region.TELEMETRY.NO_RESULT);
+});
+
+add_task(async function test_timeout() {
+ histogram.clear();
+ Services.prefs.setIntPref("browser.region.retry-timeout", 0);
+ Services.prefs.setIntPref("browser.region.timeout", RESPONSE_TIMEOUT);
+ let srv = useHttpServer(RegionTestUtils.REGION_URL_PREF);
+ srv.registerPathHandler("/", (req, res) => {
+ res.processAsync();
+ do_timeout(RESPONSE_DELAY, () => {
+ send(res, { country_code: "UK" });
+ res.finish();
+ });
+ });
+
+ let result = await Region._fetchRegion();
+ Assert.equal(result, null, "Region fetch should return null");
+
+ await checkTelemetry(Region.TELEMETRY.TIMEOUT);
+ await cleanup(srv);
+});
+
+add_task(async function test_mismatched_probe() {
+ let probeDetails = await getExpectedHistogramDetails();
+ let probeHistogram;
+ if (probeDetails) {
+ probeHistogram = Services.telemetry.getHistogramById(probeDetails.probeId);
+ probeHistogram.clear();
+ }
+ histogram.clear();
+ Region._home = null;
+
+ RegionTestUtils.setNetworkRegion("AU");
+ await Region._fetchRegion();
+ Assert.equal(Region.home, "AU", "Should have correct region");
+ await checkTelemetry(Region.TELEMETRY.SUCCESS);
+
+ // We dont store probes for linux and on treeherder +
+ // Mac there is no plaform countryCode so in these cases
+ // skip the rest of the checks.
+ if (!probeDetails) {
+ return;
+ }
+ let snapshot = probeHistogram.snapshot();
+ deepEqual(snapshot.values, probeDetails.expectedResult);
+
+ await cleanup();
+});
+
+add_task(async function test_location() {
+ let location = { location: { lat: -1, lng: 1 }, accuracy: 100 };
+ let srv = useHttpServer("geo.provider.network.url");
+ srv.registerPathHandler("/", (req, res) => {
+ res.setStatusLine("1.1", 200, "OK");
+ send(res, location);
+ });
+
+ let result = await Region._getLocation();
+ Assert.ok(true, "Region fetch should succeed");
+ Assert.deepEqual(result, location, "Location is returned");
+
+ await cleanup(srv);
+});
+
+add_task(async function test_update() {
+ Region._home = null;
+ RegionTestUtils.setNetworkRegion("FR");
+ await Region._fetchRegion();
+ Assert.equal(Region.home, "FR", "Should have correct region");
+ RegionTestUtils.setNetworkRegion("DE");
+ await Region._fetchRegion();
+ Assert.equal(Region.home, "FR", "Shouldnt have changed yet");
+ // Thie first fetchRegion will set the prefs to determine when
+ // to update the home region, we need to do 2 fetchRegions to test
+ // it isnt updating when it shouldnt.
+ await Region._fetchRegion();
+ Assert.equal(Region.home, "FR", "Shouldnt have changed yet again");
+ Services.prefs.setIntPref(INTERVAL_PREF, 1);
+ /* eslint-disable mozilla/no-arbitrary-setTimeout */
+ await new Promise(resolve => setTimeout(resolve, 1100));
+ await Region._fetchRegion();
+ Assert.equal(Region.home, "DE", "Should have updated now");
+
+ await cleanup();
+});
+
+add_task(async function test_max_retry() {
+ Region._home = null;
+ let requestsSeen = 0;
+ Services.prefs.setIntPref("browser.region.retry-timeout", RESPONSE_TIMEOUT);
+ Services.prefs.setIntPref("browser.region.timeout", RESPONSE_TIMEOUT);
+ let srv = useHttpServer(RegionTestUtils.REGION_URL_PREF);
+ srv.registerPathHandler("/", (req, res) => {
+ requestsSeen++;
+ res.setStatusLine("1.1", 200, "OK");
+ res.processAsync();
+ do_timeout(RESPONSE_DELAY, res.finish.bind(res));
+ });
+
+ Region._fetchRegion();
+ await TestUtils.waitForCondition(() => requestsSeen === 3);
+ /* eslint-disable mozilla/no-arbitrary-setTimeout */
+ await new Promise(resolve => setTimeout(resolve, RESPONSE_DELAY));
+
+ Assert.equal(Region.home, null, "failed to fetch region");
+ Assert.equal(requestsSeen, 3, "Retried 4 times");
+
+ Region._retryCount = 0;
+ await cleanup(srv);
+});
+
+add_task(async function test_retry() {
+ Region._home = null;
+ let requestsSeen = 0;
+ Services.prefs.setIntPref("browser.region.retry-timeout", RESPONSE_TIMEOUT);
+ Services.prefs.setIntPref("browser.region.timeout", RESPONSE_TIMEOUT);
+ let srv = useHttpServer(RegionTestUtils.REGION_URL_PREF);
+ srv.registerPathHandler("/", (req, res) => {
+ res.setStatusLine("1.1", 200, "OK");
+ if (++requestsSeen == 2) {
+ res.setStatusLine("1.1", 200, "OK");
+ send(res, { country_code: "UK" });
+ } else {
+ res.processAsync();
+ do_timeout(RESPONSE_DELAY, res.finish.bind(res));
+ }
+ });
+
+ Region._fetchRegion();
+ await TestUtils.waitForCondition(() => requestsSeen === 2);
+ /* eslint-disable mozilla/no-arbitrary-setTimeout */
+ await new Promise(resolve => setTimeout(resolve, RESPONSE_DELAY));
+
+ Assert.equal(Region.home, "UK", "failed to fetch region");
+ Assert.equal(requestsSeen, 2, "Retried 2 times");
+
+ await cleanup(srv);
+});
+
+add_task(async function test_timerManager() {
+ RegionTestUtils.setNetworkRegion("FR");
+
+ // Ensure the home region updates immediately, but the update
+ // check will only happen once per second.
+ Services.prefs.setIntPref("browser.region.update.interval", 0);
+ Services.prefs.setIntPref("browser.region.update.debounce", 1);
+
+ let region = Region.newInstance();
+ await region.init();
+ Assert.equal(region.home, "FR", "Should have correct initial region");
+
+ // Updates are being debounced, these should be ignored.
+ RegionTestUtils.setNetworkRegion("DE");
+ await region._updateTimer();
+ await region._updateTimer();
+ Assert.equal(region.home, "FR", "Ignored updates to region");
+
+ // Set the debounce interval to 0 so these updates are used.
+ Services.prefs.setIntPref("browser.region.update.debounce", 0);
+ RegionTestUtils.setNetworkRegion("AU");
+ await region._updateTimer();
+ await region._updateTimer();
+ Assert.equal(region.home, "AU", "region has been updated");
+ await cleanup();
+});
+
+function useHttpServer(pref) {
+ let server = new HttpServer();
+ server.start(-1);
+ Services.prefs.setCharPref(
+ pref,
+ `http://localhost:${server.identity.primaryPort}/`
+ );
+ return server;
+}
+
+function send(res, json) {
+ res.setStatusLine("1.1", 200, "OK");
+ res.setHeader("content-type", "application/json", true);
+ res.write(JSON.stringify(json));
+}
+
+async function cleanup(srv = null) {
+ Services.prefs.clearUserPref("browser.search.region");
+ if (srv) {
+ await new Promise(r => srv.stop(r));
+ }
+}
+
+async function checkTelemetry(aExpectedValue) {
+ // Wait until there is 1 result.
+ await TestUtils.waitForCondition(() => {
+ let snapshot = histogram.snapshot();
+ return Object.values(snapshot.values).reduce((a, b) => a + b) == 1;
+ });
+ let snapshot = histogram.snapshot();
+ Assert.equal(snapshot.values[aExpectedValue], 1);
+}
+
+// Define some checks for our platform-specific telemetry.
+// We can't influence what they return (as we can't
+// influence the countryCode the platform thinks we
+// are in), but we can check the values are
+// correct given reality.
+async function getExpectedHistogramDetails() {
+ let probeUSMismatched, probeNonUSMismatched;
+ switch (AppConstants.platform) {
+ case "macosx":
+ probeUSMismatched = "SEARCH_SERVICE_US_COUNTRY_MISMATCHED_PLATFORM_OSX";
+ probeNonUSMismatched =
+ "SEARCH_SERVICE_NONUS_COUNTRY_MISMATCHED_PLATFORM_OSX";
+ break;
+ case "win":
+ probeUSMismatched = "SEARCH_SERVICE_US_COUNTRY_MISMATCHED_PLATFORM_WIN";
+ probeNonUSMismatched =
+ "SEARCH_SERVICE_NONUS_COUNTRY_MISMATCHED_PLATFORM_WIN";
+ break;
+ default:
+ break;
+ }
+
+ if (probeUSMismatched && probeNonUSMismatched) {
+ let countryCode = await Services.sysinfo.countryCode;
+ print("Platform says the country-code is", countryCode);
+ if (!countryCode) {
+ // On treeherder for Mac the countryCode is null, so the probes won't be
+ // recorded.
+ // We still let the test run for Mac, as a developer would likely
+ // eventually pick up on the issue.
+ info("No country code set on this machine, skipping rest of test");
+ return false;
+ }
+
+ if (countryCode == "US") {
+ // boolean probe so 3 buckets, expect 1 result for |1|.
+ return {
+ probeId: probeUSMismatched,
+ expectedResult: { 0: 0, 1: 1, 2: 0 },
+ };
+ }
+ // We are expecting probeNonUSMismatched with false if the platform
+ // says AU (not a mismatch) and true otherwise.
+ return {
+ probeId: probeNonUSMismatched,
+ expectedResult:
+ countryCode == "AU" ? { 0: 1, 1: 0 } : { 0: 0, 1: 1, 2: 0 },
+ };
+ }
+ return false;
+}