mcmire-shoulda-matchers 2.5.0

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

@@ -0,0 +1,48 @@
+module Shoulda
+  module Matchers
+    module ActionController
+      # @private
+      class RouteParams
+        def initialize(args)
+          @args = args
+        end
+
+        def normalize
+          if controller_and_action_given_as_string?
+            extract_params_from_string
+          else
+            stringify_params
+          end
+        end
+
+        private
+
+        attr_reader :args
+
+        def controller_and_action_given_as_string?
+          args[0].is_a?(String)
+        end
+
+        def extract_params_from_string
+          params = args[1] || {}
+          controller, action = args[0].split('#')
+          params.merge!(controller: controller, action: action)
+        end
+
+        def stringify_params
+          args[0].each do |key, value|
+            args[0][key] = stringify(value)
+          end
+        end
+
+        def stringify(value)
+          if value.is_a?(Array)
+            value.map(&:to_param)
+          else
+            value.to_param
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,164 @@
+module Shoulda
+  module Matchers
+    module ActionController
+      # The `set_session` matcher is used to make assertions about the
+      # `session` hash.
+      #
+      #     class PostsController < ApplicationController
+      #       def show
+      #         session[:foo] = 'bar'
+      #       end
+      #     end
+      #
+      #     # RSpec
+      #     describe PostsController do
+      #       describe 'GET #show' do
+      #         before { get :show }
+      #
+      #         it { should set_session(:foo) }
+      #         it { should_not set_session(:baz) }
+      #       end
+      #     end
+      #
+      #     # Test::Unit
+      #     class PostsControllerTest < ActionController::TestCase
+      #       context 'GET #show' do
+      #         setup { get :show }
+      #
+      #         should set_session(:foo)
+      #         should_not set_session(:baz)
+      #       end
+      #     end
+      #
+      # #### Qualifiers
+      #
+      # ##### to
+      #
+      # Use `to` to assert that the key in the session hash was set to a
+      # particular value.
+      #
+      #     class PostsController < ApplicationController
+      #       def show
+      #         session[:foo] = 'bar'
+      #       end
+      #     end
+      #
+      #     # RSpec
+      #     describe PostsController do
+      #       describe 'GET #show' do
+      #         before { get :show }
+      #
+      #         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 #show' do
+      #         setup { get :show }
+      #
+      #         should set_session(:foo).to('bar')
+      #         should_not set_session(:foo).to('something else')
+      #       end
+      #     end
+      #
+      # @return [SetSessionMatcher]
+      #
+      def set_session(key)
+        SetSessionMatcher.new(key)
+      end
+
+      # @private
+      class SetSessionMatcher
+        def initialize(key)
+          @key = key.to_s
+        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
+          assigned_correct_value? || cleared_value?
+        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 #{result}"
+        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
+        end
+
+        def in_context(context)
+          @context = context
+          self
+        end
+
+        private
+
+        def assigned_value?
+          !assigned_value.nil?
+        end
+
+        def cleared_value?
+          defined?(@value) && @value.nil? && assigned_value.nil?
+        end
+
+        def assigned_correct_value?
+          if assigned_value?
+            if @value.nil?
+              true
+            else
+              assigned_value == @value
+            end
+          end
+        end
+
+        def assigned_value
+          session[@key]
+        end
+
+        def expectation
+          expectation = "session variable #{@key} to be set"
+          if @value
+            expectation << " to #{@value.inspect}"
+          end
+        end
+
+        def result
+          if session.empty?
+            'no session variables were set'
+          else
+            "the session was #{session.inspect}"
+          end
+        end
+
+        def session
+          if @controller.request.respond_to?(:session)
+            @controller.request.session.to_hash
+          else
+            @controller.response.session.data
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,296 @@
+module Shoulda
+  module Matchers
+    module ActionController
+      # The `set_the_flash` matcher is used to make assertions about the
+      # `flash` hash.
+      #
+      #     class PostsController < ApplicationController
+      #       def index
+      #         flash[:foo] = 'A candy bar'
+      #       end
+      #
+      #       def destroy
+      #       end
+      #     end
+      #
+      #     # RSpec
+      #     describe PostsController do
+      #       describe 'GET #index' do
+      #         before { get :index }
+      #
+      #         it { should set_the_flash }
+      #       end
+      #
+      #       describe 'DELETE #destroy' do
+      #         before { delete :destroy }
+      #
+      #         it { should_not set_the_flash }
+      #       end
+      #     end
+      #
+      #     # Test::Unit
+      #     class PostsControllerTest < ActionController::TestCase
+      #       context 'GET #index' do
+      #         setup { get :index }
+      #
+      #         should set_the_flash
+      #       end
+      #
+      #       context 'DELETE #destroy' do
+      #         setup { delete :destroy }
+      #
+      #         should_not set_the_flash
+      #       end
+      #     end
+      #
+      # #### Qualifiers
+      #
+      # ##### []
+      #
+      # Use `[]` to narrow the scope of the matcher to a particular key.
+      #
+      #     class PostsController < ApplicationController
+      #       def index
+      #         flash[:foo] = 'A candy bar'
+      #       end
+      #     end
+      #
+      #     # RSpec
+      #     describe PostsController do
+      #       describe 'GET #index' do
+      #         before { get :index }
+      #
+      #         it { should set_the_flash[:foo] }
+      #         it { should_not set_the_flash[:bar] }
+      #       end
+      #     end
+      #
+      #     # Test::Unit
+      #     class PostsControllerTest < ActionController::TestCase
+      #       context 'GET #index' do
+      #         setup { get :show }
+      #
+      #         should set_the_flash[:foo]
+      #         should_not set_the_flash[: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.
+      #
+      #     class PostsController < ApplicationController
+      #       def index
+      #         flash[:foo] = 'A candy bar'
+      #       end
+      #     end
+      #
+      #     # RSpec
+      #     describe PostsController do
+      #       describe 'GET #index' do
+      #         before { get :index }
+      #
+      #         it { should set_the_flash.to('A candy bar') }
+      #         it { should set_the_flash.to(/bar/) }
+      #         it { should set_the_flash[:foo].to('bar') }
+      #         it { should_not set_the_flash[:foo].to('something else') }
+      #       end
+      #     end
+      #
+      #     # Test::Unit
+      #     class PostsControllerTest < ActionController::TestCase
+      #       context 'GET #index' do
+      #         setup { get :show }
+      #
+      #         should set_the_flash.to('A candy bar')
+      #         should set_the_flash.to(/bar/)
+      #         should set_the_flash[:foo].to('bar')
+      #         should_not set_the_flash[:foo].to('something else')
+      #       end
+      #     end
+      #
+      # ##### now
+      #
+      # Use `now` to change the scope of the matcher to use the "now" hash
+      # instead of the usual "future" hash.
+      #
+      #     class PostsController < ApplicationController
+      #       def show
+      #         flash.now[:foo] = 'bar'
+      #       end
+      #     end
+      #
+      #     # RSpec
+      #     describe PostsController do
+      #       describe 'GET #show' do
+      #         before { get :show }
+      #
+      #         it { should set_the_flash.now }
+      #         it { should set_the_flash[:foo].now }
+      #         it { should set_the_flash[:foo].to('bar').now }
+      #       end
+      #     end
+      #
+      #     # Test::Unit
+      #     class PostsControllerTest < ActionController::TestCase
+      #       context 'GET #index' do
+      #         setup { get :show }
+      #
+      #         should set_the_flash.now
+      #         should set_the_flash[:foo].now
+      #         should set_the_flash[:foo].to('bar').now
+      #       end
+      #     end
+      #
+      # @return [SetTheFlashMatcher]
+      #
+      def set_the_flash
+        SetTheFlashMatcher.new
+      end
+
+      # @private
+      class SetTheFlashMatcher
+        def initialize
+          @options = {}
+        end
+
+        def to(value)
+          if !value.is_a?(String) && !value.is_a?(Regexp)
+            raise "cannot match against #{value.inspect}"
+          end
+          @value = value
+          self
+        end
+
+        def now
+          @options[:now] = true
+          self
+        end
+
+        def [](key)
+          @options[:key] = 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.to_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
+        end
+
+        def expected_flash_invocation
+          "flash#{pretty_now}#{pretty_key}"
+        end
+
+        def pretty_now
+          if @options[:now]
+            '.now'
+          else
+            ''
+          end
+        end
+
+        def pretty_key
+          if @options[:key]
+            "[:#{@options[:key]}]"
+          else
+            ''
+          end
+        end
+      end
+    end
+  end
+end