shoulda-matchers 3.0.1 → 3.1.0

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

@@ -1,51 +0,0 @@
-module Shoulda
-  module Matchers
-    module ActiveModel
-      # @private
-      module StrictValidator
-        def allow_description(allowed_values)
-          "doesn't raise when #{attribute} is set to #{allowed_values}"
-        end
-
-        def expected_message_from(attribute_message)
-          "#{human_attribute_name} #{attribute_message}"
-        end
-
-        def formatted_messages
-          [messages.first.message]
-        end
-
-        def messages_description
-          if has_messages?
-            ': ' + messages.first.message.inspect
-          else
-            ' no exception'
-          end
-        end
-
-        def expected_messages_description(expected_message)
-          if expected_message
-            "exception to include #{expected_message.inspect}"
-          else
-            'an exception to have been raised'
-          end
-        end
-
-        protected
-
-        def collect_messages
-          validation_exceptions
-        end
-
-        private
-
-        def validation_exceptions
-          record.valid?(context)
-          []
-        rescue ::ActiveModel::StrictValidationFailed => exception
-          [exception]
-        end
-      end
-    end
-  end
-end

data/spec/support/unit/shared_examples/numerical_type_submatcher.rb

@@ -1,15 +0,0 @@
-shared_examples 'a numerical type submatcher' do
-  it 'implements the allowed_type method' do
-    expect(subject).to respond_to(:allowed_type).with(0).arguments
-    expect { subject.allowed_type }.not_to raise_error
-  end
-
-  it 'implements the diff_to_compare' do
-    expect(subject).to respond_to(:diff_to_compare).with(0).arguments
-    expect { subject.diff_to_compare }.not_to raise_error
-  end
-
-  it 'returns itself when given a message' do
-    expect(subject.with_message('some message')).to eq subject
-  end
-end

data/spec/unit/shoulda/matchers/active_model/numericality_matchers/comparison_matcher_spec.rb

