rainux-selenium-webdriver 0.0.17

data/common/src/js/by.js

@@ -0,0 +1,149 @@
+/** @license
+Copyright 2007-2009 WebDriver committers
+Copyright 2007-2009 Google 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 Factory methods for the supported locator strategies.
+ * @author jmleyba@gmail.com (Jason Leyba)
+ */
+
+goog.provide('webdriver.By');
+goog.provide('webdriver.By.Locator');
+goog.provide('webdriver.By.Strategy');
+
+goog.require('goog.object');
+goog.require('goog.string');
+
+
+
+/**
+ * An element locator.
+ * @param {webdriver.By.Strategy} type The type of strategy to use for this
+ *     locator.
+ * @param {string} target The target of this locator.
+ * @constructor
+ */
+webdriver.By.Locator = function(type, target) {
+  this.type = type;
+  this.target = target;
+};
+
+
+/**
+ * Creates a new Locator from an object whose only property is also a key in
+ * the {@code webdriver.By.Strategy} enumeration. This property will be the
+ * locator type; its value will be the locator target.
+ * @param {{*: string}} obj The object to convert into a Locator.
+ * @return {webdriver.By.Locator} The new locator object.
+ * @throws If {@code obj} could not be converted.
+ */
+webdriver.By.Locator.createFromObj = function(obj) {
+  var key = goog.object.getAnyKey(obj);
+  if (key && key in webdriver.By.Strategy) {
+    return new webdriver.By.Locator(webdriver.By.Strategy[key], obj[key]);
+  }
+  throw new Error('Unsupported locator strategy: ' + key);
+};
+
+
+/**
+ * Verifies that a {@code locator} is a valid locator to use for searching for
+ * elements on the page.
+ * @param {webdriver.By.Locator|{*: string}} locator The locator to verify, or
+ *     a short-hand object that can be converted into a locator to verify.
+ * @return {webdriver.By.Locator} The validated locator.
+ * @throws If the {@code locator} is not valid.
+ */
+webdriver.By.Locator.checkLocator = function(locator) {
+  if (!locator.type || !locator.target) {
+    locator = webdriver.By.Locator.createFromObj(locator);
+  }
+
+  if (locator.type == webdriver.By.Strategy.className) {
+    var normalized = goog.string.normalizeWhitespace(locator.target);
+    locator.target = goog.string.trim(normalized);
+    if (locator.target.search(/\s/) >= 0) {
+      throw new Error('Compound class names are not allowed for searches: ' +
+                      goog.string.quote(locator.target));
+    }
+  }
+
+  return locator;
+};
+
+
+/**
+ * Enumeration of the supported strategies for finding {@code Element}s on the
+ * page.  For all strategies, if there is more than one possible match, the
+ * first element encountered will be returned.
+ * @enum {string}
+ */
+webdriver.By.Strategy = {
+
+  /**
+   * Find an element by its ID.
+   */
+  id: 'id',
+
+  /**
+   * Find an element by the value of its name attribute.
+   */
+  name: 'name',
+
+  /**
+   * Find an element by one of its class names. Only one class name may be
+   * specified per search.
+   */
+  className: 'class name',
+
+  /**
+   * Find an A tag by its text context.
+   */
+  linkText: 'link text',
+
+  /**
+   * Find an A tag by partially matching its text context.
+   */
+  partialLinkText: 'partial link text',
+
+  /**
+   * Find an element by its tagName property.
+   */
+  tagName: 'tag name',
+
+  /**
+   * Find an element by evaluating an XPath expression.
+   */
+  xpath: 'xpath',
+
+  /**
+   * Find an element by evaluating a javascript expression.
+   */
+  js: 'js'
+};
+
+
+/**
+ * Map each of the supported strategies to a factory function in the
+ * {@code webdriver.By} namespace.
+ */
+goog.object.forEach(webdriver.By.Strategy, function(name, key) {
+  webdriver.By[key] = function(target) {
+    return new webdriver.By.Locator(name, target);
+  };
+});
+
+goog.exportSymbol('By', webdriver.By);

data/common/src/js/command.js

