rainux-selenium-webdriver 0.0.17

data/common/src/js/extension/README

@@ -0,0 +1,2 @@
+This directory contains Javascript files that are used in both the Chrome and
+Firefox extensions.

data/common/src/js/extension/dommessenger.js

@@ -0,0 +1,152 @@
+/*
+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 Messenger service used to communicate with the current web
+ * page through custom DOM events.
+ *
+ * <p>The DomMessenger will listen for {@code webdriverCommand} events on the
+ * document. The event target should be a node whose {@code command} attribute
+ * is a JSON string with the command to execute.
+ *
+ * <p>Once the command has been executed, the response will be stored as a JSON
+ * string in the {@code response} attribute of the node that dispatched the
+ * original {@code webdriverCommand} event. The DomMessenger will then dispatch
+ * a {@code webdriverResponse} event on that node to notify the page that a
+ * response is ready.
+ * 
+ * @author jmleyba@gmail.com (Jason Leyba)
+ */
+
+
+/**
+ * The DomMessenger is used to communicate with the current webpage through
+ * custom events fired on the DOM.
+ *
+ * @param { {execute: function(string, function(string))} } commandProcessor The
+ *     object to send commands to for execution. The object should have a single
+ *     method, {@code execute}, that takes two arguments: the command to execute
+ *     as a JSON string, and a callback for the command response (specified as a
+ *     JSON string).
+ * @constructor
+ */
+var DomMessenger = function(commandProcessor) {
+
+  /**
+   * The object to use as a command processor.
+   * @type { {execute: function(string, function(string))} }
+   * @private
+   */
+  this.commandProcessor_ = commandProcessor;
+
+  var self = this;  // TODO(jmleyba): bind
+
+  /**
+   * EventListener for {@code COMMAND_EVENT}s.
+   * @type {function(Event)}
+   * @private
+   */
+  this.commandEventListener_ = function(e) {
+    self.onCommand(e);
+  };
+};
+
+
+/**
+ * Attributes used to pass information between the extension and the current
+ * web page.
+ * @enum {string}
+ */
+DomMessenger.Attribute = {
+  COMMAND: 'command',
+  RESPONSE: 'response'
+};
+
+
+/**
+ * Custom event types used to signal a new message either to or from the current
+ * web page.
+ * @enum {string}
+ */
+DomMessenger.EventType = {
+  COMMAND: 'webdriverCommand',
+  RESPONSE: 'webdriverResponse'
+};
+
+
+/**
+ * Called when a page loads to 
+ * Called when a page loads so an element can be injected for communicating with
+ * the web page.
+ */
+DomMessenger.prototype.onPageLoad = function(e) {
+  // Annotate the documentElement to signal to the client that webdriver is
+  // installed.
+  var doc = e.originalTarget || e.target;
+  doc.documentElement.setAttribute('webdriver', true);
+  doc.addEventListener(
+      DomMessenger.EventType.COMMAND, this.commandEventListener_, true);
+};
+
+
+/**
+ * Called when a page unloads; removes the command event listener.
+ * @param {Event} e The unload event, whose target is the document that was
+ *    unloaded.
+ */
+DomMessenger.prototype.onPageUnload = function(e) {
+  var doc = e.originalTarget || e.target;
+  doc.removeEventListener(
+      DomMessenger.EventType.COMMAND, this.commandEventListener_, true);
+};
+
+
+/**
+ * Handles {@code COMMAND_EVENT}s. The command should be stored as a JSON string
+ * in the {@code COMMAND_ATTRIBUTE}.
+ * @param {Event} e The command event.
+ */
+DomMessenger.prototype.onCommand = function(e) {
+  var client = e.target;
+  var command = client.getAttribute(DomMessenger.Attribute.COMMAND);
+
+  if (!command) {
+    throw Error('No command specified');
+  }
+
+  var self = this;  // TODO(jmleyba): bind
+  this.commandProcessor_.execute(command, function(response) {
+    self.dispatchResponse(client, response);
+  });
+};
+
+
+/**
+ * Dispatches a {@code RESPONSE_EVENT} to notify the appropriate page that a
+ * command it gave completed execution.
+ * @param {Node} client The DOM node that issued the command this response is
+ *     for.
+ * @param {string} response Response to a command as a JSON string.
+ */
+DomMessenger.prototype.dispatchResponse = function(client, response) {
+  client.setAttribute(DomMessenger.Attribute.RESPONSE, response);
+  var evt = client.ownerDocument.createEvent('Event');
+  evt.initEvent(DomMessenger.EventType.RESPONSE,
+      /*canBubble=*/true, /*cancellable=*/true);
+  client.dispatchEvent(evt);
+};

