shoulda-matchers 2.7.0 → 2.8.0.rc1

data/lib/shoulda/matchers/action_controller/set_session_matcher.rb

@@ -5,45 +5,53 @@ module Shoulda
       # `session` hash.
       #
       #     class PostsController < ApplicationController
-      #       def show
-      #         session[:foo] = 'bar'
+      #       def index
+      #         session[:foo] = 'A candy bar'
+      #       end
+      #
+      #       def destroy
       #       end
       #     end
       #
       #     # RSpec
       #     describe PostsController do
-      #       describe 'GET #show' do
-      #         before { get :show }
+      #       describe 'GET #index' do
+      #         before { get :index }
       #
-      #         it { should set_session(:foo) }
-      #         it { should_not set_session(:baz) }
+      #         it { should set_session }
+      #       end
+      #
+      #       describe 'DELETE #destroy' do
+      #         before { delete :destroy }
+      #
+      #         it { should_not set_session }
       #       end
       #     end
       #
       #     # Test::Unit
       #     class PostsControllerTest < ActionController::TestCase
-      #       context 'GET #show' do
-      #         setup { get :show }
+      #       context 'GET #index' do
+      #         setup { get :index }
       #
-      #         should set_session(:foo)
-      #         should_not set_session(:baz)
+      #         should set_session
+      #       end
+      #
+      #       context 'DELETE #destroy' do
+      #         setup { delete :destroy }
+      #
+      #         should_not set_session
       #       end
       #     end
       #
       # #### Qualifiers
       #
-      # ##### to
+      # ##### []
       #
-      # Use `to` to assert that the key in the session hash was set to a
-      # particular value.
+      # Use `[]` to narrow the scope of the matcher to a particular key.
       #
       #     class PostsController < ApplicationController
       #       def index
-      #         session[:foo] = 'bar'
-      #       end
-      #
-      #       def show
-      #         session[:foo] = nil
+      #         session[:foo] = 'A candy bar'
       #       end
       #     end
       #
@@ -52,48 +60,81 @@ module Shoulda
       #       describe 'GET #index' do
       #         before { get :index }
       #
-      #         it { should set_session(:foo).to('bar') }
-      #         it { should_not set_session(:foo).to('something else') }
-      #         it { should_not set_session(:foo).to(nil) }
-      #       end
-      #
-      #       describe 'GET #show' do
-      #         before { get :show }
-      #
-      #         it { should set_session(:foo).to(nil) }
+      #         it { should set_session[:foo] }
+      #         it { should_not set_session[:bar] }
       #       end
       #     end
       #
       #     # Test::Unit
       #     class PostsControllerTest < ActionController::TestCase
       #       context 'GET #index' do
-      #         setup { get :index }
+      #         setup { get :show }
+      #
+      #         should set_session[:foo]
+      #         should_not set_session[:bar]
+      #       end
+      #     end
+      #
+      # ##### to
+      #
+      # Use `to` to assert that some key was set to a particular value, or that
+      # some key matches a particular regex.
       #
-      #         should set_session(:foo).to('bar')
-      #         should_not set_session(:foo).to('something else')
-      #         should_not set_session(:foo).to(nil)
+      #     class PostsController < ApplicationController
+      #       def index
+      #         session[:foo] = 'A candy bar'
       #       end
+      #     end
       #
-      #       context 'GET #show' do
+      #     # RSpec
+      #     describe PostsController do
+      #       describe 'GET #index' do
+      #         before { get :index }
+      #
+      #         it { should set_session.to('A candy bar') }
+      #         it { should set_session.to(/bar/) }
+      #         it { should set_session[:foo].to('bar') }
+      #         it { should_not set_session[:foo].to('something else') }
+      #       end
+      #     end
+      #
+      #     # Test::Unit
+      #     class PostsControllerTest < ActionController::TestCase
+      #       context 'GET #index' do
       #         setup { get :show }
       #
-      #         should set_session(:foo).to(nil)
+      #         should set_session.to('A candy bar')
+      #         should set_session.to(/bar/)
+      #         should set_session[:foo].to('bar')
+      #         should_not set_session[:foo].to('something else')
       #       end
       #     end
       #
       # @return [SetSessionMatcher]
       #
-      def set_session(key)
+      def set_session(key = nil)
         SetSessionMatcher.new(key)
       end
 
       # @private
       class SetSessionMatcher
         def initialize(key)
