bbc-capybara 1.1.2

data/lib/capybara/rack_test/node.rb

@@ -0,0 +1,121 @@
+class Capybara::RackTest::Node < Capybara::Driver::Node
+  def text
+    unnormalized_text.strip.gsub(/\s+/, ' ')
+  end
+
+  def [](name)
+    string_node[name]
+  end
+
+  def value
+    string_node.value
+  end
+
+  def set(value)
+    if tag_name == 'input' and type == 'radio'
+      other_radios_xpath = XPath.generate { |x| x.anywhere(:input)[x.attr(:name).equals(self[:name])] }.to_s
+      driver.dom.xpath(other_radios_xpath).each { |node| node.remove_attribute("checked") }
+      native['checked'] = 'checked'
+    elsif tag_name == 'input' and type == 'checkbox'
+      if value && !native['checked']
+        native['checked'] = 'checked'
+      elsif !value && native['checked']
+        native.remove_attribute('checked')
+      end
+    elsif tag_name == 'input'
+      if (type == 'text' || type == 'password') && self[:maxlength] &&
+        !self[:maxlength].empty?
+        # Browser behavior for maxlength="0" is inconsistent, so we stick with
+        # Firefox, allowing no input
+        value = value[0...self[:maxlength].to_i]
+      end
+      native['value'] = value.to_s
+    elsif tag_name == "textarea"
+      native.content = value.to_s
+    end
+  end
+
+  def select_option
+    if select_node['multiple'] != 'multiple'
+      select_node.find(".//option[@selected]").each { |node| node.native.remove_attribute("selected") }
+    end
+    native["selected"] = 'selected'
+  end
+
+  def unselect_option
+    if select_node['multiple'] != 'multiple'
+      raise Capybara::UnselectNotAllowed, "Cannot unselect option from single select box."
+    end
+    native.remove_attribute('selected')
+  end
+
+  def click
+    if tag_name == 'a'
+      method = self["data-method"] if driver.options[:respect_data_method]
+      method ||= :get
+      driver.follow(method, self[:href].to_s)
+    elsif (tag_name == 'input' and %w(submit image).include?(type)) or
+        ((tag_name == 'button') and type.nil? or type == "submit")
+      Capybara::RackTest::Form.new(driver, form).submit(self)
+    end
+  end
+
+  def tag_name
+    native.node_name
+  end
+
+  def visible?
+    string_node.visible?
+  end
+
+  def checked?
+    string_node.checked?
+  end
+
+  def selected?
+    string_node.selected?
+  end
+
+  def path
+    native.path
+  end
+
+  def find(locator)
+    native.xpath(locator).map { |n| self.class.new(driver, n) }
+  end
+
+protected
+
+  def unnormalized_text
+    if !visible?
+      ''
+    elsif native.text?
+      native.text
+    elsif native.element?
+      native.children.map do |child|
+        Capybara::RackTest::Node.new(driver, child).unnormalized_text
+      end.join
+    else
+      ''
+    end
+  end
+
+private
+
+  def string_node
+    @string_node ||= Capybara::Node::Simple.new(native)
+  end
+
+  # a reference to the select node if this is an option node
+  def select_node
+    find('./ancestor::select').first
+  end
+
+  def type
+    native[:type]
+  end
+
+  def form
+    native.ancestors('form').first
+  end
+end

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,152 @@
+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
+        query.failure_message(:assert, @actual)
+      end
+
+      def failure_message_for_should_not
+        query.negative_failure_message(:assert, @actual)
+      end
+
+      def description
+        "has #{query.description}"
+      end
+
+      def wrap(actual)
+        if actual.respond_to?("has_selector?")
+          actual
+        else
+          Capybara.string(actual.to_s)
+        end
+      end
+
+      def query
+        @query ||= Capybara::Query.new(*@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)
+        elsif(@options[:count])
+          "expected #{selector_name} to be returned #{@options[:count]} times"
+        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_text(text)
+      HaveMatcher.new(:text, text.to_s) do |page, matcher|
+        %(expected there to be text #{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,156 @@
+module Capybara
+  class Selector
+    attr_reader :name, :custom_filters
+
+
+    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
+    end
+
+    def initialize(name, &block)
+      @name = name
+      @custom_filters = {}
+      @match = nil
+      @failure_message = nil
+      instance_eval(&block)
+    end
+
+    def xpath(&block)
+      @xpath = block if block
+      @xpath
+    end
+
+    # Same as xpath, but wrap in XPath.css().
+    def css(&block)
+      if block
+        @xpath = xpath { |*args| XPath.css(block.call(*args)) }
+      end
+      @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
+
+    def filter(name, &block)
+      @custom_filters[name] = block
+    end
+  end
+end
+
+Capybara.add_selector(:xpath) do
+  xpath { |xpath| xpath }
+end
+
+Capybara.add_selector(:css) do
+  css { |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
+
+Capybara.add_selector(:field) do
+  xpath { |locator| XPath::HTML.field(locator) }
+  filter(:checked) { |node, value| not(value ^ node.checked?) }
+  filter(:unchecked) { |node, value| (value ^ node.checked?) }
+  filter(:with) { |node, with| node.value == with }
+end
+
+Capybara.add_selector(:fieldset) do
+  xpath { |locator| XPath::HTML.fieldset(locator) }
+end
+
+Capybara.add_selector(:link_or_button) do
+  xpath { |locator| XPath::HTML.link_or_button(locator) }
+  failure_message { |node, selector| "no link or button '#{selector.locator}' found" }
+end
+
+Capybara.add_selector(:link) do
+  xpath { |locator| XPath::HTML.link(locator) }
+  failure_message { |node, selector| "no link with title, id or text '#{selector.locator}' found" }
+  filter(:href) do |node, href|
+    node.first(:xpath, XPath.axis(:self)[XPath.attr(:href).equals(href)])
+  end
+end
+
+Capybara.add_selector(:button) do
+  xpath { |locator| XPath::HTML.button(locator) }
+  failure_message { |node, selector| "no button with value or id or text '#{selector.locator}' found" }
+end
+
+Capybara.add_selector(:fillable_field) do
+  xpath { |locator| XPath::HTML.fillable_field(locator) }
+  failure_message { |node, selector| "no text field, text area or password field with id, name, or label '#{selector.locator}' found" }
+end
+
+Capybara.add_selector(:radio_button) do
+  xpath { |locator| XPath::HTML.radio_button(locator) }
+  failure_message { |node, selector| "no radio button with id, name, or label '#{selector.locator}' found" }
+  filter(:checked) { |node, value| not(value ^ node.checked?) }
+  filter(:unchecked) { |node, value| (value ^ node.checked?) }
+end
+
+Capybara.add_selector(:checkbox) do
+  xpath { |locator| XPath::HTML.checkbox(locator) }
+  failure_message { |node, selector| "no checkbox with id, name, or label '#{selector.locator}' found" }
+  filter(:checked) { |node, value| not(value ^ node.checked?) }
+  filter(:unchecked) { |node, value| (value ^ node.checked?) }
+end
+
+Capybara.add_selector(:select) do
+  xpath { |locator| XPath::HTML.select(locator) }
+  failure_message { |node, selector| "no select box with id, name, or label '#{selector.locator}' found" }
+  filter(:options) { |node, options| options.all? { |option| node.first(:option, option) } }
+  filter(:selected) do |node, selected|
+    actual = node.all(:xpath, './/option').select { |option| option.selected? }.map { |option| option.text }
+    ([selected].flatten - actual).empty?
+  end
+end
+
+Capybara.add_selector(:option) do
+  xpath { |locator| XPath::HTML.option(locator) }
+  failure_message do |node, selector|
+    "no option with text '#{selector.locator}'".tap do |message|
+      message << " in the select box" if node.tag_name == 'select'
+    end
+  end
+end
+
+Capybara.add_selector(:file_field) do
+  xpath { |locator| XPath::HTML.file_field(locator) }
+  failure_message { |node, selector| "no file field with id, name, or label '#{selector.locator}' found" }
+end
+
+Capybara.add_selector(:content) do
+  xpath { |content| XPath::HTML.content(content) }
+end
+
+Capybara.add_selector(:table) do
+  xpath { |locator| XPath::HTML.table(locator) }
+end