HornsAndHooves-flat_map 0.2.1 → 0.5.0

data/spec/flat_map/mapper/mounting_spec.rb

@@ -75,7 +75,7 @@ module FlatMap
 
     context 'defining mountings' do
       it "should use Factory for defining mappings" do
-        Mapper::Factory.should_receive(:new).
+        expect(Mapper::Factory).to receive(:new).
                         with(:foo, :mapper_class_name => 'FooMapper').
                         and_call_original
 
@@ -85,75 +85,75 @@ module FlatMap
     end
 
     describe 'properties' do
-      it{ mapper.hosted?.should be false }
-      it{ mounting.hosted?.should be true }
-      it{ mounting.host.should == mapper }
+      it{ expect(mapper.hosted?  ).to be false }
+      it{ expect(mounting.hosted?).to be true }
+      it{ expect(mounting.host   ).to eq mapper }
     end
 
     it 'should be able to access mapping by name' do
-      mapper.mounting(:spec_mount).should be_a(FlatMap::Mapper)
-      mapper.mounting(:undefined_mount).should be_nil
+      expect(mapper.mounting(:spec_mount     )).to be_a(FlatMap::Mapper)
+      expect(mapper.mounting(:undefined_mount)).to be_nil
     end
 
     describe "#read" do
       it 'should add mounted mappers to a result' do
-        mapper.read.should == {
+        expect(mapper.read).to eq({
           :host_attr     => 'attr',
           :attr_a        => 'a',
           :mapped_attr_b => 'b'
-        }
+        })
       end
 
       it 'should define dynamic writer methods' do
-        mapper.respond_to?(:attr_a).should be true
-        mapper.method(:attr_a).should_not  be nil
+        expect(mapper.respond_to?(:attr_a)).to     be true
+        expect(mapper.method(:attr_a     )).not_to be nil
 
-        mapper.respond_to?(:mapped_attr_b).should be true
-        mapper.method(:mapped_attr_b).should_not  be nil
+        expect(mapper.respond_to?(:mapped_attr_b)).to     be true
+        expect(mapper.method(:mapped_attr_b     )).not_to be nil
       end
     end
 
     describe "#write" do
       it 'should define dynamic writer methods' do
-        mapper.respond_to?(:attr_a=).should be true
-        mapper.method(:attr_a=).should_not  be nil
+        expect(mapper.respond_to?(:attr_a=)).to     be true
+        expect(mapper.method(:attr_a=     )).not_to be nil
 
-        mapper.respond_to?(:mapped_attr_b=).should be true
-        mapper.method(:mapped_attr_b=).should_not  be nil
+        expect(mapper.respond_to?(:mapped_attr_b=)).to     be true
+        expect(mapper.method(:mapped_attr_b=     )).not_to be nil
       end
 
       it 'should pass values to mounted mappers' do
         target = MountingSpec.mount_target
         mapper.write :attr_a => 'A', :mapped_attr_b => 'B'
-        target.attr_a.should == 'A'
-        target.attr_b.should == 'B'
+        expect(target.attr_a).to eq 'A'
+        expect(target.attr_b).to eq 'B'
       end
     end
 
     it 'should delegate missing methods to mounted mappers' do
-      expect{ mapper.a_method.should == 'a value' }.not_to raise_error
+      expect{ expect(mapper.a_method).to eq 'a value' }.not_to raise_error
     end
 
     specify '#before_save_mountings' do
-      mapper.before_save_mountings.should == [mapper.mounting(:spec_mount_before)]
+      expect(mapper.before_save_mountings).to eq [mapper.mounting(:spec_mount_before)]
     end
 
     specify '#after_save_mountings' do
-      mapper.after_save_mountings.should == [mapper.mounting(:spec_mount)]
+      expect(mapper.after_save_mountings).to eq [mapper.mounting(:spec_mount)]
     end
 
     context 'with suffix' do
       let(:mapper){ MountingSuffixSpec::SpecMapper.new(OpenStruct.new) }
       let(:mounting){ mapper.mounting(:mount_foo) }
 
-      it{ mapper.should_not be_suffixed }
-      it{ mounting.should be_suffixed }
+      it{ expect(mapper  ).not_to be_suffixed }
+      it{ expect(mounting).to be_suffixed }
 
       it 'should cascade to nested mappings' do
         mapper.attr_mount_foo  = 'foo'
         mapper.attr_nested_foo = 'bar'
 