-          @key = key.to_s
+          if key
+            Shoulda::Matchers.warn <<EOT
+Passing a key to set_session is deprecated.
+Please use the hash syntax instead (e.g., `set_session[:foo]`, not `set_session(:foo)`).
+EOT
+            self[key]
+          end
+
           @value_block = nil
         end
 
+        def [](key)
+          @key = key.to_s
+          self
+        end
+
         def to(value = nil, &block)
           @value = value
           @value_block = block
@@ -102,10 +143,27 @@ module Shoulda
 
         def matches?(controller)
           @controller = controller
+
           if @value_block
             @value = @context.instance_eval(&@value_block)
           end
-          assigned_correct_value? || cleared_value?
+
+          if nil_value_expected_but_actual_value_unset?
+            Shoulda::Matchers.warn <<EOT
+Using `should set_session[...].to(nil)` to assert that a variable is unset is deprecated.
+Please use `should_not set_session[...]` instead.
+EOT
+          end
+
+          if key_specified? && value_specified?
+            @value === session[@key]
+          elsif key_specified?
+            session.key?(@key)
+          elsif value_specified?
+            session.values.any? { |value| @value === value }
+          else
+            session_present?
+          end
         end
 
         def failure_message
@@ -114,16 +172,12 @@ module Shoulda
         alias failure_message_for_should failure_message
 
         def failure_message_when_negated
-          "Didn't expect #{expectation}, but #{result}"
+          "Didn't expect #{expectation}, but it was"
         end
         alias failure_message_for_should_not failure_message_when_negated
 
         def description
-          description = "set session variable #{@key.inspect}"
-          if @value
-            description << " to #{@value.inspect}"
-          end
-          description
+          "should #{expectation}"
         end
 
         def in_context(context)
@@ -133,54 +187,56 @@ module Shoulda
 
         private
 
-        def value_or_default_value
-          defined?(@value) && @value
+        def key_specified?
+          defined?(@key)
         end
 
-        def assigned_value?
-          !assigned_value.nil?
+        def value_specified?
+          defined?(@value)
         end
 
-        def cleared_value?
-          defined?(@value) && @value.nil? && assigned_value.nil?
+        def value_or_default_value
+          defined?(@value) && @value
         end
 
-        def assigned_correct_value?
-          if assigned_value?
-            if !defined?(@value)
-              true
-            else
-              assigned_value == value_or_default_value
-            end
-          end
+        def nil_value_expected_but_actual_value_unset?
+          value_specified? && @value.nil? && !session.key?(@key)
         end
 
-        def assigned_value
-          session[@key]
+        def session_present?
+          !session.empty?
         end
 
         def expectation
-          expectation = "session variable #{@key} to be set"
+          expectation = ""
+
+          if key_specified?
+            expectation << "session variable #{@key.inspect}"
+          else
+            expectation << "any session variable"
+          end
 
-          if value_or_default_value
-            expectation << " to #{value_or_default_value.inspect}"
+          expectation << " to be"
+
+          if value_specified? && !@value.nil?
+            expectation << " #{@value.inspect}"
+          else
+            expectation << " set"
           end
+
+          expectation
         end
 
         def result
-          if session.empty?
-            'no session variables were set'
-          else
+          if session_present?
             "the session was #{session.inspect}"
+          else
+            'no session variables were set'
           end
         end
 
         def session
-          if @controller.request.respond_to?(:session)
-            @controller.request.session.to_hash
-          else
-            @controller.response.session.data
-          end
+          @controller.session
         end
       end
     end

data/lib/shoulda/matchers/active_model.rb

@@ -4,12 +4,11 @@ require 'shoulda/matchers/active_model/validation_message_finder'
 require 'shoulda/matchers/active_model/exception_message_finder'
 require 'shoulda/matchers/active_model/allow_value_matcher'
 require 'shoulda/matchers/active_model/disallow_value_matcher'
-require 'shoulda/matchers/active_model/ensure_length_of_matcher'
+require 'shoulda/matchers/active_model/validate_length_of_matcher'
 require 'shoulda/matchers/active_model/validate_inclusion_of_matcher'
 require 'shoulda/matchers/active_model/validate_exclusion_of_matcher'
 require 'shoulda/matchers/active_model/validate_absence_of_matcher'
 require 'shoulda/matchers/active_model/validate_presence_of_matcher'
-require 'shoulda/matchers/active_model/validate_uniqueness_of_matcher'
 require 'shoulda/matchers/active_model/validate_acceptance_of_matcher'
 require 'shoulda/matchers/active_model/validate_confirmation_of_matcher'
 require 'shoulda/matchers/active_model/validate_numericality_of_matcher'

