shoulda 2.11.3 → 3.0.0.beta1

data/lib/shoulda/action_controller/matchers.rb

@@ -1,39 +0,0 @@
-require 'shoulda/action_controller/matchers/assign_to_matcher'
-require 'shoulda/action_controller/matchers/filter_param_matcher'
-require 'shoulda/action_controller/matchers/set_the_flash_matcher'
-require 'shoulda/action_controller/matchers/render_with_layout_matcher'
-require 'shoulda/action_controller/matchers/respond_with_matcher'
-require 'shoulda/action_controller/matchers/respond_with_content_type_matcher'
-require 'shoulda/action_controller/matchers/set_session_matcher'
-require 'shoulda/action_controller/matchers/route_matcher'
-require 'shoulda/action_controller/matchers/redirect_to_matcher'
-require 'shoulda/action_controller/matchers/render_template_matcher'
-
-module Shoulda # :nodoc:
-  module ActionController # :nodoc:
-
-    # By using the macro helpers you can quickly and easily create concise and
-    # easy to read test suites.
-    #
-    # This code segment:
-    #
-    #   describe UsersController, "on GET to show with a valid id" do
-    #     before(:each) do
-    #       get :show, :id => User.first.to_param
-    #     end
-    #
-    #     it { should assign_to(:user) }
-    #     it { should respond_with(:success) }
-    #     it { should render_template(:show) }
-    #     it { should not_set_the_flash) }
-    #
-    #     it "should do something else really cool" do
-    #       assigns[:user].id.should == 1
-    #     end
-    #   end
-    #
-    # Would produce 5 tests for the show action
-    module Matchers
-    end
-  end
-end

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

@@ -1,112 +0,0 @@
-module Shoulda # :nodoc:
-  module ActionController # :nodoc:
-    module Matchers
-
-      # Ensures that the controller assigned to the named instance variable.
-      #
-      # Options:
-      # * <tt>with_kind_of</tt> - The expected class of the instance variable
-      #   being checked.
-      # * <tt>with</tt> - The value that should be assigned.
-      #
-      # Example:
-      #
-      #   it { should assign_to(:user) }
-      #   it { should_not assign_to(:user) }
-      #   it { should assign_to(:user).with_kind_of(User) }
-      #   it { should assign_to(:user).with(@user) }
-      def assign_to(variable)
-        AssignToMatcher.new(variable)
-      end
-
-      class AssignToMatcher # :nodoc:
-
-        def initialize(variable)
-          @variable = variable.to_s
-        end
-
-        def with_kind_of(expected_class)
-          @expected_class = expected_class
-          self
-        end
-
-        def with(expected_value = nil, &block)
-          @expected_value = expected_value
-          @expectation_block = block
-          self
-        end
-
-        def matches?(controller)
-          @controller = controller
-          @expected_value = @context.instance_eval(&@expectation_block) if @expectation_block
-          assigned_value? && kind_of_expected_class? && equal_to_expected_value?
-        end
-
-        attr_reader :failure_message, :negative_failure_message
-
-        def description
-          description = "assign @#{@variable}"
-          description << " with a kind of #{@expected_class}" if @expected_class
-          description
-        end
-
-        def in_context(context)
-          @context = context
-          self
-        end
-
-        private
-
-        def assigned_value?
-          if assigned_value.nil?
-            @failure_message =
-              "Expected action to assign a value for @#{@variable}"
-            false
-          else
-            @negative_failure_message =
-              "Didn't expect action to assign a value for @#{@variable}, " <<
-              "but it was assigned to #{assigned_value.inspect}"
-            true
-          end
-        end
-
-        def kind_of_expected_class?
-          return true unless @expected_class
-          if assigned_value.kind_of?(@expected_class)
-            @negative_failure_message =
-              "Didn't expect action to assign a kind of #{@expected_class} " <<
-              "for #{@variable}, but got one anyway"
-            true
-          else
-            @failure_message =
-              "Expected action to assign a kind of #{@expected_class} " <<
-              "for #{@variable}, but got #{@variable.inspect} " <<
-              "(#{@variable.class.name})"
-            false
-          end
-        end
-
-        def equal_to_expected_value?
-          return true unless @expected_value
-          if @expected_value == assigned_value
-            @negative_failure_message =
-              "Didn't expect action to assign #{@expected_value.inspect} " <<
-              "for #{@variable}, but got it anyway"
-            true
-          else
-            @failure_message =
-              "Expected action to assign #{@expected_value.inspect} " <<
-              "for #{@variable}, but got #{assigned_value.inspect}"
-            false
-          end
-        end
-
-        def assigned_value
-          @controller.instance_variable_get("@#{@variable}")
-        end
-
-      end
-
-    end
-  end
-end

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

