remockable 0.2.1 → 0.3.0

data/spec/active_record/have_default_scope_spec.rb

@@ -1,168 +1,167 @@
-require 'spec_helper'
-
 describe :have_default_scope do
   let(:options) { :one }
 
   it_behaves_like 'an Active Record matcher' do
     let(:model) { build_class(:User, ActiveRecord::Base) }
 
+    subject(:instance) { model.new }
+
     before do
-      create_table(:users) { |table| table.string(:one) }
+      create_table :users do |table|
+        table.string :one
+      end
     end
 
-    subject { model.new }
-
     context 'description' do
       let(:matcher) { send(matcher_name, *options) }
 
       it 'has a custom description' do
-        name = matcher.instance_variable_get(:@name).to_s.gsub(/_/, ' ')
-        with = " with #{matcher.expected}" if matcher.expected.any?
+        with = " with #{matcher.options}" if matcher.options.any?
 
-        matcher.description.should == "have a default scope#{with}"
+        expect(matcher.description).to eq "have a default scope#{with}"
       end
     end
 
     context 'without arguments' do
       it 'matches if a default scope exists' do
-        model.instance_eval { default_scope(-> { order(:id) }) }
-        model.should have_default_scope
+        model.instance_eval { default_scope -> { order :id } }
+        expect(model).to have_default_scope
       end
 
       it 'does not match if a default scope does not exist' do
-        model.should_not have_default_scope
+        expect(model).to_not have_default_scope
       end
     end
 
     context 'with a from value' do
       it 'matches if the scope exists and the query matches' do
-        model.instance_eval { default_scope(-> { from('users') }) }
-        model.should have_default_scope.from('users')
+        model.instance_eval { default_scope-> { from 'users' } }
+        expect(model).to have_default_scope.from 'users'
       end
 
       it 'does not match if the query does not match' do
-        model.instance_eval { default_scope(-> { from('users') }) }
-        model.should_not have_default_scope.from('friends')
+        model.instance_eval { default_scope -> { from 'users' } }
+        expect(model).to_not have_default_scope.from 'friends'
       end
     end
 
     context 'with a group value' do
       it 'matches if the scope exists and the query matches' do
-        model.instance_eval { default_scope(-> { group('one') }) }
-        model.should have_default_scope.group('one')
+        model.instance_eval { default_scope -> { group 'one' } }
+        expect(model).to have_default_scope.group 'one'
       end
 
       it 'does not match if the query does not match' do
-        model.instance_eval { default_scope(-> { group('one') }) }
-        model.should_not have_default_scope.group('two')
+        model.instance_eval { default_scope -> { group 'one' } }
+        expect(model).to_not have_default_scope.group 'two'
       end
     end
 
     context 'with a having value' do
       it 'matches if the scope exists and the query matches' do
-        model.instance_eval { default_scope(-> { having('COUNT(*) > 1') }) }
-        model.should have_default_scope.having('COUNT(*) > 1')
+        model.instance_eval { default_scope -> { having 'COUNT(*) > 1' } }
+        expect(model).to have_default_scope.having('COUNT(*) > 1')
       end
 
       it 'does not match if the query does not match' do
-        model.instance_eval { default_scope(-> { having('COUNT(*) > 1') }) }
-        model.should_not have_default_scope.having('COUNT(*) > 2')
+        model.instance_eval { default_scope -> { having 'COUNT(*) > 1' } }
+        expect(model).to_not have_default_scope.having 'COUNT(*) > 2'
       end
     end
 
     context 'with a having value' do
       it 'matches if the scope exists and the query matches' do
-        model.instance_eval { default_scope(-> { having('COUNT(*) > 1') }) }
-        model.should have_default_scope.having('COUNT(*) > 1')
+        model.instance_eval { default_scope -> { having 'COUNT(*) > 1' } }
+        expect(model).to have_default_scope.having 'COUNT(*) > 1'
       end
 
       it 'does not match if the query does not match' do
-        model.instance_eval { default_scope(-> { having('COUNT(*) > 1') }) }
-        model.should_not have_default_scope.having('COUNT(*) > 2')
+        model.instance_eval { default_scope -> { having 'COUNT(*) > 1' } }
+        expect(model).to_not have_default_scope.having 'COUNT(*) > 2'
       end
     end
 
     context 'with a joins value' do
       it 'matches if the scope exists and the query matches' do
