shoulda-matchers 1.5.6 → 2.0.0

data/lib/shoulda/matchers/active_model/validate_format_of_matcher.rb

@@ -1,108 +0,0 @@
-require 'active_support/deprecation'
-
-module Shoulda # :nodoc:
-  module Matchers
-    module ActiveModel # :nodoc:
-      # Ensures that the model is not valid if the given attribute is not
-      # formatted correctly.
-      #
-      # Options:
-      # * <tt>with_message</tt> - value the test expects to find in
-      #   <tt>allow_blank</tt> - allows a blank value
-      #   <tt>allow_nil</tt> - allows a nil value
-      #   <tt>errors.on(:attribute)</tt>. <tt>Regexp</tt> or <tt>String</tt>.
-      #   Defaults to the translation for <tt>:invalid</tt>.
-      # * <tt>with(string to test against)</tt>
-      # * <tt>not_with(string to test against)</tt>
-      #
-      # Examples:
-      #   it { should validate_format_of(:name).
-      #                 with('12345').
-      #                 with_message(/is not optional/) }
-      #   it { should validate_format_of(:name).
-      #                 not_with('12D45').
-      #                 with_message(/is not optional/) }
-      #
-      def validate_format_of(attr)
-        ValidateFormatOfMatcher.new(attr)
-      end
-
-      class ValidateFormatOfMatcher < ValidationMatcher # :nodoc:
-        def initialize(attribute)
-          ActiveSupport::Deprecation.warn 'The validate_format_of matcher is deprecated and will be removed in 2.0'
-          super
-          @options = {}
-        end
-
-        def allow_blank(allow_blank = true)
-          @options[:allow_blank] = allow_blank
-          self
-        end
-
-        def allow_nil(allow_nil = true)
-          @options[:allow_nil] = allow_nil
-          self
-        end
-
-        def with_message(message)
-          if message
-            @expected_message = message
-          end
-          self
-        end
-
-        def with(value)
-          if @value_to_fail
-            raise 'You may not call both with and not_with'
-          else
-            @value_to_pass = value
-            self
-          end
-        end
-
-        def not_with(value)
-          if @value_to_pass
-            raise 'You may not call both with and not_with'
-          else
-            @value_to_fail = value
-            self
-          end
-        end
-
-        def matches?(subject)
-          super(subject)
-          @expected_message ||= :invalid
-
-          if @value_to_fail
-            disallows_value_of(@value_to_fail, @expected_message) && allows_blank_value? && allows_nil_value?
-          else
-            allows_value_of(@value_to_pass, @expected_message) && allows_blank_value? && allows_nil_value?
-          end
-        end
-
-        def description
-          "have a valid format for #{@attribute}"
-        end
-
-        private
-
-        def allows_blank_value?
-          if @options.key?(:allow_blank)
-            @options[:allow_blank] == allows_value_of('')
-          else
-            true
-          end
-        end
-
-        def allows_nil_value?
-          if @options.key?(:allow_nil)
-            @options[:allow_nil] == allows_value_of(nil)
-          else
-            true
-          end
-        end
-      end
-
-    end
-  end
-end

data/lib/shoulda/matchers/active_record/query_the_database_matcher.rb

