path-email_spec 0.6.2

data/lib/email_spec/address_converter.rb

@@ -0,0 +1,29 @@
+require 'singleton'
+
+module EmailSpec
+  class AddressConverter
+    include Singleton
+  
+    attr_accessor :converter
+  
+    # The block provided to conversion should convert to an email
+    # address string or return the input untouched. For example:
+    #
+    #  EmailSpec::AddressConverter.instance.conversion do |input|
+    #   if input.is_a?(User)
+    #     input.email
+    #   else
+    #     input
+    #   end
+    #  end
+    #    
+    def conversion(&block)
+      self.converter = block
+    end
+  
+    def convert(input)
+      return input unless converter
+      converter.call(input)
+    end
+  end
+end

data/lib/email_spec/background_processes.rb

@@ -0,0 +1,45 @@
+module EmailSpec
+  module BackgroundProcesses
+    module DelayedJob
+      def all_emails
+        work_off_queue
+        super
+      end
+
+      def last_email_sent
+        work_off_queue
+        super
+      end
+
+      def reset_mailer
+        work_off_queue
+        super
+      end
+
+      def mailbox_for(address)
+        work_off_queue
+        super
+      end
+
+      private
+
+      # Later versions of DelayedJob switch from using Delayed::Job to Delayed::Worker
+      # Support both versions for those who haven't upgraded yet
+      def work_off_queue
+        if defined?(Delayed::Job)
+          Delayed::Job.work_off
+        else
+          Delayed::Worker.send :public, :work_off
+          worker = Delayed::Worker.new(:max_priority => nil, :min_priority => nil, :quiet => true)
+          worker.work_off
+        end
+      end
+    end
+
+    module Compatibility
+      if defined?(Delayed) && (defined?(Delayed::Job) || defined?(Delayed::Worker))
+        include EmailSpec::BackgroundProcesses::DelayedJob
+      end
+    end
+  end
+end

data/lib/email_spec/cucumber.rb

@@ -0,0 +1,26 @@
+# require this in your env.rb file after you require cucumber/rails/world
+
+# Global Setup
+if defined?(ActionMailer)
+  unless [:activerecord, :cache].include?(ActionMailer::Base.delivery_method)
+    ActionMailer::Base.delivery_method = :test
+  end
+  ActionMailer::Base.perform_deliveries = true
+
+  Before do
+    # Scenario setup
+    case ActionMailer::Base.delivery_method
+      when :test then ActionMailer::Base.deliveries.clear
+      when :cache then ActionMailer::Base.clear_cache
+    end
+  end
+end
+
+After do
+  EmailSpec::EmailViewer.save_and_open_all_raw_emails if ENV['SHOW_EMAILS']
+  EmailSpec::EmailViewer.save_and_open_all_html_emails if ENV['SHOW_HTML_EMAILS']
+  EmailSpec::EmailViewer.save_and_open_all_text_emails if ENV['SHOW_TEXT_EMAILS']
+end
+
+World(EmailSpec::Helpers)
+World(EmailSpec::Matchers)

data/lib/email_spec/deliveries.rb

@@ -0,0 +1,87 @@
+module EmailSpec
+  module MailerDeliveries
+    def all_emails
+      deliveries
+    end
+
+    def last_email_sent
+      deliveries.last || raise("No email has been sent!")
+    end
+
+    def reset_mailer
+      deliveries.clear
+    end
+
+    def mailbox_for(address)
+      deliveries.select { |email|
+        (email.to && email.to.include?(address)) ||
+        (email.bcc && email.bcc.include?(address)) ||
+        (email.cc && email.cc.include?(address)) }
+    end
+
+    protected
+
+    def deliveries
+      if ActionMailer::Base.delivery_method == :cache
+        mailer.cached_deliveries
+      else
+        mailer.deliveries
+      end
+    end
+  end
+
+  module ARMailerDeliveries
+    def all_emails
+      Email.all.map{ |email| parse_to_mail(email) }
+    end
+
+    def last_email_sent
+      if email = Email.last
+        Mail.read(email.mail)
+      else
+        raise("No email has been sent!")
+      end
+    end
+
+    def reset_mailer
+      Email.delete_all
+    end
+
+    def mailbox_for(address)
+      Email.all.select { |email|
+        (email.to && email.to.include?(address)) ||
+        (email.bcc && email.bcc.include?(address)) ||
+        (email.cc && email.cc.include?(address)) }.map{ |email| parse_to_mail(email) }
+    end
+
+    def parse_to_mail(email)
+      Mail.read(email.mail)
+    end
+  end
+
+  if defined?(Pony)
+    module ::Pony
+      def self.deliveries
+        @deliveries ||= []
+      end
+
+      def self.mail(options)
+        deliveries << build_mail(options)
+      end
+    end
+  end
+
+  module Deliveries
+    if defined?(Pony)
+      def deliveries; Pony::deliveries ; end
+      include EmailSpec::MailerDeliveries
+    elsif ActionMailer::Base.delivery_method == :activerecord
+      include EmailSpec::ARMailerDeliveries
+    else
+      def mailer; ActionMailer::Base; end
+      include EmailSpec::MailerDeliveries
+    end
+    include EmailSpec::BackgroundProcesses::Compatibility
+  end
+end
+

