rspec-rails 2.14.2 → 2.99.0.beta1

data/spec/rspec/rails/extensions/active_record/base_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe ::ActiveModel::Validations do
+  describe "#errors_on" do
+    context "ActiveModel class that takes no arguments to valid?" do
+      let(:klass) {
+        Class.new do
+          include ActiveModel::Validations
+
+          def self.name
+            "ActiveModelValidationsFake"
+          end
+
+          def valid?
+            super
+          end
+
+          attr_accessor :name
+          validates_presence_of :name
+        end
+      }
+
+      context "with nil name" do
+        it "has one error" do
+          object = klass.new
+          object.name = ""
+
+          expect(object).to have(1).error_on(:name)
+        end
+      end
+
+      context "with non-blank name" do
+        it "has no error" do
+          object = klass.new
+          object.name = "Ywen"
+
+          expect(object).to have(:no).error_on(:name)
+        end
+      end
+    end
+  end
+end

data/spec/rspec/rails/fixture_support_spec.rb

@@ -0,0 +1,17 @@
+require "spec_helper"
+
+module RSpec::Rails
+  describe FixtureSupport do
+    context "with use_transactional_fixtures set to false" do
+      it "still supports fixture_path" do
+        RSpec.configuration.stub(:use_transactional_fixtures) { false }
+        group = RSpec::Core::ExampleGroup.describe do
+          include FixtureSupport
+        end
+
+        group.should respond_to(:fixture_path)
+        group.should respond_to(:fixture_path=)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,142 @@
+require "spec_helper"
+
+describe "be_a_new matcher" do
+  include RSpec::Rails::Matchers
+
+  context "new record" do
+    let(:record) do
+      Class.new do
+        def new_record?; true; end
+      end.new
+    end
+    context "right class" do
+      it "passes" do
+        record.should be_a_new(record.class)
+      end
+    end
+    context "wrong class" do
+      it "fails" do
+        record.should_not be_a_new(String)
+      end
+    end
+  end
+
+  context "existing record" do
+    let(:record) do
+      Class.new do
+        def new_record?; false; end
+      end.new
+    end
+    context "right class" do
+      it "fails" do
+        record.should_not be_a_new(record.class)
+      end
+    end
+    context "wrong class" do
+      it "fails" do
+        record.should_not be_a_new(String)
+      end
+    end
+  end
+
+  describe "#with" do
+    context "right class and new record" do
+      let(:record) do
+        Class.new do
+          def initialize(attributes)
+            @attributes = attributes
+          end
+
+          def attributes
+            @attributes.stringify_keys
+          end
+
+          def new_record?; true; end
+        end.new(:foo => 'foo', :bar => 'bar')
+      end
+
+      context "all attributes same" do
+        it "passes" do
+          record.should be_a_new(record.class).with(:foo => 'foo', :bar => 'bar')
+        end
+      end
+
+      context "one attribute same" do
+        it "passes" do
+          record.should be_a_new(record.class).with(:foo => 'foo')
+        end
+      end
+
+      context "no attributes same" do
+        it "fails" do
+          expect {
+            record.should be_a_new(record.class).with(:zoo => 'zoo', :car => 'car')
+          }.to raise_error {|e|
+            e.message.should match(/attributes {.*} were not set on #{record.inspect}/)
+            e.message.should match(/"zoo"=>"zoo"/)
+            e.message.should match(/"car"=>"car"/)
+          }
+        end
+      end
+
+      context "one attribute value not the same" do
+        it "fails" do
+          expect {
+            record.should be_a_new(record.class).with(:foo => 'bar')
+          }.to raise_error(
+            %Q(attribute {"foo"=>"bar"} was not set on #{record.inspect})
+          )
+        end
+      end
+    end
+
+    context "wrong class and existing record" do
+      let(:record) do
+        Class.new do
+          def initialize(attributes)
+            @attributes = attributes
+          end
+
+          def attributes
+            @attributes.stringify_keys
+          end
+
+          def new_record?; false; end
+        end.new(:foo => 'foo', :bar => 'bar')
+      end
+
+      context "all attributes same" do
+        it "fails" do
+          expect {
+            record.should be_a_new(String).with(:foo => 'foo', :bar => 'bar')
+          }.to raise_error(
+            "expected #{record.inspect} to be a new String"
+          )
+        end
+      end
+
+      context "no attributes same" do
+        it "fails" do
+          expect {
+            record.should be_a_new(String).with(:zoo => 'zoo', :car => 'car')
+          }.to raise_error {|e|
+            e.message.should match(/expected #{record.inspect} to be a new String and attributes {.*} were not set on #{record.inspect}/)
+            e.message.should match(/"zoo"=>"zoo"/)
+            e.message.should match(/"car"=>"car"/)
+          }
+        end
+      end
+
+      context "one attribute value not the same" do
+        it "fails" do
+          expect {
+            record.should be_a_new(String).with(:foo => 'bar')
+          }.to raise_error(
+            "expected #{record.inspect} to be a new String and " +
+            %Q(attribute {"foo"=>"bar"} was not set on #{record.inspect})
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+require "spec_helper"
+
+describe "be_new_record" do
+  include RSpec::Rails::Matchers
+
+  context "un-persisted record" do
+    let(:record) { double('record', :persisted? => false) }
+
+    it "passes" do
+      record.should be_new_record
+    end
+
+    it "fails with custom failure message" do
+      expect {
+        expect(record).not_to be_new_record
+      }.to raise_exception(/expected .* to be persisted, but was a new record/)
+    end
+  end
+
+  context "persisted record" do
+    let(:record) { double('record', :persisted? => true) }
+
+    it "fails" do
+      record.should_not be_new_record
+    end
+
+    it "fails with custom failure message" do
+      expect {
+        expect(record).to be_new_record
+      }.to raise_exception(/expected .* to be a new record, but was persisted/)
+    end
+  end
+end

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