mini-quick-sys 0.0.1

data/rspec-rails-8.0.4/lib/rspec/rails/matchers/be_a_new.rb

@@ -0,0 +1,83 @@
+module RSpec
+  module Rails
+    module Matchers
+      # @api private
+      #
+      # Matcher class for `be_a_new`. Should not be instantiated directly.
+      #
+      # @see RSpec::Rails::Matchers#be_a_new
+      class BeANew < RSpec::Rails::Matchers::BaseMatcher
+        # @private
+        def initialize(expected)
+          @expected = expected
+        end
+
+        # @private
+        def matches?(actual)
+          @actual = actual
+          actual.is_a?(expected) && actual.new_record? && attributes_match?(actual)
+        end
+
+        # @api public
+        # @see RSpec::Rails::Matchers#be_a_new
+        def with(expected_attributes)
+          attributes.merge!(expected_attributes)
+          self
+        end
+
+        # @private
+        def failure_message
+          [].tap do |message|
+            unless actual.is_a?(expected) && actual.new_record?
+              message << "expected #{actual.inspect} to be a new #{expected.inspect}"
+            end
+            unless attributes_match?(actual)
+              describe_unmatched_attributes = surface_descriptions_in(unmatched_attributes)
+              if unmatched_attributes.size > 1
+                message << "attributes #{describe_unmatched_attributes.inspect} were not set on #{actual.inspect}"
+              else
+                message << "attribute #{describe_unmatched_attributes.inspect} was not set on #{actual.inspect}"
+              end
+            end
+          end.join(' and ')
+        end
+
+      private
+
+        def attributes
+          @attributes ||= {}
+        end
+
+        def attributes_match?(actual)
+          attributes.stringify_keys.all? do |key, value|
+            values_match?(value, actual.attributes[key])
+          end
+        end
+
+        def unmatched_attributes
+          attributes.stringify_keys.reject do |key, value|
+            values_match?(value, actual.attributes[key])
+          end
+        end
+      end
+
+      # @api public
+      # Passes if actual is an instance of `model_class` and returns `true` for
+      # `new_record?`. Typically used to specify instance variables assigned to
+      # views by controller actions
+      #
+      # Use the `with` method to specify the specific attributes to match on the
+      # new record.
+      #
+      # @example
+      #     get :new
+      #     assigns(:thing).should be_a_new(Thing)
+      #
+      #     post :create, :thing => { :name => "Illegal Value" }
+      #     assigns(:thing).should be_a_new(Thing).with(:name => nil)
+      def be_a_new(model_class)
+        BeANew.new(model_class)
+      end
+    end
+  end
+end

data/rspec-rails-8.0.4/lib/rspec/rails/matchers/be_new_record.rb

@@ -0,0 +1,30 @@
+module RSpec
+  module Rails
+    module Matchers
+      # @private
+      class BeANewRecord < RSpec::Rails::Matchers::BaseMatcher
+        def matches?(actual)
+          actual.new_record?
+        end
+
+        def failure_message
+          "expected #{actual.inspect} to be a new record, but was persisted"
+        end
+
+        def failure_message_when_negated
+          "expected #{actual.inspect} to be persisted, but was a new record"
+        end
+      end
+
+      # @api public
+      # Passes if actual returns `true` for `new_record?`.
+      #
+      # @example
+      #     get :new
+      #     expect(assigns(:thing)).to be_new_record
+      def be_new_record
+        BeANewRecord.new
+      end
+    end
+  end
+end

data/rspec-rails-8.0.4/lib/rspec/rails/matchers/be_valid.rb

@@ -0,0 +1,49 @@
+module RSpec
+  module Rails
+    module Matchers
+      # @private
+      class BeValid < RSpec::Matchers::BuiltIn::Be
+        def initialize(*args)
+          @args = args
+        end
+
+        def matches?(actual)
+          @actual = actual
+          actual.valid?(*@args)
+        end
+
+        def failure_message
+          message = "expected #{actual.inspect} to be valid"
+
+          if actual.respond_to?(:errors) && actual.method(:errors).arity < 1
+            errors = if actual.errors.respond_to?(:full_messages)
+                       actual.errors.full_messages
+                     else
+                       actual.errors
+                     end
+
+            message << ", but got errors: #{errors.map(&:to_s).join(', ')}"
+          end
+
+          message
+        end
+
+        def failure_message_when_negated
+          "expected #{actual.inspect} not to be valid"
+        end
+      end
+
+      # @api public
+      # Passes if the given model instance's `valid?` method is true, meaning
+      # all of the `ActiveModel::Validations` passed and no errors exist. If a
+      # message is not given, a default message is shown listing each error.
+      #
+      # @example
+      #     thing = Thing.new
+      #     expect(thing).to be_valid
+      def be_valid(*args)
+        BeValid.new(*args)
+      end
+    end
+  end
+end

