rspec-goodies 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 688595f20fe784a45182edf3ebdcb7f19a411ad3dd975259b0022631d925f788
+  data.tar.gz: f9a6bd4961893ceab3d91de8592d6ce8ca883d2c68a1706212144e0d74972dcd
+SHA512:
+  metadata.gz: 430633d6935b63b479bc46e9fc1e02dcf65f73ddd5ab8aa38db6efe3adc4c0c85681c2ad0eccc00fd720eefaf958c0566b19e7ae7dc9f2132c223d940a33e5bc
+  data.tar.gz: 14841a867c03923ec9af50fa0eda9d02b5d88f9c64ba7dc9783ec4be283ab3fc4e865bdaf3c04d52dc11ee1202b23c6c8bf36277355944978915bceac8131191

data/Gemfile

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in rspec-goodies.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,218 @@
+PATH
+  remote: .
+  specs:
+    rspec-goodies (0.0.1)
+      activesupport
+      byebug
+      rails
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    actioncable (7.1.2)
+      actionpack (= 7.1.2)
+      activesupport (= 7.1.2)
+      nio4r (~> 2.0)
+      websocket-driver (>= 0.6.1)
+      zeitwerk (~> 2.6)
+    actionmailbox (7.1.2)
+      actionpack (= 7.1.2)
+      activejob (= 7.1.2)
+      activerecord (= 7.1.2)
+      activestorage (= 7.1.2)
+      activesupport (= 7.1.2)
+      mail (>= 2.7.1)
+      net-imap
+      net-pop
+      net-smtp
+    actionmailer (7.1.2)
+      actionpack (= 7.1.2)
+      actionview (= 7.1.2)
+      activejob (= 7.1.2)
+      activesupport (= 7.1.2)
+      mail (~> 2.5, >= 2.5.4)
+      net-imap
+      net-pop
+      net-smtp
+      rails-dom-testing (~> 2.2)
+    actionpack (7.1.2)
+      actionview (= 7.1.2)
+      activesupport (= 7.1.2)
+      nokogiri (>= 1.8.5)
+      racc
+      rack (>= 2.2.4)
+      rack-session (>= 1.0.1)
+      rack-test (>= 0.6.3)
+      rails-dom-testing (~> 2.2)
+      rails-html-sanitizer (~> 1.6)
+    actiontext (7.1.2)
+      actionpack (= 7.1.2)
+      activerecord (= 7.1.2)
+      activestorage (= 7.1.2)
+      activesupport (= 7.1.2)
+      globalid (>= 0.6.0)
+      nokogiri (>= 1.8.5)
+    actionview (7.1.2)
+      activesupport (= 7.1.2)
+      builder (~> 3.1)
+      erubi (~> 1.11)
+      rails-dom-testing (~> 2.2)
+      rails-html-sanitizer (~> 1.6)
+    activejob (7.1.2)
+      activesupport (= 7.1.2)
+      globalid (>= 0.3.6)
+    activemodel (7.1.2)
+      activesupport (= 7.1.2)
+    activerecord (7.1.2)
+      activemodel (= 7.1.2)
+      activesupport (= 7.1.2)
+      timeout (>= 0.4.0)
+    activestorage (7.1.2)
+      actionpack (= 7.1.2)
+      activejob (= 7.1.2)
+      activerecord (= 7.1.2)
+      activesupport (= 7.1.2)
+      marcel (~> 1.0)
+    activesupport (7.1.2)
+      base64
+      bigdecimal
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      connection_pool (>= 2.2.5)
+      drb
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      mutex_m
+      tzinfo (~> 2.0)
+    base64 (0.1.1)
+    bigdecimal (3.1.4)
+    builder (3.2.4)
+    byebug (11.1.3)
+    concurrent-ruby (1.2.2)
+    connection_pool (2.4.1)
+    crass (1.0.6)
+    date (3.3.4)
+    diff-lcs (1.5.0)
+    drb (2.1.1)
+      ruby2_keywords
+    erubi (1.12.0)
+    globalid (1.2.1)
+      activesupport (>= 6.1)
+    i18n (1.14.1)
+      concurrent-ruby (~> 1.0)
+    io-console (0.7.1)
+    irb (1.11.0)
+      rdoc
+      reline (>= 0.3.8)
+    loofah (2.22.0)
+      crass (~> 1.0.2)
+      nokogiri (>= 1.12.0)
+    mail (2.8.1)
+      mini_mime (>= 0.1.1)
+      net-imap
+      net-pop
+      net-smtp
+    marcel (1.0.2)
+    mini_mime (1.1.5)
+    minitest (5.20.0)
+    mutex_m (0.1.2)
+    net-imap (0.4.9)
+      date
+      net-protocol
+    net-pop (0.1.2)
+      net-protocol
+    net-protocol (0.2.2)
+      timeout
+    net-smtp (0.4.0)
+      net-protocol
+    nio4r (2.7.0)
+    nokogiri (1.15.5-arm64-darwin)
+      racc (~> 1.4)
+    psych (5.1.2)
+      stringio
+    racc (1.7.3)
+    rack (3.0.8)
+    rack-session (2.0.0)
+      rack (>= 3.0.0)
+    rack-test (2.1.0)
+      rack (>= 1.3)
+    rackup (2.1.0)
+      rack (>= 3)
+      webrick (~> 1.8)
+    rails (7.1.2)
+      actioncable (= 7.1.2)
+      actionmailbox (= 7.1.2)
+      actionmailer (= 7.1.2)
+      actionpack (= 7.1.2)
+      actiontext (= 7.1.2)
+      actionview (= 7.1.2)
+      activejob (= 7.1.2)
+      activemodel (= 7.1.2)
+      activerecord (= 7.1.2)
+      activestorage (= 7.1.2)
+      activesupport (= 7.1.2)
+      bundler (>= 1.15.0)
+      railties (= 7.1.2)
+    rails-dom-testing (2.2.0)
+      activesupport (>= 5.0.0)
+      minitest
+      nokogiri (>= 1.6)
+    rails-html-sanitizer (1.6.0)
+      loofah (~> 2.21)
+      nokogiri (~> 1.14)
+    railties (7.1.2)
+      actionpack (= 7.1.2)
+      activesupport (= 7.1.2)
+      irb
+      rackup (>= 1.0.0)
+      rake (>= 12.2)
+      thor (~> 1.0, >= 1.2.2)
+      zeitwerk (~> 2.6)
+    rake (13.1.0)
+    rdoc (6.6.2)
+      psych (>= 4.0.0)
+    redis-client (0.19.1)
+      connection_pool
+    reline (0.4.1)
+      io-console (~> 0.5)
+    rspec (3.12.0)
+      rspec-core (~> 3.12.0)
+      rspec-expectations (~> 3.12.0)
+      rspec-mocks (~> 3.12.0)
+    rspec-core (3.12.2)
+      rspec-support (~> 3.12.0)
+    rspec-expectations (3.12.3)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.12.0)
+    rspec-mocks (3.12.6)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.12.0)
+    rspec-support (3.12.1)
+    ruby2_keywords (0.0.5)
+    sidekiq (7.2.0)
+      concurrent-ruby (< 2)
+      connection_pool (>= 2.3.0)
+      rack (>= 2.2.4)
+      redis-client (>= 0.14.0)
+    stringio (3.1.0)
+    thor (1.3.0)
+    timecop (0.9.8)
+    timeout (0.4.1)
+    tzinfo (2.0.6)
+      concurrent-ruby (~> 1.0)
+    webrick (1.8.1)
+    websocket-driver (0.7.6)
+      websocket-extensions (>= 0.1.0)
+    websocket-extensions (0.1.5)
+    zeitwerk (2.6.12)
+
+PLATFORMS
+  arm64-darwin-21
+
+DEPENDENCIES
+  rspec
+  rspec-goodies!
+  sidekiq
+  timecop
+
+BUNDLED WITH
+   2.4.20

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023 James Hu
+
+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,45 @@
+# rspec-goodies
+
+Provides RSpec helpers and matchers for stubs, Sidekiq, and more.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "rspec-goodies"
+```
+
+And then execute:
+
+```shell
+bundle install
+```
+
+Or install it yourself as:
+
+```shell
+gem install rspec-goodies
+```
+
+## Usage
+
+Within `spec_helper.rb` or `rails_helper.rb`
+
+```ruby
+require "rspec-goodies"
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/axsuul/rspec-goodies.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+task default: %i[]

