putio 0.0.1.pre

data/development/ruby/1.8/gems/shoulda-2.11.3/lib/shoulda/action_controller/macros.rb

@@ -0,0 +1,221 @@
+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
+
+      # Deprecated: use ActionController::Matchers#set_the_flash instead.
+      #
+      # Macro that creates a test asserting that the flash contains the given
+      # value. Expects a +String+ or +Regexp+.
+      #
+      # 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)
+        ::ActiveSupport::Deprecation.warn("use: should set_the_flash")
+        should set_the_flash.to(val)
+      end
+
+      # Deprecated: use ActionController::Matchers#set_the_flash instead.
+      #
+      # Macro that creates a test asserting that the flash is empty.
+      def should_not_set_the_flash
+        ::ActiveSupport::Deprecation.warn("use: should_not set_the_flash")
+        should_not set_the_flash
+      end
+
+      # Deprecated: use ActionController::Matchers#filter_param instead.
+      #
+      # 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)
+        ::ActiveSupport::Deprecation.warn("use: should filter_param")
+        keys.each do |key|
+          should filter_param(key)
+        end
+      end
+
+      # Deprecated: use ActionController::Matchers#assign_to instead.
+      #
+      # 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)
+        ::ActiveSupport::Deprecation.warn("use: should assign_to")
+        klass = get_options!(names, :class)
+        names.each do |name|
+          matcher = assign_to(name).with_kind_of(klass)
+          matcher = matcher.with(&block) if block
+          should matcher
+        end
+      end
+
+      # Deprecated: use ActionController::Matchers#assign_to instead.
+      #
+      # 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)
+        ::ActiveSupport::Deprecation.warn("use: should_not assign_to")
+        names.each do |name|
+          should_not assign_to(name)
+        end
+      end
+
+      # Deprecated: use ActionController::Matchers#respond_with instead.
+      #
+      # 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)
+        ::ActiveSupport::Deprecation.warn("use: should respond_with")
+        should respond_with(response)
+      end
+
+      # Deprecated: use ActionController::Matchers#respond_with_content_type instead.
+      #
+      # 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)
+        ::ActiveSupport::Deprecation.warn("use: should respond_with_content_type")
+        should respond_with_content_type(content_type)
+      end
+
+      # Deprecated: use ActionController::Matchers#set_session instead.
+      #
+      # 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)
+        ::ActiveSupport::Deprecation.warn("use: should set_session")
+        matcher = set_session(key)
+        matcher = matcher.to(&block) if block
+        should matcher
+      end
+
+      # Deprecated: use ActionController::Matchers#render_template instead.
+      #
+      # Macro that creates a test asserting that the controller rendered the given template.
+      # Example:
+      #
+      #   should_render_template :new
+      def should_render_template(template)
+        ::ActiveSupport::Deprecation.warn("use: should render_template")
+        should render_template(template)
+      end
+
+      # Deprecated: use ActionController::Matchers#render_with_layout instead.
+      #
+      # 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')
+        ::ActiveSupport::Deprecation.warn("use: should render_with_layout")
+        should render_with_layout(expected_layout)
+      end
+
+      # Deprecated: use ActionController::Matchers#render_with_layout instead.
+      #
+      # 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
+        ::ActiveSupport::Deprecation.warn("use: should_not render_with_layout")
+        should_not render_with_layout
+      end
+
+      # Deprecated: use ActionController::Matchers#redirect_to instead.
+      #
+      # 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)
+        ::ActiveSupport::Deprecation.warn("use: should redirect_to")
+        should redirect_to(description, &block)
+      end
+
+      # Deprecated: use ActionController::Matchers#route instead.
+      #
+      # 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)
+        ::ActiveSupport::Deprecation.warn("use: should route")
+        should route(method, path).to(options)
+      end
+    end
+  end
+end

data/development/ruby/1.8/gems/shoulda-2.11.3/lib/shoulda/action_controller/matchers/assign_to_matcher.rb

@@ -0,0 +1,112 @@
+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/development/ruby/1.8/gems/shoulda-2.11.3/lib/shoulda/action_controller/matchers/filter_param_matcher.rb

@@ -0,0 +1,74 @@
+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/development/ruby/1.8/gems/shoulda-2.11.3/lib/shoulda/action_controller/matchers/redirect_to_matcher.rb

@@ -0,0 +1,62 @@
+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/development/ruby/1.8/gems/shoulda-2.11.3/lib/shoulda/action_controller/matchers/render_template_matcher.rb

@@ -0,0 +1,54 @@
+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/development/ruby/1.8/gems/shoulda-2.11.3/lib/shoulda/action_controller/matchers/render_with_layout_matcher.rb

@@ -0,0 +1,99 @@
+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/development/ruby/1.8/gems/shoulda-2.11.3/lib/shoulda/action_controller/matchers/respond_with_content_type_matcher.rb

@@ -0,0 +1,74 @@
+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