rspec-rails-w-factory_girl 1.3.2

data/lib/spec/rails/matchers/assert_select.rb

@@ -0,0 +1,180 @@
+# This is a wrapper of assert_select for rspec.
+
+module Spec # :nodoc:
+  module Rails
+    module Matchers
+
+      class AssertSelect #:nodoc:
+        attr_reader :options
+
+        def initialize(selector_assertion, spec_scope, *args, &block)
+          @args, @options = args_and_options(args)
+          @spec_scope = spec_scope
+          @selector_assertion = selector_assertion
+          @block = block
+        end
+        
+        def matches?(response_or_text, &block)
+          @block = block if block
+
+          if doc = doc_from(response_or_text)
+            @args.unshift(doc)
+          end
+
+          begin
+            @spec_scope.__send__(@selector_assertion, *@args, &@block)
+            true
+          rescue ::Test::Unit::AssertionFailedError => @error
+            false
+          end
+        end
+        
+        def failure_message_for_should; @error.message; end
+        def failure_message_for_should_not; "should not #{description}, but did"; end
+
+        def description
+          {
+            :assert_select => "have tag#{format_args(*@args)}",
+            :assert_select_email => "send email#{format_args(*@args)}",
+          }[@selector_assertion]
+        end
+
+      private
+
+        module TestResponseOrString
+          def test_response?
+            ActionController::TestResponse === self and
+                                               !self.headers['Content-Type'].blank? and
+                                               self.headers['Content-Type'].to_sym == :xml
+          end
+        
+          def string?
+            String === self
+          end
+        end
+
+        def doc_from(response_or_text)
+          response_or_text.extend TestResponseOrString
+          if response_or_text.test_response?
+            HTML::Document.new(response_or_text.body, @options[:strict], @options[:xml]).root
+          elsif response_or_text.string?
+            HTML::Document.new(response_or_text, @options[:strict], @options[:xml]).root
+           end
+        end
+
+        def format_args(*args)
+          args.empty? ? "" : "(#{arg_list(*args)})"
+        end
+
+        def arg_list(*args)
+          args.map do |arg|
+            arg.respond_to?(:description) ? arg.description : arg.inspect
+          end.join(", ")
+        end
+        
+        def args_and_options(args)
+          opts = {:xml => false, :strict => false}
+          if args.last.is_a?(::Hash)
+            opts[:strict] = args.last.delete(:strict) unless args.last[:strict].nil?
+            opts[:xml]    = args.last.delete(:xml)    unless args.last[:xml].nil?
+            args.pop if args.last.empty?
+          end
+          return [args, opts]
+        end
+        
+      end
+      
+      # :call-seq:
+      #   response.should have_tag(*args, &block)
+      #   string.should have_tag(*args, &block)
+      #
+      # wrapper for assert_select with additional support for using
+      # css selectors to set expectation on Strings. Use this in
+      # helper specs, for example, to set expectations on the results
+      # of helper methods. Also allow specification of how the 
+      # response is parsed using the options :xml and :strict options.
+      # By default, these options are set to false.
+      #
+      # == Examples
+      #
+      #   # in a controller spec
+      #   response.should have_tag("div", "some text")
+      #
+      #   # to force xml and/or strict parsing of the response
+      #   response.should have_tag("div", "some text", :xml => true)
+      #   response.should have_tag("div", "some text", :strict => true)
+      #   response.should have_tag("div", "some text", :xml => true, :strict => false)
+      #
+      #   # in a helper spec (person_address_tag is a method in the helper)
+      #   person_address_tag.should have_tag("input#person_address")
+      #
+      # see documentation for assert_select at http://api.rubyonrails.org/
+      def have_tag(*args, &block)
+        @__current_scope_for_assert_select = AssertSelect.new(:assert_select, self, *args, &block)
+      end
+    
+      # wrapper for a nested assert_select
+      #
+      #   response.should have_tag("div#form") do
+      #     with_tag("input#person_name[name=?]", "person[name]")
+      #   end
+      #
+      # see documentation for assert_select at http://api.rubyonrails.org/
+      def with_tag(*args, &block)
+        args = prepare_args(args, @__current_scope_for_assert_select)
+        @__current_scope_for_assert_select.should have_tag(*args, &block)
+      end
+    
+      # wrapper for a nested assert_select with false
+      #
+      #   response.should have_tag("div#1") do
+      #     without_tag("span", "some text that shouldn't be there")
+      #   end
+      #
+      # see documentation for assert_select at http://api.rubyonrails.org/
+      def without_tag(*args, &block)
+        args = prepare_args(args, @__current_scope_for_assert_select)
+        @__current_scope_for_assert_select.should_not have_tag(*args, &block)
+      end
+    
+      # :call-seq:
+      #   response.should have_rjs(*args, &block)
+      #
+      # wrapper for assert_select_rjs
+      #
+      # see documentation for assert_select_rjs at http://api.rubyonrails.org/
+      def have_rjs(*args, &block)
+        AssertSelect.new(:assert_select_rjs, self, *args, &block)
+      end
+      
+      # :call-seq:
+      #   response.should send_email(*args, &block)
+      #
+      # wrapper for assert_select_email
+      #
+      # see documentation for assert_select_email at http://api.rubyonrails.org/
+      def send_email(*args, &block)
+        AssertSelect.new(:assert_select_email, self, *args, &block)
+      end
+      
+      # wrapper for assert_select_encoded
+      #
+      # see documentation for assert_select_encoded at http://api.rubyonrails.org/
+      def with_encoded(*args, &block)
+        should AssertSelect.new(:assert_select_encoded, self, *args, &block)
+      end
+
+    private
+    
+      def prepare_args(args, current_scope = nil)
+        return args if current_scope.nil?
+        defaults = current_scope.options || {:strict => false, :xml => false}
+        args << {} unless args.last.is_a?(::Hash)
+        args.last[:strict] = defaults[:strict] if args.last[:strict].nil?
+        args.last[:xml] = defaults[:xml] if args.last[:xml].nil?
+        args
+      end
+
+    end
+  end
+end

