benhutton-remarkable_rails 4.0.0.alpha4

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

@@ -0,0 +1,95 @@
+module Remarkable
+  module ActionController
+    module Matchers
+      class AssignToMatcher < Remarkable::ActionController::Base #:nodoc:
+        arguments :collection => :names, :as => :name, :block => true
+
+        optional :with, :block => true
+        optional :with_kind_of
+
+        collection_assertions :assigned_value?, :is_kind_of?, :is_equal_value?
+
+        before_assert :evaluate_expected_value
+
+        protected
+
+          def assigned_value?
+            assigns.key?(@name)
+          end
+
+          def is_kind_of?
+            return true unless @options[:with_kind_of]
+            return assigns[@name].kind_of?(@options[:with_kind_of])
+          end
+
+          # Returns true if :with is not given and no block is given.
+          # In case :with is a proc or a block is given, we evaluate it in the
+          # @spec scope.
+          #
+          def is_equal_value?
+            return true unless value_to_compare?
+            assigns[@name] == @options[:with]
+          end
+
+          def assigns
+            #@subject.response.template.assigns.with_indifferent_access
+            @subject.instance_variable_get(:@assigns).with_indifferent_access
+          end
+
+          def value_to_compare?
+            @options.key?(:with) || @block
+          end 
+
+          # Update interpolation options
+          def interpolation_options
+            if @subject && @subject.response
+              { :assign_inspect => assigns[@name].inspect, :assign_class => assigns[@name].class.name }
+            else
+              { }
+            end
+          end
+
+          # Evaluate procs before assert to avoid them appearing in descriptions.
+          def evaluate_expected_value
+            if value_to_compare?
+              value = @options.key?(:with) ? @options[:with] : @block
+              value = @spec.instance_eval(&value) if value.is_a?(Proc)
+              @options[:with] = value
+            end
+          end
+
+      end
+
+      # Checks if the controller assigned the variables given by name. If you
+      # want to check that a variable is not being assigned, please do:
+      #
+      #   should_not_assign_to(:user)
+      #
+      # If you want to assure that a variable is being assigned to nil, do instead:
+      #
+      #   should_assign_to(:user).with(nil)
+      #
+      # == Options
+      #
+      # * <tt>:with</tt> - The value to compare the assign.
+      #   It can be also be supplied as proc or as a block (see examples below)
+      #
+      # * <tt>:with_kind_of</tt> - The expected class of the assign.
+      #
+      # == Examples
+      #
+      #   should_assign_to :user, :with_kind_of => User
+      #   should_assign_to :user, :with => proc{ users(:first) }
+      #   should_assign_to(:user){ users(:first) }
+      #
+      #   it { should assign_to(:user) }
+      #   it { should assign_to(:user, :with => users(:first)) }
+      #   it { should assign_to(:user, :with_kind_of => User) }
+      #
+      def assign_to(*args, &block)
+        AssignToMatcher.new(*args, &block).spec(self)
+      end
+
+    end
+  end
+end

data/lib/remarkable_rails/action_controller/matchers/filter_params_matcher.rb

@@ -0,0 +1,41 @@
+module Remarkable
+  module ActionController
+    module Matchers
+      # Do not inherit from ActionController::Base since it don't need all macro stubs behavior.
+      class FilterParamsMatcher < Remarkable::Base #:nodoc:
+        arguments :collection => :params, :as => :param
+
+        assertions :respond_to_filter_params?
+        collection_assertions :is_filtered?
+
+        protected
+
+          def respond_to_filter_params?
+            @subject.respond_to?(:filter_parameters)
+          end
+
+          def is_filtered?
+            filtered = @subject.send(:filter_parameters, { @param.to_s => @param.to_s })
+            filtered[@param.to_s] == '[FILTERED]'
+          end
+
+      end
+
+      # Checks if the controller filters the given params.
+      #
+      # == Examples
+      #
+      #   should_filter_params :password
+      #   should_not_filter_params :username
+      #
+      #   it { should filter_params(:password) }
+      #   it { should_not filter_params(:username) }
+      #
+      def filter_params(*params, &block)
+        FilterParamsMatcher.new(*params, &block).spec(self)
+      end
+      alias :filter_param :filter_params
+
+    end
+  end
+end

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

