rspec-rails 2.14.0.rc1 → 2.14.0

data/features/controller_specs/Cookies.md

@@ -0,0 +1,57 @@
+Controller specs wrap Rails controller tests, which expose a few different ways
+to access cookies:
+
+    @request.cookies['key']
+    @response.cookies['key']
+    cookies['key']
+
+rails-3.0.x and 3.1 handle these slightly differently, so to avoid confusion, we recommend
+the following guidelines:
+
+### Recommended guidelines for rails-3.0.0 to 3.1.0
+
+  * Access cookies through the `request` and `response` objects in the spec.
+    * Use `request.cookies` before the action to set up state.
+    * Use `response.cookies` after the action to specify outcomes.
+  * Use the `cookies` object in the controller action. 
+  * Use String keys.
+
+<pre>
+# spec
+request.cookies['foo'] = 'bar'
+get :some_action
+expect(response.cookies['foo']).to eq('modified bar')
+
+# controller
+def some_action
+  cookies['foo'] = "modified #{cookies['foo']}"
+end
+</pre>
+
+#### Why use Strings instead of Symbols?
+
+The `cookies` objects in the spec come from Rack, and do not support
+indifferent access (i.e. `:foo` and `"foo"` are different keys). The `cookies`
+object in the controller _does_ support indifferent access, which is a bit
+confusing.
+
+This changed in rails-3.1, so you _can_ use symbol keys, but we recommend
+sticking with string keys for consistency.
+
+#### Why not use the `cookies` method?
+
+The `cookies` method combines the `request` and `response` cookies. This can
+lead to confusion when setting cookies in the example in order to set up state
+for the controller action. 
+
+    # does not work in rails 3.0.0 > 3.1.0
+    cookies['foo'] = 'bar' # this is not visible in the controller
+    get :some_action
+
+### Future versions of Rails
+
+There is code in the master branch in rails that makes cookie access more
+consistent so you can use the same `cookies` object before and after the action, 
+and you can use String or Symbol keys. We'll update these docs accordingly when
+that is released.
+

data/features/controller_specs/README.md

