sidekiq-grouping 1.1.0 → 1.2.0

data/lib/sidekiq/grouping/web.rb

@@ -1,24 +1,29 @@
-require 'sidekiq/web'
+# frozen_string_literal: true
+
+require "sidekiq/web"
 
 module Sidekiq
   module Grouping
     module Web
-      VIEWS = File.expand_path('views', File.dirname(__FILE__))
+      VIEWS = File.expand_path("views", File.dirname(__FILE__))
 
       def self.registered(app)
         app.get "/grouping" do
           @batches = Sidekiq::Grouping::Batch.all
-          erb File.read(File.join(VIEWS, 'index.erb')), locals: {view_path: VIEWS}
+          erb File.read(File.join(VIEWS, "index.erb")),
+              locals: { view_path: VIEWS }
         end
 
         app.post "/grouping/:name/delete" do
-          worker_class, queue = Sidekiq::Grouping::Batch.extract_worker_klass_and_queue(params['name'])
+          worker_class, queue =
+            Sidekiq::Grouping::Batch.extract_worker_klass_and_queue(
+              params["name"]
+            )
           batch = Sidekiq::Grouping::Batch.new(worker_class, queue)
           batch.delete
           redirect "#{root_path}grouping"
         end
       end
-
     end
   end
 end

data/lib/sidekiq/grouping.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support"
 require "active_support/core_ext/string"
 require "active_support/configurable"
@@ -5,36 +7,39 @@ require "active_support/core_ext/numeric/time"
 require "sidekiq/grouping/version"
 require "concurrent"
 
-module Sidekiq::Grouping
-  autoload :Config, "sidekiq/grouping/config"
-  autoload :Redis, "sidekiq/grouping/redis"
-  autoload :Batch, "sidekiq/grouping/batch"
-  autoload :Middleware, "sidekiq/grouping/middleware"
-  autoload :Flusher, "sidekiq/grouping/flusher"
-  autoload :FlusherObserver, "sidekiq/grouping/flusher_observer"
-
-  class << self
-    attr_writer :logger
-
-    def logger
-      @logger ||= Sidekiq.logger
-    end
-
-    def force_flush_for_test!
-      Sidekiq::Grouping::Flusher.new.force_flush_for_test!
-    end
-
-    def start!
-      interval = Sidekiq::Grouping::Config.poll_interval
-      @observer = Sidekiq::Grouping::FlusherObserver.new
-      @task = Concurrent::TimerTask.new(
-        execution_interval: interval
-      ) { Sidekiq::Grouping::Flusher.new.flush }
-      @task.add_observer(@observer)
-      logger.info(
-        "[Sidekiq::Grouping] Started polling batches every #{interval} seconds"
-      )
-      @task.execute
+module Sidekiq
+  module Grouping
+    autoload :Config, "sidekiq/grouping/config"
+    autoload :Redis, "sidekiq/grouping/redis"
+    autoload :Batch, "sidekiq/grouping/batch"
+    autoload :Middleware, "sidekiq/grouping/middleware"
+    autoload :Flusher, "sidekiq/grouping/flusher"
+    autoload :FlusherObserver, "sidekiq/grouping/flusher_observer"
+
+    class << self
+      attr_writer :logger
+
+      def logger
+        @logger ||= Sidekiq.logger
+      end
+
+      def force_flush_for_test!
+        Sidekiq::Grouping::Flusher.new.force_flush_for_test!
+      end
+
+      def start!
+        interval = Sidekiq::Grouping::Config.poll_interval
+        @observer = Sidekiq::Grouping::FlusherObserver.new
+        @task = Concurrent::TimerTask.new(
+          execution_interval: interval
+        ) { Sidekiq::Grouping::Flusher.new.flush }
+        @task.add_observer(@observer)
+        logger.info(
+          "[Sidekiq::Grouping] Started polling batches every " \
+          "#{interval} seconds"
+        )
+        @task.execute
+      end
     end
   end
 end

data/sidekiq-grouping.gemspec

