ultra-fast-box 0.0.1

data/shoulda-matchers-8.0.1/lib/shoulda/matchers/active_model/validation_message_finder.rb

@@ -0,0 +1,63 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      # @private
+      class ValidationMessageFinder
+        include Helpers
+
+        def initialize(instance, attribute, context = nil)
+          @instance = instance
+          @attribute = attribute
+          @context = context
+        end
+
+        def allow_description(allowed_values)
+          "allow #{@attribute} to be set to #{allowed_values}"
+        end
+
+        def expected_message_from(attribute_message)
+          attribute_message
+        end
+
+        def has_messages?
+          errors.present?
+        end
+
+        def source_description
+          'errors'
+        end
+
+        def messages_description
+          if errors.empty?
+            ' no errors'
+          else
+            " errors:\n#{pretty_error_messages(validated_instance)}"
+          end
+        end
+
+        def messages
+          Array(messages_for_attribute)
+        end
+
+        private
+
+        def messages_for_attribute
+          errors[@attribute]
+        end
+
+        def errors
+          validated_instance.errors
+        end
+
+        def validated_instance
+          @_validated_instance ||= validate_instance
+        end
+
+        def validate_instance
+          @instance.valid?(*@context)
+          @instance
+        end
+      end
+    end
+  end
+end

data/shoulda-matchers-8.0.1/lib/shoulda/matchers/active_model/validator.rb

@@ -0,0 +1,127 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      # @private
+      class Validator
+        include Helpers
+
+        def initialize(record, attribute, options = {})
+          @record = record
+          @attribute = attribute
+          @context = options[:context]
+          @expects_strict = options[:expects_strict]
+          @expected_message = options[:expected_message]
+
+          @_validation_result = nil
+          @captured_validation_exception = false
+          @captured_range_error = false
+        end
+
+        def call
+          !messages_match? && !captured_range_error?
+        end
+
+        def has_messages?
+          messages.any?
+        end
+
+        def has_any_errors?
+          record.errors.any?
+        end
+
+        def captured_validation_exception?
+          @captured_validation_exception
+        end
+
+        def type_of_message_matched?
+          expects_strict? == captured_validation_exception?
+        end
+
+        def all_formatted_validation_error_messages
+          format_validation_errors(all_validation_errors)
+        end
+
+        def validation_exception_message
+          validation_result[:validation_exception_message]
+        end
+
+        def formatted_validation_error_messages
+          format_validation_errors(all_validation_errors, attribute)
+        end
+
+        protected
+
+        attr_reader :attribute, :context, :record
+
+        private
+
+        def expects_strict?
+          @expects_strict
+        end
+
+        def messages_match?
+          has_messages? &&
+            type_of_message_matched? &&
+            matched_messages.compact.any?
+        end
+
+        def messages
+          if expects_strict?
+            [validation_exception_message]
+          else
+            validation_error_messages
+          end
+        end
+
+        def matched_messages
+          if @expected_message
+            messages.grep(@expected_message)
+          else
+            messages
+          end
+        end
+
+        def captured_range_error?
+          !!@captured_range_error
+        end
+
+        def all_validation_errors
+          validation_result[:all_validation_errors]
+        end
+
+        def validation_error_messages
+          validation_result[:validation_error_messages]
+        end
+
+        def validation_result
+          @_validation_result ||= perform_validation
+        end
+
+        def perform_validation
+          if context
+            record.valid?(context)
+          else
+            record.valid?
+          end
+
+          all_validation_errors = record.errors.dup
+
+          validation_error_messages = record.errors[attribute]
+
+          {
+            all_validation_errors:,
+            validation_error_messages:,
+            validation_exception_message: nil,
+          }
+        rescue ::ActiveModel::StrictValidationFailed => e
+          @captured_validation_exception = true
+          {
+            all_validation_errors: nil,
+            validation_error_messages: [],
+            validation_exception_message: e.message,
+          }
+        end
+      end
+    end
+  end
+end

data/shoulda-matchers-8.0.1/lib/shoulda/matchers/active_model.rb

