test_assistant 0.0.4 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 49e305f2819ade85d5d24f684b4793021fc5b9a4
-  data.tar.gz: d665d5ac5bb5ac475e76c897fbb755cef7bb2a3d
+  metadata.gz: 9b1c5794fb9961343ed9b9c926125a1e7f4128bb
+  data.tar.gz: 8dfad5f30319bffaac95db75a76c99228bbe3fad
 SHA512:
-  metadata.gz: 398f6cfb2cde42b5d13b1f1daf392986400258bfa1e64e7e3c73b0215078fd9adfe458c3085d2e345d796ef15e3aa798e2162dd6ed082b2261ae148b3f7cc1f1
-  data.tar.gz: b571f52714417646144182f5051a88346d8b46b52538f68ecd478cc850e4494dc4453b5c7d4b6c5b4e50c4d499f20a627e7e608d8a128aed3e570a836b527d56
+  metadata.gz: 3e8db6c937c7895f188fc16c03f2fbf2344cfbd0e8621ccd42521cc380819ac259a05eac1e869e5036e9e1ec2f4ee1e57bf23ad13098ef32496abacd0adea298
+  data.tar.gz: f841a64f96693ebc1fd9422c931c8f626531f74e38935049bfc2851a3d0de7cae8250c84f5b84be276943f883a6eb12efa102297ef16b0f3ac19dcd751072c5e

data/README.md

@@ -1,11 +1,13 @@
 # TestAssistant
 
-A collection of testing tools and utilities for writing and fixing tests faster
+RSpec toolbox for writing and diagnosing Ruby on Rails tests, faster - especially emails and JSON APIs.
 
-## Stability
-
-TestAssistant is in its infancy and should be considered unstable. The API and behaviour is likely to change. 
+## 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
 
@@ -19,10 +21,6 @@ And then execute:
 
     $ bundle
 
-Or install it yourself as:
-
-    $ gem install test_assistant
-
 ## Usage
 
 Test assistant requires access to the RSpec configuration object, so add the following to either `rails_helper.rb` or `spec_helper.rb`:
@@ -30,131 +28,217 @@ Test assistant requires access to the RSpec configuration object, so add the fol
 ```ruby
 RSpec.configure do |config|
   # other rspec configuration
-  
+
   TestAssistant.configure(config) do |ta_config|
     # test assistant configuration here
   end
 end
 ```
 
-### Rendering a response context when a test fails
+## 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.
 
-Test assistant can automatically render the server response in your browser when a test fails and you have applied a nominated tag. 
+### Setup
 
 ```ruby
 TestAssistant.configure(config) do |ta_config|
-  ta_config.render_failed_responses tag: :focus, type: :request
+  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 a correct result', focus: true do
-      # failing assertions
+    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
 ```
 
-### Invoking a debugger when a test fails
-
-It's possible to invoke a debugger (`pry` is default, but fallback is to `byebug` and then `debugger`) if a test fails. This gives you access to some of the scope that the failing test ran in, allowing you to inspect objects and test variations of the failing assertion.
+## Email expectations
 
-The `debug_failed_responses` accepts a the following options:
+Test Assistant provides a declarative API for describing when emails should be sent and their characteristics.
 
-* `tag: :<tag_name>` (default is `:debugger`) 
-* `type: :<spec_type>` (default: nil - matches all test types) options. 
+### Setup
 
 ```ruby
 TestAssistant.configure(config) do |ta_config|
-    ta_config.include_json_helpers type: :request
+  ta_config.include_email_helpers type: :request
+end
+```
 
-    ta_config.debug_failed_responses tag: :debugger
-  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
-RSpec.describe 'making some valid request', type: :request do
-  context 'some important context' do
-    it 'should return a correct result', debugger: true do
-      # failing assertions
-    end
-  end
-end
+expect(email).to have_been_sent.from('user@email.com')
 ```
 
-## JSON expectations
+### Email subject
+
+You can assert an email's subject:
 
-RSpec's failed equality reports are often extremely difficult to interpret when dealing with complicated JSON objects. A minor difference, deeply nested in arrays and objects can take a long time to locate because RSpec dumps the entire object in the failure message.
- 
+```ruby
+expect(email).to have_been_sent.with_subject('Welcome!')
+```
 
-When enabled, Test Assistant provides a method `json_response` that automatically parses the last response object as json and a custom assertion `eql_json` that reports failed equality of complicated json objects in a format that is much clearer. The full `expected` and `actual` values are still reported, but below them Test Assistant prints only the paths to the failed nested values and their differences, removing the need to manually compare the two complete objects to find what is different. 
+
+### 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.
 
 ```ruby
 TestAssistant.configure(config) do |ta_config|
