test_assistant 0.1.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9311d43bef33250abf4b13c6f10cfa03df96f8ed
-  data.tar.gz: 1fb3475a4bed626f4a5744724c340ac8702888b4
+  metadata.gz: 8304109fa9e5a8dcd0e7664b4034699179311eb5
+  data.tar.gz: 847f3f376f40a1a4665e4a5866131488a2f04278
 SHA512:
-  metadata.gz: '00185e2575b08c763500c145db50601143a73da0fa669c40eb70f7cc4e9156905c9b49ab13b3d4c6db8c7fe27fb82b60d9bd1d7a87df21c9472034e83c893609'
-  data.tar.gz: e76955c99b919c852f83de86ebb6ee173ac41acc8dbff90b8100d5784f0847fc35f09c4f03a0b3d61ee672a479aa51ba2f1f37f5cf52d8ee05e4a3a723289eb9
+  metadata.gz: a1293ac55e9244756384126f45f2c8b54fca5cf6f9f55f9a001e8838661aa3fe224f479a5dee95fb838379950e43d28c32d3a121049eb5d8187babdd92d028d4
+  data.tar.gz: c3732fbe8aae17fa613a69d80328fe06063373f9917c02d83610c6cb90dbeaecea1df64ef390f28d31c40c1971ee014b49921659ebc4d174cbbb12cac5c84a94

data/README.md

@@ -1,12 +1,10 @@
 # TestAssistant
 
-RSpec toolbox for writing and diagnosing Ruby on Rails tests, faster - especially emails and JSON APIs.
+RSpec toolbox for writing and diagnosing Ruby on Rails tests, faster.
 
 ## Features
 
 * Light-weight, scoped, lazily executed and composable tool-box, so you only include the features you want to use, when you want to use them with no unnecessary overhead
-* JSON assertion that gives noise-free reports on complex nested structures, so you can find out exactly what has changed with your JSON API without having to manually diff large objects
-* Expressive email assertions that let you succinctly describe when emails should and should not sent
 * Automatic reporting of the context around failing tests, so you don't have to re-run them with additional logging or a debugger
 
 ## Installation
