selenium-webdriver 0.0.7 → 0.0.8

data/common/src/rb/lib/selenium/webdriver/driver.rb

@@ -34,6 +34,10 @@ module Selenium
         @bridge = bridge
       end
 
+      def inspect
+        '#<%s:0x%x browser=%s>' % [self.class, hash*2, bridge.browser.inspect]
+      end
+
       def navigate
         @navigate ||= WebDriver::Navigation.new(self)
       end

data/common/src/rb/lib/selenium/webdriver/element.rb

@@ -9,6 +9,10 @@ module Selenium
         @bridge, @id = bridge, id
       end
 
+      def inspect
+        '#<%s:0x%x id=%s tag_name=%s>' % [self.class, hash*2, @id.inspect, tag_name.inspect]
+      end
+
       def click
         bridge.clickElement @id
       end

data/firefox/src/extension/components/badCertListener.js

@@ -0,0 +1,186 @@
+/*
+ Copyright 2007-2009 WebDriver committers
+ Copyright 2007-2009 Google Inc.
+ Portions copyright 2007 ThoughtWorks, Inc
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ */
+
+/**
+ * @fileOverview Contains a Javascript implementation for
+ * a custom nsICertOverrideService. This class will forward requests to the
+ * original certificate override service - unless it was told to accept all
+ * of them.
+ */
+
+const CC = Components.classes;
+const CI = Components.interfaces;
+
+const CONSOLE = CC["@mozilla.org/consoleservice;1"].
+                  getService(CI["nsIConsoleService"]);
+
+function localdump(message) {
+  try {
+    CONSOLE.logStringMessage(message + "\n");
+  } catch (e) {
+    dump(message + "\n");
+  }
+}
+
+function WdCertOverrideService() {
+  var prefs =
+      CC["@mozilla.org/preferences-service;1"].getService(CI["nsIPrefBranch"]);
+
+  this.acceptAll = undefined;
+  if (!prefs.prefHasUserValue("webdriver_accept_untrusted_certs")) {
+    localdump('webdriver_accept_untrusted_certs not set; defaulting to true');
+    this.acceptAll = true;
+  } else {
+    localdump("Found preference for webdriver_accept_untrusted_certs: " +
+              prefs.getBoolPref("webdriver_accept_untrusted_certs"));
+    this.acceptAll = prefs.getBoolPref("webdriver_accept_untrusted_certs");
+  }
+  // UUID of the original implementor of this service.
+  var ORIGINAL_OVERRIDE_SERVICE_ID = "{67ba681d-5485-4fff-952c-2ee337ffdcd6}";
+
+  localdump("Accept untrusted certificates: " + this.acceptAll);
+
+  // Keep a reference to the original bad certificate listener.
+  var originalService = Components.classesByID[ORIGINAL_OVERRIDE_SERVICE_ID].
+      getService();
+
+  this.origListener_ =
+      originalService.QueryInterface(
+        Components.interfaces.nsICertOverrideService);
+};
+
+WdCertOverrideService.prototype = {
+  ERROR_UNTRUSTED: 1,
+  ERROR_MISMATCH: 2,
+  ERROR_TIME: 4
+};
+
+WdCertOverrideService.prototype.hasMatchingOverride = function(
+    aHostName, aPort, aCert, aOverrideBits, aIsTemporary) {
+  var retval = false;
+
+  if (this.acceptAll === true) {
+    localdump("Allowing certificate from site: " + aHostName + ":" + aPort);
+    retval = true;
+    aIsTemporary.value = false;
+    aOverrideBits.value = this.ERROR_UNTRUSTED | this.ERROR_MISMATCH |
+        this.ERROR_TIME;
+    localdump("Bits: " + aOverrideBits.value);
+  } else {
+    retval = this.origListener.hasMatchingOverride(aHostName, aPort,
+              aCert, aOverrideBits, aIsTemporary);
+  }
+
+  return retval;
+};
+
+// Delegate the rest of the functions - they are not interesting as they are not
+// called during validation of invalid certificate normally.
+WdCertOverrideService.prototype.clearValidityOverride = function(aHostName,
+                                                                 aPort) {
+  this.origListener_.clearValidityOverride(aHostName, aPort);
+};
+
+WdCertOverrideService.prototype.getAllOverrideHostsWithPorts = function(
+    aCount, aHostsWithPortsArray) {
+  this.origListener_.getAllOverrideHostsWithPorts(aCert, aHostsWithPortsArray);
+};
+
+WdCertOverrideService.prototype.getValidityOverride = function(
+    aHostName, aPort, aHashAlg, aFingerprint, aOverrideBits, aIsTemporary) {
+  return this.origListener_.getValidityOverride(
+      aHostName, aPort, aHashAlg, aFingerprint, aOverrideBits, aIsTemporary);
+};
+
+WdCertOverrideService.prototype.isCertUsedForOverrides = function(
+    aCert, aCheckTemporaries, aCheckPermanents) {
+  return this.origListener_.isCertUsedForOverrides(
+      aCert, aCheckTemporaries, aCheckPermanents);
+};
+
+WdCertOverrideService.prototype.rememberValidityOverride = function(
+    aHostName, aPort, aCert, aOverrideBits, aTemporary) {
+  this.origListener_.rememberValidityOverride(
+      aHostName, aPort, aCert, aOverrideBits, aTemporary);
+};
+
+// Service contract ID which we override
+const CERTOVERRIDE_CONTRACT_ID = "@mozilla.org/security/certoverride;1";
+// UUID for this instance specifically.
+const DUMMY_BADCERT_SERVICE_CLASS_ID =
+  Components.ID('{c8fffaba-9b7a-41aa-872d-7e7366c16715}');
+
+var service = undefined;
+
+var WDBadCertListenerFactory = {
+  createInstance: function (aOuter, aIID) {
+    if (aOuter != null)
+      throw Components.results.NS_ERROR_NO_AGGREGATION;
+    if (service == undefined) {
+      service = new WdCertOverrideService();
+    }
+    return service;
+  }
+};
+
+function WDBadCertListenerModule() {
+  this.firstTime_ = true;
+}
+
+WDBadCertListenerModule.prototype.registerSelf = function(
+    aCompMgr, aFileSpec, aLocation, aType) {
+
+  if (this.firstTime_) {
+    this.firstTime_ = false;
+    throw Components.results.NS_ERROR_FACTORY_REGISTER_AGAIN;
+  }
+
+  localdump("Registering Override Certificate service.");
+  aCompMgr = aCompMgr.QueryInterface(
+      Components.interfaces.nsIComponentRegistrar);
+  aCompMgr.registerFactoryLocation(
+      DUMMY_BADCERT_SERVICE_CLASS_ID, "WebDriver Override Cert Service",
+      CERTOVERRIDE_CONTRACT_ID, aFileSpec, aLocation, aType);
+};
+
+WDBadCertListenerModule.prototype.unregisterSelf = function(
+    aCompMgr, aLocation, aType) {
+  localdump("Un-registering Override Certificate service.");
+  aCompMgr =
+  aCompMgr.QueryInterface(Components.interfaces.nsIComponentRegistrar);
+  aCompMgr.unregisterFactoryLocation(DUMMY_BADCERT_SERVICE_CLASS_ID, aLocation);
+};
+
+WDBadCertListenerModule.prototype.getClassObject = function(
+    aCompMgr, aCID, aIID) {
+  if (!aIID.equals(Components.interfaces.nsIFactory))
+    throw Components.results.NS_ERROR_NOT_IMPLEMENTED;
+
+  if (aCID.equals(DUMMY_BADCERT_SERVICE_CLASS_ID))
+    return WDBadCertListenerFactory;
+
+  throw Components.results.NS_ERROR_NO_INTERFACE;
+};
+
+WDBadCertListenerModule.prototype.canUnload = function(aCompMgr) {
+  return true;
+};
+
+function NSGetModule(comMgr, fileSpec) {
+  return new WDBadCertListenerModule();
+}

