opsb-email_spec 0.6.2

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,23 @@
+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 = stub(:has_body_text? => true,
+                   :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 = stub(:has_body_text? => true,
+                   :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 = stub(:has_body_text? => false)
+      lambda { parse_email_for_link(email, "non-existent text") }.should raise_error(Spec::Expectations::ExpectationNotMetError)
+    end
+  end
+end

data/spec/email_spec/matchers_spec.rb

@@ -0,0 +1,240 @@
+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
+
+  def mock_email(stubs)
+    mock("email", stubs)
+  end
+
+  describe "#reply_to" do
+    it "should match when the email is set to deliver to the specified address" do
+      email = mock_email(:reply_to => ["test@gmail.com"])
+      reply_to("test@gmail.com").should match(email)
+    end
+
+    it "should match given a name and address" do
+      email = mock_email(: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?(mock_email(:inspect => 'email', :reply_to => ['freddy_noe@yahoo.com']))
+      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 = mock_email(: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 = mock_email(: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 = mock_email(:to => addresses)
+      deliver_to(addresses).should match(email)
+    end
+
+    it "should use the passed in objects :email method if not a string" do
+      email = mock_email(: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")
+      matcher.matches?(mock_email(:inspect => 'email', :to => 'freddy_noe@yahoo.com'))
+      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 = mock_email(:from_addrs => [TMail::Address.parse("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 = mock_email(:from_addrs => [TMail::Address.parse("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 = mock_email(:from_addrs => 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 = mock_email(:from_addrs => [TMail::Address.parse("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 = mock_email(:from_addrs => [TMail::Address.parse("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 = mock_email(:from_addrs => [TMail::Address.parse("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?(mock_email(:inspect => 'email', :from_addrs => [TMail::Address.parse("freddy_noe@yahoo.com")]))
+      matcher.failure_message.should == %{expected email 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 = mock_email(: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 = mock_email(: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 = mock_email(:bcc => addresses)
+      bcc_to(addresses).should match(email)
+    end
+
+    it "should use the passed in objects :email method if not a string" do
+      email = mock_email(: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 mathches regexp" do
+        email = mock_email(:subject => ' -- The Subject --')
+
+        have_subject(/The Subject/).should match(email)
+        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?(mock_email(:subject => "bar"))
+
+        matcher.description.should == "have subject matching /foo/"
+      end
+
+      it "should offer helpful failing messages" do
+        matcher = have_subject(/foo/)
+        matcher.matches?(mock_email(: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?(mock_email(: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 = mock_email(: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?(mock_email(:subject => "bar"))
+
+        matcher.description.should == 'have subject of "foo"'
+      end
+
+      it "should offer helpful failing messages" do
+        matcher = have_subject("foo")
+        matcher.matches?(mock_email(: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?(mock_email(: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
+    it "should have specs!"
+  end
+
+  describe "#have_body_text" do
+    it "should have specs!"
+  end
+
+  describe "#have_header" do
+    it "should have specs!"
+  end
+end