rspec-rails 3.0.0.beta2 → 3.0.0.rc1

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
-    expect(model).to receive(:valid?)
-    model.errors_on(:foo)
-  end
-
-  it "returns the errors on that attribute" do
-    model = klass.new
-    allow(model).to receive(:errors) do
-      { :foo => ['a', 'b'] }
-    end
-    expect(model.errors_on(:foo)).to 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/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
-        allow(RSpec.configuration).to receive(:use_transactional_fixtures) { false }
-        group = RSpec::Core::ExampleGroup.describe do
-          include FixtureSupport
-        end
-
-        expect(group).to respond_to(:fixture_path)
-        expect(group).to 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
-        expect(record).to be_a_new(record.class)
-      end
-    end
-    context "wrong class" do
-      it "fails" do
-        expect(record).not_to 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
-        expect(record).not_to be_a_new(record.class)
-      end
-    end
-    context "wrong class" do
-      it "fails" do
-        expect(record).not_to 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
-          expect(record).to be_a_new(record.class).with(:foo => 'foo', :bar => 'bar')
-        end
-      end
-
-      context "one attribute same" do
-        it "passes" do
-          expect(record).to be_a_new(record.class).with(:foo => 'foo')
-        end
-      end
-
-      context "no attributes same" do
-        it "fails" do
-          expect {
-            expect(record).to be_a_new(record.class).with(:zoo => 'zoo', :car => 'car')
-          }.to raise_error {|e|
-            expect(e.message).to match(/attributes {.*} were not set on #{record.inspect}/)
-            expect(e.message).to match(/"zoo"=>"zoo"/)
-            expect(e.message).to match(/"car"=>"car"/)
-          }
-        end
-      end
-
-      context "one attribute value not the same" do
-        it "fails" do
-          expect {
-            expect(record).to 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 {
-            expect(record).to 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 {
-            expect(record).to be_a_new(String).with(:zoo => 'zoo', :car => 'car')
-          }.to raise_error {|e|
-            expect(e.message).to match(/expected #{record.inspect} to be a new String and attributes {.*} were not set on #{record.inspect}/)
-            expect(e.message).to match(/"zoo"=>"zoo"/)
-            expect(e.message).to match(/"car"=>"car"/)
-          }
-        end
-      end
-
-      context "one attribute value not the same" do
-        it "fails" do
-          expect {
-            expect(record).to 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
-      expect(record).to 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
-      expect(record).not_to 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
-      allow(routes).to receive(:recognize_path) { {} }
-      expect do
-        expect({:get => "/a/path"}).to be_routable
-      end.to_not raise_error
-    end
-
-    it "fails if routes do not recognize the path" do
-      allow(routes).to receive(:recognize_path) { raise ActionController::RoutingError.new('ignore') }
-      expect do
-        expect({:get => "/a/path"}).to 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
-      allow(routes).to receive(:recognize_path) { raise ActionController::RoutingError.new('ignore') }
-      expect do
-        expect({:get => "/a/path"}).not_to be_routable
-      end.to_not raise_error
-    end
-
-    it "fails if routes recognize the path" do
-      allow(routes).to receive(:recognize_path) { {:controller => "foo"} }
-      expect do
-        expect({:get => "/a/path"}).not_to 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,73 +0,0 @@
-require "spec_helper"
-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
-
-  class Book
-    def valid?
-      false
-    end
-
-    def errors
-      ['the spine is broken', 'the pages are dog-eared']
-    end
-  end
-
-  class Boat
-    def valid?
-      false
-    end
-  end
-
-  let(:post) { Post.new }
-  let(:book) { Book.new }
-  let(:boat) { Boat.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 the error messages for simple implementations of error messages" do
-    expect {
-      expect(book).to be_valid
-    }.to raise_exception(/the spine is broken/)
-  end
-
-  it "includes a brief error message for the simplest implementation of validity" do
-    expect {
-      expect(boat).to be_valid
-    }.to raise_exception(/expected .+ to be valid\z/)
-  end
-
-  it "includes a failure message for the negative case" do
-    allow(post).to receive(: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
-    expect(post).to receive(:valid?).with(:create) { true }
-    expect(post).to be_valid(:create)
-  end
-
-  it "does not include the validation context if not provided" do
-    expect(post).to receive(:valid?).with(no_args) { true }
-    expect(post).to be_valid
-  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
-    expect(owner.associated_items).to 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
-        expect(self).to 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
-        expect(self).to 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
-        expect(self).to 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