has_finder 0.1.1

data/spec/rails/vendor/plugins/rspec_on_rails/lib/spec/rails/dsl/behaviour/controller.rb

@@ -0,0 +1,246 @@
+module Spec
+  module Rails
+    module DSL
+      module ControllerBehaviourHelpers
+        class << self
+          def included(mod)
+            mod.send :include, ExampleMethods
+            mod.send :extend,  BehaviourMethods
+          end
+        end
+        
+        module BehaviourMethods
+          attr_accessor :controller_class_name # :nodoc:
+          
+          # Use this to instruct RSpec to render views in your controller examples (Integration Mode).
+          # 
+          #   describe ThingController do
+          #     integrate_views
+          #     ...
+          #
+          # See Spec::Rails::DSL::ControllerBehaviour for more information about
+          # Integration and Isolation modes.
+          def integrate_views
+            @integrate_views = true
+          end
+          def integrate_views? # :nodoc:
+            @integrate_views
+          end
+        end
+        
+        module ExampleMethods
+          # Uses ActionController::Routing::Routes to generate
+          # the correct route for a given set of options.
+          # == Examples
+          #   route_for(:controller => 'registrations', :action => 'edit', :id => 1)
+          #     => '/registrations/1;edit'
+          def route_for(options)
+            ensure_that_routes_are_loaded
+            ActionController::Routing::Routes.generate(options)
+          end
+
+          # TODO - TEST ME
+          # Also - this is somewhat experimental at the moment and may be changed
+          # or removed without explanation or apology!
+          def raise_controller_errors
+            unless @controller_class_name.blank?
+              @controller_class_name.constantize.class_eval do
+                define_method :rescue_action do |e|
+                  raise e
+                end
+              end
+            end
+          end
+        end
+      end
+
+      module ControllerInstanceMethods #:nodoc:
+
+        # === render(options = nil, deprecated_status = nil, &block)
+        #
+        # This gets added to the controller's singleton meta class,
+        # allowing Controller Specs to run in two modes, freely switching
+        # from context to context.
+        def render(options=nil, deprecated_status=nil, &block)
+          unless block_given?
+            unless integrate_views?
+              @template.metaclass.class_eval do
+                define_method :file_exists? do true end
+                define_method :find_template_extension_for do "erb" end
+                define_method :read_template_file do "this is fake content generated by rspec" end
+                define_method :render_file do |*args|
+                  @first_render ||= args[0]
+                end
+              end
+            end
+          end
+          response.controller_path = controller_path
+          
+          super unless performed?
+        end
+        
+        def response(&block)
+          # NOTE - we're setting @update for the assert_select_spec - kinda weird, huh?
+          @update = block
+          @_response || @response
+        end
+      
+        def integrate_views!
+          @integrate_views = true
+        end
+
+      private
+
+        def integrate_views?
+          @integrate_views
+        end
+      end
+    
+      # The methods provided by Spec::Rails::DSL::ControllerEvalContext
+      # are available to you in Controller Specs.
+      #
+      # The Public Class Methods are to be used within the +context+ block:
+      #
+      #   describe ThingController do
+      #     # public class methods go here
+      #
+      # The Public Instance Methods are to be used within the +specify+ block:
+      #
+      #   describe ThingController do
+      #     it "should do stuff" do
+      #       # public instance methods go here
+      #
+      # See Spec::Rails::DSL::ControllerBehaviour for more general information
+      # on Controller Specs
+      class ControllerEvalContext < Spec::Rails::DSL::FunctionalEvalContext
+        include Spec::Rails::DSL::ControllerBehaviourHelpers
+        attr_reader :response, :request, :controller
+      
+        def setup #:nodoc:
+          super
+          
+          # Some Rails apps explicitly disable ActionMailer in environment.rb
+          if defined?(ActionMailer)
+            @deliveries = []
+            ActionMailer::Base.deliveries = @deliveries
+          end
+
+          unless @controller.class.ancestors.include?(ActionController::Base)
+            Spec::Expectations.fail_with <<-EOE
+  You have to declare the controller name in controller specs. For example:
+    describe "The ExampleController" do
+      controller_name "example" #invokes the ExampleController
+    end
+  EOE
+          end
+          @controller.metaclass.class_eval do
+            def controller_path #:nodoc:
+              self.class.name.underscore.gsub('_controller','')
+            end
+            include ControllerInstanceMethods
+          end
+          @controller.integrate_views! if @integrate_views
+          @controller.session = session
+        end
+
+        protected
+          def _controller_ivar_proxy
+            @controller_ivar_proxy ||= AssignsHashProxy.new @controller
+          end
+      
+        private
+          def ensure_that_routes_are_loaded
+            ActionController::Routing::Routes.reload if ActionController::Routing::Routes.empty?
+          end
+      end
+
+      # Controller Specs live in $RAILS_ROOT/spec/controllers/.
+      #
+      # Controller Specs use Spec::Rails::DSL::ControllerBehaviour, which supports running specs for
+      # Controllers in two modes, which represent the tension between the more granular
+      # testing common in TDD and the more high level testing built into
+      # rails. BDD sits somewhere in between: we want to a balance between
+      # specs that are close enough to the code to enable quick fault
+      # isolation and far enough away from the code to enable refactoring
+      # with minimal changes to the existing specs.
+      #
+      # == Isolation mode (default)
+      #
+      # No dependencies on views because none are ever rendered. The
+      # benefit of this mode is that can spec the controller completely
+      # independent of the view, allowing that responsibility to be
+      # handled later, or by somebody else. Combined w/ separate view
+      # specs, this also provides better fault isolation.
+      #
+      # == Integration mode
+      #
+      # To run in this mode, include the +integrate_views+ declaration
+      # in your controller context:
+      # 
+      #   describe ThingController do
+      #     integrate_views
+      #     ...
+      # 
+      # In this mode, controller specs are run in the same way that
+      # rails functional tests run - one set of tests for both the
+      # controllers and the views. The benefit of this approach is that
+      # you get wider coverage from each spec. Experienced rails
+      # developers may find this an easier approach to begin with, however
+      # we encourage you to explore using the isolation mode and revel
+      # in its benefits.
+      #
+      # == Expecting Errors
+      #
+      # By default, Rails will swallow errors that are raised in controller
+      # actions and return an error code in the header. If you want to
+      # specify that an action should raise an error, you can either
+      # override rescue_action in your controller ...
+      #
+      #   before(:each) do
+      #     controller.class.send(:define_method, :rescue_action) { |e| raise e }
+      #   end
+      #
+      # ... or you can expect error codes in headers ...
+      #
+      #   it "should return an error in the header" do
+      #     response.should be_error
+      #   end
+      #
+      #   it "should return a 501" do
+      #     response.response_code.should == 501
+      #   end
+      #
+      #   it "should return a 501" do
+      #     response.code.should == "501"
+      #   end
+      #
+      # See Spec::Rails::DSL::ControllerEvalContext for information
+      # about methods you can use in your Controller Specs
+      class ControllerBehaviour < Spec::DSL::Behaviour
+        def execution_context(example=nil) # :nodoc:
+          instance = execution_context_class.new(example)
+          if controller_class_name.nil? && !described_type.nil?
+            controller_klass_name = described_type.to_s
+          else
+            controller_klass_name = controller_class_name.to_s
+          end
+          integrate_views = integrate_views?
+          instance.instance_eval {
+            @controller_class_name = controller_klass_name
+            @integrate_views = integrate_views
+          }
+          instance
+        end
+
+        def before_eval # :nodoc:
+          inherit Spec::Rails::DSL::ControllerEvalContext
+          prepend_before {setup}
+          append_after {teardown}
+          configure
+        end
+
+        Spec::DSL::BehaviourFactory.add_behaviour_class(:controller, self)
+      end
+    end
+  end
+end

