shoulda-matchers 2.7.0 → 2.8.0.rc1

data/spec/{shoulda → unit/shoulda}/matchers/active_record/association_matchers/model_reflection_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require 'unit_spec_helper'
 
 describe Shoulda::Matchers::ActiveRecord::AssociationMatchers::ModelReflection do
   it 'delegates other methods to the given Reflection object' do
@@ -7,7 +7,7 @@ describe Shoulda::Matchers::ActiveRecord::AssociationMatchers::ModelReflection d
       belongs_to :country
     end
     delegate_reflection = person_model.reflect_on_association(:country)
-    delegate_reflection.stubs(foo: 'bar')
+    allow(delegate_reflection).to receive(:foo).and_return('bar')
     reflection = described_class.new(delegate_reflection)
 
     expect(reflection.foo).to eq 'bar'

data/spec/{shoulda → unit/shoulda}/matchers/active_record/define_enum_for_matcher_spec.rb

@@ -1,6 +1,6 @@
-require "spec_helper"
+require "unit_spec_helper"
 
-describe Shoulda::Matchers::ActiveRecord::DefineEnumForMatcher do
+describe Shoulda::Matchers::ActiveRecord::DefineEnumForMatcher, type: :model do
   if active_record_supports_enum?
     describe "with only the attribute name specified" do
       it "accepts a record where the attribute is defined as an enum" do

data/spec/{shoulda → unit/shoulda}/matchers/active_record/have_db_column_matcher_spec.rb

@@ -1,6 +1,6 @@
-require 'spec_helper'
+require 'unit_spec_helper'
 
-describe Shoulda::Matchers::ActiveRecord::HaveDbColumnMatcher do
+describe Shoulda::Matchers::ActiveRecord::HaveDbColumnMatcher, type: :model do
   it 'accepts an existing database column' do
     expect(model(nickname: :string)).to have_db_column(:nickname)
   end

data/spec/{shoulda → unit/shoulda}/matchers/active_record/have_db_index_matcher_spec.rb

@@ -1,6 +1,6 @@
-require 'spec_helper'
+require 'unit_spec_helper'
 
-describe Shoulda::Matchers::ActiveRecord::HaveDbIndexMatcher do
+describe Shoulda::Matchers::ActiveRecord::HaveDbIndexMatcher, type: :model do
   context 'have_db_index' do
     it 'accepts an existing index' do
       expect(with_index_on(:age)).to have_db_index(:age)
@@ -65,10 +65,13 @@ describe Shoulda::Matchers::ActiveRecord::HaveDbIndexMatcher do
   end
 
   it 'allows an IndexDefinition to have a truthy value for unique' do
-    index_definition = stub('ActiveRecord::ConnectionAdapters::IndexDefinition',
-      unique: 7, name: :age)
+    index_definition = double(
+      'ActiveRecord::ConnectionAdapters::IndexDefinition',
+      unique: 7,
+      name: :age
+    )
     matcher = have_db_index(:age).unique(true)
-    matcher.stubs(matched_index: index_definition)
+    allow(matcher).to receive(:matched_index).and_return(index_definition)
 
     expect(with_index_on(:age)).to matcher
   end

data/spec/{shoulda → unit/shoulda}/matchers/active_record/have_readonly_attributes_matcher_spec.rb

@@ -1,6 +1,6 @@
-require 'spec_helper'
+require 'unit_spec_helper'
 
-describe Shoulda::Matchers::ActiveRecord::HaveReadonlyAttributeMatcher do
+describe Shoulda::Matchers::ActiveRecord::HaveReadonlyAttributeMatcher, type: :model do
   context 'a read-only attribute' do
     it 'accepts' do
       expect(with_readonly_attr).to have_readonly_attribute(:attr)

data/spec/{shoulda → unit/shoulda}/matchers/active_record/serialize_matcher_spec.rb

@@ -1,6 +1,6 @@
-require 'spec_helper'
+require 'unit_spec_helper'
 
-describe Shoulda::Matchers::ActiveRecord::SerializeMatcher do
+describe Shoulda::Matchers::ActiveRecord::SerializeMatcher, type: :model do
   it 'accepts when the attribute is serialized' do
     expect(with_serialized_attr).to serialize(:attr)
   end
