rspec-sidekiq_pro 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ab301b38f104fcdeda2a304b6f87f4d50e67ed15f01340b08c7d77643b35d98b
+  data.tar.gz: bdcf93f32eb2ec8040c286e864fa204ce01f066f88e76f6f0b5b9e61ec16cb11
+SHA512:
+  metadata.gz: e86e8d44fcdad8b55dd826ae835fabc40b235dba13c90d471dbfef38e609d3d19a18a4ea4d6b9f65ec4c42db7a9f0690d97ad9ef582aed6303ebdad41ba5ecce
+  data.tar.gz: e682c9fe04fb2e49866a11af75d052d3003127e150444af0769332f983a3fe55f1f76e153db56beaca6bd4e6cb901117be42f5974016ddbcbfd17ea1780a02f6

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2022 Savater Sebastien
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,38 @@
+# Rspec for Sidekiq Pro
+
+### Installation
+
+```bash
+bundle add rspec-sidekiq_pro
+```
+
+### Usage
+
+TODO
+
+## Contributing
+
+1. Don't hesitate to submit your feature/idea/fix in [issues](https://github.com/inkstak/rspec-sidekiq_pro)
+2. Fork the [repository](https://github.com/inkstak/rspec-sidekiq_pro)
+3. Create your feature branch
+4. Ensure RSpec & Rubocop are passing
+4. Create a pull request
+
+### Tests & lint
+
+```bash
+bundle exec rspec
+bundle exec rubocop
+```
+
+Both can be run with:
+
+```bash
+bundle exec rake
+```
+
+## License & credits
+
+Please see [LICENSE](https://github.com/inkstak/rspec-sidekiq_pro/blob/main/LICENSE) for further details.
+
+Contributors: [./graphs/contributors](https://github.com/inkstak/rspec-sidekiq_pro/graphs/contributors)

data/lib/rspec/sidekiq_pro/batches.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+module RSpec
+  module SidekiqPro
+    module Batches
+      module Props
+        class << self
+          delegate :size, :first, :last, :each, :empty?, :any?, :none?, to: :batches_array
+          delegate :fetch, to: :batches_hash
+
+          def [](key)
+            if key.is_a?(Numeric)
+              batches_array[key]
+            else
+              batches_hash[key]
+            end
+          end
+
+          def []=(bid, batch)
+            batch["bid"] = bid
+            batches_array << batch
+            batches_hash[bid] = batch
+          end
+
+          def delete(bid)
+            batch = batches_hash.delete(bid)
+            batches_array.delete(batch)
+          end
+
+          def clear_all
+            batches_array.clear
+            batches_hash.clear
+          end
+
+          def to_a
+            batches_array
+          end
+
+          def to_h
+            batches_hash
+          end
+
+          private
+
+          def batches_array
+            @batches_array ||= []
+          end
+
+          def batches_hash
+            @batches_hash ||= {}
+          end
+        end
+      end
+
+      class << self
+        delegate :size, :delete, :clear_all, :empty?, :any?, :none?, to: Props
+        delegate_missing_to :each
+
+        def each
+          return to_enum(:each) unless block_given?
+
+          Props.each do |props|
+            yield Sidekiq::Batch.new(props["bid"])
+          end
+        end
+
+        def [](key)
+          Sidekiq::Batch.new(Props[key]["bid"])
+        end
+
+        def first
+          Sidekiq::Batch.new(Props.first["bid"])
+        end
+
+        def last
+          Sidekiq::Batch.new(Props.last["bid"])
+        end
+      end
+    end
+  end
+end
+
+module Sidekiq
+  class Batch
+    def initialize(bid = nil)
+      if Sidekiq::Testing.disabled?
+        super
+      else
+        @bid  = bid || SecureRandom.urlsafe_base64(10)
+        props = RSpec::SidekiqPro::Batches::Props.fetch(bid, {})
+
+        @created_at  = props.fetch("created_at", Time.now.utc).to_f
+        @description = props["description"]
+        @parent_bid  = props["parent"]
+        @callbacks   = props.fetch("callbacks", {})
+        @jids        = props.fetch("jids", [])
+        @mutable     = props.empty?
+      end
+    end
+
+    def redis(bid, &block)
+      return super if Sidekiq::Testing.disabled?
+
+      raise "Redis unavailbale when Sidekiq::Testing is enable"
+    end
+
+    def jids
+      return super if Sidekiq::Testing.disabled?
+
+      @jids
+    end
+
+    def include?(jid)
+      return super if Sidekiq::Testing.disabled?
+
+      @jids.include?(jid)
+    end
+
+    def invalidate_all
+      return super if Sidekiq::Testing.disabled?
+
+      RSpec::SidekiqPro::Batches::Props[bid]["invalidated"] = true
+      Sidekiq::Queues.jobs_by_queue.each_value { |jobs| jobs.delete_if { |job| include?(job["jid"]) } }
+      Sidekiq::Queues.jobs_by_class.each_value { |jobs| jobs.delete_if { |job| include?(job["jid"]) } }
+    end
+
+    def invalidate_jids(*jids)
+      return super if Sidekiq::Testing.disabled?
+
+      # TODO
+    end
+
+    def invalidated?
+      return super if Sidekiq::Testing.disabled?
+
+      !!RSpec::SidekiqPro::Batches::Props[bid]["invalidated"]
+    end
+
+    def jobs(&block)
+      return super if Sidekiq::Testing.disabled?
+
+      raise ArgumentError, "Must specify a block" unless block
+
+      if mutable?
+        @parent_bid = Thread.current[:sidekiq_batch]&.bid
+
+        RSpec::SidekiqPro::Batches::Props[bid] = {
+          "created_at" => created_at,
+          "description" => description,
+          "parent" => parent_bid,
+          "callbacks" => callbacks,
+          "jids" => jids
+        }
+      end
+
+      @mutable = false
+
+      begin
+        parent = Thread.current[:sidekiq_batch]
+        Thread.current[:sidekiq_batch] = self
+        yield
+      ensure
+        Thread.current[:sidekiq_batch] = parent
+      end
+
+      RSpec::SidekiqPro::Batches::Props[bid]["jids"] = @jids
+    end
+
+    def register(jid)
+      return super if Sidekiq::Testing.disabled?
+
+      @jids << jid
+    end
+
+    def perform_callback(event)
+      raise NotImplementedError if Sidekiq::Testing.disabled?
+
+      callbacks[event.to_s]&.each do |callback|
+        callback.each do |target, options|
+          klass_name, method = target.to_s.split("#")
+          klass = klass_name.constantize
+          meth  = method || "on_#{event}"
+          inst  = klass.new
+          inst.jid = SecureRandom.hex(12) if inst.respond_to?(:jid)
+          inst.send(meth, status, options)
+        end
+      end
+    end
+
+    class Status
+      def initialize(bid)
+        if Sidekiq::Testing.disabled?
+          super
+        else
+          @bid      = bid
+          @props    = RSpec::SidekiqPro::Batches::Props.fetch(bid, {})
+          @pending  = 0
+          @failures = 0
+          @total    = @props.fetch("jids", []).size
+        end
+      end
+    end
+  end
+end

data/lib/rspec/sidekiq_pro/matchers/enqueue_sidekiq_jobs.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "rspec/sidekiq_pro/matchers/job_matcher"
+
+module RSpec
+  module SidekiqPro
+    module Matchers
+      class EnqueueSidekiqJobs
+        include JobMatcher
+
+        def initialize(worker_class)
+          @worker_class = worker_class
+        end
+
+        def supports_block_expectations?
+          true
+        end
+
+        def supports_value_expectations?
+          false
+        end
+
+        def matches?(block)
+          super(capture_actual_jobs(block))
+        end
+
+        def does_not_match?(block)
+          super(capture_actual_jobs(block))
+        end
+
+        def description
+          "enqueue #{expected_job_description}"
+        end
+
+        def failure_message
+          "expected to enqueue #{worker_class} job\n#{failure_message_diff}"
+        end
+
+        def failure_message_when_negated
+          "expected not to enqueue #{worker_class} job\n#{failure_message_diff}"
+        end
+
+        def capture_actual_jobs(block)
+          before = worker_class.jobs.dup
+          result = block.call
+
+          if @expected_arguments.is_a?(Proc)
+            arguments = @expected_arguments.call(result)
+            raise "arguments returned from a proc are expected to be an Array" unless arguments.is_a?(Array)
+
+            @expected_arguments = normalize_arguments(arguments)
+          end
+
+          worker_class.jobs - before
+        end
+      end
+    end
+  end
+end

data/lib/rspec/sidekiq_pro/matchers/have_enqueued_sidekiq_jobs.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "rspec/sidekiq_pro/matchers/job_matcher"
+
+module RSpec
+  module SidekiqPro
+    module Matchers
+      class HaveEnqueuedSidekiqJobs
+        include JobMatcher
+
+        def supports_block_expectations?
+          false
+        end
+
+        def supports_value_expectations?
+          true
+        end
+
+        def matches?(worker_class)
+          @worker_class = worker_class
+          super(worker_class.jobs)
+        end
+
+        def does_not_match?(worker_class)
+          @worker_class = worker_class
+          super(worker_class.jobs)
+        end
+
+        def description
+          "have enqueued #{expected_job_description}"
+        end
+
+        def failure_message
+          "expected to have enqueued #{worker_class} job\n#{failure_message_diff}"
+        end
+
+        def failure_message_when_negated
+          "expected not to have enqueued #{worker_class} job\n#{failure_message_diff}"
+        end
+      end
+    end
+  end
+end

data/lib/rspec/sidekiq_pro/matchers/job_matcher.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+module RSpec
+  module SidekiqPro
+    module Matchers
+      module JobMatcher
+        include ::RSpec::Matchers::Composable
+
+        attr_reader :worker_class,
+          :expected_arguments,
+          :expected_interval,
+          :expected_timestamp,
+          :expected_schedule,
+          :expected_count,
+          :expected_without_batch,
+          :expected_batch,
+          :actual_jobs
+
+        def with(*expected_arguments, &block)
+          if block
+            raise ArgumentError, "setting block to `with` is not supported for this matcher" if supports_value_expectations?
+            raise ArgumentError, "setting arguments and block together in `with` is not supported" if expected_arguments.any?
+
+            @expected_arguments = block
+          else
+            @expected_arguments = normalize_arguments(expected_arguments)
+          end
+
+          self
+        end
+
+        def in(interval)
+          raise "setting expecations with both `at` and `in` is not supported" if @expected_timestamp
+
+          @expected_interval = interval
+          @expected_schedule = interval.from_now.to_i
+          self
+        end
+
+        def at(timestamp)
+          raise "setting expecations with both `at` and `in` is not supported" if @expected_interval
+
+          @expected_timestamp = timestamp
+          @expected_schedule  = timestamp.to_i
+          self
+        end
+
+        def once
+          exactly(1)
+        end
+
+        def twice
+          exactly(2)
+        end
+
+        def exactly(times)
+          @expected_count = times
+          self
+        end
+
+        def times
+          self
+        end
+        alias_method :time, :times
+
+        def without_batch
+          raise "setting expecations with both `without_batch` and `within_batch` is not supported" if @expected_batch
+
+          @expected_without_batch = true
+          self
+        end
+
+        def within_batch(batch_expectation = :__undef__, &block)
+          raise "setting expecations with both `without_batch` and `within_batch` is not supported" if @expected_without_batch
+
+          if block
+            raise ArgumentError, "setting arguments and block together in `with_batch` is not supported" if batch_expectation != :__undef__
+
+            @expected_batch = block
+          else
+            @expected_batch = batch_expectation
+          end
+
+          self
+        end
+
+        def matches?(jobs)
+          @actual_jobs  = jobs
+          filtered_jobs = filter_jobs(actual_jobs)
+
+          if expected_count
+            filtered_jobs.count == expected_count
+          else
+            filtered_jobs.any?
+          end
+        end
+
+        def does_not_match?(jobs)
+          @actual_jobs  = jobs
+          filtered_jobs = filter_jobs(actual_jobs)
+
+          if expected_count
+            filtered_jobs.count != expected_count
+          else
+            filtered_jobs.empty?
+          end
+        end
+
+        def normalize_arguments(arguments)
+          JSON.parse(JSON.dump(arguments))
+        end
+
+        def output_arguments(arguments)
+          arguments.map(&:inspect).join(", ")
+        end
+
+        def expected_job_description
+          description = "#{worker_class} job"
+
+          if expected_count == 1
+            description += " once"
+          elsif expected_count == 2
+            description += " twice"
+          elsif expected_count
+            description += " #{expected_count} times"
+          end
+
+          if expected_arguments.is_a?(Proc)
+            description += " with some arguments"
+          elsif expected_arguments
+            description += " with arguments #{expected_arguments}"
+          end
+
+          description
+        end
+
+        def failure_message_diff
+          diff = []
+          diff << "  exactly:   #{expected_count} time(s)"       if expected_count
+          diff << "  arguments: #{expected_arguments}"           if expected_arguments
+          diff << "  in:        #{expected_interval_output}"     if expected_interval
+          diff << "  at:        #{expected_timestamp}"           if expected_timestamp
+          diff << "  batch:     #{output_batch(expected_batch)}" if expected_batch
+          diff << "  batch:     no batch"                        if expected_without_batch
+          diff << "" if diff.any?
+
+          if actual_jobs.empty?
+            diff << "no #{worker_class} found"
+          elsif !expected_arguments && !expected_schedule && !expected_without_batch && !expected_batch
+            diff << "found #{actual_jobs.size} #{worker_class}"
+          else
+            diff << "found #{actual_jobs.size} #{worker_class}:"
+
+            actual_jobs.each do |job|
+              job_message = []
+              job_message << "arguments: #{job["args"]}"                if expected_arguments
+              job_message << "at:        #{output_schedule(job["at"])}" if expected_schedule && job["at"]
+              job_message << "at:        no schedule"                   if expected_schedule && !job["at"]
+              job_message << "batch:     #{output_batch(job["bid"])}"   if (expected_without_batch || expected_batch) && job["bid"]
+              job_message << "batch:     no batch"                      if (expected_without_batch || expected_batch) && !job["bid"]
+
+              diff += job_message.map.with_index do |line, index|
+                if actual_jobs.size == 1
+                  "  #{line}"
+                elsif index.zero?
+                  "  - #{line}"
+                else
+                  "    #{line}"
+                end
+              end
+            end
+          end
+
+          diff.join("\n")
+        end
+
+        def expected_interval_output
+          "#{expected_interval.inspect} (#{output_schedule(expected_schedule)})"
+        end
+
+        def output_schedule(timestamp)
+          Time.at(timestamp) if timestamp
+        end
+
+        def output_batch(value)
+          case value
+          when :__undef__     then "to be present"
+          when String         then "<Sidekiq::Batch bid: #{value.inspect}>"
+          when Sidekiq::Batch then "<Sidekiq::Batch bid: #{value.bid.inspect}>"
+          else
+            if value.respond_to?(:description)
+              value.description
+            else
+              value
+            end
+          end
+        end
+
+        def filter_jobs(jobs)
+          jobs.select do |job|
+            next if expected_arguments && !values_match?(expected_arguments, job["args"])
+            next if expected_schedule && !values_match?(expected_schedule.to_i, job["at"].to_i)
+            next if expected_without_batch && job["bid"]
+            next if expected_batch && !batch_match?(expected_batch, job["bid"])
+
+            true
+          end
+        end
+
+        def batch_match?(expected_batch, bid)
+          case expected_batch
+          when :__undef__
+            !bid.nil?
+          when String
+            expected_batch == bid
+
+          when ::Sidekiq::Batch
+            expected_batch.bid == bid
+
+          else
+            return unless bid
+
+            batch = ::Sidekiq::Batch.new(bid)
+            values_match?(expected_batch, batch)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rspec/sidekiq_pro/matchers.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "rspec/sidekiq_pro/matchers/enqueue_sidekiq_jobs"
+require "rspec/sidekiq_pro/matchers/have_enqueued_sidekiq_jobs"
+
+module RSpec
+  module SidekiqPro
+    module Matchers
+      # Checks if a certain job was enqueued.
+      #
+      # AwesomeWorker.perform_async
+      # expect(AwesomeWorker).to have_enqueued_sidekiq_job
+      #
+      # AwesomeWorker.perform_async(42, 'David')
+      # expect(AwesomeWorker).to have_enqueued_sidekiq_job.with(42, 'David')
+      #
+      # AwesomeWorker.perform_in(5.minutes)
+      # expect(AwesomeWorker).to have_enqueued_sidekiq_job.in(5.minutes)
+      #
+      def have_enqueued_sidekiq_job
+        HaveEnqueuedSidekiqJobs.new.once
+      end
+
+      def have_enqueued_sidekiq_jobs
+        HaveEnqueuedSidekiqJobs.new
+      end
+
+      # Checks if a certain job was enqueued in a block.
+      #
+      # expect { AwesomeWorker.perform_async }
+      #   .to enqueue_sidekiq_job(AwesomeWorker)
+      #
+      # expect { AwesomeWorker.perform_async(42, 'David')
+      #   .to enqueue_sidekiq_job(AwesomeWorker).with(42, 'David')
+      #
+      # expect { AwesomeWorker.perform_in(5.minutes) }
+      #   .to enqueue_sidekiq_job(AwesomeWorker).in(5.minutes)
+      #
+      def enqueue_sidekiq_job(worker_class)
+        EnqueueSidekiqJobs.new(worker_class).once
+      end
+
+      def enqueue_sidekiq_jobs(worker_class)
+        EnqueueSidekiqJobs.new(worker_class)
+      end
+    end
+  end
+end

data/lib/rspec/sidekiq_pro/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module RSpec
+  module SidekiqPro
+    VERSION = "0.0.0"
+  end
+end

data/lib/rspec/sidekiq_pro.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "rspec"
+require "sidekiq"
+require "sidekiq-pro"
+require "sidekiq/testing"
+require "active_support/duration"
+require "active_support/core_ext/module/delegation"
+require "rspec/sidekiq_pro/matchers"
+require "rspec/sidekiq_pro/batches"
+
+RSpec.configure do |config|
+  config.include RSpec::SidekiqPro::Matchers
+end

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: rspec-sidekiq_pro
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Savater Sebastien
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-08-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.11'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.11'
+- !ruby/object:Gem::Dependency
+  name: sidekiq
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.5'
+- !ruby/object:Gem::Dependency
+  name: sidekiq-pro
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.5'
+description:
+email: github.60k5k@simplelogin.co
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/rspec/sidekiq_pro.rb
+- lib/rspec/sidekiq_pro/batches.rb
+- lib/rspec/sidekiq_pro/matchers.rb
+- lib/rspec/sidekiq_pro/matchers/enqueue_sidekiq_jobs.rb
+- lib/rspec/sidekiq_pro/matchers/have_enqueued_sidekiq_jobs.rb
+- lib/rspec/sidekiq_pro/matchers/job_matcher.rb
+- lib/rspec/sidekiq_pro/version.rb
+homepage: http://github.com/inkstak/rspec-sidekiq_pro
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.7
+signing_key:
+specification_version: 4
+summary: A collection of tools and matchers for Sidekiq Pro
+test_files: []