The Tor Browser: toolkit/components/telemetry/tests/unit/test_TelemetrySendOldPings.js@b8a032363ba2 (annotated)

toolkit/components/telemetry/tests/unit/test_TelemetrySendOldPings.js@b8a032363ba2 (annotated)

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

Thu, 22 Jan 2015 13:21:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 22 Jan 2015 13:21:57 +0100
branch: TOR_BUG_9701
changeset 15: b8a032363ba2
permissions: -rw-r--r--

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

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