@@ -35,155 +33,8 @@ RSpec.configure do |config|
 end
 ```
 
-## JSON expectations
-
-Test Assistant lets you include helpers in your controller and request specs to get succinct declarative methods for defining the expected results for JSON responses.
-
-### Setup
-
-```ruby
-TestAssistant.configure(config) do |ta_config|
-  ta_config.include_json_helpers type: :request
-end
-```
-
-### Asserting JSON responses
-
-Among the helpers provided are `json_response`, which automatically parses the last response object as json, and a custom assertion `eql_json` that reports failures in a format that is much clearer than anything provided by RSpec.
-
-The full `expected` and `actual` values are still reported, but below is a separate report that only includes the paths to the failed nested values and their differences, removing the need to manually compare the two complete objects to find the difference.
-
-```ruby
-RSpec.describe 'making some valid request', type: :request do
-  context 'some important context' do
-    it 'should return some complicated JSON' do
-
-      perform_request
-
-      expect(json_response).to eql_json([
-        {
-            "a" => [
-                1, 2, 3
-           ],
-           "c" => { "d" => "d'"}
-        },
-        {
-            "b" => [
-                1, 2, 3
-           ],
-           "c" => { "d" => "d'"}
-        }
-      ])
-    end
-  end
-end
-```
-
-## Email expectations
-
-Test Assistant provides a declarative API for describing when emails should be sent and their characteristics.
-
-### Setup
-
-```ruby
-TestAssistant.configure(config) do |ta_config|
-  ta_config.include_email_helpers type: :request
-end
-```
-
-### Clearing emails
-
-Emails can be cleared at any point by calling `clear_emails` in your tests. This is helpful when you are testing a user workflow that may trigger multiple emails.
-
-Emails are automatically cleared between each request spec.
-
-### Email receiver address
-
-It's possible to assert an email was sent to one or more or more addresses using the following format:
-
-```ruby
-expect(email).to have_been_sent.to('user@email.com')
-```
-
-### Email sender address
-
-Similarly, you can assert an email was sent from an address:
-
-```ruby
-expect(email).to have_been_sent.from('user@email.com')
-```
-
-### Email subject
-
-You can assert an email's subject:
-
-```ruby
-expect(email).to have_been_sent.with_subject('Welcome!')
-```
-
-
-### Email body
-
-You can assert the body of an email by text:
-
-```ruby
-expect(email).to have_been_sent.with_text('Welcome, user@email.com')
-```
-
-Or using a selector on the email's HTML:
-
-```ruby
-expect(email).to have_been_sent.with_selector('#password')
-```
-
-Or look for links:
-
-```ruby
-expect(email).to have_been_sent.with_link('www.site.com/onboarding/1')
-```
-
-Or images:
-
-```ruby
-expect(email).to have_been_sent.with_image('www.site.com/assets/images/welcome.png')
-```
-
-### Chaining assertions
-
-You can chain any combination of the above that you want for ultra specific assertions:
-
-
-```ruby
-expect(email).to have_been_sent
-                  .to('user@email.com')
-                  .from('admin@site.com')
-                  .with_subject('Welcome!')
-                  .with_text('Welcome, user@email.com')
-                  .with_selector('#password').and('#username')
-                  .with_link('www.site.com/onboarding/1')
-                  .with_image('www.site.com/assets/images/welcome.png')
-
-```
-
-You can also chain multiple assertions of the the same type with the `and` method:
-
-```ruby
-expect(email).to have_been_sent
-                    .with_text('Welcome, user@email.com').and('Thanks for signing up')
-```
-
-### Asserting emails are NOT sent
-
-The `have_sent_email` assertion works with the negative case as well:
-
-```ruby
-expect(email).to_not have_been_sent.with_text('Secret token')
-```
-
 ## Failure Reporting
 
-
-
 ### Rendering a response context when a test fails
 
 Test Assistant can automatically render the server response in your browser when a test fails and you have applied a nominated tag.
@@ -215,8 +66,6 @@ The `debug_failed_responses` accepts a the following options:
 
 ```ruby
 TestAssistant.configure(config) do |ta_config|
-    ta_config.include_json_helpers type: :request
-
     ta_config.debug_failed_responses tag: :debugger
   end
 ```
@@ -231,14 +80,6 @@ RSpec.describe 'making some valid request', type: :request do
 end
 ```
 
