RSpec Sidekiq

https://github.com/wspurgin/rspec-sidekiq
Admin
RSpec Sidekiq provides RSpec matchers and helpers for testing Sidekiq jobs, simplifying the process...
Tokens:6,390
Snippets:33
Trust Score:8.1
License:MIT
Update:1 year ago
Show doc for...
Tokens:
Raw
### rspec-sidekiq Example Matcher Usage

Source: https://github.com/wspurgin/rspec-sidekiq/blob/main/README.md

Provides an example of how to use various rspec-sidekiq matchers within an RSpec test suite to verify job properties like queue, retryability, uniqueness, and expiration. It also shows how to test job enqueuing.

```ruby
require 'spec_helper'

describe AwesomeJob do
  it { is_expected.to be_processed_in :my_queue }
  it { is_expected.to be_retryable 5 }
  it { is_expected.to be_unique }
  it { is_expected.to be_expired_in 1.hour }

  it 'enqueues another awesome job' do
    subject.perform

    expect(AnotherAwesomeJob).to have_enqueued_sidekiq_job('Awesome', true)
  end
end
```

--------------------------------

### Install rspec-sidekiq Gem

Source: https://github.com/wspurgin/rspec-sidekiq/blob/main/README.md

Add the rspec-sidekiq gem to your Gemfile within the test group to enable its testing utilities for Sidekiq jobs.

```ruby
# Gemfile
group :test do
  gem 'rspec-sidekiq'
end
```

--------------------------------

### rspec-sidekiq: Silence have_enqueued_sidekiq_job warnings

Source: https://github.com/wspurgin/rspec-sidekiq/wiki/have_enqueued_sidekiq_job-without-argument-default-behavior

To globally silence warnings related to the `have_enqueued_sidekiq_job` default behavior change, configure `RSpec::Sidekiq` in your RSpec setup.

```ruby
RSpec::Sidekiq.configure do |config|
  config.silence_warning(:have_enqueued_sidekiq_job_default)
end
```

--------------------------------

### Mocking Sidekiq Batches with stub_batches

Source: https://github.com/wspurgin/rspec-sidekiq/blob/main/README.md

Explains how to use the `stub_batches: true` option to mock Sidekiq Pro's Batch implementation for testing without a Redis instance. It highlights that this uses a NullObject pattern and may not perfectly mirror the actual Sidekiq::Batch API, cautioning against relying on non-existent methods.

```ruby
RSpec.describe "Using mocked batches", stub_batches: true do
  it "uses mocked batches" do
    batch = Sidekiq::Batch.new
    batch.jobs do
      SomeJob.perform_async 123
    end

    expect(SomeJob).to have_enqueued_sidekiq_job

    # Caution, the NullObject pattern means that the mocked Batch implementation
    # responds to anything... even if it's not on the true `Sidekiq::Batch` API
    # For example, the following fails
    expect { batch.foobar! }.to raise_error(NoMethodError)
  end
end
```

--------------------------------

### RSpec Configuration

Source: https://github.com/wspurgin/rspec-sidekiq/blob/main/CHANGES.md

Demonstrates how to configure RSpec to integrate with rspec-sidekiq, particularly for enabling specific matchers or behaviors.

```APIDOC
Configuration: RSpec.configure

Description: Used to configure RSpec behavior, including loading custom matchers or setting up testing environments.

Usage:
  RSpec.configure do |config|
    # Load sidekiq matchers
    config.include RspecSidekiqMatchers

    # Example: Configure Sidekiq options for testing
    # config.sidekiq_options = { :queues => [['default', 1]] }
  end

Notes:
  The `rspec-sidekiq` gem typically makes its matchers available automatically upon loading, but explicit inclusion can be used if needed.

Related:
  rspec/sidekiq/matchers (gem module)
```

--------------------------------

### Configure rspec-sidekiq

Source: https://github.com/wspurgin/rspec-sidekiq/blob/main/README.md

Customize rspec-sidekiq's behavior by adding configuration options to your `spec_helper.rb` file. This includes options for clearing jobs, enabling terminal colors, and warning about jobs not processed by Sidekiq.