-        model.instance_eval { default_scope(-> { joins('INNER JOIN friends') }) }
-        model.should have_default_scope.joins('INNER JOIN friends')
+        model.instance_eval { default_scope -> { joins 'INNER JOIN friends' } }
+        expect(model).to have_default_scope.joins 'INNER JOIN friends'
       end
 
       it 'does not match if the query does not match' do
-        model.instance_eval { default_scope(-> { joins('INNER JOIN friends') }) }
-        model.should_not have_default_scope.joins('INNER JOIN enemies')
+        model.instance_eval { default_scope -> { joins 'INNER JOIN friends' } }
+        expect(model).to_not have_default_scope.joins 'INNER JOIN enemies'
       end
     end
 
     context 'with a limit value' do
       it 'matches if the scope exists and the query matches' do
-        model.instance_eval { default_scope(-> { limit(10) }) }
-        model.should have_default_scope.limit(10)
+        model.instance_eval { default_scope -> { limit 10 } }
+        expect(model).to have_default_scope.limit 10
       end
 
       it 'does not match if the query does not match' do
-        model.instance_eval { default_scope(-> { limit(10) }) }
-        model.should_not have_default_scope.limit(15)
+        model.instance_eval { default_scope -> { limit 10 } }
+        expect(model).to_not have_default_scope.limit 15
       end
     end
 
     context 'with an offset value' do
       it 'matches if the scope exists and the query matches' do
-        model.instance_eval { default_scope(-> { offset(10) }) }
-        model.should have_default_scope.offset(10)
+        model.instance_eval { default_scope -> { offset 10 } }
+        expect(model).to have_default_scope.offset 10
       end
 
       it 'does not match if the query does not match' do
-        model.instance_eval { default_scope(-> { offset(10) }) }
-        model.should_not have_default_scope.offset(15)
+        model.instance_eval { default_scope -> { offset 10 } }
+        expect(model).to_not have_default_scope.offset 15
       end
     end
 
     context 'with an order value' do
       it 'matches if the scope exists and the query matches' do
-        model.instance_eval { default_scope(-> { order('one') }) }
-        model.should have_default_scope.order('one')
+        model.instance_eval { default_scope -> { order 'one' } }
+        expect(model).to have_default_scope.order 'one'
       end
 
       it 'does not match if the query does not match' do
-        model.instance_eval { default_scope(-> { order('one') }) }
-        model.should_not have_default_scope.order('id')
+        model.instance_eval { default_scope -> { order 'one' } }
+        expect(model).to_not have_default_scope.order 'id'
       end
     end
 
     context 'with a reorder value' do
       it 'matches if the scope exists and the query matches' do
-        model.instance_eval { default_scope(-> { reorder('one') }) }
-        model.should have_default_scope.reorder('one')
+        model.instance_eval { default_scope -> { reorder 'one' } }
+        expect(model).to have_default_scope.reorder 'one'
       end
 
       it 'does not match if the query does not match' do
-        model.instance_eval { default_scope(-> { reorder('one') }) }
-        model.should_not have_default_scope.reorder('id')
+        model.instance_eval { default_scope -> { reorder 'one' } }
+        expect(model).to_not have_default_scope.reorder 'id'
       end
     end
 
     context 'with a select value' do
       it 'matches if the scope exists and the query matches' do
-        model.instance_eval { default_scope(-> { select('one') }) }
-        model.should have_default_scope.select('one')
+        model.instance_eval { default_scope -> { select 'one' } }
+        expect(model).to have_default_scope.select 'one'
       end
 
       it 'does not match if the query does not match' do
-        model.instance_eval { default_scope(-> { select('one') }) }
-        model.should_not have_default_scope.select('id')
+        model.instance_eval { default_scope -> { select 'one' } }
+        expect(model).to_not have_default_scope.select 'id'
       end
     end
 
     context 'with a where value' do
       it 'matches if the scope exists and the query matches' do
-        model.instance_eval { default_scope(-> { where(:one => nil) }) }
-        model.should have_default_scope.where(:one => nil)
+        model.instance_eval { default_scope -> { where one: nil } }
+        expect(model).to have_default_scope.where one: nil
       end
 
       it 'does not match if the query does not match' do
