lockbox_middleware 1.2.1 → 1.2.2

data/vendor/gems/shoulda-2.10.2/lib/shoulda/action_controller/macros.rb

@@ -1,240 +0,0 @@
-module Shoulda # :nodoc:
-  module ActionController # :nodoc:
-    # = Macro test helpers for your controllers
-    #
-    # By using the macro helpers you can quickly and easily create concise and easy to read test suites.
-    #
-    # This code segment:
-    #   context "on GET to :show for first record" do
-    #     setup do
-    #       get :show, :id => 1
-    #     end
-    #
-    #     should_assign_to :user
-    #     should_respond_with :success
-    #     should_render_template :show
-    #     should_not_set_the_flash
-    #
-    #     should "do something else really cool" do
-    #       assert_equal 1, assigns(:user).id
-    #     end
-    #   end
-    #
-    # Would produce 5 tests for the +show+ action
-    module Macros
-      include Matchers
-
-      # Macro that creates a test asserting that the flash contains the given
-      # value. Expects a +String+ or +Regexp+.
-      #
-      # If the argument is +nil+, it will assert that the flash is not set.
-      # This behavior is deprecated.
-      #
-      # Example:
-      #
-      #   should_set_the_flash_to "Thank you for placing this order."
-      #   should_set_the_flash_to /created/i
-      def should_set_the_flash_to(val)
-        if val
-          matcher = set_the_flash.to(val)
-          should matcher.description do
-            assert_accepts matcher, @controller
-          end
-        else
-          warn "[DEPRECATION] should_set_the_flash_to nil is deprecated. " <<
-               "Use should_not_set_the_flash instead."
-          should_not_set_the_flash
-        end
-      end
-
-      # Macro that creates a test asserting that the flash is empty.
-      def should_not_set_the_flash
-        matcher = set_the_flash
-        should "not #{matcher.description}" do
-          assert_rejects matcher, @controller
-        end
-      end
-
-      # Macro that creates a test asserting that filter_parameter_logging
-      # is set for the specified keys
-      #
-      # Example:
-      #
-      #   should_filter_params :password, :ssn
-      def should_filter_params(*keys)
-        keys.each do |key|
-          matcher = filter_param(key)
-          should matcher.description do
-            assert_accepts matcher, @controller
-          end
-        end
-      end
-
-      # Macro that creates a test asserting that the controller assigned to
-      # each of the named instance variable(s).
-      #
-      # Options:
-      # * <tt>:class</tt> - The expected class of the instance variable being checked.
-      #
-      # If a block is passed, the assigned variable is expected to be equal to
-      # the return value of that block.
-      #
-      # Example:
-      #
-      #   should_assign_to :user, :posts
-      #   should_assign_to :user, :class => User
-      #   should_assign_to(:user) { @user }
-      def should_assign_to(*names, &block)
-        klass = get_options!(names, :class)
-        names.each do |name|
-          matcher = assign_to(name).with_kind_of(klass)
-          should matcher.description do
-            if block
-              expected_value = instance_eval(&block)
-              matcher = matcher.with(expected_value)
-            end
-
-            assert_accepts matcher, @controller
-          end
-        end
-      end
-
-      # Macro that creates a test asserting that the controller did not assign to
-      # any of the named instance variable(s).
-      #
-      # Example:
-      #
-      #   should_not_assign_to :user, :posts
-      def should_not_assign_to(*names)
-        names.each do |name|
-          matcher = assign_to(name)
-          should "not #{matcher.description}" do
-            assert_rejects matcher, @controller
-          end
-        end
-      end
-
-      # Macro that creates a test asserting that the controller responded with a 'response' status code.
-      # Example:
-      #
-      #   should_respond_with :success
-      def should_respond_with(response)
-        should "respond with #{response}" do
-          matcher = respond_with(response)
-          assert_accepts matcher, @controller
-        end
-      end
-
-      # Macro that creates a test asserting that the response content type was 'content_type'.
-      # Example:
-      #
-      #   should_respond_with_content_type 'application/rss+xml'
-      #   should_respond_with_content_type :rss
-      #   should_respond_with_content_type /rss/
-      def should_respond_with_content_type(content_type)
-        matcher = respond_with_content_type(content_type)
-        should matcher.description do
-          assert_accepts matcher, @controller
-        end
-      end
-
-      # Macro that creates a test asserting that a value returned from the
-      # session is correct. Expects the session key as a parameter, and a block
-      # that returns the expected value.
-      #
-      # Example:
-      #
-      #   should_set_session(:user_id) { @user.id }
-      #   should_set_session(:message) { "Free stuff" }
-      def should_set_session(key, &block)
-        matcher = set_session(key)
-        should matcher.description do
-          expected_value = instance_eval(&block)
-          matcher = matcher.to(expected_value)
-          assert_accepts matcher, @controller
-        end
-      end
-
-      # Macro that creates a test asserting that the controller rendered the given template.
-      # Example:
-      #
-      #   should_render_template :new
-      def should_render_template(template)
-        should "render template #{template.inspect}" do
-          assert_template template.to_s
-        end
-      end
-
-      # Macro that creates a test asserting that the controller rendered with the given layout.
-      # Example:
-      #
-      #   should_render_with_layout 'special'
-      def should_render_with_layout(expected_layout = 'application')
-        matcher = render_with_layout(expected_layout)
-        if expected_layout
-          should matcher.description do
-            assert_accepts matcher, @controller
-          end
-        else
-          should "render without layout" do
-            assert_rejects matcher, @controller
-          end
-        end
-      end
-
-      # Macro that creates a test asserting that the controller rendered without a layout.
-      # Same as @should_render_with_layout false@
-      def should_render_without_layout
-        should_render_with_layout nil
-      end
-
-      # Macro that creates a test asserting that the controller returned a
-      # redirect to the given path. The passed description will be used when
-      # generating a test name. Expects a block that returns the expected path
-      # for the redirect.
-      #
-      # Example:
-      #
-      #   should_redirect_to("the user's profile") { user_url(@user) }
-      def should_redirect_to(description, &block)
-        should "redirect to #{description}" do
-          expected_url = instance_eval(&block)
-          assert_redirected_to expected_url
-        end
-      end
-
-      # Macro that creates a routing test. It tries to use the given HTTP
-      # +method+ on the given +path+, and asserts that it routes to the
-      # given +options+.
-      #
-      # If you don't specify a :controller, it will try to guess the controller
-      # based on the current test.
-      #
-      # +to_param+ is called on the +options+ given.
-      #
-      # Examples:
-      #
-      #   should_route :get, "/posts", :controller => :posts, :action => :index
-      #   should_route :get, "/posts/new", :action => :new
-      #   should_route :post, "/posts", :action => :create
-      #   should_route :get, "/posts/1", :action => :show, :id => 1
-      #   should_route :edit, "/posts/1", :action => :show, :id => 1
-      #   should_route :put, "/posts/1", :action => :update, :id => 1
-      #   should_route :delete, "/posts/1", :action => :destroy, :id => 1
-      #   should_route :get, "/users/1/posts/1",
-      #     :action => :show, :id => 1, :user_id => 1
-      #
-      def should_route(method, path, options)
-        unless options[:controller]
-          options[:controller] = self.name.gsub(/ControllerTest$/, '').tableize
-        end
-
-        matcher = route(method, path).to(options)
-
-        should matcher.description do
-          assert_accepts matcher.in_context(self), self
-        end
-      end
-    end
-  end
-end

