terminus_spec 0.5.0

data/spec/terminus_spec/platforms_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+class TestPageForLoading
+  include TerminusSpec::Platforms
+end
+
+describe TestPageForLoading do
+  let(:platform) { TestPageForLoading.new() }
+  let(:drivers) { {} }
+  
+  context "if a chrome browser is associated with a chrome platform" do
+    let(:chrome_browser) { double('browser') }
+    before { drivers[:chrome_browser] = mock_driver(chrome_browser, :chrome_platform) }
+    
+    it "then the chrome platform will be established for the chrome browser" do
+      platform.platform_for(chrome_browser, drivers).should == :chrome_platform
+    end
+    
+    context "if a firefox browser is associated with a firefox platform" do
+      let(:firefox_browser) { double('browser') }
+      before { drivers[:firefox_browser] = mock_driver(firefox_browser, :firefox_platform) }
+      
+      it "then the chrome platform will still be established for the chrome browser" do
+        platform.platform_for(chrome_browser, drivers).should == :chrome_platform
+      end
+    end
+  end
+  
+  context "if a firefox browser is associated with a firefox platform" do
+    let(:firefox_browser) { double('browser') }
+    before { drivers[:firefox_browser] = mock_driver(firefox_browser, :firefox_platform) }
+    
+    it "then the firefox platform will be established for the firefox browser" do
+      platform.platform_for(firefox_browser, drivers).should == :firefox_platform
+    end
+  end
+  
+  context "if an unknown browser object is associated with a platform" do
+    it "it should raise an exception" do
+      expect { platform.platform_for("false_browser") }.to raise_error
+    end
+  end
+end

data/spec/terminus_spec/terminus_spec.rb