data/firefox/src/extension/components/firefoxDriver.js

@@ -146,15 +146,7 @@ FirefoxDriver.prototype.executeScript = function(respond, script) {
 
     var result = runScript(scriptSrc, parameters);
 
-    var wrappedResult = Utils.wrapResult(result, respond.context);
-
-    if (wrappedResult.resultType !== undefined) {
-      respond.setField("resultType", wrappedResult.resultType);
-    }
-
-    if (wrappedResult.response !== undefined) {
-      respond.response = wrappedResult.response;
-    }
+    respond.response = Utils.wrapResult(result, respond.context);
 
   } catch (e) {
     respond.isError = true;
@@ -460,7 +452,7 @@ FirefoxDriver.prototype.findElementsInternal_ = function(respond, method,
     elementIds.push(Utils.addToKnownElements(element, respond.context));
   }
 
-  respond.response = elementIds.join(',');
+  respond.response = elementIds;
   respond.send();
 };
 
@@ -650,12 +642,11 @@ FirefoxDriver.prototype.getCookie = function(respond) {
         + (c.isSecure ? "secure ;" : "");
   };
 
-  var toReturn = "";
+  var toReturn = [];
   var cookies = getVisibleCookies(Utils.getBrowser(respond.context).
       contentWindow.location);
   for (var i = 0; i < cookies.length; i++) {
-    var toAdd = cookieToString(cookies[i]);
-    toReturn += toAdd + "\n";
+    toReturn.push(cookieToString(cookies[i]));
   }
 
   respond.response = toReturn;
