seleniumrc 0.0.1 → 0.0.2

data/spec/seleniumrc/selenium_driver_spec.rb

@@ -0,0 +1,104 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+module Seleniumrc
+  describe SeleniumDriver, :shared => true do
+    it_should_behave_like "Selenium"
+    attr_reader :driver, :commands
+    before do
+      @driver = ::Seleniumrc::SeleniumDriver.new("localhost", 4444, "*iexplore", "localhost:3000")
+    end
+
+    def sample_locator
+      "sample_locator"
+    end
+
+    def sample_text
+      "test text"
+    end
+  end
+
+  describe SeleniumDriver, "#initialize" do
+    it_should_behave_like "Seleniumrc::SeleniumDriver"
+    
+    it "initializes with defaults" do
+      driver.server_host.should == "localhost"
+      driver.server_port.should == 4444
+      driver.browser_start_command.should == "*iexplore"
+      driver.browser_url.should == "localhost:3000"
+      driver.timeout_in_milliseconds.should == 30000
+    end
+
+    it "should start" do
+      mock(driver).do_command.
+        with("getNewBrowserSession", ["*iexplore", "localhost:3000"]).returns("   12345")
+
+      driver.start
+      driver.instance_variable_get(:@session_id).should == "12345"
+    end
+  end
+
+  describe SeleniumDriver, "#inner_html_js" do
+    it_should_behave_like "Seleniumrc::SeleniumDriver"
+
+    it "returns findElement command in js" do
+      driver.inner_html_js(sample_locator).should ==
+        %Q|this.page().findElement("#{sample_locator}").innerHTML|
+    end
+  end
+
+  describe SeleniumDriver, "#wait_for_element_to_contain" do
+    it_should_behave_like "Seleniumrc::SeleniumDriver"
+
+    it "when finding text within time limit, passes" do
+      is_element_present_results = [false, true]
+      mock(driver).do_command('isElementPresent', [sample_locator]).times(2) do
+        result(is_element_present_results.shift)
+      end
+      mock(driver).do_command('getEval', [driver.inner_html_js(sample_locator)]) do
+        result(sample_text)
+      end
+
+      driver.wait_for_element_to_contain(sample_locator, sample_text)
+    end
+
+    it "when element not found in time, fails" do
+      mock(driver).do_command('isElementPresent', [sample_locator]).times(4) do
+        result(false)
+      end
+
+      proc do
+        driver.wait_for_element_to_contain(sample_locator, "")
+      end.should raise_error(Test::Unit::AssertionFailedError, "Timeout exceeded (after 5 sec)")
+    end
+
+    it "when text does not match in time, fails" do
+      is_element_present_results = [false, true, true, true]
+      stub(driver).do_command('isElementPresent', [sample_locator]) do
+        result(is_element_present_results.shift)
+      end
+      stub(driver).do_command('getEval', [driver.inner_html_js(sample_locator)]) do
+        result(sample_text)
+      end
+
+      proc do
+        driver.wait_for_element_to_contain(sample_locator, "wrong text", nil, 1)
+      end.should raise_error(Test::Unit::AssertionFailedError, "Timeout exceeded (after 1 sec)")
+    end
+  end
+
+  describe SeleniumDriver, "#open and #open_and_wait" do
+    it_should_behave_like "Seleniumrc::SeleniumDriver"
+
+    it "opens page and waits for it to load" do
+      mock(driver).do_command("open", ["http://localhost:4000"])
+      mock(driver).do_command("waitForPageToLoad", [driver.default_timeout]) {result}
+      mock(driver).do_command("getTitle", []) {result("Some Title")}
+
+      driver.open("http://localhost:4000")
+    end
+
+    it "aliases #open_and_wait to #open" do
+      driver.method(:open_and_wait).should == driver.method(:open)
+    end
+  end  
+end

data/spec/seleniumrc/selenium_element_spec.rb

@@ -2,12 +2,14 @@ require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
 
 module Seleniumrc
 describe SeleniumElement, :shared => true do
+  it_should_behave_like "Selenium"
   include SeleniumTestCaseSpec
-  
+  attr_reader :driver
+
   before do
-    @selenium = "Selenium"
+    @driver = ::Seleniumrc::SeleniumDriver.new('http://test.host', 4000, "*firefox", 'http://test.host')
     @element_locator ||= "id=foobar"
-    @element = SeleniumElement.new(@selenium, @element_locator)
+    @element = SeleniumElement.new(driver, @element_locator)
   end
 end
 
