zena 1.1.3 → 1.2.0

data/vendor/plugins/selenium-on-rails/selenium-core/scripts/selenium-executionloop.js

@@ -0,0 +1,175 @@
+/*
+* Copyright 2004 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.
+*/
+
+function TestLoop(commandFactory) {
+    this.commandFactory = commandFactory;
+}
+
+TestLoop.prototype = {
+
+    start : function() {
+        selenium.reset();
+        LOG.debug("currentTest.start()");
+        this.continueTest();
+    },
+
+    continueTest : function() {
+        /**
+         * Select the next command and continue the test.
+         */
+        LOG.debug("currentTest.continueTest() - acquire the next command");
+        if (! this.aborted) {
+            this.currentCommand = this.nextCommand();
+        }
+        if (! this.requiresCallBack) {
+            this.continueTestAtCurrentCommand();
+        } // otherwise, just finish and let the callback invoke continueTestAtCurrentCommand()
+    },
+
+    continueTestAtCurrentCommand : function() {
+        LOG.debug("currentTest.continueTestAtCurrentCommand()");
+        if (this.currentCommand) {
+            // TODO: rename commandStarted to commandSelected, OR roll it into nextCommand
+            this.commandStarted(this.currentCommand);
+            this._resumeAfterDelay();
+        } else {
+            this._testComplete();
+        }
+    },
+
+    _resumeAfterDelay : function() {
+        /**
+         * Pause, then execute the current command.
+         */
+
+        // Get the command delay. If a pauseInterval is set, use it once
+        // and reset it.  Otherwise, use the defined command-interval.
+        var delay = this.pauseInterval || this.getCommandInterval();
+        this.pauseInterval = undefined;
+
+        if (this.currentCommand.isBreakpoint || delay < 0) {
+            // Pause: enable the "next/continue" button
+            this.pause();
+        } else {
+            window.setTimeout(fnBind(this.resume, this), delay);
+        }
+    },
+
+    resume: function() {
+        /**
+         * Select the next command and continue the test.
+         */
+        LOG.debug("currentTest.resume() - actually execute");
+        try {
+            selenium.browserbot.runScheduledPollers();
+            this._executeCurrentCommand();
+            this.continueTestWhenConditionIsTrue();
+        } catch (e) {
+            if (!this._handleCommandError(e)) {
+                this.testComplete();
+            } else {
+                this.continueTest();
+            }
+        }
+    },
+
+    _testComplete : function() {
+        selenium.ensureNoUnhandledPopups();
+        this.testComplete();
+    },
+
+    _executeCurrentCommand : function() {
+        /**
+         * Execute the current command.
+         *
+         * @return a function which will be used to determine when
+         * execution can continue, or null if we can continue immediately
+         */
+        var command = this.currentCommand;
+        LOG.info("Executing: |" + command.command + " | " + command.target + " | " + command.value + " |");
+
+        var handler = this.commandFactory.getCommandHandler(command.command);
+        if (handler == null) {
+            throw new SeleniumError("Unknown command: '" + command.command + "'");
+        }
+
+        command.target = selenium.preprocessParameter(command.target);
+        command.value = selenium.preprocessParameter(command.value);
+        LOG.debug("Command found, going to execute " + command.command);
+        this.result = handler.execute(selenium, command);
+        
+
+        this.waitForCondition = this.result.terminationCondition;
+
+    },
+
+    _handleCommandError : function(e) {
+        if (!e.isSeleniumError) {
+            LOG.exception(e);
+            var msg = "Command execution failure. Please search the forum at http://clearspace.openqa.org for error details from the log window.";
+            msg += "  The error message is: " + extractExceptionMessage(e);
+            return this.commandError(msg);
+        } else {
+            LOG.error(e.message);
+            return this.commandError(e.message);
+        }
+    },
+
+    continueTestWhenConditionIsTrue: function () {
+        /**
+         * Busy wait for waitForCondition() to become true, and then carry
+         * on with test.  Fail the current test if there's a timeout or an
+         * exception.
+         */
+        //LOG.debug("currentTest.continueTestWhenConditionIsTrue()");
+        selenium.browserbot.runScheduledPollers();
+        try {
+            if (this.waitForCondition == null) {
+                LOG.debug("null condition; let's continueTest()");
+                LOG.debug("Command complete");
+                this.commandComplete(this.result);
+                this.continueTest();
+            } else if (this.waitForCondition()) {
+                LOG.debug("condition satisfied; let's continueTest()");
+                this.waitForCondition = null;
+                LOG.debug("Command complete");
+                this.commandComplete(this.result);
+                this.continueTest();
+            } else {
+                //LOG.debug("waitForCondition was false; keep waiting!");
+                window.setTimeout(fnBind(this.continueTestWhenConditionIsTrue, this), 10);
+            }
+        } catch (e) {
+            this.result = {};
+            this.result.failed = true;
+            this.result.failureMessage = extractExceptionMessage(e);
+            this.commandComplete(this.result);
+            this.continueTest();
+        }
+    },
+
+    pause : function() {},
+    nextCommand : function() {},
+    commandStarted : function() {},
+    commandComplete : function() {},
+    commandError : function() {},
+    testComplete : function() {},
+
+    getCommandInterval : function() {
+        return 0;
+    }
+
+}

