spreewald 4.1.1 → 4.3.2

data/lib/spreewald/web_steps.rb

@@ -31,6 +31,7 @@ require 'spreewald_support/custom_matchers'
 require 'spreewald_support/web_steps_helpers'
 require 'spreewald_support/driver_info'
 require 'spreewald_support/comparison'
+require 'spreewald_support/field_errors'
 require 'uri'
 require 'cgi'
 
@@ -167,32 +168,23 @@ end.overridable
 # Checks that some text appears on the page
 #
 # Note that this does not detect if the text might be hidden via CSS
-Then /^(?:|I )should see "([^"]*)"$/ do |text|
+Then /^(?:|I )should( not)? see "([^"]*)"$/ do |negate, text|
+  expectation = negate ? :not_to : :to
+
   patiently do
-    expect(page).to have_content(text)
+    expect(page).send(expectation, have_content(text))
   end
 end.overridable
 
 # Checks that a regexp appears on the page
 #
 # Note that this does not detect if the text might be hidden via CSS
-Then /^(?:|I )should see \/(.*)\/$/ do |regexp|
+Then /^(?:|I )should( not)? see \/(.*)\/$/ do |negate, regexp|
+  expectation = negate ? :not_to : :to
   regexp = Regexp.new(regexp)
-  patiently do
-    expect(page).to have_xpath('.//descendant-or-self::*', :text => regexp)
-  end
-end.overridable
 
-Then /^(?:|I )should not see "([^"]*)"$/ do |text|
   patiently do
-    expect(page).to have_no_content(text)
-  end
-end.overridable
-
-Then /^(?:|I )should not see \/(.*)\/$/ do |regexp|
-  patiently do
-    regexp = Regexp.new(regexp)
-    expect(page).to have_no_xpath('.//descendant-or-self::*', :text => regexp)
+    expect(page).send(expectation, have_xpath('.//descendant-or-self::*', text: regexp))
   end
 end.overridable
 
@@ -239,22 +231,20 @@ end.overridable(priority: -5) # priority lower than within
 
 # Like `Then I should see`, but with single instead of double quotes. In case
 # the expected string contains quotes as well.
-Then /^(?:|I )should see '([^']*)'$/ do |text|
+Then /^(?:|I )should( not)? see '([^']*)'$/ do |negate, text|
+  expectation = negate ? :not_to : :to
+
   patiently do
-    expect(page).to have_content(text)
+    expect(page).send(expectation, have_content(text))
   end
 end.overridable
 
 # Check that the raw HTML contains a string
-Then /^I should see "([^\"]*)" in the HTML$/ do |text|
-  patiently do
-    expect(page.body).to include(text)
-  end
-end.overridable
+Then /^I should( not)? see "([^\"]*)" in the HTML$/ do |negate, text|
+  expectation = negate ? :not_to : :to
 
-Then /^I should not see "([^\"]*)" in the HTML$/ do |text|
   patiently do
-    expect(page.body).not_to include(text)
+    expect(page.body).send(expectation, include(text))
   end
 end.overridable
 
@@ -271,7 +261,7 @@ end.overridable
 #     Then I should see the element ".panel"
 #     Then I should not see an element ".sidebar"
 #     Then I should not see the element ".sidebar"
-Then /^I should (not )?see (?:an|the) element "([^"]+)"$/ do |negate, selector|
+Then /^I should( not)? see (?:an|the) element "([^"]+)"$/ do |negate, selector|
   expectation = negate ? :not_to : :to
   patiently do
     expect(page).send(expectation, have_css(selector))
@@ -286,7 +276,7 @@ end.overridable
 #     Then I should see the element for the panel
 #     Then I should not see an element for the sidebar
 #     Then I should not see the element for the sidebar
-Then /^I should (not )?see (?:an|the) element for (.*?)$/ do |negate, locator|
+Then /^I should( not)? see (?:an|the) element for (.*?)$/ do |negate, locator|
   expectation = negate ? :not_to : :to
   selector = _selector_for(locator)
   patiently do