@@ -1,111 +0,0 @@
-require 'active_support/deprecation'
-
-module Shoulda # :nodoc:
-  module Matchers
-    module ActiveRecord # :nodoc:
-
-      # Ensures that the number of database queries is known. Rails 3.1 or greater is required.
-      #
-      # Options:
-      # * <tt>when_calling</tt> - Required, the name of the method to examine.
-      # * <tt>with</tt> - Used in conjunction with <tt>when_calling</tt> to pass parameters to the method to examine.
-      # * <tt>or_less</tt> - Pass if the database is queried no more than the number of times specified, as opposed to exactly that number of times.
-      #
-      # Examples:
-      #   it { should query_the_database(4.times).when_calling(:complicated_counting_method)
-      #   it { should query_the_database(4.times).or_less.when_calling(:generate_big_report)
-      #   it { should_not query_the_database.when_calling(:cached_count)
-      #
-      def query_the_database(times = nil)
-        QueryTheDatabaseMatcher.new(times)
-      end
-
-      class QueryTheDatabaseMatcher # :nodoc:
-        def initialize(times)
-          ActiveSupport::Deprecation.warn 'The query_the_database matcher is deprecated and will be removed in 2.0'
-          @queries = []
-          @options = {}
-
-          if times.respond_to?(:count)
-            @options[:expected_query_count] = times.count
-          else
-            @options[:expected_query_count] = times
-          end
-        end
-
-        def when_calling(method_name)
-          @options[:method_name] = method_name
-          self
-        end
-
-        def with(*method_arguments)
-          @options[:method_arguments] = method_arguments
-          self
-        end
-
-        def or_less
-          @options[:expected_count_is_maximum] = true
-          self
-        end
-
-        def matches?(subject)
-          subscriber = ActiveSupport::Notifications.subscribe('sql.active_record') do |name, started, finished, id, payload|
-            @queries << payload unless filter_query(payload)
-          end
-
-          if @options[:method_arguments]
-            subject.send(@options[:method_name], *@options[:method_arguments])
-          else
-            subject.send(@options[:method_name])
-          end
-
-          ActiveSupport::Notifications.unsubscribe(subscriber)
-
-          if @options[:expected_count_is_maximum]
-            @queries.length <= @options[:expected_query_count]
-          elsif @options[:expected_query_count].present?
-            @queries.length == @options[:expected_query_count]
-          else
-            @queries.length > 0
-          end
-        end
-
-        def failure_message_for_should
-          if @options.key?(:expected_query_count)
-            "Expected ##{@options[:method_name]} to cause #{@options[:expected_query_count]} database queries but it actually caused #{@queries.length} queries:" + friendly_queries
-          else
-            "Expected ##{@options[:method_name]} to query the database but it actually caused #{@queries.length} queries:" + friendly_queries
-          end
-        end
-
-        def failure_message_for_should_not
-          if @options[:expected_query_count]
-            "Expected ##{@options[:method_name]} to not cause #{@options[:expected_query_count]} database queries but it actually caused #{@queries.length} queries:" + friendly_queries
-          else
-            "Expected ##{@options[:method_name]} to not query the database but it actually caused #{@queries.length} queries:" + friendly_queries
-          end
-        end
-
-        private
-
-        def friendly_queries
-          @queries.map do |query|
-            "\n  (#{query[:name]}) #{query[:sql]}"
-          end.join
-        end
-
-        def filter_query(query)
-          query[:name] == 'SCHEMA' || looks_like_schema?(query[:sql])
-        end
-
-        def schema_terms
-          ['FROM sqlite_master', 'PRAGMA', 'SHOW TABLES', 'SHOW KEYS FROM', 'SHOW FIELDS FROM', 'begin transaction', 'commit transaction']
-        end
-
-        def looks_like_schema?(sql)
-          schema_terms.any? { |term| sql.include?(term) }
-        end
-      end
-    end
-  end
-end

data/lib/shoulda/matchers/independent.rb

@@ -1,9 +0,0 @@
-require 'shoulda/matchers/independent/delegate_matcher'
-
-module Shoulda
-  module Matchers
-    # = Matchers for non-Rails-dependent code.
-    module Independent
-    end
-  end
-end

data/lib/shoulda/matchers/independent/delegate_matcher.rb

@@ -1,134 +0,0 @@
-require 'bourne'
-require 'active_support/deprecation'
-
-module Shoulda # :nodoc:
-  module Matchers
-    module Independent # :nodoc:
-
-      # Ensure that a given method is delegated properly.
-      #
-      # Basic Syntax:
-      #   it { should delegate_method(:deliver_mail).to(:mailman) }
-      #
-      # Options:
-      # * <tt>:as</tt> - tests that the object being delegated to is called with a certain method
-      #   (defaults to same name as delegating method)
-      # * <tt>:with_arguments</tt> - tests that the method on the object being delegated to is
-      #   called with certain arguments
-      #
-      # Examples:
-      #   it { should delegate_method(:deliver_mail).to(:mailman).as(:deliver_with_haste)
-      #   it { should delegate_method(:deliver_mail).to(:mailman).
-      #     with_arguments('221B Baker St.', :hastily => true) }
-      #
-      def delegate_method(delegating_method)
-        DelegateMatcher.new(delegating_method)
-      end
-
-      class DelegateMatcher
-        def initialize(delegating_method)
-          ActiveSupport::Deprecation.warn 'The delegate_method matcher is deprecated and will be removed in 2.0'
-          @delegating_method = delegating_method
-        end
-
-        def matches?(subject)
-          @subject = subject
-          ensure_target_method_is_present!
-
-          begin
-            extend Mocha::API
-
-            stubbed_object = stub(method_on_target)
-            subject.stubs(@target_method).returns(stubbed_object)
-            subject.send(@delegating_method)
-
-            matcher = Mocha::API::HaveReceived.new(method_on_target).with(*@delegated_arguments)
-            matcher.matches?(stubbed_object)
-          rescue NoMethodError, Mocha::ExpectationError
-            false
-          end
-        end
-
-        def description
-          add_clarifications_to("delegate method ##{@delegating_method} to :#{@target_method}")
-        end
-
-        def does_not_match?(subject)
-          raise InvalidDelegateMatcher
-        end
-
-        def to(target_method)
-          @target_method = target_method
-          self
-        end
-
-        def as(method_on_target)
-          @method_on_target = method_on_target
-          self
-        end
-
-        def with_arguments(*arguments)
-          @delegated_arguments = arguments
-          self
-        end
-
-        def failure_message_for_should
-          base = "Expected #{delegating_method_name} to delegate to #{target_method_name}"
-          add_clarifications_to(base)
-        end
-
-        private
-
-        def add_clarifications_to(message)
-          if @delegated_arguments.present?
-            message << " with arguments: #{@delegated_arguments.inspect}"
-          end
-
-          if @method_on_target.present?
-            message << " as ##{@method_on_target}"
-          end
-
-          message
-        end
-
-        def delegating_method_name
-          method_name_with_class(@delegating_method)
-        end
-
-        def target_method_name
-          method_name_with_class(@target_method)
-        end
-
-        def method_name_with_class(method)
-          if Class === @subject
-            @subject.name + '.' + method.to_s
-          else
-            @subject.class.name + '#' + method.to_s
-          end
-        end
-
-        def method_on_target
-          @method_on_target || @delegating_method
-        end
-
-        def ensure_target_method_is_present!
-          if @target_method.blank?
-            raise TargetNotDefinedError
-          end
-        end
-      end
-
-      class DelegateMatcher::TargetNotDefinedError < StandardError
-        def message
-          'Delegation needs a target. Use the #to method to define one, e.g. `post_office.should delegate(:deliver_mail).to(:mailman)`'
-        end
-      end
-
-      class DelegateMatcher::InvalidDelegateMatcher < StandardError
-        def message
-          '#delegate_to does not support #should_not syntax.'
-        end
-      end
-    end
-  end
-end

