remockable 0.1.1 → 0.1.2

data/spec/active_record/have_scope_spec.rb

@@ -0,0 +1,229 @@
+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) }
+
+    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 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)
+      end
+
+      it 'does not match if the scope does not exist' do
+        model.should_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)
+      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)
+      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')
+      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')
+      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')
+      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')
+      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')
+      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')
+      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)
+      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)
+      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')
+      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')
+      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)
+      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)
+      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)
+      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)
+      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)
+      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)
+      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')
+      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')
+      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)
+      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)
+      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)
+      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)
+      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')
+      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')
+      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')
+      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')
+      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)
+      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)
+      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)
+      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)
+      end
+    end
+  end
+end

data/spec/active_record/validate_associated_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe :validate_associated do
+  let(:validator_name) { :associated }
+  let(:attribute) { :company }
+  let(:default_options) { { :on => :create } }
+
+  before do
+    create_table(:users) { |table| table.string(:company_id) }
+  end
+
+  it_behaves_like 'a validation matcher' do
+    let(:model) do
+      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_conditional_option(:if)
+    with_conditional_option(:unless)
+  end
+end

data/spec/active_record/validate_uniqueness_of_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe :validate_uniqueness_of do
+  let(:validator_name) { :uniqueness }
+  let(:default_options) { { :scope => :two } }
+
+  it_behaves_like 'a validation matcher' do
+    let(:model) do
+      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_conditional_option(:if)
+    with_conditional_option(:unless)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+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.
+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.run_all_when_everything_filtered = true
+end

data/spec/support/active_record_example_group.rb

@@ -0,0 +1,22 @@
+module ActiveRecordExampleGroup
+  extend ActiveSupport::Concern
+
+  included do
+    metadata[:type] = :active_record
+
+    let(:rake) { Rake::Application.new }
+    let(:task) { rake[self.class.description] }
+    let(:namespace) { self.class.description.split(':').first }
+
+    before do
+      ActiveRecord::Base.establish_connection(
+        :adapter => 'sqlite3',
+        :database => ':memory:'
+      )
+    end
+  end
+
+  RSpec.configure do |config|
+    config.include self, :example_group => { :file_path => /spec\/active_record/ }
+  end
+end

data/spec/support/class_builder.rb

@@ -0,0 +1,39 @@
+module ClassBuilder
+  def build_class(name, superclass=Object, &block)
+    Class.new(superclass) do
+      class_eval <<-EVAL
+        def self.name
+          '#{name}'
+        end
+      EVAL
+
+      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
+    rescue
+      drop_table(table_name)
+      raise $!
+    end
+  end
+
+  def drop_table(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) }
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include(ClassBuilder)
+  config.after { drop_created_tables }
+end

data/spec/support/shared/a_validation_matcher.rb

@@ -0,0 +1,130 @@
+shared_examples_for 'a validation matcher' do
+  let(:attribute) { :one }
+  let(:options) { default_options }
+  let(:matcher_name) { self.class.parent.parent.description }
+
+  let(:model) do
+    build_class(:User) do
+      include ActiveModel::Validations
+    end
+  end
+
+  before do
+    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
+        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)
+      end
+
+      it 'does not match if the options do not match' do
+        should_not send(matcher_name, attribute, option_name => negative)
+      end
+    end
+  end
+
+  def self.with_option!(option_name, positive, negative)
+    with_option(option_name, positive, negative, true)
+  end
+
+  def self.with_conditional_option(option_name)
+    context "with option #{option_name.inspect} with a symbol" do
+      let(:options) {
+        option = { option_name => :returns_true }
+        default_options.is_a?(Hash) ? default_options.merge(option) : option
+      }
+
+      it 'matches if the options match' do
+        should send(matcher_name, attribute, option_name => :returns_true)
+      end
+
+      it 'does not match if the options do not match' do
+        should_not send(matcher_name, attribute, option_name => :returns_false)
+      end
+    end
+
+    context "with option #{option_name.inspect} with a procedure" do
+      let(:procedure) { lambda { |record| record.skip_validations } }
+
+      let(:options) {
+        option = { option_name => procedure }
+        default_options.is_a?(Hash) ? default_options.merge(option) : option
+      }
+
+      it 'matches if the options match' do
+        subject.stub(: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)
+        should_not send(matcher_name, attribute, option_name => true)
+      end
+    end
+  end
+
+  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)
+      end
+    end
+  end
+
+  context 'description' do
+    let(:matcher) { send(matcher_name, attribute) }
+
+    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} #{attribute}#{with}"
+    end
+  end
+
+  context 'failure messages' do
+    let(:matcher) { send(matcher_name, attribute) }
+
+    before { matcher.matches?(subject) }
+
+    it 'has a custom failure message' do
+      matcher.failure_message_for_should.should ==
+        "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}"
+    end
+  end
+
+  context 'without options' do
+    it 'matches if the validator has been defined' do
+      should send(matcher_name, :one)
+    end
+
+    it 'does not match if the validator has not been defined' do
+      should_not send(matcher_name, :two)
+    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)
+    end
+  end
+end

data/spec/support/shared/an_active_record_matcher.rb

@@ -0,0 +1,53 @@
+shared_examples_for 'an Active Record matcher' do
+  let(:matcher_name) { self.class.parent.parent.description }
+
+  def self.with_option(option_name, positive, negative)
+    context "with option #{option_name.inspect}" do
+      let(:options) { [:company, { option_name => positive }] }
+
+      before { model.send(macro, *options) }
+
+      it 'matches if the options match' do
+        should send(matcher_name, :company, option_name => positive)
+      end
+
+      it 'does not match if the options do not match' do
+        should_not send(matcher_name, :company, option_name => negative)
+      end
+    end
+  end
+
+  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)
+      end
+    end
+  end
+
+  context 'failure messages' do
+    let(:matcher) { send(matcher_name, *options) }
+
+    before { matcher.matches?(subject) }
+
+    it 'has a custom failure message' do
+      matcher.failure_message_for_should.should ==
+        "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}"
+    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)
+    end
+  end
+end