remockable 0.2.1 → 0.3.0

data/spec/active_model/allow_values_for_spec.rb

@@ -1,38 +1,44 @@
-require 'spec_helper'
-
 describe :allow_values_for do
   let(:attribute) { :one }
   let(:values) { ['123'] }
   let(:matcher_name) { self.class.parent.description }
 
-  let(:model) do
-    build_class(:User) { include ActiveModel::Validations }
-  end
+  let(:model) {
+    build_class :User do
+      include ActiveModel::Validations
+    end
+  }
 
-  before { model.validates(attribute, :format => /\A\d+\Z/) }
+  subject(:instance) { model.new }
 
-  subject { model.new }
+  before do
+    model.validates attribute, format: /\A\d+\Z/
+  end
 
   context 'description' do
     it 'has a custom description' do
       matcher = allow_values_for(attribute, *values)
-      matcher.description.should == "allow the values #{values.collect(&:inspect).to_sentence} for #{attribute}"
+
+      expect(matcher.description)
+        .to eq "allow the values #{values.collect(&:inspect).to_sentence} for #{attribute}"
     end
   end
 
   context 'failure messages' do
     let(:matcher) { allow_values_for(attribute, *values) }
 
-    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
 

data/spec/active_model/validate_acceptance_of_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 describe :validate_acceptance_of do
   let(:validator_name) { :acceptance }
   let(:default_options) { true }

data/spec/active_model/validate_confirmation_of_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 describe :validate_confirmation_of do
   let(:validator_name) { :confirmation }
   let(:default_options) { true }

data/spec/active_model/validate_exclusion_of_spec.rb

@@ -1,16 +1,14 @@
-require 'spec_helper'
-
 describe :validate_exclusion_of do
   let(:validator_name) { :exclusion }
-  let(:default_options) { { :in => [true, false] } }
+  let(:default_options) { { in: [true, false] } }
 
   it_behaves_like 'a validation matcher' do
-    with_option(:allow_blank, true, false)
-    with_option(:allow_nil, true, false)
-    with_option(:in, [true, false], %w(male female))
-    with_option(:message, 'is in list!', 'invalid')
+    with_option :allow_blank, true, false
+    with_option :allow_nil, true, false
+    with_option :in, [true, false], %w(male female)
+    with_option :message, 'is in list!', 'invalid'
 
-    with_conditional_option(:if)
-    with_conditional_option(:unless)
+    with_conditional_option :if
+    with_conditional_option :unless
   end
 end

data/spec/active_model/validate_format_of_spec.rb

@@ -1,18 +1,16 @@
-require 'spec_helper'
-
 describe :validate_format_of do
   let(:validator_name) { :format }
-  let(:default_options) { { :with => /\d+/ } }
+  let(:default_options) { { with: /\d+/ } }
 
   it_behaves_like 'a validation matcher' do
-    with_option(:allow_blank, true, false)
-    with_option(:allow_nil, true, false)
-    with_option(:message, 'is the wrong format!', 'invalid')
-    with_option(:on, :create, :update)
-    with_option!(:with, /\d+/, /\w+/)
-    with_option!(:without, /\d+/, /\w+/)
+    with_option :allow_blank, true, false
+    with_option :allow_nil, true, false
+    with_option :message, 'is the wrong format!', 'invalid'
+    with_option :on, :create, :update
+    with_option! :with, /\d+/, /\w+/
+    with_option! :without, /\d+/, /\w+/
 
-    with_conditional_option(:if)
-    with_conditional_option(:unless)
+    with_conditional_option :if
+    with_conditional_option :unless
   end
 end

data/spec/active_model/validate_inclusion_of_spec.rb

@@ -1,16 +1,14 @@
-require 'spec_helper'
-
 describe :validate_inclusion_of do
   let(:validator_name) { :inclusion }
-  let(:default_options) { { :in => [true, false] } }
+  let(:default_options) { { in: [true, false] } }
 
   it_behaves_like 'a validation matcher' do
