rspec-rails 2.99.0 → 3.0.0.beta1

data/features/feature_specs/feature_spec.feature

@@ -0,0 +1,35 @@
+@capybara
+Feature: feature spec
+
+  Feature specs are high-level tests meant to exercise slices of functionality
+  through an application. They should drive the application only via its
+  external interface, usually web pages.
+
+  Feature specs require the [capybara](http://github.com/jnicklas/capybara)
+  gem, version 2.0.0 or later. Refer to the [capybara API
+  documentation](http://rubydoc.info/github/jnicklas/capybara/master) for more
+  information on the methods and matchers that can be used in feature specs.
+
+  The `feature` and `scenario` DSL correspond to `describe` and `it`,
+  respectively. These methods are simply aliases that allow feature specs to
+  read more as [customer tests](http://c2.com/cgi/wiki?CustomerTest) and
+  [acceptance tests](http://c2.com/cgi/wiki?AcceptanceTest).
+
+  Scenario: specify creating a Widget by driving the application with capybara
+    Given a file named "spec/features/widget_management_spec.rb" with:
+      """ruby
+      require "spec_helper"
+
+      feature "Widget management" do
+        scenario "User creates a new widget" do
+          visit "/widgets/new"
+
+          fill_in "Name", :with => "My Widget"
+          click_button "Create Widget"
+
+          expect(page).to have_text("Widget was successfully created.")
+        end
+      end
+      """
+    When I run `rspec spec/features/widget_management_spec.rb`
+    Then the example should pass

data/features/helper_specs/helper_spec.feature

@@ -0,0 +1,122 @@
+Feature: helper spec
+
+  Helper specs live in `spec/helpers`, or any example group with `:type =>
+  :helper`.
+
+  Helper specs expose a `helper` object, which includes the helper module being
+  specified, the `ApplicationHelper` module (if there is one) and all of the
+  helpers built into Rails. It does not include the other helper modules in
+  your app.
+
+  To access the helper methods you're specifying, simply call them directly
+  on the `helper` object.
+
+  NOTE: helper methods defined in controllers are not included.
+
+  Scenario: helper method that returns a value
+    Given a file named "spec/helpers/application_helper_spec.rb" with:
+      """ruby
+      require "spec_helper"
+
+      describe ApplicationHelper do
+        describe "#page_title" do
+          it "returns the default title" do
+            expect(helper.page_title).to eq("RSpec is your friend")
+          end
+        end
+      end
+      """
+    And a file named "app/helpers/application_helper.rb" with:
+      """ruby
+      module ApplicationHelper
+        def page_title
+          "RSpec is your friend"
+        end
+      end
+      """
+    When I run `rspec spec/helpers/application_helper_spec.rb`
+    Then the examples should all pass
+
+  Scenario: helper method that accesses an instance variable
+    Given a file named "spec/helpers/application_helper_spec.rb" with:
+      """ruby
+      require "spec_helper"
+
+      describe ApplicationHelper do
+        describe "#page_title" do
+          it "returns the instance variable" do
+            assign(:title, "My Title")
+            expect(helper.page_title).to eql("My Title")
+          end
+        end
+      end
+      """
+    And a file named "app/helpers/application_helper.rb" with:
+      """ruby
+      module ApplicationHelper
+        def page_title
+          @title || nil
+        end
+      end
+      """
+    When I run `rspec spec/helpers/application_helper_spec.rb`
+    Then the examples should all pass
+
+  Scenario: application helper is included in helper object
+    Given a file named "spec/helpers/widgets_helper_spec.rb" with:
+      """ruby
+      require "spec_helper"
+
+      describe WidgetsHelper do
+        describe "#widget_title" do
+          it "includes the app name" do
+            assign(:title, "This Widget")
+            expect(helper.widget_title).to eq("The App: This Widget")
+          end
+        end
+      end
+      """
+    And a file named "app/helpers/application_helper.rb" with:
+      """ruby
+      module ApplicationHelper
+        def app_name
+          "The App"
+        end
+      end
+      """
+    And a file named "app/helpers/widgets_helper.rb" with:
+      """ruby
+      module WidgetsHelper
+        def widget_title
+          "#{app_name}: #{@title}"
+        end
+      end
+      """
+    When I run `rspec spec/helpers/widgets_helper_spec.rb`
+    Then the examples should all pass
+
+  Scenario: url helpers are defined
+    Given a file named "spec/helpers/widgets_helper_spec.rb" with:
+    """ruby
+    require "spec_helper"
+
+    describe WidgetsHelper do
+      describe "#link_to_widget" do
+        it "links to a widget using its name" do
+          widget = Widget.create!(:name => "This Widget")
+          expect(helper.link_to_widget(widget)).to include("This Widget")
+          expect(helper.link_to_widget(widget)).to include(widget_path(widget))
+        end
+      end
+    end
+    """
+    And a file named "app/helpers/widgets_helper.rb" with:
+    """ruby
+    module WidgetsHelper
+      def link_to_widget(widget)
+        link_to(widget.name, widget_path(widget))
+      end
+    end
+    """
+    When I run `rspec spec/helpers/widgets_helper_spec.rb`
+    Then the examples should all pass

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