terminus_spec 0.5.0

data/lib/terminus_spec/web_objects/button.rb

@@ -0,0 +1,32 @@
+module TerminusSpec
+  module WebObjects
+    
+    class Button < WebObject
+      
+      def initialize(web_object, platform)
+        @web_object = web_object
+        mixin_web_objects_for platform
+      end
+      
+      protected
+      
+      def self.locators_for_watir
+        super + [:text, :value]
+      end
+      
+      def self.locators_for_selenium
+        super + [:value]
+      end
+      
+      def mixin_web_objects_for(platform)
+        super
+        if platform[:platform] == :selenium_webdriver
+          require "terminus_spec/platform_selenium/web_objects/button"
+          self.class.send :include, TerminusSpec::Platforms::SeleniumWebDriver::Button
+        end
+      end
+      
+    end # class Button
+    
+  end # module WebObjects
+end # module TerminusSpec

data/lib/terminus_spec/web_objects/link.rb

@@ -0,0 +1,40 @@
+module TerminusSpec
+  module WebObjects
+    
+    class Link < WebObject
+      
+      def initialize(web_object, platform)
+        @web_object = web_object
+        mixin_web_objects_for platform
+      end
+      
+      protected
+      
+      def self.locators_for_watir
+        super + [:href, :text]
+      end
+      
+      def self.mappings_for_watir
+        super.merge({:link => :text, :link_text => :text})
+      end
+      
+      def self.locators_for_selenium
+        super + [:link, :link_text]
+      end
+      
+      def self.mappings_for_selenium
+        super.merge(:text => :link_text)
+      end
+      
+      def mixin_web_objects_for(platform)
+        super
+        if platform[:platform] == :selenium_webdriver
+          require "terminus_spec/platform_selenium/web_objects/link"
+          self.class.send :include, TerminusSpec::Platforms::SeleniumWebDriver::Link
+        end
+      end
+      
+    end # class Link
+    
+  end # module WebObjects
+end # module TerminusSpec

data/lib/terminus_spec/web_objects/text_field.rb

@@ -0,0 +1,45 @@
+module TerminusSpec
+  module WebObjects
+    
+    class TextField < WebObject
+      
+      def initialize(web_object, platform)
+        @web_object = web_object
+        mixin_web_objects_for platform
+      end
+      
+      protected
+      
+      def self.locators_for_watir
+        super + [:tag_name]
+      end
+      
+      def self.mappings_for_watir
+        super.merge({:css => :tag_name})
+      end
+      
+      def self.locators_for_selenium
+        super + [:css]
+      end
+      
+      def self.mappings_for_selenium
+        super.merge({:tag_name => :css})
+      end
+      
+      def mixin_web_objects_for(platform)
+        super
+        if platform[:platform] == :watir_webdriver
+          require "terminus_spec/platform_watir/web_objects/text_field"
+          self.class.send :include, TerminusSpec::Platforms::WatirWebDriver::TextField
+        elsif platform[:platform] == :selenium_webdriver
+          require "terminus_spec/platform_selenium/web_objects/text_field"
+          self.class.send :include, TerminusSpec::Platforms::SeleniumWebDriver::TextField
+        else
+          raise ArgumentError, "Unable to mixin web objects for the specified platform."
+        end
+      end
+      
+    end # class TextField
+    
+  end # module WebObjects
+end # module TerminusSpec

data/spec/spec_helper.rb

