The Tor Browser: comparison toolkit/components/telemetry/tests/unit/test_TelemetrySendOldPings.js

comparison: toolkit/components/telemetry/tests/unit/test_TelemetrySendOldPings.js

toolkit/components/telemetry/tests/unit/test_TelemetrySendOldPings.js

changeset 0: 6474c204b198

equal deleted inserted replaced

--1:000000000000
+:24dd599a1bb8
+/* Any copyright is dedicated to the Public Domain.
+http://creativecommons.org/publicdomain/zero/1.0/
+/**
+* This test case populates the profile with some fake stored
+* pings, and checks that:
+*
+* 1) Pings that are considered "expired" are deleted and never sent.
+* 2) Pings that are considered "overdue" trigger a send of all
+*    overdue and recent pings.
+*/
+"use strict"
+const Cc = Components.classes;
+const Ci = Components.interfaces;
+const Cr = Components.results;
+const Cu = Components.utils;
+Cu.import("resource://gre/modules/Services.jsm", this);
+Cu.import("resource://testing-common/httpd.js", this);
+Cu.import("resource://gre/modules/Promise.jsm", this);
+Cu.import("resource://gre/modules/TelemetryFile.jsm", this);
+Cu.import("resource://gre/modules/TelemetryPing.jsm", this);
+Cu.import("resource://gre/modules/Task.jsm", this);
+let {OS: {File, Path, Constants}} = Cu.import("resource://gre/modules/osfile.jsm", {});
+// We increment TelemetryFile's MAX_PING_FILE_AGE and
+// OVERDUE_PING_FILE_AGE by 1 minute so that our test pings exceed
+// those points in time, even taking into account file system imprecision.
+const ONE_MINUTE_MS = 60 * 1000;
+const EXPIRED_PING_FILE_AGE = TelemetryFile.MAX_PING_FILE_AGE + ONE_MINUTE_MS;
+const OVERDUE_PING_FILE_AGE = TelemetryFile.OVERDUE_PING_FILE_AGE + ONE_MINUTE_MS;
+const PING_SAVE_FOLDER = "saved-telemetry-pings";
+const PING_TIMEOUT_LENGTH = 5000;
+const EXPIRED_PINGS = 5;
+const OVERDUE_PINGS = 6;
+const RECENT_PINGS = 4;
+const TOTAL_EXPECTED_PINGS = OVERDUE_PINGS + RECENT_PINGS;
+let gHttpServer = new HttpServer();
+let gCreatedPings = 0;
+let gSeenPings = 0;
+/**
+* Creates some TelemetryPings for the current session and
+* saves them to disk. Each ping gets a unique ID slug based on
+* an incrementor.
+*
+* @param aNum the number of pings to create.
+* @param aAge the age in milliseconds to offset from now. A value
+*             of 10 would make the ping 10ms older than now, for
+*             example.
+* @returns Promise
+* @resolve an Array with the created pings.
+*/
+function createSavedPings(aNum, aAge) {
+return Task.spawn(function*(){
+// Create a TelemetryPing service that we can generate payloads from.
+// Luckily, the TelemetryPing constructor does nothing that we need to
+// clean up.
+let pings = [];
+let age = Date.now() - aAge;
+for (let i = 0; i < aNum; ++i) {
+let payload = TelemetryPing.getPayload();
+let ping = { slug: "test-ping-" + gCreatedPings, reason: "test", payload: payload };
+yield TelemetryFile.savePing(ping);
+if (aAge) {
+// savePing writes to the file synchronously, so we're good to
+// modify the lastModifedTime now.
+let file = getSavePathForPing(ping);
+yield File.setDates(file, null, age);
+}
+gCreatedPings++;
+pings.push(ping);
+}
+return pings;
+});
+}
+/**
+* Deletes locally saved pings in aPings if they
+* exist.
+*
+* @param aPings an Array of pings to delete.
+* @returns Promise
+*/
+function clearPings(aPings) {
+return Task.spawn(function*() {
+for (let ping of aPings) {
+let path = getSavePathForPing(ping);
+yield File.remove(path);
+}
+});
+}
+/**
+* Returns a handle for the file that aPing should be
+* stored in locally.
+*
+* @returns path
+*/
+function getSavePathForPing(aPing) {
+return Path.join(Constants.Path.profileDir, PING_SAVE_FOLDER, aPing.slug);
+}
+/**
+* Check if the number of TelemetryPings received by the
+* HttpServer is not equal to aExpectedNum.
+*
+* @param aExpectedNum the number of pings we expect to receive.
+*/
+function assertReceivedPings(aExpectedNum) {
+do_check_eq(gSeenPings, aExpectedNum);
+}
+/**
+* Throws if any pings in aPings is saved locally.
+*
+* @param aPings an Array of pings to check.
+* @returns Promise
+*/
+function assertNotSaved(aPings) {
+return Task.spawn(function*() {
+let saved = 0;
+for (let ping of aPings) {
+let file = getSavePathForPing(ping);
+if (yield File.exists()) {
+saved++;
+}
+}
+if (saved > 0) {
+do_throw("Found " + saved + " unexpected saved pings.");
+}
+});
+}
+/**
+* Our handler function for the HttpServer that simply
+* increments the gSeenPings global when it successfully
+* receives and decodes a TelemetryPing payload.
+*
+* @param aRequest the HTTP request sent from HttpServer.
+*/
+function pingHandler(aRequest) {
+gSeenPings++;
+}
+/**
+* Returns a Promise that resolves when gHttpServer has been
+* successfully shut down.
+*
+* @returns Promise
+*/
+function stopHttpServer() {
+let deferred = Promise.defer();
+gHttpServer.stop(function() {
+deferred.resolve();
+})
+return deferred.promise;
+}
+/**
+* Teardown a TelemetryPing instance and clear out any pending
+* pings to put as back in the starting state.
+*/
+function resetTelemetry() {
+TelemetryPing.uninstall();
+// Quick and dirty way to clear TelemetryFile's pendingPings
+// collection, and put it back in its initial state.
+let gen = TelemetryFile.popPendingPings();
+for (let item of gen) {};
+}
+/**
+* Creates and returns a TelemetryPing instance in "testing"
+* mode.
+*/
+function startTelemetry() {
+return TelemetryPing.setup();
+}
+function run_test() {
+gHttpServer.registerPrefixHandler("/submit/telemetry/", pingHandler);
+gHttpServer.start(-1);
+do_get_profile();
+Services.prefs.setBoolPref(TelemetryPing.Constants.PREF_ENABLED, true);
+Services.prefs.setCharPref(TelemetryPing.Constants.PREF_SERVER,
+"http://localhost:" + gHttpServer.identity.primaryPort);
+run_next_test();
+}
+/**
+* Test that pings that are considered too old are just chucked out
+* immediately and never sent.
+*/
+add_task(function test_expired_pings_are_deleted() {
+let expiredPings = yield createSavedPings(EXPIRED_PINGS, EXPIRED_PING_FILE_AGE);
+yield startTelemetry();
+assertReceivedPings(0);
+yield assertNotSaved(expiredPings);
+yield resetTelemetry();
+});
+/**
+* Test that really recent pings are not sent on Telemetry initialization.
+*/
+add_task(function test_recent_pings_not_sent() {
+let recentPings = yield createSavedPings(RECENT_PINGS);
+yield startTelemetry();
+assertReceivedPings(0);
+yield resetTelemetry();
+yield clearPings(recentPings);
+});
+/**
+* Create some recent, expired and overdue pings. The overdue pings should
+* trigger a send of all recent and overdue pings, but the expired pings
+* should just be deleted.
+*/
+add_task(function test_overdue_pings_trigger_send() {
+let recentPings = yield createSavedPings(RECENT_PINGS);
+let expiredPings = yield createSavedPings(EXPIRED_PINGS, EXPIRED_PING_FILE_AGE);
+let overduePings = yield createSavedPings(OVERDUE_PINGS, OVERDUE_PING_FILE_AGE);
+yield startTelemetry();
+assertReceivedPings(TOTAL_EXPECTED_PINGS);
+yield assertNotSaved(recentPings);
+yield assertNotSaved(expiredPings);
+yield assertNotSaved(overduePings);
+yield resetTelemetry();
+});
+add_task(function teardown() {
+yield stopHttpServer();
+});