path-email_spec 0.6.2

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,194 @@
+# 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(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 text "([^"]*?)"$/ do |address, text|
+  open_email(address, :with_text => 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.multipart?.should == true
+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

data/rails_generators/email_spec/email_spec_generator.rb

@@ -0,0 +1,17 @@
+# This generator adds email steps to the step definitions directory 
+generator_base = defined?(Rails) ? Rails::Generator::Base : RubiGen::Base
+class EmailSpecGenerator < generator_base
+  def manifest
+    record do |m|
+      m.directory 'features/step_definitions'
+      m.file      'email_steps.rb', 'features/step_definitions/email_steps.rb'
+    end
+  end
+
+protected
+
+  def banner
+    "Usage: #{$0} email_spec"
+  end
+
+end

data/rails_generators/email_spec/templates/email_steps.rb

@@ -0,0 +1,182 @@
+# 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(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 text "([^"]*?)"$/ do |address, text|
+  open_email(address, :with_text => 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.body.should include(text)
+end
+
+Then /^(?:I|they) should see \/([^"]*?)\/ in the email body$/ do |text|
+  current_email.body.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
+
+#
+# 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.original_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)].original_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 == 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 == content_type
+end
+
+Then /^all attachments should not be blank$/ do
+  current_email_attachments.each do |attachment|
+    attachment.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

data/spec/email_spec/helpers_spec.rb

@@ -0,0 +1,21 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe EmailSpec::Helpers do
+  include EmailSpec::Helpers
+  describe "#parse_email_for_link" do
+    it "properly finds links with text" do
+      email = Mail.new(:body =>  %(<a href="/path/to/page">Click Here</a>))
+      parse_email_for_link(email, "Click Here").should == "/path/to/page"
+    end
+
+    it "recognizes img alt properties as text" do
+      email = Mail.new(:body => %(<a href="/path/to/page"><img src="http://host.com/images/image.gif" alt="an image" /></a>))
+      parse_email_for_link(email, "an image").should == "/path/to/page"
+    end
+
+    it "causes a spec to fail if the body doesn't contain the text specified to click" do
+      email = Mail.new(:body => "")
+      lambda { parse_email_for_link(email, "non-existent text") }.should raise_error(  RSpec::Expectations::ExpectationNotMetError)
+    end
+  end
+end

data/spec/email_spec/matchers_spec.rb

@@ -0,0 +1,430 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe EmailSpec::Matchers do
+  include EmailSpec::Matchers
+
+  class MatcherMatch
+    def initialize(object_to_test_match)
+      @object_to_test_match = object_to_test_match
+    end
+
+    def description
+      "match when provided #{@object_to_test_match.inspect}"
+    end
+
+    def matches?(matcher)
+      @matcher = matcher
+      matcher.matches?(@object_to_test_match)
+    end
+
+    def failure_message
+      "expected #{@matcher.inspect} to match when provided #{@object_to_test_match.inspect}, but it did not"
+    end
+
+    def negative_failure_message
+      "expected #{@matcher.inspect} not to match when provided #{@object_to_test_match.inspect}, but it did"
+    end
+  end
+
+  def match(object_to_test_match)
+    if object_to_test_match.is_a?(Regexp)
+      super # delegate to rspec's built in 'match' matcher
+    else
+      MatcherMatch.new(object_to_test_match)
+    end
+  end
+
+  describe "#reply_to" do
+    it "should match when the email is set to deliver to the specified address" do
+      email = Mail::Message.new(:reply_to => ["test@gmail.com"])
+      reply_to("test@gmail.com").should match(email)
+    end
+
+    it "should match given a name and address" do
+      email = Mail::Message.new(:reply_to => ["test@gmail.com"])
+      reply_to("David Balatero <test@gmail.com>").should match(email)
+    end
+
+    it "should give correct failure message when the email is not set to deliver to the specified address" do
+      matcher = reply_to("jimmy_bean@yahoo.com")
+      matcher.matches?(Mail::Message.new(:reply_to => ['freddy_noe@yahoo.com']).with_inspect_stub)
+      matcher.failure_message.should == %{expected email to reply to "jimmy_bean@yahoo.com", but it replied to "freddy_noe@yahoo.com"}
+    end
+
+  end
+
+  describe "#deliver_to" do
+    it "should match when the email is set to deliver to the specidied address" do
+      email = Mail::Message.new(:to => "jimmy_bean@yahoo.com")
+
+      deliver_to("jimmy_bean@yahoo.com").should match(email)
+    end
+
+    it "should match when a list of emails is exact same as all of the email's recipients" do
+      email = Mail::Message.new(:to => ["james@yahoo.com", "karen@yahoo.com"])
+
+      deliver_to("karen@yahoo.com", "james@yahoo.com").should match(email)
+      deliver_to("karen@yahoo.com").should_not match(email)
+    end
+
+    it "should match when an array of emails is exact same as all of the email's recipients" do
+      addresses = ["james@yahoo.com", "karen@yahoo.com"]
+      email = Mail::Message.new(:to => addresses)
+      deliver_to(addresses).should match(email)
+    end
+
+    it "should use the passed in objects :email method if not a string" do
+      email = Mail::Message.new(:to => "jimmy_bean@yahoo.com")
+      user = mock("user", :email => "jimmy_bean@yahoo.com")
+
+      deliver_to(user).should match(email)
+    end
+
+    it "should give correct failure message when the email is not set to deliver to the specified address" do
+      matcher = deliver_to("jimmy_bean@yahoo.com")
+      message = Mail::Message.new(:to => 'freddy_noe@yahoo.com')
+      message.stub(:inspect).and_return("email")
+      matcher.matches?(message)
+      matcher.failure_message.should == %{expected email to deliver to ["jimmy_bean@yahoo.com"], but it delivered to ["freddy_noe@yahoo.com"]}
+    end
+
+  end
+
+  describe "#deliver_from" do
+    it "should match when the email is set to deliver from the specified address" do
+      email = Mail::Message.new(:from => "jimmy_bean@yahoo.com")
+      deliver_from("jimmy_bean@yahoo.com").should match(email)
+    end
+
+    it "should match when the email is set to deliver from the specified name and address" do
+      email = Mail::Message.new(:from => "Jimmy Bean <jimmy_bean@yahoo.com>")
+      deliver_from("Jimmy Bean <jimmy_bean@yahoo.com>").should match(email)
+    end
+
+    it "should not match when the email does not have a sender" do
+      email = Mail::Message.new(:from => nil)
+      deliver_from("jimmy_bean@yahoo.com").should_not match(email)
+    end
+
+    it "should not match when the email addresses match but the names do not" do
+      email = Mail::Message.new(:from => "Jimmy Bean <jimmy_bean@yahoo.com>")
+      deliver_from("Freddy Noe <jimmy_bean@yahoo.com>").should_not match(email)
+    end
+
+    it "should not match when the names match but the email addresses do not" do
+      email = Mail::Message.new(:from => "Jimmy Bean <jimmy_bean@yahoo.com>")
+      deliver_from("Jimmy Bean <freddy_noe@yahoo.com>").should_not match(email)
+    end
+
+    it "should not match when the email is not set to deliver from the specified address" do
+      email = Mail::Message.new(:from => "freddy_noe@yahoo.com")
+      deliver_from("jimmy_bean@yahoo.com").should_not match(email)
+    end
+
+    it "should give correct failure message when the email is not set to deliver from the specified address" do
+      matcher = deliver_from("jimmy_bean@yahoo.com")
+      matcher.matches?(Mail::Message.new(:from => "freddy_noe@yahoo.com"))
+      matcher.failure_message.should =~ /expected .+ to deliver from "jimmy_bean@yahoo\.com", but it delivered from "freddy_noe@yahoo\.com"/
+    end
+
+  end
+
+  describe "#bcc_to" do
+
+    it "should match when the email is set to deliver to the specidied address" do
+      email = Mail::Message.new(:bcc => "jimmy_bean@yahoo.com")
+
+      bcc_to("jimmy_bean@yahoo.com").should match(email)
+    end
+
+    it "should match when a list of emails is exact same as all of the email's recipients" do
+      email = Mail::Message.new(:bcc => ["james@yahoo.com", "karen@yahoo.com"])
+
+      bcc_to("karen@yahoo.com", "james@yahoo.com").should match(email)
+      bcc_to("karen@yahoo.com").should_not match(email)
+    end
+
+    it "should match when an array of emails is exact same as all of the email's recipients" do
+      addresses = ["james@yahoo.com", "karen@yahoo.com"]
+      email = Mail::Message.new(:bcc => addresses)
+      bcc_to(addresses).should match(email)
+    end
+
+    it "should use the passed in objects :email method if not a string" do
+      email = Mail::Message.new(:bcc => "jimmy_bean@yahoo.com")
+      user = mock("user", :email => "jimmy_bean@yahoo.com")
+
+      bcc_to(user).should match(email)
+    end
+
+  end
+
+  describe "#have_subject" do
+
+    describe "when regexps are used" do
+
+      it "should match when the subject matches regexp" do
+        email = Mail::Message.new(:subject => ' -- The Subject --')
+
+        have_subject(/The Subject/).should match(email)
+        have_subject(/foo/).should_not match(email)
+      end
+
+      it "should have a helpful description" do
+        matcher = have_subject(/foo/)
+        matcher.matches?(Mail::Message.new(:subject => "bar"))
+
+        matcher.description.should == "have subject matching /foo/"
+      end
+
+      it "should offer helpful failing messages" do
+        matcher = have_subject(/foo/)
+        matcher.matches?(Mail::Message.new(:subject => "bar"))
+
+        matcher.failure_message.should == 'expected the subject to match /foo/, but did not.  Actual subject was: "bar"'
+      end
+
+      it "should offer helpful negative failing messages" do
+        matcher = have_subject(/b/)
+        matcher.matches?(Mail::Message.new(:subject => "bar"))
+
+        matcher.negative_failure_message.should == 'expected the subject not to match /b/ but "bar" does match it.'
+      end
+    end
+
+    describe "when strings are used" do
+      it "should match when the subject equals the passed in string exactly" do
+        email = Mail::Message.new(:subject => 'foo')
+
+        have_subject("foo").should match(email)
+        have_subject(" - foo -").should_not match(email)
+      end
+
+      it "should have a helpful description" do
+        matcher = have_subject("foo")
+        matcher.matches?(Mail::Message.new(:subject => "bar"))
+
+        matcher.description.should == 'have subject of "foo"'
+      end
+
+      it "should offer helpful failing messages" do
+        matcher = have_subject("foo")
+        matcher.matches?(Mail::Message.new(:subject => "bar"))
+
+        matcher.failure_message.should == 'expected the subject to be "foo" but was "bar"'
+      end
+
+      it "should offer helpful negative failing messages" do
+        matcher = have_subject("bar")
+        matcher.matches?(Mail::Message.new(:subject => "bar"))
+
+        matcher.negative_failure_message.should == 'expected the subject not to be "bar" but was'
+      end
+    end
+  end
+
+  describe "#include_email_with_subject" do
+    
+    describe "when regexps are used" do
+      
+      it "should match when any email's subject matches passed in regexp" do
+        emails = [Mail::Message.new(:subject => "foobar"), Mail::Message.new(:subject => "bazqux")]
+        
+        include_email_with_subject(/foo/).should match(emails)
+        include_email_with_subject(/quux/).should_not match(emails)
+      end
+
+      it "should have a helpful description" do
+        matcher = include_email_with_subject(/foo/)
+        matcher.matches?([])
+        
+        matcher.description.should == 'include email with subject matching /foo/'
+      end
+
+      it "should offer helpful failing messages" do
+        matcher = include_email_with_subject(/foo/)
+        matcher.matches?([Mail::Message.new(:subject => "bar")])
+        
+        matcher.failure_message.should == 'expected at least one email to have a subject matching /foo/, but none did. Subjects were ["bar"]'
+      end
+
+      it "should offer helpful negative failing messages" do
+        matcher = include_email_with_subject(/foo/)
+        matcher.matches?([Mail::Message.new(:subject => "foo")])
+        
+        matcher.negative_failure_message.should == 'expected no email to have a subject matching /foo/ but found at least one. Subjects were ["foo"]'
+      end
+    end
+    
+    describe "when strings are used" do
+      it "should match when any email's subject equals passed in subject exactly" do
+        emails = [Mail::Message.new(:subject => "foobar"), Mail::Message.new(:subject => "bazqux")]
+        
+        include_email_with_subject("foobar").should match(emails)
+        include_email_with_subject("foo").should_not match(emails)
+      end
+      
+      it "should have a helpful description" do
+        matcher = include_email_with_subject("foo")
+        matcher.matches?([])
+        
+        matcher.description.should == 'include email with subject of "foo"'
+      end
+      
+      it "should offer helpful failing messages" do
+        matcher = include_email_with_subject("foo")
+        matcher.matches?([Mail::Message.new(:subject => "bar")])
+        
+        matcher.failure_message.should == 'expected at least one email to have the subject "foo" but none did. Subjects were ["bar"]'
+      end
+      
+      it "should offer helpful negative failing messages" do
+        matcher = include_email_with_subject("foo")
+        matcher.matches?([Mail::Message.new(:subject => "foo")])
+        
+        matcher.negative_failure_message.should == 'expected no email with the subject "foo" but found at least one. Subjects were ["foo"]'
+      end
+    end
+  end
+
+  describe "#have_body_text" do
+    describe "when regexps are used" do
+      it "should match when the body matches regexp" do
+        email = Mail::Message.new(:body => 'foo bar baz')
+
+        have_body_text(/bar/).should match(email)
+        have_body_text(/qux/).should_not match(email)
+      end
+
+      it "should have a helpful description" do
+        matcher = have_body_text(/qux/)
+        matcher.matches?(Mail::Message.new(:body => 'foo bar baz'))
+        
+        matcher.description.should == 'have body matching /qux/'
+      end
+
+      it "should offer helpful failing messages" do
+        matcher = have_body_text(/qux/)
+        matcher.matches?(Mail::Message.new(:body => 'foo bar baz'))
+        
+        matcher.failure_message.should == 'expected the body to match /qux/, but did not.  Actual body was: "foo bar baz"'
+      end
+
+      it "should offer helpful negative failing messages" do
+        matcher = have_body_text(/bar/)
+        matcher.matches?(Mail::Message.new(:body => 'foo bar baz'))
+
+        matcher.negative_failure_message.should == 'expected the body not to match /bar/ but "foo bar baz" does match it.'
+      end
+    end
+    
+    describe "when strings are used" do
+      it "should match when the body includes the text" do
+        email = Mail::Message.new(:body => 'foo bar baz')
+        
+        have_body_text('bar').should match(email)
+        have_body_text('qux').should_not match(email)
+      end
+      
+      it "should have a helpful description" do
+        matcher = have_body_text('qux')
+        matcher.matches?(Mail::Message.new(:body => 'foo bar baz'))
+        
+        matcher.description.should == 'have body including "qux"'
+      end
+      
+      it "should offer helpful failing messages" do
+        matcher = have_body_text('qux')
+        matcher.matches?(Mail::Message.new(:body => 'foo bar baz'))
+        
+        matcher.failure_message.should == 'expected the body to contain "qux" but was "foo bar baz"'
+      end
+      
+      it "should offer helpful negative failing messages" do
+        matcher = have_body_text('bar')
+        matcher.matches?(Mail::Message.new(:body => 'foo bar baz'))
+        
+        matcher.negative_failure_message.should == 'expected the body not to contain "bar" but was "foo bar baz"'
+      end
+    end
+
+    describe "when dealing with multipart messages" do
+      it "should look at the html part" do
+        email = Mail.new do
+          text_part do
+            body "This is text"
+          end
+          html_part do
+            body "This is html"
+          end
+        end
+        have_body_text(/This is html/).should match(email)
+        have_body_text(/This is text/).should_not match(email)
+      end
+    end
+  end
+
+  describe "#have_header" do
+    describe "when regexps are used" do
+      it "should match when header matches passed in regexp" do
+        email = Mail::Message.new(:content_type => "text/html")
+        
+        have_header(:content_type, /text/).should match(email)
+        have_header(:foo, /text/).should_not match(email)
+        have_header(:content_type, /bar/).should_not match(email)
+      end
+
+      it "should have a helpful description" do
+        matcher = have_header(:content_type, /bar/)
+        matcher.matches?(Mail::Message.new(:content_type => "text/html"))
+        
+        matcher.description.should == 'have header content_type with value matching /bar/'
+      end
+
+      it "should offer helpful failing messages" do
+        matcher = have_header(:content_type, /bar/)
+        matcher.matches?(Mail::Message.new(:content_type => "text/html"))
+        
+        matcher.failure_message.should == 'expected the headers to include \'content_type\' with a value matching /bar/ but they were {"content-type"=>"text/html"}'
+      end
+
+      it "should offer helpful negative failing messages" do
+        matcher = have_header(:content_type, /text/)
+        matcher.matches?(Mail::Message.new(:content_type => "text/html"))
+        
+        matcher.negative_failure_message.should == 'expected the headers not to include \'content_type\' with a value matching /text/ but they were {"content-type"=>"text/html"}'
+      end
+    end
+    
+    describe "when strings are used" do
+      it "should match when header equals passed in value exactly" do
+        email = Mail::Message.new(:content_type => "text/html")
+        
+        have_header(:content_type, 'text/html').should match(email)
+        have_header(:foo, 'text/html').should_not match(email)
+        have_header(:content_type, 'text').should_not match(email)
+      end
+      
+      it "should have a helpful description" do
+        matcher = have_header(:content_type, 'text')
+        matcher.matches?(Mail::Message.new(:content_type => "text/html"))
+        
+        matcher.description.should == 'have header content_type: text'
+      end
+      
+      it "should offer helpful failing messages" do
+        matcher = have_header(:content_type, 'text')
+        matcher.matches?(Mail::Message.new(:content_type => "text/html"))
+        
+        matcher.failure_message.should == 'expected the headers to include \'content_type: text\' but they were {"content-type"=>"text/html"}'
+      end
+      
+      it "should offer helpful negative failing messages" do
+        matcher = have_header(:content_type, 'text/html')
+        matcher.matches?(Mail::Message.new(:content_type => "text/html"))
+        
+        matcher.negative_failure_message == 'expected the headers not to include \'content_type: text/html\' but they were {:content_type=>"text/html"}'
+      end
+    end
+  end
+end