-    with_option(:allow_blank, true, false)
-    with_option(:allow_nil, true, false)
-    with_option(:in, [true, false], %w(male female))
-    with_option(:message, 'is not in list!', 'invalid')
+    with_option :allow_blank, true, false
+    with_option :allow_nil, true, false
+    with_option :in, [true, false], %w(male female)
+    with_option :message, 'is not in list!', 'invalid'
 
-    with_conditional_option(:if)
-    with_conditional_option(:unless)
+    with_conditional_option :if
+    with_conditional_option :unless
   end
 end

data/spec/active_model/validate_length_of_spec.rb

@@ -1,26 +1,24 @@
-require 'spec_helper'
-
 describe :validate_length_of do
   let(:validator_name) { :length }
-  let(:default_options) { { :is => 5 } }
+  let(:default_options) { { is: 5 } }
 
   it_behaves_like 'a validation matcher' do
-    with_option(:allow_blank, true, false)
-    with_option(:allow_nil, true, false)
-    with_option(:in, 1..10, 1..5)
-    with_option(:is, 5, 10)
-    with_option(:maximum, 5, 10)
-    with_option(:message, 'is the wrong length!', 'invalid')
-    with_option(:minimum, 5, 10)
-    with_option(:on, :create, :update)
-    with_option(:too_long, 'is too long!', 'invalid')
-    with_option(:too_short, 'is too short!', 'invalid')
-    with_option(:within, 1..10, 1..5)
-    with_option(:wrong_length, 'is not five!', 'invalid')
+    with_option :allow_blank, true, false
+    with_option :allow_nil, true, false
+    with_option :in, 1..10, 1..5
+    with_option :is, 5, 10
+    with_option :maximum, 5, 10
+    with_option :message, 'is the wrong length!', 'invalid'
+    with_option :minimum, 5, 10
+    with_option :on, :create, :update
+    with_option :too_long, 'is too long!', 'invalid'
+    with_option :too_short, 'is too short!', 'invalid'
+    with_option :within, 1..10, 1..5
+    with_option :wrong_length, 'is not five!', 'invalid'
 
-    with_conditional_option(:if)
-    with_conditional_option(:unless)
+    with_conditional_option :if
+    with_conditional_option :unless
 
-    with_unsupported_option(:tokenizer, lambda { |string| string.scan(/\w+/) })
+    with_unsupported_option :tokenizer, ->(string) { string.scan(/\w+/) }
   end
 end

data/spec/active_model/validate_numericality_of_spec.rb

@@ -1,23 +1,21 @@
-require 'spec_helper'
-
 describe :validate_numericality_of do
   let(:validator_name) { :numericality }
-  let(:default_options) { { :only_integer => true } }
+  let(:default_options) { { only_integer: true } }
 
   it_behaves_like 'a validation matcher' do
-    with_option(:allow_nil, true, false)
-    with_option(:equal_to, 5, 10)
-    with_option(:even, true, false)
-    with_option(:greater_than, 5, 10)
-    with_option(:greater_than_or_equal_to, 5, 10)
-    with_option(:less_than, 5, 10)
-    with_option(:less_than_or_equal_to, 5, 10)
-    with_option(:message, 'is the wrong numericality!', 'invalid')
-    with_option(:odd, true, false)
-    with_option(:on, :create, :update)
-    with_option(:only_integer, true, false)
+    with_option :allow_nil, true, false
+    with_option :equal_to, 5, 10
+    with_option :even, true, false
+    with_option :greater_than, 5, 10
+    with_option :greater_than_or_equal_to, 5, 10
+    with_option :less_than, 5, 10
+    with_option :less_than_or_equal_to, 5, 10
+    with_option :message, 'is the wrong numericality!', 'invalid'
+    with_option :odd, true, false
+    with_option :on, :create, :update
+    with_option :only_integer, true, false
 
-    with_conditional_option(:if)
-    with_conditional_option(:unless)
+    with_conditional_option :if
+    with_conditional_option :unless
   end
 end

