shoulda-matchers 1.5.6 → 2.0.0

data/spec/shoulda/matchers/active_model/validate_format_of_matcher_spec.rb

@@ -1,75 +0,0 @@
-require 'spec_helper'
-
-describe Shoulda::Matchers::ActiveModel::ValidateFormatOfMatcher do
-  context 'a model with a format validation' do
-    it 'accepts when format matches ' do
-      validating_format(:with => /^\d{5}$/).should matcher.with('12345')
-    end
-
-    it 'rejects blank with should_not' do
-      validating_format(:with => /^\d{5}$/).should_not matcher.with(' ')
-    end
-
-    it 'rejects blank with not_with' do
-      validating_format(:with => /^\d{5}$/).should matcher.not_with(' ')
-    end
-
-    it 'rejects nil' do
-      validating_format(:with => /^\d{5}$/).should_not matcher.with(nil)
-    end
-
-    it 'rejects a non-matching format with should_not' do
-      validating_format(:with => /^\d{5}$/).should_not matcher.with('1234a')
-    end
-
-    it 'rejects a non-matching format with not_with' do
-      validating_format(:with => /^\d{5}$/).should matcher.not_with('1234a')
-    end
-
-    it 'raises an error if you try to call both with and not_with' do
-      expect {
-        validate_format_of(:attr).not_with('123456').with('12345')
-      }.to raise_error(RuntimeError)
-    end
-  end
-
-  context 'when allow_blank or allow_nil are set' do
-    it 'is valid when attr is nil' do
-      validating_format(:with => /abc/, :allow_nil => true).
-        should matcher.with(nil)
-    end
-
-    it 'is valid when attr is blank' do
-      validating_format(:with => /abc/, :allow_blank => true).
-        should matcher.with(' ')
-    end
-  end
-
-  context '#allow_blank' do
-    it 'accepts when allow_blank matches' do
-      validating_format(:with => /abc/, :allow_blank => true).
-        should matcher.allow_blank
-    end
-
-    it 'rejects when allow_blank does not match' do
-      validating_format(:with => /abc/, :allow_blank => false).
-        should_not matcher.allow_blank
-    end
-  end
-
-  context '#allow_nil' do
-    it 'accepts when allow_nil matches' do
-      validating_format(:with => /abc/, :allow_nil => true).
-        should matcher.allow_nil
-    end
-
-    it 'rejects when allow_nil does not match' do
-      validating_format(:with => /abc/, :allow_nil => false).
-        should_not matcher.allow_nil
-    end
-  end
-
-  def matcher
-    validate_format_of(:attr)
-  end
-end

data/spec/shoulda/matchers/active_record/query_the_database_matcher_spec.rb

@@ -1,45 +0,0 @@
-require 'spec_helper'
-
-describe Shoulda::Matchers::ActiveRecord::QueryTheDatabaseMatcher do
-  before do
-    @parent = define_model :litter do
-      has_many :kittens
-    end
-    @child = define_model :kitten, :litter_id => :integer do
-      belongs_to :litter
-    end
-  end
-
-  it 'accepts the correct number of queries when there is a single query' do
-    @parent.should query_the_database(1.times).when_calling(:count)
-  end
-
-  it 'accepts any number of queries when no number is specified' do
-    @parent.should query_the_database.when_calling(:count)
-  end
-
-  it 'rejects any number of queries when no number is specified' do
-    @parent.should_not query_the_database.when_calling(:to_s)
-  end
-
-  it 'accepts the correct number of queries when there are two queries' do
-    nonsense = lambda do
-      @parent.create.kittens.create
-    end
-    nonsense.should query_the_database(2.times).when_calling(:call)
-  end
-
-  it 'rejects the wrong number of queries' do
-    @parent.should_not query_the_database(10.times).when_calling(:count)
-  end
-
-  it 'accepts fewer than the specified maximum' do
-    @parent.should query_the_database(5.times).or_less.when_calling(:count)
-  end
-
-  it 'passes arguments to the method to examine' do
-    model = stub('Model', :count => nil)
-    model.should_not query_the_database.when_calling(:count).with('arguments')
-    model.should have_received(:count).with('arguments')
-  end
-end

data/spec/shoulda/matchers/independent/delegate_matcher_spec.rb

