Testing sidekiq - code snippets

app_services_example.rb

class Example
  def initialize(employee_id)
    @employee_id = employee_id
  end
  def call
    ExampleJob.perform_async(@employee_id)
  end
end

app_sidekiq_example_job.rb

class ExampleJob
  include Sidekiq::Job

  def perform(employee_id)
    employee = Employee.find(employee_id)

    employee.update!(position: 'CEO')
  end
end

spec_rails_helper.rb

 require 'sidekiq/testing'
 
 config.before(:each) do
    Sidekiq::Worker.clear_all
  end

  config.around(:each, :disable_sidekiq_testing) do |example|
    Sidekiq::Testing.disable! do
      example.run
    end
  end

  config.around(:each, :inline_sidekiq_testing) do |example|
    Sidekiq::Testing.inline! do
      example.run
    end
  end

spec_services_example_spec.rb

# frozen_string_literal: true

require 'rails_helper'
describe Example, type: :service do
  subject(:service) { described_class.new(employee_id_param).call }

  let(:employee) { create(:employee) }
  let(:employee_id_param) { employee.id }

  context 'with success' do
    it 'enqueue job' do
      Sidekiq::Testing.disable! do
        expect { service }.to change { Sidekiq::Queue.new.size }.by(1)
      end
    end

    it 'enqueue job2', :disable_sidekiq_testing do
      expect { service }.to change { Sidekiq::Queue.new.size }.by(1)
    end

    it 'enqueue job3', :disable_sidekiq_testing do
      expect { service }.to change {
                              Sidekiq::Queue.new.select do |job|
                                job.klass == 'ExampleJob'
                                job.args == [employee_id_param]
                                job.queue == 'default'
                              end.size
                            }.by(1)
    end
  end
end

spec_sidekiq_example_job_spec.rb

require 'rails_helper'
RSpec.describe ExampleJob, type: :job do
  subject(:job) { described_class.perform_async(employee_id) }

  let(:employee) { create(:employee, position: 'resource') }
  let(:employee_id) { employee.id }

  context 'with success' do
    it 'queues the job' do
      expect { job }.to change(Sidekiq::Queues['default'], :size).by(1)
    end

    it 'queues the job2' do
      expect { job }.to change(described_class.jobs, :size).by(1)
    end

    it 'queues the job3' do
      job
      expect(described_class).to have_enqueued_sidekiq_job(employee.id)
    end

    it 'updates employee position' do
      expect do
        job
        described_class.drain # process all jobs
      end.to change { employee.reload.position }.from('resource').to('CEO')
    end
  end

  context 'when employee not found' do
    let(:employee_id) { 0 }

    it 'raise errors' do
      expect do
        job
        described_class.drain # process all jobs
      end.to raise_error(ActiveRecord::RecordNotFound)
    end

    it 'raise errors2' do
      expect { described_class.perform_inline(employee_id) }.to raise_error(ActiveRecord::RecordNotFound)
    end

    it 'raise errors3', :inline_sidekiq_testing do
      expect { job }.to raise_error(ActiveRecord::RecordNotFound)
    end
  end
end