@@ -0,0 +1,37 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'watir-webdriver'
+require 'selenium-webdriver'
+require 'terminus_spec'
+
+require 'simplecov'
+SimpleCov.start { add_filter "/spec/" }
+
+def mock_browser_with_watir
+  watir_browser = double('watir')
+  watir_browser.stub(:is_a?).with(anything()).and_return(false)
+  watir_browser.stub(:is_a?).with(Selenium::WebDriver::Driver).and_return(false)
+  watir_browser.stub(:is_a?).with(Watir::Browser).and_return(true)
+  watir_browser
+end
+
+def mock_browser_with_selenium
+  selenium_browser = double('selenium')
+  selenium_browser.stub(:is_a?).with(anything()).and_return(false)
+  selenium_browser.stub(:is_a?).with(Watir::Browser).and_return(false)
+  selenium_browser.stub(:is_a?).with(Selenium::WebDriver::Driver).and_return(true)
+  selenium_browser
+end
+
+def mock_driver(browser, platform_object)
+  driver = double('driver')
+  driver.stub(:works_for?).with(anything()).and_return(false)
+  driver.stub(:works_for?).with(browser).and_return(true)
+  driver.stub(:create_platform_object_for).and_return platform_object
+  driver
+end
+
+def mock_drivers_list(drivers)
+  TerminusSpec::Platforms.stub(:list).and_return drivers
+end

data/spec/terminus_spec/factory_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+require 'terminus_spec/factory'
+
+class FactoryTestPage
+  include TerminusSpec
+  
+  url_is "http://testerstories.com"
+end
+
+class TestFactory
+  include TerminusSpec::Factory
+  attr_accessor :browser
+end
+
+describe TerminusSpec::Factory do
+  before(:each) do
+    @factory = TestFactory.new
+    @factory.browser = mock_browser_with_watir
+  end
+  
+  it "should be able to visit a new page after it has been created" do
+    @factory.browser.should_receive(:goto)
+    @factory.visit FactoryTestPage do |page|
+      page.should be_instance_of FactoryTestPage
+    end
+  end
+  
+  it "should set an instance variable that can be used outside of the page block" do
+    page = @factory.on FactoryTestPage
+    current_page = @factory.instance_variable_get "@page"
+    current_page.should === page
+  end
+  
+  it "should create a new page object and execute a block if one is provided" do
+    @factory.browser.should_not_receive(:goto)
+    @factory.on FactoryTestPage do |page|
+      page.should be_instance_of FactoryTestPage
+    end
+  end
+end

data/spec/terminus_spec/generators_spec.rb

