shoulda-matchers 3.0.1 → 3.1.0

data/lib/shoulda/matchers/active_model/allow_value_matcher/attribute_changed_value_error.rb

@@ -0,0 +1,45 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      class AllowValueMatcher
+        # @private
+        class AttributeChangedValueError < Shoulda::Matchers::Error
+          attr_accessor :matcher_name, :model, :attribute_name, :value_written,
+            :value_read
+
+          def message
+            Shoulda::Matchers.word_wrap <<-MESSAGE
+The #{matcher_name} matcher attempted to set :#{attribute_name} on
+#{model.name} to #{value_written.inspect}, but when the attribute was
+read back, it had stored #{value_read.inspect} instead.
+
+This creates a problem because it means that the model is behaving in a
+way that is interfering with the test -- there's a mismatch between the
+test that you wrote and test that we actually ran.
+
+There are a couple of reasons why this could be happening:
+
+* ActiveRecord is typecasting the incoming value.
+* The writer method for :#{attribute_name} has been overridden so that
+  incoming values are changed in some way.
+
+If this exception makes sense to you and you wish to bypass it, try
+adding the `ignoring_interference_by_writer` qualifier onto the end of
+your matcher. If the test still does not pass after that, then you may
+need to do something different.
+
+If you need help, feel free to ask a question on the shoulda-matchers
+issues list:
+
+http://github.com/thoughtbot/shoulda-matchers/issues
+            MESSAGE
+          end
+
+          def successful?
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoulda/matchers/active_model/allow_value_matcher/attribute_does_not_exist_error.rb

@@ -0,0 +1,23 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      class AllowValueMatcher
+        # @private
+        class AttributeDoesNotExistError < Shoulda::Matchers::Error
+          attr_accessor :model, :attribute_name, :value
+
+          def message
+            Shoulda::Matchers.word_wrap <<-MESSAGE
+The matcher attempted to set :#{attribute_name} on the #{model.name} to
+#{value.inspect}, but that attribute does not exist.
+            MESSAGE
+          end
+
+          def successful?
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoulda/matchers/active_model/allow_value_matcher/attribute_setter.rb

@@ -0,0 +1,236 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      class AllowValueMatcher
+        # @private
+        class AttributeSetter
+          def self.set(args)
+            new(args).set
+          end
+
+          attr_reader(
+            :attribute_name,
+            :result_of_checking,
+            :result_of_setting,
+            :value_written,
+          )
+
+          def initialize(args)
+            @args = args
+            @matcher_name = args.fetch(:matcher_name)
+            @object = args.fetch(:object)
+            @attribute_name = args.fetch(:attribute_name)
+            @value_written = args.fetch(:value)
+            @ignore_interference_by_writer = args.fetch(
+              :ignore_interference_by_writer,
+              Qualifiers::IgnoreInterferenceByWriter.new
+            )
+            @after_set_callback = args.fetch(:after_set_callback, -> { })
+
+            @result_of_checking = nil
+            @result_of_setting = nil
+          end
+
+          def description
+            description = ":#{attribute_name} to "
+            description << Shoulda::Matchers::Util.inspect_value(value_written)
+
+            if attribute_changed_value?
+              description << " -- which was read back as "
+              description << Shoulda::Matchers::Util.inspect_value(value_read)
+              description << " --"
+            end
+
+            description
+          end
+
+          def run
+            check && set
+          end
+
+          def run!
+            check && set!
+          end
+
+          def check
+            if attribute_exists?
+              @result_of_checking = successful_check
+              true
+            else
+              @result_of_checking = attribute_does_not_exist_error
+              false
+            end
+          end
+
+          def set!
+            if attribute_exists?
+              set
+
+              unless result_of_setting.successful?
+                raise result_of_setting
+              end
+
+              @result_of_checking = successful_check
+              @result_of_setting = successful_setting
+
+              true
+            else
+              attribute_does_not_exist!
+            end
+          end
+
+          def set
+            object.public_send("#{attribute_name}=", value_written)
+            after_set_callback.call
+
+            @result_of_checking = successful_check
+
+            if raise_attribute_changed_value_error?
+              @result_of_setting = attribute_changed_value_error
+              false
+            else
+              @result_of_setting = successful_setting
+              true
+            end
+          end
+
+          def failure_message
+            if successful?
+              raise "We're not supposed to be here!"
+            elsif result_of_setting
+              result_of_setting.message
+            else
+              result_of_checking.message
+            end
+          end
+
+          def successful?
+            successfully_checked? && successfully_set?
+          end
+
+          def unsuccessful?
+            !successful?
+          end
+
+          def checked?
+            !result_of_checking.nil?
+          end
+
+          def successfully_checked?
+            checked? && result_of_checking.successful?
+          end
+
+          def unsuccessfully_checked?
+            !successfully_checked?
+          end
+
+          def set?
+            !result_of_setting.nil?
+          end
+
+          def successfully_set?
+            set? && result_of_setting.successful?
+          end
+
+          def value_read
+            @_value_read ||= object.public_send(attribute_name)
+          end
+
+          def attribute_changed_value?
+            value_written != value_read
+          end
+
+          protected
+
+          attr_reader :args, :matcher_name, :object, :after_set_callback
+
+          private
+
+          def model
+            object.class
+          end
+
+          def attribute_exists?
+            if active_resource_object?
+              object.known_attributes.include?(attribute_name.to_s)
+            else
+              object.respond_to?("#{attribute_name}=")
+            end
+          end
+
+          def ignore_interference_by_writer
+            @ignore_interference_by_writer
+          end
+
+          def raise_attribute_changed_value_error?
+            attribute_changed_value? &&
+              !(attribute_is_an_enum? && value_read_is_expected_for_an_enum?) &&
+              !ignore_interference_by_writer.considering?(value_read)
+          end
+
+          def attribute_is_an_enum?
+            enum_values.any?
+          end
+
+          def value_read_is_expected_for_an_enum?
+            enum_values.key?(value_read) &&
+              enum_values[value_read] == value_written
+          end
+
+          def enum_values
+            defined_enums.fetch(attribute_name.to_s, {})
+          end
+
+          def defined_enums
+            if model.respond_to?(:defined_enums)
+              model.defined_enums
+            else
+              {}
+            end
+          end
+
+          def successful_check
+            SuccessfulCheck.new
+          end
+
+          def successful_setting
+            SuccessfulSetting.new
+          end
+
+          def attribute_changed_value!
+            raise attribute_changed_value_error
+          end
+
+          def attribute_changed_value_error
+            AttributeChangedValueError.create(
+              model: object.class,
+              attribute_name: attribute_name,
+              value_written: value_written,
+              value_read: value_read
+            )
+          end
+
+          def attribute_does_not_exist!
+            raise attribute_does_not_exist_error
+          end
+
+          def attribute_does_not_exist_error
+            AttributeDoesNotExistError.create(
+              model: object.class,
+              attribute_name: attribute_name,
+              value: value_written
+            )
+          end
+
+          def active_resource_object?
+            object.respond_to?(:known_attributes)
+          end
+
+          def model
+            object.class
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoulda/matchers/active_model/allow_value_matcher/attribute_setter_and_validator.rb