@@ -39,7 +39,7 @@ describe Shoulda::Matchers::ActiveRecord::SerializeMatcher do
     end
   end
 
-  context 'an attribute that is serialized as a specific type' do
+  context 'an attribute that will end up being serialized as YAML' do
     it 'accepts when the types match' do
       expect(with_serialized_attr(Hash)).to serialize(:attr).as(Hash)
     end

data/spec/{shoulda → unit/shoulda}/matchers/doublespeak/double_collection_spec.rb

@@ -1,34 +1,56 @@
-require 'spec_helper'
+require 'unit_spec_helper'
 
 module Shoulda::Matchers::Doublespeak
   describe DoubleCollection do
     describe '#register_stub' do
       it 'calls DoubleImplementationRegistry.find correctly' do
+        allow(DoubleImplementationRegistry).to receive(:find)
         double_collection = described_class.new(:klass)
-        DoubleImplementationRegistry.expects(:find).with(:stub)
+
         double_collection.register_stub(:a_method)
+
+        expect(DoubleImplementationRegistry).to have_received(:find).with(:stub)
       end
 
       it 'calls Double.new correctly' do
-        DoubleImplementationRegistry.stubs(:find).returns(:implementation)
+        allow(DoubleImplementationRegistry).
+          to receive(:find).
+          and_return(:implementation)
+        allow(Double).to receive(:new)
         double_collection = described_class.new(:klass)
-        Double.expects(:new).with(:klass, :a_method, :implementation)
+
         double_collection.register_stub(:a_method)
+
+        expect(Double).
+          to have_received(:new).
+          with(:klass, :a_method, :implementation)
       end
     end
 
     describe '#register_proxy' do
       it 'calls DoubleImplementationRegistry.find correctly' do
+        allow(DoubleImplementationRegistry).to receive(:find)
         double_collection = described_class.new(:klass)
-        DoubleImplementationRegistry.expects(:find).with(:proxy)
+
         double_collection.register_proxy(:a_method)
+
+        expect(DoubleImplementationRegistry).
+          to have_received(:find).
+          with(:proxy)
       end
 
       it 'calls Double.new correctly' do
-        DoubleImplementationRegistry.stubs(:find).returns(:implementation)
+        allow(DoubleImplementationRegistry).
+          to receive(:find).
+          and_return(:implementation)
+        allow(Double).to receive(:new)
         double_collection = described_class.new(:klass)
-        Double.expects(:new).with(:klass, :a_method, :implementation)
+
         double_collection.register_proxy(:a_method)
+
+        expect(Double).
+          to have_received(:new).
+          with(:klass, :a_method, :implementation)
       end
     end
 

data/spec/{shoulda → unit/shoulda}/matchers/doublespeak/double_implementation_registry_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require 'unit_spec_helper'
 
 module Shoulda::Matchers::Doublespeak
   describe DoubleImplementationRegistry do

data/spec/{shoulda → unit/shoulda}/matchers/doublespeak/double_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require 'unit_spec_helper'
 
 module Shoulda::Matchers::Doublespeak
   describe Double do
@@ -6,7 +6,8 @@ module Shoulda::Matchers::Doublespeak
       it 'tells its implementation to call the given block' do
         sent_block = -> { }
         actual_block = nil
-        implementation = stub
+        implementation = build_implementation
+        implementation.singleton_class.__send__(:undef_method, :returns)
         implementation.singleton_class.__send__(:define_method, :returns) do |&block|
           actual_block = block
         end
@@ -16,16 +17,18 @@ module Shoulda::Matchers::Doublespeak
       end
 
       it 'tells its implementation to return the given value' do
-        implementation = mock()
-        implementation.expects(:returns).with(:implementation)
+        implementation = build_implementation
         double = described_class.new(:klass, :a_method, implementation)
         double.to_return(:implementation)
+
+        expect(implementation).to have_received(:returns).with(:implementation)
       end
 
       it 'prefers a block over a non-block' do
         sent_block = -> { }
         actual_block = nil