-        model.instance_eval { default_scope(-> { where(:one => nil) }) }
-        model.should_not have_default_scope.where(:one => 1)
+        model.instance_eval { default_scope -> { where one: nil } }
+        expect(model).to_not have_default_scope.where one: 1
       end
     end
   end

data/spec/active_record/have_index_spec.rb

@@ -1,88 +1,85 @@
-require 'spec_helper'
-
 describe :have_index do
   let(:options) { :one }
 
   it_behaves_like 'an Active Record matcher' do
     let(:model) { build_class(:User, ActiveRecord::Base) }
 
+    subject(:instance) { model.new }
+
     before do
-      create_table(:users) do |table|
-        table.string(:one)
-        table.string(:two)
+      create_table :users do |table|
+        table.string :one
+        table.string :two
       end
     end
 
-    subject { model.new }
-
     context 'description' do
       let(:matcher) { send(matcher_name, *options) }
 
       it 'has a custom description' do
-        name = matcher.instance_variable_get(:@name).to_s.gsub(/_/, ' ')
-        with = " with #{matcher.expected}" if matcher.expected.any?
+        with = " with #{matcher.options}" if matcher.options.any?
 
-        matcher.description.should == "#{name} on #{options}#{with}"
+        expect(matcher.description).to eq "have index on #{options}#{with}"
       end
     end
 
     context 'with a single column' do
       it 'matches if the index exists' do
-        ActiveRecord::Base.connection.add_index(:users, :one)
-        model.should have_index(:one)
+        ActiveRecord::Base.connection.add_index :users, :one
+        expect(model).to have_index :one
       end
 
       it 'does not match if the index does not exist' do
-        model.should_not have_index(:one)
+        expect(model).to_not have_index :one
       end
     end
 
     context 'with multiple columns' do
       it 'matches if the index exists' do
-        ActiveRecord::Base.connection.add_index(:users, [:one, :two])
-        model.should have_index([:one, :two])
+        ActiveRecord::Base.connection.add_index :users, [:one, :two]
+        expect(model).to have_index [:one, :two]
       end
 
       it 'does not match if the index does not exist' do
-        model.should_not have_index([:one, :two])
+        expect(model).to_not have_index [:one, :two]
       end
     end
 
     context 'with option :unique' do
       it 'matches if the index exists' do
-        ActiveRecord::Base.connection.add_index(:users, :one, :unique => true)
-        model.should have_index(:one, :unique => true)
+        ActiveRecord::Base.connection.add_index :users, :one, unique: true
+        expect(model).to have_index :one, unique: true
       end
 
       it 'does not match if the index is not unique' do
-        ActiveRecord::Base.connection.add_index(:users, :one)
-        model.should_not have_index(:one, :unique => true)
+        ActiveRecord::Base.connection.add_index :users, :one
+        expect(model).to_not have_index :one, unique: true
       end
 
       it 'does not match if the index does not exist' do
-        model.should_not have_index(:one, :unique => true)
+        expect(model).to_not have_index :one, unique: true
       end
     end
 
     context 'with option :name' do
       it 'matches if the index exists' do
-        ActiveRecord::Base.connection.add_index(:users, :one, :name => :oneness)
-        model.should have_index(:one, :name => :oneness)
+        ActiveRecord::Base.connection.add_index :users, :one, name: :oneness
+        expect(model).to have_index :one, name: :oneness
       end
 
       it 'does not match if the index does not exist' do
-        model.should_not have_index(:one, :name => :oneness)
+        expect(model).to_not have_index :one, name: :oneness
       end
     end
 
     context 'with option :name and without :one' do
       it 'matches if the index exists' do
-        ActiveRecord::Base.connection.add_index(:users, :one, :name => :oneness)
-        model.should have_index(:name => :oneness)
+        ActiveRecord::Base.connection.add_index :users, :one, name: :oneness
+        expect(model).to have_index name: :oneness
       end
 
       it 'does not match if the index does not exist' do
-        model.should_not have_index(:name => :oneness)
+        expect(model).to_not have_index name: :oneness
       end
     end
   end

data/spec/active_record/have_many_spec.rb

@@ -1,25 +1,24 @@
-require 'spec_helper'
-
 describe :have_many do
   let(:macro) { :has_many }
