turnip-extra_steps 0.1.0

data/lib/turnip/extra_steps/support.rb

@@ -0,0 +1,2 @@
+module Turnip::ExtraSteps::Support
+end

data/lib/turnip/extra_steps/support/custom_matchers.rb

@@ -0,0 +1,30 @@
+module Turnip::ExtraSteps::Support::CustomMatchers
+  rspec = defined?(RSpec) ? RSpec : Spec
+
+  rspec::Matchers.define :contain_with_wildcards do |expected_string|
+    match do |field_value|
+      @field_value = field_value.to_s
+      @expected_string = expected_string
+      regex_parts = expected_string.to_s.split('*', -1).collect { |part| Regexp.escape(part) }
+
+      @field_value =~ /\A#{regex_parts.join(".*")}\z/m
+    end
+
+    failure_message do
+      "The field's content #{@field_value.inspect} did not match #{@expected_string.inspect}"
+    end
+
+    failure_message_when_negated do
+      "The field's content #{@field_value.inspect} matches #{@expected_string.inspect}"
+    end
+  end
+
+  rspec::Matchers.define :be_sorted do
+  match do |array|
+    sort_method = defined?(array.natural_sort) ? :natural_sort : :sort
+
+    array == array.send(sort_method)
+  end
+end
+
+end

data/lib/turnip/extra_steps/support/mail_finder.rb

@@ -0,0 +1,59 @@
+# coding: UTF-8
+
+class MailFinder
+  class << self
+
+    attr_accessor :user_identity
+
+    def find(conditions)
+      filename_method = Rails::VERSION::MAJOR < 3 ? 'original_filename' : 'filename'
+      ActionMailer::Base.deliveries.detect do |mail|
+        mail_body = email_text_body(mail)
+        [ conditions[:to].nil? || mail.to.include?(resolve_email conditions[:to]),
+          conditions[:cc].nil? || mail.cc.andand.include?(resolve_email conditions[:cc]),
+          conditions[:bcc].nil? || mail.bcc.andand.include?(resolve_email conditions[:bcc]),
+          conditions[:from].nil? || mail.from.include?(resolve_email conditions[:from]),
+          conditions[:reply_to].nil? || mail.reply_to.include?(resolve_email conditions[:reply_to]),
+          conditions[:subject].nil? || mail.subject.include?(conditions[:subject]),
+          conditions[:body].nil? || mail_body.include?(conditions[:body]),
+          conditions[:attachments].nil? || conditions[:attachments].split(/\s*,\s*/).sort == Array(mail.attachments).collect(&:"#{filename_method}").sort
+        ].all?
+      end.tap do |mail|
+        log(mail)
+      end
+    end
+
+    def resolve_email(identity)
+      if identity =~ /^.+\@.+$/
+        identity
+      else
+        User.send("find_by_#{user_identity || 'email'}!", identity).email
+      end
+    end
+
+    def log(mail)
+      if mail.present?
+        if defined?(Rails)
+          File.open(Rails.root.join("log/test_mails.log"), "a") do |file|
+            file << "From: #{mail.from}\n"
+            file << "To: #{mail.to.join(', ')}\n" if mail.to
+            file << "Subject: #{mail.subject}\n\n"
+            file << email_text_body(mail)
+            file << "\n-------------------------\n\n"
+          end
+        end
+      end
+    end
+
+    def email_text_body(mail)
+      if mail.parts.any?
+        mail.parts.select { |part| part.content_type.include?('text/') }.collect(&:decoded).join("\n")
+      elsif mail.body.respond_to? :raw_source
+        mail.body.raw_source
+      else
+        mail.body
+      end
+    end
+
+  end
+end

data/lib/turnip/extra_steps/support/path_selector_fallbacks.rb

