rainux-selenium-webdriver 0.0.17

data/chrome/src/extension/manifest-nonwin.json

@@ -0,0 +1,19 @@
+{
+  "name": "WebDriver",
+  "version": "1.9.10",
+  "description": "WebDriver extension for Chrome",
+  "browser_action": {
+    "default_title": "WebDriver",
+    "default_icon": "icons/free.png"
+  },
+  "background_page": "background.html",
+  "content_scripts": [
+    {
+      "matches": ["http://*/*", "https://*/*", "file:///*"],
+      "js": ["utils.js", "content_script.js"],
+      "run_at": "document_end",
+      "all_frames": true
+    }
+  ],
+  "permissions": ["http://*/*", "tabs"]
+}

data/chrome/src/extension/manifest-win.json

@@ -0,0 +1,20 @@
+{
+  "name": "WebDriver",
+  "version": "1.9.10  ",
+  "description": "WebDriver extension for Chrome",
+  "browser_action": {
+    "default_title": "WebDriver",
+    "default_icon": "icons/free.png"
+  },
+  "background_page": "background.html",
+  "content_scripts": [
+    {
+      "matches": ["http://*/*", "https://*/*", "file:///*"],
+      "js": ["utils.js", "content_script.js"],
+      "run_at": "document_end",
+      "all_frames": true
+    }
+  ],
+  "plugins": [{"path": "npchromedriver.dll", "public": true}],
+  "permissions": ["http://*/*", "tabs"]
+}

data/chrome/src/extension/utils.js