@@ -0,0 +1,96 @@
+require 'shoulda/matchers/active_model/helpers'
+require 'shoulda/matchers/active_model/qualifiers'
+require 'shoulda/matchers/active_model/validation_matcher'
+require 'shoulda/matchers/active_model/validation_matcher/build_description'
+require 'shoulda/matchers/active_model/validator'
+require 'shoulda/matchers/active_model/allow_value_matcher'
+require 'shoulda/matchers/active_model/allow_value_matcher/attribute_changed_value_error'
+require 'shoulda/matchers/active_model/allow_value_matcher/attribute_does_not_exist_error'
+require 'shoulda/matchers/active_model/allow_value_matcher/attribute_setter'
+require 'shoulda/matchers/active_model/allow_value_matcher/attribute_setter_and_validator'
+require 'shoulda/matchers/active_model/allow_value_matcher/attribute_setters'
+require 'shoulda/matchers/active_model/allow_value_matcher/attribute_setters_and_validators'
+require 'shoulda/matchers/active_model/allow_value_matcher/successful_check'
+require 'shoulda/matchers/active_model/allow_value_matcher/successful_setting'
+require 'shoulda/matchers/active_model/disallow_value_matcher'
+require 'shoulda/matchers/active_model/validate_length_of_matcher'
+require 'shoulda/matchers/active_model/validate_inclusion_of_matcher'
+require 'shoulda/matchers/active_model/validate_exclusion_of_matcher'
+require 'shoulda/matchers/active_model/validate_absence_of_matcher'
+require 'shoulda/matchers/active_model/validate_presence_of_matcher'
+require 'shoulda/matchers/active_model/validate_acceptance_of_matcher'
+require 'shoulda/matchers/active_model/validate_confirmation_of_matcher'
+require 'shoulda/matchers/active_model/validate_numericality_of_matcher'
+require 'shoulda/matchers/active_model/validate_comparison_of_matcher'
+require 'shoulda/matchers/active_model/comparison_matcher'
+require 'shoulda/matchers/active_model/numericality_matchers/numeric_type_matcher'
+require 'shoulda/matchers/active_model/numericality_matchers/odd_number_matcher'
+require 'shoulda/matchers/active_model/numericality_matchers/even_number_matcher'
+require 'shoulda/matchers/active_model/numericality_matchers/only_integer_matcher'
+require 'shoulda/matchers/active_model/numericality_matchers/range_matcher'
+require 'shoulda/matchers/active_model/numericality_matchers/submatchers'
+require 'shoulda/matchers/active_model/errors'
+require 'shoulda/matchers/active_model/have_secure_password_matcher'
+
+module Shoulda
+  module Matchers
+    # This module provides matchers that are used to test behavior within
+    # ActiveModel or ActiveRecord classes.
+    #
+    # ### Testing conditional validations
+    #
+    # If your model defines a validation conditionally -- meaning that the
+    # validation is declared with an `:if` or `:unless` option -- how do you
+    # test it? You might expect the validation matchers here to have
+    # corresponding `if` or `unless` qualifiers, but this isn't what you use.
+    # Instead, before using the matcher in question, you place the record
+    # you're testing in a state such that the validation you're also testing
+    # will be run. A common way to do this is to make a new `context` and
+    # override the subject to populate the record accordingly. You'll also want
+    # to make sure to test that the validation is *not* run when the
+    # conditional fails.
+    #
+    # Here's an example to illustrate what we mean:
+    #
+    #     class User
+    #       include ActiveModel::Model
+    #
+    #       attr_accessor :role, :admin
+    #
+    #       validates_presence_of :role, if: :admin
+    #     end
+    #
+    #     # RSpec
+    #     RSpec.describe User, type: :model do
+    #       context "when an admin" do
+    #         subject { User.new(admin: true) }
+    #
+    #         it { should validate_presence_of(:role) }
+    #       end
+    #
+    #       context "when not an admin" do
+    #         subject { User.new(admin: false) }
+    #
+    #         it { should_not validate_presence_of(:role) }
+    #       end
+    #     end
+    #
+    #     # Minitest (Shoulda)
+    #     class UserTest < ActiveSupport::TestCase
+    #       context "when an admin" do
+    #         subject { User.new(admin: true) }
+    #
+    #         should validate_presence_of(:role)
+    #       end
+    #
+    #       context "when not an admin" do
+    #         subject { User.new(admin: false) }
+    #
+    #         should_not validate_presence_of(:role)
+    #       end
+    #     end
+    #
+    module ActiveModel
+    end
+  end
+end

data/shoulda-matchers-8.0.1/lib/shoulda/matchers/active_record/accept_nested_attributes_for_matcher.rb