@@ -0,0 +1,271 @@
+require 'spec_helper'
+
+class PageTester
+  include TerminusSpec
+end
+
+class PlatformObject
+end
+
+describe TerminusSpec do
+  let(:watir_browser) { mock_browser_with_watir }
+  let(:watir_page) { PageTester.new(watir_browser) }
+  let(:selenium_browser) { mock_browser_with_selenium }
+  let(:selenium_page) { PageTester.new(selenium_browser) }
+  
+  context "is included with a page using watir-webdriver" do
+    it "so it should use a watir platform object" do
+      watir_page.platform.should be_kind_of TerminusSpec::Platforms::WatirWebDriver::PlatformObject
+    end
+  end
+  
+  context "is included with a page using selenium-webdriver" do
+    it "so it should use a selenium platform object" do
+      selenium_page.platform.should be_kind_of TerminusSpec::Platforms::SeleniumWebDriver::PlatformObject
+    end
+  end
+  
+  context "is included with page using an unrecognized browser" do
+    it "so it should raise an exception" do
+      expect { PageTester.new("false_browser") }.to raise_error
+    end
+  end
+  
+  context "is included with a page using an unassociated custom driver" do
+    let(:custom_driver) { mock_driver(:custom_browser, PlatformObject) }
+    it "so it should raise an exception" do
+      expect { custom_page = PageTester.new(:custom_browser) }.to raise_error
+    end
+  end
+  
+  context "is included with a page using an associated custom driver" do
+    let(:custom_driver) { mock_driver(:custom_browser, PlatformObject) }
+    it "so it should use a custom platform object" do
+      mock_drivers_list({:custom_driver => custom_driver})
+      custom_page = PageTester.new(:custom_browser)
+      custom_page.platform.should be custom_driver.create_platform_object_for
+    end
+  end
+  
+  describe "(in terms of browser-level page functionality)" do
+    context "when using any platform" do
+      it "an individual page can provide its own setup logic" do
+        class TestPage
+          include TerminusSpec
+          
+          def setup_page
+            @setup_page = true
+          end
+        end
+        
+        @page = TestPage.new(watir_browser)
+        @page.setup_page.should be_true
+      end
+      
+      it "a window will get two tries to be attached to" do
+        watir_page.platform.should_receive(:attach_to_window).once.and_throw "exception"
+        watir_page.platform.should_receive(:attach_to_window)
+        watir_page.attach_to_window("contentPane")
+      end
+    end
+    
+    context "when using the watir platform" do
+      it "a page can be navigated to" do
+        watir_browser.should_receive(:goto).with("testerstories.com")
+        watir_page.navigate_to("testerstories.com")
+      end
+      
+      it "the title of the page is accessible" do
+        watir_browser.should_receive(:title).and_return("Page Title")
+        watir_page.title.should == "Page Title"
+      end
+      
+      it "the text of the page is accessible" do
+        watir_browser.should_receive(:text).and_return("page text")
+        watir_page.text.should == "page text"
+      end
+      
+      it "the markup of the page is accessible" do
+        watir_browser.should_receive(:html).and_return("<html>HTML page text</html>")
+        watir_page.html.should == "<html>HTML page text</html>"
+      end
+      
+      it "the current web address of the page is accessible" do
+        watir_browser.should_receive(:url).and_return("http://testerstories.com/?p=355")
+        watir_page.current_url.should == "http://testerstories.com/?p=355"
+      end
+      
+      it "the current page can be refreshed" do
+        watir_browser.should_receive(:refresh)
+        watir_page.refresh
+      end
+      
+      it "the preceding page in history can be navigated to" do
+        watir_browser.should_receive(:back)
+        watir_page.back
+      end
+      
+      it "the succeeding page in history can be navigated to" do
+        watir_browser.should_receive(:forward)
+        watir_page.forward
+      end
+      
+      it "the browser cookies can be cleared" do
+        watir_browser.should_receive(:clear_cookies)
+        watir_page.clear_cookies
+      end
+      
+      it "the current page can be captured in a screenshot" do
+        watir_browser.should_receive(:wd).and_return(watir_browser)
+        watir_browser.should_receive(:save_screenshot)
+        watir_page.save_screenshot("testing.png")
+      end
+      
+      it "a condition on the page can be waited for" do
+        watir_browser.should_receive(:wait_until).with(5, "Timeout")
+        watir_page.wait_until(5, "Timeout")
+      end
+      
+      it "alert popup message boxes can be handled" do
+        watir_browser.should_receive(:wd).twice.and_return(watir_browser)
+        watir_browser.should_receive(:execute_script).twice
+        watir_page.will_alert do
+        end
+      end
+      
+      it "confirm popup message boxes can be handled" do
+        watir_browser.should_receive(:wd).twice.and_return(watir_browser)
+        watir_browser.should_receive(:execute_script).twice
+        watir_page.will_confirm(true) do
+        end
+      end
+      
+      it "prompt popup message boxes can be handled" do
+        watir_browser.should_receive(:wd).twice.and_return(watir_browser)
+        watir_browser.should_receive(:execute_script).twice
+        watir_page.will_prompt("Question") do
+        end
+      end
+      
+      it "a window can be attached to by using the title" do
+        watir_browser.should_receive(:window).with(:title => /Display\ Results/).and_return(watir_browser)
+        watir_browser.should_receive(:use)
+        watir_page.attach_to_window(:title => "Display Results")
+      end
+      
+      it "a window can be attached to by using the url" do
+        watir_browser.should_receive(:window).with(:url => /results\.html/).and_return(watir_browser)
+        watir_browser.should_receive(:use)
+        watir_page.attach_to_window(:url => "results.html")
+      end
+      
+      it "a modal dialog can be treated as a window" do
+        watir_browser.should_receive(:execute_script)
+        watir_page.will_be_modal {}
+      end
+    end
+    
+    context "when using the selenium platform" do
+      it "a page can be navigated to" do
+        selenium_browser.stub_chain(:navigate, :to).with("testerstories.com")
+        selenium_page.navigate_to("testerstories.com")
+      end
+      
+      it "the title of the page is accessible" do
+        selenium_browser.should_receive(:title).and_return("Page Title")
+        selenium_page.title.should == "Page Title"
+      end
+      
+      it "the text of the page is accessible" do
+        selenium_browser.stub_chain(:find_element, :text).and_return("page text")
+        selenium_page.text.should == "page text"
+      end
+      
+      it "the markup of the page is accessible" do
+        selenium_browser.should_receive(:page_source).and_return("<html>HTML page text</html>")
+        selenium_page.html.should == "<html>HTML page text</html>"
+      end
+      
+      it "the current web address of the page is accessible" do
+        selenium_browser.should_receive(:current_url).and_return("http://testerstories.com/?p=355")
+        selenium_page.current_url.should == "http://testerstories.com/?p=355"
+      end
+      
+      it "the current page can be refreshed" do
+        selenium_browser.should_receive(:navigate).and_return(selenium_browser)
+        selenium_browser.should_receive(:refresh)
+        selenium_page.refresh
+      end
+      
+      it "the preceding page in history can be navigated to" do
+        selenium_browser.should_receive(:navigate).and_return(selenium_browser)
+        selenium_browser.should_receive(:back)
+        selenium_page.back
+      end
+      
+      it "the succeeding page in history can be navigated to" do
+        selenium_browser.should_receive(:navigate).and_return(selenium_browser)
+        selenium_browser.should_receive(:forward)
+        selenium_page.forward
+      end
+      
+      it "the browser cookies can be cleared" do
+        selenium_browser.should_receive(:manage).and_return(selenium_browser)
+        selenium_browser.should_receive(:delete_all_cookies)
+        selenium_page.clear_cookies
+      end
+      
+      it "the current page can be captured in a screenshot" do
+        selenium_browser.should_receive(:save_screenshot)
+        selenium_page.save_screenshot("testing.png")
+      end
+      
+      it "a condition on the page can be waited for" do
+        wait = double('wait')
+        Selenium::WebDriver::Wait.should_receive(:new).with({:timeout=>5, :message=>'Timeout'}).and_return(wait)
+        wait.should_receive(:until)
+        selenium_page.wait_until(5, 'Timeout')
+      end
+      
+      it "alert popup message boxes can be handled" do
+        selenium_browser.should_receive(:execute_script).twice
+        selenium_page.will_alert do
+        end
+      end
+      
+      it "confirm popup message boxes can be handled" do
+        selenium_browser.should_receive(:execute_script).twice
+        selenium_page.will_confirm(true) do
+        end
+      end
+      
+      it "prompt popup message boxes can be handled" do
+        selenium_browser.should_receive(:execute_script).twice
+        selenium_page.will_prompt("Question") do
+        end
+      end
+      
+      it "a window can be attached to by using the title" do
+        selenium_browser.should_receive(:window_handles).and_return(["result"])
+        selenium_browser.should_receive(:switch_to).twice.and_return(selenium_browser)
+        selenium_browser.should_receive(:window).twice.with("result").and_return(selenium_browser)
+        selenium_browser.should_receive(:title).and_return("Display Results")
+        selenium_page.attach_to_window(:title => "Display Results")
+      end
+      
+      it "a window can be attached to by using the url" do
+        selenium_browser.should_receive(:window_handles).and_return(["result"])
+        selenium_browser.should_receive(:switch_to).twice.and_return(selenium_browser)
+        selenium_browser.should_receive(:window).twice.with("result").and_return(selenium_browser)
+        selenium_browser.should_receive(:current_url).and_return("results.html")
+        selenium_page.attach_to_window(:url => "results.html")
+      end
+      
+      it "a modal dialog can be treated as a window" do
+        selenium_browser.should_receive(:execute_script)
+        selenium_page.will_be_modal {}
+      end
+    end
+  end
+  
+end