@@ -0,0 +1,231 @@
+//Very cut-down and slightly modified (generally to remove context) from
+//$WEBDRIVER_HOME/firefox/src/extension/components/utils.js
+
+function Utils() {
+}
+
+function getTextFromNode(node, toReturn, textSoFar, isPreformatted) {
+    if (node['tagName'] && node.tagName == "SCRIPT") {
+        return [toReturn, textSoFar];
+    } else if (node['tagName'] && node.tagName == "TITLE") {
+        return [textSoFar + node.text, ""];
+    }
+    var children = node.childNodes;
+
+    for (var i = 0; i < children.length; i++) {
+        var child = children[i];
+
+        // Do we need to collapse the text so far?
+        if (child["tagName"] && child.tagName == "PRE") {
+            toReturn += collapseWhitespace(textSoFar);
+            textSoFar = "";
+            var bits = getTextFromNode(child, toReturn, "", true);
+            toReturn += bits[1];
+            continue;
+        }
+
+        // Or is this just plain text?
+        if (child.nodeName == "#text") {
+            if (Utils.isDisplayed(child)) {
+                var textToAdd = child.nodeValue;
+                textToAdd = textToAdd.replace(new RegExp(String.fromCharCode(160), "gm"), " ");
+                textSoFar += textToAdd;
+            }
+            continue;
+        }
+
+        // Treat as another child node.
+        var bits = getTextFromNode(child, toReturn, textSoFar, false);
+        toReturn = bits[0];
+        textSoFar = bits[1];
+    }
+
+    if (isBlockLevel(node)) {
+        if (node["tagName"] && node.tagName != "PRE") {
+            toReturn += collapseWhitespace(textSoFar) + "\n";
+            textSoFar = "";
+        } else {
+            toReturn += "\n";
+        }
+    }
+    return [toReturn, textSoFar];
+}
+;
+
+function isBlockLevel(node) {
+    if (node["tagName"] && node.tagName == "BR")
+        return true;
+
+    try {
+        // Should we think about getting hold of the current document?
+        return "block" == Utils.getStyleProperty(node, "display");
+    } catch (e) {
+        return false;
+    }
+};
+
+Utils.isInHead = function(element) {
+  while (element) {
+    if (element.tagName && element.tagName.toLowerCase() == "head") {
+      return true;
+    }
+    try {
+      element = element.parentNode;
+    } catch (e) {
+      // Fine. the DOM has dispeared from underneath us
+      return false;
+    }
+  }
+
+  return false;
+};
+
+Utils.isDisplayed = function(element) {
+    // Ensure that we're dealing with an element.
+    var el = element;
+    while (el.nodeType != 1 && !(el.nodeType >= 9 && el.nodeType <= 11)) {
+        el = el.parentNode;
+    }
+
+    // Hidden input elements are, by definition, never displayed
+    if (el.tagName == "input" && el.type == "hidden") {
+      return false;
+    }
+
+    var visibility = Utils.getStyleProperty(el, "visibility");
+
+    var _isDisplayed = function(e) {
+      var display = e.ownerDocument.defaultView.getComputedStyle(e, null).getPropertyValue("display");
+      if (display == "none") return display;
+      if (e && e.parentNode && e.parentNode.style) {
+        return _isDisplayed(e.parentNode);
+      }
+      return undefined;
+    };
+
+    var displayed = _isDisplayed(el);
+
+    if (element.scrollIntoView && element.getBoundingClientRect &&
+        element.tagName.toLowerCase() != "option") {
+      //Option tags have 0-dimension bounding rects so ignore them
+      element.scrollIntoView(true);
+      var clientRect = element.getBoundingClientRect();
+      if (clientRect.width == 0 || clientRect.height == 0) {
+        return false;
+      }
+    }
+    
+    return displayed != "none" && visibility != "hidden";
+};
+
+Utils.getStyleProperty = function(node, propertyName) {
+    if (!node)
+      return undefined;
+
+    var value = node.ownerDocument.defaultView.getComputedStyle(node, null).getPropertyValue(propertyName);
+
+    // Convert colours to hex if possible
+    var raw = /rgb\((\d{1,3}),\s(\d{1,3}),\s(\d{1,3})\)/.exec(value);
+    if (raw) {
+        var temp = value.substr(0, raw.index);
+
+        var hex = "#";
+        for (var i = 1; i <= 3; i++) {
+            var colour = (raw[i] - 0).toString(16);
+            if (colour.length == 1)
+                colour = "0" + colour;
+            hex += colour
+        }
+        hex = hex.toLowerCase();
+        value = temp + hex + value.substr(raw.index + raw[0].length);
+    }
+
+    if (value == "inherit" && element.parentNode.style) {
+      value = Utils.getStyleProperty(node.parentNode, propertyName);
+    }
+
+    return value;
+};
+
+function collapseWhitespace(textSoFar) {
+    return textSoFar.replace(/\s+/g, " ");
+}
+
+function getPreformattedText(node) {
+    var textToAdd = "";
+    return getTextFromNode(node, "", textToAdd, true)[1];
+}
+
+function isWhiteSpace(character) {
+    return character == '\n' || character == ' ' || character == '\t' || character == '\r';
+}
+
+Utils.getText = function(element) {
+    var bits = getTextFromNode(element, "", "", element.tagName == "PRE");
+    var text = bits[0] + collapseWhitespace(bits[1]);
+    var start = 0;
+    while (start < text.length && isWhiteSpace(text[start])) {
+        ++start;
+    }
+    var end = text.length;
+    while (end > start && isWhiteSpace(text[end - 1])) {
+        --end;
+    }
+    return text.slice(start, end);
+};
+
+/**
+ * Fires the event using Utils.fireEvent, and if the event returned true,
+ * perform callback, which will be passed on arguments
+ */
+Utils.fireHtmlEventAndConditionallyPerformAction = function(element, eventName, callback) {
+    Utils.fireHtmlEvent(element, eventName, function(evt) { if (JSON.parse(evt.newValue).value) { callback(); } });
+};
+
+Utils.fireHtmlEvent = function(element, eventName, callback) {
+    if (callback === undefined) {
+      callback = function() {};
+    }
+    var args = [
+      {type: "ELEMENT", value: addElementToInternalArray(element)},
+      {type: "STRING", value: eventName}
+    ];
+
+    // We need to do this because event handlers refer to functions that
+    // the content script can't reah. See:
+    // http://code.google.com/p/chromium/issues/detail?id=29071
+    var script = "var e = document.createEvent('HTMLEvents'); "
+      + "e.initEvent(arguments[1], true, true); " 
+      + "return arguments[0].dispatchEvent(e);";
+
+    execute_(script, args, callback);
+};
+
+
+Utils.fireMouseEventOn = function(element, eventName) {
+    Utils.triggerMouseEvent(element, eventName, 0, 0);
+};
+
+Utils.triggerMouseEvent = function(element, eventType, clientX, clientY) {
+    var args = [
+      {type: "ELEMENT", value: addElementToInternalArray(element)},
+      {type: "STRING", value: eventType},
+      {type: "NUMBER", value: clientX},
+      {type: "NUMBER", value: clientY}
+    ];
+
+    // We need to do this because event handlers refer to functions that
+    // the content script can't reah. See:
+    // http://code.google.com/p/chromium/issues/detail?id=29071
+    var script =
+        "var event = arguments[0].ownerDocument.createEvent('MouseEvents'); "
+        + "var view = arguments[0].ownerDocument.defaultView; "
+        + "event.initMouseEvent(arguments[1], true, true, view, 1, 0, 0, arguments[2], arguments[3], false, false, false, false, 0, arguments[0]);"
+        + " arguments[0].dispatchEvent(event);";
+
+    execute_(script, args, function(){});
+};
+
+Utils.trim = function(str) {
+  return str.replace(/^\s*/, "").replace(/\s*$/, "");
+}