@@ -0,0 +1,38 @@
+# coding: UTF-8
+
+module Turnip::ExtraSteps::Support::PathSelectorFallbacks
+  def _selector_for(locator)
+    if respond_to?(:selector_for)
+      selector_for(locator)
+    elsif locator =~ /^"(.+)"$/
+      $1
+    else
+      raise "Can't find mapping from \"#{locator}\" to a selector.\n" +
+        "Add and require a selectors.rb file (compare /examples/selectors.rb)"
+    end
+  end
+
+  def _path_to(page_name)
+    if respond_to?(:path_to)
+      path_to(page_name)
+    else
+      begin
+        page_name =~ /^the (.*) page$/
+        path_components = $1.split(/\s+/)
+        self.send(path_components.push('path').join('_').to_sym)
+      rescue NoMethodError, ArgumentError
+        raise "Can't find mapping from \"#{page_name}\" to a path.\n" +
+          "Add and require a paths.rb file (compare /examples/paths.rb)"
+      end
+    end
+  end
+end
+RSpec.configure { |c| c.include Turnip::ExtraSteps::Support::PathSelectorFallbacks}
+
+module Turnip::ExtraSteps::Support::WithinHelpers
+  def with_scope(locator)
+    locator ? within(*_selector_for(locator)) { yield } : yield
+  end
+end
+RSpec.configure { |c| c.include Turnip::ExtraSteps::Support::WithinHelpers}
+

data/lib/turnip/extra_steps/support/step_fallback.rb

@@ -0,0 +1,13 @@
+# coding: UTF-8
+
+module Turnip::ExtraSteps::Support::StepFallback
+  def step(*args)
+    if defined?(super)
+      super
+    else
+      When(*args)
+    end
+  end
+end
+
+RSpec.configure { |c| c.include Turnip::ExtraSteps::Support::StepFallback}

data/lib/turnip/extra_steps/support/tolerance_for_selenium_sync_issues.rb

@@ -0,0 +1,42 @@
+# coding: UTF-8
+
+module Turnip::ExtraSteps::Support::ToleranceForSeleniumSyncIssues
+  RETRY_ERRORS = %w[
+    Capybara::ElementNotFound
+    Spec::Expectations::ExpectationNotMetError
+    RSpec::Expectations::ExpectationNotMetError
+    Minitest::Assertion
+    Capybara::Poltergeist::ClickFailed
+    Capybara::ExpectationNotMet
+    Selenium::WebDriver::Error::StaleElementReferenceError
+    Selenium::WebDriver::Error::NoAlertPresentError
+    Selenium::WebDriver::Error::ElementNotVisibleError
+    Selenium::WebDriver::Error::NoSuchFrameError
+    Selenium::WebDriver::Error::NoAlertPresentError
+  ]
+
+  # This is similiar but not entirely the same as Capybara::Node::Base#wait_until or Capybara::Session#wait_until
+  def patiently(seconds=Capybara.default_wait_time, &block)
+    old_wait_time = Capybara.default_wait_time
+    # dont make nested wait_untils use up all the alloted time
+    Capybara.default_wait_time = 0 # for we are a jealous gem
+    if page.driver.wait?
+      start_time = Time.now
+      begin
+        block.call
+      rescue Exception => e
+        raise e unless RETRY_ERRORS.include?(e.class.name)
+        raise e if (Time.now - start_time) >= seconds
+        sleep(0.05)
+        raise Capybara::FrozenInTime, "time appears to be frozen, Capybara does not work with libraries which freeze time, consider using time travelling instead" if Time.now == start_time
+        retry
+      end
+    else
+      block.call
+    end
+  ensure
+    Capybara.default_wait_time = old_wait_time
+  end
+end
+
+RSpec.configure { |c| c.include Turnip::ExtraSteps::Support::ToleranceForSeleniumSyncIssues}

data/lib/turnip/extra_steps/support/version.rb

@@ -0,0 +1,3 @@
+module Spreewald
+  VERSION = '1.2.6'
+end

data/lib/turnip/extra_steps/support/web_steps_helpers.rb