```ruby
RSpec::Sidekiq.configure do |config|
  # Clears all job queues before each example
  config.clear_all_enqueued_jobs = true # default => true

  # Whether to use terminal colours when outputting messages
  config.enable_terminal_colours = true # default => true

  # Warn when jobs are not enqueued to Redis but to a job array
  config.warn_when_jobs_not_processed_by_sidekiq = true # default => true
end
```

--------------------------------

### Use enqueue_sidekiq_job Matcher

Source: https://github.com/wspurgin/rspec-sidekiq/blob/main/README.md

Assert that a block of code enqueues a Sidekiq job. This matcher supports specifying the job class, arguments, queue, timing, and the number of times the job is enqueued.

```ruby
# Basic
expect { AwesomeJob.perform_async }.to enqueue_sidekiq_job

# A specific job class
expect { AwesomeJob.perform_async }.to enqueue_sidekiq_job(AwesomeJob)

# with specific arguments
expect { AwesomeJob.perform_async "Awesome!" }.to enqueue_sidekiq_job.with("Awesome!")

# On a specific queue
expect { AwesomeJob.set(queue: "high").perform_async }.to enqueue_sidekiq_job.on("high")

# At a specific datetime
specific_time = 1.hour.from_now
expect { AwesomeJob.perform_at(specific_time) }.to enqueue_sidekiq_job.at(specific_time)

# In a specific interval (be mindful of freezing or managing time here)
freeze_time do
  expect { AwesomeJob.perform_in(1.hour) }.to enqueue_sidekiq_job.in(1.hour)
end

# A specific number of times
expect { AwesomeJob.perform_async }.to enqueue_sidekiq_job.never
expect { AwesomeJob.perform_async }.to enqueue_sidekiq_job.exactly(0)
expect { AwesomeJob.perform_async }.to enqueue_sidekiq_job.exactly(0).time
expect { AwesomeJob.perform_async }.to enqueue_sidekiq_job.once
expect { AwesomeJob.perform_async }.to enqueue_sidekiq_job.exactly(1).time
expect { AwesomeJob.perform_async }.to enqueue_sidekiq_job.exactly(:once)
expect { AwesomeJob.perform_async }.to enqueue_sidekiq_job.at_least(1).time
expect { AwesomeJob.perform_async }.to enqueue_sidekiq_job.at_least(:once)
expect { AwesomeJob.perform_async }.to enqueue_sidekiq_job.at_most(2).times
expect { AwesomeJob.perform_async }.to enqueue_sidekiq_job.at_most(:twice)
expect { AwesomeJob.perform_async }.to enqueue_sidekiq_job.at_most(:thrice)

# With specific context:
# Useful for testing anything `set` on the job, including
# overrides to things like `retry`
expect {
  AwesomeJob.set(trace_id: "something").perform_async
}.to enqueue_sidekiq_job.with_context(trace_id: anything)

expect {
  AwesomeJob.set(retry: 5).perform_async
}.to enqueue_sidekiq_job.with_context(retry: 5)

# Combine and chain them as desired
expect { AwesomeJob.perform_at(specific_time, "Awesome!") }.to(
  enqueue_sidekiq_job(AwesomeJob)
  .with("Awesome!")
  .on("default")
  .at(specific_time)
)

# Also composable
expect do
  AwesomeJob.perform_async
  OtherJob.perform_async
end.to enqueue_sidekiq_job(AwesomeJob).and enqueue_sidekiq_job(OtherJob)
```

--------------------------------

### Testing Scheduled Jobs with Time Matchers

Source: https://github.com/wspurgin/rspec-sidekiq/blob/main/README.md

Checks if jobs were scheduled to run at a specific time or within a given interval. Supports `.at`, `.in`, and `.immediately` matchers for precise scheduling verification.

