terminus_spec 0.5.0

data/lib/terminus_spec/platform_watir.rb

@@ -0,0 +1,18 @@
+module TerminusSpec
+  module Platforms
+    module WatirWebDriver
+      
+      def self.create_platform_object_for(browser)
+        require 'terminus_spec/platform_watir/platform_object'
+        return WatirWebDriver::PlatformObject.new(browser)
+      end
+      
+      def self.works_for?(browser)
+        browser.is_a?(Watir::Browser)
+      end
+      
+    end # module WatirWebDriver
+  end # module Platforms
+end # module TerminusSpec
+
+TerminusSpec::Platforms.associate(:watir_webdriver, TerminusSpec::Platforms::WatirWebDriver)

data/lib/terminus_spec/platform_watir/platform_object.rb

@@ -0,0 +1,190 @@
+module TerminusSpec
+  module Platforms
+    module WatirWebDriver
+      
+      class PlatformObject
+        
+        attr_reader :browser
+        
+        def initialize(browser)
+          @browser = browser
+        end
+        
+        # Platform method to navigate to a specified URL.
+        # See TerminusSpec#navigate_to
+        def navigate_to(url)
+          @browser.goto url
+        end
+        
+        # Platform method to retrieve the title for the current page.
+        # See TerminusSpec#title
+        def title
+          @browser.title
+        end
+        
+        # Platform method to retrieve text from the current page.
+        # See TerminusSpec#text
+        def text
+          @browser.text
+        end
+        
+        # Platform method to retrieve the HTML markup for the current page.
+        # See TerminusSpec#html
+        def html
+          @browser.html
+        end
+        
+        # Platform method to get the current URL.
+        # See TerminusSpec#current_url
+        def current_url
+          @browser.url
+        end
+        
+        # Platform method to refresh the page.
+        # See TerminusSpec#refresh
+        def refresh
+          @browser.refresh
+        end
+        
+        # Platform method to go to the preceding page in history.
+        # See TerminusSpec#back
+        def back
+          @browser.back
+        end
+        
+        # Platform method to go to the succeeding page in history.
+        # See TerminusSpec#forward
+        def forward
+          @browser.forward
+        end
+        
+        # Platform method to clear the cookies from the browser.
+        # See TerminusSpec#clear_cookies
+        def clear_cookies
+          @browser.clear_cookies
+        end
+        
+        # Platform method to save the current screenshot to a file.
+        # See TerminusSpec#save_screenshot
+        def save_screenshot(file_name)
+          @browser.wd.save_screenshot(file_name)
+        end
+        
+        # Platform method to wait for a condition on a page to be true.
+        # See TerminusSpec#wait_until
+        def wait_until(timeout, message, &block)
+          @browser.wait_until(timeout, message, &block)
+        end
+        
+        # Platform method to handle an alert popup message box.
+        # See TerminusSpec#will_alert
+        def will_alert(&block)
+          @browser.wd.execute_script "window.alert = function(msg) { window.__lastWatirAlert=msg; }"
+          yield
+          value = @browser.wd.execute_script "return window.__lastWatirAlert"
+          value
+        end
+        
+        # Platform method to handle a confirmation popup message box.
+        # See TerminusSpec#will_confirm
+        def will_confirm(response, &block)
+          @browser.wd.execute_script "window.confirm = function(msg) { window.__lastWatirConfirm=msg; return #{!!response} }"
+          yield
+          value = @browser.wd.execute_script "return window.__lastWatirConfirm"
+          value
+        end
+        
+        # Platform method to handle a prompt popup message box.
+        # See TerminusSpec#will_prompt
+        def will_prompt(response, &block)
+          @browser.wd.execute_script "window.prompt = function(text, value) { window.__lastWatirPrompt = { message: text, default_value: value }; return #{response.to_json}; }"
+          yield
+          result = @browser.wd.execute_script "return window.__lastWatirPrompt"
+          result && result.dup.each_key { |k| result[k.to_sym] = result.delete(k) }
+          result
+        end
+        
+        # Platform method to attach to a displayed window.
+        # See TerminusSpec#attach_to_window
+        def attach_to_window(identifier, &block)
+          win_id = {identifier.keys.first => /#{Regexp.escape(identifier.values.first)}/}
+          @browser.window(win_id).use(&block)
+        end
+        
+        # Platform method to return a link object.
+        # Link objects are of type: TerminusSpec::WebObjects::Link
+        # See TerminusSpec::Generators#link
+        def get_link_for(locator)
+          locator = get_platform_locator_for(locator, WebObjects::Link)
+          web_object = @browser.instance_eval "link(locator)"
+          WebObjects::Link.new(web_object, :platform => :watir_webdriver)
+        end
+        
+        # Platform method to click a link object.
+        # See TerminusSpec::Generators#link
+        def click_link_for(locator)
+          locator = get_platform_locator_for(locator, WebObjects::Link)
+          @browser.instance_eval "link(locator).click if locator"
+        end
+        
+        # Platform method to return a text field object.
+        # Text field objects are of type: TerminusSpec::WebObjects::TextField
+        # See TerminusSpec::Generators#text_field
+        def get_text_field_for(locator)
+          identifier = get_platform_locator_for(locator, WebObjects::TextField)
+          web_object = @browser.instance_eval "text_field(locator)"
+          WebObjects::TextField.new(web_object, :platform => :watir_webdriver)
+        end
+        
+        # Platform method to get the value in a text field object.
+        # See TerminusSpec::Generators#text_field
+        def get_text_field_value_for(locator)
+          identifier = get_platform_locator_for(locator, WebObjects::TextField)
+          value = @browser.instance_eval "text_field(locator).value"
+          value
+        end
+        
+        # Platform method to set a value in a text field object.
+        # See TerminusSpec::Generators#text_field
+        def set_text_field_value_for(locator, text)
+          identifier = get_platform_locator_for(locator, WebObjects::TextField)
+          @browser.instance_eval "text_field(locator).set(text)"
+        end
+        
+        # Platform method to return a button object.
+        # Button objects are of type: TerminusSpec::WebObjects::Button
+        # See TerminusSpec::Generators#button
+        def get_button_for(locator)
+          identifier = get_platform_locator_for(locator, WebObjects::Button)
+          web_object = @browser.instance_eval "button(locator)"
+          WebObjects::Button.new(web_object, :platform => :watir_webdriver)
+        end
+        
+        # Platform method to click a button object.
+        # See TerminusSpec::Generators#button
+        def click_button_for(locator)
+          identifier = get_platform_locator_for(locator, WebObjects::Button)
+          @browser.instance_eval "button(locator).click"
+        end
+        
+        protected
+        
+        def get_platform_locator_for(locator, web_object, tag=nil)
+          locator = qualify_with_tagname_for locator, tag if tag
+          locator = web_object.have_watir_find_object_with locator
+          return locator
+        end
+        
+        def qualify_with_tagname_for(locator, tag)
+          return locator if locator.length < 2 and not locator[:name]
+          locator[:tag_name] = tag if locator[:name]
+          locator
+        end
+        
+      end # class PlatformObject
+      
+    end # module WatirWebDriver
+  end # module Platforms
+end # module TerminusSpec
+
+Dir["#{File.dirname(__FILE__)}/../web_objects/**/*.rb"].each { |file| require file }

data/lib/terminus_spec/platform_watir/web_objects/all.rb

@@ -0,0 +1,88 @@
+module TerminusSpec
+  module Platforms
+    module WatirWebDriver
+      module WebObject
+        
+        def ==(other)
+          @web_object == other # other.element??
+        end
+        
+        def visible?
+          @web_object.present?
+        end
+        
+        def exists?
+          @web_object.exists?
+        end
+        
+        def text
+          @web_object.text
+        end
+        
+        def value
+          @web_object.value
+        end
+        
+        def tag_name
+          @web_object.tag_name
+        end
+        
+        def clear
+          @web_object.clear
+        end
+        
+        # Send keystrokes to the object.
+        # @param [String, Symbol, Array]
+        # @examples
+        #  web_object.send_keys "test"    #=> value: 'foo'
+        #  web_object.send_keys "tet", :arrow_left, "s"    #=> value: 'test'
+        #  web_object.send_keys [:control, 'a'], :space    #=> value: ' '
+        # @see Selenium::WebDriver::Keys::KEYS
+        def send_keys(*args)
+          @web_object.send_keys(*args)
+        end
+        
+        # Waits until an object is present on the screen.
+        # @param [Integer] (defaults to: 5) seconds to wait before timing out
+        def when_present(timeout=5)
+          @web_object.wait_until_present(timeout)
+          self
+        end
+        
+        # Waits until an object is visible on the screen.
+        # @param [Integer] (defaults to: 5) seconds to wait before timing out
+        def when_visible(timeout=5)
+          Object::Watir::Wait.until(timeout, "Object was not visible in #{timeout} seconds") do
+            visible?
+          end
+          self
+        end
+        
+        # Waits until an object is not visible on the screen.
+        # @param [Integer] (defaults to: 5) seconds to wait before timing out
+        def when_not_visible(timeout=5)
+          Object::Watir::Wait.while(timeout, "Object still visible after #{timeout} seconds") do
+            visible?
+          end
+          self
+        end
+        
+        # Waits until a given returns true (and thus was executed).
+        # @param [Integer] (defaults to: 5) seconds to wait before timing out
+        # @param [String] the message to display if the event times out
+        # @param the block to execute when the event occurs
+        def wait_until(timeout=5, message=nil, &block)
+          Object::Watir::Wait.until(timeout, message, &block)
+        end
+        
+        # Get the value of a the given attribute of the object.
+        # @param [String] attribute name
+        # @return [String,nil] attribute value
+        def attribute(attribute_name)
+          @web_object.attribute_value attribute_name
+        end
+        
+      end # module WebObject
+    end # module WatirWebDriver
+  end # module Platforms
+end # module TerminusSpec

data/lib/terminus_spec/platform_watir/web_objects/text_field.rb

@@ -0,0 +1,13 @@
+module TerminusSpec
+  module Platforms
+    module WatirWebDriver
+      module TextField
+        
+        def value=(this)
+          @web_object.set(this)
+        end
+        
+      end # module TextField
+    end # module WatirWebDriver
+  end # module Platforms
+end # module TerminusSpec

data/lib/terminus_spec/platforms.rb

@@ -0,0 +1,25 @@
+module TerminusSpec
+  module Platforms
+    
+    @@drivers = {}
+    
+    def self.list
+      @@drivers
+    end
+    
+    def self.associate(key, driver)
+      @@drivers[key] = driver
+    end
+    
+    def platform_for(browser, drivers)
+      drivers.each_value { |driver|
+        return driver.create_platform_object_for browser if driver.works_for? browser
+      }
+      raise "Unable to associate a platform using the provided browser."
+    end
+    
+  end # module Platforms
+end # module TerminusSpec
+
+require 'terminus_spec/platform_watir'
+require 'terminus_spec/platform_selenium'

data/lib/terminus_spec/version.rb

@@ -0,0 +1,3 @@
+module TerminusSpec
+  VERSION = "0.5.0"
+end

data/lib/terminus_spec/web_objects/all.rb

@@ -0,0 +1,172 @@
+module TerminusSpec
+  module WebObjects
+    
+    class WebObject
+      
+      def initialize(web_object, platform)
+        @web_object = web_object
+        mixin_web_objects_for platform
+      end
+      
+      def self.have_watir_find_object_with(locator)
+        if need_to_construct_watir_xpath(locator)
+          key_path = :xpath
+          value_path = construct_xpath_for(locator)
+          return key_path => value_path
+        end
+        
+        locator_list = {}
+        
+        locator.each do |key, value|
+          current = {key => value}
+          #puts "****** What I got: #{current}"
+          object_locator = locator_for(current, locators_for_watir, mappings_for_watir)
+          #puts "****** What I gave: #{object_locator}"
+          locator_list[object_locator.keys.first] = object_locator.values.first
+        end
+        
+        locator_list
+      end
+      
+      def self.have_selenium_find_object_with(locator)
+        if locator.length == 1
+          #puts "****** What I got: #{locator}"
+          object_locator = locator_for(locator, locators_for_selenium, mappings_for_selenium)
+          #puts "****** What I gave: #{object_locator}"
+          return object_locator.keys.first, object_locator.values.first
+        elsif locator.length > 1
+          key = :xpath
+          value = construct_xpath_for locator
+          return key, value
+        end
+      end
+      
+      # Used to delegate calls to the driver object.
+      def method_missing(*args, &block)
+        m = args.shift
+        begin
+          @web_object.send m, *args, &block
+        rescue Exception => e
+          raise
+        end
+      end
+      
+      protected
+      
+      def self.locator_for(locator, direct_find, mapping_find)
+        key, value = locator.keys.first, locator.values.first
+        return key => value if direct_find.include? key
+        return mapping_find[key] => value if mapping_find[key]
+        return nil => value
+      end
+      
+      def self.locators_for_watir
+        [:class, :id, :index, :name, :xpath]
+      end
+      
+      def self.mappings_for_watir
+        {}
+      end
+      
+      def self.locators_for_selenium
+        [:class, :id, :index, :name, :xpath]
+      end
+      
+      def self.mappings_for_selenium
+        {}
+      end
+      
+      # This method will only return true if a tag name matches one in the list
+      # AND an attribute of :name is used. That's a potentially specialized
+      # condition. Selenium requires xpath quite a bit more than Watir.
+      def self.need_to_construct_watir_xpath(locator)
+        ['table', 'span', 'div', 'td', 'li', 'ul', 'ol', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'p'].include? locator[:tag_name] and locator[:name]
+      end
+      
+      def self.construct_xpath_for(locator)
+        tag_locator = locator.delete(:tag_name)
+        index_locator = locator.delete(:index)
+        if tag_locator == 'input' and locator[:type] == 'submit'
+          locator.delete(:type)
+          button_locator = locator.clone
+          if button_locator[:value]
+            button_locator[:text] = button_locator[:value]
+            button_locator.delete(:value)
+          end
+          xpath = ".//button"
+          xpath << "[#{express_attributes_for(button_locator)}]" unless button_locator.empty?
+          xpath << "[#{index_locator+1}]" if index_locator
+          locator[:type] = %w[button reset submit image]
+          xpath << " | .//input"
+        else
+          xpath = ".//#{tag_locator}"
+        end
+        xpath << "[#{express_attributes_for(locator)}]" unless locator.empty?
+        xpath << "[#{index_locator+1}]" if index_locator
+        xpath
+      end
+      
+      def self.express_attributes_for(locator)
+        locator.map do |key, value|
+          if value.kind_of?(Array)
+            "(" + value.map { |v| equal_pair(key, v) }.join(" or ") + ")"
+          else
+            get_valid_xpath_pair_for(key, value)
+          end
+        end.join(" and ")
+      end
+      
+      # The inclusion of normalize-space means that leading and trailing spaces
+      # will be removed before comparison. This will also make sure that any
+      # internal sequences of white space will be replaced with just one
+      # space. The @for will be used to grab the for attribute for a label
+      # if it exists.
+      def self.get_valid_xpath_pair_for(key, value)
+        if key == :label
+          "@id=//label[normalize-space()=#{finalize_xpath_string(value)}]/@for"
+        else
+          "#{qualify_lhs_for(key)}=#{finalize_xpath_string(value)}"
+        end
+      end
+      
+      def self.qualify_lhs_for(key)
+        case key
+          when :text, 'text'
+            'normalize-space()'
+          when :href
+            'normalize-space(@href)'
+          else
+            "@#{key.to_s.gsub("_", "-")}"
+        end
+      end
+      
+      def self.finalize_xpath_string(value)
+        if value.include? "'"
+          parts = value.split("'", -1).map { |part| "'#{part}'" }
+          string = parts.join(%{,"'",})
+          "concat(#{string})"
+        else
+          "'#{value}'"
+        end
+      end
+      
+      def mixin_web_objects_for(platform)
+        if platform[:platform] == :watir_webdriver
+          require "terminus_spec/platform_watir/web_objects/all"
+          require "terminus_spec/platform_watir/platform_object"
+          self.class.send :include, TerminusSpec::Platforms::WatirWebDriver::WebObject
+          @platform = TerminusSpec::Platforms::WatirWebDriver::PlatformObject.new(@web_object)
+        elsif platform[:platform] == :selenium_webdriver
+          require "terminus_spec/platform_selenium/web_objects/all"
+          require "terminus_spec/platform_selenium/platform_object"
+          self.class.send :include, TerminusSpec::Platforms::SeleniumWebDriver::WebObject
+          @platform = TerminusSpec::Platforms::SeleniumWebDriver::PlatformObject.new(@web_object)
+        else
+          raise ArgumentError, "Unable to mixin web objects for the specified platform."
+        end
+      end
+      
+    end # class WebObject
+    
+  end # module WebObjects
+end # module TerminusSpec