@@ -0,0 +1,179 @@
+require 'spec_helper'
+
+class TestPage
+  include TerminusSpec
+  
+  url_is "http://testerstories.com"
+  
+  link :static_text_examples, :text => "Static Text Examples"
+  link :static_text_examples_b do |this| "testing" end
+  text_field :server, :id => "server"
+  text_field :server_b do |this| "testing" end
+  button :submit, :id => "submit"
+  button :submit_b do |content| "testing" end
+end
+
+describe TerminusSpec::Generators do
+  let(:watir_browser) { mock_browser_with_watir }
+  let(:watir_page) { TestPage.new(watir_browser) }
+  
+  let(:selenium_browser) { mock_browser_with_selenium }
+  let(:selenium_page) { TestPage.new(selenium_browser) }
+  
+  describe "there are page objects that contain location information" do
+    context "which means" do
+      it "it should be possible to navigate to a page when requested" do
+        watir_browser.should_receive(:goto)
+        page = TestPage.new(watir_browser, true)
+      end
+      
+      it "it should not navigate to a page when not requested" do
+        watir_browser.should_not_receive(:goto)
+        page = TestPage.new(watir_browser)
+      end
+      
+      it "it should not navigate to a page when a url is not specified" do
+        watir_browser.should_not_receive(:goto)
+        page = TestPage.new(watir_browser)
+      end
+    end
+  end
+  
+  describe "there are link generators" do
+    context "and when a link is declared on a page" do
+      it "methods for querying and manipulating the link should be generated" do
+        watir_page.should respond_to(:static_text_examples)
+        watir_page.should respond_to(:static_text_examples_object)
+        watir_page.should respond_to(:static_text_examples_link)
+      end
+      
+      it "blocks declared with the object will be executed" do
+        watir_page.static_text_examples_b_link.should == "testing"
+      end
+    end
+    
+    context "and when used on the watir platform implementation" do
+      it "it should be possible to find a link object" do
+        watir_browser.should_receive(:link).and_return(watir_browser)
+        web_object = watir_page.static_text_examples_object
+        web_object.should be_instance_of TerminusSpec::WebObjects::Link
+      end
+      
+      it "it should be possible to select (and thus click) a link" do
+        watir_browser.stub_chain(:link, :click)
+        watir_page.static_text_examples
+      end
+    end
+    
+    context "and when used on the selenium platform implementation" do
+      it "it should be possible to find a link object" do
+        selenium_browser.should_receive(:find_element).and_return(selenium_browser)
+        web_object = selenium_page.static_text_examples_object
+        web_object.should be_instance_of TerminusSpec::WebObjects::Link
+      end
+      
+      it "it should be possible to select (and thus click) a link" do
+        selenium_browser.stub_chain(:find_element, :click)
+        selenium_page.static_text_examples
+      end
+    end
+  end
+  
+  describe "there are text field generators" do
+    context "and when a text field is declared on a page" do
+      it "methods for querying and manipulating the text field should be generated" do
+        watir_page.should respond_to(:server)
+        watir_page.should respond_to(:server=)
+        watir_page.should respond_to(:server_object)
+        watir_page.should respond_to(:server_text_field)
+      end
+      
+      it "blocks declared with the object will be executed" do
+        watir_page.server_b_object.should == "testing"
+      end
+    end
+    
+    context "and when used on the watir platform implementation" do
+      it "it should be possible to find a text field object" do
+        watir_browser.should_receive(:text_field).and_return(watir_browser)
+        web_object = watir_page.server_object
+        web_object.should be_instance_of TerminusSpec::WebObjects::TextField
+      end
+      
+      it "it should be possible to get the text from a text field" do
+        watir_browser.should_receive(:text_field).and_return(watir_browser)
+        watir_browser.should_receive(:value).and_return("Testing")
+        watir_page.server.should == "Testing"
+      end
+      
+      it "it should be possible to type text into a text field" do
+        watir_browser.should_receive(:text_field).and_return(watir_browser)
+        watir_browser.should_receive(:set).with("Testing")
+        watir_page.server = "Testing"
+      end
+    end
+    
+    context "and when used on the selenium platform implementation" do
+      it "it should be possible to find a text field object" do
+        selenium_browser.should_receive(:find_element).and_return(selenium_browser)
+        web_object = selenium_page.server_object
+        web_object.should be_instance_of TerminusSpec::WebObjects::TextField
+      end
+      
+      it "it should be possible to get the text from a text field" do
+        selenium_browser.should_receive(:find_element).and_return(selenium_browser)
+        selenium_browser.should_receive(:attribute).with('value').and_return("Testing")
+        selenium_page.server.should == "Testing"
+      end
+      
+      it "it should be possible to type text into a text field" do
+        selenium_browser.should_receive(:find_element).twice.and_return(selenium_browser)
+        selenium_browser.should_receive(:clear)
+        selenium_browser.should_receive(:send_keys).with("Testing")
+        selenium_page.server = "Testing"
+      end
+    end
+  end
+  
+  describe "there are button generators" do
+    context "and when a button is declared on a page" do
+      it "methods for querying and manipulating the button should be generated" do
+        watir_page.should respond_to(:submit)
+        watir_page.should respond_to(:submit_object)
+        watir_page.should respond_to(:submit_button)
+      end
+      
+      it "blocks declared with the object will be executed" do
+        watir_page.submit_b_object.should == "testing"
+      end
+    end
+    
+    context "and when used on the watir platform implementation" do
+      it "it should be possible to find a button object" do
+        watir_browser.should_receive(:button).and_return(watir_browser)
+        web_object = watir_page.submit_object
+        web_object.should be_instance_of TerminusSpec::WebObjects::Button
+      end
+      
+      it "it should be possible to click a button object" do
+        watir_browser.should_receive(:button).and_return(watir_browser)
+        watir_browser.should_receive(:click)
+        watir_page.submit
+      end
+    end
+    
+    context "and when used on the selenium platform implementation" do
+      it "it should be possible to find a button object" do
+        selenium_browser.should_receive(:find_element).and_return(selenium_browser)
+        web_object = selenium_page.submit_object
+        web_object.should be_instance_of TerminusSpec::WebObjects::Button
+      end
+      
+      it "it should be possible to click a button object" do
+        selenium_browser.should_receive(:find_element).and_return(selenium_browser)
+        selenium_browser.should_receive(:click)
+        selenium_page.submit
+      end
+    end
+  end
+end

