rspec-rails 2.99.0 → 3.0.0.beta1

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

data/features/model_specs/errors_on.feature

@@ -0,0 +1,51 @@
+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 ::ActiveRecord::VERSION::STRING < '4'
+
+        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

data/features/model_specs/records.feature

@@ -0,0 +1,27 @@
+Feature: records
+
+  Scenario: asserting number of records
+    Given a file named "spec/models/widget_spec.rb" with:
+      """ruby
+      require "spec_helper"
+
+      describe Widget do
+        it "has no widgets in the database" do
+          expect(Widget).to have(:no).records
+          expect(Widget).to have(0).records
+        end
+
+        it "has one record" do
+          Widget.create!(:name => "Cog")
+          expect(Widget).to have(1).record
+        end
+
+        it "counts only records that match a query" do
+          Widget.create!(:name => "Cog")
+          expect(Widget.where(:name => "Cog")).to have(1).record
+          expect(Widget.where(:name => "Wheel")).to have(0).records
+        end
+      end
+      """
+    When I run `rspec spec/models/widget_spec.rb`
+    Then the examples should all pass

data/features/model_specs/transactional_examples.feature

@@ -0,0 +1,109 @@
+Feature: transactional examples
+
+  By default rspec executes each individual example in a transaction.
+
+  You can also explicitly enable/disable transactions the configuration
+  property 'use_transactional_examples'.
+
+  Scenario: run in transactions (default)
+    Given a file named "spec/models/widget_spec.rb" with:
+      """ruby
+      require "spec_helper"
+
+      describe Widget do
+        it "has none to begin with" do
+          expect(Widget.count).to eq 0
+        end
+
+        it "has one after adding one" do
+          Widget.create
+          expect(Widget.count).to eq 1
+        end
+
+        it "has none after one was created in a previous example" do
+          expect(Widget.count).to eq 0
+        end
+      end
+      """
+    When I run `rspec spec/models/widget_spec.rb`
+    Then the examples should all pass
+
+  Scenario: run in transactions (explicit)
+    Given a file named "spec/models/widget_spec.rb" with:
+      """ruby
+      require "spec_helper"
+
+      RSpec.configure do |c|
+        c.use_transactional_examples = true
+      end
+
+      describe Widget do
+        it "has none to begin with" do
+          expect(Widget.count).to eq 0
+        end
+
+        it "has one after adding one" do
+          Widget.create
+          expect(Widget.count).to eq 1
+        end
+
+        it "has none after one was created in a previous example" do
+          expect(Widget.count).to eq 0
+        end
+      end
+      """
+    When I run `rspec spec/models/widget_spec.rb`
+    Then the examples should all pass
+
+  Scenario: disable transactions (explicit)
+    Given a file named "spec/models/widget_spec.rb" with:
+      """ruby
+      require "spec_helper"
+
+      RSpec.configure do |c|
+        c.use_transactional_examples = false
+        c.order = "defined"
+      end
+
+      describe Widget do
+        it "has none to begin with" do
+          expect(Widget.count).to eq 0
+        end
+
+        it "has one after adding one" do
+          Widget.create
+          expect(Widget.count).to eq 1
+        end
+
+        it "has one after one was created in a previous example" do
+          expect(Widget.count).to eq 1
+        end
+
+        after(:all) { Widget.destroy_all }
+      end
+      """
+    When I run `rspec spec/models/widget_spec.rb`
+    Then the examples should all pass
+
+  Scenario: run in transactions with fixture
+    Given a file named "spec/models/thing_spec.rb" with:
+      """ruby
+      require "spec_helper"
+
+      describe Thing do
+        fixtures :things
+        it "fixture method defined" do
+          things(:one)
+        end
+      end
+      """
+    Given a file named "spec/fixtures/things.yml" with:
+      """
+      one:
+        name: MyString
+      """
+    When I run `rspec spec/models/thing_spec.rb`
+    Then the examples should all pass
+
+
+

data/features/request_specs/request_spec.feature

