/testing/selenium-core/scripts/selenium-testrunner.js

   1/*
   2* Copyright 2004 ThoughtWorks, Inc
   3*
   4*  Licensed under the Apache License, Version 2.0 (the "License");
   5*  you may not use this file except in compliance with the License.
   6*  You may obtain a copy of the License at
   7*
   8*      http://www.apache.org/licenses/LICENSE-2.0
   9*
  10*  Unless required by applicable law or agreed to in writing, software
  11*  distributed under the License is distributed on an "AS IS" BASIS,
  12*  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13*  See the License for the specific language governing permissions and
  14*  limitations under the License.
  15*
  16*/
  17
  18// An object representing the current test, used external
  19var currentTest = null; // TODO: get rid of this global, which mirrors the htmlTestRunner.currentTest
  20var selenium = null;
  21
  22var htmlTestRunner;
  23var HtmlTestRunner = classCreate();
  24objectExtend(HtmlTestRunner.prototype, {
  25    initialize: function() {
  26        this.metrics = new Metrics();
  27        this.controlPanel = new HtmlTestRunnerControlPanel();
  28        this.testFailed = false;
  29        this.currentTest = null;
  30        this.runAllTests = false;
  31        this.appWindow = null;
  32        // we use a timeout here to make sure the LOG has loaded first, so we can see _every_ error
  33        setTimeout(fnBind(function() {
  34            this.loadSuiteFrame();
  35        }, this), 500);
  36    },
  37
  38    getTestSuite: function() {
  39        return suiteFrame.getCurrentTestSuite();
  40    },
  41
  42    markFailed: function() {
  43        this.testFailed = true;
  44        this.getTestSuite().markFailed();
  45    },
  46
  47    loadSuiteFrame: function() {
  48        var logLevel = this.controlPanel.getDefaultLogLevel();
  49        if (logLevel) {
  50            LOG.setLogLevelThreshold(logLevel);
  51        }
  52        if (selenium == null) {
  53            var appWindow = this._getApplicationWindow();
  54            try { appWindow.location; }
  55            catch (e) { 
  56                // when reloading, we may be pointing at an old window (Perm Denied)
  57                setTimeout(fnBind(function() {
  58                    this.loadSuiteFrame();
  59                }, this), 50);
  60                return;
  61            }
  62            selenium = Selenium.createForWindow(appWindow);
  63            this._registerCommandHandlers();
  64        }
  65        this.controlPanel.setHighlightOption();
  66        var testSuiteName = this.controlPanel.getTestSuiteName();
  67        var self = this;
  68        if (testSuiteName) {
  69            suiteFrame.load(testSuiteName, function() {setTimeout(fnBind(self._onloadTestSuite, self), 50)} );
  70            selenium.browserbot.baseUrl = absolutify(testSuiteName, window.location.href);
  71        }
  72        // DGF or should we use the old default?
  73        // selenium.browserbot.baseUrl = window.location.href;
  74        if (this.controlPanel.getBaseUrl()) {
  75            selenium.browserbot.baseUrl = this.controlPanel.getBaseUrl();
  76        }
  77    },
  78
  79    _getApplicationWindow: function () {
  80        if (this.controlPanel.isMultiWindowMode()) {
  81            return this._getSeparateApplicationWindow();
  82        }
  83        return sel$('selenium_myiframe').contentWindow;
  84    },
  85
  86    _getSeparateApplicationWindow: function () {
  87        if (this.appWindow == null) {
  88            this.appWindow = openSeparateApplicationWindow('TestRunner-splash.html', this.controlPanel.isAutomatedRun());
  89        }
  90        return this.appWindow;
  91    },
  92
  93    _onloadTestSuite:function () {
  94        suiteFrame = new HtmlTestSuiteFrame(getSuiteFrame());
  95        if (! this.getTestSuite().isAvailable()) {
  96            return;
  97        }
  98        if (this.controlPanel.isAutomatedRun()) {
  99            this.startTestSuite();
 100        } else if (this.controlPanel.getAutoUrl()) {
 101            //todo what is the autourl doing, left to check it out
 102            addLoadListener(this._getApplicationWindow(), fnBind(this._startSingleTest, this));
 103            this._getApplicationWindow().src = this.controlPanel.getAutoUrl();
 104        } else {
 105            var testCaseLoaded = fnBind(function(){this.testCaseLoaded=true;},this);
 106            var testNumber = 0;
 107            if (this.controlPanel.getTestNumber() != null){
 108                var testNumber = this.controlPanel.getTestNumber() - 1; 
 109            }
 110            this.getTestSuite().getSuiteRows()[testNumber].loadTestCase(testCaseLoaded);
 111        }
 112    },
 113
 114    _startSingleTest:function () {
 115        removeLoadListener(getApplicationWindow(), fnBind(this._startSingleTest, this));
 116        var singleTestName = this.controlPanel.getSingleTestName();
 117        testFrame.load(singleTestName, fnBind(this.startTest, this));
 118    },
 119
 120    _registerCommandHandlers: function () {
 121        this.commandFactory = new CommandHandlerFactory();
 122        this.commandFactory.registerAll(selenium);
 123    },
 124
 125    startTestSuite: function() {
 126        this.controlPanel.reset();
 127        this.metrics.resetMetrics();
 128        this.getTestSuite().reset();
 129        this.runAllTests = true;
 130        this.runNextTest();
 131    },
 132
 133    runNextTest: function () {
 134        this.getTestSuite().updateSuiteWithResultOfPreviousTest();
 135        if (!this.runAllTests) {
 136            return;
 137        }
 138        this.getTestSuite().runNextTestInSuite();
 139    },
 140
 141    startTest: function () {
 142        this.controlPanel.reset();
 143        testFrame.scrollToTop();
 144        //todo: move testFailed and storedVars to TestCase
 145        this.testFailed = false;
 146        storedVars = new Object();
 147        storedVars.nbsp = String.fromCharCode(160);
 148        storedVars.space = ' ';
 149        this.currentTest = new HtmlRunnerTestLoop(testFrame.getCurrentTestCase(), this.metrics, this.commandFactory);
 150        currentTest = this.currentTest;
 151        this.currentTest.start();
 152    },
 153
 154    runSingleTest:function() {
 155        this.runAllTests = false;
 156        this.metrics.resetMetrics();
 157        this.startTest();
 158    }
 159});
 160
 161var runInterval = 0;
 162
 163/** SeleniumFrame encapsulates an iframe element */
 164var SeleniumFrame = classCreate();
 165objectExtend(SeleniumFrame.prototype, {
 166
 167    initialize : function(frame) {
 168        this.frame = frame;
 169        addLoadListener(this.frame, fnBind(this._handleLoad, this));
 170    },
 171
 172    getWindow : function() {
 173        return this.frame.contentWindow;
 174    },
 175
 176    getDocument : function() {
 177        return this.frame.contentWindow.document;
 178    },
 179
 180    _handleLoad: function() {
 181        this._attachStylesheet();
 182        this._onLoad();
 183        if (this.loadCallback) {
 184            this.loadCallback();
 185        }
 186    },
 187
 188    _attachStylesheet: function() {
 189        var d = this.getDocument();
 190        var head = d.getElementsByTagName('head').item(0);
 191        var styleLink = d.createElement("link");
 192        styleLink.rel = "stylesheet";
 193        styleLink.type = "text/css";
 194        if (browserVersion && browserVersion.isChrome) {
 195            // DGF We have to play a clever trick to get the right absolute path.
 196            // This trick works on most browsers, (not IE), but is only needed in
 197            // chrome
 198            var tempLink = window.document.createElement("link");
 199            tempLink.href = "selenium-test.css"; // this will become an absolute href
 200            styleLink.href = tempLink.href;
 201        } else {
 202            // this works in every browser (except Firefox in chrome mode)
 203            var styleSheetPath = window.location.pathname.replace(/[^\/\\]+$/, "selenium-test.css");
 204            if (browserVersion.isIE && window.location.protocol == "file:") {
 205                styleSheetPath = "file:///" + styleSheetPath;
 206            }
 207            styleLink.href = styleSheetPath;
 208        }
 209        // DGF You're only going to see this log message if you set defaultLogLevel=debug
 210        LOG.debug("styleLink.href="+styleLink.href);
 211        head.appendChild(styleLink);
 212    },
 213
 214    _onLoad: function() {
 215    },
 216
 217    scrollToTop : function() {
 218        this.frame.contentWindow.scrollTo(0, 0);
 219    },
 220
 221    _setLocation: function(location) {
 222        var isChrome = browserVersion.isChrome || false;
 223        var isHTA = browserVersion.isHTA || false;
 224        // DGF TODO multiWindow
 225        location += (location.indexOf("?") == -1 ? "?" : "&");
 226        location += "thisIsChrome=" + isChrome + "&thisIsHTA=" + isHTA; 
 227        if (browserVersion.isSafari) {
 228            // safari doesn't reload the page when the location equals to current location.
 229            // hence, set the location to blank so that the page will reload automatically.
 230            this.frame.src = "about:blank";
 231            this.frame.src = location;
 232        } else {
 233            this.frame.contentWindow.location.replace(location);
 234        }
 235    },
 236
 237    load: function(/* url, [callback] */) {
 238        if (arguments.length > 1) {
 239            this.loadCallback = arguments[1];
 240
 241        }
 242        this._setLocation(arguments[0]);
 243    }
 244
 245});
 246
 247/** HtmlTestSuiteFrame - encapsulates the suite iframe element */
 248var HtmlTestSuiteFrame = classCreate();
 249objectExtend(HtmlTestSuiteFrame.prototype, SeleniumFrame.prototype);
 250objectExtend(HtmlTestSuiteFrame.prototype, {
 251
 252    getCurrentTestSuite: function() {
 253        if (!this.currentTestSuite) {
 254            this.currentTestSuite = new HtmlTestSuite(this.getDocument());
 255        }
 256        return this.currentTestSuite;
 257    }
 258
 259});
 260
 261/** HtmlTestFrame - encapsulates the test-case iframe element */
 262var HtmlTestFrame = classCreate();
 263objectExtend(HtmlTestFrame.prototype, SeleniumFrame.prototype);
 264objectExtend(HtmlTestFrame.prototype, {
 265
 266    _onLoad: function() {
 267        this.currentTestCase = new HtmlTestCase(this.getWindow(), htmlTestRunner.getTestSuite().getCurrentRow());
 268    },
 269
 270    getCurrentTestCase: function() {
 271        return this.currentTestCase;
 272    }
 273
 274});
 275
 276function onSeleniumLoad() {
 277    suiteFrame = new HtmlTestSuiteFrame(getSuiteFrame());
 278    testFrame = new HtmlTestFrame(getTestFrame());
 279    htmlTestRunner = new HtmlTestRunner();
 280}
 281
 282var suiteFrame;
 283var testFrame;
 284
 285function getSuiteFrame() {
 286    var f = sel$('testSuiteFrame');
 287    if (f == null) {
 288        f = top;
 289        // proxyInjection mode does not set selenium_myiframe
 290    }
 291    return f;
 292}
 293
 294function getTestFrame() {
 295    var f = sel$('testFrame');
 296    if (f == null) {
 297        f = top;
 298        // proxyInjection mode does not set selenium_myiframe
 299    }
 300    return f;
 301}
 302
 303var HtmlTestRunnerControlPanel = classCreate();
 304objectExtend(HtmlTestRunnerControlPanel.prototype, URLConfiguration.prototype);
 305objectExtend(HtmlTestRunnerControlPanel.prototype, {
 306    initialize: function() {
 307        this._acquireQueryString();
 308
 309        this.runInterval = 0;
 310
 311        this.highlightOption = sel$('highlightOption');
 312        this.pauseButton = sel$('pauseTest');
 313        this.stepButton = sel$('stepTest');
 314
 315        this.highlightOption.onclick = fnBindAsEventListener((function() {
 316            this.setHighlightOption();
 317        }), this);
 318        this.pauseButton.onclick = fnBindAsEventListener(this.pauseCurrentTest, this);
 319        this.stepButton.onclick = fnBindAsEventListener(this.stepCurrentTest, this);
 320
 321
 322        this.speedController = new Control.Slider('speedHandle', 'speedTrack', {
 323            range: $R(0, 1000),
 324            onSlide: fnBindAsEventListener(this.setRunInterval, this),
 325            onChange: fnBindAsEventListener(this.setRunInterval, this)
 326        });
 327
 328        this._parseQueryParameter();
 329    },
 330
 331    setHighlightOption: function () {
 332        var isHighlight = this.highlightOption.checked;
 333        selenium.browserbot.setShouldHighlightElement(isHighlight);
 334    },
 335
 336    _parseQueryParameter: function() {
 337        var tempRunInterval = this._getQueryParameter("runInterval");
 338        if (tempRunInterval) {
 339            this.setRunInterval(tempRunInterval);
 340        }
 341        this.highlightOption.checked = this._getQueryParameter("highlight");
 342    },
 343
 344    setRunInterval: function(runInterval) {
 345        this.runInterval = runInterval;
 346    },
 347
 348    setToPauseAtNextCommand: function() {
 349        this.runInterval = -1;
 350    },
 351
 352    pauseCurrentTest: function () {
 353        this.setToPauseAtNextCommand();
 354        this._switchPauseButtonToContinue();
 355    },
 356
 357    continueCurrentTest: function () {
 358        this.reset();
 359        currentTest.resume();
 360    },
 361
 362    reset: function() {
 363        this.runInterval = this.speedController.value;
 364        this._switchContinueButtonToPause();
 365    },
 366
 367    _switchContinueButtonToPause: function() {
 368        this.pauseButton.className = "cssPauseTest";
 369        this.pauseButton.onclick = fnBindAsEventListener(this.pauseCurrentTest, this);
 370    },
 371
 372    _switchPauseButtonToContinue: function() {
 373        sel$('stepTest').disabled = false;
 374        this.pauseButton.className = "cssContinueTest";
 375        this.pauseButton.onclick = fnBindAsEventListener(this.continueCurrentTest, this);
 376    },
 377
 378    stepCurrentTest: function () {
 379        this.setToPauseAtNextCommand();
 380        currentTest.resume();
 381    },
 382
 383    isAutomatedRun: function() {
 384        return this._isQueryParameterTrue("auto");
 385    },
 386
 387    shouldSaveResultsToFile: function() {
 388        return this._isQueryParameterTrue("save");
 389    },
 390
 391    closeAfterTests: function() {
 392        return this._isQueryParameterTrue("close");
 393    },
 394
 395    getTestSuiteName: function() {
 396        return this._getQueryParameter("test");
 397    },
 398
 399    getTestNumber: function() {
 400        return this._getQueryParameter("testNumber");
 401    },
 402
 403    getSingleTestName: function() {
 404        return this._getQueryParameter("singletest");
 405    },
 406
 407    getAutoUrl: function() {
 408        return this._getQueryParameter("autoURL");
 409    },
 410    
 411    getDefaultLogLevel: function() {
 412        return this._getQueryParameter("defaultLogLevel");
 413    },
 414
 415    getResultsUrl: function() {
 416        return this._getQueryParameter("resultsUrl");
 417    },
 418
 419    _acquireQueryString: function() {
 420        if (this.queryString) return;
 421        if (browserVersion.isHTA) {
 422            var args = this._extractArgs();
 423            if (args.length < 2) return null;
 424            this.queryString = args[1];
 425        } else {
 426            this.queryString = location.search.substr(1);
 427        }
 428    }
 429
 430});
 431
 432var AbstractResultAwareRow = classCreate();
 433objectExtend(AbstractResultAwareRow.prototype, {
 434
 435    initialize: function(trElement) {
 436        this.trElement = trElement;
 437    },
 438
 439    setStatus: function(status) {
 440        this.unselect();
 441        this.trElement.className = this.trElement.className.replace(/status_[a-z]+/, "");
 442        if (status) {
 443            addClassName(this.trElement, "status_" + status);
 444        }
 445    },
 446
 447    select: function() {
 448        addClassName(this.trElement, "selected");
 449        safeScrollIntoView(this.trElement);
 450    },
 451
 452    unselect: function() {
 453        removeClassName(this.trElement, "selected");
 454    },
 455
 456    markPassed: function() {
 457        this.setStatus("passed");
 458    },
 459
 460    markDone: function() {
 461        this.setStatus("done");
 462    },
 463
 464    markFailed: function() {
 465        this.setStatus("failed");
 466    }
 467
 468});
 469
 470var TitleRow = classCreate();
 471objectExtend(TitleRow.prototype, AbstractResultAwareRow.prototype);
 472objectExtend(TitleRow.prototype, {
 473
 474    initialize: function(trElement) {
 475        this.trElement = trElement;
 476        trElement.className = "title";
 477    }
 478
 479});
 480
 481var HtmlTestCaseRow = classCreate();
 482objectExtend(HtmlTestCaseRow.prototype, AbstractResultAwareRow.prototype);
 483objectExtend(HtmlTestCaseRow.prototype, {
 484
 485    getCommand: function () {
 486        return new SeleniumCommand(getText(this.trElement.cells[0]),
 487                getText(this.trElement.cells[1]),
 488                getText(this.trElement.cells[2]),
 489                this.isBreakpoint());
 490    },
 491
 492    markFailed: function(errorMsg) {
 493        AbstractResultAwareRow.prototype.markFailed.call(this, errorMsg);
 494        this.setMessage(errorMsg);
 495    },
 496
 497    setMessage: function(message) {
 498        setText(this.trElement.cells[2], message);
 499    },
 500
 501    reset: function() {
 502        this.setStatus(null);
 503        var thirdCell = this.trElement.cells[2];
 504        if (thirdCell) {
 505            if (thirdCell.originalHTML) {
 506                thirdCell.innerHTML = thirdCell.originalHTML;
 507            } else {
 508                thirdCell.originalHTML = thirdCell.innerHTML;
 509            }
 510        }
 511    },
 512
 513    onClick: function() {
 514        if (this.trElement.isBreakpoint == undefined) {
 515            this.trElement.isBreakpoint = true;
 516            addClassName(this.trElement, "breakpoint");
 517        } else {
 518            this.trElement.isBreakpoint = undefined;
 519            removeClassName(this.trElement, "breakpoint");
 520        }
 521    },
 522
 523    addBreakpointSupport: function() {
 524        elementSetStyle(this.trElement, {"cursor" : "pointer"});
 525        this.trElement.onclick = fnBindAsEventListener(function() {
 526            this.onClick();
 527        }, this);
 528    },
 529
 530    isBreakpoint: function() {
 531        if (this.trElement.isBreakpoint == undefined || this.trElement.isBreakpoint == null) {
 532            return false
 533        }
 534        return this.trElement.isBreakpoint;
 535    }
 536});
 537
 538var HtmlTestSuiteRow = classCreate();
 539objectExtend(HtmlTestSuiteRow.prototype, AbstractResultAwareRow.prototype);
 540objectExtend(HtmlTestSuiteRow.prototype, {
 541
 542    initialize: function(trElement, testFrame, htmlTestSuite) {
 543        this.trElement = trElement;
 544        this.testFrame = testFrame;
 545        this.htmlTestSuite = htmlTestSuite;
 546        this.link = trElement.getElementsByTagName("a")[0];
 547        this.link.onclick = fnBindAsEventListener(this._onClick, this);
 548    },
 549
 550    reset: function() {
 551        this.setStatus(null);
 552    },
 553
 554    _onClick: function() {
 555        this.loadTestCase(null);
 556        return false;
 557    },
 558
 559    loadTestCase: function(onloadFunction) {
 560        this.htmlTestSuite.unselectCurrentRow();
 561        this.select();
 562        this.htmlTestSuite.currentRowInSuite = this.trElement.rowIndex - 1;
 563        // If the row has a stored results table, use that
 564        var resultsFromPreviousRun = this.trElement.cells[1];
 565        if (resultsFromPreviousRun) {
 566            // todo: delegate to TestFrame, e.g.
 567            //   this.testFrame.restoreTestCase(resultsFromPreviousRun.innerHTML);
 568            var testBody = this.testFrame.getDocument().body;
 569            testBody.innerHTML = resultsFromPreviousRun.innerHTML;
 570            this.testFrame._onLoad();
 571            if (onloadFunction) {
 572                onloadFunction();
 573            }
 574        } else {
 575            this.testFrame.load(this.link.href, onloadFunction);
 576        }
 577    },
 578
 579    saveTestResults: function() {
 580        // todo: GLOBAL ACCESS!
 581        var resultHTML = this.testFrame.getDocument().body.innerHTML;
 582        if (!resultHTML) return;
 583
 584        // todo: why create this div?
 585        var divElement = this.trElement.ownerDocument.createElement("div");
 586        divElement.innerHTML = resultHTML;
 587
 588        var hiddenCell = this.trElement.ownerDocument.createElement("td");
 589        hiddenCell.appendChild(divElement);
 590        hiddenCell.style.display = "none";
 591
 592        this.trElement.appendChild(hiddenCell);
 593    }
 594
 595});
 596
 597var HtmlTestSuite = classCreate();
 598objectExtend(HtmlTestSuite.prototype, {
 599
 600    initialize: function(suiteDocument) {
 601        this.suiteDocument = suiteDocument;
 602        this.suiteRows = this._collectSuiteRows();
 603        var testTable = this.getTestTable();
 604        if (!testTable) return;
 605        this.titleRow = new TitleRow(testTable.rows[0]);
 606        this.reset();
 607    },
 608
 609    reset: function() {
 610        this.failed = false;
 611        this.currentRowInSuite = -1;
 612        this.titleRow.setStatus(null);
 613        for (var i = 0; i < this.suiteRows.length; i++) {
 614            var row = this.suiteRows[i];
 615            row.reset();
 616        }
 617    },
 618
 619    getSuiteRows: function() {
 620        return this.suiteRows;
 621    },
 622
 623    getTestTable: function() {
 624        var tables = sel$A(this.suiteDocument.getElementsByTagName("table"));
 625        return tables[0];
 626    },
 627
 628    isAvailable: function() {
 629        return this.getTestTable() != null;
 630    },
 631
 632    _collectSuiteRows: function () {
 633        var result = [];
 634        var tables = sel$A(this.suiteDocument.getElementsByTagName("table"));
 635        var testTable = tables[0];
 636        if (!testTable) return;
 637        for (rowNum = 1; rowNum < testTable.rows.length; rowNum++) {
 638            var rowElement = testTable.rows[rowNum];
 639            result.push(new HtmlTestSuiteRow(rowElement, testFrame, this));
 640        }
 641        
 642        // process the unsuited rows as well
 643        for (var tableNum = 1; tableNum < sel$A(this.suiteDocument.getElementsByTagName("table")).length; tableNum++) {
 644            testTable = tables[tableNum];
 645            for (rowNum = 1; rowNum < testTable.rows.length; rowNum++) {
 646                var rowElement = testTable.rows[rowNum];
 647                new HtmlTestSuiteRow(rowElement, testFrame, this);
 648            }
 649        }
 650        return result;
 651    },
 652
 653    getCurrentRow: function() {
 654        if (this.currentRowInSuite == -1) {
 655            return null;
 656        }
 657        return this.suiteRows[this.currentRowInSuite];
 658    },
 659
 660    unselectCurrentRow: function() {
 661        var currentRow = this.getCurrentRow()
 662        if (currentRow) {
 663            currentRow.unselect();
 664        }
 665    },
 666
 667    markFailed: function() {
 668        this.failed = true;
 669        this.titleRow.markFailed();
 670    },
 671
 672    markDone: function() {
 673        if (!this.failed) {
 674            this.titleRow.markPassed();
 675        }
 676    },
 677
 678    _startCurrentTestCase: function() {
 679        this.getCurrentRow().loadTestCase(fnBind(htmlTestRunner.startTest, htmlTestRunner));
 680    },
 681
 682    _onTestSuiteComplete: function() {
 683        this.markDone();
 684        new SeleniumTestResult(this.failed, this.getTestTable()).post();
 685    },
 686
 687    updateSuiteWithResultOfPreviousTest: function() {
 688        if (this.currentRowInSuite >= 0) {
 689            this.getCurrentRow().saveTestResults();
 690        }
 691    },
 692
 693    runNextTestInSuite: function() {
 694        this.currentRowInSuite++;
 695
 696        // If we are done with all of the tests, set the title bar as pass or fail
 697        if (this.currentRowInSuite >= this.suiteRows.length) {
 698            this._onTestSuiteComplete();
 699        } else {
 700            this._startCurrentTestCase();
 701        }
 702    }
 703
 704
 705
 706});
 707
 708var SeleniumTestResult = classCreate();
 709objectExtend(SeleniumTestResult.prototype, {
 710
 711// Post the results to a servlet, CGI-script, etc.  The URL of the
 712// results-handler defaults to "/postResults", but an alternative location
 713// can be specified by providing a "resultsUrl" query parameter.
 714//
 715// Parameters passed to the results-handler are:
 716//      result:         passed/failed depending on whether the suite passed or failed
 717//      totalTime:      the total running time in seconds for the suite.
 718//
 719//      numTestPasses:  the total number of tests which passed.
 720//      numTestFailures: the total number of tests which failed.
 721//
 722//      numCommandPasses: the total number of commands which passed.
 723//      numCommandFailures: the total number of commands which failed.
 724//      numCommandErrors: the total number of commands which errored.
 725//
 726//      suite:      the suite table, including the hidden column of test results
 727//      testTable.1 to testTable.N: the individual test tables
 728//
 729    initialize: function (suiteFailed, suiteTable) {
 730        this.controlPanel = htmlTestRunner.controlPanel;
 731        this.metrics = htmlTestRunner.metrics;
 732        this.suiteFailed = suiteFailed;
 733        this.suiteTable = suiteTable;
 734    },
 735
 736    post: function () {
 737        if (!this.controlPanel.isAutomatedRun()) {
 738            return;
 739        }
 740        var form = document.createElement("form");
 741        document.body.appendChild(form);
 742
 743        form.id = "resultsForm";
 744        form.method = "post";
 745        form.target = "selenium_myiframe";
 746
 747        var resultsUrl = this.controlPanel.getResultsUrl();
 748        if (!resultsUrl) {
 749            resultsUrl = "./postResults";
 750        }
 751
 752        var actionAndParameters = resultsUrl.split('?', 2);
 753        form.action = actionAndParameters[0];
 754        var resultsUrlQueryString = actionAndParameters[1];
 755
 756        form.createHiddenField = function(name, value) {
 757            input = document.createElement("input");
 758            input.type = "hidden";
 759            input.name = name;
 760            input.value = value;
 761            this.appendChild(input);
 762        };
 763
 764        if (resultsUrlQueryString) {
 765            var clauses = resultsUrlQueryString.split('&');
 766            for (var i = 0; i < clauses.length; i++) {
 767                var keyValuePair = clauses[i].split('=', 2);
 768                var key = unescape(keyValuePair[0]);
 769                var value = unescape(keyValuePair[1]);
 770                form.createHiddenField(key, value);
 771            }
 772        }
 773
 774        form.createHiddenField("selenium.version", Selenium.version);
 775        form.createHiddenField("selenium.revision", Selenium.revision);
 776
 777        form.createHiddenField("result", this.suiteFailed ? "failed" : "passed");
 778
 779        form.createHiddenField("totalTime", Math.floor((this.metrics.currentTime - this.metrics.startTime) / 1000));
 780        form.createHiddenField("numTestPasses", this.metrics.numTestPasses);
 781        form.createHiddenField("numTestFailures", this.metrics.numTestFailures);
 782        form.createHiddenField("numCommandPasses", this.metrics.numCommandPasses);
 783        form.createHiddenField("numCommandFailures", this.metrics.numCommandFailures);
 784        form.createHiddenField("numCommandErrors", this.metrics.numCommandErrors);
 785
 786        // Create an input for each test table.  The inputs are named
 787        // testTable.1, testTable.2, etc.
 788        for (rowNum = 1; rowNum < this.suiteTable.rows.length; rowNum++) {
 789            // If there is a second column, then add a new input
 790            if (this.suiteTable.rows[rowNum].cells.length > 1) {
 791                var resultCell = this.suiteTable.rows[rowNum].cells[1];
 792                form.createHiddenField("testTable." + rowNum, resultCell.innerHTML);
 793                // remove the resultCell, so it's not included in the suite HTML
 794                resultCell.parentNode.removeChild(resultCell);
 795            }
 796        }
 797
 798        form.createHiddenField("numTestTotal", rowNum-1);
 799
 800        // Add HTML for the suite itself
 801        form.createHiddenField("suite", this.suiteTable.parentNode.innerHTML);
 802
 803        var logMessages = [];
 804        while (LOG.pendingMessages.length > 0) {
 805            var msg = LOG.pendingMessages.shift();
 806            logMessages.push(msg.type);
 807            logMessages.push(": ");
 808            logMessages.push(msg.msg);
 809            logMessages.push('\n');
 810        }
 811        var logOutput = logMessages.join("");
 812        form.createHiddenField("log", logOutput);
 813
 814        if (this.controlPanel.shouldSaveResultsToFile()) {
 815            this._saveToFile(resultsUrl, form);
 816        } else {
 817            form.submit();
 818        }
 819        document.body.removeChild(form);
 820        if (this.controlPanel.closeAfterTests()) {
 821            window.top.close();
 822        }
 823    },
 824
 825    _saveToFile: function (fileName, form) {
 826        // This only works when run as an IE HTA
 827        var inputs = new Object();
 828        for (var i = 0; i < form.elements.length; i++) {
 829            inputs[form.elements[i].name] = form.elements[i].value;
 830        }
 831        
 832        var objFSO = new ActiveXObject("Scripting.FileSystemObject")
 833        
 834        // DGF get CSS
 835        var styles = "";
 836        try {
 837            var styleSheetPath = window.location.pathname.replace(/[^\/\\]+$/, "selenium-test.css");
 838            if (window.location.protocol == "file:") {
 839                var stylesFile = objFSO.OpenTextFile(styleSheetPath, 1);
 840                styles = stylesFile.ReadAll();
 841            } else {
 842                var xhr = XmlHttp.create();
 843                xhr.open("GET", styleSheetPath, false);
 844                xhr.send("");
 845                styles = xhr.responseText;
 846            }
 847        } catch (e) {}
 848        
 849        var scriptFile = objFSO.CreateTextFile(fileName);
 850        
 851        
 852        scriptFile.WriteLine("<html><head><title>Test suite results</title><style>");
 853        scriptFile.WriteLine(styles);
 854        scriptFile.WriteLine("</style>");
 855        scriptFile.WriteLine("<body>\n<h1>Test suite results</h1>" +
 856             "\n\n<table>\n<tr>\n<td>result:</td>\n<td>" + inputs["result"] + "</td>\n" +
 857             "</tr>\n<tr>\n<td>totalTime:</td>\n<td>" + inputs["totalTime"] + "</td>\n</tr>\n" +
 858             "<tr>\n<td>numTestTotal:</td>\n<td>" + inputs["numTestTotal"] + "</td>\n</tr>\n" +
 859             "<tr>\n<td>numTestPasses:</td>\n<td>" + inputs["numTestPasses"] + "</td>\n</tr>\n" +
 860             "<tr>\n<td>numTestFailures:</td>\n<td>" + inputs["numTestFailures"] + "</td>\n</tr>\n" +
 861             "<tr>\n<td>numCommandPasses:</td>\n<td>" + inputs["numCommandPasses"] + "</td>\n</tr>\n" +
 862             "<tr>\n<td>numCommandFailures:</td>\n<td>" + inputs["numCommandFailures"] + "</td>\n</tr>\n" +
 863             "<tr>\n<td>numCommandErrors:</td>\n<td>" + inputs["numCommandErrors"] + "</td>\n</tr>\n" +
 864             "<tr>\n<td>" + inputs["suite"] + "</td>\n<td>&nbsp;</td>\n</tr></table><table>");
 865        var testNum = inputs["numTestTotal"];
 866        
 867        for (var rowNum = 1; rowNum <= testNum; rowNum++) {
 868            scriptFile.WriteLine("<tr>\n<td>" + inputs["testTable." + rowNum] + "</td>\n<td>&nbsp;</td>\n</tr>");
 869        }
 870        scriptFile.WriteLine("</table><pre>");
 871        var log = inputs["log"];
 872        log=log.replace(/&/gm,"&amp;").replace(/</gm,"&lt;").replace(/>/gm,"&gt;").replace(/"/gm,"&quot;").replace(/'/gm,"&apos;");
 873        scriptFile.WriteLine(log);
 874        scriptFile.WriteLine("</pre></body></html>");
 875        scriptFile.Close();
 876    }
 877});
 878
 879/** HtmlTestCase encapsulates an HTML test document */
 880var HtmlTestCase = classCreate();
 881objectExtend(HtmlTestCase.prototype, {
 882
 883    initialize: function(testWindow, htmlTestSuiteRow) {
 884        if (testWindow == null) {
 885            throw "testWindow should not be null";
 886        }
 887        if (htmlTestSuiteRow == null) {
 888            throw "htmlTestSuiteRow should not be null";
 889        }
 890        this.testWindow = testWindow;
 891        this.testDocument = testWindow.document;
 892        this.pathname = "'unknown'";
 893        try {
 894            if (this.testWindow.location) {
 895                this.pathname = this.testWindow.location.pathname;
 896            }
 897        } catch (e) {}
 898            
 899        this.htmlTestSuiteRow = htmlTestSuiteRow;
 900        this.headerRow = new TitleRow(this.testDocument.getElementsByTagName("tr")[0]);
 901        this.commandRows = this._collectCommandRows();
 902        this.nextCommandRowIndex = 0;
 903        this._addBreakpointSupport();
 904    },
 905
 906    _collectCommandRows: function () {
 907        var commandRows = [];
 908        var tables = sel$A(this.testDocument.getElementsByTagName("table"));
 909        var self = this;
 910        for (var i = 0; i < tables.length; i++) {
 911            var table = tables[i];
 912            var tableRows = sel$A(table.rows);
 913            for (var j = 0; j < tableRows.length; j++) {
 914                var candidateRow = tableRows[j];
 915                if (self.isCommandRow(candidateRow)) {
 916                    commandRows.push(new HtmlTestCaseRow(candidateRow));
 917                }
 918            }
 919        }
 920        return commandRows;
 921    },
 922
 923    isCommandRow:  function (row) {
 924        return row.cells.length >= 3;
 925    },
 926
 927    reset: function() {
 928        /**
 929         * reset the test to runnable state
 930         */
 931        this.nextCommandRowIndex = 0;
 932
 933        this.setStatus('');
 934        for (var i = 0; i < this.commandRows.length; i++) {
 935            var row = this.commandRows[i];
 936            row.reset();
 937        }
 938
 939        // remove any additional fake "error" row added to the end of the document
 940        var errorElement = this.testDocument.getElementById('error');
 941        if (errorElement) {
 942            errorElement.parentNode.removeChild(errorElement);
 943        }
 944    },
 945
 946    getCommandRows: function () {
 947        return this.commandRows;
 948    },
 949
 950    setStatus: function(status) {
 951        this.headerRow.setStatus(status);
 952    },
 953
 954    markFailed: function() {
 955        this.setStatus("failed");
 956        this.htmlTestSuiteRow.markFailed();
 957    },
 958
 959    markPassed: function() {
 960        this.setStatus("passed");
 961        this.htmlTestSuiteRow.markPassed();
 962    },
 963
 964    addErrorMessage: function(errorMsg, currentRow) {
 965        errorMsg = errorMsg.replace(/ /g, String.fromCharCode(160)).replace("\n", '\\n');
 966        if (currentRow) {
 967            currentRow.markFailed(errorMsg);
 968        } else {
 969            var errorElement = this.testDocument.createElement("p");
 970            errorElement.id = "error";
 971            setText(errorElement, errorMsg);
 972            this.testDocument.body.appendChild(errorElement);
 973            errorElement.className = "status_failed";
 974        }
 975    },
 976
 977    _addBreakpointSupport: function() {
 978        for (var i = 0; i < this.commandRows.length; i++) {
 979            var row = this.commandRows[i];
 980            row.addBreakpointSupport();
 981        }
 982    },
 983
 984    hasMoreCommandRows: function() {
 985        return this.nextCommandRowIndex < this.commandRows.length;
 986    },
 987
 988    getNextCommandRow: function() {
 989        if (this.hasMoreCommandRows()) {
 990            return this.commandRows[this.nextCommandRowIndex++];
 991        }
 992        return null;
 993    }
 994
 995});
 996
 997
 998// TODO: split out an JavascriptTestCase class to handle the "sejs" stuff
 999
1000var get_new_rows = function() {
1001    var row_array = new Array();
1002    for (var i = 0; i < new_block.length; i++) {
1003
1004        var new_source = (new_block[i][0].tokenizer.source.slice(new_block[i][0].start,
1005                new_block[i][0].end));
1006
1007        var row = '<td style="display:none;" class="js">getEval</td>' +
1008                  '<td style="display:none;">currentTest.doNextCommand()</td>' +
1009                  '<td style="white-space: pre;">' + new_source + '</td>' +
1010                  '<td></td>'
1011
1012        row_array.push(row);
1013    }
1014    return row_array;
1015};
1016
1017
1018var Metrics = classCreate();
1019objectExtend(Metrics.prototype, {
1020    initialize: function() {
1021        // The number of tests run
1022        this.numTestPasses = 0;
1023        // The number of tests that have failed
1024        this.numTestFailures = 0;
1025        // The number of commands which have passed
1026        this.numCommandPasses = 0;
1027        // The number of commands which have failed
1028        this.numCommandFailures = 0;
1029        // The number of commands which have caused errors (element not found)
1030        this.numCommandErrors = 0;
1031        // The time that the test was started.
1032        this.startTime = null;
1033        // The current time.
1034        this.currentTime = null;
1035    },
1036
1037    printMetrics: function() {
1038        setText(sel$('commandPasses'), this.numCommandPasses);
1039        setText(sel$('commandFailures'), this.numCommandFailures);
1040        setText(sel$('commandErrors'), this.numCommandErrors);
1041        setText(sel$('testRuns'), this.numTestPasses + this.numTestFailures);
1042        setText(sel$('testFailures'), this.numTestFailures);
1043
1044        this.currentTime = new Date().getTime();
1045
1046        var timeDiff = this.currentTime - this.startTime;
1047        var totalSecs = Math.floor(timeDiff / 1000);
1048
1049        var minutes = Math.floor(totalSecs / 60);
1050        var seconds = totalSecs % 60;
1051
1052        setText(sel$('elapsedTime'), this._pad(minutes) + ":" + this._pad(seconds));
1053    },
1054
1055// Puts a leading 0 on num if it is less than 10
1056    _pad: function(num) {
1057        return (num > 9) ? num : "0" + num;
1058    },
1059
1060    resetMetrics: function() {
1061        this.numTestPasses = 0;
1062        this.numTestFailures = 0;
1063        this.numCommandPasses = 0;
1064        this.numCommandFailures = 0;
1065        this.numCommandErrors = 0;
1066        this.startTime = new Date().getTime();
1067    }
1068
1069});
1070
1071var HtmlRunnerCommandFactory = classCreate();
1072objectExtend(HtmlRunnerCommandFactory.prototype, {
1073
1074    initialize: function(seleniumCommandFactory, testLoop) {
1075        this.seleniumCommandFactory = seleniumCommandFactory;
1076        this.testLoop = testLoop;
1077        this.handlers = {};
1078        //todo: register commands
1079    },
1080
1081    getCommandHandler: function(command) {
1082        if (this.handlers[command]) {
1083            return this.handlers[command];
1084        }
1085        return this.seleniumCommandFactory.getCommandHandler(command);
1086    }
1087
1088});
1089
1090var HtmlRunnerTestLoop = classCreate();
1091objectExtend(HtmlRunnerTestLoop.prototype, new TestLoop());
1092objectExtend(HtmlRunnerTestLoop.prototype, {
1093    initialize: function(htmlTestCase, metrics, seleniumCommandFactory) {
1094
1095        this.commandFactory = new HtmlRunnerCommandFactory(seleniumCommandFactory, this);
1096        this.metrics = metrics;
1097
1098        this.htmlTestCase = htmlTestCase;
1099        LOG.info("Starting test " + htmlTestCase.pathname);
1100
1101        this.currentRow = null;
1102        this.currentRowIndex = 0;
1103
1104        // used for selenium tests in javascript
1105        this.currentItem = null;
1106        this.commandAgenda = new Array();
1107        this.expectedFailure = null;
1108        this.expectedFailureType = null;
1109
1110        this.htmlTestCase.reset();
1111    },
1112
1113    _advanceToNextRow: function() {
1114        if (this.htmlTestCase.hasMoreCommandRows()) {
1115            this.currentRow = this.htmlTestCase.getNextCommandRow();
1116            if (this.sejsElement) {
1117                this.currentItem = agenda.pop();
1118                this.currentRowIndex++;
1119            }
1120        } else {
1121            this.currentRow = null;
1122            this.currentItem = null;
1123        }
1124    },
1125
1126    nextCommand : function() {
1127        this._advanceToNextRow();
1128        if (this.currentRow == null) {
1129            return null;
1130        }
1131        return this.currentRow.getCommand();
1132    },
1133
1134    commandStarted : function() {
1135        sel$('pauseTest').disabled = false;
1136        this.currentRow.select();
1137        this.metrics.printMetrics();
1138    },
1139
1140    commandComplete : function(result) {
1141        this._checkExpectedFailure(result);
1142        if (result.failed) {
1143            this.metrics.numCommandFailures += 1;
1144            this._recordFailure(result.failureMessage);
1145        } else if (result.passed) {
1146            this.metrics.numCommandPasses += 1;
1147            this.currentRow.markPassed();
1148        } else {
1149            this.currentRow.markDone();
1150        }
1151    },
1152
1153    _checkExpectedFailure : function(result) {
1154        if (this.expectedFailure != null) {
1155            if (this.expectedFailureJustSet) {
1156                this.expectedFailureJustSet = false;
1157                return;
1158            }
1159            if (!result.failed) {
1160                result.passed = false;
1161                result.failed = true;
1162                result.failureMessage = "Expected " + this.expectedFailureType + " did not occur.";
1163            } else {
1164                if (PatternMatcher.matches(this.expectedFailure, result.failureMessage)) {
1165                    var failureType = result.error ? "error" : "failure";
1166                    if (failureType == this.expectedFailureType) {
1167                        result.failed = false;
1168                        result.passed = true;
1169                    } else {
1170                        result.failed = true;
1171                        result.failureMessage = "Expected "+this.expectedFailureType+", but "+failureType+" occurred instead";
1172                    }
1173                } else {
1174                    result.failed = true;
1175                    result.failureMessage = "Expected " + this.expectedFailureType + " message '" + this.expectedFailure
1176                                            + "' but was '" + result.failureMessage + "'";
1177                }
1178            }
1179            this.expectedFailure = null;
1180            this.expectedFailureType = null;
1181        }
1182    },
1183
1184    commandError : function(errorMessage) {
1185        var tempResult = {};
1186        tempResult.passed = false;
1187        tempResult.failed = true;
1188        tempResult.error = true;
1189        tempResult.failureMessage = errorMessage;
1190        this._checkExpectedFailure(tempResult);
1191        if (tempResult.passed) {
1192            this.currentRow.markDone();
1193            return true;
1194        }
1195        errorMessage = tempResult.failureMessage;
1196        this.metrics.numCommandErrors += 1;
1197        this._recordFailure(errorMessage);
1198    },
1199
1200    _recordFailure : function(errorMsg) {
1201        LOG.warn("currentTest.recordFailure: " + errorMsg);
1202        htmlTestRunner.markFailed();
1203        this.htmlTestCase.addErrorMessage(errorMsg, this.currentRow);
1204    },
1205
1206    testComplete : function() {
1207        sel$('pauseTest').disabled = true;
1208        sel$('stepTest').disabled = true;
1209        if (htmlTestRunner.testFailed) {
1210            this.htmlTestCase.markFailed();
1211            this.metrics.numTestFailures += 1;
1212        } else {
1213            this.htmlTestCase.markPassed();
1214            this.metrics.numTestPasses += 1;
1215        }
1216
1217        this.metrics.printMetrics();
1218
1219        window.setTimeout(function() {
1220            htmlTestRunner.runNextTest();
1221        }, 1);
1222    },
1223
1224    getCommandInterval : function() {
1225        return htmlTestRunner.controlPanel.runInterval;
1226    },
1227
1228    pause : function() {
1229        htmlTestRunner.controlPanel.pauseCurrentTest();
1230    },
1231
1232    doNextCommand: function() {
1233        var _n = this.currentItem[0];
1234        var _x = this.currentItem[1];
1235
1236        new_block = new Array()
1237        execute(_n, _x);
1238        if (new_block.length > 0) {
1239            var the_table = this.htmlTestCase.testDocument.getElementById("se-js-table")
1240            var loc = this.currentRowIndex
1241            var new_rows = get_new_rows()
1242
1243            // make the new statements visible on screen...
1244            for (var i = 0; i < new_rows.length; i++) {
1245                the_table.insertRow(loc + 1);
1246                the_table.rows[loc + 1].innerHTML = new_rows[i];
1247                this.commandRows.unshift(the_table.rows[loc + 1])
1248            }
1249
1250        }
1251    }
1252
1253});
1254
1255Selenium.prototype.doPause = function(waitTime) {
1256    /** Wait for the specified amount of time (in milliseconds)
1257     * @param waitTime the amount of time to sleep (in milliseconds)
1258     */
1259    // todo: should not refer to currentTest directly
1260    currentTest.pauseInterval = waitTime;
1261};
1262
1263Selenium.prototype.doBreak = function() {
1264    /** Halt the currently running test, and wait for the user to press the Continue button.
1265     * This command is useful for debugging, but be careful when using it, because it will
1266     * force automated tests to hang until a user intervenes manually.
1267     */
1268    // todo: should not refer to controlPanel directly
1269    htmlTestRunner.controlPanel.setToPauseAtNextCommand();
1270};
1271
1272Selenium.prototype.doStore = function(expression, variableName) {
1273    /** This command is a synonym for storeExpression.
1274     * @param expression the value to store
1275     * @param variableName the name of a <a href="#storedVars">variable</a> in which the result is to be stored.
1276     */
1277    storedVars[variableName] = expression;
1278}
1279
1280/*
1281 * Click on the located element, and attach a callback to notify
1282 * when the page is reloaded.
1283 */
1284// DGF TODO this code has been broken for some time... what is it trying to accomplish?
1285Selenium.prototype.XXXdoModalDialogTest = function(returnValue) {
1286    this.browserbot.doModalDialogTest(returnValue);
1287};
1288
1289Selenium.prototype.doEcho = function(message) {
1290    /** Prints the specified message into the third table cell in your Selenese tables.
1291     * Useful for debugging.
1292     * @param message the message to print
1293     */
1294    currentTest.currentRow.setMessage(message);
1295}
1296
1297/*
1298 * doSetSpeed and getSpeed are already defined in selenium-api.js,
1299 * so we're defining these functions in a tricky way so that doc.js doesn't
1300 * try to read API doc from the function definitions here.
1301 */
1302Selenium.prototype._doSetSpeed = function(value) {
1303    var milliseconds = parseInt(value);
1304    if (milliseconds < 0) milliseconds = 0;
1305    htmlTestRunner.controlPanel.speedController.setValue(milliseconds);
1306    htmlTestRunner.controlPanel.setRunInterval(milliseconds);
1307}
1308Selenium.prototype.doSetSpeed = Selenium.prototype._doSetSpeed;
1309
1310Selenium.prototype._getSpeed = function() {
1311    return htmlTestRunner.controlPanel.runInterval;
1312}
1313Selenium.prototype.getSpeed = Selenium.prototype._getSpeed;
1314
1315Selenium.prototype.assertSelected = function(selectLocator, optionLocator) {
1316    /**
1317     * Verifies that the selected option of a drop-down satisfies the optionSpecifier.  <i>Note that this command is deprecated; you should use assertSelectedLabel, assertSelectedValue, assertSelectedIndex, or assertSelectedId instead.</i>
1318     *
1319     * <p>See the select command for more information about option locators.</p>
1320     *
1321     * @param selectLocator an <a href="#locators">element locator</a> identifying a drop-down menu
1322     * @param optionLocator an option locator, typically just an option label (e.g. "John Smith")
1323     */
1324    var element = this.page().findElement(selectLocator);
1325    var locator = this.optionLocatorFactory.fromLocatorString(optionLocator);
1326    if (element.selectedIndex == -1)
1327    {
1328        Assert.fail("No option selected");
1329    }
1330    locator.assertSelected(element);
1331};
1332
1333Selenium.prototype.assertFailureOnNext = function(message) {
1334    /**
1335     * Tell Selenium to expect a failure on the next command execution. 
1336     * @param message The failure message we should expect.  This command will fail if the wrong failure message appears.
1337     */
1338    if (!message) {
1339        throw new SeleniumError("Message must be provided");
1340    }
1341
1342    currentTest.expectedFailure = message;
1343    currentTest.expectedFailureType = "failure";
1344    currentTest.expectedFailureJustSet = true;
1345};
1346
1347Selenium.prototype.assertErrorOnNext = function(message) {
1348    /**
1349     * Tell Selenium to expect an error on the next command execution. 
1350     * @param message The error message we should expect.  This command will fail if the wrong error message appears.
1351     */
1352     // This command temporarily installs a CommandFactory that generates
1353     // CommandHandlers that expect an error.
1354    if (!message) {
1355        throw new SeleniumError("Message must be provided");
1356    }
1357
1358    currentTest.expectedFailure = message;
1359    currentTest.expectedFailureType = "error";
1360    currentTest.expectedFailureJustSet = true;
1361};
1362