seleniumrc 0.0.1 → 0.0.2

data/spec/seleniumrc/selenium_page_spec.rb

@@ -2,20 +2,22 @@ require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
 
 module Seleniumrc
 describe SeleniumPage, :shared => true do
+  it_should_behave_like "Selenium"
   include SeleniumTestCaseSpec
+  attr_reader :driver
   
   before do
-    @selenium = "Selenium"
-    @page = SeleniumPage.new(@selenium)
+    @driver = ::Seleniumrc::SeleniumDriver.new('http://test.host', 4000, "*firefox", 'http://test.host')
+    @page = SeleniumPage.new(driver)
     page_loaded
   end
 
   def page_loaded
-    stub(@selenium).get_eval(SeleniumPage::PAGE_LOADED_COMMAND) {"true"}
+    stub(driver).get_eval(SeleniumPage::PAGE_LOADED_COMMAND) {"true"}
   end
 
   def page_not_loaded
-    stub(@selenium).get_eval(SeleniumPage::PAGE_LOADED_COMMAND) {"false"}
+    stub(driver).get_eval(SeleniumPage::PAGE_LOADED_COMMAND) {"false"}
   end
 end
 
@@ -23,7 +25,7 @@ describe SeleniumPage, "#initialize" do
   it_should_behave_like "Seleniumrc::SeleniumPage"
   
   it "sets the selenium object" do
-    @page.selenium.should == @selenium
+    @page.driver.should == driver
   end
 end
 
@@ -31,19 +33,27 @@ describe SeleniumPage, "#open_and_wait" do
   it_should_behave_like "Seleniumrc::SeleniumPage"
 
   it "opens the url and waits for the page to load" do
-    mock(@selenium) do |o|
-      o.open("/users/list")
-      o.wait_for_page_to_load(@page.default_timeout)
-      o.get_title {"Users in the project"}
+    mock(driver) do |m|
+      m.do_command("open", ["/users/list"]) {result}
+      m.do_command("waitForPageToLoad", [@page.default_timeout]) do
+        result
+      end
+      m.do_command("getTitle", []) do
+        result("Users in the project")
+      end
     end
     @page.open_and_wait("/users/list")
   end
 
   it "fails when titles contains Exception caught" do
-    mock(@selenium) do |o|
-      o.open("/users/list")
-      o.wait_for_page_to_load(@page.default_timeout)
-      o.get_title {"Exception caught"}
+    mock(driver) do |m|
+      m.do_command("open", ["/users/list"]) {result}
+      m.do_command("waitForPageToLoad", [@page.default_timeout]) do
+        result
+      end
+      m.do_command("getTitle", []) do
+        result("Exception caught")
+      end
     end
     proc do
       @page.open_and_wait("/users/list")
@@ -56,14 +66,14 @@ describe SeleniumPage, "#has_title" do
 
   it "passes when title is expected" do
     ticks = ["no page", "no page", "no page", "my page"]
-    mock(@selenium).get_title do
+    mock(driver).get_title do
       ticks.shift
     end.times(4)
     @page.has_title("my page")
   end
 
   it "fails when element is not present" do
-    stub(@selenium).get_title {"no page"}
+    stub(driver).get_title {"no page"}
     proc do
       @page.has_title("my page")
     end.should raise_error("Expected title 'my page' but was 'no page' (after 5 sec)")
@@ -74,12 +84,12 @@ describe SeleniumPage, "#has_title?" do
   it_should_behave_like "Seleniumrc::SeleniumPage"
 
   it "returns true when passed in title is the page title" do
-    mock(@selenium).get_title {"my page"}
+    mock(driver).get_title {"my page"}
     @page.has_title?("my page").should be_true
   end
 
   it "returns false when passed in title is not the page title" do
-    mock(@selenium).get_title {"no page"}
+    mock(driver).get_title {"no page"}
     @page.has_title?("my page").should be_false
   end
 end
@@ -89,7 +99,7 @@ describe SeleniumPage, "#is_text_present" do
 
   it "passes when title is expected" do
     ticks = [false, false, false, true]
-    mock(@selenium).is_text_present("my page") do
+    mock(driver).is_text_present("my page") do
       ticks.shift
     end.times(4)
     @page.is_text_present("my page")
@@ -103,7 +113,7 @@ describe SeleniumPage, "#is_text_present" do
   end
 
   it "fails when element is not present" do
-    stub(@selenium).is_text_present("my page") {false}
+    stub(driver).is_text_present("my page") {false}
     proc do
       @page.is_text_present("my page")
     end.should raise_error("Expected 'my page' to be present, but it wasn't (after 5 sec)")
@@ -114,12 +124,12 @@ describe SeleniumPage, "#is_text_present?" do
   it_should_behave_like "Seleniumrc::SeleniumPage"
 
   it "returns true when title is expected" do
-    mock(@selenium).is_text_present("my page") {true}
+    mock(driver).is_text_present("my page") {true}
     @page.is_text_present?("my page").should be_true
   end
 
   it "fails when element is not present" do
-    mock(@selenium).is_text_present("my page") {false}
+    mock(driver).is_text_present("my page") {false}
     @page.is_text_present?("my page").should be_false
   end
 end
@@ -129,7 +139,7 @@ describe SeleniumPage, "#is_text_not_present" do
 
   it "passes when text is not present" do
     ticks = [true, true, true, false]
-    mock(@selenium).is_text_present("my page") do
+    mock(driver).is_text_present("my page") do
       ticks.shift
     end.times(4)
     @page.is_text_not_present("my page")
@@ -143,7 +153,7 @@ describe SeleniumPage, "#is_text_not_present" do
   end
 
   it "fails when text is present" do
-    stub(@selenium).is_text_present("my page") {true}
+    stub(driver).is_text_present("my page") {true}
     proc do
       @page.is_text_not_present("my page")
     end.should raise_error("Expected 'my page' to be absent, but it wasn't (after 5 sec)")
@@ -154,12 +164,12 @@ describe SeleniumPage, "#is_text_not_present?" do
   it_should_behave_like "Seleniumrc::SeleniumPage"
 
   it "returns true when text is not present" do
-    mock(@selenium).is_text_present("my page") {false}
+    mock(driver).is_text_present("my page") {false}
     @page.is_text_not_present?("my page").should be_true
   end
 
   it "returns false when text is present" do
-    mock(@selenium).is_text_present("my page") {true}
+    mock(driver).is_text_present("my page") {true}
     @page.is_text_not_present?("my page").should be_false
   end
 end
@@ -178,14 +188,14 @@ describe SeleniumPage, "#url_ends_with" do
       "http://no.com",
       "http://foobar.com?arg1=2"
     ]
-    mock(@selenium).get_location do
+    mock(driver).get_location do
       ticks.shift
     end.times(4)
     @page.url_ends_with(@ends_with)
   end
 
   it "fails when element is not present" do
-    stub(@selenium).get_location {"http://no.com"}
+    stub(driver).get_location {"http://no.com"}
     proc do
       @page.url_ends_with(@ends_with)
     end.should raise_error("Expected 'http://no.com' to end with '#{@ends_with}' (after 5 sec)")
@@ -200,12 +210,12 @@ describe SeleniumPage, "#url_ends_with?" do
   end
 
   it "passes when title is expected" do
-    mock(@selenium).get_location {"http://foobar.com?arg1=2"}
+    mock(driver).get_location {"http://foobar.com?arg1=2"}
     @page.url_ends_with?(@ends_with).should be_true
   end
 
   it "fails when element is not present" do
-    mock(@selenium).get_location {"http://no.com"}
+    mock(driver).get_location {"http://no.com"}
     @page.url_ends_with?(@ends_with).should be_false
   end
 end

data/spec/seleniumrc/selenium_test_case_spec.rb

@@ -1,908 +1,866 @@
 require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
 
 module Seleniumrc