data/lib/rspec/goodies/helpers/sidekiq.rb

@@ -0,0 +1,156 @@
+require "active_support"
+require "active_support/core_ext/hash"
+
+module RSpec
+  module Goodies
+    module Helpers
+      module Sidekiq
+        # Helper to briefly enable unique jobs functionality Only use this if you're explicitly testing unique job
+        # behavior otherwise it is very unpredictable and it's best to disable it for normal tests
+        def within_sidekiq_unique
+          ::Sidekiq::Enterprise.unique!
+
+          yield
+        ensure
+          disable_sidekiq_unique!
+        end
+
+        def disable_sidekiq_unique!
+          ::Sidekiq.configure_server do |config|
+            config.server_middleware do |chain|
+              chain.remove(::Sidekiq::Enterprise::Unique::Server)
+            end
+          end
+
+          ::Sidekiq.configure_client do |config|
+            config.client_middleware do |chain|
+              chain.remove(::Sidekiq::Enterprise::Unique::Client)
+            end
+          end
+        end
+
+        # Simulate job being performed within the entire middleware stack
+        def perform_sidekiq_job(worker_class, *args)
+          worker_class.perform_async(*args)
+
+          actual_worker_class =
+            if worker_class.is_a?(::Sidekiq::Worker::Setter)
+              worker_class.instance_variable_get("@klass")
+            else
+              worker_class
+            end
+
+          actual_worker_class.process_job(actual_worker_class.jobs.last)
+        end
+
+        def process_sidekiq_payloads(payloads)
+          payloads.each do |payload|
+            payload_hash = ::Sidekiq.load_json(payload)
+            worker_class = ::Sidekiq::Testing.constantize(payload_hash["class"])
+
+            worker_class.process_job(payload_hash)
+          end
+        end
+
+        def add_enqueued_sidekiq_job(worker_class:, args:, metadata: {}, jid: SecureRandom.hex, queue: :default)
+          payload = ::Sidekiq.dump_json(
+            metadata.merge(
+              "jid" => jid,
+              "class" => worker_class.to_s,
+              "args" => args,
+              "queue" => queue.to_s,
+              "enqueued_at" => Time.current.to_f,
+            ),
+          )
+
+          ::Sidekiq.redis do |redis|
+            redis.sadd("queues", queue.to_s)
+            redis.lpush("queue:#{queue}", payload)
+          end
+
+          payload
+        end
+
+        # Simulate job being added to retry queue (based off Sidekiq source code)
+        def add_retry_sidekiq_job(
+          worker_class:,
+          args:,
+          metadata: {},
+          jid: SecureRandom.hex,
+          retry_count: 2,
+          retry_at: 1.hour.from_now
+        )
+          payload = ::Sidekiq.dump_json(
+            metadata.merge(
+              "jid" => jid,
+              "class" => worker_class.to_s,
+              "args" => args,
+              "queue" => "default",
+              "failed_at" => Time.now.to_f,
+              "retry_count" => retry_count,
+              "error_backtrace" => ["line1", "line2"],
+            ),
+          )
+
+          ::Sidekiq.redis do |redis|
+            redis.zadd("retry", retry_at.to_f.to_s, payload)
+          end
+
+          payload
+        end
+
+        def add_scheduled_sidekiq_job(worker_class:, args:, metadata: {}, jid: SecureRandom.hex)
+          payload = ::Sidekiq.dump_json(
+            metadata.merge(
+              "jid" => jid,
+              "class" => worker_class.to_s,
+              "args" => args,
+            ),
+          )
+          score = Time.now.to_f
+
+          ::Sidekiq.redis do |redis|
+            redis.zadd("schedule", score, payload)
+          end
+
+          payload
+        end
+
+        # Simulate job being worked on a worker so that's available via the Sidekiq::Workers.new API (based off Sidekiq
+        # source code)
+        def add_in_progress_sidekiq_job(worker_class:, args:, jid: SecureRandom.hex)
+          @sidekiq_job_in_progress_thread_id ||= 1000
+          @sidekiq_job_in_progress_count ||= 0
+
+          process_id = "foo:#{SecureRandom.hex}"
+          job_data = ::Sidekiq.dump_json(
+            "queue" => "default",
+            "payload" => {
+              "jid" => jid,
+              "class" => worker_class.to_s,
+              "args" => args,
+            },
+            "run_at" => Time.current.to_i,
+          )
+          process_data = ::Sidekiq.dump_json(
+            "hostname" => "foo",
+            "started_at" => Time.now.to_f,
+            "queues" => ["default"],
+          )
+
+          ::Sidekiq.redis do |redis|
+            redis.incr("busy")
+            redis.sadd("processes", process_id)
+            redis.hmset(
+              process_id, "info",
+              process_data, "at",
+              Time.current.to_f, "busy",
+              @sidekiq_job_in_progress_count += 1,
+            )
+            redis.hmset("#{process_id}:work", @sidekiq_job_in_progress_thread_id += 1, job_data)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rspec/goodies/helpers/stubs.rb