-## Test suite
-
-TestAssistant comes with close to complete test coverage. You can run the test suite as follows:
-
-```bash
-rspec
-```
-
 ## Contributing
 
 1. Fork it ( https://github.com/greena13/test_assistant/fork )
@@ -246,7 +87,3 @@ rspec
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create a new Pull Request
-
-## Inspirations
-
-* [CapybaraEmail](https://github.com/DockYard/capybara-email)

data/lib/test_assistant.rb

@@ -4,8 +4,6 @@ require 'test_assistant/configuration'
 # Utility module for working with RSpec test suites for Rails or similar applications
 #
 # Contains:
-# - Expressive syntax for asserting testing emails
-# - Sophisticated JSON matchers and diff failure reports
 # - Rendering and debugging tools for viewing test failures
 #
 # @see https://github.com/greena13/test_assistant Test Assistant Github page

data/lib/test_assistant/configuration.rb

@@ -1,6 +1,4 @@
 module TestAssistant
-  autoload :Json, 'test_assistant/json/helpers'
-  autoload :Email, 'test_assistant/email/helpers'
   autoload :FailureReporter, 'test_assistant/failure_reporter'
 
   # Class that provides configuration methods to control what parts of Test Assistant
@@ -19,49 +17,6 @@ module TestAssistant
       @rspec_config = rspec_config
     end
 
-    # Configures RSpec to include the JSON helpers provided by Test Assistant in the
-    # the test suite's scope
-    #
-    # @see TestAssistant::Json::Helpers
-    # @see RSpec::Core::Configuration#include
-    #
-    # @param [Hash] options RSpec::Core::Configuration#include options
-    # @return void
-    #
-    # @example Include JSON helpers in your RSpec test suite
-    #   RSpec.configure do |config|
-    #     TestAssistant.configure(config) do |ta_config|
-    #       ta_config.include_json_helpers
-    #     end
-    #   end
-    def include_json_helpers(options = {})
-      @rspec_config.include Json::Helpers, options
-    end
-
-    # Configures RSpec to include the email helpers provided by Test Assistant in the
-    # the test suite's scope and to clear the list of emails sent after each test
-    #
-    # @see TestAssistant::Email::Helpers
-    # @see RSpec::Core::Configuration#include
-    #
-    # @param [Hash] options RSpec::Core::Configuration#include options
-    # @return void
-    #
-    # @example Include Email helpers in your RSpec test suite
-    #   RSpec.configure do |config|
-    #     TestAssistant.configure(config) do |ta_config|
-    #       ta_config.include_email_helpers
-    #     end
-    #   end
-    def include_email_helpers(options = {})
-      @rspec_config.include Email::Helpers, options
-
-      @rspec_config.after :each, type: :request do
-        # clear emails after every request spec
-        ActionMailer::Base.deliveries = []
-      end
-    end
-
     # Configures under what circumstances a failing test should open a failure report
     # detailing the last HTTP request and response in a browser
     #
@@ -105,12 +60,17 @@ module TestAssistant
       no_type_filter = !type_filter
 
       @rspec_config.after(:each) do |example|
-        if example.exception
-          if (example.metadata[tag_filter] || no_tag_filter) && (example.metadata[:type] == type_filter || no_type_filter)
-            reporter = FailureReporter.report(request, response)
-            reporter.write
-            reporter.open
-          end
+        next unless example.exception
+
+        metadata = example.metadata
+        next unless (metadata[tag_filter] || no_tag_filter) && (metadata[:type] == type_filter || no_type_filter)
+
+        if metadata[:type] == :feature
+          save_and_open_page
+        else
+          reporter = FailureReporter.report(request, response)
+          reporter.write
+          reporter.open
         end
       end
     end
@@ -153,16 +113,18 @@ module TestAssistant
       no_type_filter = !type_filter
 
       @rspec_config.after(:each) do |example|
-        if example.exception
-          if (example.metadata[tag_filter]) && (example.metadata[:type] == type_filter || no_type_filter)
-            if defined? binding
-              binding.pry
-            elsif defined? byebug
-              byebug
-            else
-              debugger
-            end
-          end
+        next unless example.exception
+
+        metadata = example.metadata
+        next unless (metadata.key?(tag_filter)) && (metadata[:type] == type_filter || no_type_filter)
+
+        # noinspection RubyResolve
+        if defined? binding
+          binding.pry
+        elsif defined? byebug
+          byebug
+        else
+          debugger
         end
       end
     end

data/lib/test_assistant/version.rb

@@ -1,3 +1,3 @@
 module TestAssistant
-  VERSION = "0.1.2"
+  VERSION = "1.0.0"
 end

data/test_assistant.gemspec

@@ -18,9 +18,6 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency 'capybara', '~> 2.5', '>= 2.5.0'
-  spec.add_dependency 'hashdiff', '~> 0'
-
   spec.add_development_dependency "bundler", "~> 1.6"
   spec.add_development_dependency "rake", "~> 0"
   spec.add_development_dependency "guard", "~> 2.1"

metadata

@@ -1,49 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: test_assistant
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 1.0.0
 platform: ruby
 authors:
 - Aleck Greenham
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-05-01 00:00:00.000000000 Z
+date: 2019-04-13 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: capybara
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.5'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 2.5.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.5'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 2.5.0
-- !ruby/object:Gem::Dependency
-  name: hashdiff
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -132,16 +98,9 @@ files:
 - Rakefile
 - lib/test_assistant.rb
 - lib/test_assistant/configuration.rb
-- lib/test_assistant/email/expectation.rb
-- lib/test_assistant/email/helpers.rb
 - lib/test_assistant/failure_reporter.rb
-- lib/test_assistant/json/expectation.rb
-- lib/test_assistant/json/helpers.rb
 - lib/test_assistant/version.rb
-- spec/email_expectation_spec.rb
-- spec/eql_json_spec.rb
 - spec/spec_helper.rb
-- spec/support/email_mock.rb
 - test_assistant.gemspec
 homepage: https://github.com/greena13/test_assistant
 licenses:
@@ -168,7 +127,4 @@ signing_key:
 specification_version: 4
 summary: A toolbox for increased testing efficiency with RSpec
 test_files:
-- spec/email_expectation_spec.rb
-- spec/eql_json_spec.rb
 - spec/spec_helper.rb
-- spec/support/email_mock.rb

data/lib/test_assistant/email/expectation.rb

@@ -1,456 +0,0 @@
-require 'capybara/rspec'
-
-module TestAssistant::Email
-  # 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.
-  #
-  # Expected to be used as part of a RSpec test suite and with
-  # TestAssistant::Email::Helpers#email.
-  #
-  # Has two major components:
-  # - A Builder or chainable methods syntax for constructing arbitrarily specific
-  #   expectations
-  # - An implementation of the same interface as RSpec custom matcher classes to
-  #   allow evaluating those expectations those expectations
-  #
-  # @see TestAssistant::Email::Helpers#email
-  # @see TestAssistant::Email::Helpers#have_been_sent
-  class Expectation
-    MATCHERS = {
-        to: :to,
-        from: :from,
-        with_subject: :subject,
-        with_text: {
-            match: ->(_, email, value){ value.all?{|text| email.has_content?(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
-        }
-    }
-
-    # Creates a new TestAssistant::Email::Expectation object
-    #
-    # @return [TestAssistant::Email::Expectation] new expectation object
-    def initialize
-      @expectations = {}
-      @failure_message = 'Expected email to be sent'
-      @and_scope = nil
-    end
-
-    #
-    # Expectation creation methods
-    #
-
-    # Allows chaining two assertions on the same email attribute together without having
-    # to repeat the same method. Intended as syntactical sugar only and is functionally
-    # equivalent to repeating the method.
-    #
-    # @example Asserting an email was sent to two email addresses
-    #   expect(email).to have_been_sent.to('user1@email.com').and('user2@email.com')
-    #
-    # @param [Array] arguments parameters to pass to whatever assertion is being
-    #   extended.
-    # @return [TestAssistant::Email::Expectation] reference to self, to allow for
-    #   further method chaining
-    def and(*arguments)
-      if @and_scope
-        self.send(@and_scope, *arguments)
-      else
-        ArugmentError.new("Cannot use and without a proceeding assertion.")
-      end
-    end
-
-    # For constructing an assertion that at least one email was sent to a particular
-    # email address
-    #
-    # @example Asserting an email was sent to user@email.com
-    #   expect(email).to have_been_sent.to('user@email.com')
-    #
-    # @param [String, Array<String>] email_address address email is expected to be
-    #   sent to. If an array of email addresses, the email is expected to have been
-    #   sent to all of them.
-    # @return [TestAssistant::Email::Expectation] reference to self, to allow for
-    #   further method chaining
-    def to(email_address)
-      @expectations[:to] ||= []
-
-      if email_address.kind_of?(Array)
-        @expectations[:to] = @expectations[:to].concat(email_address)
-      else
-        @expectations[:to] ||= []
-        @expectations[:to] << email_address
-      end
-
-      @and_scope = :to
-
-      self
-    end
-
-    # For constructing an assertion that at least one email was sent from a particular
-    # email address
-    #
-    # @example Asserting an email was sent from admin@site.com
-    #   expect(email).to have_been_sent.from('admin@site.com')
-    #
-    # @param [String] email_address address email is expected to be sent from.
-    # @raise ArgumentError when from is called more than once on the same expectation,
-    #   as an email can only ben sent from a single sender.
-    # @return [TestAssistant::Email::Expectation] reference to self, to allow for
-    #   further method chaining
-    def from(email_address)
-      if @expectations[:from]
-        raise ArgumentError('An email can only have one from address, but you tried to assert the presence of 2 or more values')
-      else
-        @expectations[:from] = email_address
-      end
-
-      @and_scope = :from
-
-      self
-    end
-
-    # For constructing an assertion that at least one email was sent with a particular
-    # subject line
-    #
-    # @example Asserting an email was sent with subject line 'Hello'
-    #   expect(email).to have_been_sent.with_subject('Hello')
-    #
-    # @param [String] subject Subject line an email is expected to have been sent with
-    # @raise ArgumentError when with_subject is called more than once on the same
-    #   expectation, as an email can only have one subject line.
-    # @return [TestAssistant::Email::Expectation] reference to self, to allow for
-    #   further method chaining
-    def with_subject(subject)
-      if @expectations[:with_subject]
-        raise ArgumentError('An email can only have one subject, but you tried to assert the presence of 2 or more values')
-      else
-        @expectations[:with_subject] = subject
-      end
-
-      @and_scope = :with_subject
-
-      self
-    end
-
-    # For constructing an assertion that at least one email was sent with a particular
-    # string in the body of the email
-    #
-    # @example Asserting an email was sent with the text 'User 1'
-    #   expect(email).to have_been_sent.with_text('User 1')
-    #
-    # @param [String] text Text an email is expected to have been sent with in the body
-    # @return [TestAssistant::Email::Expectation] reference to self, to allow for
-    #   further method chaining
-    def with_text(text)
-      @expectations[:with_text] ||= []
-      @expectations[:with_text].push(text)
-
-      @and_scope = :with_text
-      self
-    end
-
-    # For constructing an assertion that at least one email was sent with a body that
-    # matches a particular CSS selector
-    #
-    # @example Asserting an email was sent with a body matching selector '#imporant-div'
-    #   expect(email).to have_been_sent.matching_selector('#imporant-div')
-    #
-    # @param [String] selector CSS selector that should match at least one sent
-    #   email's body
-    # @return [TestAssistant::Email::Expectation] reference to self, to allow for
-    #   further method chaining
-    def matching_selector(selector)
-      @expectations[:matching_selector] ||= []
-      @expectations[:matching_selector].push(selector)
-
-      @and_scope = :matching_selector
-      self
-    end
-
-    # For constructing an assertion that at least one email was sent with a link to
-    # a particular url in the body
-    #
-    # @example Asserting an email was sent with a link to http://www.example.com
-    #   expect(email).to have_been_sent.with_link('http://www.example.com')
-    #
-    # @param [String] href URL that should appear in at least one sent email's body
-    # @return [TestAssistant::Email::Expectation] reference to self, to allow for
-    #   further method chaining
-    def with_link(href)
-      @expectations[:with_link] ||= []
-      @expectations[:with_link].push(href)
-
-      @and_scope = :with_link
-      self
-    end
-
-    # For constructing an assertion that at least one email was sent with an image
-    # hosted at a particular URL
-    #
-    # @example Asserting an email was sent with the image http://www.example.com/image.png
-    #   expect(email).to have_been_sent.with_link('http://www.example.com/image.png')
-    #
-    # @param [String] src URL of the image that should appear in at least one sent
-    #   email's body
-    # @return [TestAssistant::Email::Expectation] reference to self, to allow for
-    #   further method chaining
-    def with_image(src)
-      @expectations[:with_image] ||= []
-      @expectations[:with_image].push(src)
-
-      @and_scope = :with_image
-      self
-    end
-
-    #
-    # RSpec Matcher methods
-    #
-
-    # 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] whether a matching email was sent
-    def matches?(emails)
-      @emails = emails
-
-      matching_emails = @emails
-
-      if @expectations.any?
-        @expectations.each do |attribute, expected|
-          @failed_attribute = attribute
-          @failed_expected = expected
-
-          matching_emails =
-              matching_emails.select do |email|
-                email_matches?(email, MATCHERS[attribute], expected)
-              end
-
-          if matching_emails.empty?
-            return false
-          end
-        end
-
-        true
-      else
-        @emails.any?
-      end
-    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). Only used when the
-    # positive assertion is used, i.e. expect(email).to have_been_sent. For the
-    # failure message used for negative assertions, i.e.
-    # expect(email).to_not have_been_sent, 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
-      field_descs = attribute_descriptions
-      value_descs = value_descriptions
-
-      base_clause = expectation_description(
-          'Expected an email to be sent',
-          field_descs,
-          value_descs
-      )
-
-      if @emails.length == 0
-        "#{base_clause} However, no emails were sent."
-      else
-        email_values = sent_email_values
-
-        if email_values.any?
-          base_clause + " However, #{email_pluralisation(@emails)} sent #{result_description(field_descs, [to_sentence(email_values)])}."
-        else
-          base_clause
-        end
-      end
-    end
-
-    # Failure message to display for negative RSpec assertions, i.e.
-    # expect(email).to_not have_been_sent. 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_descs = attribute_descriptions(negated: true)
-      value_descs = value_descriptions(negated: true)
-
-      expectation_description(
-          'Expected no emails to be sent',
-          field_descs,
-          value_descs
-      )
-    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.inject([]) do |memo, email|
-
-        if [ :matching_selector, :with_link, :with_image ].include?(@failed_attribute)
-          memo << email_body(email)
-        else
-          matcher = MATCHERS[@failed_attribute]
-
-          value =
-              case matcher
-              when String, Symbol
-                email.send(matcher)
-              when Hash
-                field_description = matcher[:actual_name] if matcher[:actual_name]
-                matcher[:actual].(email, parsed_emails(email))
-              end
-
-          value = value.kind_of?(String) ? "'#{value}'" : value.map{|element| "'#{element}'"}
-          memo << value
-        end
-
-        memo
-      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}" if field_description.length > 0
-
-        if (value_description = value_descriptions[index])
-          clause += " #{value_description}"
-        end
-
-        additional_clauses.push(clause) if clause.length > 0
-      end
-
-      description + additional_clauses.join('') + '.'
-    end
-
-    def attribute_descriptions(negated: false)
-      attributes_to_describe =
-          if negated
-            @expectations.keys
-          else
-            [ @failed_attribute ]
-          end
-
-      attributes_to_describe.map do |attribute|
-          attribute.to_s.gsub('_', ' ')
-      end
-    end
-
-    def value_descriptions(negated: false)
-      values_to_describe =
-          if negated
-            @expectations.values
-          else
-            [ @failed_expected ]
-          end
-
-      values_to_describe.map do |value|
-        case value
-        when String
-          "'#{value}'"
-        when Array
-          to_sentence(value.map{|val| "'#{val}'"})
-        else
-          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
-
-    def parsed_emails(email)
-      @parsed_emails ||= {}
-      @parsed_emails[email] ||= parser(email)
-      @parsed_emails[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
-
-    def email_matches?(email, assertion, expected)
-
-      case assertion
-        when :to
-          (expected & email.send(assertion)).length > 0
-        when String, Symbol
-          email.send(assertion).include?(expected)
-        when Hash
-          assertion[:match].(email, parsed_emails(email), expected)
-        else
-          raise RuntimeError.new(
-              "Unsupported assertion mapping '#{assertion_match}' of type #{assertion_match.class.name}"
-          )
-      end
-    end
-  end
-end