data/common/src/js/factory.js

@@ -0,0 +1,55 @@
+/** @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 Provides factory methods for creating new instances of
+ * {@code webdriver.WebDriver}.
+ * @author jmleyba@gmail.com (Jason Leyba)
+ */
+
+goog.provide('webdriver.factory');
+
+goog.require('goog.userAgent');
+goog.require('webdriver.LocalCommandProcessor');
+goog.require('webdriver.WebDriver');
+
+
+/**
+ * Creates a new {@code webdriver.WebDriver} instance that uses an
+ * {@code webdriver.AbstractCommandProcessor}. This driver will only be able to
+ * perform the most basic of commands: sleeping and calling user defined
+ * functions.
+ * @return {webdriver.WebDriver} A new WebDriver instance.
+ */
+webdriver.factory.createAbstractDriver = function() {
+  return new webdriver.WebDriver(new webdriver.AbstractCommandProcessor());
+};
+
+
+/**
+ * Creates a new {@code webdriver.WebDriver} instance that uses a
+ * CommandProcessor directly accessible to the current JavaScript engine.
+ * Currently, only Firefox is supported, but IE and Google Chrome support is
+ * planned.
+ * TODO(jmleyba): Add support for Internet Explorer and Goolge Chrome.
+ * @return {webdriver.WebDriver} A new WebDriver instance.
+ * @throws If called from a JavaScript engine that does not have support for a
+ *     local CommandProcessor.
+ */
+webdriver.factory.createLocalWebDriver = function() {
+  return new webdriver.WebDriver(new webdriver.LocalCommandProcessor());
+};

data/common/src/js/future.js

@@ -0,0 +1,141 @@
+/** @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 class for representing the result of an asynchronous
+ * {@code webdriver.Command}.
+ * @author jmleyba@gmail.com (Jason Leyba)
+ */
+
+goog.provide('webdriver.Future');
+
+goog.require('goog.Disposable');
+goog.require('goog.array');
+
+
+/**
+ * Represents the result of an asynchronous {@code webdriver.Command}. Methods
+ * are provided to check if the result has been set and to retrieve the result.
+ * @param {webdriver.WebDriver} driver The WebDriver instance that will
+ *     eventually set this instance's value.
+ * @constructor
+ * @extends {goog.Disposable}
+ */
+webdriver.Future = function(driver) {
+  goog.Disposable.call(this);
+
+  /**
+   * The WebDriver that will eventaully set this instance's value.
+   * @type {webdriver.WebDriver}
+   * @private
+   */
+  this.driver_ = driver;
+
+  /**
+   * The value of this Future.
+   * @type {*}
+   * @private
+   */
+  this.value_ = webdriver.Future.NOT_SET_;
+
+  /**
+   * Futures whose values are linked to this one. When this future's value is
+   * set, all of the linked futures will also be updated.
+   * @type {Array.<webdriver.Future>}
+   * @private
+   */
+  this.linkedFutures_ = [];
+};
+goog.inherits(webdriver.Future,  goog.Disposable);
+
+
+/**
+ * A special place-holder value used to represent that the result for a future
+ * has not been computed yet.
+ * @type {Object}
+ * @private
+ */
+webdriver.Future.NOT_SET_ = {};
+
+
+/** @override */
+webdriver.Future.prototype.disposeInternal = function() {
+  delete this.driver_;
+  delete this.value_;
+  delete this.linkedFutures_;
+  webdriver.Future.superClass_.disposeInternal.call(this);
+};
+
+
+/**
+ * @return {*} The value of this Future.
+ * @throws If the value has not been set yet.
+ */
+webdriver.Future.prototype.getValue = function() {
+  if (this.value_ === webdriver.Future.NOT_SET_) {
+    throw new Error('Value has not been set yet');
+  }
+  return this.value_;
+};
+
+
+/**
+ * @return {webdriver.WebDriver} The WebDriver that set/will set this Future's
+ *     value.
+ */
+webdriver.Future.prototype.getDriver = function() {
+  return this.driver_;
+};
+
+
+/**
+ * Sets the value of this Future and dispatches a
+ * {@code goog.events.EventType.CHANGE} event. If the given value is another
+ * future and its value has not been set, a callback will be registered to
+ * set this instance's value when the input future's value is set. Note that
+ * the value of a future may only be set once.
+ * @param {*} value The new value.
+ */
+webdriver.Future.prototype.setValue = function(value) {
+  if (this.isSet()) {
+    return;
+  }
+  if (value instanceof webdriver.Future) {
+    if (value.isSet()) {
+      value = value.getValue();
+      this.value_ = value;
+      goog.array.forEach(this.linkedFutures_, function(future) {
+        future.setValue(value);
+      });
+    } else {
+      value.linkedFutures_.push(this);
+    }
+  } else {
+    this.value_ = value;
+    goog.array.forEach(this.linkedFutures_, function(future) {
+      future.setValue(value);
+    });
+  }
+};
+
+
+/**
+ * @return {boolean} Whether this future has had its value set.
+ */
+webdriver.Future.prototype.isSet = function() {
+  return this.value_ !== webdriver.Future.NOT_SET_;
+};

