RubyGems - rubinium - Versions diffs - 0.1.1 - Mend

rubinium 0.1.1

Files changed (161) hide show

data/vendor/selenium-0.6.0/selenium/tests/browserbot/command-handler-tests.html ADDED

@@ -0,0 +1,115 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+"http://www.w3.org/TR/html4/loose.dtd">
+<!--
+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.
+-->
+<html>
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+    <title>Test for the CommandHandler</title>
+    <link rel="stylesheet" type="text/css" href="jsunit/css/jsUnitStyle.css">
+<script language="JavaScript" type="text/javascript" src="/jsunit/app/jsUnitCore.js"></script>
+<script language="JavaScript" type="text/javascript" src="/jsmock/mock.js"></script>
+<script language="JavaScript" type="text/javascript" src="/selenium-commandhandlers.js"></script>
+<script language="JavaScript" type="text/javascript" src="/htmlutils.js"></script>
+<script language="JavaScript" type="text/javascript">
+function testCommandHandlerExecuteCallsTheExecutorFunction() {
+    var called = false;
+    var executor = function() { called = true;};
+    var handler = new CommandHandler("name", false, executor);
+    handler.execute("selenium", "command");
+    assertTrue(called);
+}
+function testShouldFailActionCommandsIfAlertPresent() {
+     mockBrowserBot = new Mock();
+     function MockSelenium() {
+        this.browserbot = mockBrowserBot;
+     }
+     mockBrowserBot.expects("hasAlerts").returns(true);
+     mockBrowserBot.expects("getNextAlert").returns("The Alert");
+     var executorCalled = false;
+     var executor = function() { executorCalled = true;};
+     var handler = new ActionHandler(executor, false);
+     try {
+        handler.execute(new MockSelenium(), "command");
+        fail("Command Should have failed");
+     } catch ( e ) {
+        assertTrue(e.isSeleniumError);
+        assertEquals("There was an unexpected Alert! [The Alert]", e.message);
+     }
+     assertFalse(executorCalled);
+     mockBrowserBot.verify();
+}
+function testShouldFailActionCommandsIfConfirmPresent() {
+     mockBrowserBot = new Mock();
+     function MockSelenium() {
+        this.browserbot = mockBrowserBot;
+     }
+     mockBrowserBot.expects("hasAlerts").returns(false);
+     mockBrowserBot.expects("hasConfirmations").returns(true);
+     mockBrowserBot.expects("getNextConfirmation").returns("The Confirmation");
+     var executorCalled = false;
+     var executor = function() { executorCalled = true;};
+     var handler = new ActionHandler(executor, false);
+     try {
+        handler.execute(new MockSelenium(), "command");
+        fail("Command Should have failed");
+     } catch ( e ) {
+        assertTrue(e.isSeleniumError);
+        assertEquals("There was an unexpected Confirmation! [The Confirmation]", e.message);
+     }
+     assertFalse(executorCalled);
+     mockBrowserBot.verify();
+}
+function testAccessorHandlerShouldReturnResultInCommandResult() {
+        function MockSelenium() {
+     }
+        var executorCalled = false;
+        var executor = function() { executorCalled = true; return "foo"; };
+        var handler = new AccessorHandler(executor, false);
+        result = handler.execute(new MockSelenium(), "command");
+        assertTrue(executorCalled);
+        assertEquals("foo", result.result);
+}
+</script>
+  </head>
+  <body>
+    <h1>CommandHandler component tests</h1>
+    <p>This page contains tests for different components in the CommandHandler. To see them, take a look at the source. To run them, load this file via JsUnit's testRunner.html</p>
+  </body>
+</html>

data/vendor/selenium-0.6.0/selenium/tests/browserbot/confirm-handling-tests.html ADDED