@@ -19,7 +21,7 @@ describe SeleniumElement, "#initialize" do
   end
 
   it "sets the selenium object" do
-    @element.selenium.should == @selenium
+    @element.driver.should == driver
   end
 end
 
@@ -28,14 +30,14 @@ describe SeleniumElement, "#is_present" do
 
   it "passes when element is present" do
     ticks = [false, false, false, true]
-    mock(@selenium).is_element_present(@element_locator) do
-      ticks.shift
-    end.times(4)
+    mock(driver).do_command("isElementPresent", [@element_locator]).times(4) do
+      result ticks.shift
+    end
     @element.is_present
   end
   
   it "fails when element is not present" do
-    stub(@selenium).is_element_present(@element_locator) {false}
+    stub(driver).is_element_present(@element_locator) {false}
     proc do
       @element.is_present
     end.should raise_error("Expected element 'id=foobar' to be present, but it was not (after 5 sec)")
@@ -46,12 +48,12 @@ describe SeleniumElement, "#is_present?" do
   it_should_behave_like "Seleniumrc::SeleniumElement"
 
   it "returns true when element is present" do
-    mock(@selenium).is_element_present(@element_locator) {true}
+    mock(driver).is_element_present(@element_locator) {true}
     @element.is_present?.should be_true
   end
 
   it "returns false when element is not present" do
-    mock(@selenium).is_element_present(@element_locator) {false}
+    mock(driver).is_element_present(@element_locator) {false}
     @element.is_present?.should be_false
   end
 end
@@ -61,14 +63,14 @@ describe SeleniumElement, "#is_not_present" do
 
   it "passes when element is not present" do
     ticks = [true, true, true, false]
-    mock(@selenium).is_element_present(@element_locator) do
+    mock(driver).is_element_present(@element_locator) do
       ticks.shift
     end.times(4)
     @element.is_not_present
   end
 
   it "fails when element is present" do
-    stub(@selenium).is_element_present(@element_locator) {true}
+    stub(driver).is_element_present(@element_locator) {true}
     proc do
       @element.is_not_present
     end.should raise_error("Expected element 'id=foobar' to be absent, but it was not (after 5 sec)")
@@ -79,12 +81,12 @@ describe SeleniumElement, "#is_not_present?" do
   it_should_behave_like "Seleniumrc::SeleniumElement"
 
   it "returns true when element is not present" do
-    mock(@selenium).is_element_present(@element_locator) {false}
+    mock(driver).is_element_present(@element_locator) {false}
     @element.is_not_present?.should be_true
   end
 
   it "returns false when element is present" do
-    mock(@selenium).is_element_present(@element_locator) {true}
+    mock(driver).is_element_present(@element_locator) {true}
     @element.is_not_present?.should be_false
   end
 end
@@ -94,26 +96,26 @@ describe SeleniumElement, "#has_value" do
 
   it "passes when element is present and value is expected value" do
     element_ticks = [false, false, false, true]
-    mock(@selenium).is_element_present(@element_locator) do
+    mock(driver).is_element_present(@element_locator) do
       element_ticks.shift
     end.times(4)
     value_ticks = [nil, nil, nil, "joe"]
-    mock(@selenium).get_value(@element_locator) do
+    mock(driver).get_value(@element_locator) do
       value_ticks.shift
     end.times(4)
     @element.has_value("joe")
   end
 
   it "fails when element is present and not expected value" do
-    mock(@selenium).is_element_present(@element_locator) {true}
-    stub(@selenium).get_value(@element_locator) {"jane"}
+    mock(driver).is_element_present(@element_locator) {true}
+    stub(driver).get_value(@element_locator) {"jane"}
     proc do
       @element.has_value("joe")
     end.should raise_error
   end
 
   it "fails when element is not present" do
-    stub(@selenium).is_element_present(@element_locator) {false}
+    stub(driver).is_element_present(@element_locator) {false}
     proc do
       @element.has_value("joe")
     end.should raise_error
@@ -124,12 +126,12 @@ describe SeleniumElement, "#has_value?" do
   it_should_behave_like "Seleniumrc::SeleniumElement"
 
   it "returns true when value is expected value" do
-    mock(@selenium).get_value(@element_locator) {"joe"}
+    mock(driver).get_value(@element_locator) {"joe"}
     @element.has_value?("joe").should be_true
   end
 
   it "returns false when value is not expected value" do
-    stub(@selenium).get_value(@element_locator) {"jane"}
+    stub(driver).get_value(@element_locator) {"jane"}
     @element.has_value?("joe").should be_false
   end
 end
