remockable 0.2.1 → 0.3.0

data/spec/active_record/have_scope_spec.rb

@@ -1,228 +1,228 @@
-require 'spec_helper'
-
 describe :have_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?
+        name = matcher.attribute
+        with = " with #{matcher.options}" if matcher.options.any?
 
-        matcher.description.should == "have scope #{name}#{with}"
+        expect(matcher.description).to eq "have scope #{name}#{with}"
       end
     end
 
     context 'with a scope name' do
       it 'matches if the scope exists' do
-        model.instance_eval { scope(:no_one, -> { where(:one => nil) }) }
-        model.should have_scope(:no_one)
+        model.instance_eval { scope :no_one, -> { where one: nil } }
+        expect(model).to have_scope :no_one
       end
 
       it 'does not match if the scope does not exist' do
-        model.should_not have_scope(:no_one)
+        expect(model).to_not have_scope :no_one
       end
     end
 
     context 'with an eager_load value' do
       it 'matches if the scope exists and the query matches' do
-        model.instance_eval { scope(:loaded, -> { eager_load(:order) }) }
-        model.should have_scope(:loaded).eager_load(:order)
+        model.instance_eval { scope :loaded, -> { eager_load :order } }
+        expect(model).to have_scope(:loaded).eager_load(:order)
       end
 
       it 'does not match if the query does not match' do
-        model.instance_eval { scope(:loaded, -> { eager_load(:order) }) }
-        model.should_not have_scope(:loaded).eager_load(:from)
+        model.instance_eval { scope :loaded, -> { eager_load :order } }
+        expect(model).to_not have_scope(:loaded).eager_load(:from)
       end
     end
 
     context 'with a from value' do
       it 'matches if the scope exists and the query matches' do
-        model.instance_eval { scope(:used, -> { from('users') }) }
-        model.should have_scope(:used).from('users')
+        model.instance_eval { scope :used, -> { from 'users' } }
+        expect(model).to have_scope(:used).from('users')
       end
 
       it 'does not match if the query does not match' do
-        model.instance_eval { scope(:used, -> { from('users') }) }
-        model.should_not have_scope(:used).from('friends')
+        model.instance_eval { scope :used, -> { from 'users' } }
+        expect(model).to_not have_scope(:used).from('friends')
       end
     end
 
     context 'with a group value' do
       it 'matches if the scope exists and the query matches' do
-        model.instance_eval { scope(:grouped, -> { group('one') }) }
-        model.should have_scope(:grouped).group('one')
+        model.instance_eval { scope :grouped, -> { group 'one' } }
+        expect(model).to have_scope(:grouped).group('one')
       end
 
       it 'does not match if the query does not match' do
-        model.instance_eval { scope(:grouped, -> { group('one') }) }
-        model.should_not have_scope(:grouped).group('two')
+        model.instance_eval { scope :grouped, -> { group 'one' } }
+        expect(model).to_not have_scope(:grouped).group('two')
       end
     end
 
     context 'with a having value' do
       it 'matches if the scope exists and the query matches' do
-        model.instance_eval { scope(:had, -> { having('COUNT(*) > 1') }) }
-        model.should have_scope(:had).having('COUNT(*) > 1')
+        model.instance_eval { scope :had, -> { having 'COUNT(*) > 1' } }
+        expect(model).to have_scope(:had).having('COUNT(*) > 1')
       end
 
       it 'does not match if the query does not match' do
-        model.instance_eval { scope(:had, -> { having('COUNT(*) > 1') }) }
-        model.should_not have_scope(:had).having('COUNT(*) > 2')
+        model.instance_eval { scope :had, -> { having 'COUNT(*) > 1' } }
+        expect(model).to_not have_scope(:had).having('COUNT(*) > 2')
       end
     end
 
     context 'with an includes value' do
       it 'matches if the scope exists and the query matches' do
