rspec-rails 2.14.0.rc1 → 2.14.0

data/spec/rspec/rails/matchers/be_routable_spec.rb

@@ -0,0 +1,41 @@
+require "spec_helper"
+
+describe "be_routable" do
+  include RSpec::Rails::Matchers::RoutingMatchers
+  attr_reader :routes
+
+  before { @routes = double("routes") }
+
+  context "with should" do
+    it "passes if routes recognize the path" do
+      routes.stub(:recognize_path) { {} }
+      expect do
+        {:get => "/a/path"}.should be_routable
+      end.to_not raise_error
+    end
+
+    it "fails if routes do not recognize the path" do
+      routes.stub(:recognize_path) { raise ActionController::RoutingError.new('ignore') }
+      expect do
+        {:get => "/a/path"}.should be_routable
+      end.to raise_error(/expected \{:get=>"\/a\/path"\} to be routable/)
+    end
+  end
+
+  context "with should_not" do
+
+    it "passes if routes do not recognize the path" do
+      routes.stub(:recognize_path) { raise ActionController::RoutingError.new('ignore') }
+      expect do
+        {:get => "/a/path"}.should_not be_routable
+      end.to_not raise_error
+    end
+
+    it "fails if routes recognize the path" do
+      routes.stub(:recognize_path) { {:controller => "foo"} }
+      expect do
+        {:get => "/a/path"}.should_not be_routable
+      end.to raise_error(/expected \{:get=>"\/a\/path"\} not to be routable, but it routes to \{:controller=>"foo"\}/)
+    end
+  end
+end

data/spec/rspec/rails/matchers/be_valid_spec.rb