@@ -143,26 +145,26 @@ describe SeleniumElement, "#has_attribute" do
 
   it "passes when element is present and value is expected value" do
     element_ticks = [false, false, false, true]
-    mock(@selenium).is_element_present(@element_locator) do
+    mock(driver).is_element_present(@element_locator) do
       element_ticks.shift
     end.times(4)
     label_ticks = ["jane", "jane", "jane", "joe"]
-    mock(@selenium).get_attribute(@element_locator) do
+    mock(driver).get_attribute(@element_locator) do
       label_ticks.shift
     end.times(4)
     @element.has_attribute("joe")
   end
 
   it "fails when element is present and value is not expected" do
-    stub(@selenium).is_element_present(@element_locator) {true}
-    stub(@selenium).get_attribute(@element_locator) {"jane"}
+    stub(driver).is_element_present(@element_locator) {true}
+    stub(driver).get_attribute(@element_locator) {"jane"}
     proc do
       @element.has_attribute("joe")
     end.should raise_error
   end
 
   it "fails when element is not present" do
-    stub(@selenium).is_element_present(@element_locator) {false}
+    stub(driver).is_element_present(@element_locator) {false}
     proc do
       @element.has_attribute("joe")
     end.should raise_error
@@ -178,26 +180,26 @@ describe SeleniumElement, "#has_selected" do
 
   it "passes when element is present and value is expected value" do
     element_ticks = [false, false, false, true]
-    mock(@selenium).is_element_present(@element_locator) do
+    mock(driver).is_element_present(@element_locator) do
       element_ticks.shift
     end.times(4)
     label_ticks = ["jane", "jane", "jane", "joe"]
-    mock(@selenium).get_selected_label(@element_locator) do
+    mock(driver).get_selected_label(@element_locator) do
       label_ticks.shift
     end.times(4)
     @element.has_selected("joe")
   end
 
   it "fails when element is present and value is not expected" do
-    stub(@selenium).is_element_present(@element_locator) {true}
-    stub(@selenium).get_selected_label(@element_locator) {"jane"}
+    stub(driver).is_element_present(@element_locator) {true}
+    stub(driver).get_selected_label(@element_locator) {"jane"}
     proc do
       @element.has_selected("joe")
     end.should raise_error
   end
 
   it "fails when element is not present" do
-    stub(@selenium).is_element_present(@element_locator) {false}
+    stub(driver).is_element_present(@element_locator) {false}
     proc do
       @element.has_selected("joe")
     end.should raise_error
@@ -213,26 +215,26 @@ describe SeleniumElement, "#is_visible" do
 
   it "passes when element exists and is visible" do
     element_ticks = [false, false, false, true]
-    mock(@selenium).is_element_present(@element_locator) do
+    mock(driver).is_element_present(@element_locator) do
       element_ticks.shift
     end.times(4)
     visible_ticks = [false, false, false, true]
-    mock(@selenium).is_visible(@element_locator) do
+    mock(driver).is_visible(@element_locator) do
       visible_ticks.shift
     end.times(4)
     @element.is_visible
   end
 
   it "fails when element is present and is not visible" do
-    stub(@selenium).is_element_present(@element_locator) {true}
-    stub(@selenium).is_visible(@element_locator) {false}
+    stub(driver).is_element_present(@element_locator) {true}
+    stub(driver).is_visible(@element_locator) {false}
     proc do
       @element.is_visible
     end.should raise_error
   end
 
   it "fails when element is not present" do
-    stub(@selenium).is_element_present(@element_locator) {false}
+    stub(driver).is_element_present(@element_locator) {false}
     proc do
       @element.is_visible
     end.should raise_error
@@ -248,26 +250,26 @@ describe SeleniumElement, "#is_not_visible" do
 
   it "passes when element exists and is not visible" do
     element_ticks = [false, false, false, true]
-    mock(@selenium).is_element_present(@element_locator) do
+    mock(driver).is_element_present(@element_locator) do
       element_ticks.shift
     end.times(4)
     visible_ticks = [true, true, true, false]
-    mock(@selenium).is_visible(@element_locator) do
+    mock(driver).is_visible(@element_locator) do
       visible_ticks.shift
     end.times(4)
     @element.is_not_visible
   end
 
   it "fails when element is present and is visible" do
-    stub(@selenium).is_element_present(@element_locator) {true}
-    stub(@selenium).is__visible(@element_locator) {true}
+    stub(driver).is_element_present(@element_locator) {true}
+    stub(driver).is__visible(@element_locator) {true}
     proc do
       @element.is_not_visible
     end.should raise_error
   end
 
   it "fails when element is not present" do
