bjeanes-capybara 0.3.1

data/lib/capybara/session.rb

@@ -0,0 +1,274 @@
+require 'capybara/wait_until'
+
+module Capybara
+  class Session
+    include Searchable
+
+    DSL_METHODS = [
+      :all, :attach_file, :body, :check, :choose, :click, :click_button, :click_link, :current_url, :drag, :evaluate_script,
+      :field_labeled, :fill_in, :find, :find_button, :find_by_id, :find_field, :find_link, :has_content?, :has_css?,
+      :has_no_content?, :has_no_css?, :has_no_xpath?, :has_xpath?, :locate, :save_and_open_page, :select, :source, :uncheck,
+      :visit, :wait_until, :within, :within_fieldset, :within_table, :has_link?, :has_no_link?, :has_button?, :has_no_button?,
+      :has_field?, :has_no_field?, :has_checked_field?, :has_unchecked_field?
+    ]
+
+    attr_reader :mode, :app
+
+    def initialize(mode, app)
+      @mode = mode
+      @app = app
+    end
+
+    def driver
+      @driver ||= case mode
+      when :rack_test
+        Capybara::Driver::RackTest.new(app)
+      when :selenium
+        Capybara::Driver::Selenium.new(app)
+      when :celerity
+        Capybara::Driver::Celerity.new(app)
+      when :culerity
+        Capybara::Driver::Culerity.new(app)
+      else
+        raise Capybara::DriverNotFoundError, "no driver called #{mode} was found"
+      end
+    end
+
+    def cleanup!
+      driver.cleanup!
+    end
+
+    def current_url
+      driver.current_url
+    end
+
+    def response_headers
+      driver.response_headers
+    end
+
+    def visit(path)
+      driver.visit(path)
+    end
+
+    def click(locator)
+      msg = "no link or button '#{locator}' found"
+      locate(:xpath, XPath.link(locator).button(locator), msg).click
+    end
+
+    def click_link(locator)
+      msg = "no link with title, id or text '#{locator}' found"
+      locate(:xpath, XPath.link(locator), msg).click
+    end
+
+    def click_button(locator)
+      msg = "no button with value or id or text '#{locator}' found"
+      locate(:xpath, XPath.button(locator), msg).click
+    end
+
+    def drag(source_locator, target_locator)
+      source = locate(:xpath, source_locator, "drag source '#{source_locator}' not found on page")
+      target = locate(:xpath, target_locator, "drag target '#{target_locator}' not found on page")
+      source.drag_to(target)
+    end
+
+    def fill_in(locator, options={})
+      msg = "cannot fill in, no text field, text area or password field with id, name, or label '#{locator}' found"
+      locate(:xpath, XPath.fillable_field(locator), msg).set(options[:with])
+    end
+
+    def choose(locator)
+      msg = "cannot choose field, no radio button with id, name, or label '#{locator}' found"
+      locate(:xpath, XPath.radio_button(locator), msg).set(true)
+    end
+
+    def check(locator)
+      msg = "cannot check field, no checkbox with id, name, or label '#{locator}' found"
+      locate(:xpath, XPath.checkbox(locator), msg).set(true)
+    end
+
+    def uncheck(locator)
+      msg = "cannot uncheck field, no checkbox with id, name, or label '#{locator}' found"
+      locate(:xpath, XPath.checkbox(locator), msg).set(false)
+    end
+
+    def select(value, options={})
+      msg = "cannot select option, no select box with id, name, or label '#{options[:from]}' found"
+      locate(:xpath, XPath.select(options[:from]), msg).select(value)
+    end
+
+    def unselect(value, options={})
+      msg = "cannot unselect option, no select box with id, name, or label '#{options[:from]}' found"
+      locate(:xpath, XPath.select(options[:from]), msg).unselect(value)
+    end
+
+    def attach_file(locator, path)
+      msg = "cannot attach file, no file field with id, name, or label '#{locator}' found"
+      locate(:xpath, XPath.file_field(locator), msg).set(path)
+    end
+
+    def body
+      driver.body
+    end
+
+    def source
+      driver.source
+    end
+
+    def within(kind, scope=nil)
+      kind, scope = Capybara.default_selector, kind unless scope
+      scope = XPath.from_css(scope) if kind == :css
+      locate(:xpath, scope, "scope '#{scope}' not found on page")
+      begin
+        scopes.push(scope)
+        yield
+      ensure
+        scopes.pop
+      end
+    end
+
+    def within_fieldset(locator)
+      within :xpath, XPath.fieldset(locator) do
+        yield
+      end
+    end
+
+    def within_table(locator)
+      within :xpath, XPath.table(locator) do
+        yield
+      end
+    end
+
+    def has_xpath?(path, options={})
+      wait_conditionally_until do
+        results = all(:xpath, path, options)
+
+        if options[:count]
+          results.size == options[:count]
+        else
+          results.size > 0
+        end
+      end
+    rescue Capybara::TimeoutError
+      return false
+    end
+
+    def has_no_xpath?(path, options={})
+      wait_conditionally_until do
+        results = all(:xpath, path, options)
+
+        if options[:count]
+          results.size != options[:count]
+        else
+          results.empty?
+        end
+      end
+    rescue Capybara::TimeoutError
+      return false
+    end
+
+    def has_css?(path, options={})
+      has_xpath?(XPath.from_css(path), options)
+    end
+
+    def has_no_css?(path, options={})
+      has_no_xpath?(XPath.from_css(path), options)
+    end
+
+    def has_content?(content)
+      has_xpath?(XPath.content(content))
+    end
+
+    def has_no_content?(content)
+      has_no_xpath?(XPath.content(content))
+    end
+
+    def has_link?(locator)
+      has_xpath?(XPath.link(locator))
+    end
+
+    def has_no_link?(locator)
+      has_no_xpath?(XPath.link(locator))
+    end
+
+    def has_button?(locator)
+      has_xpath?(XPath.button(locator))
+    end
+
+    def has_no_button?(locator)
+      has_no_xpath?(XPath.button(locator))
+    end
+
+    def has_field?(locator, options={})
+      has_xpath?(XPath.field(locator, options))
+    end
+
+    def has_no_field?(locator, options={})
+      has_no_xpath?(XPath.field(locator, options))
+    end
+
+    def has_checked_field?(locator)
+      has_xpath?(XPath.field(locator, :checked => true))
+    end
+
+    def has_unchecked_field?(locator)
+      has_xpath?(XPath.field(locator, :unchecked => true))
+    end
+
+    def has_select?(locator, options={})
+      has_xpath?(XPath.select(locator, options))
+    end
+
+    def has_no_select?(locator, options={})
+      has_no_xpath?(XPath.select(locator, options))
+    end
+
+    def has_table?(locator, options={})
+      has_xpath?(XPath.table(locator, options))
+    end
+
+    def has_no_table?(locator, options={})
+      has_no_xpath?(XPath.table(locator, options))
+    end
+
+    def save_and_open_page
+      require 'capybara/save_and_open_page'
+      Capybara::SaveAndOpenPage.save_and_open_page(body)
+    end
+
+    #return node identified by locator or raise ElementNotFound(using desc)
+    def locate(kind_or_locator, locator=nil, fail_msg = nil)
+      node = wait_conditionally_until { find(kind_or_locator, locator) }
+    ensure
+      raise Capybara::ElementNotFound, fail_msg || "Unable to locate '#{kind_or_locator}'" unless node
+      return node
+    end
+
+    def wait_until(timeout = Capybara.default_wait_time)
+      WaitUntil.timeout(timeout) { yield }
+    end
+
+    def evaluate_script(script)
+      driver.evaluate_script(script)
+    end
+
+  private
+
+    def wait_conditionally_until
+      if driver.wait? then wait_until { yield } else yield end
+    end
+
+    def all_unfiltered(locator)
+      XPath.wrap(locator).scope(current_scope).paths.map do |path|
+        driver.find(path)
+      end.flatten
+    end
+
+    def current_scope
+      scopes.join('')
+    end
+
+    def scopes
+      @scopes ||= []
+    end
+  end
+end