data/lib/email_spec/email_viewer.rb

@@ -0,0 +1,87 @@
+module EmailSpec
+  class EmailViewer
+    extend Deliveries
+
+    def self.save_and_open_all_raw_emails
+      filename = tmp_email_filename
+
+      File.open(filename, "w") do |f|
+        all_emails.each do |m|
+          f.write m.to_s
+          f.write "\n" + '='*80 + "\n"
+        end
+      end
+
+      open_in_text_editor(filename)
+    end
+
+    def self.save_and_open_all_html_emails
+      all_emails.each_with_index do |m, index|
+        if m.multipart? && html_part = m.parts.detect{ |p| p.content_type == 'text/html' }
+          filename = tmp_email_filename("-#{index}.html")
+          File.open(filename, "w") do |f|
+            f.write m.parts[1].body
+          end
+          open_in_browser(filename)
+        end
+      end
+    end
+
+    def self.save_and_open_all_text_emails
+      filename = tmp_email_filename
+
+      File.open(filename, "w") do |f|
+        all_emails.each do |m|
+          if m.multipart? && text_part = m.parts.detect{ |p| p.content_type == 'text/plain' }
+            m.ordered_each{|k,v| f.write "#{k}: #{v}\n" }
+            f.write text_part.body
+          else
+            f.write m.to_s
+          end
+          f.write "\n" + '='*80 + "\n"
+        end
+      end
+
+      open_in_text_editor(filename)
+    end
+
+    def self.save_and_open_email(mail)
+      filename = tmp_email_filename
+
+      File.open(filename, "w") do |f|
+        f.write mail.to_s
+      end
+
+      open_in_text_editor(filename)
+    end
+
+    def self.save_and_open_email_attachments_list(mail)
+      filename = tmp_email_filename
+
+      File.open(filename, "w") do |f|
+        mail.attachments.each_with_index do |attachment, index|
+          info = "#{index + 1}:"
+          info += "\n\tfilename: #{attachment.original_filename}"
+          info += "\n\tcontent type: #{attachment.content_type}"
+          info += "\n\tsize: #{attachment.size}"
+          f.write info + "\n"
+        end
+      end
+
+      open_in_text_editor(filename)
+    end
+
+    # TODO: use the launchy gem for this stuff...
+    def self.open_in_text_editor(filename)
+      `open #{filename}`
+    end
+
+    def self.open_in_browser(filename)
+      `open #{filename}`
+    end
+
+    def self.tmp_email_filename(extension = '.txt')
+      "#{RAILS_ROOT}/tmp/email-#{Time.now.to_i}#{extension}"
+    end
+  end
+end

data/lib/email_spec/helpers.rb