@@ -0,0 +1,76 @@
+module RSpec
+  module Goodies
+    module Helpers
+      module Stubs
+        def stub_service_as_spy(klass)
+          service_stub = class_spy(klass)
+          stub_const(klass.to_s, service_stub)
+
+          service_stub
+        end
+
+        def stub_rails_logger_as_spy
+          instance_spy("ActiveSupport::Logger").tap do |stub|
+            allow(::Rails).to receive(:logger).and_return(stub)
+          end
+        end
+
+        def stub_class_const(klass, const_string, value)
+          raise ArgumentError, "a Class or Module must be passed in" if !klass.is_a?(Class) && !klass.is_a?(Module)
+
+          # Check that constant actually exists. Also by calling klass here we ensure it's loaded before stubbing
+          # constant
+          unless klass.const_defined?(const_string)
+            raise Exception, "Tried to stub #{klass}::#{const_string} but it doesn't exist!"
+          end
+
+          stub_const("#{klass.name}::#{const_string}", value)
+        end
+
+        # Stubs existing constant with resulting hash deep merged with existing hash and hash passed in
+        def stub_class_const_and_merge(klass, const_string, hash)
+          raise ArgumentError, "must pass in hash" unless hash.is_a?(Hash)
+
+          existing_hash = klass.const_get(const_string)
+
+          stub_class_const(klass, const_string, existing_hash.deep_merge(hash))
+        end
+
+        # Stub environment variable so that it doesn't leak out of tests
+        def stub_env(name, value)
+          allow(ENV).to receive(:[]).with(name).and_return(value)
+        end
+
+        # Only works with nested credentials for now
+        def stub_rails_credentials(stubbed_config)
+          raise NotImplementedError, "Rails not found" unless Object.const_defined?(:Rails)
+
+          credentials = ::Rails.application.credentials
+          credentials_config = credentials.config
+          stubbed_credentials_config = credentials_config
+
+          stubbed_config.each do |key, key_stubbed_config|
+            key = key.to_sym
+
+            case key_stubbed_config
+            when Hash
+              key_stubbed_config.each do |child_key, _|
+                if !credentials_config.key?(key) || !credentials_config[key].key?(child_key)
+                  raise ArgumentError, "Tried to stub Rails credential #{key}: #{child_key} but it doesn't exist!"
+                end
+              end
+
+              # Merge in existing credentials so we don't break accessing other credentials
+              stubbed_credentials_config[key].merge!(key_stubbed_config)
+            when String
+              # Not nested so set it directly
+              stubbed_credentials_config[key] = key_stubbed_config
+            end
+          end
+
+          allow(::Rails.application).to receive(:credentials).and_return(OpenStruct.new(stubbed_credentials_config))
+        end
+      end
+    end
+  end
+end