data/spec/active_model/validate_presence_of_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 describe :validate_presence_of do
   let(:validator_name) { :presence }
   let(:default_options) { true }

data/spec/active_record/accept_nested_attributes_for_spec.rb

@@ -1,27 +1,31 @@
-require 'spec_helper'
-
 describe :accept_nested_attributes_for do
   let(:macro) { :accepts_nested_attributes_for }
-  let(:options) { [:company, { :allow_destroy => true }] }
+  let(:options) { [:company, { allow_destroy: true }] }
 
   it_behaves_like 'an Active Record matcher' do
     let(:matcher_name) { :accept_nested_attributes_for }
 
-    let(:model) do
-      build_class(:User, ActiveRecord::Base) { belongs_to :company }
-    end
+    let(:model) {
+      build_class :User, ActiveRecord::Base do
+        belongs_to :company
+      end
+    }
 
-    before { create_table(:users) }
+    subject(:instance) { model.new }
 
-    subject { model.new }
+    before do
+      create_table :users
+    end
 
     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 == "accept nested attributes for #{association}#{with}"
+        association = matcher.attribute
+        with = " with #{matcher.options.inspect}" if matcher.options.any?
+
+        expect(matcher.description)
+          .to eq "accept nested attributes for #{association}#{with}"
       end
     end
 
@@ -29,19 +33,19 @@ describe :accept_nested_attributes_for do
       let(:options) { :company }
 
       it 'matches if the model accepts the nested attributes' do
-        model.accepts_nested_attributes_for(*options)
-        model.should accept_nested_attributes_for(*options)
+        model.accepts_nested_attributes_for *options
+        expect(model).to accept_nested_attributes_for *options
       end
 
       it 'does not match if the model does not accept the nested attributes' do
-        model.should_not accept_nested_attributes_for(*options)
+        expect(model).to_not accept_nested_attributes_for *options
       end
     end
 
-    with_option(:allow_destroy, true, false)
-    with_option(:limit, 1, 2)
-    with_option(:update_only, true, false)
+    with_option :allow_destroy, true, false
+    with_option :limit, 1, 2
+    with_option :update_only, true, false
 
-    with_unsupported_option(:reject_if, :all_blank)
+    with_unsupported_option :reject_if, :all_blank
   end
 end

data/spec/active_record/belong_to_spec.rb

@@ -1,26 +1,26 @@
-require 'spec_helper'
-
 describe :belong_to do
   let(:macro) { :belongs_to }