data/lib/capybara/wait_until.rb

@@ -0,0 +1,23 @@
+module Capybara
+  #Provides timeout similar to standard library Timeout, but avoids threads
+  class WaitUntil
+
+    class << self
+
+      def timeout(seconds = 1, &block)
+        start_time = Time.now
+
+        result = nil
+
+        until result
+          return result if result = yield
+
+          if (Time.now - start_time) > seconds
+             raise TimeoutError
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/capybara/xpath.rb

@@ -0,0 +1,176 @@
+module Capybara
+  # this is a class for generating XPath queries, use it like this:
+  #     Xpath.text_field('foo').link('blah').to_s
+  # this will generate an XPath that matches either a text field or a link
+  class XPath
+
+    class << self
+      def from_css(css)
+        Nokogiri::CSS.xpath_for(css).first
+      end
+      alias_method :for_css, :from_css
+
+      def wrap(path)
+        if path.is_a?(self)
+          path
+        else
+          new(path.to_s)
+        end
+      end
+
+      def respond_to?(method)
+        new.respond_to?(method)
+      end
+
+      def method_missing(*args)
+        new.send(*args)
+      end
+    end
+
+    attr_reader :paths
+
+    def initialize(*paths)
+      @paths = paths
+    end
+
+    def field(locator, options={})
+      if options[:with]
+        fillable_field(locator, options)
+      else
+        xpath = fillable_field(locator)
+        xpath = xpath.input_field(:file, locator, options)
+        xpath = xpath.checkbox(locator, options)
+        xpath = xpath.radio_button(locator, options)
+        xpath.select(locator, options)
+      end
+    end
+
+    def fillable_field(locator, options={})
+      [:text, :password, :email, :url, :search, :tel, :color].inject(text_area(locator, options)) do |all, type|
+        all.input_field(type, locator, options)
+      end
+    end
+
+    def content(locator)
+      append("/descendant-or-self::*[contains(.,#{s(locator)})]")
+    end
+
+    def table(locator, options={})
+      conditions = ""
+      if options[:rows]
+        row_conditions = options[:rows].map do |row|
+          row = row.map { |column| "*[self::td or self::th][text()=#{s(column)}]" }.join(sibling)
+          "tr[./#{row}]"
+        end.join(sibling)
+        conditions << "[.//#{row_conditions}]"
+      end
+      append("//table[@id=#{s(locator)} or contains(caption,#{s(locator)})]#{conditions}")
+    end
+
+    def fieldset(locator)
+      append("//fieldset[@id=#{s(locator)} or contains(legend,#{s(locator)})]")
+    end
+
+    def link(locator)
+      xpath = append("//a[@href][@id=#{s(locator)} or contains(.,#{s(locator)}) or contains(@title,#{s(locator)}) or img[contains(@alt,#{s(locator)})]]")
+      xpath.prepend("//a[@href][text()=#{s(locator)} or @title=#{s(locator)} or img[@alt=#{s(locator)}]]")
+    end
+
+    def button(locator)
+      xpath = append("//input[@type='submit' or @type='image' or @type='button'][@id=#{s(locator)} or contains(@value,#{s(locator)})]")
+      xpath = xpath.append("//button[@id=#{s(locator)} or contains(@value,#{s(locator)}) or contains(.,#{s(locator)})]")
+      xpath = xpath.prepend("//input[@type='submit' or @type='image' or @type='button'][@value=#{s(locator)}]")
+      xpath = xpath.prepend("//button[@value=#{s(locator)} or text()=#{s(locator)}]")
+    end
+
+    def text_area(locator, options={})
+      options = options.merge(:text => options[:with]) if options.has_key?(:with)
+      add_field(locator, "//textarea", options)
+    end
+
+    def select(locator, options={})
+      add_field(locator, "//select", options)
+    end
+
+    def input_field(type, locator, options={})
+      options = options.merge(:value => options[:with]) if options.has_key?(:with)
+      add_field(locator, "//input[@type='#{type}']", options)
+    end
+
+    def scope(scope)
+      XPath.new(*paths.map { |p| scope + p })
+    end
+
+    def to_s
+      @paths.join(' | ')
+    end
+
+    def append(path)
+      XPath.new(*[@paths, XPath.wrap(path).paths].flatten)
+    end
+
+    def prepend(path)
+      XPath.new(*[XPath.wrap(path).paths, @paths].flatten)
+    end
+
+    def checkbox(locator, options={})
+      input_field(:checkbox, locator, options)
+    end
+
+    def radio_button(locator, options={})
+      input_field(:radio, locator, options)
+    end
+
+    [:text, :password, :email, :url, :search, :tel, :color, :file].each do |type|
+      class_eval <<-RUBY, __FILE__, __LINE__+1
+        def #{type}_field(locator)
+          input_field(:#{type}, locator)
+        end
+      RUBY
+    end
+
+  protected
+
+    # place this between to nodes to indicate that they should be siblings
+    def sibling
+      '/following-sibling::*[1]/self::'
+    end
+
+    def add_field(locator, field, options={})
+      postfix = extract_postfix(options)
+      xpath = append("#{field}[@id=#{s(locator)}]#{postfix}")
+      xpath = xpath.append("#{field}[@name=#{s(locator)}]#{postfix}")
+      xpath = xpath.append("#{field}[@id=//label[contains(.,#{s(locator)})]/@for]#{postfix}")
+      xpath = xpath.append("//label[contains(.,#{s(locator)})]#{field}#{postfix}")
+      xpath.prepend("#{field}[@id=//label[text()=#{s(locator)}]/@for]#{postfix}")
+    end
+
+    def extract_postfix(options)
+      options.inject("") do |postfix, (key, value)|
+        case key
+          when :value     then postfix += "[@value=#{s(value)}]"
+          when :text      then postfix += "[text()=#{s(value)}]"
+          when :checked   then postfix += "[@checked]"
+          when :unchecked then postfix += "[not(@checked)]"
+          when :options   then postfix += value.map { |o| "[./option/text()=#{s(o)}]" }.join
+          when :selected  then postfix += [value].flatten.map { |o| "[./option[@selected]/text()=#{s(o)}]" }.join
+        end
+        postfix
+      end
+    end
+
+    # Sanitize a String for putting it into an xpath query
+    def s(string)
+      if string.include?("'")
+        string = string.split("'", -1).map do |substr|
+          "'#{substr}'"
+        end.join(%q{,"'",})
+        "concat(#{string})"
+      else
+        "'#{string}'"
+      end
+
+    end
+
+  end
+end