data/spec/terminus_spec/locators_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+class LocatorTestPage
+  include TerminusSpec
+end
+
+describe TerminusSpec::Locators do
+  let(:watir_browser) { mock_browser_with_watir }
+  let(:watir_page) { LocatorTestPage.new(watir_browser) }
+  
+  context "a web object may not have been declared but is being referenced" do
+    it "and so it should be able to find a link object" do
+      watir_browser.should_receive(:link).with(:id => 'test').and_return(watir_browser)
+      web_object = watir_page.link_web_object(:id => 'test')
+      web_object.should be_instance_of TerminusSpec::WebObjects::Link
+    end
+    
+    it "and so it should be able to find a text field object" do
+      watir_browser.should_receive(:text_field).with(:id => 'test').and_return(watir_browser)
+      web_object = watir_page.text_field_web_object(:id => 'test')
+      web_object.should be_instance_of TerminusSpec::WebObjects::TextField
+    end
+    
+    it "and so it should be able to find a button object" do
+      watir_browser.should_receive(:button).with(:id => 'test').and_return(watir_browser)
+      web_object = watir_page.button_web_object(:id => 'test')
+      web_object.should be_instance_of TerminusSpec::WebObjects::Button
+    end
+  end
+end

data/spec/terminus_spec/platform_selenium_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe TerminusSpec::Platforms::SeleniumWebDriver do
+  it "should be in the platform objects driver list" do
+    TerminusSpec::Platforms.list[:selenium_webdriver].should be TerminusSpec::Platforms::SeleniumWebDriver
+  end
+  
+  describe "and when used to create a platform object" do
+    let(:browser) { double('browser') }
+    let(:platform) { TerminusSpec::Platforms::SeleniumWebDriver.create_platform_object_for(browser) }
+    
+    it "a SeleniumPlatformObject should be created" do
+      platform.should be_kind_of TerminusSpec::Platforms::SeleniumWebDriver::PlatformObject
+    end
+  end
+  
+  describe "and when checking if the platform can be associated with a browser" do
+    it "if the browser is of type Selenium::WebDriver, the platform will be associated " do
+      browser = mock_browser_with_selenium()
+      TerminusSpec::Platforms::SeleniumWebDriver.works_for?(browser).should be true
+    end
+    
+    it "if the browser is not of type Selenium::WebDriver, the platform will not be associated" do
+      browser = "fake browser"
+      TerminusSpec::Platforms::SeleniumWebDriver.works_for?(browser).should be false
+    end
+  end
+end

data/spec/terminus_spec/platform_watir_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe TerminusSpec::Platforms::WatirWebDriver do
+  it "should be in the platform objects driver list" do
+    TerminusSpec::Platforms.list[:watir_webdriver].should be TerminusSpec::Platforms::WatirWebDriver
+  end
+  
+  describe "and when used to create a platform object" do
+    let(:browser) { double('browser') }
+    let(:platform) { TerminusSpec::Platforms::WatirWebDriver.create_platform_object_for(browser) }
+    
+    it "a WatirPlatformObject should be created" do
+      platform.should be_kind_of TerminusSpec::Platforms::WatirWebDriver::PlatformObject
+    end
+    
+    it "the browser should be associated with the platform object" do
+      platform.browser.should be browser
+    end
+  end
+  
+  describe "and when checking if the platform can be associated with a browser" do
+    it "if the browser is of type Watir::Browser, the platform will be associated " do
+      browser = mock_browser_with_watir()
+      TerminusSpec::Platforms::WatirWebDriver.works_for?(browser).should be true
+    end
+    
+    it "if the browser is not of type Watir::Browser, the platform will not be associated" do
+      browser = "fake browser"
+      TerminusSpec::Platforms::WatirWebDriver.works_for?(browser).should be false
+    end
+  end
+end