casecumber-rails 1.0.2.1

data/lib/cucumber/rails/world.rb

@@ -0,0 +1,26 @@
+begin
+  # Try to load it so we can assign @_result below if needed.
+  require 'test/unit/testresult'
+rescue LoadError => ignore
+end
+
+module Cucumber #:nodoc:
+  module Rails #:nodoc:
+    class World < ActionController::IntegrationTest #:nodoc:
+      include Rack::Test::Methods
+      include ActiveSupport::Testing::SetupAndTeardown if ActiveSupport::Testing.const_defined?("SetupAndTeardown")
+
+      def initialize #:nodoc:
+        @_result = Test::Unit::TestResult.new if defined?(Test::Unit::TestResult)
+      end
+
+      if !defined?(ActiveRecord::Base)
+        def self.fixture_table_names; []; end # Workaround for projects that don't use ActiveRecord
+      end
+    end
+  end
+end
+
+World do
+  Cucumber::Rails::World.new
+end

data/lib/cucumber/web/tableish.rb

@@ -0,0 +1,118 @@
+require 'nokogiri'
+
+module Cucumber
+  module Web
+    module Tableish
+      # This method returns an Array of Array of String, using CSS3 selectors.
+      # This is particularly handy when using Cucumber's Table#diff! method.
+      #
+      # The +row_selector+ argument must be a String, and picks out all the rows
+      # from the web page's DOM. If the number of cells in each row differs, it
+      # will be constrained by (or padded with) the number of cells in the first row
+      #
+      # The +column_selectors+ argument must be a String or a Proc, picking out
+      # cells from each row. If you pass a Proc, it will be yielded an instance
+      # of Nokogiri::HTML::Element.
+      #
+      # == Example with a table
+      #
+      #   <table id="tools">
+      #     <tr>
+      #       <th>tool</th>
+      #       <th>dude</th>
+      #     </tr>
+      #     <tr>
+      #       <td>webrat</td>
+      #       <td>bryan</td>
+      #     </tr>
+      #     <tr>
+      #       <td>cucumber</td>
+      #       <td>aslak</td>
+      #     </tr>
+      #   </table>
+      #
+      #   t = tableish('table#tools tr', 'td,th')
+      #
+      # == Example with a dl
+      #
+      #   <dl id="tools">
+      #     <dt>webrat</dt>
+      #     <dd>bryan</dd>
+      #     <dt>cucumber</dt>
+      #     <dd>aslak</dd>
+      #   </dl>
+      #
+      #   t = tableish('dl#tools dt', lambda{|dt| [dt, dt.next.next]})
+      #
+      def tableish(row_selector, column_selectors)
+        html = defined?(Capybara) ? body : response_body
+        _tableish(html, row_selector, column_selectors)
+      end
+
+      def _tableish(html, row_selector, column_selectors) #:nodoc
+        doc = Nokogiri::HTML(html)
+        spans = nil
+        max_cols = 0
+
+        # Parse the table.
+        rows = doc.search(row_selector).map do |row|
+          cells = case(column_selectors)
+          when String
+            row.search(column_selectors)
+          when Proc
+            column_selectors.call(row)
+          end
+
+          # TODO: max_cols should be sum of colspans
+          max_cols = [max_cols, cells.length].max
+
+          spans ||= Array.new(max_cols, 1)
+
+          cell_index = 0
+
+          cells = (0...spans.length).inject([]) do |array, n|
+            span = spans[n]
+
+            cell = if span > 1
+              row_span, col_span = 1, 1
+              nil
+            else
+              cell = cells[cell_index]
+
+              row_span, col_span = _parse_spans(cell)
+
+              if col_span > 1
+                ((n + 1)...(n + col_span)).each do |m|
+                  spans[m] = row_span + 1
+                end
+              end
+
+              cell_index +=1
+              cell
+            end
+
+            spans[n] = row_span > 1 ? row_span : ([span - 1, 1].max)
+
+            array << case cell
+              when String then cell.strip
+              when nil then ''
+              else cell.text.strip
+            end
+
+            array
+          end
+
+          cells
+        end
+      end
+
+      def _parse_spans(cell)
+        cell.is_a?(Nokogiri::XML::Node) ?
+          [cell.attributes['rowspan'].to_s.to_i || 1, cell.attributes['colspan'].to_s.to_i || 1] :
+          [1, 1]
+      end
+    end
+  end
+end
+
+World(Cucumber::Web::Tableish)

