gardelea-email_spec 1.3.0

data/Rakefile

@@ -0,0 +1,17 @@
+require 'rubygems'
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+begin
+  require 'cucumber/rake/task'
+  Cucumber::Rake::Task.new(:features)
+rescue LoadError
+  task :features do
+    abort "Cucumber is not available. In order to run features, you must: sudo gem install cucumber"
+  end
+end
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new
+
+task :default => [:features, :spec]

data/lib/email-spec.rb

@@ -0,0 +1 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'email_spec'))

data/lib/email_spec.rb

@@ -0,0 +1,18 @@
+unless defined?(Pony) or defined?(ActionMailer)
+  Kernel.warn("Neither Pony nor ActionMailer appear to be loaded so email-spec is requiring ActionMailer.")
+  require 'action_mailer'
+end
+
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__))) unless $LOAD_PATH.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'rspec'
+require 'mail'
+require 'email_spec/background_processes'
+require 'email_spec/deliveries'
+require 'email_spec/address_converter'
+require 'email_spec/email_viewer'
+require 'email_spec/helpers'
+require 'email_spec/matchers'
+require 'email_spec/mail_ext'
+require 'email_spec/test_observer'
+require 'email_spec/errors'

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 Delayed::Worker.instance_methods.detect{|iv| iv.to_s == "work_off" }
+          Delayed::Worker.send :public, :work_off
+          worker = Delayed::Worker.new(:max_priority => nil, :min_priority => nil, :quiet => true)
+          worker.work_off
+        else
+          Delayed::Job.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 [:test, :activerecord, :cache, :file].include?(ActionMailer::Base.delivery_method)
+    ActionMailer::Base.register_observer(EmailSpec::TestObserver)
+  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,91 @@
+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
+      if defined?(ActionMailer) && ActionMailer::Base.delivery_method == :cache
+        mailer.clear_cache
+      else
+        deliveries.clear
+      end
+    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,91 @@
+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.include?('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.include?('text/plain') }
+            if m.respond_to?(:ordered_each) # Rails 2 / TMail
+              m.ordered_each{|k,v| f.write "#{k}: #{v}\n" }
+            else # Rails 3 / Mail
+              f.write(text_part.header.to_s + "\n")
+            end
+
+            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
+
+    def self.open_in_text_editor(filename)
+      Launchy.open(URI.parse("file://#{File.expand_path(filename)}"), :application => :editor)
+    end
+
+    def self.open_in_browser(filename)
+      Launchy.open(URI.parse("file://#{File.expand_path(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/errors.rb

@@ -0,0 +1,7 @@
+module EmailSpec
+  class CouldNotFindEmailError < StandardError
+  end
+
+  class NoEmailAddressProvided < StandardError
+  end
+end

data/lib/email_spec/helpers.rb

@@ -0,0 +1,175 @@
+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
+      visit request_uri(url)
+    end
+
+    def click_first_link_in_email(email = current_email)
+      link = links_in_email(email).first
+      visit request_uri(link)
+    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)
+      address = convert_address(address)
+      email = address ? email_spec_hash[:current_emails][address] : email_spec_hash[:current_email]
+      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
+
+    # Should be able to accept String or Regexp options.
+    def find_email(address, opts={})
+      address = convert_address(address)
+      if opts[:with_subject]
+        expected_subject = (opts[:with_subject].is_a?(String) ? Regexp.escape(opts[:with_subject]) : opts[:with_subject])
+        mailbox_for(address).find { |m| m.subject =~ Regexp.new(expected_subject) }
+      elsif opts[:with_text]
+        expected_text = (opts[:with_text].is_a?(String) ? Regexp.escape(opts[:with_text]) : opts[:with_text])
+        mailbox_for(address).find { |m| m.default_part_body =~ Regexp.new(expected_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 current_email_address.nil?
+        raise EmailSpec::NoEmailAddressProvided, "No email address has been provided. Make sure current_email_address is returning something."  
+      elsif email.nil?
+        error = "#{opts.keys.first.to_s.humanize.downcase unless opts.empty?} #{('"' + opts.values.first.to_s + '"') unless opts.empty?}"
+        raise EmailSpec::CouldNotFindEmailError, "Could not find email #{error} in the mailbox for #{current_email_address}. \n Found the following emails:\n\n #{all_emails.to_s}"
+       end
+      email
+    end
+
+    def set_current_email(email)
+      return unless email
+      [email.to, email.cc, email.bcc].compact.flatten.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
+
+    def request_uri(link)
+      return unless link
+      url = URI::parse(link)
+      url.fragment ? (url.request_uri + "#" + url.fragment) : url.request_uri
+    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 }
+      request_uri(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
+
+    # Overwrite this method to set default email address, for example:
+    # last_email_address || @current_user.email
+    def current_email_address
+      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
+