data/spec/rails/vendor/plugins/rspec_on_rails/lib/spec/rails/dsl/behaviour/functional.rb

@@ -0,0 +1,90 @@
+module Spec
+  module Rails
+    module DSL
+      module FunctionalBehaviourHelpers
+        class << self
+          def included(mod)
+            mod.send :include, ExampleMethods
+            mod.send :extend, BehaviourMethods
+          end
+        end
+        
+        module BehaviourMethods
+          # You MUST provide a controller_name within the context of
+          # your controller specs:
+          #
+          #   describe "ThingController" do
+          #     controller_name :thing
+          #     ...
+          def controller_name(name=nil)
+            @controller_class_name = "#{name}_controller".camelize
+          end
+        end
+        
+        module ExampleMethods
+          # :call-seq:
+          #   assigns()
+          #
+          # Hash of instance variables to values that are made available to views.
+          # == Examples
+          #
+          #   #in thing_controller.rb
+          #   def new
+          #     @thing = Thing.new
+          #   end
+          #
+          #   #in thing_controller_spec
+          #   get 'new'
+          #   assigns[:registration].should == Thing.new
+          #--
+          # NOTE - Even though docs say only use assigns[:key] format, but allowing assigns(:key)
+          # in order to avoid breaking old specs.
+          #++
+          def assigns(key = nil)
+            if key.nil?
+              @controller.assigns
+              _controller_ivar_proxy
+            else
+              @controller.assigns[key]
+              _controller_ivar_proxy[key]
+            end
+          end
+
+        protected
+          def _controller_ivar_proxy
+            @controller_ivar_proxy ||= IvarProxy.new @controller 
+          end
+        end
+      end
+
+      class FunctionalEvalContext < Spec::Rails::DSL::EvalContext
+        include Spec::Rails::DSL::FunctionalBehaviourHelpers
+        attr_reader :request, :response
+        
+        def setup #:nodoc:
+
+          @controller_class = Object.path2class @controller_class_name
+          raise "Can't determine controller class for #{@controller_class_name}" if @controller_class.nil?
+
+          @controller = @controller_class.new
+        
+          @request = ActionController::TestRequest.new
+          @response = ActionController::TestResponse.new
+        end
+        
+        def params
+          request.parameters
+        end
+        
+        def flash
+          response.flash
+        end
+        
+        def session
+          request.session
+        end
+        
+      end
+    end
+  end
+end