-        implementation = stub
+        implementation = build_implementation
+        implementation.singleton_class.__send__(:undef_method, :returns)
         implementation.singleton_class.__send__(:define_method, :returns) do |&block|
           actual_block = block
         end
@@ -37,22 +40,25 @@ module Shoulda::Matchers::Doublespeak
 
     describe '#activate' do
       it 'replaces the method with an implementation' do
-        implementation = stub
+        implementation = build_implementation
         klass = create_class(a_method: 42)
         instance = klass.new
         double = described_class.new(klass, :a_method, implementation)
         args = [:any, :args]
         block = -> {}
-        implementation.expects(:call).with(double, instance, args, block)
 
         double.activate
         instance.a_method(*args, &block)
+
+        expect(implementation).
+          to have_received(:call).
+          with(double, instance, args, block)
       end
     end
 
     describe '#deactivate' do
       it 'restores the original method after being doubled' do
-        implementation = stub(call: nil)
+        implementation = build_implementation
         klass = create_class(a_method: 42)
         instance = klass.new
         double = described_class.new(klass, :a_method, implementation)
@@ -63,7 +69,7 @@ module Shoulda::Matchers::Doublespeak
       end
 
       it 'still restores the original method if #activate was called twice' do
-        implementation = stub(call: nil)
+        implementation = build_implementation
         klass = create_class(a_method: 42)
         instance = klass.new
         double = described_class.new(klass, :a_method, implementation)
@@ -75,7 +81,7 @@ module Shoulda::Matchers::Doublespeak
       end
 
       it 'does nothing if the method has not been doubled' do
-        implementation = stub(call: nil)
+        implementation = build_implementation
         klass = create_class(a_method: 42)
         instance = klass.new
         double = described_class.new(klass, :a_method, implementation)
@@ -140,5 +146,9 @@ module Shoulda::Matchers::Doublespeak
         end
       end
     end
+
+    def build_implementation
+      double('implementation', returns: nil, call: nil)
+    end
   end
 end

data/spec/{shoulda → unit/shoulda}/matchers/doublespeak/object_double_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require 'unit_spec_helper'
 
 module Shoulda::Matchers::Doublespeak
   describe ObjectDouble do

data/spec/{shoulda → unit/shoulda}/matchers/doublespeak/proxy_implementation_spec.rb

@@ -1,13 +1,14 @@
-require 'spec_helper'
+require 'unit_spec_helper'
 
 module Shoulda::Matchers::Doublespeak
   describe ProxyImplementation do
     describe '#returns' do
       it 'delegates to its stub_implementation' do
         stub_implementation = build_stub_implementation
-        stub_implementation.expects(:returns).with(:value)
         implementation = described_class.new(stub_implementation)
         implementation.returns(:value)
+
+        expect(stub_implementation).to have_received(:returns).with(:value)
       end
     end
 
@@ -15,26 +16,32 @@ module Shoulda::Matchers::Doublespeak
       it 'delegates to its stub_implementation' do
         stub_implementation = build_stub_implementation
         double = build_double
-        stub_implementation.expects(:call).with(double, :object, :args, :block)
         implementation = described_class.new(stub_implementation)
         implementation.call(double, :object, :args, :block)
+
+        expect(stub_implementation).
+          to have_received(:call).
+          with(double, :object, :args, :block)
       end
 
       it 'calls #call_original_method on the double' do
         stub_implementation = build_stub_implementation
         implementation = described_class.new(stub_implementation)
         double = build_double
-        double.expects(:call_original_method).with(:object, :args, :block)
         implementation.call(double, :object, :args, :block)
+
+        expect(double).
+          to have_received(:call_original_method).
+          with(:object, :args, :block)
       end
     end
 
     def build_stub_implementation
-      stub(returns: nil, call: nil)
+      double('stub_implementation', returns: nil, call: nil)
     end
 
     def build_double
-      stub(call_original_method: nil)
+      double('double', call_original_method: nil)
     end
   end
 end