data/spec/terminus_spec/web_objects/all_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+require "terminus_spec/web_objects/all"
+
+describe "there are common methods for all web objects" do
+  context "and all objects may have to handle an unknown request" do
+    it "so the request should be delegated to the platform object" do
+      watir_driver = double('watir')
+      watir_web_object = TerminusSpec::WebObjects::WebObject.new(watir_driver, :platform => :watir_webdriver)
+      watir_driver.should_receive(:do_this)
+      watir_web_object.do_this
+    end
+  end
+  
+  context "and it will be necessary to build locators for Watir" do
+    it "so it must be possible to use xpath where objects by name is not supported" do
+      ['table', 'span', 'div', 'td', 'li', 'ol', 'ul'].each do |tag|
+        locator = {:tag_name => tag, :name => 'testing'}
+        result = TerminusSpec::WebObjects::WebObject.have_watir_find_object_with locator
+        result[:xpath].should == ".//#{tag}[@name='testing']"
+      end
+    end
+  end
+  
+  context "and it will be necesary to build locators for Selenium" do
+    
+    def display_objects
+      ['textarea', 'select', 'a', 'div', 'span', 'table', 'td', 'img', 'form', 'li', 'ul', 'ol']
+    end
+    
+    def input_objects
+      ['text', 'hidden', 'checkbox', 'radio']
+    end
+    
+    it "so it must be possible to use xpath when an index is provided for display objects" do
+      display_objects.each do |tag|
+        locator = {:tag_name => tag, :index => 1}
+        key, value = TerminusSpec::WebObjects::WebObject.have_selenium_find_object_with locator 
+        key.should == :xpath
+        value.should == ".//#{tag}[2]"
+      end
+    end
+    
+    it "so it must be possible to use xpath when an index is provided for input objects" do
+      input_objects.each do |tag|
+        locator = {:tag_name => 'input', :type => tag, :index => 1}
+        key, value = TerminusSpec::WebObjects::WebObject.have_selenium_find_object_with locator
+        key.should == :xpath
+        value.should include ".//input[@type='#{tag}'][2]"
+      end
+    end
+    
+    it "so it must be possible to use xpath when locating display objects by name and index" do
+      display_objects.each do |tag|
+        locator = {:tag_name => tag, :name => 'testing', :index => 0}
+        key, value = TerminusSpec::WebObjects::WebObject.have_selenium_find_object_with locator
+        key.should == :xpath
+        value.should == ".//#{tag}[@name='testing'][1]"
+      end
+    end
+    
+    it "so it must be possible to use xpath when locating input objects by name and index" do
+      input_objects.each do |type|
+        locator = {:tag_name => 'input', :type => "#{type}", :name => 'testing', :index => 0}
+        key, value = TerminusSpec::WebObjects::WebObject.have_selenium_find_object_with locator
+        key.should == :xpath
+        value.should include ".//input[@type='#{type}' and @name='testing'][1]"
+      end
+    end
+    
+    it "so it must be possible to use xpath when locating display objects by name and class" do
+      display_objects.each do |tag|
+        locator = {:tag_name => tag, :name => 'test', :class => 'ing'}
+        key, value = TerminusSpec::WebObjects::WebObject.have_selenium_find_object_with locator
+        key.should == :xpath
+        value.should == ".//#{tag}[@name='test' and @class='ing']"
+      end
+    end
+    
+    it "so it must be possible to use xpath when locating input objects by name and class" do
+      input_objects.each do |type|
+        locator = {:tag_name => 'input', :type => "#{type}", :name => 'test', :class => 'ing'}
+        key, value = TerminusSpec::WebObjects::WebObject.have_selenium_find_object_with locator
+        value.should include ".//input[@type='#{type}' and @name='test' and @class='ing']"
+      end
+    end
+  end
+end