-describe SeleniumTestCase, :shared => true do
-  include SeleniumTestCaseSpec
-
-  before(:each) do
-    stub_selenium_configuration
-    @test_case = SeleniumTestCaseSpec::MySeleniumTestCase.new
-    @base_selenium = "Base Selenium"
-    @test_case.base_selenium = @base_selenium
-    stub(@base_selenium).get_eval(SeleniumPage::PAGE_LOADED_COMMAND) {"true"}
-  end
-
-  def sample_locator
-    "sample_locator"
-  end
-
-  def sample_text
-    "test text"
-  end
-
-  def stub_selenium_configuration
-    @context = SeleniumContext.new
-    @context.external_app_server_host = "test.com"
-    @context.external_app_server_port = 80
-
-    stub(SeleniumConfiguration.instance).returns(@context)
-  end
-end
-
-describe SeleniumTestCase, "#setup" do
-  it_should_behave_like "Seleniumrc::SeleniumTestCase"
-
-  it "should not allow transactional fixtures" do
-    stub(@test_case.class).use_transactional_fixtures.returns true
-
-    expected_message = "Cannot use transactional fixtures if ActiveRecord concurrency is turned on (which is required for Selenium tests to work)."
-    proc {@test_case.setup}.should raise_error(RuntimeError, expected_message)
-  end
-end
-
-describe SeleniumTestCase, "#wait_for" do
-  it_should_behave_like "Seleniumrc::SeleniumTestCase"
-
-  it "should pass when the block returns true within time limit" do
-    @test_case.wait_for(:timeout => 2) do
-      true
+  describe SeleniumTestCase, :shared => true do
+    it_should_behave_like "Selenium"
+    include SeleniumTestCaseSpec
+    attr_reader :driver, :test_case, :configuration
+
+    before(:each) do
+      stub_selenium_configuration
+      @test_case = SeleniumTestCaseSpec::MySeleniumTestCase.new
+      @driver = ::Seleniumrc::SeleniumDriver.new('http://test.host', 4000, "*firefox", 'http://test.host')
+      test_case.selenium_driver = driver
+      stub(driver).do_command("getEval", [SeleniumPage::PAGE_LOADED_COMMAND]) do
+        result(true)
+      end
     end
-  end
 
-  it "should raise a AssertionFailedError when block times out" do
-    proc do
-      @test_case.wait_for(:timeout => 2) {false}
-    end.should raise_error(Test::Unit::AssertionFailedError, "Timeout exceeded (after 2 sec)")
-  end
-end
+    def sample_locator
+      "sample_locator"
+    end
 
-describe SeleniumTestCase, "#wait_for_element_to_contain" do
-  it_should_behave_like "Seleniumrc::SeleniumTestCase"
+    def sample_text
+      "test text"
+    end
 
-  it "should pass when finding text within time limit" do
-    is_element_present_results = [false, true]
+    def stub_selenium_configuration
+      @configuration = SeleniumConfiguration.new
+      configuration.external_app_server_host = "test.com"
+      configuration.external_app_server_port = 80
 
-    stub(base_selenium).is_element_present {is_element_present_results.shift}
-    stub(base_selenium).get_eval("this.page().findElement(\"#{sample_locator}\").innerHTML") do
-      sample_text
+      stub(SeleniumConfiguration.instance) {configuration}
     end
-
-    @test_case.wait_for_element_to_contain(sample_locator, sample_text)
   end
 
-  it "should fail when element not found in time" do
-    is_element_present_results = [false, false, false, false]
+  describe SeleniumTestCase, "#setup" do
+    it_should_behave_like "Seleniumrc::SeleniumTestCase"
 
-    stub(base_selenium).is_element_present {is_element_present_results.shift}
+    it "should not allow transactional fixtures" do
+      test_case.class.use_transactional_fixtures = true
 
-    proc do
-      @test_case.wait_for_element_to_contain(sample_locator, "")
-    end.should raise_error(Test::Unit::AssertionFailedError, "Timeout exceeded (after 5 sec)")
+      expected_message = "Cannot use transactional fixtures if ActiveRecord concurrency is turned on (which is required for Selenium tests to work)."
+      proc do
+        test_case.setup
+      end.should raise_error(RuntimeError, expected_message)
+    end
   end
 
-  it "should fail when text does not match in time" do
-    is_element_present_results = [false, true, true, true]
+  describe SeleniumTestCase, "#wait_for" do
+    it_should_behave_like "Seleniumrc::SeleniumTestCase"
 
-    stub(base_selenium).is_element_present {is_element_present_results.shift}
-    stub(base_selenium).get_eval.
-      with("this.page().findElement(\"#{sample_locator}\").innerHTML").
-      returns(sample_text)
+    it "should pass when the block returns true within time limit" do
+      test_case.wait_for(:timeout => 2) do
+        true
+      end
+    end
 
-    proc do
-      @test_case.wait_for_element_to_contain(sample_locator, "wrong text", nil, 1)
-    end.should raise_error(Test::Unit::AssertionFailedError, "Timeout exceeded (after 1 sec)")
+    it "should raise a AssertionFailedError when block times out" do
+      proc do
+        test_case.wait_for(:timeout => 2) {false}
+      end.should raise_error(Test::Unit::AssertionFailedError, "Timeout exceeded (after 2 sec)")
+    end
   end
-end
 
-describe SeleniumTestCase, "#default_timeout" do
-  it_should_behave_like "Seleniumrc::SeleniumTestCase"
+  describe SeleniumTestCase, "#default_timeout" do
+    it_should_behave_like "Seleniumrc::SeleniumTestCase"
 
-  it "default_timeout should be 20 seconds" do
-    @test_case.default_timeout.should == 20000
+    it "default_timeout should be 20 seconds" do
+      test_case.default_timeout.should == 20000
+    end
   end
-end
 
-describe SeleniumTestCase, "#open_home_page" do
-  it_should_behave_like "Seleniumrc::SeleniumTestCase"
+  describe SeleniumTestCase, "#open_home_page" do
+    it_should_behave_like "Seleniumrc::SeleniumTestCase"
 
-  it "opens home page" do
-    mock(base_selenium).open("http://localhost:4000")
-    mock(base_selenium).wait_for_page_to_load(@test_case.default_timeout)
-    stub(base_selenium).send {""}
-
-    @test_case.open_home_page
+    it "opens home page" do
+      mock(driver).open("http://localhost:4000")
+      test_case.open_home_page
+    end
   end
-end
 
-describe SeleniumTestCase, "#open_and_wait" do
-  it_should_behave_like "Seleniumrc::SeleniumTestCase"
+  describe SeleniumTestCase, "#assert_title" do
+    it_should_behave_like "Seleniumrc::SeleniumTestCase"
 
-  before do
-    mock.proxy(SeleniumPage).new(base_selenium) do |page|
-      mock.proxy(page).open_and_wait("/users/list")
-      page
+    it "when title is expected, passes" do
+      mock(driver).do_command("getTitle", []) {result("my page")}
+      test_case.assert_title("my page")
     end
-  end
 
-  it "opens the url and waits for the page to load" do
-    mock(base_selenium) do |o|
-      o.open("/users/list")
-      o.wait_for_page_to_load(@test_case.default_timeout)
-      o.get_title {"Users in the project"}
+    it "when title is not expected, fails" do
+      stub(driver).do_command("getTitle", []) {result("no page")}
+      proc do
+        test_case.assert_title("my page")
+      end.should raise_error(Test::Unit::AssertionFailedError)
     end
-    @test_case.open_and_wait("/users/list")
   end
-end
 
-describe SeleniumTestCase, "#assert_title" do
-  it_should_behave_like "Seleniumrc::SeleniumTestCase"
+  describe SeleniumTestCase, "#assert_text_present" do
+    it_should_behave_like "Seleniumrc::SeleniumTestCase"
 
-  before do
-    mock.proxy(SeleniumPage).new(base_selenium) do |page|
-      mock.proxy(page).has_title("my page", {})
-      page
+    before do
+      mock.proxy(SeleniumPage).new(driver) do |page|
+        mock.proxy(page).is_text_present("my page", {})
+        page
+      end
     end
-  end
 
-  it "passes when title is expected" do
-    mock(base_selenium).get_title {"my page"}
-    @test_case.assert_title("my page")
-  end
-
-  it "fails when title is not expected" do
-    stub(base_selenium).get_title {"no page"}
-    proc do
-      @test_case.assert_title("my page")
-    end.should raise_error(Test::Unit::AssertionFailedError)
-  end
-end
-
-describe SeleniumTestCase, "#assert_text_present" do
-  it_should_behave_like "Seleniumrc::SeleniumTestCase"
-
-  before do
-    mock.proxy(SeleniumPage).new(base_selenium) do |page|
-      mock.proxy(page).is_text_present("my page", {})
-      page
+    it "passes when text is in page" do
+      ticks = [false, false, false, true]
+      mock(driver).is_text_present("my page") do
+        ticks.shift
+      end.times(4)
+      test_case.assert_text_present("my page")
     end