@@ -1,74 +0,0 @@
-module Shoulda # :nodoc:
-  module ActionController # :nodoc:
-    module Matchers
-
-      # Ensures that filter_parameter_logging is set for the specified key.
-      #
-      # Example:
-      #
-      #   it { should filter_param(:password) }
-      def filter_param(key)
-        FilterParamMatcher.new(key)
-      end
-
-      class FilterParamMatcher # :nodoc:
-
-        def initialize(key)
-          @key = key.to_s
-        end
-
-        def matches?(controller)
-          @controller = controller
-          filters_params? && filters_key?
-        end
-
-        def failure_message
-          "Expected #{@key} to be filtered"
-        end
-
-        def negative_failure_message
-          "Did not expect #{@key} to be filtered"
-        end
-
-        def description
-          "filter #{@key}"
-        end
-
-        private
-
-        def filters_params?
-          @controller.respond_to?(:filter_parameters) ||
-            request.respond_to?(:filtered_parameters)
-        end
-
-        def filters_key?
-          filtered_value == '[FILTERED]'
-        end
-
-        def filtered_value
-          if request.respond_to?(:filtered_parameters)
-            filtered_request_value
-          else
-            filtered_controller_value
-          end
-        end
-
-        def filtered_controller_value
-          filtered = @controller.send(:filter_parameters,
-                                      @key.to_s => @key.to_s)
-          filtered[@key.to_s]
-        end
-
-        def filtered_request_value
-          request.env['action_dispatch.request.parameters'] = { @key.to_s => 'value' }
-          request.filtered_parameters[@key.to_s]
-        end
-
-        def request
-          @request ||= ::ActionController::TestRequest.new
-        end
-      end
-
-    end
-  end
-end

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

@@ -1,62 +0,0 @@
-module Shoulda # :nodoc:
-  module ActionController # :nodoc:
-    module Matchers
-
-      # Ensures a controller redirected to the given url.
-      #
-      # Example:
-      #
-      #   it { should redirect_to('http://somewhere.com')  }
-      #   it { should redirect_to(users_path)  }
-      def redirect_to(url_or_description, &block)
-        RedirectToMatcher.new(url_or_description, self, &block)
-      end
-
-      class RedirectToMatcher # :nodoc:
-
-        def initialize(url_or_description, context, &block)
-          if block
-            @url_block = block
-            @location = @url_or_description
-          else
-            @url = url_or_description
-            @location = @url
-          end
-          @context = context
-        end
-
-        def in_context(context)
-          @context = context
-          self
-        end
-
-        def matches?(controller)
-          @controller = controller
-          redirects_to_url?
-        end
-
-        attr_reader :failure_message, :negative_failure_message
-
-        def description
-          "redirect to #{@location}"
-        end
-
-        private
-
-        def redirects_to_url?
-          @url = @context.instance_eval(&@url_block) if @url_block
-          begin
-            @context.send(:assert_redirected_to, @url)
-            @negative_failure_message = "Didn't expect to redirect to #{@url}"
-            true
-          rescue Test::Unit::AssertionFailedError => error
-            @failure_message = error.message
-            false
-          end
-        end
-
-      end
-
-    end
-  end
-end

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

@@ -1,54 +0,0 @@
-module Shoulda # :nodoc:
-  module ActionController # :nodoc:
-    module Matchers
-
-      # Ensures a controller rendered the given template.
-      #
-      # Example:
-      #
-      #   it { should render_template(:show)  }
-      def render_template(template)
-        RenderTemplateMatcher.new(template, self)
-      end
-
-      class RenderTemplateMatcher # :nodoc:
-
-        def initialize(template, context)
-          @template = template.to_s
-          @context  = context
-        end
-
-        def matches?(controller)
-          @controller = controller
-          renders_template?
-        end
-
-        attr_reader :failure_message, :negative_failure_message
-
-        def description
-          "render template #{@template}"
-        end
-
-        def in_context(context)
-          @context = context
-          self
-        end
-
-        private
-
-        def renders_template?
-          begin
-            @context.send(:assert_template, @template)
-            @negative_failure_message = "Didn't expect to render #{@template}"
-            true
-          rescue Test::Unit::AssertionFailedError => error
-            @failure_message = error.message
-            false
-          end
-        end
-
-      end
-
-    end
-  end
-end

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

