shoulda-matchers 2.8.0 → 3.0.0.rc1

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

@@ -54,7 +54,7 @@ module Shoulda
         end
 
         def description
-          description = "rescues from #{exception}"
+          description = "rescue from #{exception}"
           description << " with ##{expected_method}" if expected_method
           description
         end

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

@@ -79,6 +79,10 @@ module Shoulda
       #
       #     route(:get, '/posts/1').to('posts#show', id: 1)
       #
+      # You may also specify special parameters such as `:format`:
+      #
+      #     route(:get, '/posts').to('posts#index', format: :json)
+      #
       # @return [RouteMatcher]
       #
       def route(method, path)
@@ -135,7 +139,7 @@ module Shoulda
           rescue ::ActionController::RoutingError => error
             @failure_message = error.message
             false
-          rescue Shoulda::Matchers::AssertionError => error
+          rescue Shoulda::Matchers.assertion_exception_class => error
             @failure_message = error.message
             false
           end

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

@@ -3,6 +3,8 @@ module Shoulda
     module ActionController
       # @private
       class RouteParams
+        PARAMS_TO_SYMBOLIZE = %i{ format }
+
         def initialize(args)
           @args = args
         end
@@ -26,17 +28,24 @@ module Shoulda
         def extract_params_from_string
           controller, action = args[0].split('#')
           params = (args[1] || {}).merge(controller: controller, action: action)
-          stringify_values(params)
+          normalize_values(params)
         end
 
         def stringify_params
-          stringify_values(args[0])
+          normalize_values(args[0])
         end
 
-        def stringify_values(hash)
-          hash.inject({}) do |hash_copy, (key, value)|
-            hash_copy[key] = stringify(value)
-            hash_copy
+        def normalize_values(hash)
+          hash.each_with_object({}) do |(key, value), hash_copy|
+            hash_copy[key] = symbolize_or_stringify(key, value)
+          end
+        end
+
+        def symbolize_or_stringify(key, value)
+          if key.in?(PARAMS_TO_SYMBOLIZE)
+            value.to_sym
+          else
+            stringify(value)
           end
         end
 

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

@@ -0,0 +1,34 @@
+module Shoulda
+  module Matchers
+    module ActionController
+      # @private
+      class SessionStore
+        attr_accessor :controller
+
+        def name
+          'session'
+        end
+
+        def has_key?(key)
+          session.key?(key)
+        end
+
+        def has_value?(expected_value)
+          session.values.any? do |actual_value|
+            expected_value === actual_value
+          end
+        end
+
+        def empty?
+          session.empty?
+        end
+
+        private
+
+        def session
+          controller.session
+        end
+      end
+    end
+  end
+end

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

@@ -1,3 +1,5 @@
+require 'forwardable'
+
 module Shoulda
   module Matchers
     module ActionController
@@ -146,162 +148,54 @@ module Shoulda
       # @return [SetFlashMatcher]
       #
       def set_flash
-        SetFlashMatcher.new
-      end
-
-      # @deprecated Use {#set_flash} instead.
-      # @return [SetFlashMatcher]
-      def set_the_flash
-        Shoulda::Matchers.warn_about_deprecated_method(
-          :set_the_flash,
-          :set_flash
-        )
-        set_flash
+        SetFlashMatcher.new.in_context(self)
       end
 
       # @private
       class SetFlashMatcher
+        extend Forwardable
+
+        def_delegators :underlying_matcher,
+          :description,
+          :matches?,
+          :failure_message,
+          :failure_message_when_negated
+        alias_method \
+          :failure_message_for_should,
+          :failure_message
+        alias_method \
+          :failure_message_for_should_not,
+          :failure_message_when_negated
+
         def initialize
-          @options = {}
-          @value = nil
+          store = FlashStore.future
+          @underlying_matcher = SetSessionOrFlashMatcher.new(store)
         end
 
-        def to(value)
-          if !value.is_a?(String) && !value.is_a?(Regexp)
-            raise "cannot match against #{value.inspect}"
-          end
-          @value = value
+        def now
+          store = FlashStore.now
+          @underlying_matcher = SetSessionOrFlashMatcher.new(store)
           self
         end
 
-        def now
-          @options[:now] = true
+        def in_context(context)
+          underlying_matcher.in_context(context)
           self
         end
 
         def [](key)
-          @options[:key] = key
+          underlying_matcher[key]
           self
         end
 
