The Tor Browser / file revision

 /* 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();

 });