@@ -0,0 +1,49 @@
+Feature: request spec
+
+  Request specs provide a thin wrapper around Rails' integration tests, and are
+  designed to drive behavior through the full stack, including routing
+  (provided by Rails) and without stubbing (that's up to you).
+
+  With request specs, you can:
+
+  * specify a single request
+  * specify multiple requests across multiple controllers
+  * specify multiple requests across multiple sessions
+
+  Check the rails documentation on integration tests for more information.
+
+  RSpec provides two matchers that delegate to Rails assertions:
+
+      render_template # delegates to assert_template
+      redirect_to     # delegates to assert_redirected_to
+
+  Check the Rails docs for details on these methods as well.
+
+  [Capybara](http://github.com/jnicklas/capybara) is no longer supported in
+  request specs as of Capybara 2.0.0. The recommended way to use Capybara is
+  with [feature specs](../feature-specs/feature-spec).
+
+  Scenario: specify managing a Widget with Rails integration methods
+    Given a file named "spec/requests/widget_management_spec.rb" with:
+      """ruby
+      require "spec_helper"
+
+      describe "Widget management" do
+
+        it "creates a Widget and redirects to the Widget's page" do
+          get "/widgets/new"
+          expect(response).to render_template(:new)
+
+          post "/widgets", :widget => {:name => "My Widget"}
+
+          expect(response).to redirect_to(assigns(:widget))
+          follow_redirect!
+
+          expect(response).to render_template(:show)
+          expect(response.body).to include("Widget was successfully created.")
+        end
+
+      end
+      """
+    When I run `rspec spec/requests/widget_management_spec.rb`
+    Then the example should pass

data/features/routing_specs/README.md

@@ -0,0 +1,16 @@
+Routing specs live in the `spec/routing` directory, or any example group with
+`:type => :routing`.
+
+Simple apps with nothing but standard RESTful routes won't get much value from
+routing specs, but they can provide significant value when used to specify
+customized routes, like vanity links, slugs, etc.
+
+    expect(:get => "/articles/2012/11/when-to-use-routing-specs").to route_to(
+      :controller => "articles",
+      :month => "2012-11",
+      :slug => "when-to-use-routing-specs"
+    )
+
+They are also valuable for routes that should not be available:
+
+    expect(:delete => "/accounts/37").not_to be_routable

data/features/routing_specs/be_routable_matcher.feature

@@ -0,0 +1,80 @@
+Feature: be_routable matcher
+
+  The `be_routable` matcher is best used with `should_not` to specify that a
+  given route should not be routable. It is available in routing specs (in
+  spec/routing) and controller specs (in spec/controllers).
+
+  Scenario: specify routeable route should not be routable (fails)
+    Given a file named "spec/routing/widgets_routing_spec.rb" with:
+      """ruby
+      require "spec_helper"
+
+      describe "routes for Widgets" do
+        it "does not route to widgets" do
+          expect(:get => "/widgets").not_to be_routable
+        end
+      end
+      """
+
+    When I run `rspec spec/routing/widgets_routing_spec.rb`
+    Then the output should contain "1 example, 1 failure"
+
+  Scenario: specify non-routeable route should not be routable (passes)
+    Given a file named "spec/routing/widgets_routing_spec.rb" with:
+      """ruby
+      require "spec_helper"
+
+      describe "routes for Widgets" do
+        it "does not route to widgets/foo/bar" do
+          expect(:get => "/widgets/foo/bar").not_to be_routable
+        end
+      end
+      """
+
+    When I run `rspec spec/routing/widgets_routing_spec.rb`
+    Then the examples should all pass
+
+  Scenario: specify routeable route should be routable (passes)
+    Given a file named "spec/routing/widgets_routing_spec.rb" with:
+      """ruby
+      require "spec_helper"
+
+      describe "routes for Widgets" do
+        it "routes to /widgets" do
+          expect(:get => "/widgets").to be_routable
+        end
+      end
+      """
+
+    When I run `rspec spec/routing/widgets_routing_spec.rb`
+    Then the examples should all pass
+
+  Scenario: specify non-routeable route should be routable (fails)
+    Given a file named "spec/routing/widgets_routing_spec.rb" with:
+      """ruby
+      require "spec_helper"
+
+      describe "routes for Widgets" do
+        it "routes to widgets/foo/bar" do
+          expect(:get => "/widgets/foo/bar").to be_routable
+        end
+      end
+      """
+
+    When I run `rspec spec/routing/widgets_routing_spec.rb`
+    Then the output should contain "1 example, 1 failure"
+
+  Scenario: be_routable in a controller spec
+    Given a file named "spec/controllers/widgets_controller_spec.rb" with:
+      """ruby
+      require "spec_helper"
+
+      describe WidgetsController do
+        it "routes to /widgets" do
+          expect(:get => "/widgets").to be_routable
+        end
+      end
+      """
+
+    When I run `rspec spec/controllers/widgets_controller_spec.rb`
+    Then the examples should all pass

data/features/routing_specs/engine_routes.feature

@@ -0,0 +1,38 @@
+Feature: engine routes
+
+  Routing specs can specify the routeset that will be used for the example
+  group. This is most useful when testing Rails engines.
+
+  @unsupported-on-rails-3-0
+  Scenario: specify engine route
+    Given a file named "spec/routing/engine_routes_spec.rb" with:
+    """ruby
+    require "spec_helper"
+
+    # A very simple Rails engine
+    module MyEngine
+      class Engine < ::Rails::Engine
+        isolate_namespace MyEngine
+      end
+
+      Engine.routes.draw do
+        resources :widgets, :only => [:index]
+      end
+
+      class WidgetsController < ::ActionController::Base
+        def index
+        end
+      end
+    end
+
+    describe MyEngine::WidgetsController do
+      routes { MyEngine::Engine.routes }
+
+      it "routes to the list of all widgets" do
+        expect(:get => widgets_path).
+          to route_to(:controller => "my_engine/widgets", :action => "index")
+      end
+    end
+    """
+    When I run `rspec spec`
+    Then the examples should all pass