data/spec/rails/vendor/plugins/rspec_on_rails/lib/spec/rails/dsl/behaviour/helper.rb

@@ -0,0 +1,100 @@
+module Spec
+  module Rails
+    module DSL
+      module HelperBehaviourHelpers
+        class << self
+          def included(mod)
+            mod.send :include, ExampleMethods
+            mod.send :extend, BehaviourMethods
+          end
+        end
+        
+        module BehaviourMethods
+          # The helper name....
+          def helper_name(name=nil)
+            send :include, "#{name}_helper".camelize.constantize
+          end
+        end
+        
+        module ExampleMethods
+          include ActionView::Helpers::ActiveRecordHelper
+          include ActionView::Helpers::TagHelper
+          include ActionView::Helpers::TextHelper
+          include ActionView::Helpers::FormTagHelper
+          include ActionView::Helpers::FormOptionsHelper
+          include ActionView::Helpers::FormHelper
+          include ActionView::Helpers::UrlHelper
+          include ActionView::Helpers::AssetTagHelper
+
+          def eval_erb(text)
+            ERB.new(text).result(binding)
+          end
+
+        end
+      end
+
+      class HelperEvalContextController < ApplicationController #:nodoc:
+        attr_accessor :request, :url
+
+        # Re-raise errors
+        def rescue_action(e); raise e; end
+      end
+
+      class HelperEvalContext < Spec::Rails::DSL::FunctionalEvalContext
+        include Spec::Rails::DSL::HelperBehaviourHelpers
+
+        def setup #:nodoc:
+          @controller_class_name = 'Spec::Rails::DSL::HelperEvalContextController'
+          super
+          @controller.request = @request
+          @controller.url = ActionController::UrlRewriter.new @request, {} # url_for
+          
+          @flash = ActionController::Flash::FlashHash.new
+          session['flash'] = @flash
+
+          ActionView::Helpers::AssetTagHelper::reset_javascript_include_default
+        end
+        
+        def flash
+          @flash
+        end
+      
+      end
+
+      # Helper Specs live in $RAILS_ROOT/spec/helpers/.
+      #
+      # Helper Specs use Spec::Rails::DSL::HelperBehaviour, which allows you to
+      # include your Helper directly in the context and write specs directly
+      # against its methods.
+      #
+      # HelperBehaviour also includes the standard lot of ActionView::Helpers in case your
+      # helpers rely on any of those.
+      #
+      # == Example
+      #
+      #   class ThingHelper
+      #     def number_of_things
+      #       Thing.count
+      #     end
+      #   end
+      #
+      #   describe "ThingHelper behaviour" do
+      #     include ThingHelper
+      #     it "should tell you the number of things" do
+      #       Thing.should_receive(:count).and_return(37)
+      #       number_of_things.should == 37
+      #     end
+      #   end
+      class HelperBehaviour < Spec::DSL::Behaviour
+        def before_eval #:nodoc:
+          inherit Spec::Rails::DSL::HelperEvalContext
+          prepend_before {setup}
+          append_after {teardown}
+          configure
+        end
+
+        Spec::DSL::BehaviourFactory.add_behaviour_class(:helper, self)
+      end
+    end
+  end
+end

data/spec/rails/vendor/plugins/rspec_on_rails/lib/spec/rails/dsl/behaviour/model.rb

@@ -0,0 +1,21 @@
+module Spec
+  module Rails
+    module DSL
+      # Model examples live in $RAILS_ROOT/spec/models/.
+      #
+      # Model examples use Spec::Rails::DSL::ModelBehaviour, which
+      # provides support for fixtures and some custom expectations via extensions
+      # to ActiveRecord::Base.
+      class ModelBehaviour < Spec::DSL::Behaviour
+        def before_eval # :nodoc:
+          inherit Spec::Rails::DSL::EvalContext
+          prepend_before {setup}
+          append_after {teardown}
+          configure
+        end
+
+        Spec::DSL::BehaviourFactory.add_behaviour_class(:model, self)
+      end
+    end
+  end
+end