@@ -698,13 +689,13 @@ FirefoxDriver.prototype.deleteAllCookies = function(respond) {
 
 
 FirefoxDriver.prototype.setMouseSpeed = function(respond, speed) {
-  this.mouseSpeed = speed;
+  this.mouseSpeed = speed.shift();
   respond.send();
 };
 
 
 FirefoxDriver.prototype.getMouseSpeed = function(respond) {
-  respond.response = "" + this.mouseSpeed;
+  respond.response = this.mouseSpeed;
   respond.send();
 };
 
@@ -754,4 +745,4 @@ FirefoxDriver.prototype.dismissAlert = function(respond, alertText) {
     }
   }
   respond.send();
-};
+};

data/firefox/src/extension/components/nsCommandProcessor.js

@@ -377,11 +377,11 @@ nsCommandProcessor.prototype.execute = function(jsonCommandString,
  * @param {Array.<*>} windowId The parameters sent with the original command.
  *     The first element in the array must be the ID of the window to switch to.
  *     Note all other command parameters are ignored.
- * @param {boolean} opt_isSecondSearch Whether this is the second attempt to
- *     find the window.
+ * @param {number} opt_searchAttempt Which attempt this is at finding the
+ *     window to switch to.
  */
 nsCommandProcessor.prototype.switchToWindow = function(response, windowId,
-                                                       opt_isSecondSearch) {
+                                                       opt_searchAttempt) {
   var lookFor = windowId[0];
   var matches = function(win, lookFor) {
     return !win.closed &&
@@ -413,9 +413,12 @@ nsCommandProcessor.prototype.switchToWindow = function(response, windowId,
   // typically true for anchors with a target attribute set. This search could
   // execute before the target window has finished loaded, meaning the content
   // window won't have a name or FirefoxDriver instance yet (see matches above).
-  // If we don't find the window, set a timeout to try one more time.
+  // If we don't find the window, set a timeout and try again.
   if (!windowFound) {
-    if (opt_isSecondSearch) {
+    // TODO(jmleyba): We should be sniffing the current windows to detect if
+    // one is still loading vs. a brute force "try again"
+    var searchAttempt = opt_searchAttempt || 0;
+    if (searchAttempt > 3) {
       response.isError = true;
       response.response = 'Unable to locate window "' + lookFor + '"';
       response.send();
@@ -423,7 +426,7 @@ nsCommandProcessor.prototype.switchToWindow = function(response, windowId,
       var self = this;
       this.wm.getMostRecentWindow('navigator:browser').
           setTimeout(function() {
-            self.switchToWindow(response, windowId, true);
+            self.switchToWindow(response, windowId, (searchAttempt + 1));
           }, 500);
     }
   }
@@ -442,11 +445,9 @@ nsCommandProcessor.prototype.getWindowHandles = function(response) {
       res.push(win.top.fxdriver.id);
     } else if (win.content) {
       res.push(win.content.name);
-    } else {
-      res.push('');
     }
   });
-  response.response = res.join(',');
+  response.response = res;
   response.send();
 };
 

data/firefox/src/extension/components/utils.js

@@ -1200,18 +1200,18 @@ Utils.unwrapParameters = function(wrappedParameters, resultArray, context) {
 Utils.wrapResult = function(result, context) {
   // Sophisticated.
   if (null === result || undefined === result) {
-    return {resultType: "NULL"};
+    return {type: "NULL", value: null};
   } else if (result['tagName']) {
-    return {resultType: "ELEMENT",
-            response: Utils.addToKnownElements(result, context)};
+    return {type: "ELEMENT",
+            value: Utils.addToKnownElements(result, context)};
   } else if (result !== undefined &&
              result.constructor.toString().indexOf("Array") != -1) {
     var array = [];
     for (var i = 0; i < result.length; i++) {
       array.push(Utils.wrapResult(result[i], context));
     }
-    return {resultType: "ARRAY", response: array};
+    return {type: "ARRAY", value: array};
   } else {
-    return {resultType: "OTHER", response: result};
+    return {type: "OTHER", value: result};
   }
 }

data/firefox/src/extension/components/webdriverserver.js

@@ -24,6 +24,11 @@ function WebDriverServer() {
       createInstance(Components.interfaces.nsIServerSocket);
   this.generator = Utils.getService("@mozilla.org/uuid-generator;1", "nsIUUIDGenerator");
   this.enableNativeEvents = null;
+
+  // Force our cert override service to be loaded - otherwise, it will not be
+  // loaded and cause a "too deep recursion" error.
+  var overrideService = Components.classes["@mozilla.org/security/certoverride;1"]
+      .getService(Components.interfaces.nsICertOverrideService);
 }
 
 

data/firefox/src/extension/components/wrappedElement.js

@@ -287,8 +287,7 @@ FirefoxDriver.prototype.getAttribute = function(respond, value) {
     respond.send();
     return;
   }
-  respond.isError = true;
-  respond.response = "No match";
+  respond.response = null;
   respond.send();
 };
 
@@ -469,8 +468,7 @@ FirefoxDriver.prototype.toggle = function(respond) {
 
 FirefoxDriver.prototype.isDisplayed = function(respond) {
   var element = Utils.getElementAt(respond.elementId, respond.context);
-
-  respond.response = Utils.isDisplayed(element) ? "true" : "false";
+  respond.response = Utils.isDisplayed(element);
   respond.send();
 };
 
@@ -480,7 +478,10 @@ FirefoxDriver.prototype.getLocation = function(respond) {
 
   var location = Utils.getElementLocation(element, respond.context);
 
-  respond.response = location.x + ", " + location.y;
+  respond.response = {
+    x: Math.round(location.x),
+    y: Math.round(location.y)
+  };
   respond.send();
 };
 
@@ -490,7 +491,10 @@ FirefoxDriver.prototype.getSize = function(respond) {
 
   var box = Utils.getLocationOnceScrolledIntoView(element);
 
-  respond.response = box.width + ", " + box.height;
+  respond.response = {
+    width: Math.round(box.width),
+    height: Math.round(box.height)
+  };
   respond.send();
 };
 

data/firefox/src/rb/lib/selenium/webdriver/firefox/bridge.rb

@@ -36,7 +36,7 @@ module Selenium
         end
 
         def getWindowHandles
-          execute(:getWindowHandles).to_s.split(", ")
+          execute :getWindowHandles
         end
 
         def getCurrentWindowHandle
@@ -77,8 +77,9 @@ module Selenium
           typed_args = args.map { |e| wrap_script_argument(e) }
 
           resp = raw_execute :executeScript, :parameters => [string, typed_args]
+          raise TypeError, "expected Hash" unless resp.kind_of? Hash
 
-          unwrap_script_argument resp
+          unwrap_script_argument resp["response"]
         end
 
         #
@@ -180,8 +181,7 @@ module Selenium
           # data = execute :getElementLocation, :element_id => element
           data = execute :getLocation,
                          :element_id => element
-
-          Point.new(*data.split(",").map { |e| Integer(e.strip) })
+          Point.new(data["x"], data["y"])
         end
 
         def getElementSize(element)
@@ -293,8 +293,7 @@ module Selenium
 
         def getAllCookies
           data = execute :getCookie
-
-          data.strip.split("\n").map do |c|
+          data.map do |c|
             parse_cookie_string(c) unless c.strip.empty?
           end.compact
         end
@@ -349,7 +348,7 @@ module Selenium
                                 :parameters => [how, what]
           end
 
-          id_string.split(",").map { |id| Element.new self, element_id_from(id) }
+          id_string.map { |id| Element.new self, element_id_from(id) }
         end
 
         def newSession
@@ -420,13 +419,13 @@ module Selenium
 
         def unwrap_script_argument(arg)
           raise TypeError, "expected Hash" unless arg.kind_of? Hash
-          case arg["resultType"]
+          case arg["type"]
           when "NULL"
             nil
           when "ELEMENT"
-            Element.new self, element_id_from(arg["response"])
+            Element.new self, element_id_from(arg["value"])
           when "ARRAY"
-            arg['response'].map { |e| unwrap_script_argument(e) }
+            arg['value'].map { |e| unwrap_script_argument(e) }
           # when "POINT"
           #   Point.new arg['x'], arg['y']
           # when "DIMENSION"
@@ -434,7 +433,7 @@ module Selenium
           # when "COOKIE"
           #   {:name => arg['name'], :value => arg['value']}
           else
-            arg["response"]
+            arg["value"]
           end
         end
 
@@ -442,4 +441,4 @@ module Selenium
       end # Bridge
     end # Firefox
   end # WebDriver
-end # Selenium
+end # Selenium