@@ -0,0 +1,114 @@
+module Turnip::ExtraSteps::Support::WebStepsHelpers
+
+  def assert_visible(options)
+    visibility_test(options.merge(:expectation => :visible))
+  end
+
+  def assert_hidden(options)
+    visibility_test(options.merge(:expectation => :hidden))
+  end
+
+  private
+
+  def visibility_test(options)
+    case Capybara::current_driver
+    when :selenium, :webkit, :poltergeist
+      detect_visibility_with_js(options)
+    else
+      detect_visibility_with_capybara(options)
+    end
+  end
+
+  def detect_visibility_with_js(options)
+    patiently do
+
+      selector_javascript = if options.has_key?(:selector)
+        options[:selector].to_json
+      else
+        "':contains(' + " + options[:text].to_json + " + ')'"
+      end
+
+      visibility_detecting_javascript = %[
+        (function() {
+          var selector = #{selector_javascript};
+          var jqueryLoaded = (typeof jQuery != 'undefined');
+
+          function findCandidates() {
+            if (jqueryLoaded) {
+              return $(selector);
+            } else {
+              return $$(selector);
+            }
+          }
+
+          function isExactCandidate(candidate) {
+            if (jqueryLoaded) {
+              return $(candidate).find(selector).length == 0;
+            } else {
+              return candidate.select(selector).length == 0;
+            }
+          }
+
+          function elementVisible(element) {
+            if (jqueryLoaded) {
+              return $(element).is(':visible');
+            } else {
+              return element.offsetWidth > 0 && element.offsetHeight > 0;
+            }
+          }
+
+          var candidates = findCandidates();
+
+          if (candidates.length == 0) {
+             throw("Selector not found in page: " + selector);
+           }
+
+          for (var i = 0; i < candidates.length; i++) {
+            var candidate = candidates[i];
+            if (isExactCandidate(candidate) && elementVisible(candidate)) {
+              return true;
+            }
+          }
+          return false;
+
+        })();
+      ]
+
+      visibility_detecting_javascript.gsub!(/\n/, ' ')
+      if options[:expectation] == :visible
+        expect(page.evaluate_script(visibility_detecting_javascript)).to be_truthy
+      else
+        expect(page.evaluate_script(visibility_detecting_javascript)).to be_falsy
+      end
+    end
+  end
+
+  def detect_visibility_with_capybara(options)
+    begin
+      old_ignore_hidden_elements = Capybara.ignore_hidden_elements
+      Capybara.ignore_hidden_elements = false
+      if options.has_key?(:selector)
+        expect(page).to have_css(options[:selector])
+        have_hidden_tag = have_css(".hidden #{options[:selector]}, .invisible #{selector_or_text}, [style~=\"display: none\"] #{options[:selector]}")
+        if options[:expectation] == :hidden
+          expect(page).to have_hidden_tag
+        else
+          expect(page).not_to have_hidden_tag
+        end
+      else
+        expect(page).to have_css('*', :text => options[:text])
+        have_hidden_text = have_css('.hidden, .invisible, [style~="display: none"]', :text => options[:text])
+        if options[:expectation] == :hidden
+          expect(page).to have_hidden_text
+        else
+          expect(page).not_to have_hidden_text
+        end
+      end
+    ensure
+      Capybara.ignore_hidden_elements = old_ignore_hidden_elements
+    end
+  end
+
+end
+
+RSpec.configure { |c| c.include Turnip::ExtraSteps::Support::WebStepsHelpers}

data/lib/turnip/extra_steps/table_steps.rb