-        model.instance_eval { scope(:joined, -> { includes(:company) }) }
-        model.should have_scope(:joined).includes(:company)
+        model.instance_eval { scope :joined, -> { includes :company } }
+        expect(model).to have_scope(:joined).includes(:company)
       end
 
       it 'does not match if the query does not match' do
-        model.instance_eval { scope(:joined, -> { includes(:company) }) }
-        model.should_not have_scope(:joined).includes(:address)
+        model.instance_eval { scope :joined, -> { includes :company } }
+        expect(model).to_not have_scope(:joined).includes(:address)
       end
     end
 
     context 'with a joins value' do
       it 'matches if the scope exists and the query matches' do
-        model.instance_eval { scope(:joined, -> { joins('INNER JOIN friends') }) }
-        model.should have_scope(:joined).joins('INNER JOIN friends')
+        model.instance_eval { scope :joined, -> { joins 'INNER JOIN friends' } }
+        expect(model).to have_scope(:joined).joins('INNER JOIN friends')
       end
 
       it 'does not match if the query does not match' do
-        model.instance_eval { scope(:joined, -> { joins('INNER JOIN friends') }) }
-        model.should_not have_scope(:joined).joins('INNER JOIN enemies')
+        model.instance_eval { scope :joined, -> { joins 'INNER JOIN friends' } }
+        expect(model).to_not have_scope(:joined).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 { scope(:limited, -> { limit(10) }) }
-        model.should have_scope(:limited).limit(10)
+        model.instance_eval { scope :limited, -> { limit 10 } }
+        expect(model).to have_scope(:limited).limit(10)
       end
 
       it 'does not match if the query does not match' do
-        model.instance_eval { scope(:limited, -> { limit(10) }) }
-        model.should_not have_scope(:limited).limit(15)
+        model.instance_eval { scope :limited, -> { limit 10 } }
+        expect(model).to_not have_scope(:limited).limit(15)
       end
     end
 
     context 'with a lock value' do
       it 'matches if the scope exists and the query matches' do
-        model.instance_eval { scope(:locked, -> { lock(true) }) }
-        model.should have_scope(:locked).lock(true)
+        model.instance_eval { scope :locked, -> { lock true } }
+        expect(model).to have_scope(:locked).lock(true)
       end
 
       it 'does not match if the query does not match' do
-        model.instance_eval { scope(:locked, -> { lock(true) }) }
-        model.should_not have_scope(:locked).lock(false)
+        model.instance_eval { scope :locked, -> { lock true } }
+        expect(model).to_not have_scope(:locked).lock(false)
       end
     end
 
     context 'with an offset value' do
       it 'matches if the scope exists and the query matches' do
-        model.instance_eval { scope(:shifted, -> { offset(10) }) }
-        model.should have_scope(:shifted).offset(10)
+        model.instance_eval { scope :shifted, -> { offset 10 } }
+        expect(model).to have_scope(:shifted).offset(10)
       end
 
       it 'does not match if the query does not match' do
-        model.instance_eval { scope(:shifted, -> { offset(10) }) }
-        model.should_not have_scope(:shifted).offset(15)
+        model.instance_eval { scope :shifted, -> { offset 10 } }
+        expect(model).to_not have_scope(:shifted).offset(15)
       end
     end
 
     context 'with an order value' do
       it 'matches if the scope exists and the query matches' do
-        model.instance_eval { scope(:ordered, -> { order('one') }) }
-        model.should have_scope(:ordered).order('one')
+        model.instance_eval { scope :ordered, -> { order 'one' } }
+        expect(model).to have_scope(:ordered).order('one')
       end
 
       it 'does not match if the query does not match' do
-        model.instance_eval { scope(:ordered, -> { order('one') }) }
-        model.should_not have_scope(:ordered).order('id')
+        model.instance_eval { scope :ordered, -> { order 'one' } }
+        expect(model).to_not have_scope(:ordered).order('id')
       end
     end
 
     context 'with a preload value' do
       it 'matches if the scope exists and the query matches' do