-  ta_config.include_json_helpers type: :request
+  ta_config.render_failed_responses tag: :focus, type: :request
 end
 ```
 
 ```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'"}
-        } 
-      ])
+    it 'should return a correct result', focus: true do
+      # failing assertions
     end
   end
 end
 ```
 
-## Email expectations
+### Invoking a debugger when a test fails
 
+It's possible to invoke a debugger (`pry` is default, but fallback is to `byebug` and then `debugger`) if a test fails. This gives you access to some of the scope that the failing test ran in, allowing you to inspect objects and test variations of the failing assertion.
+
+The `debug_failed_responses` accepts a the following options:
+
+* `tag: :<tag_name>` (default is `:debugger`)
+* `type: :<spec_type>` (default: nil - matches all test types) options.
 
 ```ruby
 TestAssistant.configure(config) do |ta_config|
-  ta_config.include_email_helpers type: :request
-end
+    ta_config.include_json_helpers type: :request
+
+    ta_config.debug_failed_responses tag: :debugger
+  end
 ```
 
 ```ruby
 RSpec.describe 'making some valid request', type: :request do
   context 'some important context' do
-    it 'should send an email' do
-      expect(email).to have_been_sent
-                          .to('user@email.com')
-                          .from('admin@site.com')
-                          .with_subject('Welcome!')
-                          .with_text('Welcome, user@email.com').and('Thanks for signing up')
-                          .with_selector('#password').and('#username')
-                          .with_link('www.site.com/onboarding/1')
-                          .with_image('www.site.com/assets/images/welcome.png')
-                          
-      clear_emails
-      
-      # further actions
-      
-      expect(email).to have_been_sent.to('user@email.com')
+    it 'should return a correct result', debugger: true do
+      # failing assertions
     end
   end
 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 )

data/lib/test_assistant/configuration.rb

@@ -14,6 +14,11 @@ module TestAssistant
 
     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
 
     def render_failed_responses(options = {})

data/lib/test_assistant/email/expectation.rb

@@ -2,6 +2,7 @@ require 'capybara/rspec'
 
 module TestAssistant::Email
   class Expectation
+
     def initialize
       @expectations = {}
       @failure_message = 'Expected email to be sent'
@@ -16,7 +17,7 @@ module TestAssistant::Email
             match: ->(_, email, value){ value.all?{|text| email.has_content?(text) }},
             actual: ->(_, email){ email.text}
         },
-        with_selector: {
+        matching_selector: {
             match: ->(_, email, value){ value.all?{|text| email.has_selector?(text) }},
             actual: ->(_, email){ email.native },
             actual_name: :with_body
@@ -55,11 +56,10 @@ module TestAssistant::Email
     end
 
     def from(email_address)
-      if email_address.kind_of?(Array)
-        @expectations[: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] ||= []
-        @expectations[:from] << email_address
+        @expectations[:from] = email_address
       end
 
       @and_scope = :from
@@ -74,6 +74,8 @@ module TestAssistant::Email
         @expectations[:with_subject] = subject
       end
 
+      @and_scope = :with_subject
+
       self
     end
 
@@ -85,11 +87,11 @@ module TestAssistant::Email
       self
     end
 
-    def with_selector(selector)
-      @expectations[:with_selector] ||= []
-      @expectations[:with_selector].push(selector)
+    def matching_selector(selector)
+      @expectations[:matching_selector] ||= []
+      @expectations[:matching_selector].push(selector)
 
-      @and_scope = :with_selector
+      @and_scope = :matching_selector
       self
     end
 
@@ -118,70 +120,169 @@ module TestAssistant::Email
 
       matching_emails = @emails
 
-      @expectations.each do |attribute, expected|
-
-        matching_emails =
-            matching_emails.select do |email|
-              email_matches?(email, MATCHERS[attribute], expected)
-            end
-
-        if matching_emails.empty?
+      if @expectations.any?
+        @expectations.each do |attribute, expected|
           @failed_attribute = attribute
           @failed_expected = expected
-          return false
+
+          matching_emails =
+              matching_emails.select do |email|
+                email_matches?(email, MATCHERS[attribute], expected)
+              end
+
+          if matching_emails.empty?
+            return false
+          end
         end
-      end
 
-      true
+        true
+      else
+        @emails.any?
+      end
     end
 
     def failure_message
-      field_description = @failed_attribute.to_s.gsub('_', ' ')
-      value_description =
-          case @failed_expected
-            when String
-              "'#{@failed_expected}'"
-            when Array
-              @failed_expected.map{|val| "'#{val}'"}.to_sentence
-            else
-              @failed_expected
-          end
+      field_descs = attribute_descriptions
+      value_descs = value_descriptions
 
-      base_clause = "Expected an email to be sent #{field_description} #{value_description}."
+      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.'
+        "#{base_clause} However, no emails were sent."
       else
-        pluralisation = @emails.length == 1 ? 'email' : 'emails'
+        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
+
+    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 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 sent_email_values
+      @emails.inject([]) do |memo, email|
 
-        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))
+              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
           memo << value