-  end
 
-  it "passes when text is in page" do
-    ticks = [false, false, false, true]
-    mock(base_selenium).is_text_present("my page") do
-      ticks.shift
-    end.times(4)
-    @test_case.assert_text_present("my page")
-  end
-
-  it "fails when text is not in page" do
-    stub(base_selenium).is_text_present("my page") {false}
-    proc do
-      @test_case.assert_text_present("my page")
-    end.should raise_error(Test::Unit::AssertionFailedError)
+    it "fails when text is not in page" do
+      stub(driver).is_text_present("my page") {false}
+      proc do
+        test_case.assert_text_present("my page")
+      end.should raise_error(Test::Unit::AssertionFailedError)
+    end
   end
-end
 
-describe SeleniumTestCase, "#assert_text_not_present" do
-  it_should_behave_like "Seleniumrc::SeleniumTestCase"
+  describe SeleniumTestCase, "#assert_text_not_present" do
+    it_should_behave_like "Seleniumrc::SeleniumTestCase"
 
-  before do
-    mock.proxy(SeleniumPage).new(base_selenium) do |page|
-      mock.proxy(page).is_text_not_present("my page", {})
-      page
+    before do
+      mock.proxy(SeleniumPage).new(driver) do |page|
+        mock.proxy(page).is_text_not_present("my page", {})
+        page
+      end
     end
-  end
 
-  it "passes when text is not in page" do
-    ticks = [true, true, true, false]
-    mock(base_selenium).is_text_present("my page") do
-      ticks.shift
-    end.times(4)
-    @test_case.assert_text_not_present("my page")
-  end
+    it "passes when text is not in page" do
+      ticks = [true, true, true, false]
+      mock(driver).is_text_present("my page") do
+        ticks.shift
+      end.times(4)
+      test_case.assert_text_not_present("my page")
+    end
 
-  it "fails when text is in page" do
-    stub(base_selenium).is_text_present("my page") {true}
-    proc do
-      @test_case.assert_text_not_present("my page")
-    end.should raise_error(Test::Unit::AssertionFailedError)
+    it "fails when text is in page" do
+      stub(driver).is_text_present("my page") {true}
+      proc do
+        test_case.assert_text_not_present("my page")
+      end.should raise_error(Test::Unit::AssertionFailedError)
+    end
   end
-end
 
-describe SeleniumTestCase, "#assert_location_ends_in" do
-  it_should_behave_like "Seleniumrc::SeleniumTestCase"
+  describe SeleniumTestCase, "#assert_location_ends_in" do
+    it_should_behave_like "Seleniumrc::SeleniumTestCase"
 
-  before do
-    @ends_with = "foobar.com?arg1=2"
-    mock.proxy(SeleniumPage).new(base_selenium) do |page|
-      mock.proxy(page).url_ends_with(@ends_with, {})
-      page
+    before do
+      @ends_with = "foobar.com?arg1=2"
+      mock.proxy(SeleniumPage).new(driver) do |page|
+        mock.proxy(page).url_ends_with(@ends_with, {})
+        page
+      end
     end
-  end
 
-  it "passes when the url ends with the passed in value" do
-    ticks = [
-      "http://no.com",
-      "http://no.com",
-      "http://no.com",
-      "http://foobar.com?arg1=2"
-    ]
-    mock(base_selenium).get_location do
-      ticks.shift
-    end.times(4)
-    @test_case.assert_location_ends_in(@ends_with)
-  end
+    it "passes when the url ends with the passed in value" do
+      ticks = [
+        "http://no.com",
+          "http://no.com",
+          "http://no.com",
+          "http://foobar.com?arg1=2"
+      ]
+      mock(driver).get_location do
+        ticks.shift
+      end.times(4)
+      test_case.assert_location_ends_in(@ends_with)
+    end
 
-  it "fails when the url does not end with the passed in value" do
-    stub(base_selenium).get_location {"http://no.com"}
-    proc do
-      @test_case.assert_location_ends_in(@ends_with)
-    end.should raise_error(Test::Unit::AssertionFailedError)
+    it "fails when the url does not end with the passed in value" do
+      stub(driver).get_location {"http://no.com"}
+      proc do
+        test_case.assert_location_ends_in(@ends_with)
+      end.should raise_error(Test::Unit::AssertionFailedError)
+    end
   end
-end
 
-describe SeleniumTestCase, "#assert_element_present" do
-  it_should_behave_like "Seleniumrc::SeleniumTestCase"
+  describe SeleniumTestCase, "#assert_element_present" do
+    it_should_behave_like "Seleniumrc::SeleniumTestCase"
 
-  before do
-    mock.proxy(SeleniumElement).new(base_selenium, sample_locator) do |element|
-      mock.proxy(element).is_present({})
-      element
+    before do
+      mock.proxy(SeleniumElement).new(driver, sample_locator) do |element|
+        mock.proxy(element).is_present({})
+        element
+      end
     end
-  end
 
-  it "passes when element is present" do
-    ticks = [false, false, false, true]
-    mock(base_selenium) do |o|
-      o.is_element_present(sample_locator) do
-        ticks.shift
-      end.times(4)
+    it "passes when element is present" do
+      ticks = [false, false, false, true]
+      mock(driver).do_command("isElementPresent", [sample_locator]).times(4) do
+        result(ticks.shift)
+      end
+      test_case.assert_element_present(sample_locator)
     end
-    @test_case.assert_element_present(sample_locator)
-  end
 
-  it "fails when element is not present" do
-    stub(base_selenium) do |o|
-      o.is_element_present(sample_locator) {false}
+    it "fails when element is not present" do
+      stub(driver).do_command("isElementPresent", [sample_locator]) do
+        result(false)
+      end
+      proc do
+        test_case.assert_element_present(sample_locator)
+      end.should raise_error(Test::Unit::AssertionFailedError)
     end
-    proc do
-      @test_case.assert_element_present(sample_locator)
-    end.should raise_error(Test::Unit::AssertionFailedError)
   end
-end
 
-describe SeleniumTestCase, "#assert_element_not_present" do
-  it_should_behave_like "Seleniumrc::SeleniumTestCase"
+  describe SeleniumTestCase, "#assert_element_not_present" do
+    it_should_behave_like "Seleniumrc::SeleniumTestCase"
 
-  before do
-    mock.proxy(SeleniumElement).new(base_selenium, sample_locator) do |element|
-      mock.proxy(element).is_not_present({})
-      element
+    before do
+      mock.proxy(SeleniumElement).new(driver, sample_locator) do |element|
+        mock.proxy(element).is_not_present({})
+        element
+      end
     end
-  end
 
-  it "passes when element is not present" do
-    ticks = [true, true, true, false]
-    mock(base_selenium) do |o|
-      o.is_element_present(sample_locator) do
-        ticks.shift
-      end.times(4)
+    it "passes when element is not present" do
+      ticks = [true, true, true, false]
+      mock(driver) do |o|
+        o.is_element_present(sample_locator) do
+          ticks.shift
+        end.times(4)
+      end
+      test_case.assert_element_not_present(sample_locator)
     end
-    @test_case.assert_element_not_present(sample_locator)
-  end
 
-  it "fails when element is present" do
-    stub(base_selenium) do |o|
-      o.is_element_present(sample_locator) {true}
+    it "fails when element is present" do
+      stub(driver) do |o|
+        o.is_element_present(sample_locator) {true}
+      end
+      proc do
+        test_case.assert_element_not_present(sample_locator)
+      end.should raise_error(Test::Unit::AssertionFailedError)
     end
-    proc do
-      @test_case.assert_element_not_present(sample_locator)
-    end.should raise_error(Test::Unit::AssertionFailedError)
   end
-end
 