data/lib/generators/cucumber/feature/USAGE

@@ -0,0 +1,16 @@
+Description:
+    Generates a skeleton for a new feature. Both a simple .feature file and
+    a steps.rb file is generated. This generator should be used with moderation.
+    See http://github.com/aslakhellesoy/cucumber/wikis/feature-coupled-steps-antipattern
+    for details about the dangers involved.
+
+    This generator can take an optional list of attribute pairs similar to Rails'
+    built-in resource generator.
+
+Examples (Rails 3):
+    `script/rails generate cucumber:feature post` # no attributes
+    `script/rails generate cucumber:feature post title:string body:text published:boolean`
+
+Examples (Rails 2):
+    `script/generate feature post` # no attributes
+    `script/generate feature post title:string body:text published:boolean`

data/lib/generators/cucumber/feature/feature_generator.rb

@@ -0,0 +1,28 @@
+require File.join(File.dirname(__FILE__), 'named_arg')
+
+module Cucumber
+  class FeatureGenerator < ::Rails::Generators::NamedBase
+    source_root File.expand_path("../templates", __FILE__)
+
+    argument :fields, :optional => true, :type => :array, :banner => "[field:type, field:type]"
+
+    attr_reader :named_args
+  
+    def parse_fields
+      @named_args = @fields.nil? ? [] : @fields.map { |arg| NamedArg.new(arg) }
+    end    
+
+    def generate
+      empty_directory 'features/step_definitions'
+      template 'feature.erb', "features/manage_#{plural_name}.feature"
+      template 'steps.erb', "features/step_definitions/#{singular_name}_steps.rb"
+      gsub_file 'features/support/paths.rb', /'\/'/mi do |match|
+        "#{match}\n    when /the new #{singular_name} page/\n      new_#{singular_name}_path\n"
+      end
+    end
+  
+    def self.banner
+      "#{$0} cucumber:feature ModelName [field:type, field:type]"
+    end
+  end
+end

data/lib/generators/cucumber/feature/named_arg.rb

@@ -0,0 +1,19 @@
+class NamedArg
+  attr_reader :name
+  attr_reader :type
+
+  def initialize(s)
+    @name, @type = *s.split(':')
+  end
+
+  def value(n)
+    if @type == 'boolean'
+      (n % 2) == 0
+    elsif @type == 'integer'
+      n
+    else
+      "#{@name} #{n}"
+    end
+  end
+end
+

data/lib/generators/cucumber/feature/templates/feature.erb

@@ -0,0 +1,63 @@
+Feature: Manage <%= plural_name %>
+  In order to [goal]
+  [stakeholder]
+  wants [behaviour]
+  
+  Scenario: Register new <%= singular_name %>
+    Given I am on the new <%= singular_name %> page
+<% keyword = 'When' -%>
+<% named_args.each do |arg| -%>
+<% if arg.type == 'boolean' -%>
+    <%= keyword %> I uncheck "<%= arg.name.humanize %>"
+<% else -%>
+    <%= keyword %> I fill in "<%= arg.name.humanize %>" with "<%= arg.value(1) %>"
+<% end -%>
+<% keyword = 'And' -%>
+<% end -%>
+    And I press "Create"
+<% keyword = 'Then' -%>
+<% named_args.each do |arg| -%>
+    <%= keyword %> I should see "<%= arg.value(1) %>"
+<% keyword = 'And' -%>
+<% end -%>
+
+<% if IO.read('features/support/env.rb') =~ /capybara/n -%>
+  # Rails generates Delete links that use Javascript to pop up a confirmation
+  # dialog and then do a HTTP POST request (emulated DELETE request).
+  #
+  # Capybara must use Culerity/Celerity or Selenium2 (webdriver) when pages rely
+  # on Javascript events. Only Culerity/Celerity supports clicking on confirmation
+  # dialogs.
+  #
+  # Since Culerity/Celerity and Selenium2 has some overhead, Cucumber-Rails will
+  # detect the presence of Javascript behind Delete links and issue a DELETE request 
+  # instead of a GET request.
+  #
+  # You can turn this emulation off by tagging your scenario with @no-js-emulation.
+  # Turning on browser testing with @selenium, @culerity, @celerity or @javascript
+  # will also turn off the emulation. (See the Capybara documentation for 
+  # details about those tags). If any of the browser tags are present, Cucumber-Rails
+  # will also turn off transactions and clean the database with DatabaseCleaner 
+  # after the scenario has finished. This is to prevent data from leaking into 
+  # the next scenario.
+  #
+  # Another way to avoid Cucumber-Rails' javascript emulation without using any
+  # of the tags above is to modify your views to use <button> instead. You can
+  # see how in http://github.com/jnicklas/capybara/issues#issue/12
+  #
+<% if options[:capybara] -%>
+  @<%= options[:capybara] %>  
+<% end -%>
+<% end -%>
+  Scenario: Delete <%= singular_name %>
+    Given the following <%= plural_name %>:
+      |<%= named_args.map(&:name).join('|') %>|
+<% (1..4).each do |n| -%>
+      |<%= named_args.map{|arg| arg.value(n)}.join('|') %>|
+<% end -%>
+    When I delete the 3rd <%= singular_name %>
+    Then I should see the following <%= plural_name %>:
+      |<%= named_args.map{|arg| arg.name.humanize}.join('|') %>|
+<% [1,2,4].each do |n| -%>
+      |<%= named_args.map{|arg| arg.value(n)}.join('|') %>|
+<% end -%>