+        end
+
+        memo
+      end
+    end
+
+    def expectation_description(base_clause, field_descriptions, value_descriptions)
+      description = base_clause
 
-          memo
+      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
 
-        if email_values.any?
-          base_clause + " However, #{pluralisation} were sent #{field_description} #{email_values.to_sentence}"
+      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
-          base_clause
+          value
         end
       end
+
     end
 
-    private
+    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 ||= {}
@@ -190,13 +291,19 @@ module TestAssistant::Email
     end
 
     def parser(email)
-      Capybara::Node::Simple.new(email.parts.first.body.decoded)
+      Capybara::Node::Simple.new(email_body(email))
+    end
+
+    def email_body(email)
+      email.parts.first.body.decoded
     end
 
     def email_matches?(email, assertion, expected)
       case assertion
+        when :to
+          expected.include?(email.send(assertion))
         when String, Symbol
-          email.send(assertion) == expected
+          expected == email.send(assertion)
         when Hash
           assertion[:match].(email, parsed_emails(email), expected)
         else

data/lib/test_assistant/json/expectation.rb

@@ -5,6 +5,8 @@ module TestAssistant::Json
   class Expectation
     def initialize(expected)
       @expected = expected
+      @message = ''
+      @reported_differences = {}
     end
 
     def diffable?
@@ -12,9 +14,6 @@ module TestAssistant::Json
     end
 
     def matches?(actual)
-      @message = ''
-      @reported_differences = {}
-
       @actual = actual
       @expected.eql?(@actual)
     end
@@ -24,36 +23,71 @@ module TestAssistant::Json
       @message += "Actual: #{@actual}\n\n"
       @message += "Differences\n\n"
 
-      differences = HashDiff.diff(@actual, @expected)
+      add_diff_to_message(@actual, @expected)
 
-      differences.each do |difference|
-        operator, *operands = difference
+      @message
+    end
 
-        case operator
-          when '-'
-            attribute, value = operands
+    private
 
-            expected_value = attribute_value(@expected, attribute)
-            add_diff_description(attribute, format_diff(attribute, expected_value, value))
+    def add_diff_to_message(original_actual, original_expected, parent_prefix = '')
+      differences = HashDiff
+                        .diff(original_actual, original_expected)
+                        .sort{|diff1, diff2| diff1[1] <=> diff2[1]}
 
-          when '+'
-            attribute, value = operands
+      grouped_differences =
+          differences.inject({}) do |memo, diff|
+            operator, name, value = diff
+            memo[name] ||= {}
+            memo[name][operator] = value
+            memo
+          end
 
-            actual_value = attribute_value(@actual, attribute)
+      grouped_differences.each do |name, difference|
+        removed_value = difference['-']
+        added_value = difference['+']
+        swapped_value = difference['~']
 
-            add_diff_description(attribute, format_diff(attribute, value, actual_value))
+        full_name = parent_prefix.length > 0 ? "#{parent_prefix}.#{name}" : name
 
-          else
-            attribute, actual_value, expected_value = operands
+        if non_empty_hash?(removed_value) && non_empty_hash?(added_value)
+          add_diff_to_message(removed_value, added_value, full_name)
+
+        elsif non_empty_array?(removed_value) && non_empty_array?(added_value)
 