@@ -0,0 +1,62 @@
+require 'forwardable'
+
+module Shoulda
+  module Matchers
+    module ActiveModel
+      class AllowValueMatcher
+        # @private
+        class AttributeSetterAndValidator
+          extend Forwardable
+
+          def_delegators(
+            :allow_value_matcher,
+            :after_setting_value_callback,
+            :attribute_to_check_message_against,
+            :context,
+            :expected_message,
+            :expects_strict?,
+            :ignore_interference_by_writer,
+            :instance,
+          )
+
+          def initialize(allow_value_matcher, attribute_name, value)
+            @allow_value_matcher = allow_value_matcher
+            @attribute_name = attribute_name
+            @value = value
+            @_attribute_setter = nil
+            @_validator = nil
+          end
+
+          def attribute_setter
+            @_attribute_setter ||= AttributeSetter.new(
+              matcher_name: :allow_value,
+              object: instance,
+              attribute_name: attribute_name,
+              value: value,
+              ignore_interference_by_writer: ignore_interference_by_writer,
+              after_set_callback: after_setting_value_callback
+            )
+          end
+
+          def attribute_setter_description
+            attribute_setter.description
+          end
+
+          def validator
+            @_validator ||= Validator.new(
+              instance,
+              attribute_to_check_message_against,
+              context: context,
+              expects_strict: expects_strict?,
+              expected_message: expected_message
+            )
+          end
+
+          protected
+
+          attr_reader :allow_value_matcher, :attribute_name, :value
+        end
+      end
+    end
+  end
+end

data/lib/shoulda/matchers/active_model/allow_value_matcher/attribute_setters.rb

@@ -0,0 +1,40 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      class AllowValueMatcher
+        # @private
+        class AttributeSetters
+          include Enumerable
+
+          def initialize(allow_value_matcher, values)
+            @tuples = values.map do |attribute_name, value|
+              AttributeSetterAndValidator.new(
+                allow_value_matcher,
+                attribute_name,
+                value
+              )
+            end
+          end
+
+          def each(&block)
+            tuples.each(&block)
+          end
+
+          def first_failing
+            tuples.detect(&method(:does_not_match?))
+          end
+
+          protected
+
+          attr_reader :tuples
+
+          private
+
+          def does_not_match?(tuple)
+            !tuple.attribute_setter.set!
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoulda/matchers/active_model/allow_value_matcher/attribute_setters_and_validators.rb

@@ -0,0 +1,48 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      class AllowValueMatcher
+        # @private
+        class AttributeSettersAndValidators
+          include Enumerable
+
+          def initialize(allow_value_matcher, values)
+            @tuples = values.map do |attribute_name, value|
+              AttributeSetterAndValidator.new(
+                allow_value_matcher,
+                attribute_name,
+                value
+              )
+            end
+          end
+
+          def each(&block)
+            tuples.each(&block)
+          end
+
+          def first_passing
+            tuples.detect(&method(:matches?))
+          end
+
+          def first_failing
+            tuples.detect(&method(:does_not_match?))
+          end
+
+          protected
+
+          attr_reader :tuples
+
+          private
+
+          def matches?(tuple)
+            tuple.attribute_setter.set! && tuple.validator.call
+          end
+
+          def does_not_match?(tuple)
+            !matches?(tuple)
+          end
+        end
+      end
+    end
+  end
+end