```ruby
time = 5.minutes.from_now
AwesomeJob.perform_at time, 'Awesome', true
expect(AwesomeJob).to have_enqueued_sidekiq_job('Awesome', true).at(time)

AwesomeJob.perform_in 5.minutes, 'Awesome', true
expect(AwesomeJob).to have_enqueued_sidekiq_job('Awesome', true).in(5.minutes)

# Job scheduled for a date in the past are enqueued immediately.
AwesomeJob.perform_later 5.minutes.ago, 'Awesome', true # equivalent to: AwesomeJob.perform_async 'Awesome', true
expect(AwesomeJob).to have_enqueued_sidekiq_job('Awesome', true).immediately
```

--------------------------------

### RSpec Matchers for Sidekiq Batches

Source: https://github.com/wspurgin/rspec-sidekiq/blob/main/CHANGES.md

Provides matchers for testing Sidekiq Batch operations, including stubbing batch behavior and verifying batch callbacks.

```APIDOC
NullBatch#description
  # Provides a description for a null batch object.
  # Returns: A string description.
  # Example:
  #   NullBatch.new.description

NullBatch#on(callback_type)
  # Allows setting a callback for a specific batch event on a null batch.
  # Parameters:
  #   callback_type: The type of callback (e.g., :success, :failure).
  # Returns: The null batch object itself, allowing chaining.
  # Example:
  #   NullBatch.new.on(:success)

NullStatus#failures
  # Returns the number of failures for a null status object.
  # Returns: An integer representing failures.
  # Example:
  #   NullStatus.new.failures

# Note: Support for mocking Sidekiq::Batch is opt-in by default since v4.0.0.
# Note: Support for Class#method notation in batch callbacks was added in v3.1.0.

```

--------------------------------

### RSpec Matchers for Sidekiq

Source: https://github.com/wspurgin/rspec-sidekiq/blob/main/CHANGES.md

This entry documents the RSpec matchers provided by the rspec-sidekiq gem for testing Sidekiq job enqueuing and retry behavior. It includes common matchers and their usage patterns.

```APIDOC
Matcher: have_enqueued_job

Description: Asserts that a specific job class was enqueued with given arguments.

Signature:
  have_enqueued_job(job_class, *args)

Parameters:
  job_class: The class of the Sidekiq job to check.
  *args: Optional arguments that the job was enqueued with.

Example:
  expect(MyWorker).to have_enqueued_job(arg1, arg2)

Related:
  have_enqueued_jobs, be_delayed, be_retryable

--- 

Matcher: have_enqueued_jobs

Description: Asserts that multiple jobs were enqueued, potentially with different arguments.

Signature:
  have_enqueued_jobs(job_description1, job_description2, ...)
  job_description can be a job class or a hash {job_class => args}

Parameters:
  job_description: A description of the job to check.

Example:
  expect(MyWorker).to have_enqueued_jobs([MyWorker, {OtherWorker => [arg1]}])

Related:
  have_enqueued_job, be_delayed, be_retryable

--- 

Matcher: be_delayed

Description: Asserts that a job was enqueued using the `delay` extension.

Signature:
  be_delayed(job_class, *args)

Parameters:
  job_class: The class of the Sidekiq job.
  *args: Optional arguments passed to the `delay` method.

Example:
  expect(MyWorker).to be_delayed(arg1)

Related:
  have_enqueued_job, have_enqueued_jobs, be_retryable

--- 

Matcher: be_retryable

Description: Asserts that a job is configured to be retryable, optionally checking the number of retries.

Signature:
  be_retryable(expected_retries = nil)

Parameters:
  expected_retries: Optional. The expected number of retries. If nil, checks if retry is enabled.

Example:
  expect(MyWorker).to be_retryable
  expect(MyWorker).to be_retryable(5)

Notes:
  This matcher checks the `retry` option set on the Sidekiq worker.

Related:
  have_enqueued_job, have_enqueued_jobs, be_delayed
```

--------------------------------

### RSpec Matchers for Sidekiq Enterprise Unique Jobs

Source: https://github.com/wspurgin/rspec-sidekiq/blob/main/CHANGES.md

Provides matchers for testing Sidekiq Enterprise's unique job functionality, specifically the `until` matcher.