@@ -1,4 +1,6 @@
-lib = File.expand_path("../lib", __FILE__)
+# frozen_string_literal: true
+
+lib = File.expand_path("lib", __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require "sidekiq/grouping/version"
 
@@ -7,26 +9,30 @@ Gem::Specification.new do |spec|
   spec.version       = Sidekiq::Grouping::VERSION
   spec.authors       = ["Victor Sokolov"]
   spec.email         = ["gzigzigzeo@gmail.com"]
-  spec.summary       = %q(
+  spec.summary       = <<~SUMMARY
     Allows identical sidekiq jobs to be processed with a single background call
-  )
+  SUMMARY
   spec.homepage      = "http://github.com/gzigzigzeo/sidekiq-grouping"
   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.required_ruby_version = ">= 2.7.0"
+
+  spec.add_development_dependency "appraisal"
   spec.add_development_dependency "bundler", "> 1.5"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec"
-  spec.add_development_dependency "simplecov"
   spec.add_development_dependency "rspec-sidekiq"
+  spec.add_development_dependency "rubocop"
+  spec.add_development_dependency "rubocop-rspec"
+  spec.add_development_dependency "simplecov"
   spec.add_development_dependency "timecop"
-  spec.add_development_dependency "appraisal"
 
   spec.add_dependency "activesupport"
-  spec.add_dependency "sidekiq", ">= 3.4.2"
   spec.add_dependency "concurrent-ruby"
+  spec.add_dependency "sidekiq", ">= 3.4.2", "< 7"
+  spec.metadata["rubygems_mfa_required"] = "true"
 end

data/spec/modules/batch_spec.rb

@@ -1,70 +1,72 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
+require "spec_helper"
 
 describe Sidekiq::Grouping::Batch do
-  subject { Sidekiq::Grouping::Batch }
+  subject(:batch_service) { described_class }
 
-  context 'adding' do
-    it 'must enqueue unbatched worker' do
-       RegularWorker.perform_async('bar')
-       expect(RegularWorker).to have_enqueued_sidekiq_job("bar")
+  context "when adding" do
+    it "must enqueue unbatched worker" do
+      RegularWorker.perform_async("bar")
+      expect(RegularWorker).to have_enqueued_sidekiq_job("bar")
     end
 
-    it 'must not enqueue batched worker' do
-      BatchedSizeWorker.perform_async('bar')
-      expect_batch(BatchedSizeWorker, 'batched_size')
+    it "must not enqueue batched worker based on batch size setting" do
+      BatchedSizeWorker.perform_async("bar")
+      expect_batch(BatchedSizeWorker, "batched_size")
     end
 
-    it 'must not enqueue batched worker' do
-      BatchedIntervalWorker.perform_async('bar')
-      expect_batch(BatchedIntervalWorker, 'batched_interval')
+    it "must not enqueue batched worker based on interval setting" do
+      BatchedIntervalWorker.perform_async("bar")
+      expect_batch(BatchedIntervalWorker, "batched_interval")
     end
 
-    it 'must not enqueue batched worker' do
-      BatchedBothWorker.perform_async('bar')
-      expect_batch(BatchedBothWorker, 'batched_both')
+    it "must not enqueue batched worker based on both settings" do
+      BatchedBothWorker.perform_async("bar")
+      expect_batch(BatchedBothWorker, "batched_both")
     end
   end
 
-  context 'checking if should flush' do
-    it 'must flush if limit exceeds for limit worker' do
-      batch = subject.new(BatchedSizeWorker.name, 'batched_size')
+  context "when checking if should flush" do
+    it "must flush if limit exceeds for limit worker", :aggregate_failures do
+      batch = batch_service.new(BatchedSizeWorker.name, "batched_size")
 
-      expect(batch.could_flush?).to be_falsy
-      BatchedSizeWorker.perform_async('bar')
-      expect(batch.could_flush?).to be_falsy
-      4.times { BatchedSizeWorker.perform_async('bar') }
-      expect(batch.could_flush?).to be_truthy
+      expect(batch).not_to be_could_flush
+      BatchedSizeWorker.perform_async("bar")
+      expect(batch).not_to be_could_flush
+      4.times { BatchedSizeWorker.perform_async("bar") }
+      expect(batch).to be_could_flush
     end
 
-    it 'must flush if limit exceeds for both worker' do
-      batch = subject.new(BatchedBothWorker.name, 'batched_both')
+    it "must flush if limit exceeds for both worker", :aggregate_failures do
+      batch = batch_service.new(BatchedBothWorker.name, "batched_both")
 
-      expect(batch.could_flush?).to be_falsy
-      BatchedBothWorker.perform_async('bar')
-      expect(batch.could_flush?).to be_falsy
-      4.times { BatchedBothWorker.perform_async('bar') }
-      expect(batch.could_flush?).to be_truthy
+      expect(batch).not_to be_could_flush
+      BatchedBothWorker.perform_async("bar")
+      expect(batch).not_to be_could_flush
+      4.times { BatchedBothWorker.perform_async("bar") }
+      expect(batch).to be_could_flush
     end
 
-    it 'must flush if limit okay but time came' do
-      batch = subject.new(BatchedIntervalWorker.name, 'batched_interval')
+    it "must flush if limit okay but time came", :aggregate_failures do
+      batch = batch_service.new(BatchedIntervalWorker.name, "batched_interval")
 
-      expect(batch.could_flush?).to be_falsy
-      BatchedIntervalWorker.perform_async('bar')
-      expect(batch.could_flush?).to be_falsy
+      expect(batch).not_to be_could_flush
+      BatchedIntervalWorker.perform_async("bar")
+      expect(batch).not_to be_could_flush
       expect(batch.size).to eq(1)
 
       Timecop.travel(2.hours.since)
 
-      expect(batch.could_flush?).to be_truthy
+      expect(batch).to be_could_flush
     end
   end
 
-  context 'flushing' do
-    it 'must put wokrer to queue on flush' do
-      batch = subject.new(BatchedSizeWorker.name, 'batched_size')
+  context "when flushing" do
+    it "must put worker to queue on flush", :aggregate_failures do
+      batch = batch_service.new(BatchedSizeWorker.name, "batched_size")
 
-      expect(batch.could_flush?).to be_falsy
+      expect(batch).not_to be_could_flush
       10.times { |n| BatchedSizeWorker.perform_async("bar#{n}") }
       batch.flush
       expect(BatchedSizeWorker).to(
@@ -74,65 +76,93 @@ describe Sidekiq::Grouping::Batch do
     end
   end
 
-  context 'with similar args' do
-    context 'option batch_unique = true' do
-      it 'enqueues once' do
-        batch = subject.new(BatchedUniqueArgsWorker.name, 'batched_unique_args')
-        3.times { BatchedUniqueArgsWorker.perform_async('bar', 1) }
+  context "with similar args" do
+    context "when option batch_unique = true" do
+      it "enqueues once" do
+        batch = batch_service.new(
+          BatchedUniqueArgsWorker.name,
+          "batched_unique_args"
+        )
+        3.times { BatchedUniqueArgsWorker.perform_async("bar", 1) }
         expect(batch.size).to eq(1)
       end
 
-      it 'enqueues once each unique set of args' do
-        batch = subject.new(BatchedUniqueArgsWorker.name, 'batched_unique_args')
-        3.times { BatchedUniqueArgsWorker.perform_async('bar', 1) }
-        6.times { BatchedUniqueArgsWorker.perform_async('baz', 1) }
-        3.times { BatchedUniqueArgsWorker.perform_async('bar', 1) }
-        2.times { BatchedUniqueArgsWorker.perform_async('baz', 3) }
-        7.times { BatchedUniqueArgsWorker.perform_async('bar', 1) }
+      it "enqueues once each unique set of args" do
+        batch = batch_service.new(
+          BatchedUniqueArgsWorker.name,
+          "batched_unique_args"
+        )
+        3.times { BatchedUniqueArgsWorker.perform_async("bar", 1) }
+        6.times { BatchedUniqueArgsWorker.perform_async("baz", 1) }
+        3.times { BatchedUniqueArgsWorker.perform_async("bar", 1) }
+        2.times { BatchedUniqueArgsWorker.perform_async("baz", 3) }
+        7.times { BatchedUniqueArgsWorker.perform_async("bar", 1) }
         expect(batch.size).to eq(3)
       end
 
-      context 'flushing' do
-
-        it 'works' do
-          batch = subject.new(BatchedUniqueArgsWorker.name, 'batched_unique_args')
-          2.times { BatchedUniqueArgsWorker.perform_async('bar', 1) }
-          2.times { BatchedUniqueArgsWorker.perform_async('baz', 1) }
-          batch.flush
-          expect(batch.size).to eq(0)
-        end
-
-        it 'allows to enqueue again after flush' do
-          batch = subject.new(BatchedUniqueArgsWorker.name, 'batched_unique_args')
-          2.times { BatchedUniqueArgsWorker.perform_async('bar', 1) }
-          2.times { BatchedUniqueArgsWorker.perform_async('baz', 1) }
-          batch.flush
-          BatchedUniqueArgsWorker.perform_async('bar', 1)
-          BatchedUniqueArgsWorker.perform_async('baz', 1)
-          expect(batch.size).to eq(2)
-        end
+      it "flushes the workers" do
+        batch = batch_service.new(
+          BatchedUniqueArgsWorker.name,
+          "batched_unique_args"
+        )
+        2.times { BatchedUniqueArgsWorker.perform_async("bar", 1) }
+        2.times { BatchedUniqueArgsWorker.perform_async("baz", 1) }
+        batch.flush
+        expect(batch.size).to eq(0)
       end
 
+      it "allows to enqueue again after flush" do
+        batch = batch_service.new(
+          BatchedUniqueArgsWorker.name,
+          "batched_unique_args"
+        )
+        2.times { BatchedUniqueArgsWorker.perform_async("bar", 1) }
+        2.times { BatchedUniqueArgsWorker.perform_async("baz", 1) }
+        batch.flush
+        BatchedUniqueArgsWorker.perform_async("bar", 1)
+        BatchedUniqueArgsWorker.perform_async("baz", 1)
+        expect(batch.size).to eq(2)
+      end
     end
 
-    context 'batch_unique is not specified' do
-      it 'enqueues all' do
-        batch = subject.new(BatchedSizeWorker.name, 'batched_size')
-        3.times { BatchedSizeWorker.perform_async('bar', 1) }
+    context "when batch_unique is not specified" do
+      it "enqueues all" do
+        batch = batch_service.new(BatchedSizeWorker.name, "batched_size")
+        3.times { BatchedSizeWorker.perform_async("bar", 1) }
         expect(batch.size).to eq(3)
       end
     end
   end
 
+  context "when inline mode" do
+    it "must pass args to worker as array" do
+      Sidekiq::Testing.inline! do
+        expect_any_instance_of(BatchedSizeWorker)
+          .to receive(:perform).with([[1]])
+
+        BatchedSizeWorker.perform_async(1)
+      end
+    end
+
+    it "must not pass args to worker as array" do
+      Sidekiq::Testing.inline! do
+        expect_any_instance_of(RegularWorker).to receive(:perform).with(1)
+
+        RegularWorker.perform_async(1)
+      end
+    end
+  end
+
   private
-  def expect_batch(klass, queue)
-    expect(klass).to_not have_enqueued_sidekiq_job("bar")
-    batch = subject.new(klass.name, queue)
-    stats = subject.all
+
+  def expect_batch(klass, queue) # rubocop:disable Metrics/AbcSize
+    expect(klass).not_to have_enqueued_sidekiq_job("bar")
+    batch = batch_service.new(klass.name, queue)
+    stats = batch_service.all
     expect(batch.size).to eq(1)
     expect(stats.size).to eq(1)
     expect(stats.first.worker_class).to eq(klass.name)
     expect(stats.first.queue).to eq(queue)
-    expect(batch.pluck).to eq [['bar']]
+    expect(batch.pluck).to eq [["bar"]]
   end
 end

data/spec/modules/redis_spec.rb

@@ -1,39 +1,41 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
+require "spec_helper"
 
 describe Sidekiq::Grouping::Redis do
-  subject { Sidekiq::Grouping::Redis.new }
+  subject(:redis_service) { described_class.new }
 
   let(:queue_name)    { "my_queue" }
   let(:key)           { "batching:#{queue_name}" }
   let(:unique_key)    { "batching:#{queue_name}:unique_messages" }
 
   describe "#push_msg" do
-    it "adds message to queue" do
-      subject.push_msg(queue_name, 'My message')
+    it "adds message to queue", :aggregate_failures do
+      redis_service.push_msg(queue_name, "My message")
       expect(redis { |c| c.llen key }).to eq 1
-      expect(redis { |c| c.lrange key, 0, 1 }).to eq ['My message']
-      expect(redis { |c| c.smembers unique_key}).to eq []
+      expect(redis { |c| c.lrange key, 0, 1 }).to eq ["My message"]
+      expect(redis { |c| c.smembers unique_key }).to eq []
     end
 
     it "remembers unique message if specified" do
-      subject.push_msg(queue_name, 'My message', true)
-      expect(redis { |c| c.smembers unique_key}).to eq ['My message']
+      redis_service.push_msg(queue_name, "My message", remember_unique: true)
+      expect(redis { |c| c.smembers unique_key }).to eq ["My message"]
     end
   end
 
   describe "#pluck" do
     it "removes messages from queue" do
-      subject.push_msg(queue_name, "Message 1")
-      subject.push_msg(queue_name, "Message 2")
-      subject.pluck(queue_name, 2)
+      redis_service.push_msg(queue_name, "Message 1")
+      redis_service.push_msg(queue_name, "Message 2")
+      redis_service.pluck(queue_name, 2)
       expect(redis { |c| c.llen key }).to eq 0
     end
 
-    it "forgets unique messages" do
-      subject.push_msg(queue_name, "Message 1", true)
-      subject.push_msg(queue_name, "Message 2", true)
+    it "forgets unique messages", :aggregate_failures do
+      redis_service.push_msg(queue_name, "Message 1", remember_unique: true)
+      redis_service.push_msg(queue_name, "Message 2", remember_unique: true)
       expect(redis { |c| c.scard unique_key }).to eq 2
-      subject.pluck(queue_name, 2)
+      redis_service.pluck(queue_name, 2)
       expect(redis { |c| c.smembers unique_key }).to eq []
     end
   end
@@ -43,5 +45,4 @@ describe Sidekiq::Grouping::Redis do
   def redis(&block)
     Sidekiq.redis(&block)
   end
-
 end

data/spec/spec_helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 $LOAD_PATH << "." unless $LOAD_PATH.include?(".")
 
 require "rubygems"
@@ -15,7 +17,7 @@ end
 require "sidekiq/grouping"
 
 Sidekiq::Grouping.logger = nil
-Sidekiq.redis = { namespace: ENV["namespace"] }
+Sidekiq.redis = { db: ENV.fetch("db", 1) }
 Sidekiq.logger = nil
 
 RSpec::Sidekiq.configure do |config|
@@ -28,14 +30,14 @@ RSpec.configure do |config|
   config.run_all_when_everything_filtered = true
   config.filter_run :focus
 
-  config.before :each do
+  config.before do
     Sidekiq.redis do |conn|
       keys = conn.keys "*batching*"
       keys.each { |key| conn.del key }
     end
   end
 
-  config.after :each do
+  config.after do
     Timecop.return
   end
 end

data/spec/support/test_workers.rb

@@ -1,8 +1,9 @@
+# frozen_string_literal: true
+
 class RegularWorker
   include Sidekiq::Worker
 
-  def perform(foo)
-  end
+  def perform(foo); end
 end
 
 class BatchedSizeWorker
@@ -10,8 +11,7 @@ class BatchedSizeWorker
 
   sidekiq_options queue: :batched_size, batch_flush_size: 3, batch_size: 2
 
-  def perform(foo)
-  end
+  def perform(foo); end
 end
 
 class BatchedIntervalWorker
@@ -19,8 +19,7 @@ class BatchedIntervalWorker
 
   sidekiq_options queue: :batched_interval, batch_flush_interval: 3600
 
-  def perform(foo)
-  end
+  def perform(foo); end
 end
 
 class BatchedBothWorker
@@ -30,8 +29,7 @@ class BatchedBothWorker
     queue: :batched_both, batch_flush_interval: 3600, batch_flush_size: 3
   )
 
-  def perform(foo)
-  end
+  def perform(foo); end
 end
 
 class BatchedUniqueArgsWorker
@@ -41,6 +39,5 @@ class BatchedUniqueArgsWorker
     queue: :batched_unique_args, batch_flush_size: 3, batch_unique: true
   )
 
-  def perform(foo)
-  end
+  def perform(foo); end
 end