nimboids-capybara 1.1.2

data/lib/capybara/rails.rb

@@ -0,0 +1,17 @@
+require 'capybara'
+require 'capybara/dsl'
+
+Capybara.app = Rack::Builder.new do
+  map "/" do
+    if Rails.version.to_f >= 3.0
+      run Rails.application  
+    else # Rails 2
+      use Rails::Rack::Static
+      run ActionController::Dispatcher.new
+    end
+  end
+end.to_app
+
+Capybara.asset_root = Rails.root.join('public')
+Capybara.save_and_open_page_path = Rails.root.join('tmp/capybara')
+

data/lib/capybara/rspec.rb

@@ -0,0 +1,26 @@
+require 'capybara'
+require 'capybara/dsl'
+require 'rspec/core'
+require 'capybara/rspec/matchers'
+require 'capybara/rspec/features'
+
+RSpec.configure do |config|
+  config.include Capybara::DSL, :type => :request
+  config.include Capybara::DSL, :type => :acceptance
+  config.include Capybara::RSpecMatchers, :type => :request
+  config.include Capybara::RSpecMatchers, :type => :acceptance
+  # The before and after blocks must run instantaneously, because Capybara
+  # might not actually be used in all examples where it's included.
+  config.after do
+    if self.class.include?(Capybara::DSL)
+      Capybara.reset_sessions!
+      Capybara.use_default_driver
+    end
+  end
+  config.before do
+    if self.class.include?(Capybara::DSL)
+      Capybara.current_driver = Capybara.javascript_driver if example.metadata[:js]
+      Capybara.current_driver = example.metadata[:driver] if example.metadata[:driver]
+    end
+  end
+end

data/lib/capybara/rspec/features.rb

@@ -0,0 +1,22 @@
+module Capybara
+  module Features
+    def self.included(base)
+      base.instance_eval do
+        alias :background :before
+        alias :scenario :it
+      end
+    end
+  end
+end
+
+def self.feature(*args, &block)
+  options = if args.last.is_a?(Hash) then args.pop else {} end
+  options[:capybara_feature] = true
+  options[:type] = :request
+  options[:caller] ||= caller
+  args.push(options)
+
+  describe(*args, &block)
+end
+
+RSpec.configuration.include Capybara::Features, :capybara_feature => true

data/lib/capybara/rspec/matchers.rb

