rufus 0.3 → 0.4

data/features/step_definitions/view_steps.rb

@@ -10,9 +10,20 @@ end
 Given(/^I start the driver$/) do
  puts selenium
 end
-Then(/^I am presented with an alert with the title "([^"]*)"$/) do |title|
 
+Then(/^the view defined "([^"]*)" does( not)? exist$/) do |which, exist|
+  on(HomePage).send("view_#{which}_view").exists?.should == exist.nil?
 end
-Then(/^I see the title of the alert defined "([^"]*)" is "([^"]*)"$/) do |alert, title|
-  on(HomePage).send("#{alert}_view").title.should == title
+
+Given(/^I have navigated to the "([^"]*)" using the "([^"]*)" route$/) do |page, which_route|
+  navigate_to(page.to_class, :using => which_route.to_sym)
+end
+Then(/^I will not find the view marked "([^"]*)" after waiting$/) do |arg|
+  view = on(HomePage).view_zilch_view
+  exists_after_wait?(view).should be_false
+end
+When(/^the view marked "([^"]*)" exists is( not)? displayed$/) do |which, not_displayed|
+  on(DisplayedPage).active?.should be_true
+  view = on(DisplayedPage).send("view_#{which}_view")
+ displayed_after_wait?(view).should == not_displayed.nil?
 end

data/features/support/env.rb

@@ -7,9 +7,10 @@ require 'require_all'
 require 'rufus/driver'
 
 World(Rufus::Navigation)
+World(Rufus)
+
  require_rel '/screens'
 
 def selenium
-  $driver = Rufus::Driver.new if $driver.nil?
   $driver
 end

data/features/support/hooks.rb

@@ -1,3 +1,10 @@
 Before do
-  puts selenium
+  $driver = Rufus::Driver.new if $driver.nil?
+  sleep 2
+  $driver.start
+end
+
+After do
+  $driver = nil
+  sleep 2
 end

data/features/support/routes.rb

@@ -0,0 +1,12 @@
+Rufus::Navigation.routes = {
+
+    :default =>[HomePage],
+    :to_exists => [
+        [HomePage, :view_exists],
+        [ExistsPage],
+    ],
+    :to_displayed => [
+      [HomePage, :view_displayed],
+      [DisplayedPage],
+    ]
+}

data/features/support/screens/displayed_page.rb

@@ -0,0 +1,12 @@
+require 'rufus'
+
+class DisplayedPage
+  include Rufus
+
+  label(:view_mystery, :name => 'Mystery Label')
+  label(:view_invisible, :name => 'Invisible Label')
+
+  def active?
+    displayed_after_wait? view_mystery_view
+  end
+end

data/features/support/screens/exists_page.rb

@@ -0,0 +1,16 @@
+require 'rufus'
+
+class ExistsPage
+  include Rufus
+
+  alert(:alert_delayed, :name => 'This Alert Exists')
+
+
+  def active?
+    exists_after_wait? alert_delayed_view
+  end
+
+
+
+
+end

data/features/support/screens/home_page.rb

@@ -4,8 +4,14 @@ class HomePage
   include Rufus
 
   view(:view_rufus, :name =>'rufusButton')
+  view(:view_zilch, :name => 'zilch')
   button(:view_show_alert, :name => 'showAlertButton')
-  alert(:alert, :name => 'Rufus Alert')
+  alert(:alert_rufus, :name => 'Rufus Alert')
+  button(:view_exists, :name => 'existsButton')
+  button(:view_displayed, :name => 'displayedPageButton')
+  button(:alert_Ok, :name => 'Ok')
+  button(:alert_Cancel, :name => 'Cancel')
+
 
 
   def active?

data/features/view.feature

@@ -1,6 +1,29 @@
+@view
 Feature: Interacting with views
 
    Scenario:  Clicking a view
     Given I am on the "HomePage"
     When I click the view defined "rufus"
     Then I am on the "RufusPage"
+
+   Scenario: Finding a view
+     Given I am on the "HomePage"
+     Then the view defined "rufus" does exist
+
+  Scenario: Not finding a view
+    Given I am on the "HomePage"
+    Then the view defined "zilch" does not exist
+
+  Scenario: Waiting for a view to exist
+    Given I have navigated to the "ExistsPage" using the "to_exists" route
+    Then I am on the "ExistsPage"
+
+  Scenario: Waiting for a view that is not there
+    Given I am on the "HomePage"
+    Then I will not find the view marked "zilch" after waiting
+@displayed
+  Scenario: Waiting for a view to be displayed
+    Given I have navigated to the "DisplayedPage" using the "to_displayed" route
+    Then I am on the "DisplayedPage"
+    And the view marked "invisible" exists is not displayed
+

