interactor-sidekiq 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5a3f2ae3d870f43556bde3c67622cc6ef268b920aad8c9cae4dee04376d46029
+  data.tar.gz: b34487c04f020818817c7554e447e35099690d5a7561e76bc4367adc091cd4e9
+SHA512:
+  metadata.gz: e146bebf4e3aaf4a5867ca4096685696e1644775f89e6db37b5b77aa4045df7e9a8bbeddacd2900c186d9ebeabb700afc75f70e97f36174914ba7cef9c728629
+  data.tar.gz: 1903783ad26f3f6fe14a0343dad485bfdf7522e3d9443443176194bb9ca277a3f51ce99a0cd5b240549c8d0e5283d4ab485e0ca3b3af9f65460e62a4fdf75322

data/.github/ci.yml

@@ -0,0 +1,24 @@
+name: CI
+
+on:
+  push:
+    - '*'
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out repository code
+        uses: actions/checkout@v1
+
+      - name: Setup Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: '3.0.3'
+          bundler-cache: true
+
+      - name: Rspec - Build and run tests
+        run: |
+          gem install bundler
+          bundle install --jobs 4 --retry 3
+          bundle exec rspec spec

data/.gitignore

@@ -0,0 +1,28 @@
+*.log
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+.ruby-version
+.ruby-gemset
+.idea
+.gs
+.byebug_history
+covarage

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/Gemfile

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'bundler'
+gem 'rake'
+gem 'rspec'

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2022, Gabriel Rocha
+
+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,111 @@
+# Interactor::Sidekiq
+
+Provides [Interactor](https://github.com/collectiveidea/interactor) with asynchronous action using [Sidekiq](https://github.com/mperham/sidekiq).
+
+## Installation
+
+```ruby
+gem 'interactor-sidekiq', '~> 1.0'
+```
+
+## #async_call
+You can now add asynchronous behavior to both types of inetagents (basic interactors and organizers).
+
+```ruby
+class RegularAction
+  include Interactor
+
+  def call
+    { context: context.variable }
+  end
+end
+```
+With the above example we can already use **async_call**.
+
+```sh
+>> RegularAction.call(key: 'value')
+#<Interactor::Context key="value">
+>> Sidekiq::Queues.jobs_by_queue
+{}
+```
+```sh
+>> RegularAction.async_call(key: 'value')
+#<Interactor::Context key="value">
+>> Sidekiq::Queues.jobs_by_queue
+{"default"=>[{"retry"=>true, "queue"=>"default", "args"=>["{\"key\":\"value\",\"interactor_class\":\"RegularAction\"}"], "class"=>"Interactor::SidekiqWorker::Worker", "jid"=>"91a374e10e584b02cb84eec3", "created_at"=>1656283783.3459146, "enqueued_at"=>1656283783.3459556}]}
+```
+
+You can pass the **sidekiq_options** and **sidekiq_scheduling_options** to customize the behavior of the **async_call** method.
+
+#### Passing options from sidekiq
+
+To set custom [sidekiq_options] (https://github.com/mperham/sidekiq/wiki/Advanced-Options#workers) you can add `sidekiq_options` class method in your interactors - these options will be passed to Sidekiq `` set ` before scheduling the asynchronous worker.
+
+#### Passing scheduling options
+
+In order to be able to schedule jobs for future execution following [Scheduled Jobs](https://github.com/mperham/sidekiq/wiki/Scheduled-Jobs), you can add the `sidekiq_schedule_options` class method in your subscriber definition - these options will be passed to Sidekiq's `perform_in` method when the worker is called.
+
+```sh
+>> RegularAction.async_call(message: 'hello!', sidekiq_options: { queue: :low_priority }, sidekiq_schedule_options: { perform_in: 5 })
+
+Interactor::Context message: 'hello!', sidekiq_options: { queue: :low_priority }, sidekiq_schedule_options: { perform_in: 5 }
+```
+
+## Failure
+
+If you pass invalid parameters to sidekiq, you will get an immediate return with the error message.
+```sh
+>> result = RegularAction.async_call(message: 'hello!', sidekiq_schedule_options: "error")
+#<Interactor::Context key="value", sidekiq_options="bad error message", error="undefined method `transform_keys' for \"bad error message\":String">
+>> result.failure?
+true
+>> Sidekiq::Queues.jobs_by_queue
+{}
+```
+
+## Interactor::Async
+
+Now you need an interactor to always assume asynchronous behavior using: **Interator::Async**.
+
+#### Passing handle sidekiq exception
+
+When executing the perform method in sidekiq there may be a problem, thinking about it we have already made it possible for you to handle this error.
+**If the context is failed during invocation of the interactor in background, the Interactor::Failure is raised**.
+
+
+```ruby
+class AsyncAction
+  include Interactor::Async
+
+  def call
+    { context: context.variable }
+  end
+
+  def self.sidekiq_options
+    { queue: :low_priority }
+  end
+    
+  def self.sidekiq_schedule_options
+    { perform_in: 5 }
+  end
+  
+  def self.handle_sidekiq_exception(error)
+    # Integrate with Application Monitoring and Error Tracking Software
+  end
+end
+```
+
+## Compatibility
+
+The same Ruby versions as Sidekiq are offically supported, but it should work
+with any 2.x syntax Ruby including JRuby and Rubinius.
+
+## Running Specs
+
+```
+bundle exec rspec
+```
+
+## License
+
+MIT

data/Rakefile

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'

data/interactor-sidekiq.gemspec

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'interactor/sidekiq/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'interactor-sidekiq'
+  spec.version       = Interactor::Sidekiq::VERSION
+  spec.authors       = ['Gabriel Rocha']
+  spec.email         = ['gabrielras100@gmail.com']
+  spec.summary       = 'Async Interactor using Sidekiq'
+  spec.description   = 'Async Interactor using Sidekiq'
+  spec.homepage      = 'https://github.com/gabrielras/interactor-sidekiq'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'interactor', '~> 3.0'
+  spec.add_dependency 'sidekiq', '>=4.1'
+end

data/lib/interactor/sidekiq/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Interactor
+  module Sidekiq
+    VERSION = '1.0.0'
+  end
+end

data/lib/interactor/sidekiq.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require 'interactor'
+require 'sidekiq'
+
+module Interactor
+  # Internal: Install Interactor's behavior in the given class.
+  def self.included(base)
+    base.class_eval do
+      extend ClassMethods
+      extend SidekiqWorker
+      include Hooks
+
+      # Public: Gets the Interactor::Context of the Interactor instance.
+      attr_reader :context
+    end
+  end
+
+  # based on Sidekiq 4.x #delay method, which is not enabled by default in Sidekiq 5.x
+  # https://github.com/mperham/sidekiq/blob/4.x/lib/sidekiq/extensions/generic_proxy.rb
+  # https://github.com/mperham/sidekiq/blob/4.x/lib/sidekiq/extensions/class_methods.rb
+
+  module SidekiqWorker
+    class Worker
+      include ::Sidekiq::Worker
+
+      def perform(context)
+        interactor_class(context).sync_call(context.except(:interactor_class))
+      rescue Exception => e
+        if interactor_class(context).respond_to?(:handle_sidekiq_exception)
+          interactor_class(context).handle_sidekiq_exception(e)
+        else
+          raise e
+        end
+      end
+
+      private
+
+      def interactor_class(context)
+        Module.const_get context[:interactor_class]
+      end
+    end
+
+    def sync_call(context = {})
+      new(context).tap(&:run!).context
+    end
+
+    def async_call(context = {})
+      options = handle_sidekiq_options(context)
+      schedule_options = delay_sidekiq_schedule_options(context)
+
+      Worker.set(options).perform_in(schedule_options.fetch(:delay, 0), handle_context_for_sidekiq(context))
+      new(context.to_h).context
+    rescue Exception => e
+      begin
+        new(context.to_h).context.fail!(error: e.message)
+      rescue Failure => e
+        e.context
+      end
+    end
+
+    private
+
+    def handle_context_for_sidekiq(context)
+      context.to_h.merge(interactor_class: to_s).to_json
+    end
+
+    def handle_sidekiq_options(context)
+      if context[:sidekiq_options].nil?
+        respond_to?(:sidekiq_options) ? sidekiq_options : { queue: :default }
+      else
+        context[:sidekiq_options]
+      end
+    end
+
+    def delay_sidekiq_schedule_options(context)
+      options = handle_sidekiq_schedule_options(context)
+      return {} unless options.key?(:perform_in) || options.key?(:perform_at)
+
+      { delay: options[:perform_in] || options[:perform_at] }
+    end
+
+    def handle_sidekiq_schedule_options(context)
+      if context[:sidekiq_schedule_options].nil?
+        respond_to?(:sidekiq_schedule_options) ? sidekiq_schedule_options : { delay: 0 }
+      else
+        context[:sidekiq_schedule_options]
+      end
+    end
+  end
+
+  module Async
+    def self.included(base)
+      base.class_eval do
+        include Interactor
+
+        extend ClassMethods
+      end
+    end
+
+    module ClassMethods
+      def call(context = {})
+        default_async_call(context)
+      end
+
+      def call!(context = {})
+        default_async_call(context)
+      end
+
+      private
+
+      def default_async_call(context)
+        async_call(context)
+      end
+    end
+  end
+end

data/spec/dummy_app/app.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# This is loaded by Sidekiq
+
+require 'interactor/sidekiq'

data/spec/interactor/sidekiq_perform_spec.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'interactor/sidekiq'
+
+RSpec.describe Interactor::SidekiqWorker::Worker do
+  class AsyncAction
+    include Interactor::Async
+
+    def call
+      { message: context.variable }
+    end
+  end
+
+  class BadAsyncAction
+    include Interactor::Async
+
+    def call
+      raise StandardError, 'This is an exception'
+    end
+  end
+
+  class CustomizedBadAsyncAction
+    include Interactor::Async
+
+    def call
+      raise StandardError, 'This is an exception'
+    end
+
+    def self.handle_sidekiq_exception(error)
+      { message: error.respond_to?(:message) ? 'captured error message' : 'not captured error message' }
+    end
+  end
+
+  shared_examples_for 'there was no new sidekiq worker' do
+    let(:jobs_by_queue) { Sidekiq::Queues.jobs_by_queue }
+
+    before { Sidekiq::Queues.clear_all }
+    before { result }
+
+    it { expect(respond_to?(:jobs_by_queue)).to be_truthy }
+  end
+
+  describe '#perform' do
+    let(:sidekiq_options) { { queue: 'default' } }
+
+    context 'when there is no error' do
+      subject(:result) { AsyncAction::SidekiqWorker::Worker.new.perform(context) }
+      let(:context) { { interactor_class: 'AsyncAction', key: 'value' } }
+
+      it { expect(result.class).to eq Interactor::Context }
+
+      it { expect(result.success?).to eq true }
+
+      it { expect(result.to_h).to eq context.except(:interactor_class) }
+
+      it_behaves_like 'there was no new sidekiq worker'
+    end
+
+    context 'when there is no error and it is handled' do
+      subject(:result) { CustomizedBadAsyncAction::SidekiqWorker::Worker.new.perform(context) }
+      let(:context) { { interactor_class: 'CustomizedBadAsyncAction', key: 'value' } }
+
+      it { expect(result).to eq({ message: 'captured error message' }) }
+
+      it_behaves_like 'there was no new sidekiq worker'
+    end
+
+    context 'when there is no error and it is not handled' do
+      subject(:result) { BadAsyncAction::SidekiqWorker::Worker.new.perform(context) }
+      let(:context) { { interactor_class: 'BadAsyncAction', key: 'value' } }
+
+      it 'returns error' do
+        expect { result }.to raise_error(StandardError, 'This is an exception')
+      end
+    end
+  end
+end

data/spec/interactor/sidekiq_worker_spec.rb

@@ -0,0 +1,379 @@
+# frozen_string_literal: true
+
+require 'interactor/sidekiq'
+
+RSpec.describe Interactor::SidekiqWorker do
+  class RegularAction
+    include Interactor
+
+    def call
+      { context: context.variable }
+    end
+  end
+
+  class AsyncAction
+    include Interactor::Async
+
+    def call
+      { context: context.variable }
+    end
+
+    def self.handle_sidekiq_exception(error); end
+  end
+
+  class AsyncActionWithSidekiqOption
+    include Interactor::Async
+
+    def call
+      { context: context.variable }
+    end
+
+    def self.sidekiq_options
+      { queue: 'low_priority' }
+    end
+  end
+
+  class AsyncActionWithSidekiqScheduleOption
+    include Interactor::Async
+
+    def call
+      { context: context.variable }
+    end
+
+    def self.sidekiq_schedule_options
+      { perform_in: 5 }
+    end
+  end
+
+  class CustomizedBadSidekiqOption
+    include Interactor::Async
+
+    def call
+      { context: context.variable }
+    end
+
+    def self.sidekiq_options
+      'bad error message'
+    end
+  end
+
+  class CustomizedBadSidekiqScheduleOption
+    include Interactor::Async
+
+    def call
+      { context: context.variable }
+    end
+
+    def self.sidekiq_schedule_options
+      'bad error message'
+    end
+  end
+
+  class RegularOrganizer
+    include Interactor::Organizer
+
+    organize RegularAction
+  end
+
+  class OrganizerWithAsyncAction
+    include Interactor::Organizer
+
+    organize RegularAction, AsyncActionWithSidekiqOption, AsyncActionWithSidekiqScheduleOption
+  end
+
+  shared_examples_for 'sidekiq worker' do |elements|
+    let(:jobs_by_queue) { Sidekiq::Queues.jobs_by_queue[(elements[:sidekiq_options][:queue])][0] }
+
+    before { Sidekiq::Queues.clear_all }
+    before { result }
+
+    it { expect(jobs_by_queue['queue']).to eq elements[:sidekiq_options][:queue] }
+
+    it { expect(jobs_by_queue['args']).to eq [context.merge(interactor_class: elements[:interactor_class]).to_json] }
+  end
+
+  shared_examples_for 'there is no sidekiq worker' do
+    let(:jobs_by_queue) { Sidekiq::Queues.jobs_by_queue }
+
+    before { Sidekiq::Queues.clear_all }
+    before { result }
+
+    
+    it { expect(respond_to?(:jobs_by_queue)).to be_truthy }
+  end
+
+  shared_examples_for 'interactor success' do
+    it { expect(result.class).to eq Interactor::Context }
+
+    it { expect(result.success?).to eq true }
+
+    it { expect(result.to_h).to eq context }
+  end
+
+  shared_examples_for 'interactor failure' do
+    it { expect(result.class).to eq Interactor::Context }
+
+    it { expect(result.failure?).to eq true }
+
+    it { expect(result.error).not_to be_empty }
+  end
+
+  describe '#async_call' do
+    subject(:result) { interactor.async_call(context) }
+
+    %w[RegularAction AsyncAction RegularOrganizer OrganizerWithAsyncAction].each do |interactor_class|
+      context "when attributes for #{interactor_class} class" do
+        let(:interactor) { Module.const_get interactor_class }
+
+        context 'when attributes are valid and not in context' do
+          let(:context) do
+            { key: 'value' }
+          end
+
+          it_behaves_like 'sidekiq worker', interactor_class: interactor_class,  sidekiq_options: { queue: 'default' },
+                                            sidekiq_schedule_options: { delay: 0 }
+
+          it_behaves_like 'interactor success'
+        end
+
+        context 'when attributes are valid and in context' do
+          let(:context) do
+            { key: 'value', sidekiq_options: { queue: 'low_priority' }, sidekiq_schedule_options: { perform_in: 5 } }
+          end
+
+          it_behaves_like 'sidekiq worker', interactor_class: interactor_class, sidekiq_options: { queue: 'low_priority' },
+                                            sidekiq_schedule_options: { perform_in: 5 }
+
+          it_behaves_like 'interactor success'
+        end
+
+        context 'when attributes are invalid' do
+          let(:context) do
+            { key: 'value', sidekiq_options: 'bad error message',
+              sidekiq_schedule_options: 'bad error message' }
+          end
+
+          it_behaves_like 'there is no sidekiq worker'
+
+          it_behaves_like 'interactor failure'
+        end
+      end
+    end
+
+    %w[AsyncActionWithSidekiqOption].each do |interactor_class|
+      context "when attributes for #{interactor_class} class" do
+        let(:interactor) { Module.const_get interactor_class }
+
+        context 'when attributes are valid and not in context' do
+          let(:context) do
+            { key: 'value' }
+          end
+
+          it_behaves_like 'sidekiq worker', interactor_class: interactor_class,  sidekiq_options: { queue: 'low_priority' },
+                                            sidekiq_schedule_options: { delay: 0 }
+
+          it_behaves_like 'interactor success'
+        end
+
+        context 'when attributes are valid and in context' do
+          let(:context) do
+            { key: 'value', sidekiq_options: { queue: 'default' }, sidekiq_schedule_options: { perform_in: 5 } }
+          end
+
+          it_behaves_like 'sidekiq worker', interactor_class: interactor_class, sidekiq_options: { queue: 'default' },
+                                            sidekiq_schedule_options: { perform_in: 5 }
+
+          it_behaves_like 'interactor success'
+        end
+
+        context 'when attributes are invalid' do
+          let(:context) do
+            { key: 'value', sidekiq_options: 'bad error message' }
+          end
+
+          it_behaves_like 'there is no sidekiq worker'
+
+          it_behaves_like 'interactor failure'
+        end
+      end
+    end
+
+    %w[AsyncActionWithSidekiqScheduleOption].each do |interactor_class|
+      context "when attributes for #{interactor_class} class" do
+        let(:interactor) { Module.const_get interactor_class }
+
+        context 'when attributes are valid and not in context' do
+          let(:context) do
+            { key: 'value' }
+          end
+
+          it_behaves_like 'sidekiq worker', interactor_class: interactor_class, sidekiq_options: { queue: 'default' },
+                                            sidekiq_schedule_options: { perform_in: 5 }
+
+          it_behaves_like 'interactor success'
+        end
+
+        context 'when attributes are valid and in context' do
+          let(:context) do
+            { key: 'value', sidekiq_options: { queue: 'low_priority' }, sidekiq_schedule_options: { perform_in: 0 } }
+          end
+
+          it_behaves_like 'sidekiq worker', interactor_class: interactor_class, sidekiq_options: { queue: 'low_priority' },
+                                            sidekiq_schedule_options: { perform_in: 0 }
+
+          it_behaves_like 'interactor success'
+        end
+
+        context "when attributes for #{interactor_class} class are invalid" do
+          let(:context) do
+            { key: 'value', sidekiq_schedule_options: 'bad error message' }
+          end
+
+          it_behaves_like 'there is no sidekiq worker'
+
+          it_behaves_like 'interactor failure'
+        end
+      end
+    end
+
+    %w[CustomizedBadSidekiqOption CustomizedBadSidekiqScheduleOption].each do |interactor_class|
+      context "when attributes for #{interactor_class} class" do
+        let(:interactor) { Module.const_get interactor_class }
+
+        context 'when attributes are valid' do
+          let(:context) do
+            { key: 'value', sidekiq_options: { queue: 'default' }, sidekiq_schedule_options: { delay: 5 } }
+          end
+
+          it_behaves_like 'sidekiq worker', interactor_class: interactor_class,  sidekiq_options: { queue: 'default' },
+                                            sidekiq_schedule_options: { delay: 5 }
+
+          it_behaves_like 'interactor success'
+        end
+
+        context 'when attributes are invalid' do
+          let(:context) { { key: 'value' } }
+
+          it_behaves_like 'there is no sidekiq worker'
+
+          it_behaves_like 'interactor failure'
+        end
+      end
+    end
+  end
+
+  describe '#call' do
+    subject(:result) { interactor.call(context) }
+
+    %w[RegularAction RegularOrganizer].each do |interactor_class|
+      context "when attributes for #{interactor_class} class" do
+        let(:interactor) { Module.const_get interactor_class }
+
+        context 'when attributes are valid and not in context' do
+          let(:context) do
+            { key: 'value' }
+          end
+
+          it_behaves_like 'there is no sidekiq worker'
+
+          it_behaves_like 'interactor success'
+        end
+
+        context 'when attributes are valid and in context' do
+          let(:context) do
+            { key: 'value', sidekiq_options: { queue: 'low_priority' }, sidekiq_schedule_options: { perform_in: 5 } }
+          end
+
+          it_behaves_like 'there is no sidekiq worker'
+
+          it_behaves_like 'interactor success'
+        end
+      end
+    end
+
+    %w[AsyncAction].each do |interactor_class|
+      context "when attributes for #{interactor_class} class" do
+        let(:interactor) { Module.const_get interactor_class }
+
+        context 'when attributes are valid' do
+          let(:context) do
+            { key: 'value' }
+          end
+
+          it_behaves_like 'sidekiq worker', interactor_class: interactor_class,  sidekiq_options: { queue: 'default' },
+                                            sidekiq_schedule_options: { delay: 0 }
+
+          it_behaves_like 'interactor success'
+        end
+      end
+    end
+
+    %w[OrganizerWithAsyncAction].each do |interactor_class|
+      context "when attributes for #{interactor_class} class" do
+        let(:interactor) { Module.const_get interactor_class }
+
+        context 'when attributes are valid' do
+          let(:context) do
+            { key: 'value' }
+          end
+
+          it_behaves_like 'sidekiq worker', interactor_class: 'AsyncActionWithSidekiqScheduleOption',
+                                            sidekiq_options: { queue: 'default' },
+                                            sidekiq_schedule_options: { delay: 0 }
+
+          it_behaves_like 'interactor success'
+        end
+      end
+    end
+
+    %w[AsyncActionWithSidekiqOption].each do |interactor_class|
+      context "when attributes for #{interactor_class} class" do
+        let(:interactor) { Module.const_get interactor_class }
+
+        context 'when attributes are valid' do
+          let(:context) do
+            { key: 'value' }
+          end
+
+          it_behaves_like 'sidekiq worker', interactor_class: interactor_class,  sidekiq_options: { queue: 'low_priority' },
+                                            sidekiq_schedule_options: { delay: 0 }
+
+          it_behaves_like 'interactor success'
+        end
+      end
+    end
+
+    %w[AsyncActionWithSidekiqScheduleOption].each do |interactor_class|
+      context "when attributes for #{interactor_class} class" do
+        let(:interactor) { Module.const_get interactor_class }
+
+        context 'when attributes are valid' do
+          let(:context) do
+            { key: 'value' }
+          end
+
+          it_behaves_like 'sidekiq worker', interactor_class: interactor_class, sidekiq_options: { queue: 'default' },
+                                            sidekiq_schedule_options: { perform_in: 5 }
+
+          it_behaves_like 'interactor success'
+        end
+      end
+    end
+
+    %w[CustomizedBadSidekiqOption CustomizedBadSidekiqScheduleOption].each do |interactor_class|
+      context "when attributes for #{interactor_class} class" do
+        let(:interactor) { Module.const_get interactor_class }
+
+        context 'when attributes are valid' do
+          let(:context) do
+            { key: 'value' }
+          end
+
+          it_behaves_like 'there is no sidekiq worker'
+
+          it_behaves_like 'interactor failure'
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'sidekiq/testing'
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  config.disable_monkey_patching!
+
+  config.warnings = true
+
+  config.default_formatter = 'doc' if config.files_to_run.one?
+
+  config.profile_examples = 0
+
+  config.order = :random
+
+  Kernel.srand config.seed
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: interactor-sidekiq
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Gabriel Rocha
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2022-06-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: interactor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: sidekiq
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.1'
+description: Async Interactor using Sidekiq
+email:
+- gabrielras100@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/ci.yml"
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- interactor-sidekiq.gemspec
+- lib/interactor/sidekiq.rb
+- lib/interactor/sidekiq/version.rb
+- spec/dummy_app/app.rb
+- spec/interactor/sidekiq_perform_spec.rb
+- spec/interactor/sidekiq_worker_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/gabrielras/interactor-sidekiq
+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.16
+signing_key: 
+specification_version: 4
+summary: Async Interactor using Sidekiq
+test_files:
+- spec/dummy_app/app.rb
+- spec/interactor/sidekiq_perform_spec.rb
+- spec/interactor/sidekiq_worker_spec.rb
+- spec/spec_helper.rb