active_storage_validations 1.1.1 → 1.2.0

data/lib/active_storage_validations/matchers/aspect_ratio_validator_matcher.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require_relative 'concerns/active_storageable.rb'
+require_relative 'concerns/allow_blankable.rb'
+require_relative 'concerns/attachable.rb'
+require_relative 'concerns/contextable.rb'
+require_relative 'concerns/messageable.rb'
+require_relative 'concerns/rspecable.rb'
+require_relative 'concerns/validatable.rb'
+
+module ActiveStorageValidations
+  module Matchers
+    def validate_aspect_ratio_of(attribute_name)
+      AspectRatioValidatorMatcher.new(attribute_name)
+    end
+
+    class AspectRatioValidatorMatcher
+      include ActiveStorageable
+      include AllowBlankable
+      include Attachable
+      include Contextable
+      include Messageable
+      include Rspecable
+      include Validatable
+
+      def initialize(attribute_name)
+        initialize_allow_blankable
+        initialize_contextable
+        initialize_messageable
+        initialize_rspecable
+        @attribute_name = attribute_name
+        @allowed_aspect_ratios = @rejected_aspect_ratios = []
+      end
+
+      def description
+        "validate the aspect ratios allowed on :#{@attribute_name}."
+      end
+
+      def failure_message
+        "is expected to validate aspect ratio of :#{@attribute_name}"
+      end
+
+      def allowing(*aspect_ratios)
+        @allowed_aspect_ratios = aspect_ratios.flatten
+        self
+      end
+
+      def rejecting(*aspect_ratios)
+        @rejected_aspect_ratios = aspect_ratios.flatten
+        self
+      end
+
+      def matches?(subject)
+        @subject = subject.is_a?(Class) ? subject.new : subject
+
+        is_a_valid_active_storage_attribute? &&
+          is_context_valid? &&
+          is_allowing_blank? &&
+          is_custom_message_valid? &&
+          all_allowed_aspect_ratios_allowed? &&
+          all_rejected_aspect_ratios_rejected?
+      end
+
+      protected
+
+      def all_allowed_aspect_ratios_allowed?
+        @allowed_aspect_ratios_not_allowed ||= @allowed_aspect_ratios.reject { |aspect_ratio| aspect_ratio_allowed?(aspect_ratio) }
+        @allowed_aspect_ratios_not_allowed.empty?
+      end
+
+      def all_rejected_aspect_ratios_rejected?
+        @rejected_aspect_ratios_not_rejected ||= @rejected_aspect_ratios.select { |aspect_ratio| aspect_ratio_allowed?(aspect_ratio) }
+        @rejected_aspect_ratios_not_rejected.empty?
+      end
+
+      def aspect_ratio_allowed?(aspect_ratio)
+        width, height = valid_width_and_height_for(aspect_ratio)
+
+        mock_dimensions_for(attach_file, width, height) do
+          validate
+          detach_file
+          is_valid?
+        end
+      end
+
+      def is_custom_message_valid?
+        return true unless @custom_message
+
+        mock_dimensions_for(attach_file, -1, -1) do
+          validate
+          detach_file
+          has_an_error_message_which_is_custom_message?
+        end
+      end
+
+      def mock_dimensions_for(attachment, width, height)
+        Matchers.mock_metadata(attachment, width, height) do
+          yield
+        end
+      end
+
+      def valid_width_and_height_for(aspect_ratio)
+        case aspect_ratio
+        when :square then [100, 100]
+        when :portrait then [100, 200]
+        when :landscape then [200, 100]
+        when validator_class::ASPECT_RATIO_REGEX
+          aspect_ratio =~ validator_class::ASPECT_RATIO_REGEX
+          x = Regexp.last_match(1).to_i
+          y = Regexp.last_match(2).to_i
+
+          [100 * x, 100 * y]
+        else
+          [-1, -1]
+        end
+      end
+    end
+  end
+end

data/lib/active_storage_validations/matchers/attached_validator_matcher.rb

@@ -1,68 +1,81 @@
 # frozen_string_literal: true
 
+require_relative 'concerns/active_storageable.rb'
+require_relative 'concerns/attachable.rb'
+require_relative 'concerns/contextable.rb'
+require_relative 'concerns/messageable.rb'
+require_relative 'concerns/rspecable.rb'
+require_relative 'concerns/validatable.rb'
+
 module ActiveStorageValidations
   module Matchers