data/lib/rufus/accessors/view.rb

@@ -9,8 +9,7 @@ module Rufus
 
       def exists?
         element = selenium.find(what)
-        false
-        true unless element.nil?
+        !element.nil?
       end
 
       def click

data/lib/rufus/driver.rb

@@ -2,13 +2,15 @@ require 'yaml'
 require 'rufus/drivers/iOS_device'
 require 'rufus/drivers/iOS_simulator'
 require 'selenium-webdriver'
+require 'erb'
+require 'selenium/webdriver/safari/extension'
 
 module Rufus
   class Driver
 
     def initialize
       raise 'No config.yml found' if !File.exists?('config.yml')
-      @config = YAML.load_file('config.yml')
+      @config = YAML.load(ERB.new(File.read('config.yml')).result)
       @url = url(@config)
     end
 
@@ -16,6 +18,11 @@ module Rufus
       driver.get @url
     end
 
+    def quit
+      driver.quit
+      @selenium = nil
+    end
+
     def config
       @config
     end
@@ -27,7 +34,11 @@ module Rufus
     def find(locator)
       how = locator.keys[0].to_sym
       what = locator[how]
-      driver.find_element(how, what)
+      begin
+        driver.find_element(how, what)
+      rescue Selenium::WebDriver::Error::NoSuchElementError
+        return nil
+      end
     end
 
     def click(locator)
@@ -46,6 +57,14 @@ module Rufus
       find(locator).displayed?
     end
 
+    def orientation
+      driver.orientation.to_s
+    end
+
+    def rotate(orientation)
+      driver.rotate orientation
+    end
+
     def type(keys, name)
       locator = {:name => name}
       find(locator).send_keys keys

data/lib/rufus/drivers/iOS_device.rb

@@ -7,7 +7,6 @@ module Rufus
       def self.for(config,url)
         @config = config
          Selenium::WebDriver.for(:remote, :desired_capabilities => capabilities, :url => url)
-
       end
 
       def self.capabilities

data/lib/rufus/drivers/iOS_simulator.rb

@@ -6,10 +6,10 @@ module Rufus
 
       def self.for(config,url)
         @config = config
-         Selenium::WebDriver.for(:remote, :desired_capabilities => capabilities, :url => url)
+        Selenium::WebDriver.for(:remote, :desired_capabilities => capabilities, :url => url)
+        #driver(url)
       end
 
