shoulda-matchers 4.0.0.rc1 → 4.0.1

data/spec/unit/shoulda/matchers/active_model/disallow_value_matcher_spec.rb

@@ -1,86 +0,0 @@
-require 'unit_spec_helper'
-
-describe Shoulda::Matchers::ActiveModel::DisallowValueMatcher, type: :model do
-  context 'an attribute with a format validation' do
-    it 'does not match if the value is allowed' do
-      expect(validating_format(with: /abc/)).not_to matcher('abcde').for(:attr)
-    end
-
-    it 'matches if the value is not allowed' do
-      expect(validating_format(with: /abc/)).to matcher('xyz').for(:attr)
-    end
-  end
-
-  context "an attribute with a context-dependent validation" do
-    context "without the validation context" do
-      it "does not match" do
-        expect(validating_format(with: /abc/, on: :customisable)).not_to matcher("xyz").for(:attr)
-      end
-    end
-
-    context "with the validation context" do
-      it "disallows a bad value" do
-        expect(validating_format(with: /abc/, on: :customisable)).to matcher("xyz").for(:attr).on(:customisable)
-      end
-
-      it "does not match a good value" do
-        expect(validating_format(with: /abc/, on: :customisable)).not_to matcher("abcde").for(:attr).on(:customisable)
-      end
-    end
-  end
-
-  context 'an attribute with a format validation and a custom message' do
-    it 'does not match if the value and message are both correct' do
-      expect(validating_format(with: /abc/, message: 'good message')).
-        not_to matcher('abcde').for(:attr).with_message('good message')
-    end
-
-    it "delegates its failure message to its allow matcher's negative failure message" do
-      allow_matcher = double('allow_matcher',
-        failure_message_when_negated: 'allow matcher failure',
-      ).as_null_object
-      allow(Shoulda::Matchers::ActiveModel::AllowValueMatcher).
-        to receive(:new).
-        and_return(allow_matcher)
-
-      matcher = matcher('abcde').for(:attr).with_message('good message')
-      matcher.matches?(validating_format(with: /abc/, message: 'good message'))
-
-      expect(matcher.failure_message).to eq 'allow matcher failure'
-    end
-
-    it 'matches if the message is correct but the value is not' do
-      expect(validating_format(with: /abc/, message: 'good message')).
-        to matcher('xyz').for(:attr).with_message('good message')
-    end
-  end
-
-  context 'an attribute where the message occurs on another attribute' do
-    it 'matches if the message is correct but the value is not' do
-      expect(record_with_custom_validation).to \
-        matcher('bad value').for(:attr).with_message(/some message/, against: :attr2)
-    end
-
-    it 'does not match if the value and message are both correct' do
-      expect(record_with_custom_validation).not_to \
-        matcher('good value').for(:attr).with_message(/some message/, against: :attr2)
-    end
-
-    def record_with_custom_validation
-      define_model :example, attr: :string, attr2: :string do
-        validate :custom_validation
-
-        def custom_validation
-          if self[:attr] != 'good value'
-            self.errors[:attr2] << 'some message'
-          end
-        end
-      end.new
-    end
-  end
-
-  def matcher(value)
-    described_class.new(value)
-  end
-  alias_method :disallow_value, :matcher
-end

data/spec/unit/shoulda/matchers/active_model/have_secure_password_matcher_spec.rb

@@ -1,20 +0,0 @@
-require 'unit_spec_helper'
-
-describe Shoulda::Matchers::ActiveModel::HaveSecurePasswordMatcher, type: :model do
-  if active_model_3_1?
-    it 'matches when the subject configures has_secure_password with default options' do
-      working_model = define_model(:example, password_digest: :string) { has_secure_password }
-      expect(working_model.new).to have_secure_password
-    end
-
-    it 'does not match when the subject does not authenticate a password' do
-      no_secure_password = define_model(:example)
-      expect(no_secure_password.new).not_to have_secure_password
-    end
-
-    it 'does not match when the subject is missing the password_digest attribute' do
-      no_digest_column = define_model(:example) { has_secure_password }
-      expect(no_digest_column.new).not_to have_secure_password
-    end
-  end
-end

data/spec/unit/shoulda/matchers/active_model/helpers_spec.rb