@@ -1,288 +0,0 @@
-require 'unit_spec_helper'
-
-describe Shoulda::Matchers::ActiveModel::NumericalityMatchers::ComparisonMatcher do
-  it_behaves_like 'a numerical submatcher' do
-    subject { build_matcher }
-  end
-
-  shared_examples_for 'strict qualifier' do
-    context 'asserting strict validation when validating strictly' do
-      it 'accepts' do
-        record = instance_with_validations(
-          validation_qualifier => 1,
-          strict: true
-        )
-        matcher = build_matcher(operator: operator, value: 1).strict
-        expect(record).to matcher
-      end
-    end
-
-    context 'asserting non-strict validation when validating strictly' do
-      it 'rejects' do
-        pending 'This needs to be fixed'
-        record = instance_with_validations(
-          validation_qualifier => 1,
-          strict: true
-        )
-        matcher = build_matcher(operator: operator, value: 1)
-        expect(record).not_to matcher
-      end
-    end
-
-    context 'asserting strict validation when not validating strictly' do
-      it 'rejects' do
-        record = instance_with_validations(validation_qualifier => 1)
-        matcher = build_matcher(operator: operator, value: 1).strict
-        expect(record).not_to matcher
-      end
-    end
-  end
-
-  context 'when initialized without correct numerical matcher' do
-    it 'raises an ArgumentError' do
-      numericality_matcher = double
-      expect { described_class.new(numericality_matcher, 0, :>) }.
-        to raise_error(ArgumentError)
-    end
-  end
-
-  describe 'is_greater_than' do
-    include_examples 'strict qualifier'
-
-    it do
-      record = instance_with_validations(greater_than: 1.5)
-      matcher = build_matcher(operator: :>, value: 2)
-      expect(record).not_to matcher
-    end
-
-    it do
-      record = instance_with_validations(greater_than: 2)
-      matcher = build_matcher(operator: :>, value: 2)
-      expect(record).to matcher
-    end
-
-    it do
-      record = instance_with_validations(greater_than: 2.5)
-      matcher = build_matcher(operator: :>, value: 2)
-      expect(record).not_to matcher
-    end
-
-    it do
-      record = instance_without_validations
-      matcher = build_matcher(operator: :>, value: 2)
-      expect(record).not_to matcher
-    end
-
-    def operator
-      :>
-    end
-
-    def validation_qualifier
-      :greater_than
-    end
-  end
-
-  describe 'is_greater_than_or_equal_to' do
-    include_examples 'strict qualifier'
-
-    it do
-      record = instance_with_validations(greater_than_or_equal_to: 1.5)
-      matcher = build_matcher(operator: :>=, value: 2)
-      expect(record).not_to matcher
-    end
-
-    it do
-      record = instance_with_validations(greater_than_or_equal_to: 2)
-      matcher = build_matcher(operator: :>=, value: 2)
-      expect(record).to matcher
-    end
-
-    it do
-      record = instance_with_validations(greater_than_or_equal_to: 2.5)
-      matcher = build_matcher(operator: :>=, value: 2)
-      expect(record).not_to matcher
-    end
-
-    it do
-      record = instance_without_validations
-      matcher = build_matcher(operator: :>=, value: 2)
-      expect(record).not_to matcher
-    end
-
-    def operator
-      :>=
-    end
-
-    def validation_qualifier
-      :greater_than_or_equal_to
-    end
-  end
-
-  describe 'is_less_than' do
-    include_examples 'strict qualifier'
-
-    it do
-      record = instance_with_validations(less_than: 1.5)
-      matcher = build_matcher(operator: :<, value: 2)
-      expect(record).not_to matcher
-    end
-
-    it do
-      record = instance_with_validations(less_than: 2)
-      matcher = build_matcher(operator: :<, value: 2)
-      expect(record).to matcher
-    end
-
-    it do
-      record = instance_with_validations(less_than: 2.5)
-      matcher = build_matcher(operator: :<, value: 2)
-      expect(record).not_to matcher
-    end
-
-    it do
-      record = instance_without_validations
-      matcher = build_matcher(operator: :<, value: 2)
-      expect(record).not_to matcher
-    end
-
-    def operator
-      :<
-    end
-
-    def validation_qualifier
-      :less_than
-    end
-  end
-
-  describe 'is_less_than_or_equal_to' do
-    include_examples 'strict qualifier'
-
-    it do
-      record = instance_with_validations(less_than_or_equal_to: 1.5)
-      matcher = build_matcher(operator: :<=, value: 2)
-      expect(record).not_to matcher
-    end
-
-    it do
-      record = instance_with_validations(less_than_or_equal_to: 2)
-      matcher = build_matcher(operator: :<=, value: 2)
-      expect(record).to matcher
-    end
-
-    it do
-      record = instance_with_validations(less_than_or_equal_to: 2.5)
-      matcher = build_matcher(operator: :<=, value: 2)
-      expect(record).not_to matcher
-    end
-
-    it do
-      record = instance_without_validations
-      matcher = build_matcher(operator: :<=, value: 2)
-      expect(record).not_to matcher
-    end
-
-    def operator
-      :<=
-    end
-
-    def validation_qualifier
-      :less_than_or_equal_to
-    end
-  end
-
-  describe 'is_equal_to' do
-    include_examples 'strict qualifier'
-
-    it do
-      record = instance_with_validations(equal_to: 1.5)
-      matcher = build_matcher(operator: :==, value: 2)
-      expect(record).not_to matcher
-    end
-
-    it do
-      record = instance_with_validations(equal_to: 2)
-      matcher = build_matcher(operator: :==, value: 2)
-      expect(record).to matcher
-    end
-
-    it do
-      record = instance_with_validations(equal_to: 2.5)
-      matcher = build_matcher(operator: :==, value: 2)
-      expect(record).not_to matcher
-    end
-
-    it do
-      record = instance_without_validations
-      matcher = build_matcher(operator: :==, value: 2)
-      expect(record).not_to matcher
-    end
-
-    def operator
-      :==
-    end
-
-    def validation_qualifier
-      :equal_to
-    end
-  end
-
-  describe 'with_message' do
-    it 'verifies the message for the validation' do
-      instance = instance_with_validations(equal_to: 0, message: 'Must be zero')
-      matcher = build_matcher.with_message('Must be zero')
-      expect(instance).to matcher
-    end
-  end
-
-  describe '#comparison_description' do
-    tests = [
-      { operator: :>, value: 0, expectation: 'greater than 0' },
-      { operator: :>=, value: -1.0, expectation: 'greater than or equal to -1.0' },
-      { operator: :==, value: 2.2, expectation: 'equal to 2.2' },
-      { operator: :<, value: -3, expectation: 'less than -3' },
-      { operator: :<=, value: 4, expectation: 'less than or equal to 4' },
-    ]
-
-    tests.each do |test|
-      context "with :#{test[:operator]} as operator and #{test[:value]} as value" do
-        it do
-          matcher = build_matcher(operator: test[:operator], value: test[:value])
-          expect(matcher.comparison_description).to eq test[:expectation]
-        end
-      end
-    end
-  end
-
-  def model_with_validations(options = {})
-    define_model :example, attribute_name => :string do |model|
-      model.validates_numericality_of(attribute_name, options)
-      model.attr_accessible(attribute_name)
-    end
-  end
-
-  def instance_with_validations(options = {})
-    model_with_validations(options).new(attribute_name => '1')
-  end
-
-  def model_without_validations
-    define_model :example, attribute_name => :string do |model|
-      model.attr_accessible(attribute_name)
-    end
-  end
-
-  def instance_without_validations
-    model_without_validations.new
-  end
-
-  def attribute_name
-    :attr
-  end
-
-  def build_matcher(operator: :==, value: 0)
-    described_class.new(numericality_matcher, value, operator).for(attribute_name)
-  end
-
-  def numericality_matcher
-    double(diff_to_compare: 1, given_numeric_column?: nil)
-  end
-end