@@ -1,99 +0,0 @@
-module Shoulda # :nodoc:
-  module ActionController # :nodoc:
-    module Matchers
-
-      # Ensures that the controller rendered with the given layout.
-      #
-      # Example:
-      #
-      #   it { should render_with_layout }
-      #   it { should render_with_layout(:special) }
-      #   it { should_not render_with_layout }
-      def render_with_layout(expected_layout = nil)
-        RenderWithLayout.new(expected_layout)
-      end
-
-      class RenderWithLayout # :nodoc:
-
-        def initialize(expected_layout)
-          @expected_layout = expected_layout.to_s unless expected_layout.nil?
-        end
-
-        # Used to provide access to layouts recorded by
-        # ActionController::TemplateAssertions in Rails 3
-        def in_context(context)
-          @context = context
-          self
-        end
-
-        def matches?(controller)
-          @controller = controller
-          rendered_with_layout? && rendered_with_expected_layout?
-        end
-
-        def failure_message
-          "Expected #{expectation}, but #{result}"
-        end
-
-        def negative_failure_message
-          "Did not expect #{expectation}, but #{result}"
-        end
-
-        def description
-          description = "render with "
-          if @expected_layout.nil?
-            description << "a layout"
-          else
-            description << "the #{@expected_layout.inspect} layout"
-          end
-          description
-        end
-
-        private
-
-        def rendered_with_layout?
-          !rendered_layouts.empty?
-        end
-
-        def rendered_with_expected_layout?
-          return true if @expected_layout.nil?
-          rendered_layouts.include?(@expected_layout)
-        end
-
-        def rendered_layouts
-          if recorded_layouts
-            recorded_layouts.keys.compact.map { |layout| layout.sub(%r{^layouts/}, '') }
-          else
-            layout = @controller.response.layout
-            if layout.nil?
-              []
-            else
-              [layout.split('/').last]
-            end
-          end
-        end
-
-        def recorded_layouts
-          if @context
-            @context.instance_variable_get('@layouts')
-          end
-        end
-
-        def expectation
-          "to #{description}"
-        end
-
-        def result
-          if rendered_with_layout?
-            "rendered with " <<
-              rendered_layouts.map { |layout| layout.inspect }.join(", ")
-          else
-            "rendered without a layout"
-          end
-        end
-
-      end
-
-    end
-  end
-end

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

@@ -1,74 +0,0 @@
-module Shoulda # :nodoc:
-  module ActionController # :nodoc:
-    module Matchers
-
-      # Ensures a controller responded with expected 'response' content type.
-      #
-      # You can pass an explicit content type such as 'application/rss+xml'
-      # or its symbolic equivalent :rss
-      # or a regular expression such as /rss/
-      #
-      # Example:
-      #
-      #   it { should respond_with_content_type(:xml)  }
-      #   it { should respond_with_content_type(:csv)  }
-      #   it { should respond_with_content_type(:atom) }
-      #   it { should respond_with_content_type(:yaml) }
-      #   it { should respond_with_content_type(:text) }
-      #   it { should respond_with_content_type('application/rss+xml')  }
-      #   it { should respond_with_content_type(/json/) }
-      def respond_with_content_type(content_type)
-        RespondWithContentTypeMatcher.new(content_type)
-      end
-
-      class RespondWithContentTypeMatcher # :nodoc:
-
-        def initialize(content_type)
-          @content_type = if content_type.is_a?(Symbol)
-            lookup_by_extension(content_type)
-          else
-            content_type
-          end
-        end
-
-        def description
-          "respond with content type of #{@content_type}"
-        end
-
-        def matches?(controller)
-          @controller = controller
-          if @content_type.is_a?(Regexp)
-            response_content_type =~ @content_type
-          else
-            response_content_type == @content_type
-          end
-        end
-
-        def failure_message
-          "Expected #{expectation}"
-        end
-
-        def negative_failure_message
-          "Did not expect #{expectation}"
-        end
-
-        protected
-
-        def response_content_type
-          @controller.response.content_type.to_s
-        end
-
-        def lookup_by_extension(extension)
-          Mime::Type.lookup_by_extension(extension.to_s).to_s
-        end
-
-        def expectation
-          "content type to be #{@content_type}, " <<
-          "but was #{response_content_type}"
-        end
-
-      end
-
-    end
-  end
-end