DevTools: Add more sanity tests.

webkit/glue/devtools/js/tests.js

 // Copyright (c) 2009 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 
 /**
  * @fileoverview This file contains small testing framework along with the
  * test suite for the frontend. These tests are a part of the continues build
  * and are executed by the devtools_sanity_unittest.cc as a part of the
  * Interactive UI Test suite.
@@ skipping 61 matching lines @@
   for (var name in this) {
     if (name.substring(0, 4) == 'test' &&
         typeof this[name] == 'function') {
       this.runTest(name);
     }
   }
 };
 
 
 /**
- * Async tests use this one to report that they are completed.
- */
-TestSuite.prototype.reportOk = function() {
-  window.domAutomationController.send('[OK]');
-};
-
-
-/**
  * Manual controller for async tests.
  * @constructor.
  */
 TestSuite.Controller = function() {
   this.controlTaken_ = false;
   this.timerId_ = -1;
 };
 
 
 /**
  * Takes control over execution.
  */
 TestSuite.Controller.prototype.takeControl = function() {
   this.controlTaken_ = true;
   // Set up guard timer.
   var self = this;
   this.timerId_ = setTimeout(function() {
-    self.reportFailure('Timeout exceeded: 20 sec');
+    self.reportFailure_('Timeout exceeded: 20 sec');
   }, 20000);
 };
 
 
 /**
+ * Releases control over execution.
+ */
+TestSuite.Controller.prototype.releaseControl = function() {
+  this.controlTaken_ = false;
+  if (this.timerId_ != -1) {
+    this.timerId_ = -1;
+    clearTimeout(this.timerId_);
+  }
+  this.reportOk_();
+};
+
+
+/**
  * Async tests use this one to report that they are completed.
  */
