remockable 0.1.1 → 0.1.2

data/spec/active_record/have_column_spec.rb

@@ -0,0 +1,109 @@
+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) }
+
+    before do
+      create_table(:users) { |table| }
+    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?
+
+        matcher.description.should == "#{name} #{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)
+      end
+
+      it 'does not match if the column does not exist' do
+        model.should_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)
+      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)
+      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)
+      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)
+      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)
+      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)
+      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)
+      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)
+      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)
+      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)
+      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)
+      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)
+      end
+    end
+  end
+end

data/spec/active_record/have_default_scope_spec.rb

@@ -0,0 +1,169 @@
+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) }
+
+    before do
+      create_table(:users) { |table| table.string(:one) }
+    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?
+
+        matcher.description.should == "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
+      end
+
+      it 'does not match if a default scope does not exist' do
+        model.should_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')
+      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')
+      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')
+      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')
+      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')
+      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')
+      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')
+      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')
+      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')
+      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')
+      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)
+      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)
+      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)
+      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)
+      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')
+      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')
+      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')
+      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')
+      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')
+      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')
+      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)
+      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)
+      end
+    end
+  end
+end

data/spec/active_record/have_index_spec.rb

@@ -0,0 +1,89 @@
+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) }
+
+    before do
+      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?
+
+        matcher.description.should == "#{name} 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)
+      end
+
+      it 'does not match if the index does not exist' do
+        model.should_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])
+      end
+
+      it 'does not match if the index does not exist' do
+        model.should_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)
+      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)
+      end
+
+      it 'does not match if the index does not exist' do
+        model.should_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)
+      end
+
+      it 'does not match if the index does not exist' do
+        model.should_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)
+      end
+
+      it 'does not match if the index does not exist' do
+        model.should_not have_index(:name => :oneness)
+      end
+    end
+  end
+end

data/spec/active_record/have_many_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe :have_many do
+  let(:macro) { :has_many }
+  let(:options) { [:posts, { :dependent => :destroy }] }
+
+  it_behaves_like 'an Active Record matcher' do
+    let(:model) { build_class(:User, ActiveRecord::Base) }
+
+    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}"
+      end
+    end
+
+    context 'with no options' do
+      let(:options) { :posts }
+
+      it 'matches if the association exists' do
+        model.has_many(*options)
+        model.should have_many(*options)
+      end
+
+      it 'does not match if the association does not exist' do
+        model.should_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)
+      end
+    end
+
+    with_option(:class_name, 'Post', 'Blog')
+    with_option(:conditions, { :published => true }, { :published => false })
+    with_option(:order, %w(published_at), %w(title))
+    with_option(:foreign_key, :post_id, :blog_id)
+    with_option(:primary_key, :id, :post_id)
+    with_option(:dependent, :destroy, :nullify)
+    with_option(:finder_sql, 'SELECT * FROM posts', 'SELECT * FROM blogs')
+    with_option(:counter_sql, 'SELECT COUNT(*) FROM posts', 'SELECT COUNT(*) FROM blogs')
+    with_option(:include, :comments, :trackbacks)
+    with_option(:group, 'comments_count', 'trackbacks_count')
+    with_option(:having, 'comments_count > 5', 'trackbacks_count > 5')
+    with_option(:limit, 5, 10)
+    with_option(:offset, 10, 20)
+    with_option(:select, %w(id), %w(title))
+    with_option(:as, :postable, :bloggable)
+    with_option(:through, :postings, :bloggings)
+    with_option(:source, :piece, :work)
+    with_option(:source_type, 'Post', 'Blog')
+    with_option(:uniq, true, false)
+    with_option(:readonly, true, false)
+    with_option(:validate, true, false)
+    with_option(:autosave, true, false)
+    with_option(:inverse_of, :users, :employees)
+
+    with_unsupported_option(:extend, Module.new)
+  end
+end

data/spec/active_record/have_one_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe :have_one do
+  let(:macro) { :has_one }
+  let(:options) { [:address, { :dependent => :destroy }] }
+
+  it_behaves_like 'an Active Record matcher' do
+    let(:model) { build_class(:User, ActiveRecord::Base) }
+
+    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 a #{association}#{with}"
+      end
+    end
+
+    context 'with no options' do
+      let(:options) { :address }
+
+      it 'matches if the association exists' do
+        model.has_one(*options)
+        model.should have_one(*options)
+      end
+
+      it 'does not match if the association does not exist' do
+        model.should_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)
+      end
+    end
+
+    with_option(:class_name, 'Address', 'Location')
+    with_option(:conditions, { :id => 1 }, { :id => 2 })
+    with_option(:order, %w(id), %w(name))
+    with_option(:dependent, :destroy, :nullify)
+    with_option(:foreign_key, :address_id, :location_id)
+    with_option(:primary_key, :id, :address_id)
+    with_option(:include, :country, :state)
+    with_option(:as, :addressable, :locatable)
+    with_option(:select, %w(id), %w(name))
+    with_option(:through, :offices, :locations)
+    with_option(:readonly, true, false)
+    with_option(:validate, true, false)
+    with_option(:autosave, true, false)
+    with_option(:inverse_of, :user, :employee)
+
+    with_unsupported_option(:extend, Module.new)
+  end
+end