-        model.instance_eval { scope(:preloaded, -> { preload(:company) }) }
-        model.should have_scope(:preloaded).preload(:company)
+        model.instance_eval { scope :preloaded, -> { preload :company } }
+        expect(model).to have_scope(:preloaded).preload(:company)
       end
 
       it 'does not match if the query does not match' do
-        model.instance_eval { scope(:preloaded, -> { preload(:company) }) }
-        model.should_not have_scope(:preloaded).preload(:address)
+        model.instance_eval { scope :preloaded, -> { preload :company } }
+        expect(model).to_not have_scope(:preloaded).preload(:address)
       end
     end
 
     context 'with a readonly value' do
       it 'matches if the scope exists and the query matches' do
-        model.instance_eval { scope(:prepared, -> { readonly(false) }) }
-        model.should have_scope(:prepared).readonly(false)
+        model.instance_eval { scope :prepared, -> { readonly false } }
+        expect(model).to have_scope(:prepared).readonly(false)
       end
 
       it 'does not match if the query does not match' do
-        model.instance_eval { scope(:prepared, -> { readonly(false) }) }
-        model.should_not have_scope(:prepared).readonly(true)
+        model.instance_eval { scope :prepared, -> { readonly false } }
+        expect(model).to_not have_scope(:prepared).readonly(true)
       end
     end
 
     context 'with a reorder value' do
       it 'matches if the scope exists and the query matches' do
-        model.instance_eval { scope(:reordered, -> { reorder('one') }) }
-        model.should have_scope(:reordered).reorder('one')
+        model.instance_eval { scope :reordered, -> { reorder 'one' } }
+        expect(model).to have_scope(:reordered).reorder('one')
       end
 
       it 'does not match if the query does not match' do
-        model.instance_eval { scope(:reordered, -> { reorder('one') }) }
-        model.should_not have_scope(:reordered).reorder('id')
+        model.instance_eval { scope :reordered, -> { reorder 'one' } }
+        expect(model).to_not have_scope(:reordered).reorder('id')
       end
     end
 
     context 'with a select value' do
       it 'matches if the scope exists and the query matches' do
-        model.instance_eval { scope(:ones, -> { select('one') }) }
-        model.should have_scope(:ones).select('one')
+        model.instance_eval { scope :ones, -> { select 'one' } }
+        expect(model).to have_scope(:ones).select('one')
       end
 
       it 'does not match if the query does not match' do
-        model.instance_eval { scope(:ones, -> { select('one') }) }
-        model.should_not have_scope(:ones).select('id')
+        model.instance_eval { scope :ones, -> { select 'one' } }
+        expect(model).to_not have_scope(:ones).select('id')
       end
     end
 
     context 'with a where value' do
       it 'matches if the scope exists and the query matches' do
-        model.instance_eval { scope(:no_one, -> { where(:one => nil) }) }
-        model.should have_scope(:no_one).where(:one => nil)
+        model.instance_eval { scope :no_one, -> { where one: nil } }
+        expect(model).to have_scope(:no_one).where(one: nil)
       end
 
       it 'does not match if the query does not match' do
-        model.instance_eval { scope(:no_one, -> { where(:one => nil) }) }
-        model.should_not have_scope(:no_one).where(:one => 1)
+        model.instance_eval { scope :no_one, -> { where one: nil } }
+        expect(model).to_not have_scope(:no_one).where(one: 1)
       end
     end
 
     context 'with option :with' do
       it 'matches if the query matches for the given value' do
-        model.instance_eval { scope(:which_one, lambda { |one| where(:one => one) }) }
-        model.should have_scope(:which_one, :with => 1).where(:one => 1)
+        model.instance_eval { scope :which_one, ->(one) { where one: one } }
+        expect(model).to have_scope(:which_one, with: 1).where(one: 1)
       end
 
       it 'does not match if the query does not match for the given value' do