-  let(:options) { [:posts, { :dependent => :destroy }] }
+  let(:options) { [:posts, { dependent: :destroy }] }
 
   it_behaves_like 'an Active Record matcher' do
     let(:model) { build_class(:User, ActiveRecord::Base) }
 
+    subject(:instance) { model.new }
+
     before do
       create_table(:users) { |table| table.string(:name) }
     end
 
-    subject { model.new }
-
     context 'description' do
       let(:matcher) { send(matcher_name, *options) }
 
       it 'has a custom description' do
-        association = matcher.instance_variable_get(:@association)
-        with = " with #{matcher.expected.inspect}" if matcher.expected.any?
-        matcher.description.should == "have many #{association}#{with}"
+        association = matcher.attribute
+        with = " with #{matcher.options.inspect}" if matcher.options.any?
+
+        expect(matcher.description).to eq "have many #{association}#{with}"
       end
     end
 
@@ -28,16 +27,16 @@ describe :have_many do
 
       it 'matches if the association exists' do
         model.has_many(*options)
-        model.should have_many(*options)
+        expect(model).to have_many(*options)
       end
 
       it 'does not match if the association does not exist' do
-        model.should_not have_many(*options)
+        expect(model).to_not have_many(*options)
       end
 
       it 'does not match if the association is of the wrong type' do
         model.belongs_to(*options)
-        model.should_not have_many(*options)
+        expect(model).to_not have_many(*options)
       end
     end
 

data/spec/active_record/have_one_spec.rb

@@ -1,25 +1,26 @@
-require 'spec_helper'
-
 describe :have_one do
   let(:macro) { :has_one }
-  let(:options) { [:address, { :dependent => :destroy }] }
+  let(:options) { [:address, { dependent: :destroy }] }
 
   it_behaves_like 'an Active Record matcher' do
     let(:model) { build_class(:User, ActiveRecord::Base) }
 
+    subject(:instance) { model.new }
+
     before do
-      create_table(:users) { |table| table.string(:name) }
+      create_table :users do |table|
+        table.string :name
+      end
     end
 
-    subject { model.new }
-
     context 'description' do
       let(:matcher) { send(matcher_name, *options) }
 
       it 'has a custom description' do
-        association = matcher.instance_variable_get(:@association)
-        with = " with #{matcher.expected.inspect}" if matcher.expected.any?
-        matcher.description.should == "have a #{association}#{with}"
+        association = matcher.attribute
+        with = " with #{matcher.options.inspect}" if matcher.options.any?
+
+        expect(matcher.description).to eq "have a #{association}#{with}"
       end
     end
 
@@ -27,30 +28,30 @@ describe :have_one do
       let(:options) { :address }
 
       it 'matches if the association exists' do
-        model.has_one(*options)
-        model.should have_one(*options)
+        model.has_one *options
+        expect(model).to have_one *options
       end
 
       it 'does not match if the association does not exist' do
-        model.should_not have_one(*options)
+        expect(model).to_not have_one *options
       end
 
       it 'does not match if the association is of the wrong type' do
-        model.has_many(*options)
-        model.should_not have_one(*options)
+        model.has_many *options
+        expect(model).to_not have_one *options
       end
     end
 
-    with_option(:class_name, 'Address', 'Location')
-    with_option(:dependent, :destroy, :nullify)
-    with_option(:foreign_key, :address_id, :location_id)
-    with_option(:primary_key, :id, :address_id)
-    with_option(:as, :addressable, :locatable)
-    with_option(:through, :offices, :locations)
-    with_option(:source, :addressable, :contactable, through: :offices)
-    with_option(:source_type, 'Company', 'Organization', through: :offices)
-    with_option(:validate, true, false)
-    with_option(:autosave, true, false)
-    with_option(:inverse_of, :user, :employee)
+    with_option :class_name, 'Address', 'Location'
+    with_option :dependent, :destroy, :nullify
+    with_option :foreign_key, :address_id, :location_id
+    with_option :primary_key, :id, :address_id
+    with_option :as, :addressable, :locatable
+    with_option :through, :offices, :locations
+    with_option :source, :addressable, :contactable, through: :offices
+    with_option :source_type, 'Company', 'Organization', through: :offices
+    with_option :validate, true, false
+    with_option :autosave, true, false
+    with_option :inverse_of, :user, :employee
   end
 end