@@ -0,0 +1,97 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+"http://www.w3.org/TR/html4/loose.dtd">
+<!--
+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.
+-->
+<html>
+  <head>
+	<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+    <title>JsUnit Utility Tests</title>
+    <link rel="stylesheet" type="text/css" href="/jsunit/css/jsUnitStyle.css">
+<script language="JavaScript" type="text/javascript" src="/jsunit/app/jsUnitCore.js"></script>
+<script language="JavaScript" type="text/javascript" src="/jsmock/mock.js"></script>
+<script language="JavaScript" type="text/javascript" src="/selenium-logging.js"></script>
+<script language="JavaScript" type="text/javascript" src="/selenium-browserbot.js"></script>
+<script language="JavaScript" type="text/javascript" src="/htmlutils.js"></script>
+<script language="JavaScript" type="text/javascript">
+function setUp() {
+   LOG = new DummyLogger();
+   testFrame =  document.getElementById("frame");
+   testWindow = testFrame.contentWindow;
+   browserBot = BrowserBot.createForFrame(testFrame);
+   browserBot.getCurrentPage();
+}
+function testShouldConfirmConfirmationsByDefault() {
+    assertTrue( testWindow.confirm("Continue?"));
+}
+function testShouldCancelConfirmationIfPreviouslyInstructedTo() {
+   browserBot.cancelNextConfirmation();
+   assertFalse( testWindow.confirm("Continue?"));
+}
+function testShouldRevertToDefaultBehaviourAfterCancellingConfirmation() {
+   browserBot.cancelNextConfirmation();
+   testWindow.confirm("Continue?");
+   testShouldConfirmConfirmationsByDefault();
+}
+function testShouldNotReportAnyConfirmationsIfNoneHaveBeenGenerated() {
+    assertFalse(browserBot.hasConfirmations());
+    assertUndefined(browserBot.getNextConfirmation());
+}
+function testShouldReportSingleConfirmationIfGenerated() {
+    testWindow.confirm("Continue?");
+    assertTrue(browserBot.hasConfirmations());
+    assertEquals("Continue?", browserBot.getNextConfirmation());
+}
+function testShouldReportMultipleConfirmationsInOrderIfGenerated() {
+    testWindow.confirm("Continue?");
+    testWindow.confirm("Really Continue?");
+    assertTrue(browserBot.hasConfirmations());
+    assertEquals("Continue?", browserBot.getNextConfirmation());
+    assertTrue(browserBot.hasConfirmations());
+    assertEquals("Really Continue?", browserBot.getNextConfirmation());
+    assertFalse(browserBot.hasConfirmations());
+}
+function testShouldRemoveConfirmationWhenItIsRetreived() {
+    testWindow.confirm("Continue?");
+    assertTrue(browserBot.hasConfirmations());
+    assertNotUndefined(browserBot.getNextConfirmation());
+    assertFalse(browserBot.hasConfirmations());
+    assertUndefined(browserBot.getNextConfirmation());
+}
+</script>
+  </head>
+  <body>
+    <h1>Selenium PageBot Confirm Handling Tests</h1>
+    <iframe NAME="frame" ID="frame" SRC=""></iframe>
+  </body>
+</html>

data/vendor/selenium-0.6.0/selenium/tests/browserbot/error-checking-command-tests.html ADDED

