has_finder 0.1.1

data/spec/rails/vendor/plugins/rspec_on_rails/lib/spec/rails/matchers/have_text.rb

@@ -0,0 +1,55 @@
+module Spec
+  module Rails
+    module Matchers
+    
+      class HaveText  #:nodoc:
+
+        def initialize(expected)
+          @expected = expected
+        end
+
+        def matches?(response)
+          @actual = response.body
+          return actual =~ expected if Regexp === expected
+          return actual == expected unless Regexp === expected
+        end
+      
+        def failure_message
+          "expected #{expected.inspect}, got #{actual.inspect}"
+        end
+        
+        def negative_failure_message
+          "expected not to have text #{expected.inspect}"
+        end
+        
+        def to_s
+          "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 =~.
+      #
+      # Use this instead of <tt>response.should have_tag()</tt>
+      # when you either don't know or don't care where on the page
+      # this text appears.
+      #
+      # == Examples
+      #
+      #   response.should have_text("This is the expected text")
+      def have_text(text)
+        HaveText.new(text)
+      end
+    
+    end
+  end
+end

data/spec/rails/vendor/plugins/rspec_on_rails/lib/spec/rails/matchers/redirect_to.rb

@@ -0,0 +1,106 @@
+require 'action_controller/url_rewriter'
+
+module Spec
+  module Rails
+    module Matchers
+    
+      class RedirectTo  #:nodoc:
+    
+        def initialize(request, expected)
+          @expected = expected
+          @request = request
+        end
+
+        def matches?(response)
+          @redirected = response.redirect?
+          @actual = response.redirect_url
+          return false unless @redirected
+          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
+          else
+            return @actual == expected_url
+          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}}, "").split("?", 2)[0]
+          path = path.split("/")[1..-1] if ::Rails::VERSION::MINOR < 2
+          ActionController::Routing::Routes.recognize_path path
+        end
+
+        def query_hash(url)
+          query = url.split("?", 2)[1] || ""
+          if defined?(CGIMethods)
+            CGIMethods.parse_query_parameters(query)
+          else
+            ActionController::AbstractRequest.parse_query_parameters(query)
+          end
+        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
+          if @redirected
+            return %Q{expected redirect to #{@expected.inspect}, got redirect to #{@actual.inspect}}
+          else
+            return %Q{expected redirect to #{@expected.inspect}, got no redirect}
+          end
+        end
+
+        def description
+          "redirect to #{@actual.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/spec/rails/vendor/plugins/rspec_on_rails/lib/spec/rails/matchers/render_template.rb

@@ -0,0 +1,63 @@
+module Spec
+  module Rails
+    module Matchers
+    
+      class RenderTemplate #:nodoc:
+    
+        def initialize(expected)
+          @expected = expected
+        end
+      
+        def matches?(response)
+          @actual = response.rendered_file(!expected.include?('/'))
+          actual == expected
+        end
+
+        def failure_message
+          "expected #{expected.inspect}, got #{actual.inspect}"
+        end
+        
+        def description
+          "render template #{actual.inspect}"
+        end
+      
+        private
+          attr_reader :expected
+          attr_reader :actual
+        
+      end
+
+      # :call-seq:
+      #   response.should render_template(path)
+      #   response.should_not render_template(path)
+      #
+      # Passes if the specified template is rendered by the response.
+      # Useful in controller specs (integration or isolation mode).
+      #
+      # <code>path</code> can include the controller path or not. It
+      # can also include an optional extension (no extension assumes .rhtml).
+      #
+      # 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')
+      #
+      #   #rjs
+      #   response.should render_template('list.rjs')
+      #   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)
+      end
+
+    end
+  end
+end

data/spec/rails/vendor/plugins/rspec_on_rails/lib/spec/rails/version.rb

@@ -0,0 +1,26 @@
+module Spec
+  module Rails
+    module VERSION #:nodoc:
+      unless defined?(REV)
+        # RANDOM_TOKEN: 0.956731547671535
+        REV = "$LastChangedRevision: 2081 $".match(/LastChangedRevision: (\d+)/)[1]
+      end
+    end
+  end
+end
+
+# Verifies that the plugin has the same revision as RSpec
+if Spec::VERSION::REV != Spec::Rails::VERSION::REV
+  raise <<-EOF
+
+############################################################################
+Your RSpec on Rails plugin is incompatible with your installed RSpec.
+
+RSpec          : #{Spec::VERSION::FULL_VERSION}
+RSpec on Rails : r#{Spec::Rails::VERSION::REV}
+
+Make sure your RSpec on Rails plugin is compatible with your RSpec gem.
+See http://rspec.rubyforge.org/documentation/rails/install.html for details.
+############################################################################
+EOF
+end

data/spec/rails/vendor/plugins/rspec_on_rails/spec/rails/dsl/assigns_hash_proxy_spec.rb

@@ -0,0 +1,55 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe "An AssignsHashProxy" do
+  before(:each) do
+    @object = Object.new
+    @assigns = Hash.new
+    @object.stub!(:assigns).and_return(@assigns)
+    @proxy = Spec::Rails::DSL::AssignsHashProxy.new(@object)
+  end
+
+  it "has [] accessor" do
+    @proxy['foo'] = 'bar'
+    @assigns['foo'].should == 'bar'
+    @proxy['foo'].should == 'bar'
+  end
+
+  it "checks for string key before symbol key" do
+    @assigns[:foo] = 2
+    @proxy[:foo].should == 2
+  end
+
+  it "checks for string key before symbol key" do
+    @assigns['foo'] = false
+    @assigns[:foo] = 2
+    @proxy[:foo].should == false
+  end
+
+  it "each method iterates through each element like a Hash" do
+    values = {
+      'foo' => 1,
+      'bar' => 2,
+      'baz' => 3
+    }
+    @proxy['foo'] = values['foo']
+    @proxy['bar'] = values['bar']
+    @proxy['baz'] = values['baz']
+
+    @proxy.each do |key, value|
+      key.should == key
+      value.should == values[key]
+    end
+  end
+
+  it "delete method deletes the element of passed in key" do
+    @proxy['foo'] = 'bar'
+    @proxy.delete('foo').should == 'bar'
+    @proxy['foo'].should be_nil
+  end
+
+  it "has_key? detects the presence of a key" do
+    @proxy['foo'] = 'bar'
+    @proxy.has_key?('foo').should == true
+    @proxy.has_key?('bar').should == false
+  end
+end

data/spec/rails/vendor/plugins/rspec_on_rails/spec/rails/dsl/behaviour_factory_spec.rb

@@ -0,0 +1,53 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe "the BehaviourFactory" do
+  it "should return a ModelBehaviour when given :behaviour_type => :model" do
+    Spec::DSL::BehaviourFactory.create("name", :behaviour_type => :model) {
+    }.should be_an_instance_of(Spec::Rails::DSL::ModelBehaviour)
+  end
+  
+  it "should return a ModelBehaviour when given :spec_path => '/blah/spec/models/'" do
+    Spec::DSL::BehaviourFactory.create("name", :spec_path => '/blah/spec/models/blah.rb') {
+    }.should be_an_instance_of(Spec::Rails::DSL::ModelBehaviour)
+  end
+  
+  it "should return a ViewBehaviour when given :behaviour_type => :model" do
+    Spec::DSL::BehaviourFactory.create("name", :behaviour_type => :view) {
+    }.should be_an_instance_of(Spec::Rails::DSL::ViewBehaviour)
+  end
+  
+  it "should return a ViewBehaviour when given :spec_path => '/blah/spec/views/'" do
+    Spec::DSL::BehaviourFactory.create("name", :spec_path => '/blah/spec/views/blah.rb') {
+    }.should be_an_instance_of(Spec::Rails::DSL::ViewBehaviour)
+  end
+  
+  it "should return a HelperBehaviour when given :behaviour_type => :helper" do
+    Spec::DSL::BehaviourFactory.create("name", :behaviour_type => :helper) {
+    }.should be_an_instance_of(Spec::Rails::DSL::HelperBehaviour)
+  end
+  
+  it "should return a HelperBehaviour when given :spec_path => '/blah/spec/helpers/'" do
+    Spec::DSL::BehaviourFactory.create("name", :spec_path => '/blah/spec/helpers/blah.rb') {
+    }.should be_an_instance_of(Spec::Rails::DSL::HelperBehaviour)
+  end
+  
+  it "should return a ControllerBehaviour when given :behaviour_type => :controller" do
+    Spec::DSL::BehaviourFactory.create("name", :behaviour_type => :controller) {
+    }.should be_an_instance_of(Spec::Rails::DSL::ControllerBehaviour)
+  end
+  
+  it "should return a ControllerBehaviour when given :spec_path => '/blah/spec/controllers/'" do
+    Spec::DSL::BehaviourFactory.create("name", :spec_path => '/blah/spec/controllers/blah.rb') {
+    }.should be_an_instance_of(Spec::Rails::DSL::ControllerBehaviour)
+  end
+  
+  it "should favor the :behaviour_type over the :spec_path" do
+    Spec::DSL::BehaviourFactory.create("name", :spec_path => '/blah/spec/models/blah.rb', :behaviour_type => :controller) {
+    }.should be_an_instance_of(Spec::Rails::DSL::ControllerBehaviour)
+  end
+  
+  it "should create a Spec::DSL::Behaviour if :shared => true" do
+    Spec::DSL::BehaviourFactory.create("name", :spec_path => '/blah/spec/models/blah.rb', :behaviour_type => :controller, :shared => true) {
+    }.should be_an_instance_of(Spec::DSL::Behaviour)
+  end
+end

data/spec/rails/vendor/plugins/rspec_on_rails/spec/rails/dsl/controller_isolation_spec.rb

@@ -0,0 +1,43 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'controller_spec_controller'
+
+describe "a controller spec running in isolation mode", :behaviour_type => :controller do
+  controller_name :controller_spec
+
+  it "should not care if the template doesn't exist" do
+    get 'some_action'
+    response.should be_success
+    response.should render_template("template/that/does/not/actually/exist")
+  end
+
+  it "should not care if the template has errors" do
+    get 'action_with_errors_in_template'
+    response.should be_success
+    response.should render_template("action_with_errors_in_template")
+  end
+end
+
+describe "a controller spec running in integration mode", :behaviour_type => :controller do
+  controller_name :controller_spec
+  integrate_views
+  
+  before(:each) do
+    controller.class.send(:define_method, :rescue_action) { |e| raise e }
+  end
+
+  it "should render a template" do
+    get 'action_with_template'
+    response.should be_success
+    response.should have_tag('div', 'This is action_with_template.rhtml')
+  end
+
+  it "should choke if the template doesn't exist" do
+    lambda { get 'some_action' }.should raise_error(ActionController::MissingTemplate)
+    response.should_not be_success
+  end
+
+  it "should choke if the template has errors" do
+    lambda { get 'action_with_errors_in_template' }.should raise_error(ActionView::TemplateError)
+    response.should_not be_success
+  end
+end

data/spec/rails/vendor/plugins/rspec_on_rails/spec/rails/dsl/controller_spec_spec.rb

@@ -0,0 +1,124 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'controller_spec_controller'
+
+['integration', 'isolation'].each do |mode|
+  describe "Given a controller spec for ControllerSpecController running in #{mode} mode", :behaviour_type => :controller do
+    controller_name :controller_spec
+    integrate_views if mode == 'integration'
+  
+    it "session should be the same object as controller session" do
+      get 'action_with_template'
+      session.should equal(controller.session)
+    end
+  
+    it "session should be the same object before and after the action" do
+      session_before = session
+      get 'action_with_template'
+      session.should equal(session_before)
+    end
+  
+    it "controller.session should NOT be nil before the action" do
+      controller.session.should_not be_nil
+      get 'action_with_template'
+    end
+    
+    it "controller.session should NOT be nil after the action" do
+      get 'action_with_template'
+      controller.session.should_not be_nil
+    end
+    
+    it "specifying a partial should work with partial name only" do
+      get 'action_with_partial'
+      response.should render_template("_a_partial")
+    end
+    
+    it "specifying a partial should work with path relative to RAILS_ROOT/app/views/" do
+      get 'action_with_partial'
+      response.should render_template("controller_spec/_a_partial")
+    end
+    
+    it "spec should have access to flash" do
+      get 'action_with_template'
+      flash[:flash_key].should == "flash value"
+    end
+    
+    it "spec should have access to flash values set after a session reset" do
+      get 'action_setting_flash_after_session_reset'
+      flash[:after_reset].should == "available"
+    end
+    
+    it "spec should not have access to flash values set before a session reset" do
+      get 'action_setting_flash_before_session_reset'
+      flash[:before_reset].should_not == "available"
+    end
+
+    it "spec should have access to session" do
+      get 'action_with_template'
+      session[:session_key].should == "session value"
+    end
+
+    it "custom routes should be speccable" do
+      route_for(:controller => "custom_route_spec", :action => "custom_route").should == "/custom_route"
+    end
+
+    it "routes should be speccable" do
+      route_for(:controller => "controller_spec", :action => "some_action").should == "/controller_spec/some_action"
+    end
+
+    it "exposes the assigns hash directly" do
+      get 'action_setting_the_assigns_hash'
+      assigns[:direct_assigns_key].should == :direct_assigns_key_value
+    end
+  end
+
+  describe "Given a controller spec for RedirectSpecController running in #{mode} mode", :behaviour_type => :controller do
+    controller_name :redirect_spec
+    integrate_views if mode == 'integration'
+
+    it "a redirect should ignore the absence of a template" do
+      get 'action_with_redirect_to_somewhere'
+      response.should be_redirect
+      response.redirect_url.should == "http://test.host/redirect_spec/somewhere"
+      response.should redirect_to("http://test.host/redirect_spec/somewhere")
+    end
+    
+    it "a call to response.should redirect_to should fail if no redirect" do
+      get 'action_with_no_redirect'
+      lambda {
+        response.redirect?.should be_true
+      }.should fail
+      lambda {
+        response.should redirect_to("http://test.host/redirect_spec/somewhere")
+      }.should fail_with("expected redirect to \"http://test.host/redirect_spec/somewhere\", got no redirect")
+    end
+  end
+  
+  describe "Given a controller spec running in #{mode} mode", :behaviour_type => :controller do
+    integrate_views if mode == 'integration'
+    it "a spec in a context without controller_name set should fail with a useful warning",
+      :should_raise => [
+        Spec::Expectations::ExpectationNotMetError,
+        /You have to declare the controller name in controller specs/
+      ] do
+    end
+  end
+  
+end
+
+describe ControllerSpecController, :behaviour_type => :controller do
+  it "should not require naming the controller if describe is passed a type" do
+  end
+end
+
+module Spec
+  module Rails
+    module DSL
+      describe ControllerBehaviour do
+        it "should tell you its behaviour_type is :controller" do
+          behaviour = ControllerBehaviour.new("") {}
+          behaviour.behaviour_type.should == :controller
+        end
+      end
+    end
+  end
+end