-        model.instance_eval { scope(:which_one, lambda { |one| where(:one => one) }) }
-        model.should_not have_scope(:which_one, :with => 2).where(:one => 1)
+        model.instance_eval { scope :which_one, ->(one) { where one: one } }
+        expect(model).to_not have_scope(:which_one, with: 2).where(one: 1)
       end
     end
   end

data/spec/active_record/validate_associated_spec.rb

@@ -1,27 +1,27 @@
-require 'spec_helper'
-
 describe :validate_associated do
   let(:validator_name) { :associated }
   let(:attribute) { :company }
-  let(:default_options) { { :on => :create } }
+  let(:default_options) { { on: :create } }
 
   before do
-    create_table(:users) { |table| table.string(:company_id) }
+    create_table :users do |table|
+      table.string :company_id
+    end
   end
 
   it_behaves_like 'a validation matcher' do
-    let(:model) do
-      build_class(:User, ActiveRecord::Base) do
+    let(:model) {
+      build_class :User, ActiveRecord::Base do
         include ActiveRecord::Validations
 
         belongs_to :company
       end
-    end
+    }
 
-    with_option(:message, 'is not unique!', 'invalid')
-    with_option(:on, :create, :update)
+    with_option :message, 'is not unique!', 'invalid'
+    with_option :on, :create, :update
 
-    with_conditional_option(:if)
-    with_conditional_option(:unless)
+    with_conditional_option :if
+    with_conditional_option :unless
   end
 end

data/spec/active_record/validate_uniqueness_of_spec.rb

@@ -1,23 +1,21 @@
-require 'spec_helper'
-
 describe :validate_uniqueness_of do
   let(:validator_name) { :uniqueness }
-  let(:default_options) { { :scope => :two } }
+  let(:default_options) { { scope: :two } }
 
   it_behaves_like 'a validation matcher' do
-    let(:model) do
-      build_class(:User) do
+    let(:model) {
+      build_class :User do
         include ActiveRecord::Validations
       end
-    end
+    }
 
-    with_option(:allow_blank, true, false)
-    with_option(:allow_nil, true, false)
-    with_option(:case_sensitive, true, false)
-    with_option(:message, 'is not unique!', 'invalid')
-    with_option(:scope, :two, :three)
+    with_option :allow_blank, true, false
+    with_option :allow_nil, true, false
+    with_option :case_sensitive, true, false
+    with_option :message, 'is not unique!', 'invalid'
+    with_option :scope, :two, :three
 
-    with_conditional_option(:if)
-    with_conditional_option(:unless)
+    with_conditional_option :if
+    with_conditional_option :unless
   end
 end

data/spec/spec_helper.rb

@@ -1,17 +1,15 @@
 require 'active_model'
 require 'active_record'
 
-$:.unshift(File.expand_path('../lib', File.dirname(__FILE__)))
 require 'remockable'
 
-# Requires supporting files with custom matchers and macros, etc.,
-# in ./support/ and its subdirectories.
+# Require supporting files with custom matchers and macros, etc.
 Dir[File.expand_path('../support/**/*.rb', __FILE__)].each do |file|
   require(file)
 end
 
 RSpec.configure do |config|
   config.mock_with :rspec
-  config.filter_run :focus => true
+  config.filter_run focus: true
   config.run_all_when_everything_filtered = true
 end

data/spec/support/active_record_example_group.rb

@@ -6,14 +6,13 @@ module ActiveRecordExampleGroup
 
     before do
       ActiveRecord::Base.establish_connection(
-        :adapter => 'sqlite3',
-        :database => ':memory:'
+        adapter: 'sqlite3',
+        database: ':memory:'
       )
     end
   end
 
   RSpec.configure do |config|
-    config.include self,
-      :example_group => { :file_path => /spec\/active_record/ }
+    config.include self, file_path: /spec\/active_record/
   end
 end

data/spec/support/class_builder.rb

