rspec-rails 2.13.1 → 2.13.2

data/spec/rspec/rails/extensions/active_model/errors_on_spec.rb

@@ -1,23 +0,0 @@
-require "spec_helper"
-
-describe "errors_on" do
-  let(:klass) do
-    Class.new do
-      include ActiveModel::Validations
-    end
-  end
-
-  it "calls valid?" do
-    model = klass.new
-    model.should_receive(:valid?)
-    model.errors_on(:foo)
-  end
-
-  it "returns the errors on that attribute" do
-    model = klass.new
-    model.stub(:errors) do
-      { :foo => ['a', 'b'] }
-    end
-    model.errors_on(:foo).should eq(['a','b'])
-  end
-end

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

@@ -1,42 +0,0 @@
-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/extensions/active_record/records_spec.rb

@@ -1,9 +0,0 @@
-require 'spec_helper'
-
-describe "records" do
-  it "delegates to find(:all)" do
-    klass = Class.new(ActiveRecord::Base)
-    klass.should_receive(:find).with(:all)
-    klass.records
-  end
-end

data/spec/rspec/rails/fixture_support_spec.rb

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

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

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

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

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

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

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

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