-    def validate_attached_of(name)
-      AttachedValidatorMatcher.new(name)
+    def validate_attached_of(attribute_name)
+      AttachedValidatorMatcher.new(attribute_name)
     end
 
     class AttachedValidatorMatcher
+      include ActiveStorageable
+      include Attachable
+      include Contextable
+      include Messageable
+      include Rspecable
+      include Validatable
+
       def initialize(attribute_name)
+        initialize_contextable
+        initialize_messageable
+        initialize_rspecable
         @attribute_name = attribute_name
-        @custom_message = nil
       end
 
       def description
-        "validate #{@attribute_name} must be attached"
+        "validate that :#{@attribute_name} must be attached"
       end
 
-      def with_message(message)
-        @custom_message = message
-        self
+      def failure_message
+        "is expected to validate attachment of :#{@attribute_name}"
       end
 
       def matches?(subject)
         @subject = subject.is_a?(Class) ? subject.new : subject
-        responds_to_methods && valid_when_attached && invalid_when_not_attached
-      end
-
-      def failure_message
-        "is expected to validate attached of #{@attribute_name}"
-      end
 
-      def failure_message_when_negated
-        "is expected to not validate attached of #{@attribute_name}"
+        is_a_valid_active_storage_attribute? &&
+          is_context_valid? &&
+          is_custom_message_valid? &&
+          is_valid_when_file_attached? &&
+          is_invalid_when_file_not_attached?
       end
 
       private
 
-      def responds_to_methods
-        @subject.respond_to?(@attribute_name) &&
-          @subject.public_send(@attribute_name).respond_to?(:attach) &&
-          @subject.public_send(@attribute_name).respond_to?(:detach)
+      def is_valid_when_file_attached?
+        attach_file unless file_attached?
+        validate
+        is_valid?
       end
 
-      def valid_when_attached
-        @subject.public_send(@attribute_name).attach(attachable) unless @subject.public_send(@attribute_name).attached?
-        @subject.validate
-        @subject.errors.details[@attribute_name].exclude?(error: error_message)
+      def is_invalid_when_file_not_attached?
+        detach_file if file_attached?
+        validate
+        !is_valid?
       end
 
-      def invalid_when_not_attached
-        @subject.public_send(@attribute_name).detach
-        # Unset the direct relation since `detach` on an unpersisted record does not set `attached?` to false.
-        @subject.public_send("#{@attribute_name}=", nil)
+      def is_custom_message_valid?
+        return true unless @custom_message
 
-        @subject.validate
-        @subject.errors.details[@attribute_name].include?(error: error_message)
+        detach_file if file_attached?
+        validate
+        has_an_error_message_which_is_custom_message?
       end
 
-      def error_message
-        @custom_message || :blank
+      def file_attached?
+        @subject.public_send(@attribute_name).attached?
       end
 
-      def attachable
-        { io: Tempfile.new('.'), filename: 'dummy.txt', content_type: 'text/plain' }
+      def detach_file
+        @subject.public_send(@attribute_name).detach
+        # Unset the direct relation since `detach` on an unpersisted record does not set `attached?` to false.
+        @subject.public_send("#{@attribute_name}=", nil)
       end
     end
   end