data/spec/terminus_spec/web_objects/button_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+require "terminus_spec/web_objects/all"
+require "terminus_spec/web_objects/button"
+
+describe TerminusSpec::WebObjects::Button do
+  let(:button) { TerminusSpec::WebObjects::Button }
+  
+  describe "when mapping how to identify a web object" do
+    it "it should be able to map watir locators" do
+      [:class, :id, :index, :name, :value, :xpath].each do |type|
+        locator = button.have_watir_find_object_with type => 'value'
+        locator.keys.first.should == type
+      end
+    end
+    
+    it "it should be able to map selenium locators" do
+      [:class, :id, :index, :name, :value, :xpath].each do |type|
+        key, value = button.have_selenium_find_object_with type => 'value'
+        key.should == type
+      end
+    end
+  end
+  
+  describe "when performing an action on a web object" do
+    let(:button_object) { double('button_object') }
+    
+    context "and when selenium is the driver" do
+      it "then it should return an error when asked for text" do
+        button = TerminusSpec::WebObjects::Button.new(button_object, :platform => :selenium_webdriver)
+        lambda { button.text }.should raise_error
+      end
+    end
+  end
+  
+end

data/spec/terminus_spec/web_objects/link_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+require "terminus_spec/web_objects/all"
+require "terminus_spec/web_objects/link"
+
+describe TerminusSpec::WebObjects::Link do
+  let(:link) { TerminusSpec::WebObjects::Link }
+  
+  describe "when mapping how to identify a web object" do
+    it "it should be able to map watir locators" do
+      [:class, :href, :id, :index, :name, :text, :xpath].each do |type|
+        locator = link.have_watir_find_object_with type => 'value'
+        locator.keys.first.should == type
+      end
+    end
+    
+    it "it should be able to map selenium locators" do
+      [:class, :id, :link, :link_text, :name, :xpath, :index].each do |type|
+        key, value = link.have_selenium_find_object_with type => 'value'
+        key.should == type
+      end
+    end
+    
+    it "it should be able to map watir selectors to selenium locators" do
+      key, value = link.have_selenium_find_object_with :text => 'value'
+      key.should == :link_text
+    end
+    
+    it "it should be able to map selenium selectors to watir locators" do
+      [:link, :link_text].each do |type|
+        locator = link.have_watir_find_object_with type => 'value'
+        locator.keys.first.should == :text
+      end
+    end
+  end
+  
+  describe "when performing an action on a web object" do
+    let(:link_object) { double('link_object') }
+    
+    context "and when selenium is the driver" do
+      it "then it should return an error when asked for a value" do
+        link = TerminusSpec::WebObjects::Link.new(link_object, :platform => :selenium_webdriver)
+        lambda { link.value }.should raise_error
+      end
+    end
+  end
+end