data/lib/shoulda/matchers/active_model/allow_value_matcher.rb

@@ -224,12 +224,12 @@ module Shoulda
         end
 
         def failure_message
-          "Did not expect #{expectation}, got error: #{matched_error}"
+          "Did not expect #{expectation},\ngot error: #{matched_error}"
         end
         alias failure_message_for_should failure_message
 
         def failure_message_when_negated
-          "Expected #{expectation}, got #{error_description}"
+          "Expected #{expectation},\ngot#{error_description}"
         end
         alias failure_message_for_should_not failure_message_when_negated
 
@@ -281,8 +281,21 @@ module Shoulda
         end
 
         def expectation
-          includes_expected_message = expected_message ? "to include #{expected_message.inspect}" : ''
-          [error_source, includes_expected_message, "when #{attribute_to_set} is set to #{value.inspect}"].join(' ')
+          parts = [
+            error_source,
+            includes_expected_message,
+            "when #{attribute_to_set} is set to #{value.inspect}"
+          ]
+
+          parts.join(' ').squeeze(' ')
+        end
+
+        def includes_expected_message
+          if expected_message
+            "to include #{expected_message.inspect}"
+          else
+            ''
+          end
         end
 
         def error_source
@@ -326,7 +339,7 @@ module Shoulda
           defaults = {
             model_name: model_name,
             instance: instance,
-            attribute: attribute_to_set,
+            attribute: attribute_to_check_message_against,
           }
 
           defaults.merge(options[:expected_message_values])

data/lib/shoulda/matchers/active_model/exception_message_finder.rb

@@ -15,9 +15,9 @@ module Shoulda
 
         def messages_description
           if has_messages?
-            messages.join
+            ": #{messages.join.inspect}"
           else
-            'no exception'
+            ' no exception'
           end
         end
 

data/lib/shoulda/matchers/active_model/helpers.rb

@@ -5,11 +5,11 @@ module Shoulda
       module Helpers
         def pretty_error_messages(obj)
           obj.errors.map do |attribute, message|
-            full_message = message.dup
+            full_message = message.dup.inspect
             parenthetical_parts = []
 
             unless attribute.to_sym == :base
-              parenthetical_parts << "attribute: #{attribute.to_s.inspect}"
+              parenthetical_parts << "attribute: #{attribute}"
 
               if obj.respond_to?(attribute)
                 parenthetical_parts << "value: #{obj.__send__(attribute).inspect}"
@@ -20,8 +20,8 @@ module Shoulda
               full_message << " (#{parenthetical_parts.join(', ')})"
             end
 
-            full_message
-          end
+            "* " + full_message
+          end.join("\n")
         end
 
         # Helper method that determines the default error message used by Active

data/lib/shoulda/matchers/active_model/validate_confirmation_of_matcher.rb

@@ -89,24 +89,31 @@ module Shoulda
         def disallows_different_value
           set_confirmation('some value')
           disallows_value_of('different value') do |matcher|
-            matcher.with_message(@message, against: error_attribute)
+            qualify_matcher(matcher)
           end
         end
 
         def allows_same_value
           set_confirmation('same value')
           allows_value_of('same value') do |matcher|
-            matcher.with_message(@message, against: error_attribute)
+            qualify_matcher(matcher)
           end
         end
 
         def allows_missing_confirmation
           set_confirmation(nil)
           allows_value_of('any value') do |matcher|
-            matcher.with_message(@message, against: error_attribute)
+            qualify_matcher(matcher)
           end
         end
 
+        def qualify_matcher(matcher)
+          matcher.with_message(@message,
+            against: error_attribute,
+            values: { attribute: attribute }
+          )
+        end
+
         def set_confirmation(val)
           setter = :"#{@confirmation_attribute}="
           if @subject.respond_to?(setter)

data/lib/shoulda/matchers/active_model/validate_exclusion_of_matcher.rb

@@ -29,7 +29,7 @@ module Shoulda
       #         in_array(['Mac', 'Linux'])
       #     end
       #
-      # If your blacklist is a range of values, use `in_rnage`:
+      # If your blacklist is a range of values, use `in_range`:
       #
       #     class Game
       #       include ActiveModel::Model

data/lib/shoulda/matchers/active_model/validate_inclusion_of_matcher.rb

@@ -409,7 +409,9 @@ EOT
             end
           end
 
-          !allows_value_of(*values_outside_of_array)
+          !values_outside_of_array.any? do |value|
+            allows_value_of(value, @low_message)
+          end
         end
 
         def values_outside_of_array