data/lib/active_storage_validations/matchers/base_size_validator_matcher.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+# Big thank you to the paperclip validation matchers:
+# https://github.com/thoughtbot/paperclip/blob/v6.1.0/lib/paperclip/matchers/validate_attachment_size_matcher.rb
+
+require_relative 'concerns/active_storageable.rb'
+require_relative 'concerns/allow_blankable.rb'
+require_relative 'concerns/attachable.rb'
+require_relative 'concerns/contextable.rb'
+require_relative 'concerns/messageable.rb'
+require_relative 'concerns/rspecable.rb'
+require_relative 'concerns/validatable.rb'
+
+module ActiveStorageValidations
+  module Matchers
+    class BaseSizeValidatorMatcher
+      # BaseSizeValidatorMatcher is an abstract class and shouldn't be instantiated directly.
+
+      include ActiveStorageable
+      include AllowBlankable
+      include Attachable
+      include Contextable
+      include Messageable
+      include Rspecable
+      include Validatable
+
+      def initialize(attribute_name)
+        initialize_allow_blankable
+        initialize_contextable
+        initialize_messageable
+        initialize_rspecable
+        @attribute_name = attribute_name
+        @min = @max = nil
+      end
+
+      def less_than(size)
+        @max = size - 1.byte
+        self
+      end
+
+      def less_than_or_equal_to(size)
+        @max = size
+        self
+      end
+
+      def greater_than(size)
+        @min = size + 1.byte
+        self
+      end
+
+      def greater_than_or_equal_to(size)
+        @min = size
+        self
+      end
+
+      def between(range)
+        @min, @max = range.first, range.last
+        self
+      end
+
+      def matches?(subject)
+        @subject = subject.is_a?(Class) ? subject.new : subject
+
+        is_a_valid_active_storage_attribute? &&
+          is_context_valid? &&
+          is_allowing_blank? &&
+          is_custom_message_valid? &&
+          not_lower_than_min? &&
+          higher_than_min? &&
+          lower_than_max? &&
+          not_higher_than_max?
+      end
+
+      protected
+
+      def build_failure_message(message)
+        return unless @failure_message_artefacts.present?
+
+        message << "  but there seem to have issues with the matcher methods you used, since:"
+        @failure_message_artefacts.each do |error_case|
+          message << "  validation failed when provided with a #{error_case[:size]} bytes test file"
+        end
+        message << "  whereas it should have passed"
+      end
+
+      def not_lower_than_min?
+        @min.nil? || !passes_validation_with_size(@min - 1)
+      end
+
+      def higher_than_min?
+        @min.nil? || passes_validation_with_size(@min + 1)
+      end
+
+      def lower_than_max?
+        @max.nil? || @max == Float::INFINITY || passes_validation_with_size(@max - 1)
+      end
+
+      def not_higher_than_max?
+        @max.nil? || @max == Float::INFINITY || !passes_validation_with_size(@max + 1)
+      end
+
+      def passes_validation_with_size(size)
+        mock_size_for(io, size) do
+          attach_file
+          validate
+          detach_file
+          is_valid? || add_failure_message_artefact(size)
+        end
+      end
+
+      def add_failure_message_artefact(size)
+        @failure_message_artefacts << { size: size }
+        false
+      end
+
+      def is_custom_message_valid?
+        return true unless @custom_message
+
+        mock_size_for(io, -1.kilobytes) do
+          attach_file
+          validate
+          detach_file
+          has_an_error_message_which_is_custom_message?
+        end
+      end
+
+      def mock_size_for(io, size)
+        Matchers.stub_method(io, :size, size) do
+          yield
+        end
+      end
+    end
+  end
+end

data/lib/active_storage_validations/matchers/concerns/active_storageable.rb

@@ -0,0 +1,17 @@
+require "active_support/concern"
+
+module ActiveStorageValidations
+  module Matchers
+    module ActiveStorageable
+      extend ActiveSupport::Concern
+
+      private
+
+      def is_a_valid_active_storage_attribute?
+        @subject.respond_to?(@attribute_name) &&
+          @subject.public_send(@attribute_name).respond_to?(:attach) &&
+          @subject.public_send(@attribute_name).respond_to?(:detach)
+      end
+    end
+  end
+end

data/lib/active_storage_validations/matchers/concerns/allow_blankable.rb

@@ -0,0 +1,26 @@
+require "active_support/concern"
+
+module ActiveStorageValidations
+  module Matchers
+    module AllowBlankable
+      extend ActiveSupport::Concern
+
+      def initialize_allow_blankable
+        @allow_blank = nil
+      end
+
+      def allow_blank
+        @allow_blank = true
+        self
+      end
+
+      private
+
+      def is_allowing_blank?
+        return true unless @allow_blank
+
+        validate
+      end
+    end
+  end
+end

data/lib/active_storage_validations/matchers/concerns/attachable.rb

@@ -0,0 +1,48 @@
+module ActiveStorageValidations
+  module Matchers
+    module Attachable
+      private
+
+      def attach_file(file = dummy_file)
+        @subject.public_send(@attribute_name).attach(file)
+        @subject.public_send(@attribute_name)
+      end
+
+      def dummy_file
+        {
+          io: io,
+          filename: 'test.png',
+          content_type: 'image/png'
+        }
+      end
+
+      def processable_image
+        {
+          io: File.open(Rails.root.join('public', 'image_1920x1080.png')),
+          filename: 'image_1920x1080_file.png',
+          content_type: 'image/png'
+        }
+      end
+
+      def not_processable_image
+        {
+          io: Tempfile.new('.'),
+          filename: 'processable.txt',
+          content_type: 'text/plain'
+        }
+      end
+
+      def io
+        @io ||= Tempfile.new('Hello world!')
+      end
+
+      def detach_file
+        @subject.attachment_changes.delete(@attribute_name.to_s)
+      end
+
+      def file_attached?
+        @subject.public_send(@attribute_name).attached?
+      end
+    end
+  end
+end