data/lib/generators/cucumber/feature/templates/steps.erb

@@ -0,0 +1,14 @@
+Given /^the following <%= plural_name %>:$/ do |<%= plural_name %>|
+  <%= class_name %>.create!(<%= plural_name %>.hashes)
+end
+
+When /^I delete the (\d+)(?:st|nd|rd|th) <%= singular_name %>$/ do |pos|
+  visit <%= plural_name %>_path
+  within("table tr:nth-child(#{pos.to_i+1})") do
+    click_link "Destroy"
+  end
+end
+
+Then /^I should see the following <%= plural_name %>:$/ do |expected_<%= plural_name %>_table|
+  expected_<%= plural_name %>_table.diff!(tableish('table tr', 'td,th'))
+end

data/lib/generators/cucumber/install/USAGE

@@ -0,0 +1,15 @@
+Description:
+    Sets up Cucumber in your Rails project. After running this generator you will
+    get a new rake task called features.
+    
+    This also generates the necessary files in the features directory.
+    
+    Also see the cucumber:feature generator.
+    
+Examples:
+    `rails generate cucumber:install`
+
+    `rails generate cucumber:install --help`
+
+    You can also provide a language argument for localized web_steps:
+    `rails generate cucumber:install de`

data/lib/generators/cucumber/install/install_generator.rb