@@ -1,204 +0,0 @@
-require 'spec_helper'
-
-describe Shoulda::Matchers::Independent::DelegateMatcher do
-  context '#description' do
-    context 'by default' do
-      it 'states that it should delegate method to the right object' do
-        matcher = delegate_method(:method_name).to(:target)
-
-        matcher.description.should == 'delegate method #method_name to :target'
-      end
-    end
-
-    context 'with #as chain' do
-      it 'states that it should delegate method to the right object and method' do
-        matcher = delegate_method(:method_name).to(:target).as(:alternate)
-
-        matcher.description.should == 'delegate method #method_name to :target as #alternate'
-      end
-    end
-
-    context 'with #with_argument chain' do
-      it 'states that it should delegate method to the right object with right argument' do
-        matcher = delegate_method(:method_name).to(:target).with_arguments(:foo, :bar => [1, 2])
-
-        matcher.description.should ==
-          'delegate method #method_name to :target with arguments: [:foo, {:bar=>[1, 2]}]'
-      end
-    end
-  end
-
-  it 'supports chaining on #to' do
-    matcher = delegate_method(:method)
-
-    matcher.to(:another_method).should == matcher
-  end
-
-  it 'supports chaining on #with_arguments' do
-    matcher = delegate_method(:method)
-
-    matcher.with_arguments(1, 2, 3).should == matcher
-  end
-
-  it 'supports chaining on #as' do
-    matcher = delegate_method(:method)
-
-    matcher.as(:some_other_method).should == matcher
-  end
-
-  it 'raises an error if no delegation target is defined' do
-    expect { Object.new.should delegate_method(:name) }.
-      to raise_exception described_class::TargetNotDefinedError
-  end
-
-  it 'raises an error if called with #should_not' do
-    expect { Object.new.should_not delegate_method(:name).to(:anyone) }.
-      to raise_exception described_class::InvalidDelegateMatcher
-  end
-
-  context 'given a method that does not delegate' do
-    before do
-      define_class(:post_office) do
-        def deliver_mail
-          :delivered
-        end
-      end
-    end
-
-    it 'rejects' do
-      post_office = PostOffice.new
-      matcher = delegate_method(:deliver_mail).to(:mailman)
-
-      matcher.matches?(post_office).should be_false
-    end
-
-    it 'has a failure message that indicates which method should have been delegated' do
-      post_office = PostOffice.new
-      matcher = delegate_method(:deliver_mail).to(:mailman)
-
-      matcher.matches?(post_office)
-
-      message = 'Expected PostOffice#deliver_mail to delegate to PostOffice#mailman'
-      matcher.failure_message_for_should.should == message
-    end
-
-    it 'uses the proper syntax for class methods in errors' do
-      matcher = delegate_method(:deliver_mail).to(:mailman)
-
-      matcher.matches?(PostOffice)
-
-      message = 'Expected PostOffice.deliver_mail to delegate to PostOffice.mailman'
-      matcher.failure_message_for_should.should == message
-    end
-  end
-
-  context 'given a method that delegates properly' do
-    it 'accepts' do
-      define_class(:mailman)
-      define_class(:post_office) do
-        def deliver_mail
-          mailman.deliver_mail
-        end
-
-        def mailman
-          Mailman.new
-        end
-      end.new.should delegate_method(:deliver_mail).to(:mailman)
-    end
-  end
-
-  context 'given a method that delegates properly with certain arguments' do
-    before do
-      define_class(:mailman)
-      define_class(:post_office) do
-        def deliver_mail
-          mailman.deliver_mail('221B Baker St.', :hastily => true)
-        end
-
-        def mailman
-          Mailman.new
-        end
-      end
-    end
-
-    context 'when given the correct arguments' do
-      it 'accepts' do
-        PostOffice.new.should delegate_method(:deliver_mail).
-          to(:mailman).with_arguments('221B Baker St.', :hastily => true)
-      end
-    end
-
-    context 'when not given the correct arguments' do
-      it 'rejects' do
-        post_office = PostOffice.new
-        matcher = delegate_method(:deliver_mail).to(:mailman).
-          with_arguments('123 Nowhere Ln.')
-        matcher.matches?(post_office).should be_false
-      end
-
-      it 'has a failure message that indicates which arguments were expected' do
-        post_office = PostOffice.new
-        matcher = delegate_method(:deliver_mail).to(:mailman).with_arguments('123 Nowhere Ln.')
-
-        matcher.matches?(post_office)
-
-        message = 'Expected PostOffice#deliver_mail to delegate to PostOffice#mailman with arguments: ["123 Nowhere Ln."]'
-        matcher.failure_message_for_should.should == message
-      end
-    end
-  end
-
-  context 'given a method that delegates properly to a method of a different name' do
-    before do
-      define_class(:mailman)
-      define_class(:post_office) do
-        def deliver_mail
-          mailman.deliver_mail_and_avoid_dogs
-        end
-
-        def mailman
-          Mailman.new
-        end
-      end
-    end
-
-    context 'when given the correct method name' do
-      it 'accepts' do
-        PostOffice.new.
-          should delegate_method(:deliver_mail).to(:mailman).as(:deliver_mail_and_avoid_dogs)
-      end
-    end
-
-    context 'when given an incorrect method name' do
-      it 'rejects' do
-        post_office = PostOffice.new
-        matcher = delegate_method(:deliver_mail).to(:mailman).as(:watch_tv)
-        matcher.matches?(post_office).should be_false
-      end
-
-      it 'has a failure message that indicates which method was expected' do
-        post_office = PostOffice.new
-        matcher = delegate_method(:deliver_mail).to(:mailman).as(:watch_tv)
-
-        matcher.matches?(post_office)
-
-        message = 'Expected PostOffice#deliver_mail to delegate to PostOffice#mailman as #watch_tv'
-        matcher.failure_message_for_should.should == message
-      end
-    end
-  end
-end
-
-describe Shoulda::Matchers::Independent::DelegateMatcher::TargetNotDefinedError do
-  it 'has a useful message' do
-    error = Shoulda::Matchers::Independent::DelegateMatcher::TargetNotDefinedError.new
-    error.message.should include 'Delegation needs a target'
-  end
-end
-
-describe Shoulda::Matchers::Independent::DelegateMatcher::InvalidDelegateMatcher do
-  it 'has a useful message' do
-    error = Shoulda::Matchers::Independent::DelegateMatcher::InvalidDelegateMatcher.new
-    error.message.should include 'does not support #should_not'
-  end
-end