@@ -1,162 +0,0 @@
-# encoding: UTF-8
-require 'unit_spec_helper'
-
-describe Shoulda::Matchers::ActiveModel::Helpers do
-  include Shoulda::Matchers::ActiveModel
-  after { I18n.backend.reload! }
-
-  describe 'default_error_message' do
-    context 'if the translation for the model attribute’s error exists' do
-      it 'provides the right error message for validate_presence_of' do
-        store_translations
-
-        assert_presence_validation_has_correct_message
-      end
-
-      it 'provides the right error message for validates_length_of' do
-        store_translations
-
-        assert_length_validation_has_correct_message
-      end
-    end
-
-    context 'if no translation for the model attribute’s error exists' do
-      context 'and the translation for the model’s error exists' do
-        it 'provides the right error message for validate_presence_of' do
-          store_translations(without: :model_attribute)
-
-          assert_presence_validation_has_correct_message
-        end
-
-        it 'provides the right error message for validates_length_of' do
-          store_translations(without: :model_attribute)
-
-          assert_length_validation_has_correct_message
-        end
-      end
-
-      context 'and no translation for the model’s error exists' do
-        context 'and the translation for the message exists' do
-          it 'provides the right error message for validate_presence_of' do
-            store_translations(without: [:model_attribute, :model])
-
-            assert_presence_validation_has_correct_message
-          end
-
-          it 'provides the right error message for validates_length_of' do
-            store_translations(without: [:model_attribute, :model])
-
-            assert_length_validation_has_correct_message
-          end
-        end
-
-        context 'and no translation for the message exists' do
-          context 'and the translation for the attribute exists' do
-            it 'provides the right error message for validate_presence_of' do
-              store_translations(without: [:model_attribute, :model, :message])
-
-              assert_presence_validation_has_correct_message
-            end
-
-            it 'provides the right error message for validates_length_of' do
-              store_translations(without: [:model_attribute, :model, :message])
-
-              assert_length_validation_has_correct_message
-            end
-          end
-
-          context 'and no translation for the attribute exists' do
-            it 'provides the general error message for validate_presence_of' do
-              assert_presence_validation_has_correct_message
-            end
-
-            it 'provides the general error message for validates_length_of' do
-              assert_length_validation_has_correct_message
-            end
-          end
-        end
-      end
-    end
-
-    context 'if ActiveModel::Errors#generate_message behavior has changed' do
-      it 'provides the right error message for validate_presence_of' do
-        stub_active_model_message_generation(type: :blank,
-                                              message: 'Behavior has diverged.')
-        assert_presence_validation_has_correct_message
-      end
-    end
-  end
-
-  def assert_presence_validation_has_correct_message
-    record = define_model :example, attr: :string do
-      validates_presence_of :attr
-    end.new
-    expect(record).to validate_presence_of(:attr)
-  end
-
-  def assert_length_validation_has_correct_message
-    record = define_model :example, attr: :string do
-      validates_length_of :attr, is: 40, allow_blank: true
-    end.new
-    expect(record).to validate_length_of(:attr).is_equal_to(40)
-  end
-
-  def store_translations(options = {without: []})
-    options[:without] = Array.wrap(options[:without] || [])
-
-    translations = {
-      activerecord: {
-        errors: {
-          models: {
-            example: {
-              attributes: {
-                attr: {}
-              }
-            }
-          },
-          messages: {}
-        }
-      },
-      errors: {
-        attributes: {
-          attr: {}
-        },
-        messages: {}
-      }
-    }
-
-    unless options[:without].include?(:model_attribute)
-      translations[:activerecord][:errors][:models][:example][:attributes][:attr][:blank] = "Don't you do that to me!"
-      translations[:activerecord][:errors][:models][:example][:attributes][:attr][:wrong_length] = "Don't you do that to me!"
-    end
-
-    unless options[:without].include?(:model)
-      translations[:activerecord][:errors][:models][:example][:blank] = 'Give it one more try!'
-      translations[:activerecord][:errors][:models][:example][:wrong_length] = 'Give it one more try!'
-    end
-
-    unless options[:without].include?(:message)
-      translations[:activerecord][:errors][:messages][:blank] = 'Oh no!'
-      translations[:activerecord][:errors][:messages][:wrong_length] = 'Oh no!'
-    end
-
-    unless options[:without].include?(:attribute)
-      translations[:errors][:attributes][:attr][:blank] = 'Seriously?'
-      translations[:errors][:attributes][:attr][:wrong_length] = 'Seriously?'
-    end
-
-    I18n.backend.store_translations(:en, translations)
-  end
-
-  def stub_active_model_message_generation(options = {})
-    attribute = options.delete(:attribute) || :attr
-    message = options.delete(:message)
-    type = options.delete(:type)
-
-    expect_any_instance_of(ActiveModel::Errors).
-      to receive(:generate_message).
-      with(attribute, type, {}).
-      at_least(1).
-      and_return(message)
-  end
-end