@@ -0,0 +1,164 @@
+require 'uri'
+require 'email_spec/deliveries'
+
+module EmailSpec
+
+  module Helpers
+    include Deliveries
+
+    def visit_in_email(link_text)
+      visit(parse_email_for_link(current_email, link_text))
+    end
+
+    def click_email_link_matching(regex, email = current_email)
+      url = links_in_email(email).detect { |link| link =~ regex }
+      raise "No link found matching #{regex.inspect} in #{email.default_part_body}" unless url
+      request_uri = URI::parse(url).request_uri
+      visit request_uri
+    end
+
+    def click_first_link_in_email(email = current_email)
+      link = links_in_email(email).first
+      request_uri = URI::parse(link).request_uri
+      visit request_uri
+    end
+
+    def open_email(address, opts={})
+      set_current_email(find_email!(address, opts))
+    end
+
+    alias_method :open_email_for, :open_email
+
+    def open_last_email
+      set_current_email(last_email_sent)
+    end
+
+    def open_last_email_for(address)
+      set_current_email(mailbox_for(address).last)
+    end
+
+    def current_email(address=nil)
+      email = if address.nil? && email_spec_hash[:current_email]
+        email_spec_hash[:current_email]
+      else
+        address = convert_address(address)
+        email_spec_hash[:current_emails][address]
+      end
+      raise   RSpec::Expectations::ExpectationNotMetError, "Expected an open email but none was found. Did you forget to call open_email?" unless email
+      email
+    end
+
+    def current_email_attachments(address=nil)
+      current_email(address).attachments || Array.new
+    end
+
+    def unread_emails_for(address)
+      mailbox_for(address) - read_emails_for(address)
+    end
+
+    def read_emails_for(address)
+      email_spec_hash[:read_emails][convert_address(address)] ||= []
+    end
+
+    def find_email(address, opts={})
+      address = convert_address(address)
+      if opts[:with_subject]
+        mailbox_for(address).find { |m| m.subject =~ Regexp.new(opts[:with_subject]) }
+      elsif opts[:with_text]
+        mailbox_for(address).find { |m| m.default_part_body =~ Regexp.new(opts[:with_text]) }
+      else
+        mailbox_for(address).first
+      end
+    end
+
+    def links_in_email(email)
+      URI.extract(email.default_part_body.to_s, ['http', 'https'])
+    end
+
+    private
+
+    def email_spec_hash
+      @email_spec_hash ||= {:read_emails => {}, :unread_emails => {}, :current_emails => {}, :current_email => nil}
+    end
+
+    def find_email!(address, opts={})
+      email = find_email(address, opts)
+      if email.nil?
+        error = "#{opts.keys.first.to_s.humanize unless opts.empty?} #{('"' + opts.values.first.to_s.humanize + '"') unless opts.empty?}"
+        raise   RSpec::Expectations::ExpectationNotMetError, "Could not find email #{error}. \n Found the following emails:\n\n #{all_emails.to_s}"
+       end
+      email
+    end
+
+    def set_current_email(email)
+      return unless email
+      email.to.each do |to|
+        read_emails_for(to) << email
+        email_spec_hash[:current_emails][to] = email
+      end
+      email_spec_hash[:current_email] = email
+    end
+
+    def parse_email_for_link(email, text_or_regex)
+      email.should have_body_text(text_or_regex)
+
+      url = parse_email_for_explicit_link(email, text_or_regex)
+      url ||= parse_email_for_anchor_text_link(email, text_or_regex)
+
+      raise "No link found matching #{text_or_regex.inspect} in #{email}" unless url
+      url
+    end
+
+    # e.g. confirm in http://confirm
+    def parse_email_for_explicit_link(email, regex)
+      regex = /#{Regexp.escape(regex)}/ unless regex.is_a?(Regexp)
+      url = links_in_email(email).detect { |link| link =~ regex }
+      URI::parse(url).request_uri if url
+    end
+
+    # e.g. Click here in  <a href="http://confirm">Click here</a>
+    def parse_email_for_anchor_text_link(email, link_text)
+      if textify_images(email.default_part_body) =~ %r{<a[^>]*href=['"]?([^'"]*)['"]?[^>]*?>[^<]*?#{link_text}[^<]*?</a>}
+        URI.split($1)[5..-1].compact!.join("?").gsub("&amp;", "&")
+        # sub correct ampersand after rails switches it (http://dev.rubyonrails.org/ticket/4002)
+      else
+        return nil
+      end
+    end
+
+    def textify_images(email_body)
+      email_body.to_s.gsub(%r{<img[^>]*alt=['"]?([^'"]*)['"]?[^>]*?/>}) { $1 }
+    end
+
+    def parse_email_count(amount)
+      case amount
+      when "no"
+        0
+      when "an"
+        1
+      else
+        amount.to_i
+      end
+    end
+
+    attr_reader :last_email_address
+
+    def convert_address(address)
+      @last_email_address = (address || current_email_address)
+      AddressConverter.instance.convert(@last_email_address)
+    end
+
+
+    def mailbox_for(address)
+      super(convert_address(address)) # super resides in Deliveries
+    end
+
+    def email_spec_deprecate(text)
+      puts ""
+      puts "DEPRECATION: #{text.split.join(' ')}"
+      puts ""
+    end
+
+  end
+end
+

data/lib/email_spec/matchers.rb

@@ -0,0 +1,225 @@
+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_email_addresses = emails.sort
+      end
+
+      def description
+        "be delivered to #{@expected_email_addresses.inspect}"
+      end
+
+      def matches?(email)
+        @email = email
+        @actual_recipients = (Array(email.to) || []).sort
+        @actual_recipients == @expected_email_addresses
+      end
+
+      def failure_message
+        "expected #{@email.inspect} to deliver to #{@expected_email_addresses.inspect}, but it delivered to #{@actual_recipients.inspect}"
+      end
+
+      def negative_failure_message
+        "expected #{@email.inspect} not to deliver to #{@expected_email_addresses.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.address == @expected_sender.address &&
+          @actual_sender.display_name == @expected_sender.display_name
+      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
+
+      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