@@ -0,0 +1,198 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+"http://www.w3.org/TR/html4/loose.dtd">
+<!--
+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.
+-->
+<html>
+  <head>
+	<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+    <title>JsUnit Utility Tests</title>
+    <link rel="stylesheet" type="text/css" href="jsunit/css/jsUnitStyle.css">
+<script language="JavaScript" type="text/javascript" src="/jsunit/app/jsUnitCore.js"></script>
+<script language="JavaScript" type="text/javascript" src="/jsmock/mock.js"></script>
+<script language="JavaScript" type="text/javascript" src="/htmlutils.js"></script>
+<script language="JavaScript" type="text/javascript" src="/selenium-api.js"></script>
+<script language="JavaScript" type="text/javascript" src="/selenium-executionloop.js"></script>
+<script language="JavaScript" type="text/javascript" src="/selenium-commandhandlers.js"></script>
+<script language="JavaScript" type="text/javascript">
+    function setUp() {
+        commandFactory = new Mock();
+        testLoop = new TestLoop(commandFactory);
+        selenium = new Selenium();
+    };
+    function verifyMocks() {
+        commandFactory.verify();
+    }
+    function testMustProvideMessageToExpectFailure() {
+        try {
+            selenium.assertFailureOnNext();
+        }
+        catch (expected) {
+            return;
+        }
+        fail("Message is a required parameter");
+    };
+    function testCommandFactoryIsTemporarilyReplacedByExpectFailureOnNext() {
+        var failingCommand = new Mock();
+        failingCommand.expects("execute").returns({failed:true, failureMessage: "Expected failure message"});
+        commandFactory.expects("getCommandHandler", "cmd").returns(failingCommand);
+        selenium.assertFailureOnNext("Expected failure message");
+        assertTrue(commandFactory != testLoop.commandFactory);
+        testLoop.commandFactory.getCommandHandler("cmd").execute();
+        assertTrue(commandFactory === testLoop.commandFactory);
+        verifyMocks();
+    };
+    function testExpectFailureSucceedsWhenSubsequentCommandFails() {
+        var failingCommand = new Mock();
+        failingCommand.expects("execute").returns({failed:true, failureMessage: "Expected failure message"});
+        commandFactory.expects("getCommandHandler", "cmd").returns(failingCommand);
+        selenium.assertFailureOnNext("Expected failure message");
+        var result = testLoop.commandFactory.getCommandHandler("cmd").execute();
+        assertTrue(result.passed);
+        verifyMocks();
+    };
+    function testExpectFailureFailsWhenSubsequentCommandFailsWithTheWrongMessage() {
+        var failingCommand = new Mock();
+        failingCommand.expects("execute").returns({failed:true, failureMessage: "foo"});
+        var originalCommandFactory = testLoop.commandFactory;
+        originalCommandFactory.expects("getCommandHandler", "cmd").returns(failingCommand);
+        selenium.assertFailureOnNext("bar");
+        var result = testLoop.commandFactory.getCommandHandler("cmd").execute();
+        assertTrue(result.failed);
+        assertEquals("Expected failure message 'bar' but was 'foo'", result.failureMessage);
+        verifyMocks();
+    };
+    function testExpectFailureFailsWhenSubsequentCommandPasses() {
+        var successCommand = new Mock();
+        successCommand.expects("execute").returns({passed:true});
+        var originalCommandFactory = testLoop.commandFactory;
+        originalCommandFactory.expects("getCommandHandler", "foo").returns(successCommand);
+        selenium.assertFailureOnNext("Expected failure message");
+        var result = testLoop.commandFactory.getCommandHandler("foo").execute();
+        assertTrue(result.failed);
+        assertEquals("Command should have failed.", result.failureMessage);
+        verifyMocks();
+    };
+    function testExpectFailurePropogatesCommandErrors() {
+        var errorCommand = new Mock();
+        errorCommand.expects("execute").andThrows("error message");
+        commandFactory.expects("getCommandHandler", "foo").returns(errorCommand);
+        selenium.assertFailureOnNext("Expected failure message");
+        try {
+            testLoop.commandFactory.getCommandHandler("foo").execute();
+        }
+        catch (expected) {
+            verifyMocks();
+            return;
+        }
+        fail("Command error should not be caught by expect failure.");
+    };
+    function testMustProvideMessageToExpectError() {
+        try {
+            selenium.assertErrorOnNext();
+        }
+        catch (expected) {
+            return;
+        }
+        fail("Message is a required parameter");
+    };
+    function testCommandFactoryIsTemporarilyReplacedByExpectErrorOnNext() {
+        var errorCommand = new Mock();
+        errorCommand.expects("execute").andThrows("error message");
+        commandFactory.expects("getCommandHandler", "cmd").returns(errorCommand);
+        selenium.assertErrorOnNext("Error: error message");
+        assertTrue(commandFactory != testLoop.commandFactory);
+        testLoop.commandFactory.getCommandHandler("cmd").execute();
+        assertTrue(commandFactory === testLoop.commandFactory);
+        verifyMocks();
+    };
+    function testExpectErrorSucceedsWhenSubsequentCommandErrors() {
+        var errorCommand = new Mock();
+        errorCommand.expects("execute").andThrows("error message");
+        commandFactory.expects("getCommandHandler", "cmd").returns(errorCommand);
+        selenium.assertErrorOnNext("error message");
+        var result = testLoop.commandFactory.getCommandHandler("cmd").execute();
+        assertTrue(result.passed);
+        verifyMocks();
+    };
+    function testExpectErrorFailsWhenSubsequentCommandErrorsWithTheWrongMessage() {
+        var errorCommand = new Mock();
+        errorCommand.expects("execute").andThrows("Error: foo");
+        commandFactory.expects("getCommandHandler", "cmd").returns(errorCommand);
+        selenium.assertErrorOnNext("Error: bar");
+        var result = testLoop.commandFactory.getCommandHandler("cmd").execute();
+        assertTrue(result.failed);
+        assertEquals("Expected failure message 'Error: bar' but was 'Error: foo'", result.failureMessage);
+        verifyMocks();
+    };
+     function testExpectErrorFailsWhenSubsequentCommandPasses() {
+        var successCommand = new Mock();
+        successCommand.expects("execute").returns({passed:true});
+        commandFactory.expects("getCommandHandler", "foo").returns(successCommand);
+        selenium.assertErrorOnNext("Expected failure message");
+        var result = testLoop.commandFactory.getCommandHandler("foo").execute();
+        assertTrue(result.failed);
+        assertEquals("Command should have failed.", result.failureMessage);
+        verifyMocks();
+    };
+    function testExpectErrorFailsWhenSubsequentCommandFails() {
+        var failingCommand = new Mock();
+        failingCommand.expects("execute").returns({failed:true, failureMessage: "Expected failure message"});
+        commandFactory.expects("getCommandHandler", "cmd").returns(failingCommand);
+        selenium.assertErrorOnNext("Expected failure message");
+        var result = testLoop.commandFactory.getCommandHandler("cmd").execute();
+        assertTrue(result.failed);
+        assertEquals("Command should have failed.", result.failureMessage);
+        verifyMocks();
+    };
+  </script>
+  </head>
+  <body>
+    <p>This page contains tests for the ExpectFailureCommandFactory object. To see them, take a look at the source. To run them, load this file via JsUnit's testRunner.html</p>
+  </body>
+</html>