-describe SeleniumTestCase, "#assert_value" do
-  it_should_behave_like "Seleniumrc::SeleniumTestCase"
+  describe SeleniumTestCase, "#assert_value" do
+    it_should_behave_like "Seleniumrc::SeleniumTestCase"
 
-  before do
-    mock.proxy(SeleniumElement).new(base_selenium, sample_locator) do |element|
-      mock.proxy(element).has_value("passed in value")
-      element
+    before do
+      mock.proxy(SeleniumElement).new(driver, sample_locator) do |element|
+        mock.proxy(element).has_value("passed in value")
+        element
+      end
     end
-  end
 
-  it "passes when value is expected" do
-    mock(base_selenium) do |o|
-      o.is_element_present(sample_locator) {true}
-      o.get_value(sample_locator) {"passed in value"}
+    it "passes when value is expected" do
+      mock(driver) do |o|
+        o.is_element_present(sample_locator) {true}
+        o.get_value(sample_locator) {"passed in value"}
+      end
+      test_case.assert_value(sample_locator, "passed in value")
     end
-    @test_case.assert_value(sample_locator, "passed in value")
-  end
 
-  it "fails when value is not expected" do
-    stub(base_selenium) do |o|
-      o.is_element_present(sample_locator) {true}
-      o.get_value(sample_locator) {"another value"}
+    it "fails when value is not expected" do
+      stub(driver) do |o|
+        o.is_element_present(sample_locator) {true}
+        o.get_value(sample_locator) {"another value"}
+      end
+      proc do
+        test_case.assert_value(sample_locator, "passed in value")
+      end.should raise_error(Test::Unit::AssertionFailedError)
     end
-    proc do
-      @test_case.assert_value(sample_locator, "passed in value")
-    end.should raise_error(Test::Unit::AssertionFailedError)
   end
-end
 
-describe SeleniumTestCase, "#assert_element_contains" do
-  it_should_behave_like "Seleniumrc::SeleniumTestCase"
+  describe SeleniumTestCase, "#assert_element_contains" do
+    it_should_behave_like "Seleniumrc::SeleniumTestCase"
 
-  before do
-    mock.proxy(SeleniumElement).new(base_selenium, sample_locator) do |element|
-      mock.proxy(element).contains_text("passed in value", {})
-      element
+    before do
+      mock.proxy(SeleniumElement).new(driver, sample_locator) do |element|
+        mock.proxy(element).contains_text("passed in value", {})
+        element
+      end
+      @evaled_js = "this.page().findElement(\"#{sample_locator}\").innerHTML"
     end
-    @evaled_js = "this.page().findElement(\"#{sample_locator}\").innerHTML"
-  end
 
-  it "passes when text is in the element's inner_html" do
-    mock(base_selenium) do |o|
-      o.is_element_present(sample_locator) {true}
-      o.get_eval(@evaled_js) do
-        "html passed in value html"
+    it "passes when text is in the element's inner_html" do
+      mock(driver) do |o|
+        o.is_element_present(sample_locator) {true}
+        o.get_eval(@evaled_js) do
+          "html passed in value html"
+        end
       end
+      test_case.assert_element_contains(sample_locator, "passed in value")
     end
-    @test_case.assert_element_contains(sample_locator, "passed in value")
-  end
 
-  it "fails when text is not in the element's inner_html" do
-    stub(base_selenium) do |o|
-      o.is_element_present(sample_locator) {true}
-      o.get_eval(@evaled_js) {"another value"}
+    it "fails when text is not in the element's inner_html" do
+      stub(driver) do |o|
+        o.is_element_present(sample_locator) {true}
+        o.get_eval(@evaled_js) {"another value"}
+      end
+      proc do
+        test_case.assert_element_contains(sample_locator, "passed in value")
+      end.should raise_error(Test::Unit::AssertionFailedError)
     end
-    proc do
-      @test_case.assert_element_contains(sample_locator, "passed in value")
-    end.should raise_error(Test::Unit::AssertionFailedError)
   end
-end
 
-describe SeleniumTestCase, "#element_does_not_contain_text" do
-  it_should_behave_like "Seleniumrc::SeleniumTestCase"
-  
-  it "returns true when element is not on the page" do
-    locator = "id=element_id"
-    expected_text = "foobar"
-    mock(base_selenium).is_element_present.with(locator).returns(false)
+  describe SeleniumTestCase, "#element_does_not_contain_text" do
+    it_should_behave_like "Seleniumrc::SeleniumTestCase"
 
-    @test_case.element_does_not_contain_text(locator, expected_text).should == true
-  end
+    it "when element is not on the page, returns true" do
+      locator = "id=element_id"
+      expected_text = "foobar"
+      mock(driver).is_element_present(locator) {false}
 
-  it "returns true when element is on page and inner_html does not contain text" do
-    locator = "id=element_id"
-    inner_html = "Some text that does not contain the expected_text"
-    expected_text = "foobar"
-    mock(base_selenium).is_element_present.with(locator).returns(true)
-    mock(@test_case).get_inner_html.with(locator).returns(inner_html)
+      test_case.element_does_not_contain_text(locator, expected_text).should == true
+    end
 
-    @test_case.element_does_not_contain_text(locator, expected_text).should == true
-  end
+    it "when element is on page and inner_html does not contain text, returns true" do
+      locator = "id=element_id"
+      inner_html = "Some text that does not contain the expected_text"
+      expected_text = "foobar"
+      mock(driver).do_command("isElementPresent", [locator]) do
+        result(true)
+      end
+      mock(driver).do_command("getEval", [driver.inner_html_js(locator)]) do
+        inner_html
+      end
 
-  it "returns false when element is on page and inner_html does contain text" do
-    locator = "id=element_id"
-    inner_html = "foobar foobar foobar"
-    expected_text = "foobar"
-    mock(base_selenium).is_element_present.with(locator).returns(true)
-    mock(@test_case).get_inner_html.with(locator).returns(inner_html)
+      test_case.element_does_not_contain_text(locator, expected_text).should == true
+    end
 
-    @test_case.element_does_not_contain_text(locator, expected_text).should == false
+    it "when element is on page and inner_html does contain text, returns false" do
+      locator = "id=element_id"
+      inner_html = "foobar foobar foobar"
+      expected_text = "foobar"
+      mock(driver).do_command("isElementPresent", [locator]) do
+        result(true)
+      end
+      mock(driver).do_command("getEval", [driver.inner_html_js(locator)]) do
+        inner_html
+      end
+
+      test_case.element_does_not_contain_text(locator, expected_text).should == false
+    end
   end
-end
 
-describe SeleniumTestCase, "#assert_element_does_not_contain_text" do
-  it_should_behave_like "Seleniumrc::SeleniumTestCase"
+  describe SeleniumTestCase, "#assert_element_does_not_contain_text" do
+    it_should_behave_like "Seleniumrc::SeleniumTestCase"
 
-  before do
-    mock.proxy(SeleniumElement).new(base_selenium, sample_locator) do |element|
-      mock.proxy(element).does_not_contain_text("passed in value", {})
-      element
+    before do
+      mock.proxy(SeleniumElement).new(driver, sample_locator) do |element|
+        mock.proxy(element).does_not_contain_text("passed in value", {})
+        element
+      end
+      @evaled_js = "this.page().findElement(\"#{sample_locator}\").innerHTML"
     end
-    @evaled_js = "this.page().findElement(\"#{sample_locator}\").innerHTML"
-  end
 
-  it "passes when text is not in the element's inner_html" do
-    mock(base_selenium) do |o|
-      o.is_element_present(sample_locator) {true}
-      o.get_eval(@evaled_js) do
-        "another value"
+    it "passes when text is not in the element's inner_html" do
+      mock(driver) do |o|
+        o.is_element_present(sample_locator) {true}
+        o.get_eval(@evaled_js) do
+          "another value"
+        end
       end
+      test_case.assert_element_does_not_contain_text(sample_locator, "passed in value")
     end
-    @test_case.assert_element_does_not_contain_text(sample_locator, "passed in value")
-  end
 