-        def matches?(controller)
-          @controller = controller
-          sets_the_flash? && string_value_matches? && regexp_value_matches?
-        end
-
-        def description
-          description = "set the #{expected_flash_invocation}"
-          description << " to #{@value.inspect}" unless @value.nil?
-          description
-        end
-
-        def failure_message
-          "Expected #{expectation}"
-        end
-        alias failure_message_for_should failure_message
-
-        def failure_message_when_negated
-          "Did not expect #{expectation}"
-        end
-        alias failure_message_for_should_not failure_message_when_negated
-
-        private
-
-        def sets_the_flash?
-          flash_values.any?
-        end
-
-        def string_value_matches?
-          if @value.is_a?(String)
-            flash_values.any? {|value| value == @value }
-          else
-            true
-          end
-        end
-
-        def regexp_value_matches?
-          if @value.is_a?(Regexp)
-            flash_values.any? {|value| value =~ @value }
-          else
-            true
-          end
-        end
-
-        def flash_values
-          if @options.key?(:key)
-            flash_hash = HashWithIndifferentAccess.new(flash.to_hash)
-            [flash_hash[@options[:key]]]
-          else
-            flash.to_hash.values
-          end
-        end
-
-        def flash
-          @flash ||= copy_of_flash_from_controller
-        end
-
-        def copy_of_flash_from_controller
-          @controller.flash.dup.tap do |flash|
-            copy_flashes(@controller.flash, flash)
-            copy_discard_if_necessary(@controller.flash, flash)
-            sweep_flash_if_necessary(flash)
-          end
-        end
-
-        def copy_flashes(original_flash, new_flash)
-          flashes_ivar = Shoulda::Matchers::RailsShim.flashes_ivar
-          flashes = original_flash.instance_variable_get(flashes_ivar).dup
-          new_flash.instance_variable_set(flashes_ivar, flashes)
-        end
-
-        def copy_discard_if_necessary(original_flash, new_flash)
-          discard_ivar = :@discard
-          if original_flash.instance_variable_defined?(discard_ivar)
-            discard = original_flash.instance_variable_get(discard_ivar).dup
-            new_flash.instance_variable_set(discard_ivar, discard)
-          end
-        end
-
-        def sweep_flash_if_necessary(flash)
-          unless @options[:now]
-            flash.sweep
-          end
-        end
-
-        def expectation
-          expectation = "the #{expected_flash_invocation} to be set"
-          expectation << " to #{@value.inspect}" unless @value.nil?
-          expectation << ", but #{flash_description}"
-          expectation
-        end
-
-        def flash_description
-          if flash.blank?
-            'no flash was set'
-          else
-            "was #{flash.inspect}"
-          end
+        def to(expected_value = nil, &block)
+          underlying_matcher.to(expected_value, &block)
+          self
         end
 
-        def expected_flash_invocation
-          "flash#{pretty_now}#{pretty_key}"
-        end
+        protected
 
-        def pretty_now
-          if @options[:now]
-            '.now'
-          else
-            ''
-          end
-        end
-
-        def pretty_key
-          if @options[:key]
-            "[:#{@options[:key]}]"
-          else
-            ''
-          end
-        end
+        attr_reader :underlying_matcher
       end
     end
   end

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

@@ -1,3 +1,5 @@
+require 'forwardable'
+
 module Shoulda
   module Matchers
     module ActionController
@@ -112,132 +114,49 @@ module Shoulda
       #
       # @return [SetSessionMatcher]
       #
-      def set_session(key = nil)
-        SetSessionMatcher.new(key)
+      def set_session
+        SetSessionMatcher.new.in_context(self)
       end
 
       # @private
       class SetSessionMatcher
-        def initialize(key)
-          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
-          self
-        end
-
-        def matches?(controller)
-          @controller = controller
-
-          if @value_block
-            @value = @context.instance_eval(&@value_block)
-          end
+        extend Forwardable
 
-          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
-          "Expected #{expectation}, but #{result}"
-        end
-        alias failure_message_for_should failure_message
-
-        def failure_message_when_negated
-          "Didn't expect #{expectation}, but it was"
-        end
-        alias failure_message_for_should_not failure_message_when_negated
+        def_delegators :underlying_matcher,
+          :description,
+          :matches?,
+          :failure_message,
+          :failure_message_when_negated
+        alias_method \
+          :failure_message_for_should,
+          :failure_message
+        alias_method \
+          :failure_message_for_should_not,
+          :failure_message_when_negated
 
-        def description
-          "should #{expectation}"
+        def initialize
+          store = SessionStore.new
+          @underlying_matcher = SetSessionOrFlashMatcher.new(store)
         end
 
         def in_context(context)
-          @context = context
+          underlying_matcher.in_context(context)
           self
         end
 
-        private
-
-        def key_specified?
-          defined?(@key)
-        end
-
-        def value_specified?
-          defined?(@value)
-        end
-
-        def value_or_default_value
-          defined?(@value) && @value
-        end
-
-        def nil_value_expected_but_actual_value_unset?
-          value_specified? && @value.nil? && !session.key?(@key)
-        end
-
-        def session_present?
-          !session.empty?
+        def [](key)
+          underlying_matcher[key]
+          self
         end
 
-        def expectation
-          expectation = ""
-
-          if key_specified?
-            expectation << "session variable #{@key.inspect}"
-          else
-            expectation << "any session variable"
-          end
-
-          expectation << " to be"
-
-          if value_specified? && !@value.nil?
-            expectation << " #{@value.inspect}"
-          else
-            expectation << " set"
-          end
-
-          expectation
+        def to(expected_value = nil, &block)
+          underlying_matcher.to(expected_value, &block)
+          self
         end
 
-        def result
-          if session_present?
-            "the session was #{session.inspect}"
-          else
-            'no session variables were set'
-          end
-        end
+        protected
 
-        def session
-          @controller.session
-        end
+        attr_reader :underlying_matcher
       end
     end
   end