```APIDOC
until(time_or_condition)
  # Matches jobs that are unique until a specified time or condition.
  # This matcher is specific to Sidekiq Enterprise.
  # Parameters:
  #   time_or_condition: A Time object or a condition that defines uniqueness.
  # Returns: A matcher object.
  # Example:
  #   expect(MyUniqueWorker).to have_enqueued_sidekiq_job.until(1.hour.from_now)

```

--------------------------------

### Testing Delayed Jobs with be_delayed Matcher

Source: https://github.com/wspurgin/rspec-sidekiq/blob/main/README.md

Demonstrates how to use the deprecated `be_delayed` matcher to test methods invoked asynchronously via Sidekiq's `delay` methods. It covers basic calls, calls with arguments, and delayed execution with `delay_for` and `delay_until`. Note that this matcher is deprecated for Sidekiq 7+.

```ruby
Object.delay.is_nil? # delay
expect(Object.method :is_nil?).to be_delayed
Object.delay.is_a? Object # delay with argument
expect(Object.method :is_a?).to be_delayed(Object)

Object.delay_for(1.hour).is_nil? # delay for
expect(Object.method :is_nil?).to be_delayed.for 1.hour
Object.delay_for(1.hour).is_a? Object # delay for with argument
expect(Object.method :is_a?).to be_delayed(Object).for 1.hour

Object.delay_until(1.hour.from_now).is_nil? # delay until
expect(Object.method :is_nil?).to be_delayed.until 1.hour.from_now
Object.delay_until(1.hour.from_now).is_a? Object # delay until with argument
expect(Object.method :is_a?).to be_delayed(Object).until 1.hour.from_now

#Rails Mailer
MyMailer.delay.some_mail
expect(MyMailer.instance_method :some_mail).to be_delayed
```

--------------------------------

### Testing Enqueued Sidekiq Jobs

Source: https://github.com/wspurgin/rspec-sidekiq/blob/main/README.md

Verifies that Sidekiq jobs have been enqueued with specific arguments or patterns. Supports checking for any arguments, specific hash contents, and chaining multiple job checks.

```ruby
expect(AwesomeJob).to have_enqueued_sidekiq_job(any_args)
expect(AwesomeJob).to have_enqueued_sidekiq_job(hash_including("something" => "Awesome"))
```

--------------------------------

### RSpec Matchers for Enqueued Sidekiq Jobs

Source: https://github.com/wspurgin/rspec-sidekiq/blob/main/CHANGES.md

Provides matchers to assert that Sidekiq jobs have been enqueued, including checks for job arguments, queue names, and execution times. These matchers simplify testing of background job processing.

```APIDOC
have_enqueued_sidekiq_job(expected_args = nil)
  # Asserts that one or more Sidekiq jobs have been enqueued.
  # Can optionally match against specific arguments.
  # If no arguments are provided, it matches any job.
  # Parameters:
  #   expected_args: An array of arguments, a single argument, or RSpec matchers to match against the job's arguments.
  #                  Can also be `any_args` to explicitly match any arguments.
  # Returns: A matcher object.
  # Example:
  #   expect(MyWorker).to have_enqueued_sidekiq_job('arg1', 123)
  #   expect(MyWorker).to have_enqueued_sidekiq_job(hash_including(:key => 'value'))
  #   expect(MyWorker).to have_enqueued_sidekiq_job(any_args)

enqueue_sidekiq_job(expected_args = nil)
  # Alias for `have_enqueued_sidekiq_job` for block-style expectations.
  # Parameters:
  #   expected_args: Same as `have_enqueued_sidekiq_job`.
  # Returns: A matcher object.
  # Example:
  #   expect { MyWorker.perform_async('arg1') }.to enqueue_sidekiq_job('arg1')

# Related Matchers:
# - `have_enqueued_sidekiq_job(any_args)`: Matches jobs with any arguments.
# - `have_enqueued_sidekiq_job(job_count)`: Matches a specific number of enqueued jobs.
# - `have_enqueued_sidekiq_job.on(queue_name)`: Matches jobs enqueued on a specific queue.
# - `have_enqueued_sidekiq_job.in(time_interval)`: Matches jobs enqueued with a delay.
# - `have_enqueued_sidekiq_job.at(time)`: Matches jobs enqueued at a specific time.
# - `have_enqueued_sidekiq_job.with_context(context_hash)`: Matches jobs with specific context.
# - `have_enqueued_sidekiq_job.exactly(n)`: Matches exactly n jobs.

# Breaking Changes:
# - In v5.0.0, `have_enqueued_sidekiq_job()` without arguments now matches jobs with any arguments, similar to `enqueue_sidekiq_job()` or `have_enqueued_sidekiq_job(any_args)`.
# - In v4.0.0, support for matching jobs on ActiveJob's private API args (e.g., `_aj_globalid`) was dropped.
# - In v4.0.0, the `have_enqueued_job` matcher was dropped.

```