@@ -0,0 +1,217 @@
+module Shoulda
+  module Matchers
+    module ActiveRecord
+      # The `accept_nested_attributes_for` matcher tests usage of the
+      # `accepts_nested_attributes_for` macro.
+      #
+      #     class Car < ActiveRecord::Base
+      #       accepts_nested_attributes_for :doors
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Car, type: :model do
+      #       it { should accept_nested_attributes_for(:doors) }
+      #     end
+      #
+      #     # Minitest (Shoulda) (using Shoulda)
+      #     class CarTest < ActiveSupport::TestCase
+      #       should accept_nested_attributes_for(:doors)
+      #     end
+      #
+      # #### Qualifiers
+      #
+      # ##### allow_destroy
+      #
+      # Use `allow_destroy` to assert that the `:allow_destroy` option was
+      # specified.
+      #
+      #     class Car < ActiveRecord::Base
+      #       accepts_nested_attributes_for :mirrors, allow_destroy: true
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Car, type: :model do
+      #       it do
+      #         should accept_nested_attributes_for(:mirrors).
+      #           allow_destroy(true)
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class CarTest < ActiveSupport::TestCase
+      #       should accept_nested_attributes_for(:mirrors).
+      #         allow_destroy(true)
+      #     end
+      #
+      # ##### limit
+      #
+      # Use `limit` to assert that the `:limit` option was specified.
+      #
+      #     class Car < ActiveRecord::Base
+      #       accepts_nested_attributes_for :windows, limit: 3
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Car, type: :model do
+      #       it do
+      #         should accept_nested_attributes_for(:windows).
+      #           limit(3)
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class CarTest < ActiveSupport::TestCase
+      #       should accept_nested_attributes_for(:windows).
+      #         limit(3)
+      #     end
+      #
+      # ##### update_only
+      #
+      # Use `update_only` to assert that the `:update_only` option was
+      # specified.
+      #
+      #     class Car < ActiveRecord::Base
+      #       accepts_nested_attributes_for :engine, update_only: true
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Car, type: :model do
+      #       it do
+      #         should accept_nested_attributes_for(:engine).
+      #           update_only(true)
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class CarTest < ActiveSupport::TestCase
+      #       should accept_nested_attributes_for(:engine).
+      #         update_only(true)
+      #     end
+      #
+      # @return [AcceptNestedAttributesForMatcher]
+      #
+      def accept_nested_attributes_for(name)
+        AcceptNestedAttributesForMatcher.new(name)
+      end
+
+      # @private
+      class AcceptNestedAttributesForMatcher
+        def initialize(name)
+          @name = name
+          @options = {}
+        end
+
+        def allow_destroy(allow_destroy)
+          @options[:allow_destroy] = allow_destroy
+          self
+        end
+
+        def limit(limit)
+          @options[:limit] = limit
+          self
+        end
+
+        def update_only(update_only)
+          @options[:update_only] = update_only
+          self
+        end
+
+        def matches?(subject)
+          @subject = subject
+          exists? &&
+            allow_destroy_correct? &&
+            limit_correct? &&
+            update_only_correct?
+        end
+
+        def failure_message
+          "Expected #{expectation} (#{@problem})"
+        end
+
+        def failure_message_when_negated
+          "Did not expect #{expectation}"
+        end
+
+        def description
+          description = "accepts_nested_attributes_for :#{@name}"
+          if @options.key?(:allow_destroy)
+            description += " allow_destroy => #{@options[:allow_destroy]}"
+          end
+          if @options.key?(:limit)
+            description += " limit => #{@options[:limit]}"
+          end
+          if @options.key?(:update_only)
+            description += " update_only => #{@options[:update_only]}"
+          end
+          description
+        end
+
+        protected
+
+        def exists?
+          if config
+            true
+          else
+            @problem = 'is not declared'
+            false
+          end
+        end
+
+        def allow_destroy_correct?
+          failure_message = "#{should_or_should_not(@options[:allow_destroy])}"\
+            ' allow destroy'
+          verify_option_is_correct(:allow_destroy, failure_message)
+        end
+
+        def limit_correct?
+          failure_message = "limit should be #{@options[:limit]},"\
+            " got #{config[:limit]}"
+          verify_option_is_correct(:limit, failure_message)
+        end
+
+        def update_only_correct?
+          failure_message = "#{should_or_should_not(@options[:update_only])}"\
+            ' be update only'
+          verify_option_is_correct(:update_only, failure_message)
+        end
+
+        def verify_option_is_correct(option, failure_message)
+          if @options.key?(option)
+            if @options[option] == config[option]
+              true
+            else
+              @problem = failure_message
+              false
+            end
+          else
+            true
+          end
+        end
+
+        def config
+          model_config[@name]
+        end
+
+        def model_config
+          model_class.nested_attributes_options
+        end
+
+        def model_class
+          @subject.class
+        end
+
+        def expectation
+          "#{model_class.name} to accept nested attributes for #{@name}"
+        end
+
+        def should_or_should_not(value)
+          if value
+            'should'
+          else
+            'should not'
+          end
+        end
+      end
+    end
+  end
+end