data/chrome/src/rb/lib/selenium/webdriver/chrome.rb

@@ -0,0 +1,8 @@
+require "selenium/webdriver/chrome/launcher"
+require "selenium/webdriver/chrome/command_executor"
+require "selenium/webdriver/chrome/bridge"
+
+require "fileutils"
+require "thread"
+require "socket"
+

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

@@ -0,0 +1,358 @@
+module Selenium
+  module WebDriver
+    module Chrome
+      class Bridge
+        include BridgeHelper
+
+        def initialize
+          @executor = CommandExecutor.new
+
+          @launcher = Launcher.launcher
+          @launcher.launch(@executor.uri)
+        end
+
+        def browser
+          :chrome
+        end
+
+        def driver_extensions
+          [DriverExtensions::TakesScreenshot]
+        end
+
+        def get(url)
+          execute :request => 'get',
+                  :url     => url
+        end
+
+        def goBack
+          execute :request => 'goBack'
+        end
+
+        def goForward
+          execute :request => 'goForward'
+        end
+
+        def getCurrentUrl
+          execute :request => 'getCurrentUrl'
+        end
+
+        def getTitle
+          execute :request => 'getTitle'
+        end
+
+        def getPageSource
+          execute :request => 'getPageSource'
+        end
+
+        def switchToWindow(name)
+          execute :request    => 'switchToWindow',
+                  :windowName => name
+        end
+
+        def switchToFrame(id)
+          execute :request => 'switchToFrameByName',
+                  :name    => id
+        end
+
+        def switchToDefaultContent
+          execute :request => "switchToDefaultContent"
+        end
+
+        def quit
+          begin
+            execute :request => 'quit'
+          rescue IOError
+          end
+
+          @launcher.kill
+          @executor.close
+        end
+
+        def close
+          execute :request => 'close'
+        end
+
+        def refresh
+          execute :request => 'refresh'
+        end
+
+        def getWindowHandles
+          execute :request => 'getWindowHandles'
+        end
+
+        def getCurrentWindowHandle
+          execute :request => 'getCurrentWindowHandle'
+        end
+
+        def getScreenshotAsBase64
+          execute :request => "screenshot"
+        end
+
+        def setSpeed(value)
+          @speed = value
+        end
+
+        def getSpeed
+          @speed
+        end
+
+        def executeScript(script, *args)
+          typed_args = args.map { |e| wrap_script_argument(e) }
+
+          resp = execute :request => 'executeScript',
+                         :script  => script,
+                         :args    => typed_args
+
+          return if resp.nil?
+          unwrap_script_argument resp
+        end
+
+        def addCookie(cookie)
+          execute :request => 'addCookie',
+                  :cookie  => cookie
+        end
+
+        def deleteCookie(name)
+          execute :request => 'deleteCookie',
+                  :name    => name
+        end
+
+        def getAllCookies
+          execute :request => 'getCookies'
+        end
+
+        def deleteAllCookies
+          execute :request => 'deleteAllCookies'
+        end
+
+        def findElementByClassName(parent, class_name)
+          find_element_by 'class name', class_name, parent
+        end
+
+        def findElementsByClassName(parent, class_name)
+          find_elements_by 'class name', class_name, parent
+        end
+
+        def findElementById(parent, id)
+          find_element_by 'id', id, parent
+        end
+
+        def findElementsById(parent, id)
+          find_elements_by 'id', id, parent
+        end
+
+        def findElementByLinkText(parent, link_text)
+          find_element_by 'link text', link_text, parent
+        end
+
+        def findElementsByLinkText(parent, link_text)
+          find_elements_by 'link text', link_text, parent
+        end
+
+        def findElementByPartialLinkText(parent, link_text)
+          find_element_by 'partial link text', link_text, parent
+        end
+
+        def findElementsByPartialLinkText(parent, link_text)
+          find_elements_by 'partial link text', link_text, parent
+        end
+
+        def findElementByName(parent, name)
+          find_element_by 'name', name, parent
+        end
+
+        def findElementsByName(parent, name)
+          find_elements_by 'name', name, parent
+        end
+
+        def findElementByTagName(parent, tag_name)
+          find_element_by 'tag name', tag_name, parent
+        end
+
+        def findElementsByTagName(parent, tag_name)
+          find_elements_by 'tag name', tag_name, parent
+        end
+
+        def findElementByXpath(parent, xpath)
+          find_element_by 'xpath', xpath, parent
+        end
+
+        def findElementsByXpath(parent, xpath)
+          find_elements_by 'xpath', xpath, parent
+        end
+
+        def findElementByCssSelector(parent, selector)
+          find_element_by 'css selector', selector, parent
+        end
+
+        def findElementsByCssSelector(parent, selector)
+          find_elements_by 'css selector', selector, parent
+        end
+
+
+        #
+        # Element functions
+        #
+
+        def clickElement(element)
+          execute :request   => 'clickElement',
+                  :elementId => element
+        end
+
+        def getElementTagName(element)
+          execute :request   => 'getElementTagName',
+                  :elementId => element
+        end
+
+        def getElementAttribute(element, name)
+          execute :request   => 'getElementAttribute',
+                  :elementId => element,
+                  :attribute => name
+        end
+
+        def getElementValue(element)
+          execute :request   => 'getElementValue',
+                  :elementId => element
+        end
+
+        def getElementText(element)
+          execute :request   => 'getElementText',
+                  :elementId => element
+        end
+
+        def getElementLocation(element)
+          data = execute :request   => 'getElementLocation',
+                         :elementId => element
+
+          Point.new data['x'], data['y']
+        end
+
+        def getElementSize(element)
+          data = execute :request   => 'getElementSize',
+                         :elementId => element
+
+          Dimension.new data['width'], data['height']
+        end
+
+        def sendKeysToElement(element, string)
+          execute :request   => 'sendKeysToElement',
+                  :elementId => element,
+                  :keys      => string.split(//u)
+        end
+
+        def clearElement(element)
+          execute :request   => 'clearElement',
+                  :elementId => element
+        end
+
+        def isElementEnabled(element)
+          execute :request   => 'isElementEnabled',
+                  :elementId => element
+        end
+
+        def isElementSelected(element)
+          execute :request   => 'isElementSelected',
+                  :elementId => element
+        end
+
+        def isElementDisplayed(element)
+          execute :request   => 'isElementDisplayed',
+                  :elementId => element
+        end
+
+        def submitElement(element)
+          execute :request   => 'submitElement',
+                  :elementId => element
+        end
+
+        def toggleElement(element)
+          execute :request   => 'toggleElement',
+                  :elementId => element
+        end
+
+        def setElementSelected(element)
+          execute :request   => 'setElementSelected',
+                  :elementId => element
+        end
+
+        def getElementValueOfCssProperty(element, prop)
+          execute :request   => 'getElementValueOfCssProperty',
+                  :elementId => element,
+                  :css       => prop
+        end
+
+        def getActiveElement
+          Element.new self, element_id_from(execute(:request => 'getActiveElement'))
+        end
+        alias_method :switchToActiveElement, :getActiveElement
+
+        def hoverOverElement(element)
+          execute :request   => 'hoverOverElement',
+                  :elementId => element
+        end
+
+        def dragElement(element, rigth_by, down_by)
+          raise UnsupportedOperationError, "drag and drop unsupported in Chrome"
+          execute :drag_element, {:id => element}, element, rigth_by, down_by
+        end
+
+        private
+
+        def find_element_by(how, what, parent = nil)
+          if parent
+            id = execute :request => 'findChildElement',
+                         :id      => parent,
+                         :using   => how,
+                         :value   => what
+          else
+            id = execute :request => 'findElement',
+                         :using   => how,
+                         :value   => what
+          end
+
+          Element.new self, element_id_from(id)
+        end
+
+        def find_elements_by(how, what, parent = nil)
+          if parent
+            ids = execute :request => 'findChildElements',
+                          :id      => parent,
+                          :using   => how,
+                          :value   => what
+          else
+            ids = execute :request => 'findElements',
+                          :using   => how,
+                          :value   => what
+          end
+
+          ids.map { |id| Element.new self, element_id_from(id) }
+        end
+
+
+        private
+
+        def execute(command)
+          puts "--> #{command.inspect}" if $DEBUG
+          resp = raw_execute command
+          puts "<-- #{resp.inspect}" if $DEBUG
+
+          code = resp['statusCode']
+          if e = Error.for_code(code)
+            msg = resp['value']['message'] if resp['value']
+            msg ||= "unknown exception for #{command.inspect}"
+            msg << " (#{code})"
+
+            raise e, msg
+          end
+
+          resp['value']
+        end
+
+        def raw_execute(command)
+          @executor.execute command
+        end
+
+      end # Bridge
+    end # Chrome
+  end # WebDriver
+end # Selenium