```APIDOC
have_enqueued_sidekiq_job(job_count)
  # Asserts that a specific number of Sidekiq jobs have been enqueued.
  # Parameters:
  #   job_count: The exact number of jobs expected.
  # Returns: A matcher object.
  # Example:
  #   expect(MyWorker).to have_enqueued_sidekiq_job.exactly(5)

have_enqueued_sidekiq_job.on(queue_name)
  # Filters enqueued jobs by their queue name.
  # Parameters:
  #   queue_name: The name of the queue to match.
  # Returns: A matcher object.
  # Example:
  #   expect(MyWorker).to have_enqueued_sidekiq_job.on('high_priority')

have_enqueued_sidekiq_job.in(time_interval)
  # Filters enqueued jobs by their scheduled delay.
  # Parameters:
  #   time_interval: A duration (e.g., 5.minutes, 1.hour) or a time object.
  # Returns: A matcher object.
  # Example:
  #   expect(MyWorker).to have_enqueued_sidekiq_job.in(10.minutes)

have_enqueued_sidekiq_job.at(time)
  # Filters enqueued jobs by their specific scheduled time.
  # Parameters:
  #   time: A Time object representing the scheduled execution time.
  # Returns: A matcher object.
  # Example:
  #   expect(MyWorker).to have_enqueued_sidekiq_job.at(Time.now + 1.hour)

have_enqueued_sidekiq_job.with_context(context_hash)
  # Filters enqueued jobs by their context hash.
  # Parameters:
  #   context_hash: A hash representing the job's context.
  # Returns: A matcher object.
  # Example:
  #   expect(MyWorker).to have_enqueued_sidekiq_job.with_context({ user_id: 123 })

# Note: These modifiers can be chained.
# Example:
#   expect(MyWorker).to have_enqueued_sidekiq_job('user_id').on('default').in(5.minutes)

```

--------------------------------

### Specifying Number of Enqueued Jobs

Source: https://github.com/wspurgin/rspec-sidekiq/blob/main/README.md

Allows precise testing of the number of times a specific job has been enqueued. Supports exact counts, at least, and at most, using various syntaxes like 'once', 'twice', or numerical values.

```ruby
expect(AwesomeJob).to have_enqueued_sidekiq_job.once
expect(AwesomeJob).to have_enqueued_sidekiq_job.exactly(1).time
expect(AwesomeJob).to have_enqueued_sidekiq_job.exactly(:once)
expect(AwesomeJob).to have_enqueued_sidekiq_job.at_least(1).time
expect(AwesomeJob).to have_enqueued_sidekiq_job.at_least(:once)
expect(AwesomeJob).to have_enqueued_sidekiq_job.at_most(2).times
expect(AwesomeJob).to have_enqueued_sidekiq_job.at_most(:twice)
expect(AwesomeJob).to have_enqueued_sidekiq_job.at_most(:thrice)
```

--------------------------------

### RSpec Matchers for Aliasing `exactly(0)`

Source: https://github.com/wspurgin/rspec-sidekiq/blob/main/CHANGES.md

Introduces the `never` matcher as an alias for `exactly(0)` for more readable assertions on job counts.

```APIDOC
never
  # Alias for `exactly(0)` when used with job count matchers.
  # Improves readability for asserting that no jobs should be enqueued.
  # Returns: A matcher object.
  # Example:
  #   expect(MyWorker).to have_enqueued_sidekiq_job.never

```