@@ -1,4 +1,4 @@
-module ClassBuilder
+class_builder = Module.new do
   def build_class(name, superclass=Object, &block)
     Class.new(superclass) do
       class_eval <<-EVAL
@@ -7,33 +7,37 @@ module ClassBuilder
         end
       EVAL
 
-      class_eval(&block) if block_given?
+      class_eval &block if block_given?
     end
   end
 
   def create_table(table_name, options={}, &block)
     begin
-      drop_table(table_name)
-      ActiveRecord::Base.connection.create_table(table_name, options, &block)
-      (@created_tables ||= []) << table_name
+      drop_table table_name
+      ActiveRecord::Base.connection.create_table table_name, options, &block
+      created_tables << table_name
     rescue
-      drop_table(table_name)
-      raise $!
+      drop_table table_name
+      raise
     end
   end
 
+  def created_tables
+    @created_tables ||= []
+  end
+
   def drop_table(table_name)
-    ActiveRecord::Base.connection.execute("DROP TABLE IF EXISTS #{table_name}")
+    ActiveRecord::Base.connection.execute "DROP TABLE IF EXISTS #{table_name}"
   end
 
   def drop_created_tables
-    if @created_tables
-      @created_tables.each { |table_name| drop_table(table_name) }
+    created_tables.each do |table_name|
+      drop_table table_name
     end
   end
 end
 
 RSpec.configure do |config|
-  config.include(ClassBuilder)
+  config.include class_builder
   config.after { drop_created_tables }
 end

data/spec/support/shared/a_validation_matcher.rb

@@ -3,25 +3,25 @@ shared_examples_for 'a validation matcher' do
   let(:options) { default_options }
   let(:matcher_name) { self.class.parent.parent.description }
 
-  let(:model) do
-    build_class(:User) do
+  let(:model) {
+    build_class :User do
       include ActiveModel::Validations
     end
-  end
+  }
+
+  subject(:instance) { model.new }
 
   before do
-    model.validates(attribute, validator_name => options)
+    model.validates attribute, validator_name => options
   end
 
-  subject { model.new }
-
   def self.with_option(option_name, positive, negative, exclusive=false)
     context "with option #{option_name.inspect}" do
-      let(:options) do
+      let(:options) {
         option = { option_name => positive }
         merge_with_default = !exclusive && default_options.is_a?(Hash)
         merge_with_default ? default_options.merge(option) : option
-      end
+      }
 
       it 'matches if the options match' do
         should send(matcher_name, attribute, option_name => positive)
@@ -34,7 +34,7 @@ shared_examples_for 'a validation matcher' do
   end
 
   def self.with_option!(option_name, positive, negative)
-    with_option(option_name, positive, negative, true)
+    with_option option_name, positive, negative, true
   end
 
   def self.with_conditional_option(option_name)
@@ -54,7 +54,7 @@ shared_examples_for 'a validation matcher' do
     end
 
     context "with option #{option_name.inspect} with a procedure" do
-      let(:procedure) { lambda { |record| record.skip_validations } }
+      let(:procedure) { ->(record) { record.skip_validations } }
 
       let(:options) {
         option = { option_name => procedure }
@@ -62,12 +62,12 @@ shared_examples_for 'a validation matcher' do
       }
 
       it 'matches if the options match' do
-        subject.stub(:skip_validations).and_return(true)
+        allow(instance).to receive(:skip_validations).and_return(true)
         should send(matcher_name, attribute, option_name => true)
       end
 
       it 'does not match if the options do not match' do
-        subject.stub(:skip_validations).and_return(false)
+        allow(instance).to receive(:skip_validations).and_return(false)
         should_not send(matcher_name, attribute, option_name => true)
       end
     end
@@ -76,9 +76,8 @@ shared_examples_for 'a validation matcher' do
   def self.with_unsupported_option(option_name, value=nil)
     context "with unsupported option #{option_name.inspect}" do
       it 'raises an error' do
