email_spectacular 1.0.0

data/lib/email_spectacular/email_filter.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'email_spectacular/dsl'
+require 'email_spectacular/failure_descriptions'
+require 'email_spectacular/matchers'
+
+module EmailSpectacular
+  class EmailFilter
+    include DSL
+    include Matchers
+    include FailureDescriptions
+  end
+end

data/lib/email_spectacular/expectation.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require 'email_spectacular/email_filter'
+
+module EmailSpectacular
+  # Backing class for {#have_been_sent} declarative syntax for specifying email
+  # expectations. Provides ability to assert emails have been sent in a given test
+  # that match particular attribute values, such as sender, receiver or contents.
+  #
+  # Implements the RSpec Matcher interface
+  #
+  # @author Aleck Greenham
+  #
+  # @see EmailSpectacular::RSpec#email
+  # @see EmailSpectacular::RSpec#have_been_sent
+  class Expectation < EmailFilter
+    # Creates a new EmailSpectacular::Expectation object
+    #
+    # @return [EmailSpectacular::Expectation] new expectation object
+    def initialize
+      @failure_message = 'Expected email to be sent'
+      super
+    end
+
+    # Declares that RSpec should not attempt to diff the actual and expected values
+    # to put in the failure message. This class takes care of diffing and presenting
+    # the differences, itself.
+    #
+    # @return [false] Always returns false
+    def diffable?
+      false
+    end
+
+    # Whether at least one email was sent during the current test that matches the
+    # constructed expectation
+    #
+    # @return [Boolean] True when a matching email was sent
+    def matches?(emails)
+      @emails = emails
+      matching_emails(emails, @scopes).any?
+    end
+
+    # Message to display to StdOut by RSpec if the equality check fails. Includes a
+    # complete a human-readable summary of the differences between what emails were
+    # expected to be sent, and what were actually sent (if any).
+    #
+    # This method is only used when the positive assertion is used, i.e.
+    # <tt>expect(email).to have_been_sent<tt>.
+    #
+    # For the failure message used for negative assertions, i.e.
+    # <tt>expect(email).to_not have_been_sent</tt>, see #failure_message_when_negated
+    #
+    # @see #failure_message_when_negated
+    #
+    # @return [String] message Full failure message with explanation of the differences
+    #         between what emails were expected and what was actually sent
+    def failure_message
+      attribute, expected_value =
+        attribute_and_expected_value(@scopes, @emails)
+
+      describe_failed_assertion(
+        @emails,
+        attribute,
+        expected_value
+      )
+    end
+
+    # Failure message to display for negative RSpec assertions, i.e.
+    # <tt>expect(email).to_not have_been_sent</tt>.
+    #
+    # For the failure message displayed for positive assertions, see #failure_message.
+    #
+    # @see #failure_message
+    #
+    # @return [String] message Full failure message with explanation of the differences
+    #         between what emails were expected and what was actually sent
+    def failure_message_when_negated
+      field_descriptions = attribute_descriptions(@scopes.keys)
+      value_descriptions = value_descriptions(@scopes.values)
+
+      expectation_description(
+        'Expected no emails to be sent',
+        field_descriptions,
+        value_descriptions
+      )
+    end
+  end
+end

