selenium-webdriver 0.0.1

data/common/src/js/by.js

@@ -0,0 +1,147 @@
+/** @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');
+
+
+/**
+ * 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,274 @@
+/** @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');
+
+
+/**
+ * Describes a command to be executed by a
+ * {@code webdriver.AbstractCommandProcessor}.
+ * @param {string} 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
+ */
+webdriver.Command = function(name, opt_element) {
+
+  /**
+   * The name of this command.
+   * @type {string}
+   */
+  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 = [];
+
+  /**
+   * Callback for when the command processor successfully finishes this command.
+   * The result of this function is included in the final result of the command.
+   * @type {?function}
+   */
+  this.onSuccessCallbackFn = null;
+  
+  /**
+   * Callback for when the command processor fails to successfully finish a
+   * command. The function should take a single argument, the
+   * {@code webdriver.Response} from the command processor. The response may be
+   * modified (for example, to turn an expect failure into a success). If the
+   * error state is cleared, the {@code onSucessCallbackFn} will still not be
+   * called.
+   * @type {?function}
+   */
+  this.onFailureCallbackFn = null;
+
+  /**
+   * Callback for when this command is completely finished, which is after the
+   * response is set and success/failure callbacks have been run. The function
+   * should take a single argument, a reference to this command.
+   * @type {?function}
+   * @private
+   */
+  this.onCompleteCallbackFn_ = null;
+
+  /**
+   * The response to this command.
+   * @type {webdriver.Response}
+   */
+  this.response = null;
+
+  /**
+   * Whether this command was aborted.
+   * @type {boolean}
+   */
+  this.abort = false;
+};
+
+
+/**
+ * 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;
+};
+
+
+/**
+ * Set the function to call with the {@code webdriver.Response} when the
+ * command processor successfully runs this command. This function is considered
+ * part of the command and any errors will cause the command as a whole to fail.
+ * @param {function} callbackFn The function to call on success.
+ * @param {Object} opt_selfObj The object in whose context to execute the
+ *     function.
+ */
+webdriver.Command.prototype.setSuccessCallback = function(callbackFn,
+                                                          opt_selfObj) {
+  if (callbackFn) {
+    this.onSuccessCallbackFn = goog.bind(callbackFn, opt_selfObj);
+  }
+  return this;
+};
+
+
+/**
+ * Set the function to call with the {@code webdriver.Response} when the
+ * command processor encounters an error while executing this command.
+ * @param {function} callbackFn The function to call on failure.
+ * @param {Object} opt_selfObj The object in whose context to execute the
+ *     function.
+ */
+webdriver.Command.prototype.setFailureCallback = function(callbackFn,
+                                                          opt_selfObj) {
+  if (callbackFn) {
+    this.onFailureCallbackFn = goog.bind(callbackFn, opt_selfObj);
+  }
+  return this;
+};
+
+
+/**
+ * Set the function to call with this command when it is completed.
+ * @param {function} callbackFn The function to call on command completion.
+ * @param {Object} opt_selfObj The object in whose context to execute the
+ *     function.
+ */
+webdriver.Command.prototype.setCompleteCallback = function(callbackFn,
+                                                           opt_selfObj) {
+  if (callbackFn) {
+    this.onCompleteCallbackFn_ = goog.bind(callbackFn, opt_selfObj);
+  }
+  return this;
+};
+
+
+/**
+ * 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.response) {
+    return;
+  }
+  this.response = response;
+
+  var sandbox = goog.bind(function(fn) {
+    try {
+      fn.call(this, this.response);
+    } catch (ex) {
+      this.response.isFailure = true;
+      this.response.errors.push(ex);
+    }
+  }, this);
+
+  if (!this.response.errors.length) {
+    if (this.response.isFailure &&
+        goog.isFunction(this.onFailureCallbackFn)) {
+      sandbox(this.onFailureCallbackFn);
+    } else if (!this.response.isFailure &&
+               goog.isFunction(this.onSuccessCallbackFn)) {
+      sandbox(this.onSuccessCallbackFn);
+    }
+  }
+
+  if (this.onCompleteCallbackFn_) {
+    this.onCompleteCallbackFn_(this);
+  }
+};
+
+
+/**
+ * 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 {string} 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);
+  this.extraData = {};
+};

data/common/src/js/context.js

@@ -0,0 +1,58 @@
+/** @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 Defines a simple class for tracking the context of a WebDriver
+ * instance currently being controlled.
+ * @author jmleyba@gmail.com (Jason Leyba)
+ */
+
+goog.provide('webdriver.Context');
+
+
+/**
+ * Keeps track of a WebDriver context (window and frame).
+ * @param {string} opt_windowId The current window ID.
+ * @param {string} opt_frameId The current frame ID.
+ * @constructor
+ */
+webdriver.Context = function(opt_windowId, opt_frameId) {
+  this.windowId = opt_windowId || '';
+  this.frameId = opt_frameId || '';
+};
+
+
+/**
+ * @return {string} The string representation of this context, in the form of
+ *     "${windowId} ${frameId}".
+ * @override
+ */
+webdriver.Context.prototype.toString = function() {
+  return this.windowId + ' ' + this.frameId;
+};
+
+
+
+/**
+ * Creates a new context from the given string.
+ * @param {string} str A string of the form "${windowId} ${frameId}".
+ * @static
+ */
+webdriver.Context.fromString = function(str) {
+  var parts = str.split(' ');
+  return new webdriver.Context(parts[0], parts[1]);
+};