gardelea-email_spec 1.3.0

data/lib/email_spec/mail_ext.rb

@@ -0,0 +1,11 @@
+module EmailSpec::MailExt
+  def default_part
+    @default_part ||= html_part || text_part || self
+  end
+
+  def default_part_body
+    default_part.body
+  end
+end
+
+Mail::Message.send(:include, EmailSpec::MailExt)

data/lib/email_spec/matchers.rb

@@ -0,0 +1,257 @@
+module EmailSpec
+  module Matchers
+    class ReplyTo
+      def initialize(email)
+        @expected_reply_to = Mail::ReplyToField.new(email).addrs.first
+      end
+
+      def description
+        "have reply to as #{@expected_reply_to.address}"
+      end
+
+      def matches?(email)
+        @email = email
+        @actual_reply_to = (email.reply_to || []).first
+        !@actual_reply_to.nil? &&
+          @actual_reply_to == @expected_reply_to.address
+      end
+
+      def failure_message
+        "expected #{@email.inspect} to reply to #{@expected_reply_to.address.inspect}, but it replied to #{@actual_reply_to.inspect}"
+      end
+
+      def negative_failure_message
+        "expected #{@email.inspect} not to deliver to #{@expected_reply_to.address.inspect}, but it did"
+      end
+    end
+
+    def reply_to(email)
+      ReplyTo.new(email)
+    end
+
+    alias :have_reply_to :reply_to
+
+    class DeliverTo
+      def initialize(expected_email_addresses_or_objects_that_respond_to_email)
+        emails = expected_email_addresses_or_objects_that_respond_to_email.map do |email_or_object|
+          email_or_object.kind_of?(String) ? email_or_object : email_or_object.email
+        end
+
+        @expected_recipients = Mail::ToField.new(emails).addrs.map(&:to_s).sort
+      end
+
+      def description
+        "be delivered to #{@expected_recipients.inspect}"
+      end
+
+      def matches?(email)
+        @email = email
+        @actual_recipients = (email.header[:to].addrs || []).map(&:to_s).sort
+        @actual_recipients == @expected_recipients
+      end
+
+      def failure_message
+        "expected #{@email.inspect} to deliver to #{@expected_recipients.inspect}, but it delivered to #{@actual_recipients.inspect}"
+      end
+
+      def negative_failure_message
+        "expected #{@email.inspect} not to deliver to #{@expected_recipients.inspect}, but it did"
+      end
+    end
+
+    def deliver_to(*expected_email_addresses_or_objects_that_respond_to_email)
+      DeliverTo.new(expected_email_addresses_or_objects_that_respond_to_email.flatten)
+    end
+
+    alias :be_delivered_to :deliver_to
+
+    class DeliverFrom
+
+      def initialize(email)
+        @expected_sender = Mail::FromField.new(email).addrs.first
+      end
+
+      def description
+        "be delivered from #{@expected_sender}"
+      end
+
+      def matches?(email)
+        @email = email
+        @actual_sender = (email.header[:from].addrs || []).first
+
+        !@actual_sender.nil? &&
+          @actual_sender.to_s == @expected_sender.to_s
+      end
+
+      def failure_message
+        %(expected #{@email.inspect} to deliver from "#{@expected_sender.to_s}", but it delivered from "#{@actual_sender.to_s}")
+      end
+
+      def negative_failure_message
+        %(expected #{@email.inspect} not to deliver from "#{@expected_sender.to_s}", but it did)
+      end
+    end
+
+    def deliver_from(email)
+      DeliverFrom.new(email)
+    end
+
+    alias :be_delivered_from :deliver_from
+
+    class BccTo
+
+      def initialize(expected_email_addresses_or_objects_that_respond_to_email)
+        emails = expected_email_addresses_or_objects_that_respond_to_email.map do |email_or_object|
+          email_or_object.kind_of?(String) ? email_or_object : email_or_object.email
+        end
+
+        @expected_email_addresses = emails.sort
+      end
+
+      def description
+        "be bcc'd to #{@expected_email_addresses.inspect}"
+      end
+
+      def matches?(email)
+        @email = email
+        @actual_recipients = (Array(email.bcc) || []).sort
+        @actual_recipients == @expected_email_addresses
+      end
+
+      def failure_message
+        "expected #{@email.inspect} to bcc to #{@expected_email_addresses.inspect}, but it was bcc'd to #{@actual_recipients.inspect}"
+      end
+
+      def negative_failure_message
+        "expected #{@email.inspect} not to bcc to #{@expected_email_addresses.inspect}, but it did"
+      end
+    end
+
+    def bcc_to(*expected_email_addresses_or_objects_that_respond_to_email)
+      BccTo.new(expected_email_addresses_or_objects_that_respond_to_email.flatten)
+    end
+
+    class CcTo
+
+      def initialize(expected_email_addresses_or_objects_that_respond_to_email)
+        emails = expected_email_addresses_or_objects_that_respond_to_email.map do |email_or_object|
+          email_or_object.kind_of?(String) ? email_or_object : email_or_object.email
+        end
+
+        @expected_email_addresses = emails.sort
+      end
+
+      def description
+        "be cc'd to #{@expected_email_addresses.inspect}"
+      end
+
+      def matches?(email)
+        @email = email
+        @actual_recipients = (Array(email.cc) || []).sort
+        @actual_recipients == @expected_email_addresses
+      end
+
+      def failure_message
+        "expected #{@email.inspect} to cc to #{@expected_email_addresses.inspect}, but it was cc'd to #{@actual_recipients.inspect}"
+      end
+
+      def negative_failure_message
+        "expected #{@email.inspect} not to cc to #{@expected_email_addresses.inspect}, but it did"
+      end
+    end
+
+    def cc_to(*expected_email_addresses_or_objects_that_respond_to_email)
+      CcTo.new(expected_email_addresses_or_objects_that_respond_to_email.flatten)
+    end
+
+    RSpec::Matchers.define :have_subject do
+      match do |given|
+        given_subject = given.subject
+        expected_subject = expected.first
+        
+        if expected_subject.is_a?(String)
+          description { "have subject of #{expected_subject.inspect}" }
+          failure_message_for_should { "expected the subject to be #{expected_subject.inspect} but was #{given_subject.inspect}" }
+          failure_message_for_should_not { "expected the subject not to be #{expected_subject.inspect} but was" }
+
+          given_subject == expected_subject
+        else
+          description { "have subject matching #{expected_subject.inspect}" }
+          failure_message_for_should { "expected the subject to match #{expected_subject.inspect}, but did not.  Actual subject was: #{given_subject.inspect}" }
+          failure_message_for_should_not { "expected the subject not to match #{expected_subject.inspect} but #{given_subject.inspect} does match it." }
+
+          !!(given_subject =~ expected_subject)
+        end
+      end
+    end
+    
+    RSpec::Matchers.define :include_email_with_subject do
+      match do |given_emails|
+        expected_subject = expected.first
+        
+        if expected_subject.is_a?(String)
+          description { "include email with subject of #{expected_subject.inspect}" }
+          failure_message_for_should { "expected at least one email to have the subject #{expected_subject.inspect} but none did. Subjects were #{given_emails.map(&:subject).inspect}" }
+          failure_message_for_should_not { "expected no email with the subject #{expected_subject.inspect} but found at least one. Subjects were #{given_emails.map(&:subject).inspect}" }
+          
+          given_emails.map(&:subject).include?(expected_subject)
+        else
+          description { "include email with subject matching #{expected_subject.inspect}" }
+          failure_message_for_should { "expected at least one email to have a subject matching #{expected_subject.inspect}, but none did. Subjects were #{given_emails.map(&:subject).inspect}" }
+          failure_message_for_should_not { "expected no email to have a subject matching #{expected_subject.inspect} but found at least one. Subjects were #{given_emails.map(&:subject).inspect}" }
+          
+          !!(given_emails.any?{ |mail| mail.subject =~ expected_subject })
+        end
+      end
+    end
+
+    RSpec::Matchers.define :have_body_text do
+      match do |given|
+        expected_text = expected.first
+        
+        if expected_text.is_a?(String)
+          normalized_body = given.default_part_body.to_s.gsub(/\s+/, " ")
+          normalized_expected = expected_text.gsub(/\s+/, " ")
+          description { "have body including #{normalized_expected.inspect}" }
+          failure_message_for_should { "expected the body to contain #{normalized_expected.inspect} but was #{normalized_body.inspect}" }
+          failure_message_for_should_not { "expected the body not to contain #{normalized_expected.inspect} but was #{normalized_body.inspect}" }
+    
+          normalized_body.include?(normalized_expected)
+        else
+          given_body = given.default_part_body.to_s
+          description { "have body matching #{expected_text.inspect}" }
+          failure_message_for_should { "expected the body to match #{expected_text.inspect}, but did not.  Actual body was: #{given_body.inspect}" }
+          failure_message_for_should_not { "expected the body not to match #{expected_text.inspect} but #{given_body.inspect} does match it." }
+    
+          !!(given_body =~ expected_text)
+        end
+      end
+    end
+
+    def mail_headers_hash(email_headers)
+      email_headers.fields.inject({}) { |hash, field| hash[field.field.class::FIELD_NAME] = field.to_s; hash }
+    end
+
+    RSpec::Matchers.define :have_header do
+      match do |given|
+        given_header = given.header
+        expected_name, expected_value = *expected
+
+        if expected_value.is_a?(String)
+          description { "have header #{expected_name}: #{expected_value}" }
+
+          failure_message_for_should { "expected the headers to include '#{expected_name}: #{expected_value}' but they were #{mail_headers_hash(given_header).inspect}" }
+          failure_message_for_should_not { "expected the headers not to include '#{expected_name}: #{expected_value}' but they were #{mail_headers_hash(given_header).inspect}" }
+    
+          given_header[expected_name].to_s == expected_value
+        else
+          description { "have header #{expected_name} with value matching #{expected_value.inspect}" }
+          failure_message_for_should { "expected the headers to include '#{expected_name}' with a value matching #{expected_value.inspect} but they were #{mail_headers_hash(given_header).inspect}" }
+          failure_message_for_should_not { "expected the headers not to include '#{expected_name}' with a value matching #{expected_value.inspect} but they were #{mail_headers_hash(given_header).inspect}" }
+    
+          given_header[expected_name].to_s =~ expected_value
+        end
+      end
+    end
+  end
+end

data/lib/email_spec/test_observer.rb

@@ -0,0 +1,7 @@
+module EmailSpec
+  class TestObserver
+    def self.delivered_email(message)
+      ActionMailer::Base.deliveries << message
+    end
+  end
+end

data/lib/generators/email_spec/steps/USAGE

@@ -0,0 +1,5 @@
+Description:
+    Creates email_steps.rb in your cucumber step_definitions.
+    
+Examples:
+    `script/rails generate email_spec:steps`

data/lib/generators/email_spec/steps/steps_generator.rb

@@ -0,0 +1,14 @@
+# This generator adds email steps to the step definitions directory
+require 'rails/generators'
+
+module EmailSpec
+  class StepsGenerator < Rails::Generators::Base
+    def generate
+      copy_file 'email_steps.rb', 'features/step_definitions/email_steps.rb'
+    end
+
+    def self.source_root
+      File.join(File.dirname(__FILE__), 'templates')
+    end
+  end
+end

data/lib/generators/email_spec/steps/templates/email_steps.rb

@@ -0,0 +1,206 @@
+# Commonly used email steps
+#
+# To add your own steps make a custom_email_steps.rb
+# The provided methods are:
+#
+# last_email_address
+# reset_mailer
+# open_last_email
+# visit_in_email
+# unread_emails_for
+# mailbox_for
+# current_email
+# open_email
+# read_emails_for
+# find_email
+#
+# General form for email scenarios are:
+#   - clear the email queue (done automatically by email_spec)
+#   - execute steps that sends an email
+#   - check the user received an/no/[0-9] emails
+#   - open the email
+#   - inspect the email contents
+#   - interact with the email (e.g. click links)
+#
+# The Cucumber steps below are setup in this order.
+
+module EmailHelpers
+  def current_email_address
+    # Replace with your a way to find your current email. e.g @current_user.email
+    # last_email_address will return the last email address used by email spec to find an email.
+    # Note that last_email_address will be reset after each Scenario.
+    last_email_address || "example@example.com"
+  end
+end
+
+World(EmailHelpers)
+
+#
+# Reset the e-mail queue within a scenario.
+# This is done automatically before each scenario.
+#
+
+Given /^(?:a clear email queue|no emails have been sent)$/ do
+  reset_mailer
+end
+
+#
+# Check how many emails have been sent/received
+#
+
+Then /^(?:I|they|"([^"]*?)") should receive (an|no|\d+) emails?$/ do |address, amount|
+  unread_emails_for(address).size.should == parse_email_count(amount)
+end
+
+Then /^(?:I|they|"([^"]*?)") should have (an|no|\d+) emails?$/ do |address, amount|
+  mailbox_for(address).size.should == parse_email_count(amount)
+end
+
+Then /^(?:I|they|"([^"]*?)") should receive (an|no|\d+) emails? with subject "([^"]*?)"$/ do |address, amount, subject|
+  unread_emails_for(address).select { |m| m.subject =~ Regexp.new(Regexp.escape(subject)) }.size.should == parse_email_count(amount)
+end
+
+Then /^(?:I|they|"([^"]*?)") should receive (an|no|\d+) emails? with subject \/([^"]*?)\/$/ do |address, amount, subject|
+  unread_emails_for(address).select { |m| m.subject =~ Regexp.new(subject) }.size.should == parse_email_count(amount)
+end
+
+Then /^(?:I|they|"([^"]*?)") should receive an email with the following body:$/ do |address, expected_body|
+  open_email(address, :with_text => expected_body)
+end
+
+#
+# Accessing emails
+#
+
+# Opens the most recently received email
+When /^(?:I|they|"([^"]*?)") opens? the email$/ do |address|
+  open_email(address)
+end
+
+When /^(?:I|they|"([^"]*?)") opens? the email with subject "([^"]*?)"$/ do |address, subject|
+  open_email(address, :with_subject => subject)
+end
+
+When /^(?:I|they|"([^"]*?)") opens? the email with subject \/([^"]*?)\/$/ do |address, subject|
+  open_email(address, :with_subject => Regexp.new(subject))
+end
+
+When /^(?:I|they|"([^"]*?)") opens? the email with text "([^"]*?)"$/ do |address, text|
+  open_email(address, :with_text => text)
+end
+
+When /^(?:I|they|"([^"]*?)") opens? the email with text \/([^"]*?)\/$/ do |address, text|
+  open_email(address, :with_text => Regexp.new(text))
+end
+
+#
+# Inspect the Email Contents
+#
+
+Then /^(?:I|they) should see "([^"]*?)" in the email subject$/ do |text|
+  current_email.should have_subject(text)
+end
+
+Then /^(?:I|they) should see \/([^"]*?)\/ in the email subject$/ do |text|
+  current_email.should have_subject(Regexp.new(text))
+end
+
+Then /^(?:I|they) should see "([^"]*?)" in the email body$/ do |text|
+  current_email.default_part_body.to_s.should include(text)
+end
+
+Then /^(?:I|they) should see \/([^"]*?)\/ in the email body$/ do |text|
+  current_email.default_part_body.to_s.should =~ Regexp.new(text)
+end
+
+Then /^(?:I|they) should see the email delivered from "([^"]*?)"$/ do |text|
+  current_email.should be_delivered_from(text)
+end
+
+Then /^(?:I|they) should see "([^\"]*)" in the email "([^"]*?)" header$/ do |text, name|
+  current_email.should have_header(name, text)
+end
+
+Then /^(?:I|they) should see \/([^\"]*)\/ in the email "([^"]*?)" header$/ do |text, name|
+  current_email.should have_header(name, Regexp.new(text))
+end
+
+Then /^I should see it is a multi\-part email$/ do
+    current_email.should be_multipart
+end
+
+Then /^(?:I|they) should see "([^"]*?)" in the email html part body$/ do |text|
+    current_email.html_part.body.to_s.should include(text)
+end
+
+Then /^(?:I|they) should see "([^"]*?)" in the email text part body$/ do |text|
+    current_email.text_part.body.to_s.should include(text)
+end
+
+#
+# Inspect the Email Attachments
+#
+
+Then /^(?:I|they) should see (an|no|\d+) attachments? with the email$/ do |amount|
+  current_email_attachments.size.should == parse_email_count(amount)
+end
+
+Then /^there should be (an|no|\d+) attachments? named "([^"]*?)"$/ do |amount, filename|
+  current_email_attachments.select { |a| a.filename == filename }.size.should == parse_email_count(amount)
+end
+
+Then /^attachment (\d+) should be named "([^"]*?)"$/ do |index, filename|
+  current_email_attachments[(index.to_i - 1)].filename.should == filename
+end
+
+Then /^there should be (an|no|\d+) attachments? of type "([^"]*?)"$/ do |amount, content_type|
+  current_email_attachments.select { |a| a.content_type.include?(content_type) }.size.should == parse_email_count(amount)
+end
+
+Then /^attachment (\d+) should be of type "([^"]*?)"$/ do |index, content_type|
+  current_email_attachments[(index.to_i - 1)].content_type.should include(content_type)
+end
+
+Then /^all attachments should not be blank$/ do
+  current_email_attachments.each do |attachment|
+    attachment.read.size.should_not == 0
+  end
+end
+
+Then /^show me a list of email attachments$/ do
+  EmailSpec::EmailViewer::save_and_open_email_attachments_list(current_email)
+end
+
+#
+# Interact with Email Contents
+#
+
+When /^(?:I|they) follow "([^"]*?)" in the email$/ do |link|
+  visit_in_email(link)
+end
+
+When /^(?:I|they) click the first link in the email$/ do
+  click_first_link_in_email
+end
+
+#
+# Debugging
+# These only work with Rails and OSx ATM since EmailViewer uses RAILS_ROOT and OSx's 'open' command.
+# Patches accepted. ;)
+#
+
+Then /^save and open current email$/ do
+  EmailSpec::EmailViewer::save_and_open_email(current_email)
+end
+
+Then /^save and open all text emails$/ do
+  EmailSpec::EmailViewer::save_and_open_all_text_emails
+end
+
+Then /^save and open all html emails$/ do
+  EmailSpec::EmailViewer::save_and_open_all_html_emails
+end
+
+Then /^save and open all raw emails$/ do
+  EmailSpec::EmailViewer::save_and_open_all_raw_emails
+end