data/lib/rspec/goodies/matchers/collection.rb

@@ -0,0 +1,50 @@
+# Used to match if array includes elements and when order matters
+RSpec::Matchers.define :include_in_order do |*args|
+  match do |collection|
+    expect_to_match = lambda do |value, matcher|
+      # If composable matcher (e.g. a_string_matching(...) then we need to use a different expectation)
+      if matcher.class.name.match?(/Matcher/)
+        expect(value).to match(matcher)
+      else
+        expect(value).to eq(matcher)
+      end
+    end
+
+    is_matched_in_order = false
+
+    # Go through collection and try to find the first match
+    collection.each_with_index do |element, collection_index|
+      initial_matcher = args.first
+
+      expect_to_match.call(element, initial_matcher)
+
+      # If reaches here, that means we found the first match so let's see if the remaining also match in order
+      is_matched_in_order = args[1..-1].each_with_index.all? do |pending_matcher, pending_matcher_index|
+        expect_to_match.call(collection[collection_index + pending_matcher_index + 1], pending_matcher)
+
+        true
+      rescue RSpec::Expectations::ExpectationNotMetError
+        false
+      end
+
+      # No need to search anymore once we found it
+      break if is_matched_in_order
+    rescue RSpec::Expectations::ExpectationNotMetError
+      # Keep trying to find the first match
+    end
+
+    is_matched_in_order
+  end
+end
+
+RSpec::Matchers.alias_matcher :a_collection_including_in_order, :include_in_order
+
+# So we can do:
+#
+# expect(collection).to not_any(...)
+#
+# since we can't do:
+#
+# expect(collection).not_to all(...)
+#
+RSpec::Matchers.define_negated_matcher :not_any, :include