data/lib/spec/rails/matchers/change.rb

@@ -0,0 +1,13 @@
+if defined?(ActiveRecord::Base)
+  module Spec
+    module Matchers
+      class Change
+        def evaluate_value_proc_with_ensured_evaluation_of_proxy
+          value = evaluate_value_proc_without_ensured_evaluation_of_proxy
+          ActiveRecord::Associations::AssociationProxy === value ? value.dup : value
+        end
+        alias_method_chain :evaluate_value_proc, :ensured_evaluation_of_proxy
+      end
+    end
+  end
+end

data/lib/spec/rails/matchers/have_text.rb

@@ -0,0 +1,57 @@
+module Spec
+  module Rails
+    module Matchers
+    
+      class HaveText  #:nodoc:
+
+        def initialize(expected)
+          @expected = expected
+        end
+
+        def matches?(response_or_text)
+          @actual = response_or_text.respond_to?(:body) ? response_or_text.body : response_or_text
+          return actual =~ expected if Regexp === expected
+          return actual == expected unless Regexp === expected
+        end
+      
+        def failure_message_for_should
+          "expected #{expected.inspect}, got #{actual.inspect}"
+        end
+        
+        def failure_message_for_should_not
+          "expected not to have text #{expected.inspect}"
+        end
+        
+        def description
+          "have text #{expected.inspect}"
+        end
+      
+        private
+          attr_reader :expected
+          attr_reader :actual
+
+      end
+
+      # :call-seq:
+      #   response.should have_text(expected)
+      #   response.should_not have_text(expected)
+      #
+      # Accepts a String or a Regexp, matching a String using ==
+      # and a Regexp using =~.
+      #
+      # If response_or_text has a #body, then that is used as to match against
+      # else it uses response_or_text
+      #
+      # Use this instead of <tt>response.should have_tag()</tt>
+      # when you want to match the whole string or whole body
+      #
+      # == Examples
+      #
+      #   response.should have_text("This is the expected text")
+      def have_text(text)
+        HaveText.new(text)
+      end
+    
+    end
+  end
+end

data/lib/spec/rails/matchers/include_text.rb