--------------------------------

### Testing Job Queue Processing Location

Source: https://github.com/wspurgin/rspec-sidekiq/blob/main/README.md

The `be_processed_in` matcher verifies that a job is configured to be processed in a specific Sidekiq queue.

```ruby
sidekiq_options queue: :download
# test with...
expect(AwesomeJob).to be_processed_in :download # or
it { is_expected.to be_processed_in :download }
```

--------------------------------

### Testing Enqueued ActiveMailer Jobs

Source: https://github.com/wspurgin/rspec-sidekiq/blob/main/README.md

Checks if ActiveMailer jobs have been enqueued correctly, verifying the mailer class, method, delivery method, and arguments passed.

```ruby
user = User.first
AwesomeActionMailer.invite(user, true).deliver_later

expect(Sidekiq::Worker).to have_enqueued_sidekiq_job(
  "AwesomeActionMailer",
  "invite",
  "deliver_now",
  user,
  true
)
```

--------------------------------

### Testing Job Queue Assignment

Source: https://github.com/wspurgin/rspec-sidekiq/blob/main/README.md

Verifies that a job is enqueued onto the correct Sidekiq queue. Supports checking the queue name directly or when the queue is specified during enqueuing.

```ruby
class AwesomeJob
  include Sidekiq::Job

  sidekiq_options queue: :low
end

AwesomeJob.perform_async("a little awesome")
expect(AwesomeJob).to have_enqueued_sidekiq_job("a little awesome").on("low")

# Setting the queue when enqueuing
AwesomeJob.set(queue: "high").perform_async("Very Awesome!")
expect(AwesomeJob).to have_enqueued_sidekiq_job("Very Awesome!").on("high")
```

--------------------------------

### Testing Job Retryability

Source: https://github.com/wspurgin/rspec-sidekiq/blob/main/README.md

The `be_retryable` matcher checks if a job is configured to retry upon failure. It can verify the boolean state of retries or the specific number of retry attempts.

```ruby
sidekiq_options retry: 5
# test with...
expect(AwesomeJob).to be_retryable true # or
it { is_expected.to be_retryable true }
# ...or alternatively specify the number of times it should be retried
expect(AwesomeJob).to be_retryable 5 # or
it { is_expected.to be_retryable 5 }
# ...or when it should not retry
expect(AwesomeJob).to be_retryable false # or
it { is_expected.to be_retryable false }
```

--------------------------------

### rspec-sidekiq: have_enqueued_sidekiq_job behavior change (v5+)

Source: https://github.com/wspurgin/rspec-sidekiq/wiki/have_enqueued_sidekiq_job-without-argument-default-behavior

In rspec-sidekiq versions 5.x and later, the `have_enqueued_sidekiq_job` matcher without arguments defaults to `any_args`. This aligns with common RSpec patterns.

```ruby
# Versions >= 5.x

expect(AwesomeJob).to have_enqueued_sidekiq_job
# This is equivalent to:
expect(AwesomeJob).to have_enqueued_sidekiq_job(any_args)
```

--------------------------------

### Using sidekiq_retries_exhausted Block

Source: https://github.com/wspurgin/rspec-sidekiq/blob/main/README.md

Demonstrates how to use the `sidekiq_retries_exhausted` block to define custom logic when a job's retries are exhausted. It also shows how to test this block using `FooClass.within_sidekiq_retries_exhausted_block`.

```ruby
sidekiq_retries_exhausted do |msg|
  bar('hello')
end
# test with...
FooClass.within_sidekiq_retries_exhausted_block {
  expect(FooClass).to receive(:bar).with('hello')
}
```

--------------------------------

### Testing Backtrace Saving

Source: https://github.com/wspurgin/rspec-sidekiq/blob/main/README.md

The `save_backtrace` matcher verifies if a job is configured to save the error backtrace when an execution fails. It can check for saving in general or a specific number of lines.