data/vendor/gems/shoulda-2.10.2/lib/shoulda/action_controller/matchers/assign_to_matcher.rb

@@ -1,109 +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)
-          @expected_value = expected_value
-          self
-        end
-
-        def matches?(controller)
-          @controller = controller
-          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
-
-        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
-          assigns[@variable]
-        end
-
-        def assigns
-          @controller.response.template.assigns 
-        end
-
-      end
-
-    end
-  end
-end

data/vendor/gems/shoulda-2.10.2/lib/shoulda/action_controller/matchers/filter_param_matcher.rb

@@ -1,57 +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)
-        end
-
-        def filters_key?
-          filtered_value == '[FILTERED]'
-        end
-
-        def filtered_value
-          filtered = @controller.send(:filter_parameters,
-                                      @key.to_s => @key.to_s)
-          filtered[@key.to_s]
-        end
-
-      end
-
-    end
-  end
-end

data/vendor/gems/shoulda-2.10.2/lib/shoulda/action_controller/matchers/render_with_layout_matcher.rb

@@ -1,81 +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(layout = nil)
-        RenderWithLayout.new(layout)
-      end
-
-      class RenderWithLayout # :nodoc:
-
-        def initialize(layout)
-          @layout = layout.to_s unless layout.nil?
-        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 @layout.nil?
-            description << "a layout"
-          else
-            description << "the #{@layout.inspect} layout"
-          end
-          description
-        end
-
-        private
-
-        def rendered_with_layout?
-          !layout.blank?
-        end
-
-        def rendered_with_expected_layout?
-          return true if @layout.nil?
-          layout == @layout
-        end
-
-        def layout
-          layout = @controller.response.layout
-          if layout.nil?
-            nil
-          else
-            layout.split('/').last
-          end
-        end
-
-        def expectation
-          "to #{description}"
-        end
-
-        def result
-          if rendered_with_layout?
-            "rendered with the #{layout.inspect} layout"
-          else
-            "rendered without a layout"
-          end
-        end
-
-      end
-
-    end
-  end
-end