data/rspec-rails-8.0.4/lib/rspec/rails/matchers/have_enqueued_mail.rb

@@ -0,0 +1,259 @@
+# We require the minimum amount of rspec-mocks possible to avoid
+# conflicts with other mocking frameworks.
+# See: https://github.com/rspec/rspec-rails/issues/2252
+require "rspec/mocks/argument_matchers"
+require "rspec/rails/matchers/active_job"
+
+# rubocop: disable Metrics/ClassLength
+module RSpec
+  module Rails
+    module Matchers
+      # Matcher class for `have_enqueued_mail`. Should not be instantiated directly.
+      #
+      # @private
+      # @see RSpec::Rails::Matchers#have_enqueued_mail
+      class HaveEnqueuedMail < ActiveJob::HaveEnqueuedJob
+        MAILER_JOB_METHOD = 'deliver_now'.freeze
+
+        include RSpec::Mocks::ArgumentMatchers
+
+        def initialize(mailer_class, method_name)
+          super(nil)
+          @mailer_class = mailer_class
+          @method_name = method_name
+          @mail_args = []
+        end
+
+        def description
+          "enqueues #{mailer_class_name}.#{@method_name}"
+        end
+
+        def with(*args, &block)
+          @mail_args = args
+          block.nil? ? super : super(&yield_mail_args(block))
+        end
+
+        def matches?(block)
+          raise ArgumentError, 'have_enqueued_mail and enqueue_mail only work with block arguments' unless block.respond_to?(:call)
+
+          check_active_job_adapter
+          super
+        end
+
+        def failure_message
+          return @failure_message if defined?(@failure_message)
+
+          "expected to enqueue #{base_message}".tap do |msg|
+            msg << "\n#{unmatching_mail_jobs_message}" if unmatching_mail_jobs.any?
+          end
+        end
+
+        def failure_message_when_negated
+          "expected not to enqueue #{base_message}"
+        end
+
+        private
+
+        def base_message
+          [mailer_class_name, @method_name].compact.join('.').tap do |msg|
+            msg << " #{expected_count_message}"
+            msg << " with #{@mail_args}," if @mail_args.any?
+            msg << " on queue #{@queue}," if @queue
+            msg << " at #{@at.inspect}," if @at
+            msg << " but enqueued #{@matching_jobs.size}"
+          end
+        end
+
+        def expected_count_message
+          "#{message_expectation_modifier} #{@expected_number} #{@expected_number == 1 ? 'time' : 'times'}"
+        end
+
+        def mailer_class_name
+          @mailer_class ? @mailer_class.name : 'ActionMailer::Base'
+        end
+
+        def job_matches?(job)
+          legacy_mail?(job) || parameterized_mail?(job) || unified_mail?(job)
+        end
+
+        def arguments_match?(job)
+          @args =
+            if @mail_args.any?
+              base_mailer_args + @mail_args
+            elsif @mailer_class && @method_name
+              base_mailer_args + [any_args]
+            elsif @mailer_class
+              [mailer_class_name, any_args]
+            else
+              []
+            end
+
+          super(job)
+        end
+
+        def detect_args_signature_mismatch(jobs)
+          return if @method_name.nil?
+          return if skip_signature_verification?
+
+          mailer_class = mailer_class_name.constantize
+
+          jobs.each do |job|
+            mailer_args = extract_args_without_parameterized_params(job)
+
+            if (signature_mismatch = check_args_signature_mismatch(mailer_class, @method_name, mailer_args))
+              return signature_mismatch
+            end
+          end
+
+          nil
+        end
+
+        def base_mailer_args
+          [mailer_class_name, @method_name.to_s, MAILER_JOB_METHOD]
+        end
+
+        def yield_mail_args(block)
+          proc { |*job_args| block.call(*(job_args - base_mailer_args)) }
+        end
+
+        def check_active_job_adapter
+          return if ::ActiveJob::QueueAdapters::TestAdapter === ::ActiveJob::Base.queue_adapter
+
+          raise StandardError, "To use HaveEnqueuedMail matcher set `ActiveJob::Base.queue_adapter = :test`"
+        end
+
+        def unmatching_mail_jobs
+          @unmatching_jobs.select do |job|
+            job_matches?(job)
+          end
+        end
+
+        def unmatching_mail_jobs_message
+          messages = ["Queued deliveries:"]
+
+          unmatching_mail_jobs.each do |job|
+            messages << "  #{mail_job_message(job)}"
+          end
+
+          messages.join("\n")
+        end
+
+        def mail_job_message(job)
+          job_args = deserialize_arguments(job)
+
+          mailer_method = job_args[0..1].join('.')
+          mailer_args = job_args[3..-1]
+
+          msg_parts = []
+          msg_parts << "with #{mailer_args}" if mailer_args.any?
+          msg_parts << "on queue #{job[:queue]}" if job[:queue] && job[:queue] != 'mailers'
+          msg_parts << "at #{Time.at(job[:at])}" if job[:at]
+
+          "#{mailer_method} #{msg_parts.join(', ')}".strip
+        end
+
+        # Ruby 3.1 changed how params were serialized on Rails 6.1
+        # so we override the active job implementation and customize it here.
+        def deserialize_arguments(job)
+          args = super
+
+          return args unless Hash === args.last
+
+          hash = args.pop
+
+          if hash.key?("_aj_ruby2_keywords")
+            keywords = hash["_aj_ruby2_keywords"]
+
+            original_hash = keywords.each_with_object({}) { |keyword, new_hash| new_hash[keyword.to_sym] = hash[keyword] }
+
+            args + [original_hash]
+          elsif hash.key?(:args) && hash.key?(:params)
+            args + [hash]
+          elsif hash.key?(:args)
+            args + hash[:args]
+          else
+            args + [hash]
+          end
+        end
+
+        def extract_args_without_parameterized_params(job)
+          args = deserialize_arguments(job)
+          mailer_args = args - base_mailer_args
+
+          if parameterized_mail?(job)
+            mailer_args = mailer_args[1..-1] # ignore parameterized params
+          elsif mailer_args.last.is_a?(Hash) && mailer_args.last.key?(:args)
+            mailer_args = args.last[:args]
+          end
+
+          mailer_args
+        end
+
+        def legacy_mail?(job)
+          RSpec::Rails::FeatureCheck.has_action_mailer_legacy_delivery_job? && job[:job] <= ActionMailer::DeliveryJob
+        end
+
+        def parameterized_mail?(job)
+          RSpec::Rails::FeatureCheck.has_action_mailer_parameterized? && job[:job] <= ActionMailer::Parameterized::DeliveryJob
+        end
+
+        def unified_mail?(job)
+          RSpec::Rails::FeatureCheck.has_action_mailer_unified_delivery? && job[:job] <= ActionMailer::MailDeliveryJob
+        end
+      end
+
+      # @api public
+      # Passes if an email has been enqueued inside block.
+      # May chain with to specify expected arguments.
+      # May chain at_least, at_most or exactly to specify a number of times.
+      # May chain at to specify a send time.
+      # May chain on_queue to specify a queue.
+      #
+      # @example
+      #     expect {
+      #       MyMailer.welcome(user).deliver_later
+      #     }.to have_enqueued_mail
+      #
+      #     expect {
+      #       MyMailer.welcome(user).deliver_later
+      #     }.to have_enqueued_mail(MyMailer)
+      #
+      #     expect {
+      #       MyMailer.welcome(user).deliver_later
+      #     }.to have_enqueued_mail(MyMailer, :welcome)
+      #
+      #     # Using alias
+      #     expect {
+      #       MyMailer.welcome(user).deliver_later
+      #     }.to enqueue_mail(MyMailer, :welcome)
+      #
+      #     expect {
+      #       MyMailer.welcome(user).deliver_later
+      #     }.to have_enqueued_mail(MyMailer, :welcome).with(user)
+      #
+      #     expect {
+      #       MyMailer.welcome(user).deliver_later
+      #       MyMailer.welcome(user).deliver_later
+      #     }.to have_enqueued_mail(MyMailer, :welcome).at_least(:once)
+      #
+      #     expect {
+      #       MyMailer.welcome(user).deliver_later
+      #     }.to have_enqueued_mail(MyMailer, :welcome).at_most(:twice)
+      #
+      #     expect {
+      #       MyMailer.welcome(user).deliver_later(wait_until: Date.tomorrow.noon)
+      #     }.to have_enqueued_mail(MyMailer, :welcome).at(Date.tomorrow.noon)
+      #
+      #     expect {
+      #       MyMailer.welcome(user).deliver_later(queue: :urgent_mail)
+      #     }.to have_enqueued_mail(MyMailer, :welcome).on_queue(:urgent_mail)
+      def have_enqueued_mail(mailer_class = nil, mail_method_name = nil)
+        HaveEnqueuedMail.new(mailer_class, mail_method_name)
+      end
+      alias_method :have_enqueued_email, :have_enqueued_mail
+      alias_method :enqueue_mail, :have_enqueued_mail
+      alias_method :enqueue_email, :have_enqueued_mail
+    end
+  end
+end
+# rubocop: enable Metrics/ClassLength