chrome/test/data/webui/net_internals/log_util.js

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 /**
   6  * @fileoverview This file contains tests for creating and loading log files.
   7  * It also tests the stop capturing button, since it both creates and then loads
   8  * a log dump.
   9  */
  10
  11 // Include test fixture.
  12 GEN_INCLUDE(['net_internals_test.js']);
  13
  14 // Anonymous namespace
  15 (function() {
  16
  17 /**
  18  * A Task that creates a log dump and then loads it.
  19  * @param {string} userComments User comments to copy to the ExportsView before
  20  *     creating the log dump.
  21  * @extends {NetInternalsTest.Task}
  22  */
  23 function CreateAndLoadLogTask(userComments) {
  24   this.userComments_ = userComments;
  25   NetInternalsTest.Task.call(this);
  26   // Not strictly necessary, but since we complete from a call to the observer,
  27   // seems reasonable to complete asynchronously.
  28   this.setCompleteAsync(true);
  29 }
  30
  31 CreateAndLoadLogTask.prototype = {
  32   __proto__: NetInternalsTest.Task.prototype,
  33
  34   /**
  35    * Start creating the log dump.  Use ExportView's function as it supports
  36    * both creating completely new logs and using existing logs to create new
  37    * ones, depending on whether or not we're currently viewing a log.
  38    */
  39   start: function() {
  40     this.initialPrivacyStripping_ =
  41         SourceTracker.getInstance().getPrivacyStripping();
  42     $(ExportView.USER_COMMENTS_TEXT_AREA_ID).value = this.userComments_;
  43     ExportView.getInstance().createLogDump_(this.onLogDumpCreated.bind(this),
  44                                             true);
  45   },
  46
  47   /**
  48    * Callback passed to |createLogDumpAsync|.  Tries to load the dumped log
  49    * text.  Checks the status bar and user comments after loading the log.
  50    * @param {string} logDumpText Log dump, as a string.
  51    */
  52   onLogDumpCreated: function(logDumpText) {
  53     expectEquals(this.initialPrivacyStripping_,
  54                  SourceTracker.getInstance().getPrivacyStripping());
  55     expectEquals('Log loaded.', log_util.loadLogFile(logDumpText, 'log.txt'));
  56     expectFalse(SourceTracker.getInstance().getPrivacyStripping());
  57
  58     NetInternalsTest.expectStatusViewNodeVisible(LoadedStatusView.MAIN_BOX_ID);
  59
  60     expectEquals(this.userComments_,
  61                  $(ExportView.USER_COMMENTS_TEXT_AREA_ID).value);
  62     // Make sure the DIV on the import tab containing the comments is visible
  63     // before checking the displayed text.
  64     expectTrue(NetInternalsTest.nodeIsVisible($(ImportView.LOADED_DIV_ID)));
  65     expectEquals(this.userComments_,
  66                  $(ImportView.LOADED_INFO_USER_COMMENTS_ID).innerText);
  67
  68     this.onTaskDone();
  69   }
  70 };
  71
  72 /**
  73  * A Task that waits until constants are received, completing asynchronously
  74  * once they are.
  75  * @extends {NetInternalsTest.Task}
  76  */
  77 function WaitForConstantsTask() {
  78   NetInternalsTest.Task.call(this);
  79   this.setCompleteAsync(true);
  80 }
  81
  82 WaitForConstantsTask.prototype = {
  83   __proto__: NetInternalsTest.Task.prototype,
  84
  85   /**
  86    * Starts watching for constants.
  87    */
  88   start: function() {
  89     g_browser.addConstantsObserver(this);
  90   },
  91
  92   /**
  93    * Resumes the test once we receive constants.
  94    */
  95   onReceivedConstants: function() {
  96     if (!this.isDone())
  97       this.onTaskDone();
  98   }
  99 };
 100
 101 /**
 102   * A Task that creates a log dump in the browser process via NetLogLogger,
 103   * waits to receive it via IPC, and and then loads it as a string.
 104   * @param {integer} truncate The number of bytes to truncate from the end of
 105   *     the string, if any, to simulate a truncated log due to crash, or
 106   *     quitting without properly shutting down a NetLogLogger.
 107   * @extends {NetInternalsTest.Task}
 108   */
 109 function GetNetLogLoggerStringAndLoadLogTask(truncate) {
 110   NetInternalsTest.Task.call(this);
 111   this.setCompleteAsync(true);
 112   this.truncate_ = truncate;
 113 };
 114
 115 GetNetLogLoggerStringAndLoadLogTask.prototype = {
 116   __proto__: NetInternalsTest.Task.prototype,
 117
 118   /**
 119    * Sets |NetInternals.callback|, and sends the request to the browser process.
 120    */
 121   start: function() {
 122     NetInternalsTest.setCallback(this.onLogReceived_.bind(this));
 123     chrome.send('getNetLogLoggerLog');
 124   },
 125
 126   /**
 127    * Loads the received log and completes the Task.
 128    * @param {string} logDumpText Log received from the browser process.
 129    */
 130   onLogReceived_: function(logDumpText) {
 131     assertEquals('string', typeof logDumpText);
 132     expectTrue(SourceTracker.getInstance().getPrivacyStripping());
 133
 134     var expectedResult = 'The log file is missing clientInfo.numericDate.\n' +
 135         'Synthesizing export date as time of last event captured.\n' +
 136         'Log loaded.';
 137
 138     if (this.truncate_) {
 139       expectedResult =
 140           'Log file truncated.  Events may be missing.\n' + expectedResult;
 141     }
 142
 143     logDumpText = logDumpText.substring(0, logDumpText.length - this.truncate_);
 144     expectEquals(expectedResult, log_util.loadLogFile(logDumpText, 'log.txt'));
 145     expectFalse(SourceTracker.getInstance().getPrivacyStripping());
 146
 147     NetInternalsTest.expectStatusViewNodeVisible(LoadedStatusView.MAIN_BOX_ID);
 148
 149     // Make sure the DIV on the import tab containing the comments is visible
 150     // before checking the displayed text.
 151     expectTrue(NetInternalsTest.nodeIsVisible($(ImportView.LOADED_DIV_ID)));
 152     expectEquals('', $(ImportView.LOADED_INFO_USER_COMMENTS_ID).innerText);
 153
 154     this.onTaskDone();
 155   }
 156 };
 157
 158 /**
 159  * Checks the visibility of each view after loading a freshly created log dump.
 160  * Also checks that the BrowserBridge is disabled.
 161  */
 162 function checkViewsAfterLogLoaded() {
 163   expectTrue(g_browser.isDisabled());
 164   var tabVisibilityState = {
 165     capture: false,
 166     export: true,
 167     import: true,
 168     proxy: true,
 169     events: true,
 170     waterfall: true,
 171     timeline: true,
 172     dns: true,
 173     sockets: true,
 174     http2: true,
 175     quic: true,
 176     sdch: true,
 177     httpCache: true,
 178     modules: true,
 179     hsts: false,
 180     prerender: true,
 181     bandwidth: true,
 182     chromeos: false
 183   };
 184   NetInternalsTest.checkTabHandleVisibility(tabVisibilityState, false);
 185 }
 186
 187 /**
 188  * Checks the visibility of each view after loading a log dump created by the
 189  * NetLogLogger.  Also checks that the BrowserBridge is disabled.
 190  */
 191 function checkViewsAfterNetLogLoggerLogLoaded() {
 192   expectTrue(g_browser.isDisabled());
 193   var tabVisibilityState = {
 194     capture: false,
 195     export: true,
 196     import: true,
 197     proxy: false,
 198     events: true,
 199     waterfall: true,
 200     timeline: true,
 201     dns: false,
 202     sockets: false,
 203     http2: false,
 204     quic: false,
 205     sdch: false,
 206     httpCache: false,
 207     modules: false,
 208     hsts: false,
 209     prerender: false,
 210     bandwidth: false,
 211     chromeos: false
 212   };
 213   NetInternalsTest.checkTabHandleVisibility(tabVisibilityState, false);
 214 }
 215
 216 function checkPrivacyStripping(expectedValue) {
 217   expectEquals(expectedValue,
 218                SourceTracker.getInstance().getPrivacyStripping());
 219 }
 220
 221 /**
 222  * Checks the currently active view.
 223  * @param {string} id ID of the view that should be active.
 224  */
 225 function checkActiveView(id) {
 226   expectEquals(id, NetInternalsTest.getActiveTabId());
 227 }
 228
 229 /**
 230  * Exports a log dump to a string and loads it.  Makes sure no errors occur,
 231  * and checks visibility of tabs aftwards.  Does not actually save the log to a
 232  * file.
 233  * TODO(mmenke):  Add some checks for the import view.
 234  */
 235 TEST_F('NetInternalsTest', 'netInternalsLogUtilExportImport', function() {
 236   expectFalse(g_browser.isDisabled());
 237   expectTrue(SourceTracker.getInstance().getPrivacyStripping());
 238   NetInternalsTest.expectStatusViewNodeVisible(CaptureStatusView.MAIN_BOX_ID);
 239
 240   var taskQueue = new NetInternalsTest.TaskQueue(true);
 241   taskQueue.addTask(new CreateAndLoadLogTask('Detailed explanation.'));
 242   taskQueue.addFunctionTask(checkViewsAfterLogLoaded);
 243   taskQueue.run(true);
 244 });
 245
 246 /**
 247  * Exports a log dump by using a NetLogLogger and attempts to load it from a
 248  * string.  The string is passed to Javascript via an IPC rather than drag and
 249  * drop.
 250  */
 251 TEST_F('NetInternalsTest',
 252     'netInternalsLogUtilImportNetLogLoggerDump',
 253     function() {
 254   var taskQueue = new NetInternalsTest.TaskQueue(true);
 255   taskQueue.addTask(new GetNetLogLoggerStringAndLoadLogTask(0));
 256   taskQueue.addFunctionTask(checkViewsAfterNetLogLoggerLogLoaded);
 257   taskQueue.run(true);
 258 });
 259
 260 /**
 261  * Same as above, but it truncates the log to simulate the case of a crash when
 262  * creating a log.
 263  */
 264 TEST_F('NetInternalsTest',
 265     'netInternalsLogUtilImportNetLogLoggerDumpTruncated',
 266     function() {
 267   var taskQueue = new NetInternalsTest.TaskQueue(true);
 268   taskQueue.addTask(new GetNetLogLoggerStringAndLoadLogTask(20));
 269   taskQueue.addFunctionTask(checkViewsAfterNetLogLoggerLogLoaded);
 270   taskQueue.run(true);
 271 });
 272
 273 /**
 274  * Exports a log dump to a string and loads it, and then repeats, making sure
 275  * we can export loaded logs.
 276  */
 277 TEST_F('NetInternalsTest',
 278     'netInternalsLogUtilExportImportExportImport',
 279     function() {
 280   var taskQueue = new NetInternalsTest.TaskQueue(true);
 281   taskQueue.addTask(new CreateAndLoadLogTask('Random comment on the weather.'));
 282   taskQueue.addFunctionTask(checkViewsAfterLogLoaded);
 283   taskQueue.addTask(new CreateAndLoadLogTask('Detailed explanation.'));
 284   taskQueue.addFunctionTask(checkViewsAfterLogLoaded);
 285   taskQueue.run(true);
 286 });
 287
 288 /**
 289  * Checks pressing the stop capturing button.
 290  */
 291 TEST_F('NetInternalsTest', 'netInternalsLogUtilStopCapturing', function() {
 292   var taskQueue = new NetInternalsTest.TaskQueue(true);
 293   // Switching to stop capturing mode will load a log dump, which will update
 294   // the constants.
 295   taskQueue.addTask(new WaitForConstantsTask());
 296
 297   taskQueue.addFunctionTask(
 298       NetInternalsTest.expectStatusViewNodeVisible.bind(
 299           null, HaltedStatusView.MAIN_BOX_ID));
 300   taskQueue.addFunctionTask(checkViewsAfterLogLoaded);
 301   taskQueue.addFunctionTask(checkPrivacyStripping.bind(null, true));
 302   taskQueue.addFunctionTask(checkActiveView.bind(null, ExportView.TAB_ID));
 303   taskQueue.run();
 304
 305   // Simulate a click on the stop capturing button
 306   $(CaptureView.STOP_BUTTON_ID).click();
 307 });
 308
 309 /**
 310  * Switches to stop capturing mode, then exports and imports a log dump.
 311  */
 312 TEST_F('NetInternalsTest',
 313     'netInternalsLogUtilStopCapturingExportImport',
 314     function() {
 315   var taskQueue = new NetInternalsTest.TaskQueue(true);
 316   // Switching to stop capturing mode will load a log dump, which will update
 317   // the constants.
 318   taskQueue.addTask(new WaitForConstantsTask());
 319
 320   taskQueue.addFunctionTask(
 321       NetInternalsTest.expectStatusViewNodeVisible.bind(
 322           null, HaltedStatusView.MAIN_BOX_ID));
 323   taskQueue.addFunctionTask(checkViewsAfterLogLoaded);
 324   taskQueue.addFunctionTask(checkPrivacyStripping.bind(null, true));
 325   taskQueue.addTask(new CreateAndLoadLogTask('Detailed explanation.'));
 326   taskQueue.addFunctionTask(checkViewsAfterLogLoaded);
 327   taskQueue.run();
 328
 329   // Simulate clicking the stop button.
 330   $(CaptureView.STOP_BUTTON_ID).click();
 331 });
 332
 333 })();  // Anonymous namespace