@@ -325,7 +315,7 @@ Then /^I should( not)? see a link labeled "([^"]*)"$/ do |negate, label|
 end.overridable
 
 # Checks that an input field contains some value (allowing * as wildcard character)
-Then /^the "([^"]*)" field should (not )?contain "([^"]*)"$/ do |label, negate, expected_string|
+Then /^the "([^"]*)" field should( not)? contain "([^"]*)"$/ do |label, negate, expected_string|
   patiently do
     field = find_with_disabled(:field, label)
     field_value = case field.tag_name
@@ -345,7 +335,7 @@ Then /^the "([^"]*)" field should (not )?contain "([^"]*)"$/ do |label, negate,
 end.overridable
 
 # Checks that a multiline textarea contains some value (allowing * as wildcard character)
-Then(/^the "(.*?)" field should (not )?contain:$/) do |label, negate, expected_string|
+Then(/^the "(.*?)" field should( not)? contain:$/) do |label, negate, expected_string|
   patiently do
     field = find_with_disabled(:field, label)
     expect(field.value.chomp).send(negate ? :not_to : :to, contain_with_wildcards(expected_string))
@@ -370,17 +360,28 @@ end.overridable
 Then /^the "([^"]*)" field should have the error "([^"]*)"$/ do |field, error_message|
   patiently do
     element = find_with_disabled(:field, field)
-    classes = element.find(:xpath, '..')[:class].split(' ')
+    field_error_finder = Spreewald::FieldErrorFinder.new(page, element)
+    expect(field_error_finder.error_present?).to eq true
 
-    form_for_input = element.find(:xpath, 'ancestor::form[1]')
-    using_formtastic = form_for_input && form_for_input.has_css?('.formtastic')
-    error_class = using_formtastic ? 'error' : 'field_with_errors'
+    if Spreewald.field_error_class
+      unless Spreewald.error_message_xpath_selector
+        raise ArgumentError, 'No XPath was specified for the custom error message element.'
+      end
+    end
 
-    expect(classes).to include(error_class)
+    error_message_element = case
+      when Spreewald.error_message_xpath_selector
+        element.find(:xpath, Spreewald.error_message_xpath_selector)
+      when field_error_finder.bootstrap3_error?
+        element.find(:xpath, 'parent::*/child::*[@class="help-block"]')
+      when field_error_finder.bootstrap45_error?
+        element.find(:xpath, 'parent::*/child::*[@class="invalid-feedback"]')
+      else
+        nil
+    end
 
-    if using_formtastic
-      error_paragraph = element.find(:xpath, '../*[@class="inline-errors"][1]')
-      expect(error_paragraph).to have_content(error_message)
+    if error_message_element
+      expect(error_message_element).to have_content(error_message)
     else
       expect(page).to have_content("#{field.titlecase} #{error_message}")
     end
@@ -390,9 +391,10 @@ end.overridable
 Then /^the "([^\"]*)" field should( not)? have an error$/ do |label, negate|
   patiently do
     expectation = negate ? :not_to : :to
-    field = find_with_disabled(:field, label)
-    expect(field[:id]).to be_present # prevent bad CSS selector if field lacks id
-    expect(page).send(expectation, have_css(".field_with_errors ##{field[:id]}"))
+    element = find_with_disabled(:field, label)
+    field_error_finder = Spreewald::FieldErrorFinder.new(page, element)
+
+    expect(field_error_finder.error_present?).public_send(expectation, (eq true))
   end
 end.overridable
 
@@ -648,18 +650,19 @@ end.overridable
 
 # Tests that an input, button, checkbox or radio button with the given label is disabled.
 Then /^the "([^\"]*)" (field|button|checkbox|radio button) should( not)? be disabled$/ do |label, kind, negate|
-  element = if kind == 'button'
-    find_with_disabled(:button, label)
-  else
-    find_with_disabled(:field, label)
-  end
+  patiently do
+    element = if kind == 'button'
+      find_with_disabled(:button, label)
+    else
+      find_with_disabled(:field, label)
+    end
 
-  if Spreewald::Comparison.compare_versions(Capybara::VERSION, :<, "2.1")
-    expect(element[:disabled]).send(negate ? :to : :not_to, eq(nil))
-  else
-    expect(!!element.disabled?).to be !negate
+    if Spreewald::Comparison.compare_versions(Capybara::VERSION, :<, "2.1")
+      expect(element[:disabled]).send(negate ? :to : :not_to, eq(nil))
+    else
+      expect(!!element.disabled?).to be !negate
+    end
   end
-
 end.overridable
 
 # Tests that a field with the given label is visible.

data/lib/spreewald.rb

@@ -1,6 +1,7 @@
 # coding: UTF-8
 
 require 'cucumber_priority'
+require "spreewald_support/field_errors"
 require "spreewald_support/version"
 require "spreewald_support/github"
 require "spreewald_support/unsupported_email_header"

data/lib/spreewald_support/field_errors.rb

@@ -0,0 +1,56 @@
+require 'spreewald_support/driver_info'
+
+module Spreewald
+  def self.field_error_class
+    self.instance_variable_get('@field_error_class')
+  end
+
+  def self.field_error_class=(error_class)
+    self.instance_variable_set('@field_error_class', error_class)
+  end
+
+  def self.error_message_xpath_selector
+    self.instance_variable_get('@error_message_xpath_selector')
+  end
+
+  # The XPath to the HTML-element that renders your validation/error message.
+  # The current node to start from is the input-field that is validated.
+  def self.error_message_xpath_selector=(message_selector)
+    self.instance_variable_set('@error_message_xpath_selector', message_selector)
+  end
+
+  class FieldErrorFinder
+    include Spreewald::DriverInfo
+
+    def initialize(page, element)
+      @page = page
+      @element = element
+    end
+
+    def error_present?
+      custom_error? || bootstrap3_error? || bootstrap45_error? || rails_error?
+    end
+
+    def custom_error?
+      Spreewald.field_error_class && @element.has_xpath?("ancestor-or-self::*[class='#{Spreewald.field_error_class}']")
+    end
+
+    def bootstrap3_error?
+      @element.has_xpath?('ancestor::div[@class="form-group has-error"]')
+    end
+
+    def bootstrap45_error?
+      element_classes = @element[:class] &.split(' ') || []
+      invalid_elements = if javascript_capable?
+        @page.all(':invalid') # Collect all invalid elements as Bootstrap 4 and 5 support client validation
+      end
+
+      element_classes.include?('is-invalid') || (invalid_elements && invalid_elements.include?(@element))
+    end
+
+    def rails_error?
+      parent_element_classes = @element.find(:xpath, '..')[:class] &.split(' ') || []
+      parent_element_classes.include?('field_with_errors')
+    end
+  end
+end

data/lib/spreewald_support/version.rb

@@ -1,3 +1,3 @@
 module Spreewald
-  VERSION = '4.1.1'
+  VERSION = '4.3.2'
 end

data/lib/steps/follow_the_link.rb

@@ -0,0 +1,63 @@
+module Spreewald
+  module Steps
+    class FollowTheLink
+      class NoVisitableLinkFound < StandardError
+        def initialize(paths, index)
+          error_message = <<~MESSAGE
+            Could not follow the #{index} link in the email.
+          MESSAGE
+          if paths&.empty?
+            error_message << "Found no link paths in the email."
+          else
+            error_message << "Found these link paths in the email: #{paths.join(', ')}"
+          end
+          super(error_message)
+        end
+      end
+
+      URL_PATTERN = %r((?:https?://[^/]+)([^"'\s]+))
+
+      def initialize(mail, index_in_words)
+        @mail = mail
+        @index_in_words = index_in_words
+      end
+
+      def run
+        index = { nil => 0, 'first' => 0, 'second' => 1, 'third' => 2 }[@index_in_words]
+
+        paths = if @mail.html_part || body_text_html?
+          search_for_links_in_html
+        else
+          search_for_links_in_plaintext
+        end
+
+        if paths[index]
+          visit_path paths[index]
+        else
+          raise NoVisitableLinkFound.new(paths, @index_in_words) unless paths[index]
+        end
+      end
+
+      private
+
+      def visit_path(path)
+        Capybara.visit(path)
+      end
+
+      def body_text_html?
+        @mail.body.to_s.include? "<html>"
+      end
+
+      def search_for_links_in_html
+        body = @mail.html_part ? @mail.html_part.body : @mail.body
+        dom = Nokogiri::HTML(body.to_s)
+        (dom / 'a[href]').map { |a| a['href'].match(URL_PATTERN) }.compact.map { |match| match[1] }
+      end
+
+      def search_for_links_in_plaintext
+        mail_body = MailFinder.email_text_body(@mail).to_s
+        mail_body.scan(URL_PATTERN).flatten(1)
+      end
+    end
+  end
+end

data/lib/steps/show_me_the_mails.rb

@@ -0,0 +1,20 @@
+require 'spreewald_support/mail_finder'
+
+module Spreewald
+  module Steps
+    class ShowMeTheMails
+      def initialize(mails, only_header = false)
+        @mails = mails
+        @only_header = only_header
+      end
+
+      def run
+        if @mails.empty?
+          puts "No emails found"
+        else
+          puts MailFinder.show_mails(@mails, @only_header)
+        end
+      end
+    end
+  end
+end

data/spec/steps/follow_the_link_spec.rb

@@ -0,0 +1,81 @@
+require "steps/follow_the_link"
+
+describe Spreewald::Steps::FollowTheLink do
+  it "raises helpful error message if no link is found" do
+    mail_without_links = Mail.new do
+      html_part do
+        body "<html><body>no link</body></html>"
+      end
+
+      text_part do
+        body "no link either"
+      end
+    end
+
+    step = ->() { Spreewald::Steps::FollowTheLink.new(mail_without_links, "first").run }
+    expect(step).to raise_error Spreewald::Steps::FollowTheLink::NoVisitableLinkFound
+  end
+
+  it "finds links in multipart html email" do
+    mail = Mail.new do
+      html_part do
+        body "<html><body><a href='https://www.example.com/abc'>a link</a><a href='https://www.example.com/def'>second link</a></body></html>"
+      end
+
+      text_part do
+        body "no link here"
+      end
+    end
+
+    step = Spreewald::Steps::FollowTheLink.new(mail, "first") 
+    expect(step).to receive(:visit_path).with("/abc")
+    step.run
+  end
+
+  it "finds the second link in a multipart html email" do
+    mail = Mail.new do
+      html_part do
+        body "<html><body><a href='https://www.example.com/abc'>a link</a><a href='https://www.example.com/def'>second link</a></body></html>"
+      end
+
+      text_part do
+        body "no link here"
+      end
+    end
+
+    step = Spreewald::Steps::FollowTheLink.new(mail, "second") 
+    expect(step).to receive(:visit_path).with("/def")
+    step.run
+  end
+
+  it "finds links in html email" do
+    mail = Mail.new do
+      text_part do
+        body "my link: https://www.example.com/abc"
+      end
+    end
+
+    step = Spreewald::Steps::FollowTheLink.new(mail, "first") 
+    expect(step).to receive(:visit_path).with("/abc")
+    step.run
+  end
+
+  it "finds links in non multipart text emails" do
+    plaintext_email = Mail.new(body: 'a link: https://www.example.com/abc')
+    step = Spreewald::Steps::FollowTheLink.new(plaintext_email, "first") 
+
+    expect(step).to receive(:visit_path).with("/abc")
+    step.run
+  end
+
+  it "finds links in non multipart html emails" do
+    html_mail = Mail.new(body: <<-HTML)
+    <html><body><a href="https://www.example.com/abc">this is a link!</a></body></html>
+    HTML
+    step = Spreewald::Steps::FollowTheLink.new(html_mail, "first") 
+
+    expect(step).to receive(:visit_path).with("/abc")
+    step.run
+  end
+end
+

data/spec/steps/show_me_the_mails_spec.rb

@@ -0,0 +1,96 @@
+require "steps/show_me_the_mails"
+
+describe Spreewald::Steps::ShowMeTheMails do
+  context "without deliveries" do
+    it "logs 'no emails found'" do
+      step = Spreewald::Steps::ShowMeTheMails.new([])
+
+      expect { step.run }.to output("No emails found\n").to_stdout
+    end
+
+    it "logs 'no emails found' with only headers enabled" do
+      step = Spreewald::Steps::ShowMeTheMails.new([], true)
+
+      expect { step.run }.to output("No emails found\n").to_stdout
+    end
+  end
+
+  context "with deliveries" do
+    it "logs the email" do
+      mail = Mail.new do
+        html_part do
+          body "<html><body>html part</body></html>"
+        end
+      end
+
+      expected_output = <<~TXT
+        E-Mail #0
+        --------------------------------------------------------------------------------
+        From: 
+        Subject: 
+        
+        html part
+        --------------------------------------------------------------------------------
+
+      TXT
+      step = Spreewald::Steps::ShowMeTheMails.new([mail])
+      expect { step.run }.to output(expected_output).to_stdout
+    end
+
+    it "logs only headers with only headers enabled" do
+      mail = Mail.new do
+        html_part do
+          body "<html><body>html part</body></html>"
+        end
+      end
+
+      expected_output = <<~TXT
+        E-Mail #0
+        --------------------------------------------------------------------------------
+        From: 
+        Subject: 
+        --------------------------------------------------------------------------------
+
+      TXT
+      step = Spreewald::Steps::ShowMeTheMails.new([mail], true)
+      expect { step.run }.to output(expected_output).to_stdout
+    end
+  end
+
+  context "with multiple deliveries" do
+    it "logs the emails" do
+      mail_one = Mail.new do
+        html_part do
+          body "<html><body>html part</body></html>"
+        end
+      end
+
+      mail_two = Mail.new do
+        html_part do
+          body "<html><body>html2 part</body></html>"
+        end
+      end
+
+      expected_output = <<~TXT
+        E-Mail #0
+        --------------------------------------------------------------------------------
+        From: 
+        Subject: 
+        
+        html part
+        --------------------------------------------------------------------------------
+
+        E-Mail #1
+        --------------------------------------------------------------------------------
+        From: 
+        Subject: 
+        
+        html2 part
+        --------------------------------------------------------------------------------
+
+      TXT
+      step = Spreewald::Steps::ShowMeTheMails.new([mail_one, mail_two])
+      expect { step.run }.to output(expected_output).to_stdout
+    end
+  end
+end

data/support/step_definition.rb

@@ -33,6 +33,11 @@ class StepDefinition
     "#{kind} #{pretty_step}"
   end
 
+  def matches_search?(search)
+    regexp = Regexp.new(search)
+    step =~ regexp || matches_without_optional_negation?(regexp)
+  end
+
   private
 
   def pretty_step
@@ -45,4 +50,10 @@ class StepDefinition
     end
   end
 
+  def matches_without_optional_negation?(regexp)
+    without_negation = step.gsub('( not)?', '').gsub('(not )?', '')
+    with_negation = step.gsub('( not)?', ' not').gsub('(not )?', 'not ')
+    with_negation =~ regexp || without_negation =~ regexp
+  end
+
 end

data/support/step_manager.rb

@@ -17,7 +17,7 @@ class StepManager
   def steps(search = nil)
     step_files.collect(&:real_steps).flatten.
       sort_by { |step| [STEP_KINDS.index(step.kind), step.to_s.downcase] }.
-      select { |definition| search.nil? or definition.step =~ Regexp.new(search) }
+      select { |definition| search.nil? || definition.matches_search?(search) }
   end
 
 private

data/tests/rails-6_capybara-3/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ../..
   specs:
-    spreewald (4.1.1)
+    spreewald (4.2.3)
       cucumber
       cucumber_priority (>= 0.3.0)
       rspec (>= 2.13.0)

data/tests/shared/app/controllers/forms_controller.rb

@@ -15,7 +15,13 @@ class FormsController < ApplicationController
   def select_fields
   end
 
-  def invalid_form
+  def invalid_rails_form
   end
 
-end
+  def invalid_bootstrap3_form
+  end
+
+  def invalid_bootstrap4_form
+  end
+
+end

data/tests/shared/app/controllers/static_pages_controller.rb

@@ -33,6 +33,9 @@ class StaticPagesController < ApplicationController
   def see_element
   end
 
+  def should_see
+  end
+
   def tab_1
   end
 

data/tests/shared/app/views/forms/invalid_bootstrap3_form.html.haml

@@ -0,0 +1,16 @@
+= form_tag do
+  .form-group.has-error
+    = label_tag 'text_control', 'A'
+    = text_field_tag 'text_control', 'Text control value'
+    .help-block 'A is invalid'
+  .form-group.has-error
+    = label_tag 'textarea_control_1', 'B'
+    = text_area_tag 'textarea_control_1', "Textarea control line 1\nTextarea control line 2\n"
+    .help-block 'B is invalid'
+  .form-group.has-error
+    = label_tag 'disabled_control', 'Disabled'
+    = text_field_tag 'disabled_control', "Disabled control value", disabled: true
+    .help-block 'Disabled is invalid'
+  .form-group
+    = label_tag 'textarea_control_2', 'C'
+    = text_area_tag 'textarea_control_2', "Textarea control line 1\nTextarea control line 2\n"

data/tests/shared/app/views/forms/invalid_bootstrap4_form.html.haml

@@ -0,0 +1,18 @@
+= form_tag do
+  .form-group
+    = label_tag 'text_control', 'A'
+    - # Client validation
+    = text_field_tag 'text_control', '', class: 'form-control', required: true
+    .invalid-feedback 'A is invalid'
+  .form-group
+    = label_tag 'textarea_control_1', 'B'
+    = text_area_tag 'textarea_control_1', '', class: 'form-control', required: true
+    .invalid-feedback 'B is invalid'
+  .form-group
+    = label_tag 'disabled_control', 'Disabled'
+    - # Server validation
+    = text_field_tag 'disabled_control', "Disabled control value", class: 'form-control is-invalid', disabled: true
+    .invalid-feedback 'Disabled is invalid'
+  .form-group
+    = label_tag 'textarea_control_2', 'C'
+    = text_area_tag 'textarea_control_2', "Textarea control line 1\nTextarea control line 2\n"

data/tests/shared/app/views/static_pages/should_see.haml

@@ -0,0 +1,7 @@
+%p Normal text
+
+%p Some text matching a regular expression
+
+%p Some text with "quotes"
+
+%p Some text in the <b>HTML</b>

data/tests/shared/config/routes.rb

@@ -23,7 +23,9 @@ Rails.application.routes.draw do
   get '/forms/form1', to: 'forms#form1'
   get '/forms/form2', to: 'forms#form2'
   get '/forms/select_fields', to: 'forms#select_fields'
-  get '/forms/invalid_form', to: 'forms#invalid_form'
+  get '/forms/invalid_rails_form', to: 'forms#invalid_rails_form'
+  get '/forms/invalid_bootstrap3_form', to: 'forms#invalid_bootstrap3_form'
+  get '/forms/invalid_bootstrap4_form', to: 'forms#invalid_bootstrap4_form'
 
   get '/iframes/iframe_1_content', to: 'iframes#iframe_1_content'
   get '/iframes/iframe_2_content', to: 'iframes#iframe_2_content'
@@ -41,6 +43,7 @@ Rails.application.routes.draw do
   get '/static_pages/session_1', to: 'static_pages#session_1'
   get '/static_pages/session_2', to: 'static_pages#session_2'
   get '/static_pages/session_3', to: 'static_pages#session_3'
+  get '/static_pages/should_see', to: 'static_pages#should_see'
   get '/static_pages/tab_1', to: 'static_pages#tab_1'
   get '/static_pages/tab_2', to: 'static_pages#tab_2'
   get '/static_pages/tab_3', to: 'static_pages#tab_3'