data/vendor/selenium-0.6.0/selenium/tests/browserbot/event-bubble-tests.html ADDED

@@ -0,0 +1,106 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+"http://www.w3.org/TR/html4/loose.dtd">
+<!--
+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.
+-->
+<html>
+  <head>
+	<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+    <title>JsUnit Utility Tests</title>
+    <link rel="stylesheet" type="text/css" href="/jsunit/css/jsUnitStyle.css">
+<script language="JavaScript" type="text/javascript" src="/jsunit/app/jsUnitCore.js"></script>
+<script language="JavaScript" type="text/javascript" src="/jsmock/mock.js"></script>
+<script language="JavaScript" type="text/javascript" src="/selenium-browserbot.js"></script>
+<script language="JavaScript" type="text/javascript" src="/htmlutils.js"></script>
+<script language="JavaScript" type="text/javascript">
+function setUp() {
+    pageBot = PageBot.createForWindow(window);
+    theForm = document.getElementById("theFormElement");
+    theTextbox = document.getElementById("theTextboxElement");
+}
+function testFocusEventNeverBubbles() {
+    var textboxFocus = false;
+    var formFocus = false;
+    theTextbox.onfocus = function() {textboxFocus = true};
+    theForm.onfocus = function() {formFocus = true};
+    pageBot.replaceText(theTextbox, 'foo1');
+    assertTrue(textboxFocus);
+    assertFalse(formFocus);
+}
+function testSelectEventCanBubbleInFirefoxButNotInIE() {
+    assertTrue(true);
+    var textboxSelect = false;
+    var formSelect = false;
+    theTextbox.onselect = function() {textboxSelect = true};
+    theForm.onselect = function() {formSelect = true};
+    pageBot.replaceText(theTextbox, 'foo1');
+    assertTrue(textboxSelect);
+    if (isIE) {
+        assertFalse(formSelect);
+    } else {
+        assertTrue(formSelect);
+    }
+}
+function testChangeEventCanBubbleInFirefoxButNotInIE() {
+    var textboxChange = false;
+    var formChange = false;
+    theTextbox.onchange = function() {textboxChange = true};
+    theForm.onchange = function() {formChange = true};
+    pageBot.replaceText(theTextbox, 'foo2');
+    assertTrue(textboxChange);
+    if (isIE) {
+        assertFalse(formChange);
+    } else {
+        assertTrue(formChange);
+    }
+}
+function testClickEventAlwaysBubbles() {
+    var buttonClick = false;
+    var formClick = false;
+    var theButton = document.getElementById("theButtonElement")
+    theButton.onclick = function() {buttonClick = true};
+    theForm.onclick = function() {formClick = true};
+    pageBot.clickElement(theButton);
+    assertTrue(buttonClick);
+    assertTrue(formClick);
+}
+</script>
+  </head>
+  <body>
+    <h1>Selenium Browserbot Tests</h1>
+    <form id="theFormElement" name="theFormElement">
+      <input name="theTextboxElement" id="theTextboxElement" type="text" value="theTextbox"/>
+      <input name="theButtonElement" id="theButtonElement" type="button" value="theButton"/>
+    </form>
+  </body>
+</html>