@@ -0,0 +1,187 @@
+# coding: UTF-8
+
+require 'turnip/extra_steps/support/tolerance_for_selenium_sync_issues'
+
+module Turnip::ExtraSteps::Support::TableStepsHelper
+  module ArrayMethods
+
+    def find_row(expected_row)
+      find_index do |row|
+        expected_row.all? do |expected_column|
+          first_column = row.find_index do |column|
+            content = normalize_content(column.content)
+            expected_content = normalize_content(expected_column)
+            matching_parts = expected_content.split(/\s*\*\s*/, -1).collect { |part| Regexp.escape(part) }
+            matching_expression = /\A#{matching_parts.join(".*")}\z/
+            content =~ matching_expression
+          end
+          if first_column.nil?
+            false
+          else
+            row = row[(first_column + 1)..-1]
+            true
+          end
+        end
+      end
+    end
+
+    def normalize_content(content)
+      nbsp = " "
+      content.gsub(/[\r\n\t]+/, ' ').gsub(nbsp, ' ').gsub(/ {2,}/, ' ').strip
+    end
+
+  end
+
+  rspec = defined?(RSpec) ? RSpec : Spec
+
+  rspec::Matchers.define :contain_table do |*args|
+    match do |tables|
+      @last_unmatched_row = nil
+      @extra_rows = nil
+      @best_rows_matched = -1
+      options = args.extract_options!
+      expected_table = args.first
+      tables.any? do |table|
+        skipped_rows = []
+        rows_matched = 0
+        match = expected_table.all? do |expected_row|
+          if @best_rows_matched < rows_matched
+            @last_unmatched_row = expected_row
+            @best_rows_matched = rows_matched
+          end
+          table.extend ArrayMethods
+          first_row = table.find_row(expected_row)
+          if first_row.nil?
+            false
+          else
+            rows_matched += 1
+            if options[:unordered]
+              table.delete_at(first_row)
+            else
+              skipped_rows += table[0...first_row]
+              table = table[(first_row + 1)..-1]
+            end
+            true
+          end
+        end
+        remaining_rows = skipped_rows + table
+        if match and options[:exactly] and not remaining_rows.empty?
+          @extra_rows = remaining_rows
+          match = false
+        end
+        match
+      end
+    end
+
+    failure_message do
+      if @extra_rows
+        "Found the following extra row: #{@extra_rows.first.collect(&:content).collect(&:squish).inspect}"
+      elsif @last_unmatched_row
+        "Could not find the following row: #{@last_unmatched_row.inspect}"
+      else
+        "Could not find a table"
+      end
+    end
+
+    failure_message_when_negated do
+      "Found the complete table: #{args.first.inspect}."
+    end
+  end
+
+  def parse_table(table)
+    if table.is_a?(String)
+      table.sub!(/^\n/, '')
+      # multiline string. split it assuming a format like cucumber tables have.
+      table.split(/\n/).collect do |line|
+        line.sub!(/^\|/, '')
+        line.sub!(/\|$/, '')
+        line.gsub!(/^\ +/, '')
+        line.gsub!(/\ +$/, '')
+        line.split(/\s*\|\s*/)
+      end
+    else
+      # vanilla cucumber table.
+      table.raw
+    end
+  end
+end
+RSpec.configure { |c| c.include Turnip::ExtraSteps::Support::TableStepsHelper}
+
+
+# Check the content of tables in your HTML.
+#
+# See [this article](https://makandracards.com/makandra/763-cucumber-step-to-match-table-rows-with-capybara) for details.
+#Then /^I should( not)? see a table with (exactly )?the following rows( in any order)?:?$/ do |negate, exactly, unordered, expected_table|
+step "I :whether_to see a table with the following rows:" do |positive, expected_table|
+  patiently do
+    document = Nokogiri::HTML(page.body)
+    tables = document.xpath('//table').collect { |table| table.xpath('.//tr').collect { |row| row.xpath('.//th|td') } }
+    parsed_table = parse_table(expected_table)
+
+    options = { exactly: false , unordered: false }
+
+    if positive
+      expect(tables).to contain_table(parsed_table, options)
+      #tables.should contain_table(parsed_table, options)
+    else
+      expect(tables).not_to contain_table(parsed_table, options)
+      #tables.should_not contain_table(parsed_table, options)
+    end
+  end
+end
+
+step "I :whether_to see a table with exactly the following rows:" do |positive, expected_table|
+  patiently do
+    document = Nokogiri::HTML(page.body)
+    tables = document.xpath('//table').collect { |table| table.xpath('.//tr').collect { |row| row.xpath('.//th|td') } }
+    parsed_table = parse_table(expected_table)
+
+    options = { exactly: true, unordered: false }
+
+    if positive
+      expect(tables).to contain_table(parsed_table, options)
+      #tables.should contain_table(parsed_table, options)
+    else
+      expect(tables).not_to contain_table(parsed_table, options)
+      #tables.should_not contain_table(parsed_table, options)
+    end
+  end
+end
+
+step "I :whether_to see a table with the following rows in any order:" do |positive, expected_table|
+  patiently do
+    document = Nokogiri::HTML(page.body)
+    tables = document.xpath('//table').collect { |table| table.xpath('.//tr').collect { |row| row.xpath('.//th|td') } }
+    parsed_table = parse_table(expected_table)
+
+    options = { exactly: false, unordered: true }
+
+    if positive
+      expect(tables).to contain_table(parsed_table, options)
+      #tables.should contain_table(parsed_table, options)
+    else
+      expect(tables).not_to contain_table(parsed_table, options)
+      #tables.should_not contain_table(parsed_table, options)
+    end
+  end
+end
+
+step "I :whether_to see a table with exactly the following rows in any order:" do |positive, expected_table|
+  patiently do
+    document = Nokogiri::HTML(page.body)
+    tables = document.xpath('//table').collect { |table| table.xpath('.//tr').collect { |row| row.xpath('.//th|td') } }
+    parsed_table = parse_table(expected_table)
+
+    options = { exactly: true, unordered: true }
+
+    if positive
+      expect(tables).to contain_table(parsed_table, options)
+      #tables.should contain_table(parsed_table, options)
+    else
+      expect(tables).not_to contain_table(parsed_table, options)
+      #tables.should_not contain_table(parsed_table, options)
+    end
+  end
+end
+
+