@@ -0,0 +1,304 @@
+/** @license
+Copyright 2007-2009 WebDriver committers
+Copyright 2007-2009 Google 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 several classes for handling commands.
+ * @author jmleyba@gmail.com (Jason Leyba)
+ */
+
+goog.provide('webdriver.Command');
+goog.provide('webdriver.CommandName');
+goog.provide('webdriver.Response');
+
+goog.require('goog.array');
+goog.require('goog.events.EventTarget');
+goog.require('goog.testing.stacktrace');
+goog.require('webdriver.Future');
+
+
+/**
+ * Describes a command to be executed by a
+ * {@code webdriver.AbstractCommandProcessor}.
+ * @param {webdriver.WebDriver} driver The driver that this is a command for.
+ * @param {webdriver.CommandName} name The name of this command.
+ * @param {webdriver.WebElement} opt_element The element to perform this
+ *     command on. If not defined, the command will be performed relative to
+ *     the document root.
+ * @constructor
+ * @extends {goog.events.EventTarget}
+ */
+webdriver.Command = function(driver, name, opt_element) {
+  goog.events.EventTarget.call(this);
+
+  /**
+   * The driver that this is a command to.
+   * @type {webdriver.WebDriver}
+   * @private
+   */
+  this.driver_ = driver;
+
+  /**
+   * A future that will be automatically updated with the value of this
+   * command's response when it is ready. If the command fails, the
+   * future's value will not be set.
+   * @type {webdriver.Future}
+   * @private
+   */
+  this.futureResult_ = new webdriver.Future(this.driver_);
+
+  /**
+   * The name of this command.
+   * @type {webdriver.CommandName}
+   */
+  this.name = name;
+
+  /**
+   * The element to perform this command on. If not defined, the command will be
+   * performed relative to the document root.
+   * @type {webdriver.WebElement}
+   */
+  this.element = opt_element;
+
+  /**
+   * The parameters to this command.
+   * @type {Array.<*>}
+   */
+  this.parameters = [];
+
+  /**
+   * The response to this command.
+   * @type {?webdriver.Response}
+   */
+  this.response = null;
+
+};
+goog.inherits(webdriver.Command, goog.events.EventTarget);
+
+
+/**
+ * The event dispatched by a command when it fails.
+ * @type {string}
+ */
+webdriver.Command.ERROR_EVENT = 'ERROR';
+
+
+/** @override */
+webdriver.Command.prototype.disposeInternal = function() {
+  webdriver.Command.superClass_.disposeInternal.call(this);
+  this.futureResult_.dispose();
+  delete this.driver_;
+  delete this.futureResult_;
+  delete this.name;
+  delete this.element;
+  delete this.parameters;
+  delete this.response;
+};
+
+
+/** @override */
+webdriver.Command.prototype.toString = function() {
+  return this.name;
+};
+
+
+/**
+ * @return {webdriver.WebDriver} The driver that this is a command to.
+ */
+webdriver.Command.prototype.getDriver = function() {
+  return this.driver_;
+};
+
+
+/**
+ * @return {webdriver.CommandName} This command's name.
+ */
+webdriver.Command.prototype.getName = function() {
+  return this.name;
+};
+
+
+/**
+ * @return {webdriver.Future} The future result (value-only) of this command.
+ */
+webdriver.Command.prototype.getFutureResult = function() {
+  return this.futureResult_;
+};
+
+
+/**
+ * @return {boolean} Whether this command has finished; aborted commands are
+ *     never considered finished.
+ */
+webdriver.Command.prototype.isFinished = function() {
+  return !!this.response;
+};
+
+
+/**
+ * Set the parameters to send with this command.
+ * @param {*} var_args The arguments to send to this command.
+ * @return {webdriver.Command} A self reference.
+ */
+webdriver.Command.prototype.setParameters = function(var_args) {
+  this.parameters = goog.array.slice(arguments, 0);
+  return this;
+};
+
+
+/**
+ * @return {Array.<*>} The parameters to send with this command.
+ */
+webdriver.Command.prototype.getParameters = function() {
+  return this.parameters;
+};
+
+
+/**
+ * @return {?webdriver.Response} The response to this command if it is ready.
+ */
+webdriver.Command.prototype.getResponse = function() {
+  return this.response;
+};
+
+
+/**
+ * Set the response for this command. The response may only be set once; any
+ * repeat calls will be ignored.
+ * @param {webdriver.Response} response The response.
+ * @throws If the response was already set.
+ */
+webdriver.Command.prototype.setResponse = function(response) {
+  if (this.isDisposed() || this.isFinished()) {
+    return;
+  }
+  this.response = response;
+  this.driver_.setContext(this.response.context);
+  if (!this.response.isFailure) {
+    this.futureResult_.setValue(this.response.value);
+  } else {
+    this.dispatchEvent(webdriver.Command.ERROR_EVENT);
+  }
+};
+
+
+/**
+ * Enumeration of predefined names command names that all command processors
+ * will support.
+ * @enum {string}
+ */
+webdriver.CommandName = {
+  // Commands executed directly by the JS API. --------------------------------
+  FUNCTION: 'function',
+  SLEEP: 'sleep',
+  WAIT: 'wait',
+  PAUSE: 'pause',
+
+  // Commands dispatched to the browser driver. -------------------------------
+  NEW_SESSION: 'newSession',
+  DELETE_SESSION: 'deleteSession',
+  QUIT: 'quit',
+  GET_CURRENT_WINDOW_HANDLE: 'getCurrentWindowHandle',
+  GET_WINDOW_HANDLES: 'getWindowHandles',
+  GET_CURRENT_URL: 'getCurrentUrl',
+  CLOSE: 'close',
+  SWITCH_TO_WINDOW: 'switchToWindow',
+  SWITCH_TO_FRAME: 'switchToFrame',
+  SWITCH_TO_DEFAULT_CONTENT: 'switchToDefaultContent',
+  GET: 'get',
+  FORWARD: 'goForward',
+  BACK: 'goBack',
+  REFRESH: 'refresh',
+  GET_TITLE: 'title',
+  GET_PAGE_SOURCE: 'getPageSource',
+  EXECUTE_SCRIPT: 'executeScript',
+  GET_MOUSE_SPEED: 'getMouseSpeed',
+  SET_MOUSE_SPEED: 'setMouseSpeed',
+  FIND_ELEMENT: 'findElement',
+  FIND_ELEMENTS: 'findElements',
+  FIND_CHILD_ELEMENT: 'findChildElement',
+  FIND_CHILD_ELEMENTS: 'findChildElements',
+  GET_ACTIVE_ELEMENT: 'getActiveElement',
+  SET_VISIBLE: 'setVisible',
+  GET_VISIBLE: 'getVisible',
+  CLICK: 'click',
+  CLEAR: 'clear',
+  SUBMIT: 'submit',
+  GET_TEXT: 'getText',
+  SEND_KEYS: 'sendKeys',
+  GET_VALUE: 'getValue',
+  GET_TAG_NAME: 'getTagName',
+  IS_SELECTED: 'isSelected',
+  SET_SELECTED: 'setSelected',
+  TOGGLE: 'toggle',
+  IS_ENABLED: 'isEnabled',
+  IS_DISPLAYED: 'isDisplayed',
+  GET_LOCATION: 'getLocation',
+  GET_SIZE: 'getSize',
+  GET_ATTRIBUTE: 'getAttribute',
+  DRAG_ELEMENT: 'dragElement',
+  GET_VALUE_OF_CSS_PROPERTY: 'getValueOfCssProperty'
+};
+
+
+/**
+ * Encapsulates a response to a {@code webdriver.Command}.
+ * @param {boolean} isFailure Whether the command resulted in an error. If
+ *     {@code true}, then {@code value} contains the error message.
+ * @param {webdriver.Context} context The (potentially new) context resulting
+ *     from the command.
+ * @param {*} value The value of the response, the meaning of which depends
+ *     on the command.
+ * @parma {Error} opt_error An error that caused this command to fail
+ *     prematurely.
+ * @constructor
+ */
+webdriver.Response = function(isFailure, context, value, opt_error) {
+  this.isFailure = isFailure;
+  this.context = context;
+  this.value = value;
+  this.errors = goog.array.slice(arguments, 3);
+};
+
+
+/**
+ * @return {?string} A formatted error message, or {@code null} if this is not a
+ *     failure response.
+ */
+webdriver.Response.prototype.getErrorMessage = function() {
+  if (!this.isFailure) {
+    return null;
+  }
+  var message = [];
+  if (goog.isString(this.value)) {
+    message.push(this.value);
+  } else if (null != this.value && goog.isDef(this.value.message)) {
+    message.push(this.value.message);
+    if (goog.isDef(this.value.fileName)) {
+      message.push(this.value.fileName + '@' + this.value.lineNumber);
+    }
+  }
+  goog.array.extend(message, goog.array.map(this.errors, function(error) {
+    if (goog.isString(error)) {
+      return error;
+    }
+    var errMsg = error.message || error.description || error.toString();
+    var stack = error.stack ?
+        goog.testing.stacktrace.canonicalize(error.stack) : error['stackTrace'];
+    return errMsg + '\n' + stack;
+  }));
+  return message.join('\n');
+};