data/common/src/js/jsunit.js

@@ -0,0 +1,40 @@
+/** @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 File to include for turnning any HTML page into a WebDriver
+ * JSUnit test suite by configuring an onload listener to the body that will
+ * instantiate and start the test runner.
+ */
+
+goog.provide('webdriver.jsunit');
+
+goog.require('goog.testing.jsunit');
+goog.require('webdriver.TestCase');
+goog.require('webdriver.asserts');
+goog.require('webdriver.factory');
+
+
+(function() {
+  window.onload = function() {
+    var test = new webdriver.TestCase(document.title,
+        webdriver.factory.createLocalWebDriver);
+    test.autoDiscoverTests();
+    G_testRunner.initialize(test);
+    G_testRunner.execute(test);
+  };
+})();

data/common/src/js/jsunit/app/css/jsUnitStyle.css

@@ -0,0 +1,50 @@
+body {
+    margin-top: 0;
+    margin-bottom: 0;
+    font-family: Verdana, Arial, Helvetica, sans-serif;
+    color: #000;
+    font-size: 0.8em;
+    background-color: #fff;
+}
+
+a:link, a:visited {
+    color: #00F;
+}
+
+a:hover {
+    color: #F00;
+}
+
+h1 {
+    font-size: 1.2em;
+    font-weight: bold;
+    color: #039;
+    font-family: Verdana, Arial, Helvetica, sans-serif;
+}
+
+h2 {
+    font-weight: bold;
+    color: #039;
+    font-family: Verdana, Arial, Helvetica, sans-serif;
+}
+
+h3 {
+    font-weight: bold;
+    color: #039;
+    text-decoration: underline;
+    font-family: Verdana, Arial, Helvetica, sans-serif;
+}
+
+h4 {
+    font-weight: bold;
+    color: #039;
+    font-family: Verdana, Arial, Helvetica, sans-serif;
+}
+
+.jsUnitTestResultSuccess {
+    color: #000;
+}
+
+.jsUnitTestResultNotSuccess {
+    color: #F00;
+}

data/common/src/js/jsunit/app/css/readme

@@ -0,0 +1,10 @@
+this file is required due to differences in behavior between Mozilla/Opera 
+and Internet Explorer.
+
+main-data.html calls kickOffTests() which calls top.testManager.start()
+in the top most frame. top.testManager.start() initializes the output 
+frames using document.write and HTML containing a relative <link> to the 
+jsUnitStyle.css file. In MSIE, the base href used to find the CSS file is 
+that of the top level frame however in Mozilla/Opera the base href is
+that of main-data.html. This leads to not-found for the jsUnitStyle.css
+in Mozilla/Opera. Creating app/css/jsUnitStyle.css works around this problem.