-  it "fails when text is in the element's inner_html" do
-    stub(base_selenium) do |o|
-      o.is_element_present(sample_locator) {true}
-      o.get_eval(@evaled_js) {"html passed in value html"}
+    it "fails when text is in the element's inner_html" do
+      stub(driver) do |o|
+        o.is_element_present(sample_locator) {true}
+        o.get_eval(@evaled_js) {"html passed in value html"}
+      end
+      proc do
+        test_case.assert_element_does_not_contain_text(sample_locator, "passed in value")
+      end.should raise_error(Test::Unit::AssertionFailedError)
     end
-    proc do
-      @test_case.assert_element_does_not_contain_text(sample_locator, "passed in value")
-    end.should raise_error(Test::Unit::AssertionFailedError)
   end
-end
 
-describe SeleniumTestCase, "#element_does_not_contain_text" do
-  it_should_behave_like "Seleniumrc::SeleniumTestCase"
+  describe SeleniumTestCase, "#element_does_not_contain_text" do
+    it_should_behave_like "Seleniumrc::SeleniumTestCase"
 
-  it "checks if text is in order" do
-    locator = "id=foo"
-    stub(@base_selenium).get_text(locator).returns("one\ntwo\nthree\n")
+    it "checks if text is in order" do
+      locator = "id=foo"
+      stub(@driver).get_text(locator).returns("one\ntwo\nthree\n")
 
-    @test_case.is_text_in_order locator, "one", "two", "three"
+      test_case.is_text_in_order locator, "one", "two", "three"
+    end
   end
-end
 
-describe SeleniumTestCase, "#assert_attribute" do
-  it_should_behave_like "Seleniumrc::SeleniumTestCase"
+  describe SeleniumTestCase, "#assert_attribute" do
+    it_should_behave_like "Seleniumrc::SeleniumTestCase"
 
-  before do
-    mock.proxy(SeleniumElement).new(base_selenium, sample_locator) do |element|
-      mock.proxy(element).has_attribute("passed in value")
-      element
+    before do
+      mock.proxy(SeleniumElement).new(driver, sample_locator) do |element|
+        mock.proxy(element).has_attribute("passed in value")
+        element
+      end
     end
-  end
 
-  it "passes when attribute is expected" do
-    mock(base_selenium) do |o|
-      o.is_element_present(sample_locator) {true}
-      o.get_attribute(sample_locator) {"passed in value"}
+    it "passes when attribute is expected" do
+      mock(driver) do |o|
+        o.is_element_present(sample_locator) {true}
+        o.get_attribute(sample_locator) {"passed in value"}
+      end
+      test_case.assert_attribute(sample_locator, "passed in value")
     end
-    @test_case.assert_attribute(sample_locator, "passed in value")
-  end
-  
-  it "fails when attribute is not expected" do
-    stub(base_selenium) do |o|
-      o.is_element_present(sample_locator) {true}
-      o.get_attribute(sample_locator) {"another value"}
+
+    it "fails when attribute is not expected" do
+      stub(driver) do |o|
+        o.is_element_present(sample_locator) {true}
+        o.get_attribute(sample_locator) {"another value"}
+      end
+      proc do
+        test_case.assert_attribute(sample_locator, "passed in value")
+      end.should raise_error(Test::Unit::AssertionFailedError)
     end
-    proc do
-      @test_case.assert_attribute(sample_locator, "passed in value")
-    end.should raise_error(Test::Unit::AssertionFailedError)
   end
-end
 
-describe SeleniumTestCase, "#assert_selected" do
-  it_should_behave_like "Seleniumrc::SeleniumTestCase"
+  describe SeleniumTestCase, "#assert_selected" do
+    it_should_behave_like "Seleniumrc::SeleniumTestCase"
 
-  before do
-    mock.proxy(SeleniumElement).new(base_selenium, sample_locator) do |element|
-      mock.proxy(element).has_selected("passed_in_element")
-      element
+    before do
+      mock.proxy(SeleniumElement).new(driver, sample_locator) do |element|
+        mock.proxy(element).has_selected("passed_in_element")
+        element
+      end
     end
-  end
 
-  it "passes when selected is expected" do
-    mock(base_selenium) do |o|
-      o.is_element_present(sample_locator) {true}
-      o.get_selected_label(sample_locator) {"passed_in_element"}
+    it "passes when selected is expected" do
+      mock(driver) do |o|
+        o.is_element_present(sample_locator) {true}
+        o.get_selected_label(sample_locator) {"passed_in_element"}
+      end
+      test_case.assert_selected(sample_locator, "passed_in_element")
     end
-    @test_case.assert_selected(sample_locator, "passed_in_element")
-  end
 
-  it "fails when selected is not expected" do
-    stub(base_selenium) do |o|
-      o.is_element_present(sample_locator) {true}
-      o.get_selected_label(sample_locator) {"another_element"}
+    it "fails when selected is not expected" do
+      stub(driver) do |o|
+        o.is_element_present(sample_locator) {true}
+        o.get_selected_label(sample_locator) {"another_element"}
+      end
+      proc do
+        test_case.assert_selected(sample_locator, "passed_in_element")
+      end.should raise_error(Test::Unit::AssertionFailedError)
     end
-    proc do
-      @test_case.assert_selected(sample_locator, "passed_in_element")
-    end.should raise_error(Test::Unit::AssertionFailedError)
-  end  
-end
+  end
 
-describe SeleniumTestCase, "#assert_checked" do
-  it_should_behave_like "Seleniumrc::SeleniumTestCase"
+  describe SeleniumTestCase, "#assert_checked" do
+    it_should_behave_like "Seleniumrc::SeleniumTestCase"
 
-  before do
-    mock.proxy(SeleniumElement).new(base_selenium, sample_locator) do |element|
-      mock.proxy(element).is_checked
-      element
+    before do
+      mock.proxy(SeleniumElement).new(driver, sample_locator) do |element|
+        mock.proxy(element).is_checked
+        element
+      end
     end
-  end
 
-  it "passes when checked" do
-    mock(base_selenium) do |o|
-      o.is_element_present(sample_locator) {true}
-      o.is_checked(sample_locator) {true}
+    it "passes when checked" do
+      mock(driver) do |o|
+        o.is_element_present(sample_locator) {true}
+        o.is_checked(sample_locator) {true}
+      end
+      test_case.assert_checked(sample_locator)
     end
-    @test_case.assert_checked(sample_locator)
-  end
 
-  it "fails when not checked" do
-    stub(base_selenium) do |o|
-      o.is_element_present(sample_locator) {true}
-      o.is_checked(sample_locator) {false}
+    it "fails when not checked" do
+      stub(driver) do |o|
+        o.is_element_present(sample_locator) {true}
+        o.is_checked(sample_locator) {false}
+      end
+      proc do
+        test_case.assert_checked(sample_locator)
+      end.should raise_error(Test::Unit::AssertionFailedError)
     end
-    proc do
-      @test_case.assert_checked(sample_locator)
-    end.should raise_error(Test::Unit::AssertionFailedError)
   end
-end
 
-describe SeleniumTestCase, "#assert_not_checked" do
-  it_should_behave_like "Seleniumrc::SeleniumTestCase"
+  describe SeleniumTestCase, "#assert_not_checked" do
+    it_should_behave_like "Seleniumrc::SeleniumTestCase"
 
-  before do
-    mock.proxy(SeleniumElement).new(base_selenium, sample_locator) do |element|
-      mock.proxy(element).is_not_checked
-      element
+    before do
+      mock.proxy(SeleniumElement).new(driver, sample_locator) do |element|
+        mock.proxy(element).is_not_checked
+        element
+      end
     end
-  end
 
-  it "passes when not checked" do
-    mock(base_selenium) do |o|
-      o.is_element_present(sample_locator) {true}
-      o.is_checked(sample_locator) {false}
+    it "passes when not checked" do
+      mock(driver) do |o|
+        o.is_element_present(sample_locator) {true}
+        o.is_checked(sample_locator) {false}
+      end
+      test_case.assert_not_checked(sample_locator)
     end
-    @test_case.assert_not_checked(sample_locator)
-  end
 
-  it "fails when checked" do
-    stub(base_selenium) do |o|
-      o.is_element_present(sample_locator) {true}
-      o.is_checked(sample_locator) {true}
+    it "fails when checked" do
+      stub(driver) do |o|
+        o.is_element_present(sample_locator) {true}
+        o.is_checked(sample_locator) {true}
+      end
+      proc do
+        test_case.assert_not_checked(sample_locator)
+      end.should raise_error(Test::Unit::AssertionFailedError)
     end
