rspec-rails 2.14.2 → 2.99.0.beta1

data/features/mailer_specs/url_helpers.feature

@@ -0,0 +1,38 @@
+Feature: URL helpers in mailer examples
+
+  Scenario: using URL helpers with default options
+    Given a file named "config/initializers/mailer_defaults.rb" with:
+      """ruby
+      Rails.configuration.action_mailer.default_url_options = { :host => 'example.com' }
+      """
+    And a file named "spec/mailers/notifications_spec.rb" with:
+      """ruby
+      require 'spec_helper'
+
+      describe Notifications do
+        it 'should have access to URL helpers' do
+          expect { gadgets_url }.not_to raise_error
+        end
+      end
+      """
+    When I run `rspec spec`
+    Then the examples should all pass
+
+  Scenario: using URL helpers without default options
+    Given a file named "config/initializers/mailer_defaults.rb" with:
+      """ruby
+      # no default options
+      """
+    And a file named "spec/mailers/notifications_spec.rb" with:
+      """ruby
+      require 'spec_helper'
+
+      describe Notifications do
+        it 'should have access to URL helpers' do
+          expect { gadgets_url :host => 'example.com' }.not_to raise_error
+          expect { gadgets_url }.to raise_error
+        end
+      end
+      """
+    When I run `rspec spec`
+    Then the examples should all pass

data/features/matchers/README.md

@@ -0,0 +1,18 @@
+rspec-rails offers a number of custom matchers, most of which are
+rspec-compatible wrappers for Rails' assertions.
+
+### redirects
+
+    # delegates to assert_redirected_to
+    expect(response).to redirect_to(path)
+
+### templates
+
+    # delegates to assert_template
+    expect(response).to render_template(template_name)
+
+### assigned objects
+
+    # passes if assigns(:widget) is an instance of Widget
+    # and it is not persisted
+    expect(assigns(:widget)).to be_a_new(Widget)

data/features/matchers/new_record_matcher.feature

@@ -0,0 +1,41 @@
+Feature: be_a_new matcher
+
+  The `be_a_new` matcher accepts a class and passes if the subject is an
+  instance of that class that returns false to persisted?
+
+  You can also chain `with` on `be_a_new` with a hash of attributes to specify
+  the subject has equal attributes.
+
+  Scenario: example spec with four be_a_new possibilities 
+    Given a file named "spec/models/widget_spec.rb" with:
+      """ruby
+      require "spec_helper"
+
+      describe Widget do
+        context "when initialized" do
+          subject(:widget) { Widget.new }
+
+          it "is a new widget" do
+            expect(widget).to be_a_new(Widget)
+          end
+
+          it "is not a new string" do
+            expect(widget).not_to be_a_new(String)
+          end
+        end
+
+        context "when saved" do
+          subject(:widget) { Widget.create }
+
+          it "is not a new widget" do
+            expect(widget).not_to be_a_new(Widget)
+          end
+
+          it "is not a new string" do
+            expect(widget).not_to be_a_new(String)
+          end
+        end
+      end
+      """
+    When I run `rspec spec/models/widget_spec.rb`
+    Then the examples should all pass

data/features/matchers/redirect_to_matcher.feature