data/lib/email_spectacular/failure_descriptions.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require 'email_spectacular/parser'
+require 'email_spectacular/matchers'
+
+module EmailSpectacular
+  # Module containing the helper methods to describe the difference between the expected
+  # and actual emails sent.
+  #
+  # @author Aleck Greenham
+  module FailureDescriptions # rubocop:disable Metrics/ModuleLength
+    include Parser
+
+    def self.included(base) # rubocop:disable Metrics/MethodLength
+      base.class_eval do
+        protected
+
+        def attribute_and_expected_value(scopes, emails)
+          scopes.each do |attribute, expected|
+            matching_emails =
+              emails.select do |email|
+                email_matches?(email, EmailSpectacular::Matchers::MATCHERS[attribute], expected)
+              end
+
+            return [attribute, expected] if matching_emails.empty?
+          end
+
+          [nil, nil]
+        end
+
+        def describe_failed_assertion(emails, attribute_name, attribute_value)
+          field_descriptions = attribute_descriptions([attribute_name])
+          value_descriptions = value_descriptions([attribute_value])
+
+          base_clause = expectation_description(
+            'Expected an email to be sent',
+            field_descriptions,
+            value_descriptions
+          )
+
+          if emails.empty?
+            "#{base_clause} However, no emails were sent."
+          else
+            email_values = sent_email_values(emails, attribute_name)
+
+            if email_values.any?
+              base_clause + " However, #{email_pluralisation(emails)} sent " \
+              "#{result_description(field_descriptions, [to_sentence(email_values)])}."
+            else
+              base_clause
+            end
+          end
+        end
+
+        def attribute_descriptions(attributes)
+          attributes.map do |attr|
+            attr.to_s.tr('_', ' ')
+          end
+        end
+
+        def value_descriptions(values)
+          values.map do |value|
+            case value
+            when String
+              "'#{value}'"
+            when Array
+              to_sentence(value.map { |val| "'#{val}'" })
+            else
+              value
+            end
+          end
+        end
+
+        def expectation_description(base_clause, field_descriptions, value_descriptions)
+          description = base_clause
+
+          additional_clauses = []
+
+          field_descriptions.each.with_index do |field_description, index|
+            clause = ''
+            clause += " #{field_description}" unless field_description.empty?
+
+            if (value_description = value_descriptions[index])
+              clause += " #{value_description}"
+            end
+
+            additional_clauses.push(clause) unless clause.empty?
+          end
+
+          description + additional_clauses.join('') + '.'
+        end
+
+        private
+
+        def result_description(field_descriptions, values)
+          to_sentence(
+            field_descriptions.map.with_index do |field_description, index|
+              value = values[index]
+
+              if ['matching selector', 'with link', 'with image'].include?(field_description)
+                "with body #{value}"
+              else
+                "#{field_description} #{value}"
+              end
+            end
+          )
+        end
+
+        def sent_email_values(emails, attribute)
+          emails.each_with_object([]) do |email, memo|
+            if %i[matching_selector with_link with_image].include?(attribute)
+              memo << email_body(email)
+            else
+              matcher = EmailSpectacular::Matchers::MATCHERS[attribute]
+
+              value =
+                case matcher
+                when String, Symbol
+                  email.send(matcher)
+                when Hash
+                  matcher[:actual].call(email, parsed_emails(email))
+                else
+                  raise ArgumentError, "Failure related to an unknown or unsupported email attribute #{attribute}"
+                end
+
+              value = value.is_a?(String) ? "'#{value}'" : value.map { |element| "'#{element}'" }
+              memo << value
+            end
+          end
+        end
+
+        def email_pluralisation(emails)
+          emails.length > 2 ? "#{emails.length} were" : '1 was'
+        end
+
+        def to_sentence(items)
+          case items.length
+          when 0, 1
+            items.join('')
+          when 2
+            items.join(' and ')
+          else
+            items[0..(items.length - 3)].join(', ') + items[(items.length - 3)..items.length - 1].join(' and ')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/email_spectacular/matchers.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'email_spectacular/parser'
+
+module EmailSpectacular
+  # Module containing helper methods for matching expectations against emails
+  #
+  # @author Aleck Greenham
+  module Matchers
+    include Parser
+
+    MATCHERS = {
+      to: :to,
+      from: :from,
+      with_subject: :subject,
+      with_text: {
+        match: ->(_, email, value) { value.all? { |text| email.has_text?(text) } },
+        actual: ->(_, email) { email.text }
+      },
+      matching_selector: {
+        match: ->(_, email, value) { value.all? { |selector| email.has_selector?(selector) } },
+        actual: ->(_, email) { email.native },
+        actual_name: :with_body
+      },
+      with_link: {
+        match: ->(_, email, value) { value.all? { |url| email.has_selector?("a[href='#{url}']") } },
+        actual: ->(_, email) { email.native },
+        actual_name: :with_body
+      },
+      with_image: {
+        match: ->(_, email, value) { value.all? { |url| email.has_selector?("img[src='#{url}']") } },
+        actual: ->(_, email) { email.native },
+        actual_name: :with_body
+      }
+    }.freeze
+
+    def self.included(base) # rubocop:disable Metrics/MethodLength
+      base.class_eval do
+        def matching_emails(emails, scopes)
+          if scopes.any?
+            emails.select do |email|
+              scopes.all? do |attribute, expected|
+                email_matches?(email, MATCHERS[attribute], expected)
+              end
+            end
+          else
+            emails
+          end
+        end
+
+        def email_matches?(email, assertion, expected)
+          case assertion
+          when :to
+            !(expected & email.send(assertion)).empty?
+          when String, Symbol
+            email.send(assertion).include?(expected)
+          when Hash
+            assertion[:match].call(email, parsed_emails(email), expected)
+          else
+            raise "Unsupported assertion mapping '#{assertion}' of type #{assertion.class.name}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/email_spectacular/parser.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'capybara'
+
+module EmailSpectacular
+  # Module for parsing email bodies
+  #
+  # @author Aleck Greenham
+  module Parser
+    def parsed_emails(email)
+      parser(email)
+    end
+
+    def parser(email)
+      Capybara::Node::Simple.new(email_body(email))
+    end
+
+    def email_body(email)
+      if email.parts.first
+        email.parts.first.body.decoded
+      else
+        email.body.encoded
+      end
+    end
+  end
+end