@@ -0,0 +1,45 @@
+Controller specs live in `spec/controllers` or any example group with
+`:type => :controller`.
+
+A controller spec is an RSpec wrapper for a Rails functional test
+([ActionController::TestCase::Behavior](https://github.com/rails/rails/blob/master/actionpack/lib/action_controller/test_case.rb)).
+It allows you to simulate a single http request in each example, and then
+specify expected outcomes such as:
+
+* rendered templates
+* redirects
+* instance variables assigned in the controller to be shared with the view
+* cookies sent back with the response
+
+To specify outcomes, you can use:
+
+* standard rspec matchers (`expect(response.status).to eq(200)`)
+* standard test/unit assertions (`assert_equal 200, response.status`)
+* rails assertions (`assert_response 200`)
+* rails-specific matchers:
+  * `expect(response).to render_template(wraps assert_template)`
+  * `expect(response).to redirect_to(wraps assert_redirected_to)`
+  * `expect(assigns(:widget)).to be_a_new(Widget)`
+
+## Examples
+
+    describe TeamsController do
+      describe "GET index" do
+        it "assigns @teams" do
+          team = Team.create
+          get :index
+          expect(assigns(:teams)).to eq([team])
+        end
+
+        it "renders the index template" do
+          get :index
+          expect(response).to render_template("index")
+        end
+      end
+    end
+
+## Views
+
+* by default, views are not rendered. See
+  [views are stubbed by default](controller-specs/views-are-stubbed-by-default) and
+  [render_views](controller-specs/render-views) for details.

data/features/controller_specs/anonymous_controller.feature

@@ -0,0 +1,378 @@
+Feature: anonymous controller
+
+  Use the `controller` method to define an anonymous controller derived from
+  `ApplicationController`. This is useful for specifying behavior like global
+  error handling.
+
+  To specify a different base class, you can pass the class explicitly to the
+  controller method:
+
+      controller(BaseController)
+
+  You can also configure RSpec to use the described class:
+
+      RSpec.configure do |c|
+        c.infer_base_class_for_anonymous_controllers = true
+      end
+
+      describe BaseController do
+        controller { ... }
+        # ^^ creates an anonymous subclass of `BaseController`
+
+  Scenario: specify error handling in ApplicationController
+    Given a file named "spec/controllers/application_controller_spec.rb" with:
+      """ruby
+      require "spec_helper"
+
+      class ApplicationController < ActionController::Base
+        class AccessDenied < StandardError; end
+
+        rescue_from AccessDenied, :with => :access_denied
+
+      private
+
+        def access_denied
+          redirect_to "/401.html"
+        end
+      end
+
+      describe ApplicationController do
+        controller do
+          def index
+            raise ApplicationController::AccessDenied
+          end
+        end
+
+        describe "handling AccessDenied exceptions" do
+          it "redirects to the /401.html page" do
+            get :index
+            expect(response).to redirect_to("/401.html")
+          end
+        end
+      end
+      """
+    When I run `rspec spec`
+    Then the examples should all pass
+
+  Scenario: specify error handling in subclass of ApplicationController
+    Given a file named "spec/controllers/application_controller_subclass_spec.rb" with:
+      """ruby
+      require "spec_helper"
+
+      class ApplicationController < ActionController::Base
+        class AccessDenied < StandardError; end
+      end
+
+      class ApplicationControllerSubclass < ApplicationController
+
+        rescue_from ApplicationController::AccessDenied, :with => :access_denied
+
+      private
+
+        def access_denied
+          redirect_to "/401.html"
+        end
+      end
+
+      describe ApplicationControllerSubclass do
+        controller(ApplicationControllerSubclass) do
+          def index
+            raise ApplicationController::AccessDenied
+          end
+        end
+
+        describe "handling AccessDenied exceptions" do
+          it "redirects to the /401.html page" do
+            get :index
+            expect(response).to redirect_to("/401.html")
+          end
+        end
+      end
+      """
+    When I run `rspec spec`
+    Then the examples should all pass
+
+  Scenario: infer base class from the described class
+    Given a file named "spec/controllers/base_class_can_be_inferred_spec.rb" with:
+      """ruby
+      require "spec_helper"
+
+      RSpec.configure do |c|
+        c.infer_base_class_for_anonymous_controllers = true
+      end
+
+      class ApplicationController < ActionController::Base; end
+
+      class ApplicationControllerSubclass < ApplicationController; end
+
+      describe ApplicationControllerSubclass do
+        controller do
+          def index
+            render :text => "Hello World"
+          end
+        end
+
+        it "creates an anonymous controller derived from ApplicationControllerSubclass" do
+          expect(controller).to be_a_kind_of(ApplicationControllerSubclass)
+        end
+      end
+      """
+    When I run `rspec spec`
+    Then the examples should all pass
+
+  Scenario: invoke around filter in base class
+    Given a file named "spec/controllers/application_controller_around_filter_spec.rb" with:
+      """ruby
+      require "spec_helper"
+
+      class ApplicationController < ActionController::Base
+        around_filter :an_around_filter
+
+        def an_around_filter
+          @callback_invoked = true
+          yield
+        end
+      end
+
+      describe ApplicationController do
+        controller do
+          def index
+            render :nothing => true
+          end
+        end
+
+        it "invokes the callback" do
+          get :index
+
+          expect(assigns[:callback_invoked]).to be_true
+        end
+      end
+      """
+    When I run `rspec spec`
+    Then the examples should all pass
+
+  Scenario: anonymous controllers only create resource routes
+    Given a file named "spec/controllers/application_controller_spec.rb" with:
+    """ruby
+    require "spec_helper"
+
+    describe ApplicationController do
+      controller do
+        def index
+          render :text => "index called"
+        end
+
+        def create
+          render :text => "create called"
+        end
+
+        def new
+          render :text => "new called"
+        end
+
+        def show
+          render :text => "show called"
+        end
+
+        def edit
+          render :text => "edit called"
+        end
+
+        def update
+          render :text => "update called"
+        end
+
+        def destroy
+          render :text => "destroy called"
+        end
+
+        def willerror
+          render :text => "will not render"
+        end
+      end
+
+      describe "#index" do
+        it "responds to GET" do
+          get :index
+          expect(response.body).to eq "index called"
+        end
+
+        it "also responds to POST" do
+          post :index
+          expect(response.body).to eq "index called"
+        end
+
+        it "also responds to PUT" do
+          put :index
+          expect(response.body).to eq "index called"
+        end
+
+        it "also responds to DELETE" do
+          delete :index
+          expect(response.body).to eq "index called"
+        end
+      end
+
+      describe "#create" do
+        it "responds to POST" do
+          post :create
+          expect(response.body).to eq "create called"
+        end
+
+        # And the rest...
+        %w{get post put delete}.each do |calltype|
+          it "responds to #{calltype}" do
+            send(calltype, :create)
+            expect(response.body).to eq "create called"
+          end
+        end
+      end
+
+      describe "#new" do
+        it "responds to GET" do
+          get :new
+          expect(response.body).to eq "new called"
+        end
+
+        # And the rest...
+        %w{get post put delete}.each do |calltype|
+          it "responds to #{calltype}" do
+            send(calltype, :new)
+            expect(response.body).to eq "new called"
+          end
+        end
+      end
+
+      describe "#edit" do
+        it "responds to GET" do
+          get :edit, :id => "anyid"
+          expect(response.body).to eq "edit called"
+        end
+
+        it "requires the :id parameter" do
+          expect { get :edit }.to raise_error(ActionController::RoutingError)
+        end
+
+        # And the rest...
+        %w{get post put delete}.each do |calltype|
+          it "responds to #{calltype}" do
+            send(calltype, :edit, {:id => "anyid"})
+            expect(response.body).to eq "edit called"
+          end
+        end
+      end
+
+      describe "#show" do
+        it "responds to GET" do
+          get :show, :id => "anyid"
+          expect(response.body).to eq "show called"
+        end
+
+        it "requires the :id parameter" do
+          expect { get :show }.to raise_error(ActionController::RoutingError)
+        end
+
+        # And the rest...
+        %w{get post put delete}.each do |calltype|
+          it "responds to #{calltype}" do
+            send(calltype, :show, {:id => "anyid"})
+            expect(response.body).to eq "show called"
+          end
+        end
+      end
+
+      describe "#update" do
+        it "responds to PUT" do
+          put :update, :id => "anyid"
+          expect(response.body).to eq "update called"
+        end
+
+        it "requires the :id parameter" do
+          expect { put :update }.to raise_error(ActionController::RoutingError)
+        end
+
+        # And the rest...
+        %w{get post put delete}.each do |calltype|
+          it "responds to #{calltype}" do
+            send(calltype, :update, {:id => "anyid"})
+            expect(response.body).to eq "update called"
+          end
+        end
+      end
+
+      describe "#destroy" do
+        it "responds to DELETE" do
+          delete :destroy, :id => "anyid"
+          expect(response.body).to eq "destroy called"
+        end
+
+        it "requires the :id parameter" do
+          expect { delete :destroy }.to raise_error(ActionController::RoutingError)
+        end
+
+        # And the rest...
+        %w{get post put delete}.each do |calltype|
+          it "responds to #{calltype}" do
+            send(calltype, :destroy, {:id => "anyid"})
+            expect(response.body).to eq "destroy called"
+          end
+        end
+      end
+
+      describe "#willerror" do
+        it "cannot be called" do
+          expect { get :willerror }.to raise_error(ActionController::RoutingError)
+        end
+      end
+    end
+    """
+    When I run `rspec spec`
+    Then the examples should all pass
+
+  Scenario: draw custom routes for anonymous controllers
+    Given a file named "spec/controllers/application_controller_spec.rb" with:
+    """ruby
+    require "spec_helper"
+
+    describe ApplicationController do
+      controller do
+        def custom
+          render :text => "custom called"
+        end
+      end
+
+      specify "a custom action can be requested if routes are drawn manually" do
+        routes.draw { get "custom" => "anonymous#custom" }
+
+        get :custom
+        expect(response.body).to eq "custom called"
+      end
+    end
+    """
+    When I run `rspec spec`
+    Then the examples should all pass
+
+  Scenario: refer to application routes in the controller under test
+    Given a file named "spec/controllers/application_controller_spec.rb" with:
+    """ruby
+    require "spec_helper"
+
+    Rails.application.routes.draw do
+      match "/login" => "sessions#new", :as => "login", :via => "get"
+    end
+
+    describe ApplicationController do
+      controller do
+        def index
+          redirect_to login_url
+        end
+      end
+
+      it "redirects to the login page" do
+        get :index
+        expect(response).to redirect_to("/login")
+      end
+    end
+    """
+    When I run `rspec spec`
+    Then the examples should all pass