ultra-fast-box 0.0.1

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

@@ -0,0 +1,174 @@
+module Shoulda
+  module Matchers
+    module ActiveRecord
+      # The `encrypt` matcher tests usage of the
+      # `encrypts` macro (Rails 7+ only).
+      #
+      #     class Survey < ActiveRecord::Base
+      #       encrypts :access_code
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Survey, type: :model do
+      #       it { should encrypt(:access_code) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class SurveyTest < ActiveSupport::TestCase
+      #       should encrypt(:access_code)
+      #     end
+      #
+      # #### Qualifiers
+      #
+      # ##### deterministic
+      #
+      #     class Survey < ActiveRecord::Base
+      #       encrypts :access_code, deterministic: true
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Survey, type: :model do
+      #       it { should encrypt(:access_code).deterministic(true) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class SurveyTest < ActiveSupport::TestCase
+      #       should encrypt(:access_code).deterministic(true)
+      #     end
+      #
+      # ##### downcase
+      #
+      #     class Survey < ActiveRecord::Base
+      #       encrypts :access_code, downcase: true
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Survey, type: :model do
+      #       it { should encrypt(:access_code).downcase(true) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class SurveyTest < ActiveSupport::TestCase
+      #       should encrypt(:access_code).downcase(true)
+      #     end
+      #
+      # ##### ignore_case
+      #
+      #     class Survey < ActiveRecord::Base
+      #       encrypts :access_code, deterministic: true, ignore_case: true
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Survey, type: :model do
+      #       it { should encrypt(:access_code).ignore_case(true) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class SurveyTest < ActiveSupport::TestCase
+      #       should encrypt(:access_code).ignore_case(true)
+      #     end
+      #
+      # @return [EncryptMatcher]
+      #
+      def encrypt(value)
+        EncryptMatcher.new(value)
+      end
+
+      # @private
+      class EncryptMatcher
+        def initialize(attribute)
+          @attribute = attribute.to_sym
+          @options = {}
+        end
+
+        attr_reader :failure_message, :failure_message_when_negated
+
+        def deterministic(deterministic)
+          with_option(:deterministic, deterministic)
+        end
+
+        def downcase(downcase)
+          with_option(:downcase, downcase)
+        end
+
+        def ignore_case(ignore_case)
+          with_option(:ignore_case, ignore_case)
+        end
+
+        def matches?(subject)
+          @subject = subject
+          result = encrypted_attributes_included? &&
+                   options_correct?(
+                     :deterministic,
+                     :downcase,
+                     :ignore_case,
+                   )
+
+          if result
+            @failure_message_when_negated = "Did not expect to #{description} of #{class_name}"
+            if @options.present?
+              @failure_message_when_negated += "
+using "
+              @failure_message_when_negated += @options.map { |opt, expected|
+                ":#{opt} option as ‹#{expected}›"
+              }.join(' and
+')
+            end
+
+            @failure_message_when_negated += ",
+but it did"
+          end
+
+          result
+        end
+
+        def description
+          "encrypt :#{@attribute}"
+        end
+
+        private
+
+        def encrypted_attributes_included?
+          if encrypted_attributes.include?(@attribute)
+            true
+          else
+            @failure_message = "Expected to #{description} of #{class_name}, but it did not"
+            false
+          end
+        end
+
+        def with_option(option_name, value)
+          @options[option_name] = value
+          self
+        end
+
+        def options_correct?(*opts)
+          opts.all? do |opt|
+            next true unless @options.key?(opt)
+
+            expected = @options[opt]
+            actual = encrypted_attribute_scheme.send("#{opt}?")
+            next true if expected == actual
+
+            @failure_message = "Expected to #{description} of #{class_name} using :#{opt} option
+as ‹#{expected}›, but got ‹#{actual}›"
+
+            false
+          end
+        end
+
+        def encrypted_attributes
+          @_encrypted_attributes ||= @subject.class.encrypted_attributes || []
+        end
+
+        def encrypted_attribute_scheme
+          @subject.class.type_for_attribute(@attribute).scheme
+        end
+
+        def class_name
+          @subject.class.name
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,343 @@
+module Shoulda
+  module Matchers
+    module ActiveRecord
+      # The `have_one_attached` matcher tests usage of the
+      # `has_one_attached` macro.
+      #
+      # #### Example
+      #
+      #     class User < ApplicationRecord
+      #       has_one_attached :avatar
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe User, type: :model do
+      #       it { should have_one_attached(:avatar) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class UserTest < ActiveSupport::TestCase
+      #       should have_one_attached(:avatar)
+      #     end
+      #
+      # #### Qualifiers
+      #
+      # ##### service
+      #
+      # Use `service` to assert that the `:service` option was specified.
+      #
+      #     class User < ApplicationRecord
+      #       has_one_attached :avatar, service: :s3
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe User, type: :model do
+      #       it { should have_one_attached(:avatar).service(:s3) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class UserTest < ActiveSupport::TestCase
+      #       should have_one_attached(:avatar).service(:s3)
+      #     end
+      #
+      # ##### dependent
+      #
+      # Use `dependent` to assert that the `:dependent` option was specified.
+      #
+      #     class User < ApplicationRecord
+      #       has_one_attached :avatar, dependent: :destroy
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe User, type: :model do
+      #       it { should have_one_attached(:avatar).dependent(:destroy) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class UserTest < ActiveSupport::TestCase
+      #       should have_one_attached(:avatar).dependent(:destroy)
+      #     end
+      #
+      # ##### strict_loading
+      #
+      # Use `strict_loading` to assert that the `:strict_loading` option was specified.
+      #
+      #     class User < ApplicationRecord
+      #       has_one_attached :avatar, strict_loading: true
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe User, type: :model do
+      #       it { should have_one_attached(:avatar).strict_loading(true) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class UserTest < ActiveSupport::TestCase
+      #       should have_one_attached(:avatar).strict_loading(true)
+      #     end
+      #
+      # Default value is true when no argument is specified:
+      #
+      #     # RSpec
+      #     RSpec.describe User, type: :model do
+      #       it { should have_one_attached(:avatar).strict_loading }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class UserTest < ActiveSupport::TestCase
+      #       should have_one_attached(:avatar).strict_loading
+      #     end
+      #
+      # #### Multiple attributes
+      #
+      # You can pass multiple attributes to assert that each one has the
+      # validation. Any qualifier chained on the matcher is applied to
+      # every attribute uniformly.
+      #
+      #     class User < ActiveRecord::Base
+      #       has_one_attached :avatar
+      #       has_one_attached :cover
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe User, type: :model do
+      #       it { should have_one_attached(:avatar, :cover) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class UserTest < ActiveSupport::TestCase
+      #       should have_one_attached(:avatar, :cover)
+      #     end
+      #
+      # @return [HaveAttachedMatcher]
+      #
+      def have_one_attached(*names)
+        MatcherCollection.build(names) { |name| HaveAttachedMatcher.new(:one, name) }
+      end
+
+      # The `have_many_attached` matcher tests usage of the
+      # `has_many_attached` macro.
+      #
+      # #### Example
+      #
+      #     class Message < ApplicationRecord
+      #       has_many_attached :images
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Message, type: :model do
+      #       it { should have_many_attached(:images) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class MessageTest < ActiveSupport::TestCase
+      #       should have_many_attached(:images)
+      #     end
+      #
+      # @return [HaveAttachedMatcher]
+      #
+      def have_many_attached(name)
+        HaveAttachedMatcher.new(:many, name)
+      end
+
+      # @private
+      class HaveAttachedMatcher
+        attr_reader :name, :options
+
+        def initialize(macro, name)
+          @macro = macro
+          @name = name
+          @options = {}
+        end
+
+        def description
+          "have a has_#{macro}_attached called #{name}"
+        end
+
+        def failure_message
+          <<-MESSAGE
+Expected #{expectation}, but this could not be proved.
+  #{@failure}
+          MESSAGE
+        end
+
+        def failure_reason
+          @failure
+        end
+
+        def failure_message_when_negated
+          <<-MESSAGE
+Did not expect #{expectation}, but it does.
+          MESSAGE
+        end
+
+        def expectation
+          "#{model_class.name} to #{description}" + build_expectation_suffix
+        end
+
+        def matches?(subject)
+          @subject = subject
+          reader_attribute_exists? &&
+            writer_attribute_exists? &&
+            attachments_association_exists? &&
+            blobs_association_exists? &&
+            eager_loading_scope_exists? &&
+            service_correct? &&
+            dependent_option_correct?
+        end
+
+        OPTION_METHODS = {
+          service: -> (value) { value },
+          strict_loading: -> (value = true) { value },
+          dependent: -> (value) { value },
+        }.freeze
+
+        OPTION_METHODS.each do |option_name, value_processor|
+          define_method(option_name) do |*args|
+            @options[option_name] = value_processor.call(*args)
+            self
+          end
+        end
+
+        private
+
+        attr_reader :subject, :macro
+
+        def build_expectation_suffix
+          String.new.tap do |suffix|
+            suffix << " with service :#{options[:service]}" if options.key?(:service)
+
+            if options.key?(:strict_loading)
+              suffix << " with strict_loading option set to #{options[:strict_loading]}"
+            end
+
+            if options.key?(:dependent)
+              suffix << " with dependent option set to :#{options[:dependent]}"
+            end
+          end
+        end
+
+        def reader_attribute_exists?
+          if subject.respond_to?(name)
+            true
+          else
+            @failure = "#{model_class.name} does not have a :#{name} method."
+            false
+          end
+        end
+
+        def writer_attribute_exists?
+          if subject.respond_to?("#{name}=")
+            true
+          else
+            @failure = "#{model_class.name} does not have a :#{name}= method."
+            false
+          end
+        end
+
+        def attachments_association_exists?
+          if attachments_association_matcher.matches?(subject)
+            true
+          else
+            @failure = attachments_association_matcher.failure_message
+            false
+          end
+        end
+
+        def attachments_association_matcher
+          @_attachments_association_matcher ||=
+            AssociationMatcher.new(
+              :"has_#{macro}",
+              attachments_association_name,
+            ).
+              conditions(name:).
+              class_name('ActiveStorage::Attachment').
+              inverse_of(:record)
+        end
+
+        def attachments_association_name
+          case macro
+          when :one then "#{name}_attachment"
+          when :many then "#{name}_attachments"
+          end
+        end
+
+        def blobs_association_exists?
+          if blobs_association_matcher.matches?(subject)
+            true
+          else
+            @failure = blobs_association_matcher.failure_message
+            false
+          end
+        end
+
+        def blobs_association_matcher
+          @_blobs_association_matcher ||=
+            AssociationMatcher.new(
+              :"has_#{macro}",
+              blobs_association_name,
+            ).
+              through(attachments_association_name).
+              class_name('ActiveStorage::Blob').
+              strict_loading(options[:strict_loading]).
+              source(:blob)
+        end
+
+        def blobs_association_name
+          case macro
+          when :one then "#{name}_blob"
+          when :many then "#{name}_blobs"
+          end
+        end
+
+        def eager_loading_scope_exists?
+          if model_class.respond_to?("with_attached_#{name}")
+            true
+          else
+            @failure = "#{model_class.name} does not have a " \
+                       ":with_attached_#{name} scope."
+            false
+          end
+        end
+
+        def model_class
+          subject.class
+        end
+
+        def dependent_option_correct?
+          dependent = @options[:dependent]
+          return true if dependent.nil? || dependent_option == dependent
+
+          @failure = 'The dependent option for the association called ' \
+                      "#{attachments_association_name} is incorrect " \
+                      "(expected: :#{dependent}, " \
+                      "actual: :#{dependent_option})"
+          false
+        end
+
+        def service_correct?
+          service = @options[:service]
+          return true if service.nil? || service_name == service
+
+          @failure = 'The service for the association called ' \
+                      "#{attachments_association_name} is incorrect " \
+                      "(expected: :#{service}, " \
+                      "actual: :#{service_name})"
+          false
+        end
+
+        def attachment_reflection
+          model_class.attachment_reflections[name.to_s]
+        end
+
+        def service_name
+          attachment_reflection.options[:service_name]
+        end
+
+        def dependent_option
+          attachment_reflection.options[:dependent]
+        end
+      end
+    end
+  end
+end