data/lib/email_spectacular/rspec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'email_spectacular/expectation'
+
+module EmailSpectacular
+  # Module containing email helper methods that can be mixed into the RSpec test scope
+  #
+  # @author Aleck Greenham
+  module RSpec
+    # Syntactic sugar for referencing the list of emails sent since the start of the
+    # test
+    #
+    # @example Asserting email has been sent
+    #   expect(email).to have_been_sent.to('test@email.com')
+    #
+    # @return [Array<Mail::Message>] List of sent emails
+    def email
+      ActionMailer::Base.deliveries
+    end
+
+    # Clears the list of sent emails.
+    #
+    # @return void
+    def clear_emails
+      ActionMailer::Base.deliveries = []
+    end
+
+    # Creates a new email expectation that allows asserting emails should have specific
+    # attributes.
+    #
+    # @see EmailSpectacular::Expectation
+    #
+    # @example Asserting email has been sent
+    #   expect(email).to have_been_sent.to('test@email.com')
+    def have_been_sent # rubocop:disable Naming/PredicateName
+      EmailSpectacular::Expectation.new
+    end
+  end
+end

data/lib/email_spectacular/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module EmailSpectacular
+  VERSION = '1.0.0'
+end

data/spec/email_expectation_spec.rb

@@ -0,0 +1,429 @@
+# frozen_string_literal: true
+
+require 'email_spectacular/rspec'
+
+require_relative './support/email_mock'
+
+RSpec.describe 'have_sent_email' do
+  include EmailSpectacular::RSpec
+
+  context 'when no emails have been sent' do
+    subject { [] }
+
+    it 'then the positive assertion fails' do
+      expect do
+        expect(subject).to have_been_sent
+      end.to raise_error.with_message(
+        'Expected an email to be sent. However, no emails were sent.'
+      )
+    end
+
+    it 'then the negative assertion passes' do
+      expect do
+        expect(subject).to_not have_been_sent
+      end.to_not raise_error
+    end
+
+    it "then a non-matching 'to' assertion fails" do
+      expect do
+        expect(subject).to have_been_sent.to('test@email.com')
+      end.to raise_error.with_message(
+        'Expected an email to be sent to \'test@email.com\'. However, no emails were sent.'
+      )
+    end
+
+    it "then a non-matching 'from' assertion fails" do
+      expect do
+        expect(subject).to have_been_sent.from('test@email.com')
+      end.to raise_error.with_message(
+        'Expected an email to be sent from \'test@email.com\'. However, no emails were sent.'
+      )
+    end
+
+    it "then a non-matching 'with_subject' assertion fails" do
+      expect do
+        expect(subject).to have_been_sent.with_subject('Subject')
+      end.to raise_error.with_message(
+        'Expected an email to be sent with subject \'Subject\'. However, no emails were sent.'
+      )
+    end
+
+    it "then a non-matching 'with_text' assertion fails" do
+      expect do
+        expect(subject).to have_been_sent.with_text('Text')
+      end.to raise_error.with_message(
+        'Expected an email to be sent with text \'Text\'. However, no emails were sent.'
+      )
+    end
+
+    it "then a non-matching 'matching_selector' assertion fails" do
+      expect do
+        expect(subject).to have_been_sent.matching_selector('h1')
+      end.to raise_error.with_message(
+        'Expected an email to be sent matching selector \'h1\'. However, no emails were sent.'
+      )
+    end
+
+    it "then a non-matching 'with_link' assertion fails" do
+      expect do
+        expect(subject).to have_been_sent.with_link('www.example.com')
+      end.to raise_error.with_message(
+        'Expected an email to be sent with link \'www.example.com\'. However, no emails were sent.'
+      )
+    end
+
+    it "then a non-matching 'with_image' assertion fails" do
+      expect do
+        expect(subject).to have_been_sent.with_image('www.example.com')
+      end.to raise_error.with_message(
+        'Expected an email to be sent with image \'www.example.com\'. However, no emails were sent.'
+      )
+    end
+  end
+
+  context 'when an email has been sent' do
+    subject { [EmailMock.new] }
+
+    it 'then the unqualified assertion passes' do
+      expect do
+        expect(subject).to have_been_sent
+      end.to_not raise_error
+    end
+
+    it 'then the unqualified negative assertion fails' do
+      expect do
+        expect(subject).to_not have_been_sent
+      end.to raise_error('Expected no emails to be sent.')
+    end
+  end
+
+  context 'when a matching email has been sent' do
+    subject { [EmailMock.new] }
+
+    it "then a positive 'to' assertion passes" do
+      expect do
+        expect(subject).to have_been_sent.to(subject[0].to[0])
+      end.to_not raise_error
+    end
+
+    it "then a negative 'to' assertion fails" do
+      expect do
+        expect(subject).to_not have_been_sent.to(subject[0].to[0])
+      end.to raise_error.with_message(
+        "Expected no emails to be sent to '#{subject[0].to[0]}'."
+      )
+    end
+
+    it "then a positive 'from' assertion passes" do
+      expect do
+        expect(subject).to have_been_sent.from(subject[0].from[0])
+      end.to_not raise_error
+    end
+
+    it "then a negative 'from' assertion fails" do
+      expect do
+        expect(subject).to_not have_been_sent.from(subject[0].from[0])
+      end.to raise_error.with_message(
+        "Expected no emails to be sent from '#{subject[0].from[0]}'."
+      )
+    end
+
+    it "then a positive 'with_subject' assertion passes" do
+      expect do
+        expect(subject).to have_been_sent.with_subject(subject[0].subject)
+      end.to_not raise_error
+    end
+
+    it "then a negative 'with_subject' assertion fails" do
+      expect do
+        expect(subject).to_not have_been_sent.with_subject(subject[0].subject)
+      end.to raise_error.with_message(
+        "Expected no emails to be sent with subject '#{subject[0].subject}'."
+      )
+    end
+
+    it "then a positive 'with_text' assertion passes" do
+      expect do
+        expect(subject).to have_been_sent.with_text(subject[0].text)
+      end.to_not raise_error
+    end
+
+    it "then a negative 'with_text' assertion fails" do
+      expect do
+        expect(subject).to_not have_been_sent.with_text(subject[0].text)
+      end.to raise_error.with_message(
+        "Expected no emails to be sent with text '#{subject[0].text}'."
+      )
+    end
+
+    it "then a positive 'matching_selector' assertion passes" do
+      expect do
+        expect(subject).to have_been_sent.matching_selector('h1')
+      end.to_not raise_error
+    end
+
+    it "then a negative 'matching_selector' assertion fails" do
+      expect do
+        expect(subject).to_not have_been_sent.matching_selector('h1')
+      end.to raise_error.with_message(
+        "Expected no emails to be sent matching selector 'h1'."
+      )
+    end
+
+    it "then a positive 'with_link' assertion passes" do
+      expect do
+        expect(subject).to have_been_sent.with_link('www.test.com')
+      end.to_not raise_error
+    end
+
+    it "then a negative 'with_link' assertion fails" do
+      expect do
+        expect(subject).to_not have_been_sent.with_link('www.test.com')
+      end.to raise_error.with_message(
+        "Expected no emails to be sent with link 'www.test.com'."
+      )
+    end
+
+    it "then a positive 'with_image' assertion passes" do
+      expect do
+        expect(subject).to have_been_sent.with_image('www.test.com')
+      end.to_not raise_error
+    end
+
+    it "then a negative 'with_image' assertion fails" do
+      expect do
+        expect(subject).to_not have_been_sent.with_image('www.test.com')
+      end.to raise_error.with_message(
+        "Expected no emails to be sent with image 'www.test.com'."
+      )
+    end
+  end
+
+  context 'when a non-matching email has been sent' do
+    subject { [EmailMock.new] }
+
+    it "then a positive 'to' assertion fails" do
+      expect do
+        expect(subject).to have_been_sent.to('other@email.com')
+      end.to raise_error.with_message(
+        "Expected an email to be sent to 'other@email.com'. However, 1 was sent to '#{subject[0].to[0]}'."
+      )
+    end
+
+    it "then a negative 'to' assertion passes" do
+      expect do
+        expect(subject).to_not have_been_sent.to('other@email.com')
+      end.to_not raise_error
+    end
+
+    it "then a positive 'from' assertion fails" do
+      expect do
+        expect(subject).to have_been_sent.from('other@email.com')
+      end.to raise_error.with_message(
+        "Expected an email to be sent from 'other@email.com'. However, 1 was sent from '#{subject[0].from[0]}'."
+      )
+    end
+
+    it "then a negative 'from' assertion passes" do
+      expect do
+        expect(subject).to_not have_been_sent.from('other@email.com')
+      end.to_not raise_error
+    end
+
+    it "then a positive 'with_subject' assertion fails" do
+      expect do
+        expect(subject).to have_been_sent.with_subject('Other Subject')
+      end.to raise_error.with_message(
+        "Expected an email to be sent with subject 'Other Subject'. However, 1 was " \
+        "sent with subject '#{subject[0].subject}'."
+      )
+    end
+
+    it "then a negative 'with_subject' assertion passes" do
+      expect do
+        expect(subject).to_not have_been_sent.with_subject('Other Subject')
+      end.to_not raise_error
+    end
+
+    it "then a positive 'with_text' assertion fails" do
+      expect do
+        expect(subject).to have_been_sent.with_text('Other text')
+      end.to raise_error.with_message(
+        "Expected an email to be sent with text 'Other text'. However, 1 was sent with text '#{subject[0].text}'."
+      )
+    end
+
+    it "then a negative 'with_text' assertion passes" do
+      expect do
+        expect(subject).to_not have_been_sent.with_text('Other text')
+      end.to_not raise_error
+    end
+
+    it "then a positive 'matching_selector' assertion fails" do
+      expect do
+        expect(subject).to have_been_sent.matching_selector('.other')
+      end.to raise_error.with_message(
+        "Expected an email to be sent matching selector '.other'. However, 1 was sent with body #{subject[0].body}."
+      )
+    end
+
+    it "then a negative 'matching_selector' assertion passes" do
+      expect do
+        expect(subject).to_not have_been_sent.matching_selector('.other')
+      end.to_not raise_error
+    end
+
+    it "then a positive 'with_link' assertion fails" do
+      expect do
+        expect(subject).to have_been_sent.with_link('www.other.com')
+      end.to raise_error.with_message(
+        "Expected an email to be sent with link 'www.other.com'. However, 1 was sent with body #{subject[0].body}."
+      )
+    end
+
+    it "then a negative 'with_link' assertion passes" do
+      expect do
+        expect(subject).to_not have_been_sent.with_link('www.other.com')
+      end.to_not raise_error
+    end
+
+    it "then a positive 'with_image' assertion fails" do
+      expect do
+        expect(subject).to have_been_sent.with_image('www.other.com')
+      end.to raise_error.with_message(
+        "Expected an email to be sent with image 'www.other.com'. However, 1 was sent with body #{subject[0].body}."
+      )
+    end
+
+    it "then a negative 'with_image' assertion passes" do
+      expect do
+        expect(subject).to_not have_been_sent.with_image('www.other.com')
+      end.to_not raise_error
+    end
+  end
+
+  context 'when multiple emails have been sent' do
+    subject { [EmailMock.new, EmailMock.new(to: 'other@email.com')] }
+
+    it 'then a positive assertion matching the first email passes' do
+      expect do
+        expect(subject).to have_been_sent.to(subject[0].to[0])
+      end.to_not raise_error
+    end
+
+    it 'then a negative assertion matching the first email fails' do
+      expect do
+        expect(subject).to_not have_been_sent.to(subject[0].to[0])
+      end.to raise_error.with_message(
+        "Expected no emails to be sent to '#{subject[0].to[0]}'."
+      )
+    end
+
+    it 'then a positive assertion matching the second email passes' do
+      expect do
+        expect(subject).to have_been_sent.to(subject[1].to)
+      end.to_not raise_error
+    end
+
+    it 'then a negative assertion matching the second email fails' do
+      expect do
+        expect(subject).to_not have_been_sent.to(subject[1].to)
+      end.to raise_error.with_message(
+        "Expected no emails to be sent to '#{subject[1].to[0]}'."
+      )
+    end
+  end
+
+  context 'when using multiple qualifiers' do
+    subject { [EmailMock.new] }
+
+    it 'then a positive assertions correctly matches a matching email' do
+      expect do
+        expect(subject).to have_been_sent.to(subject[0].to[0]).from(subject[0].from[0])
+      end.to_not raise_error
+    end
+
+    it "then a positive assertions don't match an email if the first qualifier isn't satisfied" do
+      expect do
+        expect(subject).to have_been_sent.to('other@email.com').from(subject[0].from[0])
+      end.to raise_error.with_message(
+        "Expected an email to be sent to 'other@email.com'. However, 1 was sent to '#{subject[0].to[0]}'."
+      )
+    end
+
+    it "then a positive assertions don't match an email if the last qualifier isn't satisfied" do
+      expect do
+        expect(subject).to have_been_sent.to(subject[0].to[0]).from('other@email.com')
+      end.to raise_error.with_message(
+        "Expected an email to be sent from 'other@email.com'. However, 1 was sent from '#{subject[0].from[0]}'."
+      )
+    end
+
+    it 'then a negative assertions correctly matches a matching email' do
+      expect do
+        expect(subject).to_not have_been_sent.to(subject[0].to[0]).from(subject[0].from[0])
+      end.to raise_error.with_message(
+        "Expected no emails to be sent to '#{subject[0].to[0]}' from '#{subject[0].from[0]}'."
+      )
+    end
+
+    it "then a negative assertions don't match an email if the first qualifier isn't satisfied" do
+      expect do
+        expect(subject).to_not have_been_sent.to('other@email.com').from(subject[0].from[0])
+      end.to_not raise_error
+    end
+
+    it "then a negative assertions don't match an email if the last qualifier isn't satisfied" do
+      expect do
+        expect(subject).to_not have_been_sent.to(subject[0].to[0]).from('other@email.com')
+      end.to_not raise_error
+    end
+  end
+
+  context 'when using the and method' do
+    subject { [EmailMock.new] }
+
+    it 'then a positive assertion will fail if the first qualifier is not satisfied' do
+      expect do
+        expect(subject).to have_been_sent.with_text('Other').and('Email')
+      end.to raise_error.with_message(
+        "Expected an email to be sent with text 'Other' and 'Email'. However, 1 was " \
+        "sent with text '#{subject[0].text}'."
+      )
+    end
+
+    it 'then a positive assertion will fail if the second qualifier is not satisfied' do
+      expect do
+        expect(subject).to have_been_sent.with_text('Test').and('Other')
+      end.to raise_error.with_message(
+        "Expected an email to be sent with text 'Test' and 'Other'. However, 1 was sent with text '#{subject[0].text}'."
+      )
+    end
+
+    it 'then a positive assertion will pass if both qualifiers are satisfied' do
+      expect do
+        expect(subject).to have_been_sent.with_text('Test').and('Email')
+      end.to_not raise_error
+    end
+
+    it 'then a negative assertion will pass if the first qualifier is not satisfied' do
+      expect do
+        expect(subject).to_not have_been_sent.with_text('Other').and('Email')
+      end.to_not raise_error
+    end
+
+    it 'then a negative assertion will pass if the second qualifier is not satisfied' do
+      expect do
+        expect(subject).to_not have_been_sent.with_text('Test').and('Other')
+      end.to_not raise_error
+    end
+
+    it 'then a negative assertion will fail if both qualifiers are satisfied' do
+      expect do
+        expect(subject).to_not have_been_sent.with_text('Test').and('Email')
+      end.to raise_error.with_message(
+        'Expected no emails to be sent with text \'Test\' and \'Email\'.'
+      )
+    end
+  end
+end