```ruby
sidekiq_options backtrace: 5
# test with...
expect(AwesomeJob).to save_backtrace # or
it { is_expected.to save_backtrace }
# ...or alternatively specify the number of lines that should be saved
expect(AwesomeJob).to save_backtrace 5 # or
it { is_expected.to save_backtrace 5 }
# ...or when it should not save the backtrace
expect(AwesomeJob).to_not save_backtrace # or
expect(AwesomeJob).to save_backtrace false # or
it { is_expected.to_not save_backtrace } # or
it { is_expected.to save_backtrace false }
```

--------------------------------

### rspec-sidekiq: Maintain legacy behavior with no_args (v5+)

Source: https://github.com/wspurgin/rspec-sidekiq/wiki/have_enqueued_sidekiq_job-without-argument-default-behavior

If you need to preserve the pre-v5 behavior where `have_enqueued_sidekiq_job` without arguments implied `no_args`, explicitly pass `no_args` to the matcher.

```ruby
# if you need to maintain legacy behavior
expect(AwesomeJob).to have_enqueued_sidekiq_job(no_args)
```

--------------------------------

### RSpec Matchers for Delayed Sidekiq Jobs

Source: https://github.com/wspurgin/rspec-sidekiq/blob/main/CHANGES.md

Provides matchers to test jobs scheduled with `delay` or `delay_for` methods, allowing assertions on their scheduled execution times.

```APIDOC
be_delayed(expected_args = nil)
  # Asserts that a job was scheduled using `delay` or `delay_for`.
  # Can optionally match against specific arguments.
  # Parameters:
  #   expected_args: Arguments to match against the job's arguments.
  # Returns: A matcher object.
  # Example:
  #   expect(MyWorker).to be_delayed('arg1')

# Related Matchers:
# - `be_delayed.in(time_interval)`: Matches jobs scheduled with a specific delay.
# - `be_delayed.at(time)`: Matches jobs scheduled for a specific time.
# - `be_delayed.with_context(context_hash)`: Matches jobs with specific context.

# Note: This matcher was fixed in v2.1.0 to account for renames in Sidekiq's internal attributes.

```

```APIDOC
be_delayed.in(time_interval)
  # Filters delayed jobs by their scheduled delay.
  # Parameters:
  #   time_interval: A duration (e.g., 5.minutes, 1.hour) or a time object.
  # Returns: A matcher object.
  # Example:
  #   expect(MyWorker).to be_delayed.in(15.minutes)

be_delayed.at(time)
  # Filters delayed jobs by their specific scheduled time.
  # Parameters:
  #   time: A Time object representing the scheduled execution time.
  # Returns: A matcher object.
  # Example:
  #   expect(MyWorker).to be_delayed.at(Time.parse('2023-10-27 10:00:00 UTC'))

be_delayed.with_context(context_hash)
  # Filters delayed jobs by their context hash.
  # Parameters:
  #   context_hash: A hash representing the job's context.
  # Returns: A matcher object.
  # Example:
  #   expect(MyWorker).to be_delayed.with_context({ tenant_id: 456 })

# Note: These modifiers can be chained.
# Example:
#   expect(MyWorker).to be_delayed('user_id').in(1.hour).at(Time.now + 1.hour)

```

--------------------------------

### Testing Enqueued Job Context

Source: https://github.com/wspurgin/rspec-sidekiq/blob/main/README.md

Validates that a job was enqueued with specific context parameters, such as custom key-value pairs set during job enqueuing.

```ruby
AwesomeJob.set(trace_id: "something").perform_async
expect(AwesomeJob).to have_enqueued_sidekiq_job.with_context(trace_id: anything)
```

--------------------------------

### Testing Job Uniqueness (Sidekiq Enterprise)

Source: https://github.com/wspurgin/rspec-sidekiq/blob/main/README.md

The `be_unique` matcher is primarily for Sidekiq Enterprise's unique job implementation. It checks if a job is configured to be unique within its queue, optionally specifying a duration or expiration strategy.

