rspec-rails 3.0.0.beta2 → 3.0.0.rc1

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

@@ -1,81 +0,0 @@
-require "spec_helper"
-require "active_support"
-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
-          expect(response).to 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
-          expect(response).to 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
-          expect(response).to 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
-          expect(response).not_to 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
-          expect(response).not_to 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
-          expect(response).not_to redirect_to("destination")
-        end.to raise_exception("oops")
-      end
-    end
-  end
-end

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

@@ -1,31 +0,0 @@
-require "spec_helper"
-
-describe "ActiveSupport::Relation match_array 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
-      expect(MockableModel.all).to match_array(models.reverse)
-    end
-
-    it "fails if the scope encompasses more records than on the right hand side" do
-      MockableModel.create
-      expect(MockableModel.all).not_to match_array(models.reverse)
-    end
-  else
-    it "verifies that the scope returns the records on the right hand side, regardless of order" do
-      expect(MockableModel.scoped).to match_array(models.reverse)
-    end
-
-    it "fails if the scope encompasses more records than on the right hand side" do
-      MockableModel.create
-      expect(MockableModel.scoped).not_to match_array(models.reverse)
-    end
-  end
-
-  it "fails if the scope encompasses fewer records than on the right hand side" do
-    expect(MockableModel.limit(models.length - 1)).not_to match_array(models.reverse)
-  end
-end

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

@@ -1,151 +0,0 @@
-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")
-    expect(matcher.description).to eq("route {:get=>\"path\"} to {\"these\"=>\"options\"}")
-  end
-
-  it "delegates to assert_recognizes" do
-    expect(self).to receive(:assert_recognizes).with({ "these" => "options" }, { :method=> :get, :path=>"path" }, {})
-    expect({:get => "path"}).to route_to("these" => "options")
-  end
-
-  context "with shortcut syntax" do
-    it "routes with extra options" do
-      expect(self).to receive(:assert_recognizes).with({ :controller => "controller", :action => "action", :extra => "options"}, { :method=> :get, :path=>"path" }, {})
-      expect(get("path")).to route_to("controller#action", :extra => "options")
-    end
-
-    it "routes without extra options" do
-      expect(self).to receive(:assert_recognizes).with(
-        {:controller => "controller", :action => "action"}, 
-        {:method=> :get, :path=>"path" },
-        {}
-      )
-      expect(get("path")).to route_to("controller#action")
-    end
-
-    it "routes with one query parameter" do
-      expect(self).to receive(:assert_recognizes).with(
-        {:controller => "controller", :action => "action", :queryitem => "queryvalue"},
-        {:method=> :get, :path=>"path" },
-        {'queryitem' => 'queryvalue' }
-      )
-      expect(get("path?queryitem=queryvalue")).to route_to("controller#action", :queryitem => 'queryvalue')
-    end
-
-    it "routes with multiple query parameters" do
-      expect(self).to receive(:assert_recognizes).with(
-        {:controller => "controller", :action => "action", :queryitem => "queryvalue", :qi2 => 'qv2'},
-        {:method=> :get, :path=>"path"},
-        {'queryitem' => 'queryvalue', 'qi2' => 'qv2'}
-      )
-      expect(get("path?queryitem=queryvalue&qi2=qv2")).to 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
-          expect({:get => "path"}).to 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
-          expect({:get => "path"}).to 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
-          expect({:get => "path"}).to 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
-          expect({:get => "path"}).to 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
-          expect({:get => "path"}).not_to route_to("these" => "options")
-        end.to raise_error(/expected {:get=>"path"} not to route to {"these"=>"options"}/)
-      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
-          expect({:get => "path"}).not_to 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
-          expect({:get => "path"}).not_to 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
-          expect({:get => "path"}).not_to 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
-      expect({"this" => "path"}).to route_to("these" => "options")
-    end.to raise_error("this message")
-  end
-end

data/spec/rspec/rails/minitest_lifecycle_adapter_spec.rb