data/vendor/plugins/selenium-on-rails/selenium-core/scripts/selenium-logging.js

@@ -0,0 +1,148 @@
+/*
+ * Copyright 2004 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.
+ */
+
+var Logger = function() {
+    this.logWindow = null;
+}
+Logger.prototype = {
+
+    logLevels: {
+        debug: 0,
+        info: 1,
+        warn: 2,
+        error: 3,
+        off: 999
+    },
+
+    pendingMessages: new Array(),
+    
+    threshold: "info",
+
+    setLogLevelThreshold: function(logLevel) {
+        this.threshold = logLevel;
+        var logWindow = this.getLogWindow()
+        if (logWindow && logWindow.setThresholdLevel) {
+            logWindow.setThresholdLevel(logLevel);
+        }
+        // NOTE: log messages will be discarded until the log window is
+        // fully loaded.
+    },
+
+    getLogWindow: function() {
+        if (this.logWindow && this.logWindow.closed) {
+            this.logWindow = null;
+        }
+        return this.logWindow;
+    },
+    
+    openLogWindow: function() {
+        this.logWindow = window.open(
+            getDocumentBase(document) + "SeleniumLog.html?startingThreshold="+this.threshold, "SeleniumLog",
+            "width=600,height=1000,bottom=0,right=0,status,scrollbars,resizable"
+        );
+        this.logWindow.moveTo(window.screenX + 1210, window.screenY + window.outerHeight - 1400);
+        if (browserVersion.appearsToBeBrokenInitialIE6) {
+	// I would really prefer for the message to immediately appear in the log window, the instant the user requests that the log window be 
+        	// visible.  But when I initially coded it this way, thou message simply didn't appear unless I stepped through the code with a debugger.  
+        	// So obviously there is some timing issue here which I don't have the patience to figure out.
+        	var pendingMessage = new LogMessage("warn", "You appear to be running an unpatched IE 6, which is not stable and can crash due to memory problems.  We recommend you run Windows update to install a more stable version of IE.");
+            this.pendingMessages.push(pendingMessage);
+        }
+        return this.logWindow;
+    },
+    
+    show: function() {
+        if (! this.getLogWindow()) {
+            this.openLogWindow();
+        }
+        setTimeout(function(){LOG.error("Log window displayed.  Logging events will now be recorded to this window.");}, 500);
+    },
+
+    logHook: function(logLevel, message) {
+    },
+
+    log: function(logLevel, message) {
+        if (this.logLevels[logLevel] < this.logLevels[this.threshold]) {
+            return;
+        }
+        this.logHook(logLevel, message);
+        var logWindow = this.getLogWindow();
+        if (logWindow) {
+            if (logWindow.append) {
+                if (logWindow.disabled) {
+                    logWindow.callBack = fnBind(this.setLogLevelThreshold, this);
+                    logWindow.enableButtons();
+                }
+                if (this.pendingMessages.length > 0) {
+                    logWindow.append("info("+(new Date().getTime())+"): Appending missed logging messages", "info");
+                    while (this.pendingMessages.length > 0) {
+                        var msg = this.pendingMessages.shift();
+                        logWindow.append(msg.type + "("+msg.timestamp+"): " + msg.msg, msg.type);
+                    }
+                    logWindow.append("info("+(new Date().getTime())+"): Done appending missed logging messages", "info");
+                }
+                logWindow.append(logLevel + "("+(new Date().getTime())+"): " + message, logLevel);
+            }
+        } else {
+            // TODO these logging messages are never flushed, which creates 
+            //   an enormous array of strings that never stops growing.
+            //   there should at least be a way to clear the messages!
+            this.pendingMessages.push(new LogMessage(logLevel, message));
+        }
+    },
+
+    close: function(message) {
+        if (this.logWindow != null) {
+            try {
+                this.logWindow.close();
+            } catch (e) {
+                // swallow exception
+                // the window is probably closed if we get an exception here
+            }
+            this.logWindow = null;
+        }
+    },
+
+    debug: function(message) {
+       this.log("debug", message);
+    },
+
+    info: function(message) {
+       this.log("info", message);
+    },
+
+    warn: function(message) {
+       this.log("warn", message);
+    },
+
+    error: function(message) {
+       this.log("error", message);
+    },
+
+    exception: function(exception) {
+        this.error("Unexpected Exception: " + extractExceptionMessage(exception));
+        this.error("Exception details: " + describe(exception, ', '));
+    }
+
+};
+
+var LOG = new Logger();
+
+var LogMessage = function(type, msg) {
+    this.type = type;
+    this.msg = msg;
+    this.timestamp = (new Date().getTime());
+}