-        expect {
-          send(matcher_name, option_name => value)
-        }.to raise_error(ArgumentError, /unsupported.*:#{option_name}/i)
+        expect { should send(matcher_name, option_name => value) }
+          .to raise_error ArgumentError, /unsupported.*:#{option_name}/i
       end
     end
   end
@@ -88,25 +87,27 @@ shared_examples_for 'a validation matcher' do
 
     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} #{attribute}#{with}"
+      expect(matcher.description).to eq "#{name} #{attribute}#{with}"
     end
   end
 
   context 'failure messages' do
     let(:matcher) { send(matcher_name, attribute) }
 
-    before { matcher.matches?(subject) }
+    before do
+      matcher.matches?(instance)
+    end
 
     it 'has a custom failure message' do
-      matcher.failure_message_for_should.should ==
-        "Expected #{subject.class.name} to #{matcher.description}"
+      expect(matcher.failure_message)
+        .to eq "Expected #{instance.class.name} to #{matcher.description}"
     end
 
     it 'has a custom negative failure message' do
-      matcher.failure_message_for_should_not.should ==
-        "Did not expect #{subject.class.name} to #{matcher.description}"
+      expect(matcher.failure_message_when_negated)
+        .to eq "Did not expect #{instance.class.name} to #{matcher.description}"
     end
   end
 
@@ -122,9 +123,8 @@ shared_examples_for 'a validation matcher' do
 
   context 'with an unknown option' do
     it 'raises an error' do
-      expect {
-        send(matcher_name, :xxx => true)
-      }.to raise_error(ArgumentError, /unknown.*:xxx/i)
+      expect { should send(matcher_name, xxx: true) }
+        .to raise_error ArgumentError, /unknown.*:xxx/i
     end
   end
 end

data/spec/support/shared/an_active_record_matcher.rb

@@ -5,7 +5,9 @@ shared_examples_for 'an Active Record matcher' do
     context "with option #{option_name.inspect}" do
       let(:options) { [:company, context.merge(option_name => positive)] }
 
-      before { model.send(macro, *options) }
+      before do
+        model.send macro, *options
+      end
 
       it 'matches if the options match' do
         should send(matcher_name, :company, option_name => positive)
@@ -20,9 +22,8 @@ shared_examples_for 'an Active Record matcher' do
   def self.with_unsupported_option(option_name, value=nil)
     context "with unsupported option #{option_name.inspect}" do
       it 'raises an error' do
-        expect {
-          send(matcher_name, :company, option_name => value)
-        }.to raise_error(ArgumentError, /unsupported.*:#{option_name}/i)
+        expect { should send(matcher_name, :company, option_name => value) }
+          .to raise_error ArgumentError, /unsupported.*:#{option_name}/i
       end
     end
   end
@@ -30,24 +31,25 @@ shared_examples_for 'an Active Record matcher' do
   context 'failure messages' do
     let(:matcher) { send(matcher_name, *options) }
 
-    before { matcher.matches?(subject) }
+    before do
+      matcher.matches? subject
+    end
 
     it 'has a custom failure message' do
-      matcher.failure_message_for_should.should ==
-        "Expected #{subject.class.name} to #{matcher.description}"
+      expect(matcher.failure_message)
+        .to eq "Expected #{subject.class.name} to #{matcher.description}"
     end
 
     it 'has a custom negative failure message' do
-      matcher.failure_message_for_should_not.should ==
-        "Did not expect #{subject.class.name} to #{matcher.description}"
+      expect(matcher.failure_message_when_negated)
+        .to eq "Did not expect #{subject.class.name} to #{matcher.description}"
     end
   end
 
   context 'with an unknown option' do
     it 'raises an error' do
-      expect {
-        send(matcher_name, :xxx => true)
-      }.to raise_error(ArgumentError, /unknown.*:xxx/i)
+      expect { should send(matcher_name, xxx: true) }
+        .to raise_error ArgumentError, /unknown.*:xxx/i
     end
   end
 end