data/lib/active_storage_validations/matchers/concerns/contextable.rb

@@ -0,0 +1,47 @@
+require "active_support/concern"
+
+module ActiveStorageValidations
+  module Matchers
+    module Contextable
+      extend ActiveSupport::Concern
+
+      def initialize_contextable
+        @context = nil
+      end
+
+      def on(context)
+        @context = context
+        self
+      end
+
+      private
+
+      def is_context_valid?
+        return true if !@context && attribute_validators.none? { |validator| validator.options[:on] }
+
+        raise ArgumentError, "This validator matcher needs the #on option to work since its validator has one" if !@context && attribute_validators.all? { |validator| validator.options[:on] }
+        raise ArgumentError, "This validator matcher option only allows a symbol or an array" if !(@context.is_a?(Symbol) || @context.is_a?(Array))
+
+        if @context.is_a?(Array)
+          (validator_contexts & @context.map(&:to_s)) == validator_contexts || raise_context_not_listed_error
+        elsif @context.is_a?(Symbol)
+          validator_contexts.include?(@context.to_s) || raise_context_not_listed_error
+        end
+      end
+
+      def validator_contexts
+        attribute_validators.map do |validator|
+          case validator.options[:on]
+          when Array then validator.options[:on].map { |context| context.to_s }
+          when NilClass then nil
+          else validator.options[:on].to_s
+          end
+        end.flatten.compact
+      end
+
+      def raise_context_not_listed_error
+        raise ArgumentError, "One of the provided contexts to the #on method is not found in any of the listed contexts for this attribute"
+      end
+    end
+  end
+end

data/lib/active_storage_validations/matchers/concerns/messageable.rb

@@ -0,0 +1,26 @@
+require "active_support/concern"
+
+module ActiveStorageValidations
+  module Matchers
+    module Messageable
+      extend ActiveSupport::Concern
+
+      def initialize_messageable
+        @custom_message = nil
+      end
+
+      def with_message(custom_message)
+        @custom_message = custom_message
+        self
+      end
+
+      private
+
+      def has_an_error_message_which_is_custom_message?
+        validator_errors_for_attribute.one? do |error|
+          error[:error] == @custom_message
+        end
+      end
+    end
+  end
+end

data/lib/active_storage_validations/matchers/concerns/rspecable.rb

@@ -0,0 +1,25 @@
+require "active_support/concern"
+
+module ActiveStorageValidations
+  module Matchers
+    module Rspecable
+      extend ActiveSupport::Concern
+
+      def initialize_rspecable
+        @failure_message_artefacts = []
+      end
+
+      def description
+        raise NotImplementedError, "#{self.class} did not define #{__method__}"
+      end
+
+      def failure_message
+        raise NotImplementedError, "#{self.class} did not define #{__method__}"
+      end
+
+      def failure_message_when_negated
+        failure_message.sub(/is expected to validate/, 'is expected not to validate')
+      end
+    end
+  end
+end

data/lib/active_storage_validations/matchers/concerns/validatable.rb

@@ -0,0 +1,54 @@
+require "active_support/concern"
+
+module ActiveStorageValidations
+  module Matchers
+    module Validatable
+      extend ActiveSupport::Concern
+
+      private
+
+      def validate
+        @subject.validate(@context)
+      end
+
+      def validator_errors_for_attribute
+        @subject.errors.details[@attribute_name].select do |error|
+          error[:validator_type] == validator_class.to_sym
+        end
+      end
+
+      def is_valid?
+        validator_errors_for_attribute.none? do |error|
+          error[:error].in?(available_errors)
+        end
+      end
+
+      def available_errors
+        [
+          *validator_class::ERROR_TYPES,
+          *errors_from_custom_messages
+        ].compact
+      end
+
+      def validator_class
+        self.class.name.gsub(/::Matchers|Matcher/, '').constantize
+      end
+
+      def attribute_validator
+        @subject.class.validators_on(@attribute_name).find do |validator|
+          validator.class == validator_class
+        end
+      end
+
+      def attribute_validators
+        @subject.class.validators_on(@attribute_name).select do |validator|
+          validator.class == validator_class
+        end
+      end
+
+      def errors_from_custom_messages
+        attribute_validators.map { |validator| validator.options[:message] }
+      end
+    end
+  end
+end