data/vendor/gems/shoulda-2.10.2/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
-        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

data/vendor/gems/shoulda-2.10.2/lib/shoulda/action_controller/matchers/respond_with_matcher.rb

@@ -1,81 +0,0 @@
-module Shoulda # :nodoc:
-  module ActionController # :nodoc:
-    module Matchers
-
-      # Ensures a controller responded with expected 'response' status code.
-      #
-      # You can pass an explicit status number like 200, 301, 404, 500
-      # or its symbolic equivalent :success, :redirect, :missing, :error.
-      # See ActionController::StatusCodes for a full list.
-      #
-      # Example:
-      #
-      #   it { should respond_with(:success)  }
-      #   it { should respond_with(:redirect) }
-      #   it { should respond_with(:missing)  }
-      #   it { should respond_with(:error)    }
-      #   it { should respond_with(501)       }
-      def respond_with(status)
-        RespondWithMatcher.new(status)
-      end
-
-      class RespondWithMatcher # :nodoc:
-
-        def initialize(status)
-          @status = symbol_to_status_code(status)
-        end
-        
-        def matches?(controller)
-          @controller = controller
-          correct_status_code? || correct_status_code_range?
-        end
-        
-        def failure_message
-          "Expected #{expectation}"
-        end
-        
-        def negative_failure_message
-          "Did not expect #{expectation}"
-        end
-
-        def description
-          "respond with #{@status}"
-        end
-        
-        protected
-        
-        def correct_status_code?
-          response_code == @status
-        end
-        
-        def correct_status_code_range?
-          @status.is_a?(Range) &&
-            @status.include?(response_code)
-        end
-        
-        def response_code
-          @controller.response.response_code
-        end
-        
-        def symbol_to_status_code(potential_symbol)
-          case potential_symbol
-          when :success  then 200
-          when :redirect then 300..399
-          when :missing  then 404
-          when :error    then 500..599
-          when Symbol 
-            ::ActionController::StatusCodes::SYMBOL_TO_STATUS_CODE[potential_symbol]
-          else
-            potential_symbol
-          end
-        end
-        
-        def expectation
-          "response to be a #{@status}, but was #{response_code}"
-        end
-        
-      end
-      
-    end
-  end
-end