-  let(:options) { [:company, { :dependent => :destroy }] }
+  let(:options) { [:company, { 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.integer(:company_id) }
+      create_table :users do |table|
+        table.integer :company_id
+      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(/_/, ' ')
-        association = matcher.instance_variable_get(:@association)
-        with = " with #{matcher.expected.inspect}" if matcher.expected.any?
-        matcher.description.should == "#{name} #{association}#{with}"
+        association = matcher.attribute
+        with = " with #{matcher.options.inspect}" if matcher.options.any?
+
+        expect(matcher.description).to eq "belong to #{association}#{with}"
       end
     end
 
@@ -28,30 +28,30 @@ describe :belong_to do
       let(:options) { :company }
 
       it 'matches if the association exists' do
-        model.belongs_to(*options)
-        model.should belong_to(*options)
+        model.belongs_to *options
+        expect(model).to belong_to *options
       end
 
       it 'does not match if the association does not exist' do
-        model.should_not belong_to(*options)
+        expect(model).to_not belong_to *options
       end
 
       it 'does not match if the association is of the wrong type' do
-        model.has_many(*options)
-        model.should_not belong_to(*options)
+        model.has_many *options
+        expect(model).to_not belong_to *options
       end
     end
 
-    with_option(:class_name, 'Company', 'Organization')
-    with_option(:foreign_key, :company_id, :organization_id)
-    with_option(:foreign_type, :company_type, :organization_type)
-    with_option(:primary_key, :id, :company_id)
-    with_option(:dependent, :destroy, :nullify)
-    with_option(:counter_cache, true, false)
-    with_option(:polymorphic, true, false)
-    with_option(:validate, true, false)
-    with_option(:autosave, true, false)
-    with_option(:touch, true, false)
-    with_option(:inverse_of, :users, :employees)
+    with_option :class_name, 'Company', 'Organization'
+    with_option :foreign_key, :company_id, :organization_id
+    with_option :foreign_type, :company_type, :organization_type
+    with_option :primary_key, :id, :company_id
+    with_option :dependent, :destroy, :nullify
+    with_option :counter_cache, true, false
+    with_option :polymorphic, true, false
+    with_option :validate, true, false
+    with_option :autosave, true, false
+    with_option :touch, true, false
+    with_option :inverse_of, :users, :employees
   end
 end

data/spec/active_record/have_and_belong_to_many_spec.rb

@@ -1,25 +1,27 @@
-require 'spec_helper'
-
 describe :have_and_belong_to_many do
   let(:macro) { :has_and_belongs_to_many }
-  let(:options) { [:tags, { :validate => true }] }
+  let(:options) { [:tags, { validate: true }] }
 
   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 and belong to #{association}#{with}"
+        association = matcher.attribute
+        with = " with #{matcher.options.inspect}" if matcher.options.any?
+
+        expect(matcher.description)
+          .to eq "have and belong to #{association}#{with}"
       end
     end
 
@@ -27,25 +29,25 @@ describe :have_and_belong_to_many do
       let(:options) { :tags }
 
       it 'matches if the association exists' do
-        model.has_and_belongs_to_many(*options)
-        model.should have_and_belong_to_many(*options)
+        model.has_and_belongs_to_many *options
+        expect(model).to have_and_belong_to_many *options
       end
 
       it 'does not match if the association does not exist' do
-        model.should_not have_and_belong_to_many(*options)
+        expect(model).to_not have_and_belong_to_many *options
       end
 
       it 'does not match if the association is of the wrong type' do
-        model.has_many(*options)
-        model.should_not have_and_belong_to_many(*options)
+        model.has_many *options
+        expect(model).to_not have_and_belong_to_many *options
       end
     end
 
-    with_option(:class_name, 'Tag', 'Role')
-    with_option(:join_table, 'tags_users', 'user_tags')
-    with_option(:foreign_key, :user_id, :tagged_id)
-    with_option(:association_foreign_key, :tag_id, :role_id)
-    with_option(:validate, true, false)
-    with_option(:autosave, true, false)
+    with_option :class_name, 'Tag', 'Role'
+    with_option :join_table, 'tags_users', 'user_tags'
+    with_option :foreign_key, :user_id, :tagged_id
+    with_option :association_foreign_key, :tag_id, :role_id
+    with_option :validate, true, false
+    with_option :autosave, true, false
   end
 end

data/spec/active_record/have_column_spec.rb

@@ -1,108 +1,105 @@
-require 'spec_helper'
-
 describe :have_column 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| }
+      create_table :users
     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} #{options}#{with}"
+        expect(matcher.description).to eq "have column #{options}#{with}"
       end
     end
 
     context 'with a column' do
       it 'matches if the column exists' do
-        ActiveRecord::Base.connection.add_column(:users, :one, :string)
-        model.should have_column(:one)
+        ActiveRecord::Base.connection.add_column :users, :one, :string
+        expect(model).to have_column :one
       end
 
       it 'does not match if the column does not exist' do
-        model.should_not have_column(:one)
+        expect(model).to_not have_column :one
       end
     end
 
     context 'with option :default' do
       it 'matches if the column exists' do
-        ActiveRecord::Base.connection.add_column(:users, :one, :integer, :default => 1)
-        model.should have_column(:one, :default => 1)
+        ActiveRecord::Base.connection.add_column :users, :one, :integer, default: 1
+        expect(model).to have_column :one, default: 1
       end
 
       it 'does not match if the column does not have the same default' do