data/spec/{shoulda → unit/shoulda}/matchers/doublespeak/stub_implementation_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require 'unit_spec_helper'
 
 module Shoulda::Matchers::Doublespeak
   describe StubImplementation do
@@ -82,7 +82,7 @@ module Shoulda::Matchers::Doublespeak
     end
 
     def build_double
-      stub(record_call: nil)
+      double('double', record_call: nil)
     end
   end
 end

data/spec/unit/shoulda/matchers/doublespeak/world_spec.rb

@@ -0,0 +1,77 @@
+require 'unit_spec_helper'
+
+module Shoulda::Matchers::Doublespeak
+  describe World do
+    describe '#double_collection_for' do
+      it 'calls DoubleCollection.new once with the given class' do
+        allow(DoubleCollection).to receive(:new).and_return(:klass)
+        world = described_class.new
+
+        world.double_collection_for(:klass)
+        world.double_collection_for(:klass)
+
+        expect(DoubleCollection).to have_received(:new).with(:klass).once
+      end
+
+      it 'returns the created DoubleCollection' do
+        double_collection = build_double_collection
+        allow(DoubleCollection).
+          to receive(:new).
+          with(:klass).
+          and_return(double_collection)
+        world = described_class.new
+
+        expect(world.double_collection_for(:klass)).to be double_collection
+      end
+    end
+
+    describe '#with_doubles_activated' do
+      it 'installs all doubles, yields the block, then uninstalls them all' do
+        block_called = false
+        double_collections = Array.new(3) { build_double_collection }
+        double_collections.each do |double_collection|
+          allow(double_collection).to receive(:activate).ordered
+        end
+        double_collections.each do |double_collection|
+          allow(double_collection).to receive(:deactivate).ordered
+        end
+        klasses = Array.new(3) { |i| "Klass #{i}" }
+        world = described_class.new
+        double_collections.zip(klasses).each do |double_collection, klass|
+          allow(DoubleCollection).
+            to receive(:new).
+            with(klass).
+            and_return(double_collection)
+          world.double_collection_for(klass)
+        end
+
+        world.with_doubles_activated { block_called = true }
+
+        expect(block_called).to eq true
+
+        double_collections.each do |double_collection|
+          expect(double_collection).to have_received(:activate)
+          expect(double_collection).to have_received(:deactivate)
+        end
+      end
+
+      it 'still makes sure to uninstall all doubles even if the block raises an error' do
+        double_collection = build_double_collection
+        allow(DoubleCollection).to receive(:new).and_return(double_collection)
+        world = described_class.new
+        world.double_collection_for(:klass)
+
+        begin
+          world.with_doubles_activated { raise 'error' }
+        rescue RuntimeError
+        end
+
+        expect(double_collection).to have_received(:deactivate)
+      end
+    end
+
+    def build_double_collection
+      double('double_collection', activate: nil, deactivate: nil)
+    end
+  end
+end

data/spec/{shoulda → unit/shoulda}/matchers/doublespeak_spec.rb

@@ -1,18 +1,26 @@
-require 'spec_helper'
+require 'unit_spec_helper'
 
 module Shoulda::Matchers
   describe Doublespeak do
     describe '.double_collection_for' do
       it 'delegates to its world' do
-        Doublespeak.world.expects(:double_collection_for).with(:klass)
+        allow(Doublespeak.world).to receive(:double_collection_for)
+
         described_class.double_collection_for(:klass)
+
+        expect(Doublespeak.world).
+          to have_received(:double_collection_for).
+          with(:klass)
       end
     end
 
     describe '.with_doubles_activated' do
       it 'delegates to its world' do
-        Doublespeak.world.expects(:with_doubles_activated)
+        allow(Doublespeak.world).to receive(:with_doubles_activated)
+
         described_class.with_doubles_activated
+
+        expect(Doublespeak.world).to have_received(:with_doubles_activated)
       end
     end
   end

data/spec/{shoulda → unit/shoulda}/matchers/independent/delegate_method_matcher/stubbed_target_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require 'unit_spec_helper'
 
 describe Shoulda::Matchers::Independent::DelegateMethodMatcher::StubbedTarget do
   subject(:target) { described_class.new(:stubbed_method) }