-            add_diff_description(attribute, format_diff(attribute, expected_value, actual_value))
+          [removed_value.length, added_value.length].max.times do |i|
+            add_diff_to_message(removed_value[i], added_value[i], full_name)
+          end
+        else
+          if difference.has_key?('~')
+            add_diff_description(full_name,
+                format_diff(
+                    full_name,
+                    attribute_value(original_expected, name),
+                    swapped_value
+                )
+            )
+          else
+            add_diff_description(full_name,
+                format_diff(
+                  full_name,
+                  added_value || attribute_value(original_expected, name),
+                  removed_value || attribute_value(original_actual, name)
+              )
+            )
+          end
         end
+
       end
+    end
 
-      @message
+    def non_empty_hash?(target)
+      target.kind_of?(Hash) && target.any?
     end
 
-    private
+    def non_empty_array?(target)
+      target.kind_of?(Array) && target.any?
+    end
 
     def add_diff_description(attribute, difference_description)
       unless already_reported_difference?(attribute)
@@ -79,10 +113,13 @@ module TestAssistant::Json
 
       result = target
 
+
       keys.each do |key|
+
         unless key == ''
           result = result[key]
         end
+
       end
 
       result

data/lib/test_assistant/version.rb

@@ -1,3 +1,3 @@
 module TestAssistant
-  VERSION = "0.0.4"
+  VERSION = "0.1.0"
 end

data/spec/email_expectation_spec.rb

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

data/spec/eql_json_spec.rb

@@ -104,6 +104,64 @@ RSpec.describe "eql_json" do
 
   end
 
+  context "when comparing arrays of objects" do
+    let(:expected) {
+      {
+          'alpha' => 'alpha',
+          'beta' => [ 1, 2, 3],
+          'gamma' => [
+              { 'i' => 'a', 'j' => 'b' },
+              { 'i' => 'c', 'j' => 'd' },
+              { 'i' => 'e', 'j' => 'f' },
+          ]
+      }
+    }
+
+    let(:actual) {
+      {
+          'alpha' => 'alpha',
+          'beta' => [ 1, 2, 3],
+          'gamma' => [
+              { 'j' => 'b' },
+              { 'i' => 'c', 'j' => 'D' },
+              { 'i' => 'e', 'j' => 'f', 'k' => 'k' },
+          ]
+      }
+    }
+
+    it "then correctly reports the elements that have changed" do
+
+      expect(actual).to eql(actual)
+
+      expect(actual).to_not eql(expected)
+
+      begin
+        expect(actual).to eql_json(expected)
+      rescue RSpec::Expectations::ExpectationNotMetError => e
+
+        expect(e.message).to eql(error_message(expected, actual, {
+
+          'gamma[0].i' => {
+              expected: "'a'",
+              actual: ''
+          },
+          'gamma[1].j' => {
+              expected: "'d'",
+              actual: "'D'"
+          },
+          'gamma[2].k' => {
+              expected: '',
+              actual: "'k'"
+          }
+
+        }))
+
+      end
+
+    end
+
+  end
+
   context "when comparing objects" do
     let(:expected) { {
         'a' => 'a',

data/spec/support/email_mock.rb

@@ -0,0 +1,27 @@
+class EmailMock
+  attr_reader :to, :from, :subject, :text, :body
+
+  def initialize(to: 'receiver@email.com', from: 'sender@email.com', subject: 'Subject', text: 'Test Email', body: "<body><h1>Test Email</h1><a href='www.test.com' /><img src='www.test.com' /></body>")
+    @to, @from, @subject, @text, @body = to, from, subject, text, body
+  end
+
+  def parts
+    [
+       EmailBodyMock.new(@body)
+    ]
+  end
+end
+
+class EmailBodyMock
+  def initialize(text)
+    @text = text
+  end
+
+  def body
+    self
+  end
+
+  def decoded
+    @text
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: test_assistant
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.1.0
 platform: ruby
 authors:
 - Aleck Greenham
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-02-27 00:00:00.000000000 Z
+date: 2017-07-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: capybara
@@ -137,8 +137,10 @@ files:
 - 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:
@@ -160,10 +162,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.5.1
 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