@@ -0,0 +1,88 @@
+require 'rbconfig'
+
+module Cucumber
+  class InstallGenerator < ::Rails::Generators::Base
+    source_root File.expand_path("../templates", __FILE__)
+
+    DEFAULT_SHEBANG = File.join(Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name'])
+
+    argument     :language,      :type => :string,  :banner => "LANG", :optional => true
+
+    class_option :rspec,         :type => :boolean, :desc => "Use RSpec"
+    class_option :testunit,      :type => :boolean, :desc => "Use Test::Unit"
+    class_option :spork,         :type => :boolean, :desc => "Use Spork"
+    class_option :skip_database, :type => :boolean, :desc => "Skip modification of database.yml", :aliases => '-D', :default => false
+
+    attr_reader :framework
+
+    def create_templates
+      template 'config/cucumber.yml.erb', 'config/cucumber.yml'
+    end
+
+    def create_scripts
+      copy_file 'script/cucumber', 'script/cucumber'
+      chmod     'script/cucumber', 0755
+    end
+
+    def create_step_definitions
+      empty_directory 'features/step_definitions'
+
+      template "step_definitions/web_steps.rb.erb", 'features/step_definitions/web_steps.rb'
+      if language
+        template "step_definitions/web_steps_#{language}.rb.erb", "features/step_definitions/web_steps_#{language}.rb"
+      end
+    end
+
+    def create_feature_support
+      empty_directory 'features/support'
+      copy_file       'support/paths.rb',     'features/support/paths.rb'
+      copy_file       'support/selectors.rb', 'features/support/selectors.rb'
+
+      if spork?
+        template 'support/rails_spork.rb.erb', 'features/support/env.rb'
+      else
+        template 'support/rails.rb.erb',       'features/support/env.rb'
+      end
+    end
+
+    def create_tasks
+      empty_directory 'lib/tasks'
+      template 'tasks/cucumber.rake.erb', 'lib/tasks/cucumber.rake'
+    end
+
+    def create_database
+      return unless File.exist?('config/database.yml')
+      unless File.read('config/database.yml').include? 'cucumber:'
+        gsub_file 'config/database.yml', /^test:.*\n/, "test: &test\n"
+        gsub_file 'config/database.yml', /\z/, "\ncucumber:\n  <<: *test"
+        
+        # Since gsub_file doesn't ask the user, just inform user that the file was overwritten.
+        puts "       force  config/database.yml"
+      end
+    end
+
+    protected
+
+    def spork?
+      options[:spork]
+    end
+
+    def embed_file(source, indent='')
+      IO.read(File.join(self.class.source_root, source)).gsub(/^/, indent)
+    end
+
+    def embed_template(source, indent='')
+      template = File.join(self.class.source_root, source)
+      ERB.new(IO.read(template), nil, '-').result(binding).gsub(/^/, indent)
+    end
+
+    private
+
+    def framework_from_options
+      return 'rspec-rails' if options[:rspec]
+      return 'testunit' if options[:testunit]
+      return 'rspec-rails'
+    end
+
+  end
+end

data/lib/generators/cucumber/install/templates/config/cucumber.yml.erb

@@ -0,0 +1,8 @@
+<%%
+rerun = File.file?('rerun.txt') ? IO.read('rerun.txt') : ""
+rerun_opts = rerun.to_s.strip.empty? ? "--format #{ENV['CUCUMBER_FORMAT'] || 'progress'} features" : "--format #{ENV['CUCUMBER_FORMAT'] || 'pretty'} #{rerun}"
+std_opts = "--format #{ENV['CUCUMBER_FORMAT'] || 'pretty'} --strict --tags ~@wip"
+%>
+default: <%= spork? ? '--drb ' : '' %><%%= std_opts %> features
+wip: <%= spork? ? '--drb ' : '' %>--tags @wip:3 --wip features
+rerun: <%= spork? ? '--drb ' : '' %><%%= rerun_opts %> --format rerun --out rerun.txt --strict --tags ~@wip

data/lib/generators/cucumber/install/templates/script/cucumber

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+vendored_cucumber_bin = Dir["#{File.dirname(__FILE__)}/../vendor/{gems,plugins}/cucumber*/bin/cucumber"].first
+if vendored_cucumber_bin
+  load File.expand_path(vendored_cucumber_bin)
+else
+  require 'rubygems' unless ENV['NO_RUBYGEMS']
+  require 'cucumber'
+  load Cucumber::BINARY
+end

data/lib/generators/cucumber/install/templates/step_definitions/web_steps.rb.erb

@@ -0,0 +1,192 @@
+<%= embed_file('support/web_steps_warning.txt') %>
+
+require 'uri'
+require 'cgi'
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "support", "paths"))
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "support", "selectors"))
+
+module WithinHelpers
+  def with_scope(locator)
+    locator ? within(*selector_for(locator)) { yield } : yield
+  end
+end
+World(WithinHelpers)
+
+# Single-line step scoper
+When /^(.*) within (.*[^:])$/ do |step, parent|
+  with_scope(parent) { When step }
+end
+
+# Multi-line step scoper
+When /^(.*) within (.*[^:]):$/ do |step, parent, table_or_string|
+  with_scope(parent) { When "#{step}:", table_or_string }
+end
+
+Given /^(?:|I )am on (.+)$/ do |page_name|
+  visit path_to(page_name)
+end
+
+When /^(?:|I )go to (.+)$/ do |page_name|
+  visit path_to(page_name)
+end
+
+When /^(?:|I )press "([^"]*)"$/ do |button|
+  click_button(button)
+end
+
+When /^(?:|I )follow "([^"]*)"$/ do |link|
+  click_link(link)
+end
+
+When /^(?:|I )fill in "([^"]*)" with "([^"]*)"$/ do |field, value|
+  fill_in(field, :with => value)
+end
+
+When /^(?:|I )fill in "([^"]*)" for "([^"]*)"$/ do |value, field|
+  fill_in(field, :with => value)
+end
+
+# Use this to fill in an entire form with data from a table. Example:
+#
+#   When I fill in the following:
+#     | Account Number | 5002       |
+#     | Expiry date    | 2009-11-01 |
+#     | Note           | Nice guy   |
+#     | Wants Email?   |            |
+#
+# TODO: Add support for checkbox, select og option
+# based on naming conventions.
+#
+When /^(?:|I )fill in the following:$/ do |fields|
+  fields.rows_hash.each do |name, value|
+    When %{I fill in "#{name}" with "#{value}"}
+  end
+end
+
+When /^(?:|I )select "([^"]*)" from "([^"]*)"$/ do |value, field|
+  select(value, :from => field)
+end
+
+When /^(?:|I )check "([^"]*)"$/ do |field|
+  check(field)
+end
+
+When /^(?:|I )uncheck "([^"]*)"$/ do |field|
+  uncheck(field)
+end
+
+When /^(?:|I )choose "([^"]*)"$/ do |field|
+  choose(field)
+end
+
+When /^(?:|I )attach the file "([^"]*)" to "([^"]*)"$/ do |path, field|
+  attach_file(field, File.expand_path(path))
+end
+
+Then /^(?:|I )should see "([^"]*)"$/ do |text|
+  if page.respond_to? :should
+    page.should have_content(text)
+  else
+    assert page.has_content?(text)
+  end
+end
+
+Then /^(?:|I )should see \/([^\/]*)\/$/ do |regexp|
+  regexp = Regexp.new(regexp)
+
+  if page.respond_to? :should
+    page.should have_xpath('//*', :text => regexp)
+  else
+    assert page.has_xpath?('//*', :text => regexp)
+  end
+end
+
+Then /^(?:|I )should not see "([^"]*)"$/ do |text|
+  if page.respond_to? :should
+    page.should have_no_content(text)
+  else
+    assert page.has_no_content?(text)
+  end
+end
+
+Then /^(?:|I )should not see \/([^\/]*)\/$/ do |regexp|
+  regexp = Regexp.new(regexp)
+
+  if page.respond_to? :should
+    page.should have_no_xpath('//*', :text => regexp)
+  else
+    assert page.has_no_xpath?('//*', :text => regexp)
+  end
+end
+
+Then /^the "([^"]*)" field(?: within (.*))? should contain "([^"]*)"$/ do |field, parent, value|
+  with_scope(parent) do
+    field = find_field(field)
+    field_value = (field.tag_name == 'textarea') ? field.text : field.value
+    if field_value.respond_to? :should
+      field_value.should =~ /#{value}/
+    else
+      assert_match(/#{value}/, field_value)
+    end
+  end
+end
+
+Then /^the "([^"]*)" field(?: within (.*))? should not contain "([^"]*)"$/ do |field, parent, value|
+  with_scope(parent) do
+    field = find_field(field)
+    field_value = (field.tag_name == 'textarea') ? field.text : field.value
+    if field_value.respond_to? :should_not
+      field_value.should_not =~ /#{value}/
+    else
+      assert_no_match(/#{value}/, field_value)
+    end
+  end
+end
+
+Then /^the "([^"]*)" checkbox(?: within (.*))? should be checked$/ do |label, parent|
+  with_scope(parent) do
+    field_checked = find_field(label)['checked']
+    if field_checked.respond_to? :should
+      field_checked.should be_true
+    else
+      assert field_checked
+    end
+  end
+end
+
+Then /^the "([^"]*)" checkbox(?: within (.*))? should not be checked$/ do |label, parent|
+  with_scope(parent) do
+    field_checked = find_field(label)['checked']
+    if field_checked.respond_to? :should
+      field_checked.should be_false
+    else
+      assert !field_checked
+    end
+  end
+end
+ 
+Then /^(?:|I )should be on (.+)$/ do |page_name|
+  current_path = URI.parse(current_url).path
+  if current_path.respond_to? :should
+    current_path.should == path_to(page_name)
+  else
+    assert_equal path_to(page_name), current_path
+  end
+end
+
+Then /^(?:|I )should have the following query string:$/ do |expected_pairs|
+  query = URI.parse(current_url).query
+  actual_params = query ? CGI.parse(query) : {}
+  expected_params = {}
+  expected_pairs.rows_hash.each_pair{|k,v| expected_params[k] = v.split(',')} 
+  
+  if actual_params.respond_to? :should
+    actual_params.should == expected_params
+  else
+    assert_equal expected_params, actual_params
+  end
+end
+
+Then /^show me the page$/ do
+  save_and_open_page
+end