-
       private
       def self.capabilities
         {

data/lib/rufus.rb

@@ -8,4 +8,36 @@ module Rufus
     cls.extend Rufus::Accessors
   end
 
-end
+  def exists_after_wait?(view, timeout = 5)
+    wait = Selenium::WebDriver::Wait.new :timeout => timeout
+    begin
+      wait.until{view.exists?}
+    rescue Selenium::WebDriver::Error::TimeOutError
+      return false
+    end
+    true
+  end
+
+  def displayed_after_wait?(view, timeout = 5)
+    wait = Selenium::WebDriver::Wait.new :timeout => timeout
+    begin
+      wait.until{view.displayed?}
+    rescue Selenium::WebDriver::Error::TimeOutError
+      return false
+    end
+    true
+  end
+
+  def enabled_after_wait?(view, timeout = 5)
+    wait = Selenium::WebDriver::Wait.new :timeout => timeout
+    begin
+      wait.until{view.displayed?}
+    rescue Selenium::WebDriver::Error::TimeOutError
+      return false
+    end
+    true
+  end
+
+end
+
+

data/rufus.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |gem|
   gem.name          = "rufus"
-  gem.version       = "0.3"
+  gem.version       = "0.4"
   gem.authors       = ["Jeremy Stewart"]
   gem.email         = ["jlstewart379@gmail.com"]
   gem.description   = "Page object wrapper for Appium"

data/spec/drivers_specs/driver_spec.rb

@@ -15,7 +15,7 @@ describe Rufus::Driver do
     context 'config file exists' do
       before(:each) do
         File.stub(:exists?).and_return(true)
-        YAML.should_receive(:load_file).with("config.yml").and_return("browser_name" =>"iOS", "platform"=>"Mac", "version"=>"6.1", "app"=>"/Users/app/path/rufus.app")
+        YAML.should_receive(:load).and_return("browser_name" =>"iOS", "platform"=>"Mac", "version"=>"6.1", "app"=>"/Users/app/path/rufus.app")
         @driver = Rufus::Driver.new
       end
       it 'loads the config file' do
@@ -47,41 +47,53 @@ describe Rufus::Driver do
     let(:mock_elements){double('mock selenium driver elements list')}
     let(:mock_element){double('mock selenium driver element')}
 
+
     before(:each) do
       File.stub(:exists?).and_return(true)
-      YAML.should_receive(:load_file).with("config.yml").and_return("browser_name" =>"iOS", "platform"=>"Mac", "version"=>"6.1", "app"=>"/Users/app/path/rufus.app")
-
+      YAML.should_receive(:load).and_return("browser_name" =>"iOS", "platform"=>"Mac", "version"=>"6.1", "app"=>"/Users/app/path/rufus.app")
       @driver = Rufus::Driver.new
-
-      Selenium::WebDriver.should_receive(:for).and_return(mock_driver)
-      mock_driver.should_receive(:find_element).with(:name, 'rufusButton').and_return(mock_element)
+      Rufus::Drivers::IOS_Simulator.should_receive(:for).and_return(mock_driver)
     end
 
-    it 'can find an element by name' do
-      @driver.find({:name => 'rufusButton'})
+    context 'finding elements' do
+
+      it 'can find an element by name' do
+        mock_driver.should_receive(:find_element).with(:name, 'rufusButton').and_return(mock_element)
+        @driver.find({:name => 'rufusButton'}).should == mock_element
+      end
+
+      it 'can tell if an element does not exist' do
+        mock_driver.should_receive(:find_element).with(:name, 'rufusButton').and_raise(Selenium::WebDriver::Error::NoSuchElementError)
+        @driver.find({:name => 'rufusButton'}).should be_nil
+      end
     end
 
     it 'can click on an element by name' do
+      mock_driver.should_receive(:find_element).with(:name, 'rufusButton').and_return(mock_element)
       mock_element.should_receive(:click)
       @driver.click({:name =>'rufusButton'})
     end
 
     it 'can click a button by name only' do
+      mock_driver.should_receive(:find_element).with(:name, 'rufusButton').and_return(mock_element)
       mock_element.should_receive(:click)
       @driver.press_button 'rufusButton'
     end
 
     it 'can tell if an element is enabled' do
+      mock_driver.should_receive(:find_element).with(:name, 'rufusButton').and_return(mock_element)
       mock_element.should_receive(:enabled?).and_return(true)
       @driver.enabled?(:name => 'rufusButton').should be_true
     end
 
     it 'can tell if an element is displayed on screen' do
+      mock_driver.should_receive(:find_element).with(:name, 'rufusButton').and_return(mock_element)
       mock_element.should_receive(:displayed?).and_return(true)
       @driver.displayed?(:name => 'rufusButton').should be_true
     end
 
     it 'can enter text into an element' do
+      mock_driver.should_receive(:find_element).with(:name, 'rufusButton').and_return(mock_element)
       mock_element.should_receive(:send_keys).with('text')
       @driver.type('text', 'rufusButton')
     end
@@ -96,11 +108,11 @@ describe Rufus::Driver do
 
     before(:each) do
       File.stub(:exists?).and_return(true)
-      YAML.should_receive(:load_file).with("config.yml").and_return("browser_name" =>"iOS", "platform"=>"Mac", "version"=>"6.1", "app"=>"/Users/app/path/rufus.app")
+      YAML.should_receive(:load).and_return("browser_name" =>"iOS", "platform"=>"Mac", "version"=>"6.1", "app"=>"/Users/app/path/rufus.app")
 
       @test_driver = Rufus::Driver.new
 
-      Selenium::WebDriver.should_receive(:for).and_return(mock_driver)
+     Rufus::Drivers::IOS_Simulator.should_receive(:for).and_return(mock_driver)
 
     end
 
@@ -132,7 +144,7 @@ describe Rufus::Driver do
   context 'choosing the url' do
     before(:each) do
       File.stub(:exists?).and_return(true)
-      YAML.should_receive(:load_file).with("config.yml").and_return("browser_name" =>"iOS", "platform"=>"Mac", "version"=>"6.1", "app"=>"/Users/app/path/rufus.app")
+      YAML.should_receive(:load).and_return("browser_name" =>"iOS", "platform"=>"Mac", "version"=>"6.1", "app"=>"/Users/app/path/rufus.app")
       @driver = Rufus::Driver.new
     end
     it 'sets the default url' do
@@ -148,9 +160,9 @@ describe Rufus::Driver do
 
     before(:each) do
       File.stub(:exists?).and_return(true)
-      YAML.should_receive(:load_file).with("config.yml").and_return("browser_name" =>"iOS", "platform"=>"Mac", "version"=>"6.1", "app"=>"/Users/app/path/rufus.app")
+      YAML.should_receive(:load).and_return("browser_name" =>"iOS", "platform"=>"Mac", "version"=>"6.1", "app"=>"/Users/app/path/rufus.app")
       @driver = Rufus::Driver.new
-      Selenium::WebDriver.should_receive(:for).and_return(mock_driver)
+      Rufus::Drivers::IOS_Simulator.should_receive(:for).and_return(mock_driver)
     end
 
     it 'can click buttons in sequence' do
@@ -172,9 +184,9 @@ describe Rufus::Driver do
 
     before(:each) do
       File.stub(:exists?).and_return(true)
-      YAML.should_receive(:load_file).with("config.yml").and_return("browser_name" =>"iOS", "platform"=>"Mac", "version"=>"6.1", "app"=>"/Users/app/path/rufus.app")
+      YAML.should_receive(:load).and_return("browser_name" =>"iOS", "platform"=>"Mac", "version"=>"6.1", "app"=>"/Users/app/path/rufus.app")
       @driver = Rufus::Driver.new
-      Selenium::WebDriver.should_receive(:for).and_return(mock_driver)
+      Rufus::Drivers::IOS_Simulator..should_receive(:for).and_return(mock_driver)
     end
   end
 
@@ -184,7 +196,7 @@ describe Rufus::Driver do
 
     before(:each) do
       File.stub(:exists?).and_return(true)
-      YAML.should_receive(:load_file).with("config.yml").and_return("browser_name" =>"iOS", "platform"=>"Mac", "version"=>"6.1", "app"=>"/Users/app/path/rufus.app")
+      YAML.should_receive(:load).and_return("browser_name" =>"iOS", "platform"=>"Mac", "version"=>"6.1", "app"=>"/Users/app/path/rufus.app")
       @driver = Rufus::Driver.new
     end
 
@@ -211,7 +223,7 @@ describe Rufus::Driver do
 
       before(:each) do
         File.stub(:exists?).and_return(true)
-        YAML.should_receive(:load_file).with("config.yml").and_return("browser_name" =>"iOS", "platform"=>"Mac", "version"=>"6.1", "app"=>"/Users/app/path/rufus.app")
+        YAML.should_receive(:load).and_return("browser_name" =>"iOS", "platform"=>"Mac", "version"=>"6.1", "app"=>"/Users/app/path/rufus.app")
         @driver = Rufus::Driver.new
 
       end
@@ -232,7 +244,7 @@ describe Rufus::Driver do
 
       it 'can click an alert button' do
         mock_driver.should_receive(:find_elements).at_least(2).times.with(:tag_name, 'UIAElement').and_return([mock_element])
-        Selenium::WebDriver.should_receive(:for).and_return(mock_driver)
+        Rufus::Drivers::IOS_Simulator.should_receive(:for).and_return(mock_driver)
         mock_element.should_receive(:tag_name).at_least(2).times.and_return('UIAAlert')
         @driver.click_alert('Ok')
       end
@@ -249,7 +261,7 @@ describe Rufus::Driver do
         before(:each) do
           File.stub(:exists?).and_return(true)
           @config = {"browser_name" =>"iOS", "platform"=>"Mac", "version"=>"6.1", "app"=>"/Users/app/path/rufus.app", "use_physical" => true}
-          YAML.should_receive(:load_file).with("config.yml").and_return(@config)
+          YAML.should_receive(:load).and_return(@config)
           @driver = Rufus::Driver.new
         end
 
@@ -264,7 +276,7 @@ describe Rufus::Driver do
         before(:each) do
           File.stub(:exists?).and_return(true)
           @config = {"browser_name" =>"iOS", "platform"=>"Mac", "version"=>"6.1", "app"=>"/Users/app/path/rufus.app", "use_physical" => false}
-          YAML.should_receive(:load_file).with("config.yml").and_return(@config)
+          YAML.should_receive(:load).and_return(@config)
           @driver = Rufus::Driver.new
         end
 
@@ -274,6 +286,46 @@ describe Rufus::Driver do
           @driver.start
         end
       end
+    end
+    context 'verifying and setting device orientation' do
+
+      let(:yaml){double('YAML loader')}
+      let(:mock_driver){'a mock app driver'}
+      let(:url){'http://127.0.0.1:4723/wd/hub'}
+
+      context 'orientation' do
+
+        before(:each) do
+          File.stub(:exists?).and_return(true)
+          @config = {"browser_name" =>"iOS", "platform"=>"Mac", "version"=>"6.1", "app"=>"/Users/app/path/rufus.app", "use_physical" => false}
+          YAML.should_receive(:load).and_return(@config)
+          @driver = Rufus::Driver.new
+        end
+
+        it 'can get the device orientation in landscape' do
+          Rufus::Drivers::IOS_Simulator.should_receive(:for).with(@config, url).and_return(mock_driver)
+          mock_driver.should_receive(:orientation).and_return(:landscape)
+          @driver.orientation.should eq('landscape')
+        end
+
+        it 'can set the device orientation to portrait' do
+
+          Rufus::Drivers::IOS_Simulator.should_receive(:for).with(@config, url).and_return(mock_driver)
+          mock_driver.should_receive(:rotate).with('portrait')
+          @driver.rotate('portrait')
+        end
+
+
+
+
+
+
+
+
+      end
+
+
+
     end
   end
 end

data/spec/drivers_specs/iOS_device_spec.rb

@@ -8,6 +8,7 @@ describe Rufus::Drivers::IOS_Device do
   let(:config){ {"browser" =>"iOS", "platform"=>"Mac", "version"=>"6.1", "app"=>"/Users/app/path/rufus.app", "use_physical" => "true"}}
   let(:capabilities){{"browserName" =>"iOS", "platform"=>"Mac", "version"=>"6.1", "app"=>"/Users/app/path/rufus.app"}}
   let(:url){'http://127.0.0.1:4723/wd/hub'}
+  let(:mock_driver){'mock selenium driver'}
 
   context 'initializing driver for iOS device' do
     it 'can create a selenium driver for an iOS device' do
@@ -15,4 +16,22 @@ describe Rufus::Drivers::IOS_Device do
       Rufus::Drivers::IOS_Device.for config, url
     end
   end
+
+  context 'getting the orientation' do
+    it 'can get the current orientation' do
+      Selenium::WebDriver.should_receive(:for).with(:remote, :desired_capabilities => capabilities, :url => 'http://127.0.0.1:4723/wd/hub').and_return(mock_driver)
+      mock_driver.should_receive(:orientation).and_return(:landscape)
+      driver = Rufus::Drivers::IOS_Device.for config, url
+      driver.orientation
+    end
+  end
+
+  context 'setting the orientation' do
+    it 'can set a new orientation' do
+      Selenium::WebDriver.should_receive(:for).with(:remote, :desired_capabilities => capabilities, :url => 'http://127.0.0.1:4723/wd/hub').and_return(mock_driver)
+      mock_driver.should_receive(:rotate).with(:landscape)
+      driver = Rufus::Drivers::IOS_Device.for config, url
+      driver.rotate :landscape
+    end
+  end
 end

data/spec/drivers_specs/iOS_simulator_spec.rb

@@ -2,11 +2,13 @@ require 'spec_helper'
 require 'rufus/drivers/iOS_Simulator'
 require 'selenium-webdriver'
 
+
 describe Rufus::Drivers::IOS_Simulator do
 
   let(:config){ {"browser" =>"iOS", "platform"=>"Mac", "version"=>"6.1", "app"=>"/Users/app/path/rufus.app", "use_physical" => "true", "sim_app_path" => "/path/to/simulator.app"}}
   let(:capabilities){{"browserName" =>"iOS", "platform"=>"Mac", "version"=>"6.1", "app"=>"/path/to/simulator.app", "device" => "iPhoneSimulator"}}
   let(:url){'http://127.0.0.1:4723/wd/hub'}
+  let(:mock_driver){'mock selenium driver'}
 
   context 'initializing driver for iOS device' do
     it 'can create a selenium driver for an iOS device' do
@@ -14,4 +16,23 @@ describe Rufus::Drivers::IOS_Simulator do
       Rufus::Drivers::IOS_Simulator.for config, url
     end
   end
+
+  context 'getting the orientation' do
+    it 'can get the current orientation' do
+      Selenium::WebDriver.should_receive(:for).with(:remote, :desired_capabilities => capabilities, :url => 'http://127.0.0.1:4723/wd/hub').and_return(mock_driver)
+      mock_driver.should_receive(:orientation).and_return(:landscape)
+      driver = Rufus::Drivers::IOS_Simulator.for config, url
+      driver.orientation
+    end
+  end
+
+  context 'setting the orientation' do
+    it 'can set a new orientation' do
+      Selenium::WebDriver.should_receive(:for).with(:remote, :desired_capabilities => capabilities, :url => 'http://127.0.0.1:4723/wd/hub').and_return(mock_driver)
+      mock_driver.should_receive(:rotate).with(:landscape)
+      driver = Rufus::Drivers::IOS_Simulator.for config, url
+      driver.rotate :landscape
+    end
+  end
+
 end

data/spec/rufus_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+require 'rufus/driver'
+require 'rufus/drivers/iOS_device'
+require 'rufus/drivers/iOS_simulator'
+require 'yaml'
+
+describe Rufus do
+  include Rufus
+
+
+
+  context 'waiting for an element to exist' do
+
+    let(:mock_wait){'mock Selenium::WebDriver::Wait'}
+    let(:mock_view){'a mock view object'}
+
+    context 'element exists with timeout given' do
+      it 'returns true if an element is found before given timeout occurs' do
+        Selenium::WebDriver::Wait.should_receive(:new).with(:timeout => 20).and_return(mock_wait)
+        mock_wait.should_receive(:until)
+        exists_after_wait?(mock_view, 20).should be_true
+      end
+      it 'returns true if an element is found before default timeout occurs' do
+        Selenium::WebDriver::Wait.should_receive(:new).with(:timeout => 5).and_return(mock_wait)
+        mock_wait.should_receive(:until)
+        exists_after_wait?(mock_view).should be_true
+      end
+    end
+    context 'element does not exist' do
+      it 'returns false if the timeout is reached' do
+        Selenium::WebDriver::Wait.should_receive(:new).with(:timeout => 5).and_return(mock_wait)
+        mock_wait.should_receive(:until).and_raise(Selenium::WebDriver::Error::TimeOutError)
+        exists_after_wait?(mock_view).should be_false
+      end
+    end
+  end
+
+  context 'waiting for an element to be displayed' do
+
+    let(:mock_wait){'mock Selenium::WebDriver::Wait'}
+    let(:mock_view){'a mock view object'}
+
+    context 'element is displayed with timeout given' do
+      it 'returns true if an element is displayed before given timeout occurs' do
+        Selenium::WebDriver::Wait.should_receive(:new).with(:timeout => 20).and_return(mock_wait)
+        mock_wait.should_receive(:until)
+        displayed_after_wait?(mock_view, 20).should be_true
+      end
+      it 'returns true if an element is displayed before default timeout occurs' do
+        Selenium::WebDriver::Wait.should_receive(:new).with(:timeout => 5).and_return(mock_wait)
+        mock_wait.should_receive(:until)
+        displayed_after_wait?(mock_view).should be_true
+      end
+    end
+    context 'element does not exist' do
+      it 'returns false if the timeout is reached' do
+        Selenium::WebDriver::Wait.should_receive(:new).with(:timeout => 5).and_return(mock_wait)
+        mock_wait.should_receive(:until).and_raise(Selenium::WebDriver::Error::TimeOutError)
+        displayed_after_wait?(mock_view).should be_false
+      end
+    end
+  end
+  context 'waiting for an element to be enabled' do
+
+    let(:mock_wait){'mock Selenium::WebDriver::Wait'}
+    let(:mock_view){'a mock view object'}
+
+    context 'element is enabled with timeout given' do
+      it 'returns true if an element is displayed before given timeout occurs' do
+        Selenium::WebDriver::Wait.should_receive(:new).with(:timeout => 20).and_return(mock_wait)
+        mock_wait.should_receive(:until)
+        enabled_after_wait?(mock_view, 20).should be_true
+      end
+      it 'returns true if an element is enabled before default timeout occurs' do
+        Selenium::WebDriver::Wait.should_receive(:new).with(:timeout => 5).and_return(mock_wait)
+        mock_wait.should_receive(:until)
+        enabled_after_wait?(mock_view).should be_true
+      end
+    end
+    context 'element does not exist' do
+      it 'returns false if the timeout is reached' do
+        Selenium::WebDriver::Wait.should_receive(:new).with(:timeout => 5).and_return(mock_wait)
+        mock_wait.should_receive(:until).and_raise(Selenium::WebDriver::Error::TimeOutError)
+        enabled_after_wait?(mock_view).should be_false
+      end
+    end
+  end
+end