rspec-rails 2.13.1 → 2.13.2

data/features/mailer_specs/url_helpers.feature

@@ -1,38 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,40 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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 } }
-        subject { Widget.scoped }
-
-        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

@@ -1,49 +0,0 @@
-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

@@ -1,147 +0,0 @@
-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_false
-          mock_model("Car")
-          expect(Object.const_defined?(:Car)).to be_true
-        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_false
-        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

@@ -1,58 +0,0 @@
-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_true
-        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

@@ -1,21 +0,0 @@
-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

data/features/model_specs/errors_on.feature

@@ -1,51 +0,0 @@
-Feature: errors_on
-
-  Scenario: with one validation error
-    Given a file named "spec/models/widget_spec.rb" with:
-      """ruby
-      require "spec_helper"
-
-      class ValidatingWidget < ActiveRecord::Base
-        self.table_name = :widgets
-        validates_presence_of :name
-
-        # In Rails 4, mass assignment protection is implemented on controllers
-        attr_accessible :name if RSpec::Rails.rails_version_satisfied_by?('< 4.0.0.beta1')
-
-        validates_length_of :name, :minimum => 10, :on => :publication
-      end
-
-      describe ValidatingWidget do
-        it "fails validation with no name (using error_on)" do
-          expect(ValidatingWidget.new).to have(1).error_on(:name)
-        end
-
-        it "fails validation with no name (using errors_on)" do
-          expect(ValidatingWidget.new).to have(1).errors_on(:name)
-        end
-
-        it "fails validation with no name expecting a specific message" do
-          expect(ValidatingWidget.new.errors_on(:name)).to include("can't be blank")
-        end
-
-        it "fails validation with a short name (using a validation context)" do
-          expect(ValidatingWidget.new(:name => "too short")).
-            to have(1).errors_on(:name, :context => :publication)
-        end
-
-        it "passes validation with a longer name (using a validation context)" do
-          expect(ValidatingWidget.new(:name => "a longer name")).
-            to have(0).errors_on(:name, :context => :publication)
-        end
-
-        it "passes validation with a name (using 0)" do
-          expect(ValidatingWidget.new(:name => "liquid nitrogen")).to have(0).errors_on(:name)
-        end
-
-        it "passes validation with a name (using :no)" do
-          expect(ValidatingWidget.new(:name => "liquid nitrogen")).to have(:no).errors_on(:name)
-        end
-      end
-      """
-    When I run `rspec spec/models/widget_spec.rb`
-    Then the examples should all pass