-    proc do
-      @test_case.assert_not_checked(sample_locator)
-    end.should raise_error(Test::Unit::AssertionFailedError)
   end
-end
 
-describe SeleniumTestCase, "#assert_text" do
-  it_should_behave_like "Seleniumrc::SeleniumTestCase"
+  describe SeleniumTestCase, "#assert_text" do
+    it_should_behave_like "Seleniumrc::SeleniumTestCase"
 
-  before do
-    mock.proxy(SeleniumElement).new(base_selenium, sample_locator) do |element|
-      mock.proxy(element).has_text("expected text", {})
-      element
+    before do
+      mock.proxy(SeleniumElement).new(driver, sample_locator) do |element|
+        mock.proxy(element).has_text("expected text", {})
+        element
+      end
     end
-  end
 
-  it "passes when text is expected" do
-    mock(base_selenium) do |o|
-      o.is_element_present(sample_locator) {true}
-      o.get_text(sample_locator) {"expected text"}
+    it "passes when text is expected" do
+      mock(driver) do |o|
+        o.is_element_present(sample_locator) {true}
+        o.get_text(sample_locator) {"expected text"}
+      end
+      test_case.assert_text(sample_locator, "expected text")
     end
-    @test_case.assert_text(sample_locator, "expected text")
-  end
 
-  it "fails when text is not expected" do
-    stub(base_selenium) do |o|
-      o.is_element_present(sample_locator) {true}
-      o.get_text(sample_locator) {"unexpected text"}
+    it "fails when text is not expected" do
+      stub(driver) do |o|
+        o.is_element_present(sample_locator) {true}
+        o.get_text(sample_locator) {"unexpected text"}
+      end
+      proc do
+        test_case.assert_text(sample_locator, "expected text")
+      end.should raise_error(Test::Unit::AssertionFailedError)
     end
-    proc do
-      @test_case.assert_text(sample_locator, "expected text")
-    end.should raise_error(Test::Unit::AssertionFailedError)
   end
-end
 
-describe SeleniumTestCase, "#assert_visible" do
-  it_should_behave_like "Seleniumrc::SeleniumTestCase"
+  describe SeleniumTestCase, "#assert_visible" do
+    it_should_behave_like "Seleniumrc::SeleniumTestCase"
 
-  before do
-    mock.proxy(SeleniumElement).new(base_selenium, sample_locator) do |element|
-      mock.proxy(element).is_visible({})
-      element
+    before do
+      mock.proxy(SeleniumElement).new(driver, sample_locator) do |element|
+        mock.proxy(element).is_visible({})
+        element
+      end
     end
-  end
 
-  it "passes when element is visible" do
-    mock(base_selenium).is_element_present(sample_locator) {true}
-    mock(base_selenium).is_visible(sample_locator) {true}
+    it "passes when element is visible" do
+      mock(driver).is_element_present(sample_locator) {true}
+      mock(driver).is_visible(sample_locator) {true}
 
-    @test_case.assert_visible(sample_locator)
-  end
-  
-  it "fails when element is not visible" do
-    mock(base_selenium).is_element_present(sample_locator) {true}
-    stub(base_selenium).is_visible.returns {false}
+      test_case.assert_visible(sample_locator)
+    end
+
+    it "fails when element is not visible" do
+      mock(driver).is_element_present(sample_locator) {true}
+      stub(driver).is_visible.returns {false}
 
-    proc {
-      @test_case.assert_visible(sample_locator)
-    }.should raise_error(Test::Unit::AssertionFailedError)
+      proc {
+        test_case.assert_visible(sample_locator)
+      }.should raise_error(Test::Unit::AssertionFailedError)
+    end
   end
-end
 
-describe SeleniumTestCase, "#assert_not_visible" do
-  it_should_behave_like "Seleniumrc::SeleniumTestCase"
+  describe SeleniumTestCase, "#assert_not_visible" do
+    it_should_behave_like "Seleniumrc::SeleniumTestCase"
 
-  before do
-    mock.proxy(SeleniumElement).new(base_selenium, sample_locator) do |element|
-      mock.proxy(element).is_not_visible({})
-      element
+    before do
+      mock.proxy(SeleniumElement).new(driver, sample_locator) do |element|
+        mock.proxy(element).is_not_visible({})
+        element
+      end
     end
-  end
 
-  it "passes when element is present and is not visible" do
-    mock(base_selenium).is_element_present(sample_locator) {true}
-    mock(base_selenium).is_visible(sample_locator) {false}
+    it "passes when element is present and is not visible" do
+      mock(driver).is_element_present(sample_locator) {true}
+      mock(driver).is_visible(sample_locator) {false}
 
-    @test_case.assert_not_visible(sample_locator)
-  end
-  
-  it "fails when element is visible" do
-    mock(base_selenium).is_element_present(sample_locator) {true}
-    stub(base_selenium).is_visible(sample_locator) {true}
+      test_case.assert_not_visible(sample_locator)
+    end
+
+    it "fails when element is visible" do
+      mock(driver).is_element_present(sample_locator) {true}
+      stub(driver).is_visible(sample_locator) {true}
 
-    proc {
-      @test_case.assert_not_visible(sample_locator)
-    }.should raise_error(Test::Unit::AssertionFailedError)
+      proc {
+        test_case.assert_not_visible(sample_locator)
+      }.should raise_error(Test::Unit::AssertionFailedError)
+    end
   end
-end
 
-describe SeleniumTestCase, "#assert_next_sibling" do
-  it_should_behave_like "Seleniumrc::SeleniumTestCase"
+  describe SeleniumTestCase, "#assert_next_sibling" do
+    it_should_behave_like "Seleniumrc::SeleniumTestCase"
 
-  before do
-    mock.proxy(SeleniumElement).new(base_selenium, sample_locator) do |element|
-      mock.proxy(element).has_next_sibling("next_sibling", {})
-      element
+    before do
+      mock.proxy(SeleniumElement).new(driver, sample_locator) do |element|
+        mock.proxy(element).has_next_sibling("next_sibling", {})
+        element
+      end
+      @evaled_js = "this.page().findElement('#{sample_locator}').nextSibling.id"
     end
-    @evaled_js = "this.page().findElement('#{sample_locator}').nextSibling.id"
-  end
 
-  it "passes when passed next sibling id" do
-    mock(base_selenium) do |o|
-      o.is_element_present(sample_locator) {true}
-      o.get_eval(@evaled_js) {"next_sibling"}
+    it "passes when passed next sibling id" do
+      mock(driver) do |o|
+        o.is_element_present(sample_locator) {true}
+        o.get_eval(@evaled_js) {"next_sibling"}
+      end
+      test_case.assert_next_sibling(sample_locator, "next_sibling")
     end
-    @test_case.assert_next_sibling(sample_locator, "next_sibling")
-  end
 
-  it "fails when not passed next sibling id" do
-    stub(base_selenium) do |o|
-      o.is_element_present(sample_locator) {true}
-      o.get_eval(@evaled_js) {"wrong_sibling"}
+    it "fails when not passed next sibling id" do
+      stub(driver) do |o|
+        o.is_element_present(sample_locator) {true}
+        o.get_eval(@evaled_js) {"wrong_sibling"}
+      end
+      proc do
+        test_case.assert_next_sibling(sample_locator, "next_sibling")
+      end.should raise_error(Test::Unit::AssertionFailedError)
     end
-    proc do
-      @test_case.assert_next_sibling(sample_locator, "next_sibling")
-    end.should raise_error(Test::Unit::AssertionFailedError)
   end
-end
 
-describe SeleniumTestCase, "#assert_text_in_order" do
-  it_should_behave_like "Seleniumrc::SeleniumTestCase"
+  describe SeleniumTestCase, "#assert_text_in_order" do
+    it_should_behave_like "Seleniumrc::SeleniumTestCase"
 
-  before do
-    mock.proxy(SeleniumElement).new(base_selenium, sample_locator)
-    @evaled_js = "this.page().findElement('#{sample_locator}').nextSibling.id"
-  end
+    before do
+      mock.proxy(SeleniumElement).new(driver, sample_locator)
+      @evaled_js = "this.page().findElement('#{sample_locator}').nextSibling.id"
+    end
 