@@ -0,0 +1,154 @@
+module Capybara
+  module RSpecMatchers
+    class HaveSelector
+      def initialize(*args)
+        @args = args
+      end
+
+      def matches?(actual)
+        @actual = wrap(actual)
+        @actual.has_selector?(*@args)
+      end
+
+      def does_not_match?(actual)
+        @actual = wrap(actual)
+        @actual.has_no_selector?(*@args)
+      end
+
+      def failure_message_for_should
+        if normalized.failure_message
+          normalized.failure_message.call(@actual, normalized)
+        else
+          "expected #{selector_name} to return something"
+        end
+      end
+
+      def failure_message_for_should_not
+        "expected #{selector_name} not to return anything"
+      end
+
+      def description
+        "has #{selector_name}"
+      end
+
+      def selector_name
+        name = "#{normalized.name} #{normalized.locator.inspect}"
+        name << " with text #{normalized.options[:text].inspect}" if normalized.options[:text]
+        name
+      end
+
+      def wrap(actual)
+        if actual.respond_to?("has_selector?")
+          actual
+        else
+          Capybara.string(actual.to_s)
+        end
+      end
+
+      def normalized
+        @normalized ||= Capybara::Selector.normalize(*@args)
+      end
+    end
+
+    class HaveMatcher
+      attr_reader :name, :locator, :options, :failure_message, :actual
+
+      def initialize(name, locator, options={}, &block)
+        @name = name
+        @locator = locator
+        @options = options
+        @failure_message = block
+      end
+
+      def arguments
+        if options.empty? then [locator] else [locator, options] end
+      end
+
+      def matches?(actual)
+        @actual = wrap(actual)
+        @actual.send(:"has_#{name}?", *arguments)
+      end
+
+      def does_not_match?(actual)
+        @actual = wrap(actual)
+        @actual.send(:"has_no_#{name}?", *arguments)
+      end
+
+      def failure_message_for_should
+        if failure_message
+          failure_message.call(actual, self)
+        else
+          "expected #{selector_name} to return something"
+        end
+      end
+
+      def failure_message_for_should_not
+        "expected #{selector_name} not to return anything"
+      end
+
+      def description
+        "has #{selector_name}"
+      end
+
+      def selector_name
+        selector_name = "#{name} #{locator.inspect}"
+        selector_name << " with text #{options[:text].inspect}" if options[:text]
+        selector_name
+      end
+
+      def wrap(actual)
+        if actual.respond_to?("has_selector?")
+          actual
+        else
+          Capybara.string(actual.to_s)
+        end
+      end
+    end
+
+    def have_selector(*args)
+      HaveSelector.new(*args)
+    end
+
+    def have_xpath(xpath, options={})
+      HaveMatcher.new(:xpath, xpath, options)
+    end
+
+    def have_css(css, options={})
+      HaveMatcher.new(:css, css, options)
+    end
+
+    def have_content(text)
+      HaveMatcher.new(:content, text.to_s) do |page, matcher|
+        %(expected there to be content #{matcher.locator.inspect} in #{page.text.inspect})
+      end
+    end
+
+    def have_link(locator, options={})
+      HaveMatcher.new(:link, locator, options)
+    end
+
+    def have_button(locator)
+      HaveMatcher.new(:button, locator)
+    end
+
+    def have_field(locator, options={})
+      HaveMatcher.new(:field, locator, options)
+    end
+
+    def have_checked_field(locator)
+      HaveMatcher.new(:checked_field, locator)
+    end
+
+    def have_unchecked_field(locator)
+      HaveMatcher.new(:unchecked_field, locator)
+    end
+
+    def have_select(locator, options={})
+      HaveMatcher.new(:select, locator, options)
+    end
+
+    def have_table(locator, options={})
+      HaveMatcher.new(:table, locator, options)
+    end
+  end
+end

data/lib/capybara/selector.rb

@@ -0,0 +1,89 @@
+module Capybara
+  class Selector
+    attr_reader :name
+
+    class Normalized
+      attr_accessor :selector, :locator, :options, :xpaths
+
+      def failure_message; selector.failure_message; end
+      def name; selector.name; end
+    end
+
+    class << self
+      def all
+        @selectors ||= {}
+      end
+
+      def add(name, &block)
+        all[name.to_sym] = Capybara::Selector.new(name.to_sym, &block)
+      end
+
+      def remove(name)
+        all.delete(name.to_sym)
+      end
+
+      def normalize(*args)
+        normalized = Normalized.new
+        normalized.options = if args.last.is_a?(Hash) then args.pop else {} end
+
+        if args[1]
+          normalized.selector = all[args[0]]
+          normalized.locator = args[1]
+        else
+          normalized.selector = all.values.find { |s| s.match?(args[0]) }
+          normalized.locator = args[0]
+        end
+        normalized.selector ||= all[Capybara.default_selector]
+
+        xpath = normalized.selector.call(normalized.locator)
+        if xpath.respond_to?(:to_xpaths)
+          normalized.xpaths = xpath.to_xpaths
+        else
+          normalized.xpaths = [xpath.to_s].flatten
+        end
+        normalized
+      end
+    end
+
+    def initialize(name, &block)
+      @name = name
+      instance_eval(&block)
+    end
+
+    def xpath(&block)
+      @xpath = block if block
+      @xpath
+    end
+
+    def match(&block)
+      @match = block if block
+      @match
+    end
+
+    def failure_message(&block)
+      @failure_message = block if block
+      @failure_message
+    end
+
+    def call(locator)
+      @xpath.call(locator)
+    end
+
+    def match?(locator)
+      @match and @match.call(locator)
+    end
+  end
+end
+
+Capybara.add_selector(:xpath) do
+  xpath { |xpath| xpath }
+end
+
+Capybara.add_selector(:css) do
+  xpath { |css| XPath.css(css) }
+end
+
+Capybara.add_selector(:id) do
+  xpath { |id| XPath.descendant[XPath.attr(:id) == id.to_s] }
+  match { |value| value.is_a?(Symbol) }
+end

data/lib/capybara/selenium/driver.rb

@@ -0,0 +1,163 @@
+require 'selenium-webdriver'
+
+class Capybara::Selenium::Driver < Capybara::Driver::Base
+  DEFAULT_OPTIONS = {
+    :resynchronize => false,
+    :resynchronization_timeout => 10,
+    :browser => :firefox
+  }
+  SPECIAL_OPTIONS = [:browser, :resynchronize, :resynchronization_timeout]
+
+  attr_reader :app, :rack_server, :options
+
+  def browser
+    unless @browser
+      @browser = Selenium::WebDriver.for(options[:browser], options.reject { |key,val| SPECIAL_OPTIONS.include?(key) })
+
+      main = Process.pid
+      at_exit do
+        # Store the exit status of the test run since it goes away after calling the at_exit proc...
+        @exit_status = $!.status if $!.is_a?(SystemExit)
+        quit if Process.pid == main
+        exit @exit_status if @exit_status # Force exit with stored status
+      end
+    end
+    @browser
+  end
+
+  def initialize(app, options={})
+    @app = app
+    @options = DEFAULT_OPTIONS.merge(options)
+    @rack_server = Capybara::Server.new(@app)
+    @rack_server.boot if Capybara.run_server
+  end
+
+  def visit(path)
+    browser.navigate.to(url(path))
+  end
+
+  def source
+    browser.page_source
+  end
+
+  def body
+    browser.page_source
+  end
+
+  def current_url
+    browser.current_url
+  end
+
+  def find(selector)
+    browser.find_elements(:xpath, selector).map { |node| Capybara::Selenium::Node.new(self, node) }
+  end
+
+  def wait?; true; end
+
+  def resynchronize
+    if options[:resynchronize]
+      load_wait_for_ajax_support
+      yield
+      Capybara.timeout(options[:resynchronization_timeout], self, "failed to resynchronize, ajax request timed out") do
+        evaluate_script("!window.capybaraRequestsOutstanding")
+      end
+    else
+      yield
+    end
+  end
+
+  def execute_script(script)
+    browser.execute_script script
+  end
+
+  def evaluate_script(script)
+    browser.execute_script "return #{script}"
+  end
+
+  def reset!
+    # Use instance variable directly so we avoid starting the browser just to reset the session
+    if @browser
+      begin
+        @browser.manage.delete_all_cookies
+      rescue Selenium::WebDriver::Error::UnhandledError => e
+        # delete_all_cookies fails when we've previously gone
+        # to about:blank, so we rescue this error and do nothing
+        # instead.
+      end
+      @browser.navigate.to('about:blank')
+    end
+  end
+
+  def within_frame(frame_id)
+    old_window = browser.window_handle
+    browser.switch_to.frame(frame_id)
+    yield
+    browser.switch_to.window old_window
+  end
+
+  def find_window( selector )
+    original_handle = browser.window_handle
+    browser.window_handles.each do |handle|
+      browser.switch_to.window handle
+      if( selector == browser.execute_script("return window.name") ||
+          browser.title.include?(selector) ||
+          browser.current_url.include?(selector) ||
+          (selector == handle) )
+        browser.switch_to.window original_handle
+        return handle
+      end
+    end
+    raise Capybara::ElementNotFound, "Could not find a window identified by #{selector}"
+  end
+
+  def within_window(selector, &blk)
+    handle = find_window( selector )
+    browser.switch_to.window(handle, &blk)
+  end
+
+  def quit
+    @browser.quit
+  rescue Errno::ECONNREFUSED
+    # Browser must have already gone
+  end
+
+  def invalid_element_errors
+    [Selenium::WebDriver::Error::ObsoleteElementError]
+  end
+
+private
+
+  def load_wait_for_ajax_support
+    browser.execute_script <<-JS
+      window.capybaraRequestsOutstanding = 0;
+      (function() { // Overriding XMLHttpRequest
+          var oldXHR = window.XMLHttpRequest;
+
+          function newXHR() {
+              var realXHR = new oldXHR();
+
+              window.capybaraRequestsOutstanding++;
+              realXHR.addEventListener("readystatechange", function() {
+                  if( realXHR.readyState == 4 ) {
+                    setTimeout( function() {
+                      window.capybaraRequestsOutstanding--;
+                      if(window.capybaraRequestsOutstanding < 0) {
+                        window.capybaraRequestsOutstanding = 0;
+                      }
+                    }, 500 );
+                  }
+              }, false);
+
+              return realXHR;
+          }
+
+          window.XMLHttpRequest = newXHR;
+      })();
+    JS
+  end
+
+  def url(path)
+    rack_server.url(path)
+  end
+
+end