data/spec/shoulda/matchers/action_controller/assign_to_matcher_spec.rb

@@ -1,66 +0,0 @@
-require 'spec_helper'
-
-describe Shoulda::Matchers::ActionController::AssignToMatcher do
-  it 'includes the actual class in the failure message' do
-    define_class(:WrongClass) do
-      def to_s
-        'wrong class'
-      end
-    end
-
-    controller = build_response { @var = WrongClass.new }
-    matcher = assign_to(:var).with_kind_of(Fixnum)
-    matcher.matches?(controller)
-
-    matcher.failure_message_for_should.should =~ /but got wrong class \(WrongClass\)$/
-  end
-
-  context 'a controller that assigns to an instance variable' do
-    it 'accepts assigning to that variable' do
-      controller.should assign_to(:var)
-    end
-
-    it 'accepts assigning to that variable with the correct class' do
-      controller.should assign_to(:var).with_kind_of(String)
-    end
-
-    it 'rejects assigning to that variable with another class' do
-      controller.should_not assign_to(:var).with_kind_of(Fixnum)
-    end
-
-    it 'accepts assigning the correct value to that variable' do
-      controller.should assign_to(:var).with('value')
-    end
-
-    it 'rejects assigning another value to that variable' do
-      controller.should_not assign_to(:var).with('other')
-    end
-
-    it 'rejects assigning to another variable' do
-      controller.should_not assign_to(:other)
-    end
-
-    it 'accepts assigning to the same value in the test context' do
-      expected = 'value'
-      controller.should assign_to(:var).in_context(self).with { expected }
-    end
-
-    it 'rejects assigning to the another value in the test context' do
-      expected = 'other'
-      controller.should_not assign_to(:var).in_context(self).with { expected }
-    end
-
-    def controller
-      build_response { @var = 'value' }
-    end
-  end
-
-  context 'a controller that assigns a nil value to an instance variable' do
-    it 'accepts assigning to that variable' do
-      controller = build_response do
-        @var = nil
-      end
-      controller.should assign_to(:var)
-    end
-  end
-end

data/spec/shoulda/matchers/action_controller/respond_with_content_type_matcher_spec.rb

@@ -1,31 +0,0 @@
-require 'spec_helper'
-
-describe Shoulda::Matchers::ActionController::RespondWithContentTypeMatcher do
-  it 'generates the correct description' do
-    expected = 'respond with content type of application/xml'
-
-    respond_with_content_type(:xml).description.should == expected
-  end
-
-  it 'accepts responding with content type as symbol' do
-    xml_controller.should respond_with_content_type(:xml)
-  end
-
-  it 'accepts responding with qualified MIME-style content type' do
-    xml_controller.should respond_with_content_type('application/xml')
-  end
-
-  it 'accepts responding with a regex matching the content type' do
-    xml_controller.should respond_with_content_type(/xml/)
-  end
-
-  it 'rejects responding with another content type' do
-    xml_controller.should_not respond_with_content_type(:json)
-  end
-
-  def xml_controller
-    build_response do
-      render :xml => { :user => 'thoughtbot' }.to_xml
-    end
-  end
-end