data/spec/unit/shoulda/matchers/active_model/validate_absence_of_matcher_spec.rb

@@ -1,290 +0,0 @@
-require 'unit_spec_helper'
-
-describe Shoulda::Matchers::ActiveModel::ValidateAbsenceOfMatcher, type: :model do
-  if active_model_supports_absence_validation?
-    def self.available_column_types
-      [
-        :string,
-        :text,
-        :integer,
-        :float,
-        :decimal,
-        :datetime,
-        :timestamp,
-        :time,
-        :date,
-        :binary
-      ]
-    end
-
-    context 'a model with an absence validation' do
-      it 'accepts' do
-        expect(validating_absence_of(:attr)).to validate_absence_of(:attr)
-      end
-
-      it 'does not override the default message with a present' do
-        expect(validating_absence_of(:attr)).to validate_absence_of(:attr).with_message(nil)
-      end
-
-      available_column_types.each do |type|
-        context "when column is of type #{type}" do
-          it "accepts" do
-            expect(validating_absence_of(:attr, {}, type: type)).
-              to validate_absence_of(:attr)
-          end
-
-          it_supports(
-            'ignoring_interference_by_writer',
-            tests: {
-              accept_if_qualified_but_changing_value_does_not_interfere: {
-                changing_values_with: :next_value
-              },
-            }
-          )
-
-          define_method(:validation_matcher_scenario_args) do |*args|
-            super(*args).deep_merge(column_type: type)
-          end
-        end
-      end
-
-      context 'when used in the negative' do
-        it 'fails' do
-          assertion = lambda do
-            expect(validating_absence_of(:attr)).
-              not_to validate_absence_of(:attr)
-          end
-
-          message = <<-MESSAGE
-Expected Example not to validate that :attr is empty/falsy, but this
-could not be proved.
-  After setting :attr to ‹"an arbitrary value"›, the matcher expected
-  the Example to be valid, but it was invalid instead, producing these
-  validation errors:
-
-  * attr: ["must be blank"]
-          MESSAGE
-
-          expect(&assertion).to fail_with_message(message)
-        end
-      end
-
-      def validation_matcher_scenario_args
-        super.deep_merge(model_creator: :active_record)
-      end
-    end
-
-    context 'a model without an absence validation' do
-      it 'rejects with the correct failure message' do
-        record = define_model(:example, attr: :string).new
-
-        message = <<-MESSAGE
-Expected Example to validate that :attr is empty/falsy, but this could
-not be proved.
-  After setting :attr to ‹"an arbitrary value"›, the matcher expected
-  the Example to be invalid, but it was valid instead.
-        MESSAGE
-
-        assertion = lambda do
-          expect(record).to validate_absence_of(:attr)
-        end
-
-        expect(&assertion).to fail_with_message(message)
-      end
-    end
-
-    context 'an ActiveModel class with an absence validation' do
-      it 'accepts' do
-        expect(active_model_validating_absence_of(:attr)).to validate_absence_of(:attr)
-      end
-
-      it 'does not override the default message with a blank' do
-        expect(active_model_validating_absence_of(:attr)).to validate_absence_of(:attr).with_message(nil)
-      end
-
-      it_supports(
-        'ignoring_interference_by_writer',
-        tests: {
-          accept_if_qualified_but_changing_value_does_not_interfere: {
-            changing_values_with: :upcase
-          },
-        }
-      )
-
-      def validation_matcher_scenario_args
-        super.deep_merge(model_creator: :active_model)
-      end
-    end
-
-    context 'an ActiveModel class without an absence validation' do
-      it 'rejects with the correct failure message' do
-        message = <<-MESSAGE
-Expected Example to validate that :attr is empty/falsy, but this could
-not be proved.
-  After setting :attr to ‹"an arbitrary value"›, the matcher expected
-  the Example to be invalid, but it was valid instead.
-        MESSAGE
-
-        assertion = lambda do
-          expect(active_model_with(:attr)).to validate_absence_of(:attr)
-        end
-
-        expect(&assertion).to fail_with_message(message)
-      end
-    end
-
-    context 'a has_many association with an absence validation' do
-      it 'requires the attribute to not be set' do
-        expect(having_many(:children, absence: true)).to validate_absence_of(:children)
-      end
-
-      it_supports(
-        'ignoring_interference_by_writer',
-        tests: {
-          accept_if_qualified_but_changing_value_does_not_interfere: {
-            changing_values_with: :next_value
-          },
-        }
-      )
-
-      def validation_matcher_scenario_args
-        super.deep_merge(model_creator: :"active_record/has_many")
-      end
-    end
-
-    context 'a has_many association without an absence validation' do
-      it 'does not require the attribute to not be set' do
-        expect(having_many(:children, absence: false)).
-          not_to validate_absence_of(:children)
-      end
-    end
-
-    context 'an absent has_and_belongs_to_many association' do
-      it 'accepts' do
-        model = having_and_belonging_to_many(:children, absence: true)
-        expect(model).to validate_absence_of(:children)
-      end
-
-      it_supports(
-        'ignoring_interference_by_writer',
-        tests: {
-          accept_if_qualified_but_changing_value_does_not_interfere: {
-            changing_values_with: :next_value
-          },
-        }
-      )
-
-      def validation_matcher_scenario_args
-        super.deep_merge(model_creator: :"active_record/habtm")
-      end
-    end
-
-    context 'a non-absent has_and_belongs_to_many association' do
-      it 'rejects with the correct failure message' do
-        model = having_and_belonging_to_many(:children, absence: false)
-
-        message = <<-MESSAGE
-Expected Parent to validate that :children is empty/falsy, but this
-could not be proved.
-  After setting :children to ‹[#<Child id: nil>]›, the matcher expected
-  the Parent to be invalid, but it was valid instead.
-        MESSAGE
-
-        assertion = lambda do
-          expect(model).to validate_absence_of(:children)
-        end
-
-        expect(&assertion).to fail_with_message(message)
-      end
-    end
-
-    context "an i18n translation containing %{attribute} and %{model}" do
-      after { I18n.backend.reload! }
-
-      it "does not raise an exception" do
-        stub_translation("activerecord.errors.messages.present",
-                         "%{attribute} must be blank in a %{model}")
-
-        expect {
-          expect(validating_absence_of(:attr)).to validate_absence_of(:attr)
-        }.to_not raise_exception
-      end
-    end
-
-    context "an attribute with a context-dependent validation" do
-      context "without the validation context" do
-        it "does not match" do
-          expect(validating_absence_of(:attr, on: :customisable)).not_to validate_absence_of(:attr)
-        end
-      end
-
-      context "with the validation context" do
-        it "matches" do
-          expect(validating_absence_of(:attr, on: :customisable)).to validate_absence_of(:attr).on(:customisable)
-        end
-      end
-    end
-
-    def define_model_validating_absence_of(attr, validation_options = {}, given_column_options = {})
-      default_column_options = { type: :string, options: {} }
-      column_options = default_column_options.merge(given_column_options)
-
-      define_model :example, attr => column_options do |model|
-        model.validates_absence_of(attr, validation_options)
-
-        if block_given?
-          yield model
-        end
-      end
-    end
-
-    def validating_absence_of(attr, validation_options = {}, given_column_options = {})
-      model = define_model_validating_absence_of(
-        attr,
-        validation_options,
-        given_column_options
-      )
-      model.new
-    end
-    alias_method :build_record_validating_absence_of, :validating_absence_of
-
-    def active_model_with(attr, &block)
-      define_active_model_class('Example', accessors: [attr], &block).new
-    end
-
-    def active_model_validating_absence_of(attr)
-      active_model_with(attr) do
-        validates_absence_of attr
-      end
-    end
-
-    def having_many(plural_name, options = {})
-      define_model plural_name.to_s.singularize
-      define_model :parent do
-        has_many plural_name
-        if options[:absence]
-          validates_absence_of plural_name
-        end
-      end.new
-    end
-
-    def having_and_belonging_to_many(plural_name, options = {})
-      create_table 'children_parents', id: false do |t|
-        t.integer "#{plural_name.to_s.singularize}_id"
-        t.integer :parent_id
-      end
-
-      define_model plural_name.to_s.singularize
-      define_model :parent do
-        has_and_belongs_to_many plural_name
-        if options[:absence]
-          validates_absence_of plural_name
-        end
-      end.new
-    end
-
-    def validation_matcher_scenario_args
-      super.deep_merge(matcher_name: :validate_absence_of)
-    end
-  end
-end