data/lib/rspec/goodies/matchers/date_time.rb

@@ -0,0 +1,24 @@
+RSpec::Matchers.define :match_timestamp do |expected, decimal_places = nil|
+  normalize = lambda do |value|
+    value = DateTime.parse(value) if value.is_a?(String)
+
+    # Compare floats since there can be sub-seconds
+    normalized = value.to_f
+
+    # Can be limited to decimals places (e.g. 0.002 can match 0.0019 if "3" is provided)
+    normalized = normalized.round(decimal_places) if decimal_places
+
+    normalized
+  end
+
+  match do |actual|
+    normalize.call(actual) == normalize.call(expected)
+  end
+
+  failure_message do |actual|
+    <<~MESSAGE
+      expected that #{actual} (#{normalize.call(actual)}) would match timestamp #{expected}
+      (#{normalize.call(expected)})"
+    MESSAGE
+  end
+end

data/lib/rspec/goodies/matchers/hash.rb

@@ -0,0 +1,8 @@
+# Used to match if hash doesn't have all keys
+RSpec::Matchers.define :not_have_keys do |*keys|
+  match do |hash|
+    keys.all? { |k| !hash.key?(k) }
+  end
+end
+
+RSpec::Matchers.alias_matcher :a_hash_without_keys, :not_have_keys

data/lib/rspec/goodies/matchers/sidekiq.rb

@@ -0,0 +1,214 @@
+require "rspec/matchers"
+require "sidekiq/testing"
+
+class SidekiqJobsEnqueuedMatcher
+  include RSpec::Matchers
+
+  attr_reader :new_jobs, :new_jobs_matching_properties
+
+  def initialize(actual, worker_class, expected_size = nil, expected_properties = {})
+    @actual = actual
+    @worker_class = worker_class
+
+    # Size is optional to be passed in
+    if expected_size.is_a?(Hash)
+      @expected_properties = expected_size
+      @expected_size = nil
+    else
+      @expected_properties = expected_properties
+      @expected_size = expected_size
+    end
+
+    # Normalize
+    @expected_properties.stringify_keys!
+  end
+
+  def matches?
+    # Get jobs before so that we only perform new jobs
+    jobs_before = @worker_class.jobs.clone
+
+    # Calls the actual block of the matcher
+    @actual.call
+
+    jobs_after = @worker_class.jobs
+    @new_jobs = jobs_after - jobs_before
+
+    @new_jobs_matching_properties = @new_jobs.select do |job|
+      matched_count = 0
+
+      @expected_properties.each do |key, value|
+        case key
+        when "args"
+          # Coerce to an array unless it's a matcher
+          value = Array(value) unless value.respond_to?(:base_matcher)
+
+          expect(Array(job[key])).to match(value)
+        when "at"
+          if (scheduled_at = job[key])
+            # It's a float in job
+            expect(scheduled_at).to eq(value.to_f)
+
+          # Otherwise if nil, then we are looking for jobs that aren't scheduled
+          else
+            expect(job.key?("at")).to eq false
+          end
+        when "bid"
+          expect(job[key]).to match(value)
+        when "queue", "unique_for", "unique_until"
+          expect(job[key].to_s).to eq(value.to_s)
+        when "metadata"
+          # Even though we call this metadata, it's actually just keys in the job hash. We iterate through each key so
+          # that it also works on checking for nil values
+          value.each do |metadata_key, metadata_value|
+            expect(job[metadata_key]).to eq metadata_value
+          end
+        end
+
+        matched_count += 1
+      rescue RSpec::Expectations::ExpectationNotMetError
+        # Doesn't contribute to matched_count if any expectations fail
+      end
+
+      matched_count == @expected_properties.count
+    end
+
+    # Check expected number of new jobs enqueued to match size if specified
+    if @expected_size
+      @new_jobs_matching_properties.size == @expected_size
+    else
+      @new_jobs_matching_properties.any?
+    end
+  end
+
+  def new_jobs_sanitized
+    (@new_jobs || []).map { |j| j.except("jid", "backtrace", "retry", "created_at", "enqueued_at") }
+  end
+end
+
+RSpec::Matchers.define :have_sidekiq_jobs_enqueued do |*args|
+  match do |actual|
+    @matcher = SidekiqJobsEnqueuedMatcher.new(actual, *args)
+
+    @matcher.matches?
+  end
+
+  failure_message do |_|
+    "expected Sidekiq jobs to be enqueued with #{args.join(', ')} but instead found:\n\n#{@matcher.new_jobs_sanitized.pretty_inspect}"
+  end
+
+  def supports_block_expectations?
+    true
+  end
+end
+
+RSpec::Matchers.alias_matcher :have_sidekiq_job_enqueued, :have_sidekiq_jobs_enqueued
+RSpec::Matchers.define_negated_matcher :not_have_sidekiq_jobs_enqueued, :have_sidekiq_jobs_enqueued
+
+RSpec::Matchers.define :have_sidekiq_jobs_enqueued_and_performed do |*args|
+  match do |actual|
+    # Add the first arguments to the end since we are processing the chain from
+    # last to first
+    @worker_chain ||= []
+    @worker_chain << args
+
+    # Alias
+    perform_jobs = actual
+
+    while @worker_chain.any?
+      args = @worker_chain.pop
+      worker_class = args.first
+
+      @matcher = SidekiqJobsEnqueuedMatcher.new(perform_jobs, *args)
+
+      expect(@matcher.matches?).to eq true
+
+      new_jobs_matching_properties = @matcher.new_jobs_matching_properties
+
+      perform_jobs = lambda do
+        new_jobs_matching_properties.each do |job|
+          worker_class = job["class"]
+
+          # Remove from queue after performing it
+          Sidekiq::Queues.delete_for(job["jid"], job["queue"], worker_class)
+
+          worker_class.constantize.process_job(job)
+        end
+      end
+    end
+
+    # Make sure we call perform jobs one last time if there's no more in chain
+    perform_jobs.call
+  end
+
+  chain :thereafter do |*next_args|
+    @worker_chain ||= []
+    @worker_chain.prepend(next_args)
+  end
+
+  failure_message do |_|
+    "expected Sidekiq jobs to be enqueued and performed with #{args.join(', ')} but instead found:\n\n#{@matcher.new_jobs_sanitized.pretty_inspect}"
+  end
+
+  def supports_block_expectations?
+    true
+  end
+end
+
+RSpec::Matchers.define :have_sidekiq_batch_with_callback_triggered do |event, callback_class|
+  match do |actual|
+    received_callbacks = Hash.new do |hash, key|
+      hash[key] = {
+        death: [],
+        complete: [],
+        success: [],
+      }
+    end
+
+    sidekiq_batch_stub = ::Sidekiq::Batch.new.tap do |stub|
+      # This can be called multiple times so track each time
+      allow(stub).to receive(:on) do |actual_event, actual_callback_class, actual_callback_options|
+        received_callbacks[actual_callback_class.name][actual_event].push(actual_callback_options)
+      end
+
+      allow(::Sidekiq::Batch).to receive(:new).and_return(stub)
+    end
+
+    # Ensure stuff happens within batch
+    allow(sidekiq_batch_stub).to receive(:jobs).and_call_original
+
+    actual.call
+
+    # Only care about those received for event and callback
+    relevant_received_callbacks = received_callbacks[callback_class.to_s][event]
+
+    expect(relevant_received_callbacks).to be_any
+
+    # Once block is complete, simulate Sidekiq batch callback is called by manually calling it ourselves since it
+    # doesn't automatically get called in tests
+    ::Sidekiq::Batch.new.tap do |batch|
+      # Ensure created in redis so that we can access it
+      batch.jobs {}
+
+      # Simulate that callback is called for each time callback options were received
+      relevant_received_callbacks.each do |callback_options|
+        # Also simulate that callback options are converted to JSON and back to hash which is what happens in production
+        callback_class.new.send(
+          :"on_#{event}",
+          ::Sidekiq::Batch::Status.new(batch.bid),
+          JSON.parse(callback_options.to_json),
+        )
+      end
+    end
+  end
+
+  failure_message do |_|
+    "expected jobs to perform within Sidekiq batch with #{callback_class} callback to be triggered by #{event}"
+  end
+
+  def supports_block_expectations?
+    true
+  end
+end
+
+RSpec::Matchers.define_negated_matcher :not_have_sidekiq_batch_with_callback_triggered,
+  :have_sidekiq_batch_with_callback_triggered

data/lib/rspec/goodies/matchers/string.rb

@@ -0,0 +1,16 @@
+RSpec::Matchers.define_negated_matcher :a_string_not_matching, :a_string_matching
+
+RSpec::Matchers.define :match_url do |matched_url|
+  match do |url|
+    uri = Addressable::URI.parse(url)
+    matched_uri = Addressable::URI.parse(matched_url)
+
+    uri.host == matched_uri.host &&
+    uri.path == matched_uri.path &&
+    uri.query_values == matched_uri.query_values
+  end
+
+  failure_message do |url|
+    "expected the url: #{url} to match the url: #{matched_url}"
+  end
+end

data/lib/rspec-goodies.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "rspec/core"
+require "rspec/goodies/helpers/sidekiq"
+require "rspec/goodies/helpers/stubs"
+require "rspec/goodies/matchers/collection"
+require "rspec/goodies/matchers/date_time"
+require "rspec/goodies/matchers/hash"
+require "rspec/goodies/matchers/sidekiq"
+require "rspec/goodies/matchers/string"
+
+RSpec.configure do |config|
+  config.include(RSpec::Goodies::Helpers::Sidekiq)
+  config.include(RSpec::Goodies::Helpers::Stubs)
+end

data/rspec-goodies.gemspec

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+Gem::Specification.new do |spec|
+  spec.name = "rspec-goodies"
+  spec.version = "0.0.1"
+  spec.authors = ["James Hu"]
+
+  spec.summary = "RSpec goodies full of helpers, matchers, and more"
+  spec.description = "RSpec goodies full of helpers, matchers, and more"
+  spec.homepage = "https://github.com/axsuul/rspec-goodies"
+  spec.license = "MIT"
+
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/axsuul/rspec-goodies"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Uncomment to register a new dependency of your gem
+  spec.add_dependency "activesupport"
+  spec.add_dependency "byebug"
+  spec.add_dependency "rails"
+
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "sidekiq"
+  spec.add_development_dependency "timecop"
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

metadata

@@ -0,0 +1,143 @@
+--- !ruby/object:Gem::Specification
+name: rspec-goodies
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- James Hu
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2024-01-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sidekiq
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: RSpec goodies full of helpers, matchers, and more
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/rspec-goodies.rb
+- lib/rspec/goodies/helpers/sidekiq.rb
+- lib/rspec/goodies/helpers/stubs.rb
+- lib/rspec/goodies/matchers/collection.rb
+- lib/rspec/goodies/matchers/date_time.rb
+- lib/rspec/goodies/matchers/hash.rb
+- lib/rspec/goodies/matchers/sidekiq.rb
+- lib/rspec/goodies/matchers/string.rb
+- rspec-goodies.gemspec
+homepage: https://github.com/axsuul/rspec-goodies
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/axsuul/rspec-goodies
+  source_code_uri: https://github.com/axsuul/rspec-goodies
+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.1.6
+signing_key:
+specification_version: 4
+summary: RSpec goodies full of helpers, matchers, and more
+test_files: []