@@ -0,0 +1,40 @@
+Feature: redirect_to matcher
+
+  The `redirect_to` matcher is used to specify that a request redirects to a
+  given template or action.  It delegates to
+  [`assert_redirected_to`](http://api.rubyonrails.org/classes/ActionDispatch/Assertions/ResponseAssertions.html#method-i-assert_redirected_to).
+
+  It is available in controller specs (spec/controllers) and request
+  specs (spec/requests).
+
+  Scenario: redirect_to with four possible options
+    Given a file named "spec/controllers/widgets_controller_spec.rb" with:
+      """ruby
+      require "spec_helper"
+
+      describe WidgetsController do
+
+        describe "#create" do
+          subject { post :create, :widget => { :name => "Foo" } }
+
+          it "redirects to widget_url(@widget)" do
+            expect(subject).to redirect_to(widget_url(assigns(:widget)))
+          end
+
+          it "redirects_to :action => :show" do
+            expect(subject).to redirect_to :action => :show,
+                                           :id => assigns(:widget).id
+          end
+
+          it "redirects_to(@widget)" do
+            expect(subject).to redirect_to(assigns(:widget))
+          end
+
+          it "redirects_to /widgets/:id" do
+            expect(subject).to redirect_to("/widgets/#{assigns(:widget).id}")
+          end
+        end
+      end
+      """
+    When I run `rspec spec/controllers/widgets_controller_spec.rb`
+    Then the examples should all pass

data/features/matchers/relation_match_array.feature

@@ -0,0 +1,27 @@
+Feature: ActiveRecord::Relation match array
+
+  The `match_array` matcher can be used with an `ActiveRecord::Relation`
+  (scope). The assertion will pass if the scope would return all of the
+  elements specified in the array on the right hand side.
+
+  Scenario: example spec with relation match_array matcher
+    Given a file named "spec/models/widget_spec.rb" with:
+      """ruby
+      require "spec_helper"
+
+      describe Widget do
+        let!(:widgets) { Array.new(3) { Widget.create } }
+
+        if ::Rails::VERSION::STRING >= '4'
+          subject { Widget.all }
+        else
+          subject { Widget.scoped }
+        end
+
+        it "returns all widgets in any order" do
+          expect(subject).to match_array(widgets)
+        end
+      end
+      """
+    When I run `rspec spec/models/widget_spec.rb`
+    Then the examples should all pass

data/features/matchers/render_template_matcher.feature

@@ -0,0 +1,49 @@
+Feature: render_template matcher
+
+  The `render_template` matcher is used to specify that a request renders a
+  given template.  It delegates to
+  [`assert_template`](http://api.rubyonrails.org/classes/ActionController/TemplateAssertions.html#method-i-assert_template)
+
+  It is available in controller specs (spec/controllers) and request
+  specs (spec/requests).
+
+  NOTE: use `redirect_to(:action => 'new')` for redirects, not `render_template`.
+
+  Scenario: render_template with three possible options
+    Given a file named "spec/controllers/gadgets_spec.rb" with:
+      """ruby
+      require "spec_helper"
+
+      describe GadgetsController do
+        describe "GET #index" do
+          subject { get :index }
+
+          it "renders the index template" do
+            expect(subject).to render_template(:index)
+            expect(subject).to render_template("index")
+            expect(subject).to render_template("gadgets/index")
+          end
+        end
+      end
+      """
+    When I run `rspec spec/controllers/gadgets_spec.rb`
+    Then the examples should all pass
+
+  Scenario: render_template in a view spec
+    Given a file named "spec/views/gadgets/index.html.erb_spec.rb" with:
+      """ruby
+      require "spec_helper"
+
+      describe "gadgets/index" do
+        it "renders the index template" do
+          assign(:gadgets, [stub_model(Gadget)])
+          render
+
+          expect(view).to render_template(:index)
+          expect(view).to render_template("index")
+          expect(view).to render_template("gadgets/index")
+        end
+      end
+      """
+    When I run `rspec spec/views`
+    Then the examples should all pass

data/features/mocks/mock_model.feature

@@ -0,0 +1,147 @@
+Feature: mock_model
+
+  The `mock_model` method generates a test double that acts like an instance of
+  `ActiveModel`. This is different from the `stub_model` method which generates
+  an instance of a real model class.
+
+  The benefit of `mock_model` over `stub_model` is that it is a true double, so
+  the examples are not dependent on the behavior (or mis-behavior), or even the
+  existence of any other code. If you're working on a controller spec and you
+  need a model that doesn't exist, you can pass `mock_model` a string and the
+  generated object will act as though its an instance of the class named by
+  that string.
+   
+  Scenario: passing a string that represents a non-existent constant
+    Given a file named "spec/models/car_spec.rb" with:
+      """ruby
+      require "spec_helper"
+
+      describe "mock_model('Car') with no Car constant in existence" do
+        it "generates a constant" do
+          expect(Object.const_defined?(:Car)).to be_falsey
+          mock_model("Car")
+          expect(Object.const_defined?(:Car)).to be_truthy
+        end
+
+        describe "generates an object that ..." do
+          it "returns the correct name" do
+            car = mock_model("Car")
+            expect(car.class.name).to eq("Car")
+          end
+
+          it "says it is a Car" do
+            car = mock_model("Car")
+            expect(car).to be_a(Car)
+          end
+        end
+      end
+      """
+    When I run `rspec spec/models/car_spec.rb`
+    Then the examples should all pass
+
+  Scenario: passing a string that represents an existing constant
+    Given a file named "spec/models/widget_spec.rb" with:
+      """ruby
+      require "spec_helper"
+
+      describe Widget do
+        it "uses the existing constant" do
+          widget = mock_model("Widget")
+          expect(widget).to be_a(Widget)
+        end
+      end
+      """
+    When I run `rspec spec/models/widget_spec.rb`
+    Then the examples should all pass
+
+  Scenario: passing a class that does not extend ActiveModel::Naming
+    Given a file named "spec/models/string_spec.rb" with:
+      """ruby
+      require "spec_helper"
+
+      describe String do
+        it "raises" do
+          expect { mock_model(String) }.to raise_exception
+        end
+      end
+      """
+    When I run `rspec spec/models/string_spec.rb`
+    Then the examples should all pass
+
+  Scenario: passing an Active Record constant
+    Given a file named "spec/models/widget_spec.rb" with:
+      """ruby
+      require "spec_helper"
+
+      describe Widget do
+        let(:widget) { mock_model(Widget) }
+
+        it "is valid by default" do
+          expect(widget).to be_valid
+        end
+
+        it "is not a new record by default" do
+          expect(widget).not_to be_new_record
+        end
+
+        it "can be converted to a new record" do
+          expect(widget.as_new_record).to be_new_record
+        end
+
+        it "sets :id to nil upon destroy" do
+          widget.destroy
+          expect(widget.id).to be_nil
+        end
+      end
+      """
+    When I run `rspec spec/models/widget_spec.rb`
+    Then the examples should all pass
+
+  Scenario: passing an Active Record constant with method stubs
+    Given a file named "spec/models/widget_spec.rb" with:
+      """ruby
+      require "spec_helper"
+
+      describe "mock_model(Widget) with stubs" do
+        let(:widget) do
+          mock_model Widget, :foo => "bar",
+                             :save => true,
+                             :update_attributes => false
+        end
+
+        it "supports stubs for methods that don't exist in ActiveModel or ActiveRecord" do
+          expect(widget.foo).to eq("bar")
+        end
+
+        it "supports stubs for methods that do exist" do
+          expect(widget.save).to eq(true)
+          expect(widget.update_attributes).to be_falsey
+        end
+
+        describe "#errors" do
+          context "with update_attributes => false" do
+            it "is not empty" do
+              expect(widget.errors).not_to be_empty
+            end
+          end
+        end
+      end
+      """
+    When I run `rspec spec/models/widget_spec.rb`
+    Then the examples should all pass
+
+  Scenario: mock_model outside rails
+    Given a file named "mock_model_outside_rails_spec.rb" with:
+      """ruby
+      require 'rspec/rails/mocks'
+
+      describe "Foo" do
+        it "is mockable" do
+          foo = mock_model("Foo")
+          expect(foo.id).to eq(1001)
+          expect(foo.to_param).to eq("1001")
+        end
+      end
+      """
+    When I run `rspec mock_model_outside_rails_spec.rb`
+    Then the examples should all pass

data/features/mocks/stub_model.feature

@@ -0,0 +1,58 @@
+Feature: stub_model
+  
+  The stub_model method generates an instance of a Active Model model.
+  
+  While you can use stub_model in any example (model, view, controller,
+  helper), it is especially useful in view examples, which are inherently
+  more state-based than interaction-based.
+   
+  Scenario: passing an Active Record constant with a hash of stubs
+    Given a file named "spec/models/widget_spec.rb" with:
+      """ruby
+      require "spec_helper"
+
+      describe "stub_model(Widget) with a hash of stubs" do
+        let(:widget) do
+          stub_model Widget, :id => 5, :random_attribute => true
+        end
+        
+        it "stubs :id" do
+          expect(widget.id).to eql(5)
+        end
+        
+        it "stubs :random_attribute" do
+          expect(widget.random_attribute).to be_truthy
+        end
+        
+        it "returns false for new_record? if :id is set" do
+          expect(widget).not_to be_new_record
+        end
+        
+        it "can be converted to a new record" do
+          widget.as_new_record
+          expect(widget).to be_new_record
+        end
+      end
+      """
+    When I run `rspec spec/models/widget_spec.rb`
+    Then the examples should all pass
+    
+  Scenario: passing an Active Record constant with a block of stubs
+    Given a file named "spec/models/widget_spec.rb" with:
+      """ruby
+      require "spec_helper"
+
+      describe "stub_model(Widget) with a block of stubs" do
+        let(:widget) do
+          stub_model Widget do |widget|
+            widget.id = 5
+          end
+        end
+        
+        it "stubs :id" do
+          expect(widget.id).to eql(5)
+        end
+      end
+      """
+    When I run `rspec spec/models/widget_spec.rb`
+    Then the examples should all pass

data/features/model_specs/README.md

@@ -0,0 +1,21 @@
+Model specs live in `spec/models` or any example group with
+`:type => :model`.
+
+A model spec is a thin wrapper for an ActiveSupport::TestCase, and includes all
+of the behavior and assertions that it provides, in addition to RSpec's own
+behavior and expectations.
+
+## Examples
+
+    require "spec_helper"
+    
+    describe Post do
+      context "with 2 or more comments" do
+        it "orders them in reverse chronologically" do
+          post = Post.create!
+          comment1 = post.comments.create!(:body => "first comment")
+          comment2 = post.comments.create!(:body => "second comment")
+          expect(post.reload.comments).to eq([comment2, comment1])
+        end
+      end
+    end