@@ -0,0 +1,118 @@
+module Remarkable
+  module ActionController
+    module Matchers
+      class RedirectToMatcher < Remarkable::ActionController::Base #:nodoc:
+
+        arguments :expected, :block => true
+        optional :with, :block => true
+
+        assertions :redirected?, :status_matches?, :url_matches?
+
+        before_assert :evaluate_expected_value
+
+        before_assert do
+          @response = @subject.respond_to?(:response) ? @subject.response : @subject
+          @request  = @response.instance_variable_get('@request')
+        end
+
+        protected
+
+          def redirected?
+            @response.redirect?
+          end
+
+          def status_matches?
+            return true unless @options.key?(:with)
+
+            actual_status   = @response.response_code
+            expected_status = @options[:with]
+
+            return actual_status == expected_status, :status => @response.response_code.inspect
+          end
+
+          def url_matches?
+            @actual = @response.redirect_url
+
+            if @expected.instance_of?(Hash)
+              return false unless @actual =~ /^\w+:\/\/#{@request.host}/ && actual_hash
+              actual_hash == expected_hash
+            else
+              @actual == expected_url
+            end
+          end
+
+          def actual_hash
+            hash_from_url @actual
+          end
+
+          def expected_hash
+            hash_from_url expected_url
+          end
+
+          def hash_from_url(url)
+            query_hash(url).merge(path_hash(url)).with_indifferent_access
+          end
+
+          def path_hash(url)
+            path = url.sub(/^\w+:\/\/#{@request.host}(?::\d+)?/, "").split("?", 2)[0]
+            ::Rails.application.routes.recognize_path path, { :method => :get }
+          end
+
+          def query_hash(url)
+            query = url.split("?", 2)[1] || ""
+
+            if defined?(::Rack::Utils)
+              ::Rack::Utils.parse_query(query)
+            else
+              @request.class.parse_query_parameters(query)
+            end
+          end
+
+          def expected_url
+            case @expected
+              when Hash
+                return @subject.url_for(@expected)
+              when :back
+                return @request.env['HTTP_REFERER']
+              when %r{^\w+://.*}
+                return @expected
+              else
+                return "http://#{@request.host}" + (@expected.split('')[0] == '/' ? '' : '/') + @expected
+            end
+          end
+
+          def interpolation_options
+            { :expected => @expected.inspect, :actual => @actual.inspect }
+          end
+
+          def evaluate_expected_value
+            @expected ||= @block if @block
+            @expected = @spec.instance_eval(&@expected) if @expected.is_a?(Proc)
+          end
+
+      end
+
+      # Passes if the response redirects to the given url. The url can be a string,
+      # a hash or can be supplied as a block (see examples below).
+      #
+      # == Options
+      #
+      # * <tt>:with</tt> - The status 30X used when redirecting.
+      #
+      # == Examples
+      #
+      #   should_redirect_to{ users_url }
+      #   should_redirect_to(:action => 'index')
+      #   should_not_redirect_to(:controller => 'users', :action => 'new')
+      #
+      #   it { should redirect_to(users_url).with(302) }
+      #   it { should redirect_to(:action => 'index') }
+      #   it { should_not redirect_to(:controller => 'users', :action => 'new') }
+      #
+      def redirect_to(expected=nil, options={}, &block)
+        RedirectToMatcher.new(expected, options, &block).spec(self)
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module RSpec::Rails::Matchers
+  module RenderTemplate
+    extend RSpec::Matchers::DSL
+    matcher :render_template do |options, message|
+      $matcher_execution_context.send(:run_action!)
+      match_unless_raises Test::Unit::AssertionFailedError do |_|
+        options = options.to_s if Symbol === options
+        assert_template options, message
+      end
+
+      failure_message_for_should do
+        rescued_exception.message
+      end
+    end
+  end
+end

data/lib/remarkable_rails/action_controller/matchers/respond_with_matcher.rb

@@ -0,0 +1,136 @@
+module Remarkable
+  module ActionController
+    module Matchers
+      class RespondWithMatcher < Remarkable::ActionController::Base #:nodoc:
+        arguments :block => true
+
+        optional :with, :body, :content_type
+
+        before_assert do
+          @response   = @subject.respond_to?(:response) ? @subject.response : @subject
+          @controller = @spec.instance_variable_get('@controller')
+        end
+
+        before_assert :evaluate_content_type, :evaluate_body
+
+        assertions :status_matches?, :body_matches?, :content_type_matches?
+
+        protected
+
+          def status_matches?
+            return true unless @options[:with] # only continue if not nil
+
+            case @options[:with]
+              when :success, :missing, :redirect, :error
+                @response.send("#{@options[:with]}?")
+              when Fixnum
+                @response.response_code == @options[:with]
+              when Symbol, String
+                @response.response_code == ::ActionController::StatusCodes::SYMBOL_TO_STATUS_CODE[@options[:with].to_sym]
+              when Range
+                @options[:with].include?(@response.response_code)
+              else
+                raise ArgumentError, "I don't know how to interpret status #{@options[:with].inspect}, " <<
+                                      "please give me a Fixnum, Symbol, String or Range."
+            end
+          end
+
+          def body_matches?
+            return true unless @options.key?(:body)
+            assert_contains(@response.body, @options[:body])
+          end
+
+          def content_type_matches?
+            return true unless @options.key?(:content_type)
+            assert_contains(@response.content_type, @options[:content_type])
+          end
+
+          def evaluate_content_type
+            return unless @options.key?(:content_type)
+
+            @options[:content_type] = case @options[:content_type]
+              when Symbol
+                Mime::Type.lookup_by_extension(@options[:content_type].to_s).to_s
+              when Regexp
+                @options[:content_type]
+              else
+                @options[:content_type].to_s
+            end
+          end
+
+          def evaluate_body
+            if @options.key?(:body) || @block
+              value = @options.key?(:body) ? @options[:body] : @block
+              value = @spec.instance_eval(&value) if value.is_a?(Proc)
+              @options[:body] = value
+            end
+          end
+
+          def interpolation_options
+            if @response
+              { :actual_body => @response.body.inspect,
+                :actual_status => @response.response_code.inspect,
+                :actual_content_type => @response.content_type.inspect }
+            else
+              { }
+            end
+          end
+
+      end
+
+      # Passes if the response has the given status. Status can be a Symbol lik
+      # :success, :missing, :redirect and :error. Can be also a Fixnum, Range o
+      # any other symbol which matches to any of Rails status codes. 
+      #
+      # == Options
+      #
+      # * <tt>:body</tt> - The body of the response. It accepts strings and or
+      #   regular expressions. Altought you might be running your tests without
+      #   integrating your views, this is useful when rendering :xml or :text.
+      #
+      # * <tt>:content_type</tt> - The content type of the response.
+      #   It accepts strings ('application/rss+xml'), mime constants (Mime::RSS),
+      #   symbols (:rss) and regular expressions /rss/.
+      #
+      # == Examples
+      #
+      #   should_respond_with :success
+      #   should_respond_with :error,   :body => /System error/
+      #   should_respond_with 301,      :content_type => Mime::XML
+      #   should_respond_with 300..399, :content_type => Mime::XML
+      #
+      #   it { should respond_with(:success)                              }
+      #   it { should respond_with(:error).body(/System error/)           }
+      #   it { should respond_with(301).content_type(Mime::XML)      }
+      #   it { should respond_with(300..399).content_type(Mime::XML) }
+      #
+      def respond_with(*args, &block)
+        options = args.extract_options!
+        options.merge!(:with => args.first)
+        RespondWithMatcher.new(options, &block).spec(self)
+      end
+
+      # This is just a shortcut for respond_with :body => body. Check respond_with
+      # for more information.
+      #
+      def respond_with_body(*args, &block)
+        options = args.extract_options!
+        # Since body can be also given as block, only merge if any arguments was
+        # actually sent.
+        options.merge!(:body => args.first) unless args.empty?
+        RespondWithMatcher.new(options, &block).spec(self)
+      end
+
+      # This is just a shortcut for respond_with :content_type => content_type.
+      # It's also used for Shoulda compatibility. Check respond_with for more
+      # information.
+      #
+      def respond_with_content_type(*args, &block)
+        options = args.extract_options!
+        options.merge!(:content_type => args.first)
+        RespondWithMatcher.new(options, &block).spec(self)
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,135 @@
+module Remarkable
+  module ActionController
+    module Matchers
+      # Do not inherit from ActionController::Base since it don't need all macro stubs behavior.
+      class RouteMatcher < Remarkable::Base #:nodoc:
+        arguments :method, :path
+        assertions :map_to_path?, :generate_params?
+
+        # Small hack to allow should route().to/from syntax.
+        #
+        after_initialize do
+          if @path.is_a?(Hash)
+            @options.merge!(@path)
+            @path = nil
+          end
+        end
+
+        before_assert do
+          @options[:controller] ||= controller_name
+          @populated_path = @path.dup
+
+          @options.each do |key, value|
+            @options[key] = value.to_param if value.respond_to?(:to_param)
+            @populated_path.gsub!(key.inspect, value.to_s)
+          end
+
+          ::ActionController::Routing::Routes.reload if ::ActionController::Routing::Routes.empty?
+        end
+
+        def to(value)
+          @options.merge!(value)
+          self
+        end
+
+        def from(value)
+          @path = value
+          self
+        end
+
+        private
+
+          def map_to_path?
+            route_for = ::ActionController::Routing::Routes.generate(@options) rescue nil
+            return route_for == @populated_path, :actual => route_for.inspect
+          end
+
+          def generate_params?
+            env = ::ActionController::Routing::Routes.extract_request_environment(request) if request
+
+            env ||= {}
+            env[:method] = @method.to_sym
+            params_from  = ::ActionController::Routing::Routes.recognize_path(@populated_path, env) rescue nil
+            return params_from == @options, :actual => params_from.inspect
+          end
+
+          def controller
+            @controller ||= if @subject.is_a?(::ActionController::Base)
+              @subject
+            elsif @spec.respond_to?(:controller)
+              @spec.controller
+            else
+              raise "Could not find a controller for route specs."
+            end
+          end
+
+          # First tries to get the controller name from the subject, then from
+          # the spec class using controller class or finally, from the described
+          # class.
+          #
+          # We have to try the described class because we don't have neither the
+          # subject or the controller class in the RoutingExampleGroup.
+          #
+          def controller_name
+            if controller_class
+              controller_class.name.gsub(/Controller$/, '').tableize
+            else
+              raise ArgumentError, "I cannot guess the controller name in route. Please supply :controller as option"
+            end
+          end
+
+          def controller_class
+            @controller_class ||= begin
+              spec_class = @spec.class unless @spec.class == Class
+
+              attempts = []
+              attempts << controller.class            if controller
+              attempts << spec_class.controller_class if spec_class.respond_to?(:controller_class)
+              attempts << spec_class.described_class  if spec_class.respond_to?(:described_class)
+
+              # Check for not blank names to address an odd rspec/rails behavior.
+              attempts.find { |klass| ::ActionController::Base >= klass && !klass.name.blank? }
+            end
+          end
+
+          def request
+            controller.request
+          end
+
+          def interpolation_options
+            { :options => @options.inspect, :method => @method.to_s.upcase, :path => @path.inspect }
+          end
+      end
+
+      # Assert route generation AND route recognition.
+      #
+      # == Examples
+      #
+      #   # autodetects the :controller
+      #   should_route :get,    '/posts',         :action => :index
+      #
+      #   # explicitly specify :controller
+      #   should_route :post,   '/posts',         :controller => :posts, :action => :create
+      #
+      #   # non-string parameter
+      #   should_route :get,    '/posts/1',       :controller => :posts, :action => :show,    :id => 1
+      #
+      #   # string-parameter
+      #   should_route :put,    '/posts/1',       :controller => :posts, :action => :update,  :id => "1"
+      #   should_route :delete, '/posts/1',       :controller => :posts, :action => :destroy, :id => 1
+      #   should_route :get,    '/posts/new',     :controller => :posts, :action => :new
+      #
+      #   # nested routes
+      #   should_route :get,    '/users/5/posts', :controller => :posts, :action => :index,   :user_id => 5
+      #   should_route :post,   '/users/5/posts', :controller => :posts, :action => :create,  :user_id => 5
+      #
+      #   # it example
+      #   it { should route(:get, :action => :index).to('/users/5/posts') }
+      #
+      def route(*params, &block)
+        RouteMatcher.new(*params, &block).spec(self)
+      end
+
+    end
+  end
+end