-        mapper.read.should include({
+        expect(mapper.read).to include({
           :attr_mount_foo  => 'foo',
           :attr_nested_foo => 'bar' })
       end

data/spec/flat_map/mapper/persistence_spec.rb

@@ -29,21 +29,24 @@ module FlatMap
   describe Mapper::Persistence do
     describe '#target_class' do
       it 'should detect target_class from mapper class name' do
-        PersistenceSpec::TargetClassMapper.target_class.should == PersistenceSpec::TargetClass
+        expect(PersistenceSpec::TargetClassMapper.target_class.ancestors).
+          to include PersistenceSpec::TargetClass
       end
 
       it 'should detect target_class from nearest ancestor when inherited' do
-        PersistenceSpec::InheritedClassMapper.target_class.should == PersistenceSpec::TargetClass
+        expect(PersistenceSpec::InheritedClassMapper.target_class.ancestors).
+          to include PersistenceSpec::TargetClass
       end
 
       it 'should use explicit class name if specified' do
-        PersistenceSpec::ExplicitNameMapper.target_class.should == PersistenceSpec::OtherTargetClass
+        expect(PersistenceSpec::ExplicitNameMapper.target_class.ancestors).
+          to include PersistenceSpec::OtherTargetClass
       end
     end
 
     describe '.build' do
       it 'should use target class to build a new object for mapper' do
-        PersistenceSpec::TargetClassMapper.should_receive(:new).with(kind_of(PersistenceSpec::TargetClass), :used_trait)
+        expect(PersistenceSpec::TargetClassMapper).to receive(:new).with(kind_of(PersistenceSpec::TargetClass), :used_trait)
         PersistenceSpec::TargetClassMapper.build(:used_trait)
       end
     end
@@ -52,8 +55,8 @@ module FlatMap
       let(:target){ PersistenceSpec::TargetClass.new('a', 'b') }
 
       it 'should delegate to target class to find object for mapper' do
-        PersistenceSpec::TargetClass.should_receive(:find).with(1).and_return(target)
-        PersistenceSpec::TargetClassMapper.should_receive(:new).with(target, :used_trait)
+        expect(PersistenceSpec::TargetClass).to receive(:find).with(1).and_return(target)
+        expect(PersistenceSpec::TargetClassMapper).to receive(:new).with(target, :used_trait)
         PersistenceSpec::TargetClassMapper.find(1, :used_trait)
       end
     end
@@ -63,35 +66,35 @@ module FlatMap
       let(:mapper){ PersistenceSpec::TargetClassMapper.new(target){} }
 
       specify '#model_name' do
-        mapper.model_name.should == 'mapper'
+        expect(mapper.model_name).to respond_to :human
       end
 
       specify '#to_key should delegate to target' do
-        target.should_receive(:to_key).and_return(1)
-        mapper.to_key.should == 1
+        expect(target).to receive(:to_key).and_return(1)
+        expect(mapper.to_key).to eq 1
       end
 
       specify '#persisted? when target does not respond to :persised?' do
-        mapper.should_not be_persisted
+        expect(mapper).not_to be_persisted
       end
 
       specify '#persisted? when target responds to :persisted?' do
-        target.stub(:persisted?).and_return(true)
-        mapper.should be_persisted
+        expect(target).to receive(:persisted?).and_return(true)
+        expect(mapper).to be_persisted
       end
 
       specify '#id when target does not respond to :id' do
-        mapper.id.should be_nil
+        expect(mapper.id).to be_nil
       end
 
       specify '#id when target responds to :id' do
-        target.stub(:id).and_return(1)
-        mapper.id.should == 1
+        expect(target).to receive(:id).and_return(1)
+        expect(mapper.id).to eq 1
       end
 
       describe '#write with multiparams' do
         let(:params) {{
-          'attr_a'     => 'A',
+          'attr_a'  => 'A',
           'dob(0i)' => '1999',
           'dob(1i)' => '01',
           'dob(2i)' => '02'
@@ -99,23 +102,23 @@ module FlatMap
 
         it 'should assign values properly' do
           mapper.write(params)
-          target.attr_a.should == 'A'
-          target.attr_b.should == Date.new(1999, 1, 2)
+          expect(target.attr_a).to eq 'A'
+          expect(target.attr_b).to eq Date.new(1999, 1, 2)
         end
       end
 
       describe '#save_target' do
         it 'should return true for owned mappers' do
-          mapper.extension.save_target.should be true
+          expect(mapper.extension.save_target).to eq true
         end
 
         it 'should return true if target does not respond to #save' do
-          mapper.save_target.should be true
+          expect(mapper.save_target).to eq true
         end
 
         it 'should save with no validation if target responds to #save' do
-          target.should_receive(:save).with(:validate => false).and_return(true)
-          mapper.save_target.should be true
+          expect(target).to receive(:save).with(:validate => false).and_return(true)
+          expect(mapper.save_target).to eq true
         end
       end
 
@@ -123,28 +126,28 @@ module FlatMap
         let(:params){{ :attr_a => 'A' }}
 
         it 'should write params first' do
-          mapper.should_receive(:write).with(params)
-          ActiveRecord::Base.should_receive(:transaction).and_yield
+          expect(mapper).to receive(:write).with(params)
+          expect(ActiveRecord::Base).to receive(:transaction).and_yield
           mapper.apply(params)
         end
 
         it 'should not save if not valid' do
-          mapper.stub(:valid?).and_return(false)
-          mapper.should_not_receive(:save)
+          expect(mapper).to receive(:valid?).and_return(false)
+          expect(mapper).not_to receive(:save)
           mapper.apply(params)
         end
 
         it 'should save if valid' do
-          mapper.stub(:valid?).and_return(true)
-          ActiveRecord::Base.should_receive(:transaction).and_yield
-          mapper.should_receive(:save)
+          expect(mapper).to receive(:valid?).and_return(true)
+          expect(ActiveRecord::Base).to receive(:transaction).and_yield
+          expect(mapper).to receive(:save)
           mapper.apply(params)
         end
       end
 
       specify '#shallow_save saves target in a save callbacks' do
-        mapper.should_receive(:run_callbacks).with(:save).and_yield
-        mapper.should_receive(:save_target)
+        expect(mapper).to receive(:run_callbacks).with(:save).and_yield
+        expect(mapper).to receive(:save_target)
         mapper.shallow_save
       end
     end

data/spec/flat_map/mapper/skipping_spec.rb

@@ -28,22 +28,22 @@ module FlatMap
     before{ mapper.trait(:with_trait).skip! }
 
     it 'should completely ignore skipped mounting' do
-      mapper.should be_valid
-      mapper.save.should be true
-      mapper.attr_a.should be_nil
-      mapper.attr_b.should be_nil
+      expect(mapper       ).to be_valid
+      expect(mapper.save  ).to be true
+      expect(mapper.attr_a).to be_nil
+      expect(mapper.attr_b).to be_nil
     end
 
     it '#use! should enable skipped mounting' do
       mapper.trait(:with_trait).use!
 
-      mapper.should_not be_valid
-      mapper.attr_a.should == 'a'
-      mapper.errors[:attr_a].should be_present
+      expect(mapper).not_to be_valid
+      expect(mapper.attr_a).to eq 'a'
+      expect(mapper.errors[:attr_a]).to be_present
 
       mapper.attr_a = 5
       mapper.save
-      mapper.attr_b.should == 'b'
+      expect(mapper.attr_b).to eq 'b'
     end
   end
 
@@ -51,39 +51,40 @@ module FlatMap
     let(:target){ OpenStruct.new }
     let(:mapper){ SkippingSpec::SpecMapper.new(target, :with_trait) }
 
-    before{ target.stub(:is_a?).with(ActiveRecord::Base).and_return(true) }
+    before{ expect(target).
+        to receive(:is_a?).at_least(1).times.with(ActiveRecord::Base).and_return(true) }
 
     context 'for new record' do
       before do
-        target.stub(:new_record?).and_return(true)
+        expect(target).to receive(:new_record?).at_least(1).times.and_return(true)
         mapper.trait(:with_trait).skip!
       end
 
       specify '#skip! should set ivar @destroyed to true' do
-        target.instance_variable_get('@destroyed').should be true
+        expect(target.instance_variable_get('@destroyed')).to be true
       end
 
       specify '#use! should set ivar @destroyed to true' do
         mapper.trait(:with_trait).use!
-        target.instance_variable_get('@destroyed').should be false
+        expect(target.instance_variable_get('@destroyed')).to be false
       end
     end
 
     context 'for persisted record' do
       before do
-        target.stub(:new_record?).and_return(false)
+        expect(target).to receive(:new_record?).at_least(1).times.and_return(false)
       end
 
       specify '#skip! should reload persisted record' do
-        target.should_receive(:reload)
+        expect(target).to receive(:reload)
         mapper.trait(:with_trait).skip!
       end
 
       specify '#use! should use all nested mountings' do
         mapper.trait(:with_trait).skip!
         mock = double('mounting')
-        mock.should_receive(:use!)
-        mapper.trait(:with_trait).stub(:all_nested_mountings).and_return([mock])
+        expect(mock).to receive(:use!)
+        expect(mapper.trait(:with_trait)).to receive(:all_nested_mountings).and_return([mock])
         mapper.trait(:with_trait).use!
       end
     end

data/spec/flat_map/mapper/targeting_spec.rb

@@ -29,24 +29,23 @@ module FlatMap
   describe 'Working with Target' do
     describe '#target_class' do
       it 'should detect target_class from mapper class name' do
-        ModelMethodsSpec::TargetClassMapper.target_class.should == ModelMethodsSpec::TargetClass
+        expect(ModelMethodsSpec::TargetClassMapper.target_class).to eq ModelMethodsSpec::TargetClass
       end
 
       it 'should detect target_class from nearest ancestor when inherited' do
-        ModelMethodsSpec::InheritedClassMapper.target_class.
-                                               should == ModelMethodsSpec::TargetClass
+        expect(ModelMethodsSpec::InheritedClassMapper.target_class.ancestors).
+          to include ModelMethodsSpec::TargetClass
       end
 
       it 'should use explicit class name if specified' do
-        ModelMethodsSpec::ExplicitNameMapper.target_class.
-                                             should == ModelMethodsSpec::OtherTargetClass
+        expect(ModelMethodsSpec::ExplicitNameMapper.target_class.ancestors).
+          to include ModelMethodsSpec::OtherTargetClass
       end
     end
 
     describe '.build' do
       it 'should use target class to build a new object for mapper' do
-        ModelMethodsSpec::TargetClassMapper.
-          should_receive(:new).
+        expect(ModelMethodsSpec::TargetClassMapper).to receive(:new).
           with(kind_of(ModelMethodsSpec::TargetClass), :used_trait)
         ModelMethodsSpec::TargetClassMapper.build(:used_trait)
       end
@@ -56,8 +55,8 @@ module FlatMap
       let(:target){ ModelMethodsSpec::TargetClass.new('a', 'b') }
 
       it 'should delegate to target class to find object for mapper' do
-        ModelMethodsSpec::TargetClass.should_receive(:find).with(1).and_return(target)
-        ModelMethodsSpec::TargetClassMapper.should_receive(:new).with(target, :used_trait)
+        expect(ModelMethodsSpec::TargetClass).to receive(:find).with(1).and_return(target)
+        expect(ModelMethodsSpec::TargetClassMapper).to receive(:new).with(target, :used_trait)
         ModelMethodsSpec::TargetClassMapper.find(1, :used_trait)
       end
     end
@@ -67,30 +66,30 @@ module FlatMap
       let(:mapper){ ModelMethodsSpec::TargetClassMapper.new(target){} }
 
       specify '#model_name' do
-        mapper.model_name.should == 'mapper'
+        expect(mapper.model_name).to respond_to :human
       end
 
       specify '#to_key should delegate to target' do
-        target.should_receive(:to_key).and_return(1)
-        mapper.to_key.should == 1
+        expect(target).to receive(:to_key).and_return(1)
+        expect(mapper.to_key).to eq 1
       end
 
       specify '#persisted? when target does not respond to :persised?' do
-        mapper.should_not be_persisted
+        expect(mapper).not_to be_persisted
       end
 
       specify '#persisted? when target responds to :persisted?' do
-        target.stub(:persisted?).and_return(true)
-        mapper.should be_persisted
+        expect(target).to receive(:persisted?).and_return(true)
+        expect(mapper).to be_persisted
       end
 
       specify '#id when target does not respond to :id' do
-        mapper.id.should be_nil
+        expect(mapper.id).to be_nil
       end
 
       specify '#id when target responds to :id' do
-        target.stub(:id).and_return(1)
-        mapper.id.should == 1
+        expect(target).to receive(:id).and_return(1)
+        expect(mapper.id).to eq 1
       end
 
       describe '#write with multiparams' do
@@ -103,23 +102,23 @@ module FlatMap
 
         it 'should assign values properly' do
           mapper.write(params)
-          target.attr_a.should == 'A'
-          target.attr_b.should == Date.new(1999, 1, 2)
+          expect(target.attr_a).to eq 'A'
+          expect(target.attr_b).to eq Date.new(1999, 1, 2)
         end
       end
 
       describe '#save_target' do
         it 'should return true for owned mappers' do
-          mapper.extension.save_target.should be true
+          expect(mapper.extension.save_target).to be true
         end
 
         it 'should return true if target does not respond to #save' do
-          mapper.save_target.should be true
+          expect(mapper.save_target).to be true
         end
 
         it 'should save with no validation if target responds to #save' do
-          target.should_receive(:save).with(:validate => false).and_return(true)
-          mapper.save_target.should be true
+          expect(target).to receive(:save).with(:validate => false).and_return(true)
+          expect(mapper.save_target).to be true
         end
       end
 
@@ -127,28 +126,28 @@ module FlatMap
         let(:params){{ :attr_a => 'A' }}
 
         it 'should write params first' do
-          mapper.should_receive(:write).with(params)
-          ActiveRecord::Base.should_receive(:transaction).and_yield
+          expect(mapper).to receive(:write).with(params)
+          expect(ActiveRecord::Base).to receive(:transaction).and_yield
           mapper.apply(params)
         end
 
         it 'should not save if not valid' do
-          mapper.stub(:valid?).and_return(false)
-          mapper.should_not_receive(:save)
+          expect(mapper).to     receive(:valid?).and_return(false)
+          expect(mapper).not_to receive(:save)
           mapper.apply(params)
         end
 
         it 'should save if valid' do
-          mapper.stub(:valid?).and_return(true)
-          ActiveRecord::Base.should_receive(:transaction).and_yield
-          mapper.should_receive(:save)
+          expect(mapper).to receive(:valid?).and_return(true)
+          expect(ActiveRecord::Base).to receive(:transaction).and_yield
+          expect(mapper).to receive(:save)
           mapper.apply(params)
         end
       end
 
       specify '#shallow_save saves target in a save callbacks' do
-        mapper.should_receive(:run_callbacks).with(:save).and_yield
-        mapper.should_receive(:save_target)
+        expect(mapper).to receive(:run_callbacks).with(:save).and_yield
+        expect(mapper).to receive(:save_target)
         mapper.shallow_save
       end
     end

data/spec/flat_map/mapper/traits_spec.rb

@@ -51,14 +51,14 @@ module FlatMap
   describe 'Traits' do
     describe 'trait definition' do
       it "should add a traited mapper factory to a class" do
-        TraitsSpec::EmptyMapper.should_receive(:mount).
+        expect(TraitsSpec::EmptyMapper).to receive(:mount).
                                 with(kind_of(Class), :trait_name => :a_trait).
                                 and_call_original
         expect{ TraitsSpec::EmptyMapper.trait(:a_trait) }.
           to change{ TraitsSpec::EmptyMapper.mountings.length }.by(1)
         trait_mapper_class =
           TraitsSpec::EmptyMapper.mountings.first.instance_variable_get('@identifier')
-        trait_mapper_class.name.should == 'FlatMap::TraitsSpec::EmptyMapperATraitTrait'
+        expect(trait_mapper_class.name).to eq 'FlatMap::TraitsSpec::EmptyMapperATraitTrait'
       end
     end
 
@@ -79,25 +79,25 @@ module FlatMap
       end
 
       it 'should be able to access trait by name' do
-        mapper.trait(:trait_one).should be_a(Mapper)
-        mapper.trait(:undefined).should be_nil
+        expect(mapper.trait(:trait_one)).to be_a(Mapper)
+        expect(mapper.trait(:undefined)).to be_nil
       end
 
       it 'should not contain unused trait' do
-        mapper.trait(:trait_two).should be_nil
+        expect(mapper.trait(:trait_two)).to be_nil
       end
 
       it 'should have mountings of a trait' do
-        mapper.mounting(:spec_mount).should be_present
+        expect(mapper.mounting(:spec_mount)).to be_present
       end
 
       it '#read should read values with respect to trait' do
-        mapper.read.should == {
+        expect(mapper.read).to eq({
           :attr_a => 'a',
           :attr_b => 'b',
           :attr_c => 'c',
           :attr_d => 'd'
-        }
+        })
       end
 
       it '#write should properly distribute values' do
@@ -106,33 +106,33 @@ module FlatMap
           :attr_b => 'B',
           :attr_c => 'C',
           :attr_d => 'D'
-        target.attr_a.should == 'A'
-        target.attr_b.should == 'B'
-        mount_target.attr_c.should == 'C'
-        mount_target.attr_d.should == 'D'
+        expect(target.attr_a      ).to eq 'A'
+        expect(target.attr_b      ).to eq 'B'
+        expect(mount_target.attr_c).to eq 'C'
+        expect(mount_target.attr_d).to eq 'D'
       end
 
       specify 'mapper should be avle to call methods of enabled traits' do
         mapper = TraitsSpec::HostMapper.new(target, :trait_one)
-        mapper.method_one.should == 'one'
+        expect(mapper.method_one).to eq 'one'
         expect{ mapper.method_two }.to raise_error(NoMethodError)
       end
 
       specify 'traits should be able to call methods of each other' do
         mapper = TraitsSpec::HostMapper.new(target, :trait_one, :trait_two)
-        mapper.trait(:trait_two).method_two.should == 'one'
+        expect(mapper.trait(:trait_two).method_two).to eq 'one'
       end
 
       describe 'trait nesting' do
         let(:mapper){ TraitsSpec::HostMapper.new(target, :trait_one_nested) }
 
         it 'should still be able to have top-level trait definitions' do
-          mapper.mounting(:spec_mount).should be_present
-          mapper.method_one.should == 'one'
+          expect(mapper.mounting(:spec_mount)).to be_present
+          expect(mapper.method_one).to eq 'one'
         end
 
         it 'should have new definitions' do
-          mapper.method_one_nested.should == 'nested_one'
+          expect(mapper.method_one_nested).to eq 'nested_one'
         end
       end
 
@@ -150,21 +150,21 @@ module FlatMap
         end
 
         it 'should behave like a normal trait' do
-          mapper.trait(:extension).should be_present
-          mapper.read.should include :attr_b => 'b'
+          expect(mapper.trait(:extension)).to be_present
+          expect(mapper.read).to include :attr_b => 'b'
         end
 
         it 'should be accessible' do
-          mapper.extension.should be_present
+          expect(mapper.extension).to be_present
         end
 
         it 'should be_extension' do
-          mapper.extension.should be_extension
+          expect(mapper.extension).to be_extension
         end
 
         it "should be able to handle save exception of traits" do
           expect{ mapper.apply(:writing_error => 'foo') }.not_to raise_error
-          mapper.errors[:writing_error].should include 'cannot be foo'
+          expect(mapper.errors[:writing_error]).to include 'cannot be foo'
         end
       end
     end

data/spec/flat_map/mapper/validations_spec.rb

@@ -52,21 +52,21 @@ module FlatMap
     end
 
     it 'should not be valid' do
-      mapper.should_not be_valid
+      expect(mapper).not_to be_valid
     end
 
     it 'should call callbacks' do
-      mapper.trait(:with_trait).should_receive(:set_default_attr_b).and_call_original
+      expect(mapper.trait(:with_trait)).to receive(:set_default_attr_b).and_call_original
       mapper.valid?
-      mapper.attr_b.should == 'foo'
+      expect(mapper.attr_b).to eq 'foo'
     end
 
     it 'should have all the errors' do
       mapper.valid?
-      mapper.errors[:attr_a].should == ["can't be blank"]
-      mapper.errors[:attr_b].should == ["can't be foo"]
-      mapper.errors[:attr_c].should == ["can't be blank"]
-      mapper.errors[:attr_d].should == ["can't be blank"]
+      expect(mapper.errors[:attr_a]).to eq ["can't be blank"]
+      expect(mapper.errors[:attr_b]).to eq ["can't be foo"]
+      expect(mapper.errors[:attr_c]).to eq ["can't be blank"]
+      expect(mapper.errors[:attr_d]).to eq ["can't be blank"]
     end
   end
 end

data/spec/flat_map/mapping/factory_spec.rb

@@ -5,7 +5,7 @@ describe FlatMap::Mapping::Factory do
 
   specify('#create should delegate all initialization params to new mapping') do
     mapper_stub = double('mapper')
-    FlatMap::Mapping.should_receive(:new).with(mapper_stub, :foo, :bar, :baz)
+    expect(FlatMap::Mapping).to receive(:new).with(mapper_stub, :foo, :bar, :baz)
 
     factory.create(mapper_stub)
   end