-  it "passes when text is in order" do
-    mock(base_selenium) do |o|
-      o.is_element_present(sample_locator) {true}
-      o.get_text(sample_locator) {"one\ntwo\nthree\n"}
+    it "passes when text is in order" do
+      mock(driver) do |o|
+        o.is_element_present(sample_locator) {true}
+        o.get_text(sample_locator) {"one\ntwo\nthree\n"}
+      end
+      test_case.assert_text_in_order sample_locator, "one", "two", "three"
     end
-    @test_case.assert_text_in_order sample_locator, "one", "two", "three"
-  end
 
-  it "fails when element is present and text is not in order" do
-    stub(base_selenium) do |o|
-      o.is_element_present(sample_locator) {true}
-      o.get_text(sample_locator) {"<html>one\ntext not in order\n</html>"}
+    it "fails when element is present and text is not in order" do
+      stub(driver) do |o|
+        o.is_element_present(sample_locator) {true}
+        o.get_text(sample_locator) {"<html>one\ntext not in order\n</html>"}
+      end
+      proc do
+        test_case.assert_text_in_order sample_locator, "one", "two", "three"
+      end.should raise_error(Test::Unit::AssertionFailedError)
     end
-    proc do
-      @test_case.assert_text_in_order sample_locator, "one", "two", "three"
-    end.should raise_error(Test::Unit::AssertionFailedError)
   end
-end
 
-describe SeleniumTestCase, "#type" do
-  it_should_behave_like "Seleniumrc::SeleniumTestCase"
+  describe SeleniumTestCase, "#type" do
+    it_should_behave_like "Seleniumrc::SeleniumTestCase"
 
-  it "types when element is present and types" do
-    is_element_present_results = [false, true]
-    mock(base_selenium).is_element_present.with("id=foobar").twice.returns {is_element_present_results.shift}
-    mock(base_selenium).type.with("id=foobar", "The Text")
+    it "types when element is present and types" do
+      is_element_present_results = [false, true]
+      mock(driver).do_command("isElementPresent", ["id=foobar"]).twice do
+        result(is_element_present_results.shift)
+      end
+      mock(driver).do_command("type", ["id=foobar", "The Text"]) do
+        result()
+      end
 
-    @test_case.type "id=foobar", "The Text"
-  end
+      test_case.type "id=foobar", "The Text"
+    end
 
-  it "fails when element is not present" do
-    is_element_present_results = [false, false, false, false]
-    mock(base_selenium).is_element_present.with("id=foobar").times(4).
-      returns {is_element_present_results.shift}
-    dont_allow(base_selenium).type
+    it "fails when element is not present" do
+      mock(driver).do_command("isElementPresent", ["id=foobar"]).times(4) do
+        result(false)
+      end
+      dont_allow(driver).do_command("type", ["id=foobar", "The Text"])
 
-    proc {
-      @test_case.type "id=foobar", "The Text"
-    }.should raise_error(Test::Unit::AssertionFailedError)
+      proc {
+        test_case.type "id=foobar", "The Text"
+      }.should raise_error(Test::Unit::AssertionFailedError)
+    end
   end
-end
 
-describe SeleniumTestCase, "#click" do
-  it_should_behave_like "Seleniumrc::SeleniumTestCase"
+  describe SeleniumTestCase, "#click" do
+    it_should_behave_like "Seleniumrc::SeleniumTestCase"
 
-  it "click when element is present and types" do
-    is_element_present_results = [false, true]
-    mock(base_selenium).is_element_present.with("id=foobar").twice.returns {is_element_present_results.shift}
-    mock(base_selenium).click.with("id=foobar")
+    it "click when element is present and types" do
+      is_element_present_results = [false, true]
+      mock(driver).do_command("isElementPresent", ["id=foobar"]).twice do
+        result(is_element_present_results.shift)
+      end
+      mock(driver).do_command("click", ["id=foobar"]) {result}
 
-    @test_case.click "id=foobar"
-  end
+      test_case.click "id=foobar"
+    end
 
-  it "fails when element is not present" do
-    is_element_present_results = [false, false, false, false]
-    mock(base_selenium).is_element_present.with("id=foobar").times(4).
-      returns {is_element_present_results.shift}
-    dont_allow(base_selenium).click
+    it "fails when element is not present" do
+      is_element_present_results = [false, false, false, false]
+      mock(driver).do_command("isElementPresent", ["id=foobar"]).times(4) do
+        result(is_element_present_results.shift)
+      end
+      dont_allow(driver).do_command("click", [])
 
-    proc {
-      @test_case.click "id=foobar"
-    }.should raise_error(Test::Unit::AssertionFailedError)
+      proc {
+        test_case.click "id=foobar"
+      }.should raise_error(Test::Unit::AssertionFailedError)
+    end
   end
-end
 
-describe SeleniumTestCase, "#select" do
-  it_should_behave_like "Seleniumrc::SeleniumTestCase"
+  describe SeleniumTestCase, "#select" do
+    it_should_behave_like "Seleniumrc::SeleniumTestCase"
 
-  it "types when element is present and types" do
-    is_element_present_results = [false, true]
-    mock(base_selenium).is_element_present.with("id=foobar").twice.returns {is_element_present_results.shift}
-    mock(base_selenium).select.with("id=foobar", "value=3")
+    it "types when element is present and types" do
+      is_element_present_results = [false, true]
+      mock(driver).do_command("isElementPresent", ["id=foobar"]).twice do
+        result is_element_present_results.shift
+      end
+      mock(driver).do_command("select", ["id=foobar", "value=3"]) {result}
 
-    @test_case.select "id=foobar", "value=3"
-  end
+      test_case.select "id=foobar", "value=3"
+    end
 
-  it "fails when element is not present" do
-    is_element_present_results = [false, false, false, false]
-    mock(base_selenium).is_element_present.with("id=foobar").times(4).
-      returns {is_element_present_results.shift}
-    dont_allow(base_selenium).select
+    it "fails when element is not present" do
+      mock(driver).do_command("isElementPresent", ["id=foobar"]).times(4) do
+        result false
+      end
+      dont_allow(driver).do_command("select", ["id=foobar", "value=3"])
 
-    proc {
-      @test_case.select "id=foobar", "value=3"
-    }.should raise_error(Test::Unit::AssertionFailedError)
+      proc {
+        test_case.select "id=foobar", "value=3"
+      }.should raise_error(Test::Unit::AssertionFailedError)
+    end
   end
-end
 
-describe SeleniumTestCase, "#wait_for_and_click" do
-  it_should_behave_like "Seleniumrc::SeleniumTestCase"
+  describe SeleniumTestCase, "#wait_for_and_click" do
+    it_should_behave_like "Seleniumrc::SeleniumTestCase"
 
-  it "click when element is present and types" do
-    is_element_present_results = [false, true]
-    mock(base_selenium).is_element_present.with("id=foobar").twice.returns {is_element_present_results.shift}
-    mock(base_selenium).click.with("id=foobar")
+    it "click when element is present and types" do
+      is_element_present_results = [false, true]
+      mock(driver).do_command("isElementPresent", ["id=foobar"]).twice do
+        result is_element_present_results.shift
+      end
+      mock(driver).do_command("click", ["id=foobar"]) {result}
 
-    @test_case.wait_for_and_click "id=foobar"
-  end
+      test_case.wait_for_and_click "id=foobar"
+    end
 
-  it "fails when element is not present" do
-    is_element_present_results = [false, false, false, false]
-    mock(base_selenium).is_element_present.with("id=foobar").times(4).
-      returns {is_element_present_results.shift}
-    dont_allow(base_selenium).click
+    it "fails when element is not present" do
+      is_element_present_results = [false, false, false, false]
+      mock(driver).is_element_present("id=foobar").times(4) do
+        is_element_present_results.shift
+      end
+      dont_allow(driver).click
 
-    proc {
-      @test_case.wait_for_and_click "id=foobar"
-    }.should raise_error(Test::Unit::AssertionFailedError)
+      proc {
+        test_case.wait_for_and_click "id=foobar"
+      }.should raise_error(Test::Unit::AssertionFailedError)
+    end
   end