@@ -0,0 +1,54 @@
+module Spec
+  module Rails
+    module Matchers
+
+      class IncludeText  #:nodoc:
+
+        def initialize(expected)
+          @expected = expected
+        end
+
+        def matches?(response_or_text)
+          @actual = response_or_text.respond_to?(:body) ? response_or_text.body : response_or_text
+          return actual.include?(expected)
+        end
+
+        def failure_message_for_should
+          "expected to find #{expected.inspect} in #{actual.inspect}"
+        end
+
+        def failure_message_for_should_not
+          "expected not to include text #{expected.inspect}"
+        end
+
+        def description
+          "include text #{expected.inspect}"
+        end
+
+        private
+          attr_reader :expected
+          attr_reader :actual
+
+      end
+
+
+      # :call-seq:
+      #   response.should include_text(expected)
+      #   response.should_not include_text(expected)
+      #
+      # Accepts a String, matching using include?
+      #
+      # Use this instead of <tt>response.should have_text()</tt>
+      # when you either don't know or don't care where on the page
+      # this text appears.
+      #
+      # == Examples
+      #
+      #   response.should include_text("This text will be in the actual string")
+      def include_text(text)
+        IncludeText.new(text)
+      end
+
+    end
+  end
+end

data/lib/spec/rails/matchers/redirect_to.rb