```ruby
sidekiq_options unique_for: 1.hour
# test with...
expect(AwesomeJob).to be_unique
it { is_expected.to be_unique }

# specify a specific interval
sidekiq_options unique_for: 1.hour
it { is_expected.to be_unique.for(1.hour) }

# `until` sub-matcher (Sidekiq Enterprise only)
sidekiq_options unique_for: 1.hour, unique_until: :start
it { is_expected.to be_unique.until(:start) }
```

--------------------------------

### Use have_enqueued_sidekiq_job Matcher

Source: https://github.com/wspurgin/rspec-sidekiq/blob/main/README.md

Assert that a specific job class has been enqueued. This matcher can optionally verify the arguments passed to the job, including using RSpec's built-in argument matchers.

```ruby
AwesomeJob.perform_async 'Awesome', true

# test with...
expect(AwesomeJob).to have_enqueued_sidekiq_job
expect(AwesomeJob).to have_enqueued_sidekiq_job('Awesome', true)

# You can use the built-in RSpec args matchers too:
AwesomeJob.perform_async({"something" => "Awesome", "extra" => "stuff"})

# using built-in matchers from rspec-mocks:
expect(AwesomeJob).to have_enqueued_sidekiq_job(hash_including("something" => "Awesome"))
expect(AwesomeJob).to have_enqueued_sidekiq_job(any_args)
expect(AwesomeJob).to have_enqueued_sidekiq_job(hash_excluding("bad_stuff" => anything))
```

--------------------------------

### rspec-sidekiq: have_enqueued_sidekiq_job behavior (v4 and earlier)

Source: https://github.com/wspurgin/rspec-sidekiq/wiki/have_enqueued_sidekiq_job-without-argument-default-behavior

In rspec-sidekiq versions 4.x and earlier, the `have_enqueued_sidekiq_job` matcher without arguments defaulted to `no_args`, meaning it expected no arguments to be passed to the job.

```ruby
# Versions <= 4.x

expect(AwesomeJob).to have_enqueued_sidekiq_job
# This was equivalent to:
expect(AwesomeJob).to have_enqueued_sidekiq_job(no_args)
```

--------------------------------

### Testing Job Expiration

Source: https://github.com/wspurgin/rspec-sidekiq/blob/main/README.md

The `be_expired_in` matcher verifies if a job is configured with an expiration time, checking if it should expire after a specified duration.

```ruby
sidekiq_options expires_in: 1.hour
# test with...
it { is_expected.to be_expired_in 1.hour }
it { is_expected.to_not be_expired_in 2.hours }
```

--------------------------------

### Configure rspec-sidekiq to not warn about job processing

Source: https://github.com/wspurgin/rspec-sidekiq/wiki/FAQ-&-Troubleshooting

This configuration disables the warning message that appears when Sidekiq jobs are not processed by Sidekiq itself (e.g., during testing with rspec-sidekiq). It should be placed in your spec_helper.rb or rails_helper.rb file.

```ruby
RSpec::Sidekiq.configure do |config|
  config.warn_when_jobs_not_processed_by_sidekiq = false
end
```

--------------------------------

### rspec-sidekiq: Deprecation of have_enqueued_jobs matcher

Source: https://github.com/wspurgin/rspec-sidekiq/wiki/FAQ-&-Troubleshooting

The 'have_enqueued_jobs' matcher has been removed in rspec-sidekiq 1.x.x. This change aligns with RSpec's preferred syntax for checking job counts. The new syntax directly accesses the job count from the Job class.

```ruby
# RSpec 2.x (Deprecated)
# expect(Job).to have(2).jobs
# or
# expect(Job).to have(2).enqueued.jobs

# RSpec 3.x (Recommended)
expect(Job.jobs.size).to eq(2)
```

--------------------------------

### Configure rspec-sidekiq to disable terminal colors

Source: https://github.com/wspurgin/rspec-sidekiq/wiki/FAQ-&-Troubleshooting

This configuration option disables the use of terminal colors for rspec-sidekiq output. Add this to your spec_helper.rb or rails_helper.rb file to control the visual output.

```ruby
RSpec::Sidekiq.configure do |config|
  config.enable_terminal_colours = false
end
```
Tokens:
Raw