-        ActiveRecord::Base.connection.add_column(:users, :one, :integer, :default => 2)
-        model.should_not have_column(:one, :default => 1)
+        ActiveRecord::Base.connection.add_column :users, :one, :integer, default: 2
+        expect(model).to_not have_column :one, default: 1
       end
     end
 
     context 'with option :limit' do
       it 'matches if the column exists' do
-        ActiveRecord::Base.connection.add_column(:users, :one, :string, :limit => 10)
-        model.should have_column(:one, :limit => 10)
+        ActiveRecord::Base.connection.add_column :users, :one, :string, limit: 10
+        expect(model).to have_column :one, limit: 10
       end
 
       it 'does not match if the column does not have the same limit' do
-        ActiveRecord::Base.connection.add_column(:users, :one, :string, :limit => 5)
-        model.should_not have_column(:one, :limit => 10)
+        ActiveRecord::Base.connection.add_column :users, :one, :string, limit: 5
+        expect(model).to_not have_column :one, limit: 10
       end
     end
 
     context 'with option :null' do
       it 'matches if the column exists' do
-        ActiveRecord::Base.connection.add_column(:users, :one, :integer, :null => false, :default => 1)
-        model.should have_column(:one, :null => false)
+        ActiveRecord::Base.connection.add_column :users, :one, :integer, null: false, default: 1
+        expect(model).to have_column :one, null: false
       end
 
       it 'does not match if the column does not have the same null' do
-        ActiveRecord::Base.connection.add_column(:users, :one, :integer)
-        model.should_not have_column(:one, :null => false)
+        ActiveRecord::Base.connection.add_column :users, :one, :integer
+        expect(model).to_not have_column :one, null: false
       end
     end
 
     context 'with option :precision' do
       it 'matches if the column exists' do
-        ActiveRecord::Base.connection.add_column(:users, :one, :decimal, :precision => 8)
-        model.should have_column(:one, :precision => 8)
+        ActiveRecord::Base.connection.add_column :users, :one, :decimal, precision: 8
+        expect(model).to have_column :one, precision: 8
       end
 
       it 'does not match if the column does not have the same null' do
-        ActiveRecord::Base.connection.add_column(:users, :one, :decimal, :precision => 8)
-        model.should_not have_column(:one, :precision => 5)
+        ActiveRecord::Base.connection.add_column :users, :one, :decimal, precision: 8
+        expect(model).to_not have_column :one, precision: 5
       end
     end
 
     context 'with option :scale' do
       it 'matches if the column exists' do
-        ActiveRecord::Base.connection.add_column(:users, :one, :decimal, :precision => 8, :scale => 2)
-        model.should have_column(:one, :scale => 2)
+        ActiveRecord::Base.connection.add_column :users, :one, :decimal, precision: 8, scale: 2
+        expect(model).to have_column :one, scale: 2
       end
 
       it 'does not match if the column does not have the same null' do
-        ActiveRecord::Base.connection.add_column(:users, :one, :decimal, :precision => 8, :scale => 2)
-        model.should_not have_column(:one, :scale => 3)
+        ActiveRecord::Base.connection.add_column :users, :one, :decimal, precision: 8, scale: 2
+        expect(model).to_not have_column :one, scale: 3
       end
     end
 
     context 'with option :type' do
       it 'matches if the column exists' do
-        ActiveRecord::Base.connection.add_column(:users, :one, :integer)
-        model.should have_column(:one, :type => :integer)
+        ActiveRecord::Base.connection.add_column :users, :one, :integer
+        expect(model).to have_column :one, type: :integer
       end
 
       it 'does not match if the column does not have the same type' do
-        ActiveRecord::Base.connection.add_column(:users, :one, :string)
-        model.should_not have_column(:one, :type => :integer)
+        ActiveRecord::Base.connection.add_column :users, :one, :string
+        expect(model).to_not have_column :one, type: :integer
       end
     end
   end