@@ -0,0 +1,126 @@
+module Spec
+  module Rails
+    module Matchers
+
+      class RedirectTo  #:nodoc:
+
+        include ActionController::StatusCodes
+
+        def initialize(request, expected)
+          @expected = expected
+          @request = request
+        end
+
+        def matches?(response_or_controller)
+          response  = response_or_controller.respond_to?(:response) ?
+                      response_or_controller.response :
+                      response_or_controller
+
+          @redirected = response.redirect?
+          @actual = response.redirect_url
+          return false unless @redirected
+
+          if @expected_status
+            @actual_status = interpret_status(response.code.to_i)
+            @status_matched = @expected_status == @actual_status
+          else
+            @status_matched = true
+          end
+
+          if @expected.instance_of? Hash
+            return false unless @actual =~ %r{^\w+://#{@request.host}}
+            return false unless actual_redirect_to_valid_route
+            return actual_hash == expected_hash && @status_matched
+          else
+            return @actual == expected_url && @status_matched
+          end
+        end
+
+        def actual_hash
+          hash_from_url @actual
+        end
+
+        def expected_hash
+          hash_from_url expected_url
+        end
+
+        def actual_redirect_to_valid_route
+          actual_hash
+        end
+
+        def hash_from_url(url)
+          query_hash(url).merge(path_hash(url)).with_indifferent_access
+        end
+
+        def path_hash(url)
+          path = url.sub(%r{^\w+://#{@request.host}(?::\d+)?}, "").split("?", 2)[0]
+          ActionController::Routing::Routes.recognize_path path, { :method => :get }
+        end
+
+        def query_hash(url)
+          query = url.split("?", 2)[1] || ""
+          Rack::Utils.parse_query(query)
+        end
+
+        def with(options)
+          @expected_status = interpret_status(options[:status])
+          self
+        end
+        
+       def expected_url
+          case @expected
+            when Hash
+              return ActionController::UrlRewriter.new(@request, {}).rewrite(@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 failure_message_for_should
+          if @redirected
+            if @status_matched
+              return %Q{expected redirect to #{@expected.inspect}, got redirect to #{@actual.inspect}}
+            else
+              return %Q{expected redirect to #{@expected.inspect} with status #{@expected_status}, got #{@actual_status}}
+            end
+          else
+            return %Q{expected redirect to #{@expected.inspect}, got no redirect}
+          end
+        end
+
+        def failure_message_for_should_not
+            return %Q{expected not to be redirected to #{@expected.inspect}, but was} if @redirected
+        end
+
+        def description
+          "redirect to #{@expected.inspect}"
+        end
+      end
+
+      # :call-seq:
+      #   response.should redirect_to(url)
+      #   response.should redirect_to(:action => action_name)
+      #   response.should redirect_to(:controller => controller_name, :action => action_name)
+      #   response.should_not redirect_to(url)
+      #   response.should_not redirect_to(:action => action_name)
+      #   response.should_not redirect_to(:controller => controller_name, :action => action_name)
+      #
+      # Passes if the response is a redirect to the url, action or controller/action.
+      # Useful in controller specs (integration or isolation mode).
+      #
+      # == Examples
+      #
+      #   response.should redirect_to("path/to/action")
+      #   response.should redirect_to("http://test.host/path/to/action")
+      #   response.should redirect_to(:action => 'list')
+      def redirect_to(opts)
+        RedirectTo.new(request, opts)
+      end
+    end
+
+  end
+end

data/lib/spec/rails/matchers/render_template.rb

@@ -0,0 +1,129 @@
+module Spec
+  module Rails
+    module Matchers
+    
+      class RenderTemplate #:nodoc:
+    
+        def initialize(expected, controller)
+          @controller = controller
+          @expected = expected
+        end
+      
+        def matches?(response_or_controller)
+          response  = response_or_controller.respond_to?(:response) ?
+                      response_or_controller.response :
+                      response_or_controller
+
+          if response.respond_to?(:redirect?) && response.redirect?
+            @redirect_url = response.redirect_url
+          elsif response.respond_to?(:rendered_file)
+            @actual = response.rendered_file
+          elsif response.respond_to?(:rendered)
+            case template = response.rendered[:template]
+            when nil
+              unless response.rendered[:partials].empty?
+                @actual = path_and_file(response.rendered[:partials].keys.first).join("/_")
+              end
+            when ActionView::Template
+              @actual = template.path
+            when String
+              @actual = template
+            end
+          else
+            @actual = response.rendered_template.to_s
+          end
+          return false if @actual.blank?
+          given_controller_path, given_file = path_and_file(@actual)
+          expected_controller_path, expected_file = path_and_file(@expected)
+          given_controller_path == expected_controller_path && match_files(given_file, expected_file)
+        end
+        
+        def match_files(actual, expected)
+          actual_parts = actual.split('.')
+          expected_parts = expected.split('.')
+          expected_parts.each_with_index do |expected_part, index|
+            return false unless expected_part == actual_parts[index]
+          end
+          true
+        end
+        
+        def failure_message_for_should
+          if @redirect_url
+            "expected #{@expected.inspect}, got redirected to #{@redirect_url.inspect}"
+          else
+            "expected #{@expected.inspect}, got #{@actual.inspect}"
+          end
+        end
+        
+        def failure_message_for_should_not
+          "expected not to render #{@expected.inspect}, but did"
+        end
+        
+        def description
+          "render template #{@expected.inspect}"
+        end
+      
+        private
+          def path_and_file(path)
+            parts = path.split('/')
+            file = parts.pop
+            controller = parts.empty? ? current_controller_path : parts.join('/')
+            return controller, file
+          end
+        
+          def controller_path_from(path)
+            parts = path.split('/')
+            parts.pop
+            parts.join('/')
+          end
+
+          def current_controller_path
+            @controller.class.to_s.underscore.gsub(/_controller$/,'')
+          end
+        
+      end
+      
+      # :call-seq:
+      #   response.should render_template(template)
+      #   response.should_not render_template(template)
+      #
+      # For use in controller code examples (integration or isolation mode).
+      #
+      # Passes if the specified template (view file) is rendered by the
+      # response. This file can be any view file, including a partial. However
+      # if it is a partial it must be rendered directly i.e. you can't detect
+      # that a partial has been rendered as part of a view using
+      # render_template. For that you should use a message expectation
+      # (mock) instead:
+      #
+      #   controller.should_receive(:render).with(:partial => 'path/to/partial')
+      #
+      # <code>template</code> can include the controller path. It can also
+      # include an optional extension, which you only need to use when there
+      # is ambiguity.
+      #
+      # Note that partials must be spelled with the preceding underscore.
+      #
+      # == Examples
+      #
+      #   response.should render_template('list')
+      #   response.should render_template('same_controller/list')
+      #   response.should render_template('other_controller/list')
+      #
+      #   # with extensions
+      #   response.should render_template('list.rjs')
+      #   response.should render_template('list.haml')
+      #   response.should render_template('same_controller/list.rjs')
+      #   response.should render_template('other_controller/list.rjs')
+      #
+      #   # partials
+      #   response.should render_template('_a_partial')
+      #   response.should render_template('same_controller/_a_partial')
+      #   response.should render_template('other_controller/_a_partial')
+      def render_template(path)
+        RenderTemplate.new(path.to_s, @controller)
+      end
+
+    end
+  end
+end