data/spec/unit/shoulda/matchers/active_model/numericality_matchers/even_number_matcher_spec.rb

@@ -1,100 +0,0 @@
-require 'unit_spec_helper'
-
-describe Shoulda::Matchers::ActiveModel::NumericalityMatchers::EvenNumberMatcher  do
-  subject { described_class.new(numericality_matcher, :attr) }
-
-  it_behaves_like 'a numerical submatcher'
-  it_behaves_like 'a numerical type submatcher'
-
-  it 'allows even number' do
-    expect(subject.allowed_type).to eq 'even numbers'
-  end
-
-  describe '#diff_to_compare' do
-    it { expect(subject.diff_to_compare).to eq 2 }
-  end
-
-  context 'when the model has an even validation' do
-    it 'matches' do
-      match = subject
-      expect(validating_even_number).to match
-    end
-  end
-
-  context 'when the model does not have an even validation' do
-    it 'does not match' do
-      match = subject
-      expect(not_validating_even_number).not_to match
-    end
-
-    it 'fails with the ActiveRecord :even message' do
-      match = subject
-      expect {
-        expect(not_validating_even_number).to match
-      }.to fail_with_message_including('Expected errors to include "must be even"')
-    end
-  end
-
-  context 'with custom validation message' do
-    it 'only accepts even number values for that attribute with that message' do
-      expect(validating_even_number(message: 'custom')).to subject.with_message(/custom/)
-    end
-
-    it 'fails even number values for that attribute with another message' do
-      expect(validating_even_number(message: 'custom')).not_to subject.with_message(/wrong/)
-    end
-  end
-
-  context 'asserting strict validation when validating strictly' do
-    it 'accepts' do
-      expect(validating_even_number(strict: true)).to subject.strict
-    end
-  end
-
-  context 'asserting non-strict validation when validating strictly' do
-    it 'rejects' do
-      pending 'This needs to be fixed'
-      expect(validating_even_number(strict: true)).not_to subject
-    end
-  end
-
-  context 'asserting strict validation when not validating strictly' do
-    it 'rejects' do
-      expect(validating_even_number).not_to subject.strict
-    end
-  end
-
-  context 'qualified with on and validating with on' do
-    it 'accepts' do
-      expect(validating_even_number(on: :customizable)).
-        to subject.on(:customizable)
-    end
-  end
-
-  context 'qualified with on but not validating with on' do
-    it 'accepts since the validation never considers a context' do
-      expect(validating_even_number).to subject.on(:customizable)
-    end
-  end
-
-  context 'not qualified with on but validating with on' do
-    it 'rejects since the validation never runs' do
-      expect(validating_even_number(on: :customizable)).
-        not_to subject
-    end
-  end
-
-  def numericality_matcher
-    double(:numericality_matcher, given_numeric_column?: nil)
-  end
-
-  def validating_even_number(options = {})
-    define_model :example, attr: :string do
-      validates_numericality_of :attr, { even: true }.merge(options)
-    end.new
-  end
-
-  def not_validating_even_number
-    define_model(:example, attr: :string).new
-  end
-end