-    stub(@selenium).is_element_present(@element_locator) {false}
+    stub(driver).is_element_present(@element_locator) {false}
     proc do
       @element.is_visible
     end.should raise_error
@@ -283,26 +285,26 @@ describe SeleniumElement, "#is_checked" do
 
   it "passes when element is present and value is expected value" do
     element_ticks = [false, false, false, true]
-    mock(@selenium).is_element_present(@element_locator) do
+    mock(driver).is_element_present(@element_locator) do
       element_ticks.shift
     end.times(4)
     checked_ticks = [false, false, false, true]
-    mock(@selenium).is_checked(@element_locator) do
+    mock(driver).is_checked(@element_locator) do
       checked_ticks.shift
     end.times(4)
     @element.is_checked
   end
 
   it "fails when element is present and value is not expected" do
-    stub(@selenium).is_element_present(@element_locator) {true}
-    stub(@selenium).is_checked(@element_locator) {false}
+    stub(driver).is_element_present(@element_locator) {true}
+    stub(driver).is_checked(@element_locator) {false}
     proc do
       @element.is_checked
     end.should raise_error
   end
 
   it "fails when element is not present" do
-    stub(@selenium).is_element_present(@element_locator) {false}
+    stub(driver).is_element_present(@element_locator) {false}
     proc do
       @element.is_checked
     end.should raise_error
@@ -318,26 +320,26 @@ describe SeleniumElement, "#is_not_checked" do
 
   it "passes when element is present and value is expected value" do
     element_ticks = [false, false, false, true]
-    mock(@selenium).is_element_present(@element_locator) do
+    mock(driver).is_element_present(@element_locator) do
       element_ticks.shift
     end.times(4)
     checked_ticks = [true, true, true, false]
-    mock(@selenium).is_checked(@element_locator) do
+    mock(driver).is_checked(@element_locator) do
       checked_ticks.shift
     end.times(4)
     @element.is_not_checked
   end
 
   it "fails when element is present and value is not expected" do
-    stub(@selenium).is_element_present(@element_locator) {true}
-    stub(@selenium).is_checked(@element_locator) {true}
+    stub(driver).is_element_present(@element_locator) {true}
+    stub(driver).is_checked(@element_locator) {true}
     proc do
       @element.is_not_checked
     end.should raise_error
   end
 
   it "fails when element is not present" do
-    stub(@selenium).is_element_present(@element_locator) {false}
+    stub(driver).is_element_present(@element_locator) {false}
     proc do
       @element.is_not_checked
     end.should raise_error
@@ -353,26 +355,26 @@ describe SeleniumElement, "#has_text" do
 
   it "passes when element is present and value is expected value" do
     element_ticks = [false, false, false, true]
-    mock(@selenium).is_element_present(@element_locator) do
+    mock(driver).is_element_present(@element_locator) do
       element_ticks.shift
     end.times(4)
     checked_ticks = ["no match", "no match", "no match", "match"]
-    mock(@selenium).get_text(@element_locator) do
+    mock(driver).get_text(@element_locator) do
       checked_ticks.shift
     end.times(4)
     @element.has_text("match")
   end
 
   it "fails when element is present and value is not expected" do
-    stub(@selenium).is_element_present(@element_locator) {true}
-    stub(@selenium).get_text(@element_locator) {"no match"}
+    stub(driver).is_element_present(@element_locator) {true}
+    stub(driver).get_text(@element_locator) {"no match"}
     proc do
       @element.has_text "match"
     end.should raise_error
   end
 
   it "fails when element is not present" do
-    stub(@selenium).is_element_present(@element_locator) {false}
+    stub(driver).is_element_present(@element_locator) {false}
     proc do
       @element.has_text "match"
     end.should raise_error
@@ -389,26 +391,26 @@ describe SeleniumElement, "#contains_text" do
 
   it "passes when element is present and the element contains text" do
     element_ticks = [false, false, false, true]
-    mock(@selenium).is_element_present(@element_locator) do
+    mock(driver).is_element_present(@element_locator) do
       element_ticks.shift
     end.times(4)
     inner_html_ticks = ["html", "html", "html", "html match html"]
-    mock(@selenium).get_eval(@evaled_js) do
+    mock(driver).get_eval(@evaled_js) do
       inner_html_ticks.shift
     end.times(4)
     @element.contains_text("match")
   end
 
   it "fails when element is present and the element does not contain text" do