-end
 
-describe SeleniumTestCase, "#page" do
-  it_should_behave_like "Seleniumrc::SeleniumTestCase"
-  
-  it "returns page" do
-    @test_case.page.should == SeleniumPage.new(base_selenium)
+  describe SeleniumTestCase, "#page" do
+    it_should_behave_like "Seleniumrc::SeleniumTestCase"
+
+    it "returns page" do
+      test_case.page.should == SeleniumPage.new(driver)
+    end
   end
-end
 
-describe "SeleniumTestCase in test browser mode and test fails" do
-  it_should_behave_like "Seleniumrc::SeleniumTestCase"
+  describe "SeleniumTestCase in test browser mode and test fails" do
+    it_should_behave_like "Seleniumrc::SeleniumTestCase"
 
-  it "should stop interpreter when configuration says to stop test" do
-    @test_case.configuration = "Seleniumrc::SeleniumConfiguration"
-    mock(@test_case.configuration).test_browser_mode?.returns(true)
+    it "should stop driver when configuration says to stop test" do
+      test_case.configuration = configuration = Seleniumrc::SeleniumConfiguration.new
+      configuration.test_browser_mode
 
-    stub(@test_case).passed?.returns(false)
-    mock(@test_case.configuration).stop_selenese_interpreter?.with(false).returns(true)
+      stub(test_case).passed? {false}
+      configuration.keep_browser_open_on_failure = false
 
-    mock(base_selenium).stop.once
-    @test_case.base_selenium = base_selenium
+      mock(driver).stop.once
+      test_case.selenium_driver = driver
 
-    @test_case.teardown
-  end
+      test_case.teardown
+    end
 
-  it "should not stop interpreter when configuration says not to stop test" do
-    @test_case.configuration = "Seleniumrc::SeleniumConfiguration"
-    mock(@test_case.configuration).test_browser_mode?.returns(true)
+    it "should not stop driver when configuration says not to stop test" do
+      test_case.configuration = "Seleniumrc::SeleniumConfiguration"
+      mock(test_case.configuration).test_browser_mode?.returns(true)
 
-    stub(@test_case).passed?.returns(false)
-    mock(@test_case.configuration).stop_selenese_interpreter?.with(false).returns(false)
+      stub(test_case).passed? {false}
+      mock(test_case.configuration).stop_driver?(false) {false}
 
-    @test_case.base_selenium = base_selenium
+      test_case.selenium_driver = driver
 
-    @test_case.teardown
+      test_case.teardown
+    end
   end
-end
 
-describe "SeleniumTestCase in test browser mode and test pass" do
-  it_should_behave_like "Seleniumrc::SeleniumTestCase"
+  describe "SeleniumTestCase in test browser mode and test pass" do
+    it_should_behave_like "Seleniumrc::SeleniumTestCase"
 
-  it "should stop interpreter when configuration says to stop test" do
-    @test_case.configuration = "Seleniumrc::SeleniumConfiguration"
-    mock(@test_case.configuration).test_browser_mode?.returns(true)
+    it "should stop driver when configuration says to stop test" do
+      test_case.configuration = "Seleniumrc::SeleniumConfiguration"
+      mock(test_case.configuration).test_browser_mode?.returns(true)
 
-    stub(@test_case).passed?.returns(true)
-    mock(@test_case.configuration).stop_selenese_interpreter?.with(true).returns(true)
+      stub(test_case).passed?.returns(true)
+      mock(test_case.configuration).stop_driver?(true) {true}
 
-    mock(base_selenium).stop.once
-    @test_case.base_selenium = base_selenium
+      mock(driver).stop.once
+      test_case.selenium_driver = driver
 
-    @test_case.teardown
-  end
+      test_case.teardown
+    end
 
-  it "should not stop interpreter when configuration says not to stop test" do
-    @test_case.configuration = "Seleniumrc::SeleniumConfiguration"
-    mock(@test_case.configuration).test_browser_mode?.returns(true)
+    it "should not stop driver when configuration says not to stop test" do
+      test_case.configuration = "Seleniumrc::SeleniumConfiguration"
+      mock(test_case.configuration).test_browser_mode?.returns(true)
 
-    stub(@test_case).passed?.returns(true)
-    mock(@test_case.configuration).stop_selenese_interpreter?.with(true).returns(false)
+      stub(test_case).passed?.returns(true)
+      mock(test_case.configuration).stop_driver?(true) {false}
 
-    @test_case.base_selenium = base_selenium
+      test_case.selenium_driver = driver
 
-    @test_case.teardown
+      test_case.teardown
+    end
   end
-end
 
-describe "SeleniumTestCase not in suite browser mode" do
-  it_should_behave_like "Seleniumrc::SeleniumTestCase"
+  describe "SeleniumTestCase not in suite browser mode" do
+    it_should_behave_like "Seleniumrc::SeleniumTestCase"
 
-  it "should not stop interpreter when tests fail" do
-    @test_case.configuration = "Seleniumrc::SeleniumConfiguration"
-    mock(@test_case.configuration).test_browser_mode?.returns(false)
+    it "should not stop driver when tests fail" do
+      test_case.configuration = "Seleniumrc::SeleniumConfiguration"
+      mock(test_case.configuration).test_browser_mode? {false}
 
-    def @test_case.passed?; false; end
+      def test_case.passed?;
+        false;
+      end
 
-    @test_case.base_selenium = base_selenium
+      test_case.selenium_driver = driver
 
-    @test_case.teardown
-  end
+      test_case.teardown
+    end
 
-   it "should stop interpreter when tests pass" do
-     @test_case.configuration = "Seleniumrc::SeleniumConfiguration"
-     mock(@test_case.configuration).test_browser_mode?.returns(false)
+    it "should stop driver when tests pass" do
+      test_case.configuration = "Seleniumrc::SeleniumConfiguration"
+      mock(test_case.configuration).test_browser_mode? {false}
 
-     stub(@test_case).passed?.returns(true)
+      stub(test_case).passed?.returns(true)
 
-     @test_case.base_selenium = base_selenium
+      test_case.selenium_driver = driver
 
-     @test_case.teardown
-   end
-end
+      test_case.teardown
+    end
+  end
 
-describe "SeleniumTestCase in test browser mode and test pass" do
-  it_should_behave_like "Seleniumrc::SeleniumTestCase"
+  describe "SeleniumTestCase in test browser mode and test pass" do
+    it_should_behave_like "Seleniumrc::SeleniumTestCase"
 
-  it "should stop interpreter when configuration says to stop test" do
-    @test_case.configuration = "Seleniumrc::SeleniumConfiguration"
-    mock(@test_case.configuration).test_browser_mode?.returns(true)
+    it "should stop driver when configuration says to stop test" do
+      test_case.configuration = "Seleniumrc::SeleniumConfiguration"
+      mock(test_case.configuration).test_browser_mode?.returns(true)
 
-    stub(@test_case).passed?.returns(true)
-    mock(@test_case.configuration).stop_selenese_interpreter?.with(true).returns(true)
+      stub(test_case).passed?.returns(true)
+      mock(test_case.configuration).stop_driver?(true) {true}
 
-    mock(base_selenium).stop.once
-    @test_case.base_selenium = base_selenium
+      mock(driver).stop.once
+      test_case.selenium_driver = driver
 
-    @test_case.teardown
-  end
+      test_case.teardown
+    end
 
-  it "should not stop interpreter when configuration says not to stop test" do
-    @test_case.configuration = "Seleniumrc::SeleniumConfiguration"
-    mock(@test_case.configuration).test_browser_mode?.returns(true)
+    it "should not stop driver when configuration says not to stop test" do
+      test_case.configuration = "Seleniumrc::SeleniumConfiguration"
+      mock(test_case.configuration).test_browser_mode? {true}
 
-    stub(@test_case).passed?.returns(true)
-    mock(@test_case.configuration).stop_selenese_interpreter?.with(true).returns(false)
+      stub(test_case).passed?.returns(true)
+      mock(test_case.configuration).stop_driver?(true) {false}
 
-    @test_case.base_selenium = base_selenium
+      test_case.selenium_driver = driver
 
-    @test_case.teardown
+      test_case.teardown
+    end
   end
 end
-end