@@ -0,0 +1,44 @@
+require "spec_helper"
+require 'active_support/all'
+require 'rspec/rails/matchers/be_valid'
+
+describe "be_valid matcher" do
+  include RSpec::Rails::Matchers
+
+  class Post
+    include ActiveModel::Validations
+    attr_accessor :title
+    validates_presence_of :title
+  end
+
+  let(:post) { Post.new }
+
+  it "includes the error messages in the failure message" do
+    expect {
+      expect(post).to be_valid
+    }.to raise_exception(/Title can't be blank/)
+  end
+
+  it "includes a failure message for the negative case" do
+    post.stub(:valid?) { true }
+    expect {
+      expect(post).not_to be_valid
+    }.to raise_exception(/expected .* not to be valid/)
+  end
+
+  it "uses a custom failure message if provided" do
+    expect {
+      expect(post).to be_valid, "Post was not valid!"
+    }.to raise_exception(/Post was not valid!/)
+  end
+
+  it "includes the validation context if provided" do
+    post.should_receive(:valid?).with(:create) { true }
+    expect(post).to be_valid(:create)
+  end
+
+  it "does not include the validation context if not provided" do
+    post.should_receive(:valid?).with(no_args) { true }
+    expect(post).to be_valid
+  end
+end

data/spec/rspec/rails/matchers/errors_on_spec.rb

@@ -0,0 +1,38 @@
+require "spec_helper"
+
+describe "error_on" do
+  it "provides a description including the name of what the error is on" do
+    have(1).error_on(:whatever).description.should == "have 1 error on :whatever"
+  end
+
+  it "provides a failure message including the number actually given" do
+    lambda {
+      [].should have(1).error_on(:whatever)
+    }.should raise_error("expected 1 error on :whatever, got 0")
+  end
+end
+
+describe "errors_on" do
+  it "provides a description including the name of what the error is on" do
+    have(2).errors_on(:whatever).description.should == "have 2 errors on :whatever"
+  end
+
+  it "provides a failure message including the number actually given" do
+    lambda {
+      [1].should have(3).errors_on(:whatever)
+    }.should raise_error("expected 3 errors on :whatever, got 1")
+  end
+end
+
+describe "have something other than error_on or errors_on" do
+  it "has a standard rspec failure message" do
+    lambda {
+      [1,2,3].should have(2).elements
+    }.should raise_error("expected 2 elements, got 3")
+  end
+
+  it "has a standard rspec description" do
+    have(2).elements.description.should == "have 2 elements"
+  end
+end
+

data/spec/rspec/rails/matchers/has_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+class CollectionOwner < ActiveRecord::Base
+  connection.execute <<-SQL
+    CREATE TABLE collection_owners (
+      id integer PRIMARY KEY AUTOINCREMENT
+    )
+SQL
+  has_many :associated_items do
+    def has_some_quality?; true end
+  end
+end
+
+class AssociatedItem < ActiveRecord::Base
+  connection.execute <<-SQL
+    CREATE TABLE associated_items (
+      id integer PRIMARY KEY AUTOINCREMENT,
+      collection_owner_id integer
+    )
+SQL
+  belongs_to :collection_owner
+end
+
+describe "should have_xxx" do
+  it "works with ActiveRecord::Associations::CollectionProxy" do
+    owner = CollectionOwner.new
+    owner.associated_items.should have_some_quality
+  end
+end

data/spec/rspec/rails/matchers/have_rendered_spec.rb

@@ -0,0 +1,93 @@
+require "spec_helper"
+
+%w[have_rendered render_template].each do |template_expectation|
+  describe template_expectation do
+    include RSpec::Rails::Matchers::RenderTemplate
+    let(:response) { ActionController::TestResponse.new }
+
+    context "given a hash" do
+      it "delegates to assert_template" do
+        self.should_receive(:assert_template).with({:this => "hash"}, "this message")
+        expect("response").to send(template_expectation, {:this => "hash"}, "this message")
+      end
+    end
+
+    context "given a string" do
+      it "delegates to assert_template" do
+        self.should_receive(:assert_template).with("this string", "this message")
+        expect("response").to send(template_expectation, "this string", "this message")
+      end
+    end
+
+    context "given a symbol" do
+      it "converts to_s and delegates to assert_template" do
+        self.should_receive(:assert_template).with("template_name", "this message")
+        expect("response").to send(template_expectation, :template_name, "this message")
+      end
+    end
+
+    context "with should" do
+      context "when assert_template passes" do
+        it "passes" do
+          def assert_template(*); end
+          expect do
+            expect(response).to send(template_expectation, "template_name")
+          end.to_not raise_exception
+        end
+      end
+
+      context "when assert_template fails" do
+        it "uses failure message from assert_template" do
+          def assert_template(*)
+            raise ActiveSupport::TestCase::Assertion.new("this message")
+          end
+          expect do
+            expect(response).to send(template_expectation, "template_name")
+          end.to raise_error("this message")
+        end
+      end
+
+      context "when fails due to some other exception" do
+        it "raises that exception" do
+          def assert_template(*)
+            raise "oops"
+          end
+          expect do
+            expect(response).to send(template_expectation, "template_name")
+          end.to raise_exception("oops")
+        end
+      end
+    end
+
+    context "with should_not" do
+      context "when assert_template fails" do
+        it "passes" do
+          def assert_template(*)
+            raise ActiveSupport::TestCase::Assertion.new("this message")
+          end
+          expect do
+            expect(response).to_not send(template_expectation, "template_name")
+          end.to_not raise_exception
+        end
+      end
+
+      context "when assert_template passes" do
+        it "fails with custom failure message" do
+          def assert_template(*); end
+          expect do
+            expect(response).to_not send(template_expectation, "template_name")
+          end.to raise_error(/expected not to render \"template_name\", but did/)
+        end
+      end
+
+      context "when fails due to some other exception" do
+        it "raises that exception" do
+          def assert_template(*); raise "oops"; end
+          expect do
+            expect(response).to_not send(template_expectation, "template_name")
+          end.to raise_exception("oops")
+        end
+      end
+    end
+  end
+end

data/spec/rspec/rails/matchers/redirect_to_spec.rb

@@ -0,0 +1,80 @@
+require "spec_helper"
+require "active_support/test_case"
+
+describe "redirect_to" do
+  include RSpec::Rails::Matchers::RedirectTo
+
+  let(:response) { ActionController::TestResponse.new }
+
+  context "with should" do
+    context "when assert_redirected_to passes" do
+      def assert_redirected_to(*); end
+
+      it "passes" do
+        expect do
+          response.should redirect_to("destination")
+        end.to_not raise_exception
+      end
+    end
+
+    context "when assert_redirected_to fails" do
+      def assert_redirected_to(*)
+        raise ActiveSupport::TestCase::Assertion.new("this message")
+      end
+
+      it "uses failure message from assert_redirected_to" do
+        expect do
+          response.should redirect_to("destination")
+        end.to raise_exception("this message")
+      end
+    end
+
+    context "when fails due to some other exception" do
+      def assert_redirected_to(*)
+        raise "oops"
+      end
+
+      it "raises that exception" do
+        expect do
+          response.should redirect_to("destination")
+        end.to raise_exception("oops")
+      end
+    end
+  end
+
+  context "with should_not" do
+    context "when assert_redirected_to fails" do
+      def assert_redirected_to(*)
+        raise ActiveSupport::TestCase::Assertion.new("this message")
+      end
+
+      it "passes" do
+        expect do
+          response.should_not redirect_to("destination")
+        end.to_not raise_exception
+      end
+    end
+
+    context "when assert_redirected_to passes" do
+      def assert_redirected_to(*); end
+
+      it "fails with custom failure message" do
+        expect do
+          response.should_not redirect_to("destination")
+        end.to raise_exception(/expected not to redirect to \"destination\", but did/)
+      end
+    end
+
+    context "when fails due to some other exception" do
+      def assert_redirected_to(*)
+        raise "oops"
+      end
+
+      it "raises that exception" do
+        expect do
+          response.should_not redirect_to("destination")
+        end.to raise_exception("oops")
+      end
+    end
+  end
+end

data/spec/rspec/rails/matchers/relation_match_array_spec.rb

@@ -0,0 +1,31 @@
+require "spec_helper"
+
+describe "ActiveSupport::Relation =~ matcher" do
+  before { MockableModel.delete_all }
+
+  let!(:models) { Array.new(3) { MockableModel.create } }
+
+  if ::Rails::VERSION::STRING >= '4'
+    it "verifies that the scope returns the records on the right hand side, regardless of order" do
+      MockableModel.all.should =~ models.reverse
+    end
+
+    it "fails if the scope encompasses more records than on the right hand side" do
+      MockableModel.create
+      MockableModel.all.should_not =~ models.reverse
+    end
+  else
+    it "verifies that the scope returns the records on the right hand side, regardless of order" do
+      MockableModel.scoped.should =~ models.reverse
+    end
+
+    it "fails if the scope encompasses more records than on the right hand side" do
+      MockableModel.create
+      MockableModel.scoped.should_not =~ models.reverse
+    end
+  end
+
+  it "fails if the scope encompasses fewer records than on the right hand side" do
+    MockableModel.limit(models.length - 1).should_not =~ models.reverse
+  end
+end

data/spec/rspec/rails/matchers/route_to_spec.rb

@@ -0,0 +1,151 @@
+require "spec_helper"
+
+describe "route_to" do
+  include RSpec::Rails::Matchers::RoutingMatchers
+  include RSpec::Rails::Matchers::RoutingMatchers::RouteHelpers
+
+  def assert_recognizes(*)
+    # no-op
+  end
+
+  it "provides a description" do
+    matcher = route_to("these" => "options")
+    matcher.matches?(:get => "path")
+    matcher.description.should == "route {:get=>\"path\"} to {\"these\"=>\"options\"}"
+  end
+
+  it "delegates to assert_recognizes" do
+    self.should_receive(:assert_recognizes).with({ "these" => "options" }, { :method=> :get, :path=>"path" }, {})
+    {:get => "path"}.should route_to("these" => "options")
+  end
+
+  context "with shortcut syntax" do
+    it "routes with extra options" do
+      self.should_receive(:assert_recognizes).with({ :controller => "controller", :action => "action", :extra => "options"}, { :method=> :get, :path=>"path" }, {})
+      get("path").should route_to("controller#action", :extra => "options")
+    end
+
+    it "routes without extra options" do
+      self.should_receive(:assert_recognizes).with(
+        {:controller => "controller", :action => "action"}, 
+        {:method=> :get, :path=>"path" },
+        {}
+      )
+      get("path").should route_to("controller#action")
+    end
+
+    it "routes with one query parameter" do
+      self.should_receive(:assert_recognizes).with(
+        {:controller => "controller", :action => "action", :queryitem => "queryvalue"},
+        {:method=> :get, :path=>"path" },
+        {'queryitem' => 'queryvalue' }
+      )
+      get("path?queryitem=queryvalue").should route_to("controller#action", :queryitem => 'queryvalue')
+    end
+
+    it "routes with multiple query parameters" do
+      self.should_receive(:assert_recognizes).with(
+        {:controller => "controller", :action => "action", :queryitem => "queryvalue", :qi2 => 'qv2'},
+        {:method=> :get, :path=>"path"},
+        {'queryitem' => 'queryvalue', 'qi2' => 'qv2'}
+      )
+      get("path?queryitem=queryvalue&qi2=qv2").should route_to("controller#action", :queryitem => 'queryvalue', :qi2 => 'qv2')
+    end
+
+  end
+
+  context "with should" do
+    context "when assert_recognizes passes" do
+      it "passes" do
+        expect do
+          {:get => "path"}.should route_to("these" => "options")
+        end.to_not raise_exception
+      end
+    end
+
+    context "when assert_recognizes fails with an assertion failure" do
+      it "fails with message from assert_recognizes" do
+        def assert_recognizes(*)
+          raise ActiveSupport::TestCase::Assertion.new("this message")
+        end
+        expect do
+          {:get => "path"}.should route_to("these" => "options")
+        end.to raise_error(RSpec::Expectations::ExpectationNotMetError, "this message")
+      end
+    end
+
+    context "when assert_recognizes fails with a routing error" do
+      it "fails with message from assert_recognizes" do
+        def assert_recognizes(*)
+          raise ActionController::RoutingError.new("this message")
+        end
+        expect do
+          {:get => "path"}.should route_to("these" => "options")
+        end.to raise_error(RSpec::Expectations::ExpectationNotMetError, "this message")
+      end
+    end
+
+    context "when an exception is raised" do
+      it "raises that exception" do
+        def assert_recognizes(*)
+          raise "oops"
+        end
+        expect do
+          {:get => "path"}.should route_to("these" => "options")
+        end.to raise_exception("oops")
+      end
+    end
+  end
+
+  context "with should_not" do
+    context "when assert_recognizes passes" do
+      it "fails with custom message" do
+        expect do
+          {:get => "path"}.should_not route_to("these" => "options")
+        end.to raise_error(/expected .* not to route to .*/)
+      end
+    end
+
+    context "when assert_recognizes fails with an assertion failure" do
+      it "passes" do
+        def assert_recognizes(*)
+          raise ActiveSupport::TestCase::Assertion.new("this message")
+        end
+        expect do
+          {:get => "path"}.should_not route_to("these" => "options")
+        end.to_not raise_error
+      end
+    end
+
+    context "when assert_recognizes fails with a routing error" do
+      it "passes" do
+        def assert_recognizes(*)
+          raise ActionController::RoutingError.new("this message")
+        end
+        expect do
+          {:get => "path"}.should_not route_to("these" => "options")
+        end.to_not raise_error
+      end
+    end
+
+    context "when an exception is raised" do
+      it "raises that exception" do
+        def assert_recognizes(*)
+          raise "oops"
+        end
+        expect do
+          {:get => "path"}.should_not route_to("these" => "options")
+        end.to raise_exception("oops")
+      end
+    end
+  end
+
+  it "uses failure message from assert_recognizes" do
+    def assert_recognizes(*)
+      raise ActiveSupport::TestCase::Assertion, "this message"
+    end
+    expect do
+      {"this" => "path"}.should route_to("these" => "options")
+    end.to raise_error("this message")
+  end
+end