-    stub(@selenium).is_element_present(@element_locator) {true}
-    stub(@selenium).get_eval(@evaled_js) {"html"}
+    stub(driver).is_element_present(@element_locator) {true}
+    stub(driver).get_eval(@evaled_js) {"html"}
     proc do
       @element.contains_text "match"
     end.should raise_error
   end
 
   it "fails when element is not present" do
-    stub(@selenium).is_element_present(@element_locator) {false}
+    stub(driver).is_element_present(@element_locator) {false}
     proc do
       @element.contains_text "match"
     end.should raise_error
@@ -425,26 +427,26 @@ describe SeleniumElement, "#does_not_contain_text" do
 
   it "passes when element is present and the element does not contain text" do
     element_ticks = [false, false, false, true]
-    mock(@selenium).is_element_present(@element_locator) do
+    mock(driver).is_element_present(@element_locator) do
       element_ticks.shift
     end.times(4)
     inner_html_ticks = ["html match html", "html match html", "html match html", "html"]
-    mock(@selenium).get_eval(@evaled_js) do
+    mock(driver).get_eval(@evaled_js) do
       inner_html_ticks.shift
     end.times(4)
     @element.does_not_contain_text("match")
   end
 
   it "fails when element is present and the element contains text" do
-    stub(@selenium).is_element_present(@element_locator) {true}
-    stub(@selenium).get_eval(@evaled_js) {"html match html"}
+    stub(driver).is_element_present(@element_locator) {true}
+    stub(driver).get_eval(@evaled_js) {"html match html"}
     proc do
       @element.does_not_contain_text "match"
     end.should raise_error
   end
 
   it "fails when element is not present" do
-    stub(@selenium).is_element_present(@element_locator) {false}
+    stub(driver).is_element_present(@element_locator) {false}
     proc do
       @element.does_not_contain_text "match"
     end.should raise_error
@@ -461,26 +463,26 @@ describe SeleniumElement, "#has_next_sibling" do
 
   it "passes when element is present and value is expected value" do
     element_ticks = [false, false, false, true]
-    mock(@selenium).is_element_present(@element_locator) do
+    mock(driver).is_element_present(@element_locator) do
       element_ticks.shift
     end.times(4)
     inner_html_ticks = ["", "", "", "next_element"]
-    mock(@selenium).get_eval(@evaled_js) do
+    mock(driver).get_eval(@evaled_js) do
       inner_html_ticks.shift
     end.times(4)
     @element.has_next_sibling("next_element")
   end
 
   it "fails when element is present and value is not expected" do
-    stub(@selenium).is_element_present(@element_locator) {true}
-    stub(@selenium).get_eval(@evaled_js) {""}
+    stub(driver).is_element_present(@element_locator) {true}
+    stub(driver).get_eval(@evaled_js) {""}
     proc do
       @element.has_next_sibling "next_element"
     end.should raise_error
   end
 
   it "fails when element is not present" do
-    stub(@selenium).is_element_present(@element_locator) {false}
+    stub(driver).is_element_present(@element_locator) {false}
     proc do
       @element.has_next_sibling "match"
     end.should raise_error
@@ -497,7 +499,7 @@ describe SeleniumElement, "#has_text_in_order" do
 
   it "passes when element is present and value is expected value" do
     element_ticks = [false, false, false, true]
-    mock(@selenium).is_element_present(@element_locator) do
+    mock(driver).is_element_present(@element_locator) do
       element_ticks.shift
     end.times(4)
     get_text_ticks = [
@@ -506,22 +508,22 @@ describe SeleniumElement, "#has_text_in_order" do
       "no match",
       "one\ntwo\nthree",
     ]
-    mock(@selenium).get_text(@element_locator) do
+    mock(driver).get_text(@element_locator) do
       get_text_ticks.shift
     end.times(4)
     @element.has_text_in_order('one', 'two', 'three')
   end
 
   it "fails when element is present and value is not expected" do
-    stub(@selenium).is_element_present(@element_locator) {true}
-    stub(@selenium).get_text(@element_locator) {"no match"}
+    stub(driver).is_element_present(@element_locator) {true}
+    stub(driver).get_text(@element_locator) {"no match"}
     proc do
       @element.has_text_in_order 'one', 'two', 'three'
     end.should raise_error
   end
 
   it "fails when element is not present" do
-    stub(@selenium).is_element_present(@element_locator) {false}
+    stub(driver).is_element_present(@element_locator) {false}
     proc do
       @element.has_text_in_order 'one', 'two', 'three'
     end.should raise_error