@@ -1,31 +0,0 @@
-require "spec_helper"
-
-describe RSpec::Rails::MinitestLifecycleAdapter do
-  it "invokes minitest lifecycle hooks at the appropriate times" do
-    invocations = []
-    example_group = RSpec::Core::ExampleGroup.describe("MinitestHooks") do
-      include RSpec::Rails::MinitestLifecycleAdapter
-
-      define_method(:before_setup)    { invocations << :before_setup }
-      define_method(:after_setup)     { invocations << :after_setup }
-      define_method(:before_teardown) { invocations << :before_teardown }
-      define_method(:after_teardown)  { invocations << :after_teardown }
-    end
-
-    example = example_group.example("foo") { invocations << :example }
-    example_group.run(NullObject.new)
-
-    expect(invocations).to eq([
-      :before_setup, :after_setup, :example, :before_teardown, :after_teardown
-    ])
-  end
-
-  it "allows let variables named 'send'" do
-    run_result = ::RSpec::Core::ExampleGroup.describe do
-      let(:send) { "WHAT" }
-      specify { expect(send).to eq "WHAT" }
-    end.run NullObject.new
-
-    expect(run_result).to be true
-  end
-end

data/spec/rspec/rails/mocks/mock_model_spec.rb

@@ -1,400 +0,0 @@
-require 'spec_helper'
-
-describe "mock_model(RealModel)" do
-  context "given a String" do
-    context "that does not represent an existing constant" do
-      it "class says it's name" do
-        model = mock_model("Foo")
-        expect(model.class.name).to eq("Foo")
-      end
-    end
-
-    context "that represents an existing constant" do
-      context "that extends ActiveModel::Naming" do
-        it "treats the constant as the class" do
-          model = mock_model("MockableModel")
-          expect(model.class.name).to eq("MockableModel")
-        end
-      end
-
-      context "that does not extend ActiveModel::Naming" do
-        it "raises with a helpful message" do
-          expect do
-            mock_model("String")
-          end.to raise_error(ArgumentError)
-        end
-      end
-    end
-  end
-
-  context "given a class that does not extend ActiveModel::Naming" do
-    it "raises with a helpful message" do
-      expect do
-        mock_model(String)
-      end.to raise_error(ArgumentError)
-    end
-  end
-
-  describe "with #id stubbed" do
-    before(:each) do
-      @model = mock_model(MockableModel, :id => 1)
-    end
-
-    it "is named using the stubbed id value" do
-      expect(@model.instance_variable_get(:@name)).to eq("MockableModel_1")
-    end
-  end
-
-  describe "destroy" do
-    it "sets persisted to false" do
-      model = mock_model(MockableModel)
-      model.destroy
-      expect(model).not_to be_persisted
-    end
-  end
-
-  describe "association" do
-    it "constructs a mock association object" do
-      model = mock_model(MockableModel)
-      expect(model.association(:association_name)).to be
-    end
-
-    it "returns a different association object for each association name" do
-      model = mock_model(MockableModel)
-      posts = model.association(:posts)
-      authors = model.association(:authors)
-
-      expect(posts).not_to equal(authors)
-    end
-
-    it "returns the same association model each time for the same association name" do
-      model = mock_model(MockableModel)
-      posts1 = model.association(:posts)
-      posts2 = model.association(:posts)
-
-      expect(posts1).to equal(posts2)
-    end
-  end
-
-  describe "errors" do
-    context "default" do
-      it "is empty" do
-        model = mock_model(MockableModel)
-        expect(model.errors).to be_empty
-      end
-    end
-
-    context "with :save => false" do
-      it "is not empty" do
-        model = mock_model(MockableModel, :save => false)
-        expect(model.errors).not_to be_empty
-      end
-    end
-
-    context "with :update_attributes => false" do
-      it "is not empty" do
-        model = mock_model(MockableModel, :save => false)
-        expect(model.errors).not_to be_empty
-      end
-    end
-  end
-
-  describe "with params" do
-    it "does not mutate its parameters" do
-      params = {:a => 'b'}
-      mock_model(MockableModel, params)
-      expect(params).to eq({:a => 'b'})
-    end
-  end
-
-  describe "as association" do
-    before(:each) do
-      @real = AssociatedModel.create!
-      @mock_model = mock_model(MockableModel)
-      @real.mockable_model = @mock_model
-    end
-
-    it "passes: associated_model == mock" do
-      expect(@mock_model).to eq(@real.mockable_model)
-    end
-
-    it "passes: mock == associated_model" do
-      expect(@real.mockable_model).to eq(@mock_model)
-    end
-  end
-
-  describe "as association that doesn't exist yet" do
-    before(:each) do
-      @real = AssociatedModel.create!
-      @mock_model = mock_model("Other")
-      @real.nonexistent_model = @mock_model
-    end
-
-    it "passes: associated_model == mock" do
-      expect(@mock_model).to eq(@real.nonexistent_model)
-    end
-
-    it "passes: mock == associated_model" do
-      expect(@real.nonexistent_model).to eq(@mock_model)
-    end
-  end
-
-  describe "#is_a?" do
-    before(:each) do
-      @model = mock_model(SubMockableModel)
-    end
-
-    it "says it is_a?(RealModel)" do
-      expect(@model.is_a?(SubMockableModel)).to be(true)
-    end
-
-    it "says it is_a?(OtherModel) if RealModel is an ancestors" do
-      expect(@model.is_a?(MockableModel)).to be(true)
-    end
-
-    it "can be stubbed" do
-      expect(mock_model(MockableModel, :is_a? => true).is_a?(:Foo)).to be_truthy
-    end
-  end
-
-  describe "#kind_of?" do
-    before(:each) do
-      @model = mock_model(SubMockableModel)
-    end
-
-    it "says it is kind_of? if RealModel is" do
-      expect(@model.kind_of?(SubMockableModel)).to be(true)
-    end
-
-    it "says it is kind_of? if RealModel's ancestor is" do
-      expect(@model.kind_of?(MockableModel)).to be(true)
-    end
-
-    it "can be stubbed" do
-      expect(mock_model(MockableModel, :kind_of? => true).kind_of?(:Foo)).to be_truthy
-    end
-  end
-
-  describe "#instance_of?" do
-    before(:each) do
-      @model = mock_model(SubMockableModel)
-    end
-
-    it "says it is instance_of? if RealModel is" do
-      expect(@model.instance_of?(SubMockableModel)).to be(true)
-    end
-
-    it "does not say it instance_of? if RealModel isn't, even if it's ancestor is" do
-      expect(@model.instance_of?(MockableModel)).to be(false)
-    end
-
-    it "can be stubbed" do
-      expect(mock_model(MockableModel, :instance_of? => true).instance_of?(:Foo)).to be_truthy
-    end
-  end
-
-  describe "#respond_to?" do
-    context "with an ActiveRecord model" do
-      before(:each) do
-        allow(MockableModel).to receive(:column_names).and_return(["column_a", "column_b"])
-        @model = mock_model(MockableModel)
-      end
-
-      it "accepts two arguments" do
-        expect do
-          @model.respond_to?("title_before_type_cast", false)
-        end.to_not raise_exception
-      end
-
-      context "without as_null_object" do
-        it "says it will respond_to?(key) if RealModel has the attribute 'key'" do
-          expect(@model.respond_to?("column_a")).to be(true)
-        end
-        it "stubs column accessor (with string)" do
-          @model.respond_to?("column_a")
-          expect(@model.column_a).to be_nil
-        end
-        it "stubs column accessor (with symbol)" do
-          @model.respond_to?(:column_a)
-          expect(@model.column_a).to be_nil
-        end
-        it "does not stub column accessor if already stubbed in declaration (with string)" do
-          model = mock_model(MockableModel, "column_a" => "a")
-          model.respond_to?("column_a")
-          expect(model.column_a).to eq("a")
-        end
-        it "does not stub column accessor if already stubbed in declaration (with symbol)" do
-          model = mock_model(MockableModel, :column_a => "a")
-          model.respond_to?("column_a")
-          expect(model.column_a).to eq("a")
-        end
-        it "does not stub column accessor if already stubbed after declaration (with string)" do
-          allow(@model).to receive_messages("column_a" => "a")
-          @model.respond_to?("column_a")
-          expect(@model.column_a).to eq("a")
-        end
-        it "does not stub column accessor if already stubbed after declaration (with symbol)" do
-          allow(@model).to receive_messages(:column_a => "a")
-          @model.respond_to?("column_a")
-          expect(@model.column_a).to eq("a")
-        end
-        it "says it will not respond_to?(key) if RealModel does not have the attribute 'key'" do
-          expect(@model.respond_to?("column_c")).to be(false)
-        end
-        it "says it will not respond_to?(xxx_before_type_cast)" do
-          expect(@model.respond_to?("title_before_type_cast")).to be(false)
-        end
-      end
-
-      context "with as_null_object" do
-        it "says it will respond_to?(key) if RealModel has the attribute 'key'" do
-          expect(@model.as_null_object.respond_to?("column_a")).to be(true)
-        end
-        it "says it will respond_to?(key) even if RealModel does not have the attribute 'key'" do
-          expect(@model.as_null_object.respond_to?("column_c")).to be(true)
-        end
-        it "says it will not respond_to?(xxx_before_type_cast)" do
-          expect(@model.as_null_object.respond_to?("title_before_type_cast")).to be(false)
-        end
-        it "returns self for any unprepared message" do
-          @model.as_null_object.tap do |x|
-            expect(x.non_existant_message).to be(@model)
-          end
-        end
-      end
-    end
-
-    context "with a non-ActiveRecord model" do
-      it "responds as normal" do
-        model = NonActiveRecordModel.new
-        expect(model).to respond_to(:to_param)
-      end
-
-      context "with as_null_object" do
-        it "says it will not respond_to?(xxx_before_type_cast)" do
-          model = NonActiveRecordModel.new.as_null_object
-          expect(model.respond_to?("title_before_type_cast")).to be(false)
-        end
-      end
-    end
-
-    it "can be stubbed" do
-      expect(mock_model(MockableModel, :respond_to? => true).respond_to?(:foo)).to be_truthy
-    end
-  end
-
-  describe "#class" do
-    it "returns the mocked model" do
-      expect(mock_model(MockableModel).class).to eq(MockableModel)
-    end
-
-    it "can be stubbed" do
-      expect(mock_model(MockableModel, :class => String).class).to be(String)
-    end
-  end
-
-  describe "#to_s" do
-    it "returns (model.name)_(model#to_param)" do
-      expect(mock_model(MockableModel).to_s).to eq("MockableModel_#{to_param}")
-    end
-
-    it "can be stubbed" do
-      expect(mock_model(MockableModel, :to_s => "this string").to_s).to eq("this string")
-    end
-  end
-
-  describe "#destroyed?" do
-    context "default" do
-      it "returns false" do
-        @model = mock_model(SubMockableModel)
-        expect(@model.destroyed?).to be(false)
-      end
-    end
-  end
-
-  describe "#marked_for_destruction?" do
-    context "default" do
-      it "returns false" do
-        @model = mock_model(SubMockableModel)
-        expect(@model.marked_for_destruction?).to be(false)
-      end
-    end
-  end
-
-  describe "#persisted?" do
-    context "with default identifier" do
-      it "returns true" do
-        expect(mock_model(MockableModel)).to be_persisted
-      end
-    end
-
-    context "with explicit identifier via :id" do
-      it "returns true" do
-        expect(mock_model(MockableModel, :id => 37)).to be_persisted
-      end
-    end
-
-    context "with id => nil" do
-      it "returns false" do
-        expect(mock_model(MockableModel, :id => nil)).not_to be_persisted
-      end
-    end
-  end
-
-  describe "#valid?" do
-    context "default" do
-      it "returns true" do
-        expect(mock_model(MockableModel)).to be_valid
-      end
-    end
-
-    context "stubbed with false" do
-      it "returns false" do
-        expect(mock_model(MockableModel, :valid? => false)).not_to be_valid
-      end
-    end
-  end
-
-  describe "#as_new_record" do
-    it "says it is a new record" do
-      m = mock_model(MockableModel)
-      expect(m.as_new_record).to be_new_record
-    end
-
-    it "says it is not persisted" do
-      m = mock_model(MockableModel)
-      expect(m.as_new_record).not_to be_persisted
-    end
-
-    it "has a nil id" do
-      expect(mock_model(MockableModel).as_new_record.id).to be(nil)
-    end
-
-    it "returns nil for #to_param" do
-      expect(mock_model(MockableModel).as_new_record.to_param).to be(nil)
-    end
-  end
-
-  describe "#blank?" do
-    it "is false" do
-      expect(mock_model(MockableModel)).not_to be_blank
-    end
-  end
-
-  describe "ActiveModel Lint tests" do
-    require 'active_model/lint'
-    include RSpec::Rails::MinitestAssertionAdapter
-    include ActiveModel::Lint::Tests
-
-    # to_s is to support ruby-1.9
-    ActiveModel::Lint::Tests.public_instance_methods.map{|m| m.to_s}.grep(/^test/).each do |m|
-      example m.gsub('_',' ') do
-        send m
-      end
-    end
-
-    def model
-      mock_model(MockableModel, :id => nil)
-    end
-  end
-end