-TestSuite.Controller.prototype.reportOk = function() {
-  if (this.timerId_ != -1) {
-    this.timerId_ = -1;
-    clearTimeout(this.timerId_);
-  }
+TestSuite.Controller.prototype.reportOk_ = function() {
   window.domAutomationController.send('[OK]');
 };
 
 
 /**
  * Async tests use this one to report failures.
  */
-TestSuite.Controller.prototype.reportFailure = function(error) {
+TestSuite.Controller.prototype.reportFailure_ = function(error) {
   if (this.timerId_ != -1) {
     this.timerId_ = -1;
     clearTimeout(this.timerId_);
   }
   window.domAutomationController.send('[FAILED] ' + error);
 };
 
 
 /**
  * Runs all global functions starting with 'test' as unit tests.
  */
 TestSuite.prototype.runTest = function(testName) {
   var controller = new TestSuite.Controller();
   try {
     this[testName](controller);
     if (!controller.controlTaken_) {
-      controller.reportOk();
+      controller.reportOk_();
     }
   } catch (e) {
-    controller.reportFailure(e);
+    controller.reportFailure_(e);
   }
 };
 
 
 /**
  * @param {string} panelName Name of the panel to show.
  */
 TestSuite.prototype.showPanel = function(panelName) {
   // Open Scripts panel.
   var toolbar = document.getElementById('toolbar');
@@ skipping 50 matching lines @@
 
   var test = this;
   var oldAddResource = WebInspector.addResource;
   WebInspector.addResource = function(identifier, payload) {
     WebInspector.addResource = oldAddResource;
     oldAddResource.call(this, identifier, payload);
     test.assertEquals('simple_page.html', payload.lastPathComponent);
     WebInspector.panels.resources.refresh();
     WebInspector.resources[identifier]._resourcesTreeElement.select();
 
-    controller.reportOk();
+    controller.releaseControl();
   };
 
   // Following call should lead to reload that we capture in the
   // addResource override.
   WebInspector.panels.resources._enableResourceTracking();
 
   // We now have some time to report results to controller.
   controller.takeControl();
 };
 
 
 /**
+ * Tests resource headers.
+ */
+TestSuite.prototype.testResourceHeaders = function(controller) {
+  this.showPanel('resources');
+
+  var test = this;
+  var oldAddResource = WebInspector.addResource;
+  var oldUpdateResource = WebInspector.updateResource;
+
+  var requestOk = false;
+  var responseOk = false;
+  var timingOk = false;
+
+  WebInspector.addResource = function(identifier, payload) {
+    oldAddResource.call(this, identifier, payload);
+    var resource = this.resources[identifier];
+    if (resource.mainResource) {
+      // We are only interested in secondary resources in this test.
+      return;
+    }
+
+    var requestHeaders = JSON.stringify(resource.requestHeaders);
+    test.assertContains(requestHeaders, 'Accept');
+    requestOk = true;
+  };
+
+  WebInspector.updateResource = function(identifier, payload) {
+    oldUpdateResource.call(this, identifier, payload);
+    var resource = this.resources[identifier];
+    if (resource.mainResource) {
+      // We are only interested in secondary resources in this test.
+      return;
+    }
+
+    if (payload.didResponseChange) {
+      var responseHeaders = JSON.stringify(resource.responseHeaders);
+      test.assertContains(responseHeaders, 'Content-type');
+      test.assertContains(responseHeaders, 'Content-Length');
+      test.assertTrue(typeof resource.responseReceivedTime != 'undefnied');
+      responseOk = true;
+    }
+
+    if (payload.didTimingChange) {
+      test.assertTrue(typeof resource.startTime != 'undefnied');
+      timingOk = true;
+    }
+
+    if (payload.didCompletionChange) {
+      test.assertTrue(requestOk);
+      test.assertTrue(responseOk);
+      test.assertTrue(timingOk);
+      test.assertTrue(typeof resource.endTime != 'undefnied');
+      controller.releaseControl();
+    }
+  };
+
+  WebInspector.panels.resources._enableResourceTracking();
+  controller.takeControl();
+};
+
+
+/**
  * Test that profiler works.
  */
 TestSuite.prototype.testProfilerTab = function(controller) {
   this.showPanel('profiles');
 
+  var test = this;
   var oldAddProfile = WebInspector.addProfile;
   WebInspector.addProfile = function(profile) {
     WebInspector.addProfile = oldAddProfile;
     oldAddProfile.call(this, profile);
 
     var panel = WebInspector.panels.profiles;
     panel.showProfile(profile);
     var node = panel.visibleView.profileDataGridTree.children[0];
     // Iterate over displayed functions and search for a function
     // that is called 'fib' or 'eternal_fib'. If found, it will mean
     // that we actually have profiled page's code.
     while (node) {
       if (node.functionName.indexOf("fib") != -1) {
-        controller.reportOk();
+        controller.releaseControl();
       }
       node = node.traverseNextNode(true, null, true);
     }
 
-    controller.reportFailure();
+    test.fail();
   };
 
   InspectorController.startProfiling();
   window.setTimeout('InspectorController.stopProfiling();', 1000);
   controller.takeControl();
 };
 
 
 /**
  * Tests that scripts tab can be open and populated with inspected scripts.
  */
 TestSuite.prototype.testShowScriptsTab = function(controller) {
   var parsedDebuggerTestPageHtml = false;
   var parsedDebuggerTestJs = false;
 
   // Intercept parsedScriptSource calls to check that all expected scripts are
   // added to the debugger.
-  var self = this;
+  var test = this;
   var originalParsedScriptSource = WebInspector.parsedScriptSource;
   WebInspector.parsedScriptSource = function(sourceID, sourceURL, source,
       startingLine) {
     if (sourceURL.search(/debugger_test_page.html$/) != -1) {
       if (parsedDebuggerTestPageHtml) {
-        controller.reportFailure('Unexpected parse event: ' + sourceURL);
-        return;
+        test.fail('Unexpected parse event: ' + sourceURL);
       }
       parsedDebuggerTestPageHtml = true;
     } else if (sourceURL.search(/debugger_test.js$/) != -1) {
       if (parsedDebuggerTestJs) {
-        controller.reportFailure('Unexpected parse event: ' + sourceURL);
-        return;
+        test.fail('Unexpected parse event: ' + sourceURL);
       }
       parsedDebuggerTestJs = true;
     } else {
-      controller.reportFailure('Unexpected script URL: ' + sourceURL);
+      test.fail('Unexpected script URL: ' + sourceURL);
     }
     originalParsedScriptSource.apply(this, arguments);
 
     if (!WebInspector.panels.scripts.visibleView) {
-      controller.reportFailure('No visible script view: ' + sourceURL);
-      return;
+      test.fail('No visible script view: ' + sourceURL);
     }
 
     if (parsedDebuggerTestJs && parsedDebuggerTestPageHtml) {
-       controller.reportOk();
+       controller.releaseControl();
     }
-    controller.reportOk();
   };
 
   this.showPanel('scripts');
 
   // Wait until all scripts are added to the debugger.
   controller.takeControl();
 };
 
 
-TestSuite.ConsoleEnter = {
-    keyIdentifier : 'Enter',
-    preventDefault : function() {},
-    stopPropagation : function() {}
-};
-
-
 /**
+ * Key event with given key identifier.
+ */
+TestSuite.KeyEvent = function(key) {
+  this.keyIdentifier = key;
+};
+TestSuite.KeyEvent.prototype.preventDefault = function() {};
+TestSuite.KeyEvent.prototype.stopPropagation = function() {};
+
+
+/**
  * Tests console eval.
  */
 TestSuite.prototype.testConsoleEval = function(controller) {
   var test = this;
   var originalConsoleAddMessage = WebInspector.Console.prototype.addMessage;
   WebInspector.Console.prototype.addMessage = function(commandResult) {
     originalConsoleAddMessage.call(this, commandResult);
     WebInspector.Console.prototype.addMessage = originalConsoleAddMessage;
     test.assertEquals('123', commandResult.toMessageElement().textContent);
-    controller.reportOk();
+    controller.releaseControl();
   };
 
   WebInspector.console.visible = true;
   WebInspector.console.prompt.text = '123';
-  WebInspector.console.promptElement.handleKeyEvent(TestSuite.ConsoleEnter);
+  WebInspector.console.promptElement.handleKeyEvent(
+      new TestSuite.KeyEvent('Enter'));
 
   controller.takeControl();
 };
 
 
 /**
  * Tests console log.
  */
 TestSuite.prototype.testConsoleLog = function(controller) {
   WebInspector.console.visible = true;
@@ skipping 26 matching lines @@
   assertNext('19', 'Object Object');
   assertNext('22', 'repeated', 'log', 5);
   assertNext('26', 'count: 1');
   assertNext('26', 'count: 2');
   assertNext('29', 'group', 'group-title');
   index++;
   assertNext('33', 'timer:', 'log', '', true);
 };
 
 
+/**
+ * Tests eval of global objects.
+ */
+TestSuite.prototype.testEvalGlobal = function(controller) {
+  var test = this;
+  var originalConsoleAddMessage = WebInspector.Console.prototype.addMessage;
+  WebInspector.Console.prototype.addMessage = function(commandResult) {
+    originalConsoleAddMessage.call(this, commandResult);
+    WebInspector.Console.prototype.addMessage = originalConsoleAddMessage;
+    test.assertEquals('fooValue', commandResult.toMessageElement().textContent);
+    controller.releaseControl();
+  };
+
+  WebInspector.console.visible = true;
+  WebInspector.console.prompt.text = 'foo';
+  WebInspector.console.promptElement.handleKeyEvent(
+      new TestSuite.KeyEvent('Enter'));
+
+  controller.takeControl();
+};
+
+
+/**
+ * Tests eval on call frame.
+ */
+TestSuite.prototype.testEvalCallFrame = function(controller) {
+};
+
+
 var uiTests = new TestSuite();
 }