sidekiq-limit_fetch 2.4.1 → 2.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 308521ae4ca41ec67f93b1e586c24d5b2704c6f2
-  data.tar.gz: 638d54dc481262e7bf13a128777cd22016106a3d
+  metadata.gz: 1edc411f8e5b3ab852b0b005548a28fafd0167e4
+  data.tar.gz: df6b938724aa978eab9757d1c969c9577c9e58c3
 SHA512:
-  metadata.gz: 6a584f739cc6c4c825a6c1da2e09aec8536ca866433605252220b503bc3fbabe75a35228053b4ba38656c7016b24aa466272c321cc0d1bd41eb04829c5e0f7f7
-  data.tar.gz: d62381535352afec36b7668792f0db79d069ec4b10ab0ede19dc7d6c69720a21612265338192ecd4f693e08a0bcc21d988b5e20bd47b025b38035a3a1fefbd0e
+  metadata.gz: 4cb020c997e1dc814969e949ae497f49ee048f4d8b0b18833dd8eca51de0a1b943cae09d2e34e523e9d9c29b251101bf707cbab67d7a5ff270cda43be69ffbbd
+  data.tar.gz: 29eb71b1e70bde0da6dee13798e2fae39c2900abca6cbcf25d22ab2466028525ef84ff4abb3c00b02b48524b4ffef09bb8a98f432761d9e5081bf3a656c7d24e

data/lib/sidekiq/limit_fetch/queues.rb

@@ -9,8 +9,8 @@ class Sidekiq::LimitFetch
 
       options[:strict] ? strict_order! : weighted_order!
 
-      set :limit, options[:limits]
       set :process_limit, options[:process_limits]
+      set :limit, options[:limits]
       set_blocks options[:blocking]
     end
 

data/sidekiq-limit_fetch.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |gem|
   gem.name          = 'sidekiq-limit_fetch'
-  gem.version       = '2.4.1'
+  gem.version       = '2.4.2'
   gem.license       = 'MIT'
   gem.authors       = 'brainopia'
   gem.email         = 'brainopia@evilmartians.com'
@@ -16,6 +16,6 @@ Gem::Specification.new do |gem|
   gem.require_paths = %w(lib)
 
   gem.add_dependency 'sidekiq', '>= 2.6.5', '< 4.0'
-  gem.add_development_dependency 'rspec', '< 3.0'
+  gem.add_development_dependency 'rspec', '~> 3.2.0'
   gem.add_development_dependency 'rake'
 end

data/spec/sidekiq/extensions/queue_spec.rb

@@ -1,16 +1,16 @@
 require 'spec_helper'
 
-describe Sidekiq::Queue do
+RSpec.describe Sidekiq::Queue do
   context 'singleton' do
     shared_examples :constructor do
       it 'with default name' do
         new_object = -> { described_class.send constructor }
-        new_object.call.should == new_object.call
+        expect(new_object.call).to eq new_object.call
       end
 
       it 'with given name' do
         new_object = ->(name) { described_class.send constructor, name }
-        new_object.call('name').should == new_object.call('name')
+        expect(new_object.call('name')).to eq new_object.call('name')
       end
     end
 
@@ -29,67 +29,67 @@ describe Sidekiq::Queue do
       let(:queue) { Sidekiq::Queue[name] }
 
       it 'should be available' do
-        queue.acquire.should be
+        expect(queue.acquire).to be
       end
 
       it 'should be pausable' do
         queue.pause
-        queue.acquire.should_not be
+        expect(queue.acquire).not_to be
       end
 
       it 'should be continuable' do
         queue.pause
         queue.unpause
-        queue.acquire.should be
+        expect(queue.acquire).to be
       end
 
       it 'should be limitable' do
         queue.limit = 1
-        queue.acquire.should be
-        queue.acquire.should_not be
+        expect(queue.acquire).to be
+        expect(queue.acquire).not_to be
       end
 
       it 'should be resizable' do
         queue.limit = 0
-        queue.acquire.should_not be
+        expect(queue.acquire).not_to be
         queue.limit = nil
-        queue.acquire.should be
+        expect(queue.acquire).to be
       end
 
       it 'should be countable' do
         queue.limit = 3
         5.times { queue.acquire }
-        queue.probed.should == 3
+        expect(queue.probed).to eq 3
       end
 
       it 'should be releasable' do
         queue.acquire
-        queue.probed.should == 1
+        expect(queue.probed).to eq 1
         queue.release
-        queue.probed.should == 0
+        expect(queue.probed).to eq 0
       end
 
       it 'should tell if paused' do
-        queue.should_not be_paused
+        expect(queue).not_to be_paused
         queue.pause
-        queue.should be_paused
+        expect(queue).to be_paused
         queue.unpause
-        queue.should_not be_paused
+        expect(queue).not_to be_paused
       end
 
       it 'should tell if blocking' do
-        queue.should_not be_blocking
+        expect(queue).not_to be_blocking
         queue.block
-        queue.should be_blocking
+        expect(queue).to be_blocking
         queue.unblock
-        queue.should_not be_blocking
+        expect(queue).not_to be_blocking
       end
 
       it 'should be marked as changed' do
         queue = Sidekiq::Queue["uniq_#{name}"]
-        queue.should_not be_limit_changed
+        expect(queue).not_to be_limit_changed
         queue.limit = 3
-        queue.should be_limit_changed
+        expect(queue).to be_limit_changed
       end
     end
   end

data/spec/sidekiq/limit_fetch/global/monitor_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 Thread.abort_on_exception = true
 
-describe Sidekiq::LimitFetch::Global::Monitor do
+RSpec.describe Sidekiq::LimitFetch::Global::Monitor do
   let(:queues) { double dynamic?: false }
   let(:monitor) { described_class.start! queues, ttl, timeout }
   let(:ttl) { 1 }
@@ -23,21 +23,21 @@ describe Sidekiq::LimitFetch::Global::Monitor do
     it 'should remove invalidated old locks' do
       2.times { queue.acquire }
       sleep 2*ttl
-      queue.probed.should == 2
+      expect(queue.probed).to eq 2
 
-      described_class.stub :update_heartbeat
+      allow(described_class).to receive(:update_heartbeat)
       sleep 2*ttl
-      queue.probed.should == 0
+      expect(queue.probed).to eq 0
     end
 
     it 'should remove invalid locks' do
       2.times { queue.acquire }
-      described_class.stub :update_heartbeat
+      allow(described_class).to receive(:update_heartbeat)
       Sidekiq.redis do |it|
         it.del Sidekiq::LimitFetch::Global::Monitor::PROCESS_SET
       end
       sleep 2*ttl
-      queue.probed.should == 0
+      expect(queue.probed).to eq 0
     end
   end
 end

data/spec/sidekiq/limit_fetch/queues_spec.rb

@@ -1,69 +1,71 @@
 require 'spec_helper'
 
-describe Sidekiq::LimitFetch::Queues do
+RSpec.describe Sidekiq::LimitFetch::Queues do
   subject { described_class.new options }
 
-  let(:queues)   { %w[queue1 queue2] }
-  let(:limits)   {{ 'queue1' => 3 }}
-  let(:strict)   { true }
-  let(:blocking) {}
+  let(:queues)         { %w[queue1 queue2] }
+  let(:limits)         {{ 'queue1' => 3 }}
+  let(:strict)         { true }
+  let(:blocking)       {}
+  let(:process_limits) {{ 'queue2' => 3 }}
 
   let(:options) do
     { queues:   queues,
       limits:   limits,
       strict:   strict,
       blocking: blocking,
+      process_limits: process_limits,
       namespace: Sidekiq::LimitFetch::Redis.determine_namespace }
   end
 
   it 'should acquire queues' do
     subject.acquire
-    Sidekiq::Queue['queue1'].probed.should == 1
-    Sidekiq::Queue['queue2'].probed.should == 1
+    expect(Sidekiq::Queue['queue1'].probed).to eq 1
+    expect(Sidekiq::Queue['queue2'].probed).to eq 1
   end
 
   it 'should acquire dynamically blocking queues' do
     subject.acquire
-    Sidekiq::Queue['queue1'].probed.should == 1
-    Sidekiq::Queue['queue2'].probed.should == 1
+    expect(Sidekiq::Queue['queue1'].probed).to eq 1
+    expect(Sidekiq::Queue['queue2'].probed).to eq 1
 
     Sidekiq::Queue['queue1'].block
 
     subject.acquire
-    Sidekiq::Queue['queue1'].probed.should == 2
-    Sidekiq::Queue['queue2'].probed.should == 1
+    expect(Sidekiq::Queue['queue1'].probed).to eq 2
+    expect(Sidekiq::Queue['queue2'].probed).to eq 1
   end
 
   it 'should block except given queues' do
     Sidekiq::Queue['queue1'].block_except 'queue2'
     subject.acquire
-    Sidekiq::Queue['queue1'].probed.should == 1
-    Sidekiq::Queue['queue2'].probed.should == 1
+    expect(Sidekiq::Queue['queue1'].probed).to eq 1
+    expect(Sidekiq::Queue['queue2'].probed).to eq 1
 
     Sidekiq::Queue['queue1'].block_except 'queue404'
     subject.acquire
-    Sidekiq::Queue['queue1'].probed.should == 2
-    Sidekiq::Queue['queue2'].probed.should == 1
+    expect(Sidekiq::Queue['queue1'].probed).to eq 2
+    expect(Sidekiq::Queue['queue2'].probed).to eq 1
   end
 
   it 'should release queues' do
     subject.acquire
     subject.release_except nil
-    Sidekiq::Queue['queue1'].probed.should == 0
-    Sidekiq::Queue['queue2'].probed.should == 0
+    expect(Sidekiq::Queue['queue1'].probed).to eq 0
+    expect(Sidekiq::Queue['queue2'].probed).to eq 0
   end
 
   it 'should release queues except selected' do
     subject.acquire
     subject.release_except 'queue:queue1'
-    Sidekiq::Queue['queue1'].probed.should == 1
-    Sidekiq::Queue['queue2'].probed.should == 0
+    expect(Sidekiq::Queue['queue1'].probed).to eq 1
+    expect(Sidekiq::Queue['queue2'].probed).to eq 0
   end
 
   it 'should release when no queues was acquired' do
     queues.each {|name| Sidekiq::Queue[name].pause }
     subject.acquire
-    -> { subject.release_except nil }.should_not raise_exception
+    expect { subject.release_except nil }.not_to raise_exception
   end
 
   context 'blocking' do
@@ -71,26 +73,31 @@ describe Sidekiq::LimitFetch::Queues do
 
     it 'should acquire blocking queues' do
       3.times { subject.acquire }
-      Sidekiq::Queue['queue1'].probed.should == 3
-      Sidekiq::Queue['queue2'].probed.should == 1
+      expect(Sidekiq::Queue['queue1'].probed).to eq 3
+      expect(Sidekiq::Queue['queue2'].probed).to eq 1
     end
   end
 
   it 'should set limits' do
     subject
-    Sidekiq::Queue['queue1'].limit.should == 3
-    Sidekiq::Queue['queue2'].limit.should_not be
+    expect(Sidekiq::Queue['queue1'].limit).to eq 3
+    expect(Sidekiq::Queue['queue2'].limit).not_to be
+  end
+
+  it 'should set process_limits' do
+    subject
+    expect(Sidekiq::Queue['queue2'].process_limit).to eq 3
   end
 
   context 'without strict flag' do
     let(:strict) { false }
 
     it 'should retrieve weighted queues' do
-      subject.ordered_queues.should =~ %w(queue1 queue2)
+      expect(subject.ordered_queues).to match_array(%w(queue1 queue2))
     end
   end
 
   it 'with strict flag should retrieve strictly ordered queues' do
-    subject.ordered_queues.should == %w(queue1 queue2)
+    expect(subject.ordered_queues).to eq %w(queue1 queue2)
   end
 end

data/spec/sidekiq/limit_fetch/semaphore_spec.rb

@@ -1,48 +1,48 @@
 require 'spec_helper'
 
-describe 'semaphore' do
+RSpec.describe 'semaphore' do
   let(:name) { 'default' }
   subject { Sidekiq::LimitFetch::Global::Semaphore.new name }
 
   it 'should have no limit by default' do
-    subject.limit.should_not be
+    expect(subject.limit).not_to be
   end
 
   it 'should set limit' do
     subject.limit = 4
-    subject.limit.should == 4
+    expect(subject.limit).to eq 4
   end
 
   it 'should acquire and count active tasks' do
     3.times { subject.acquire }
-    subject.probed.should == 3
+    expect(subject.probed).to eq 3
   end
 
   it 'should acquire tasks with regard to limit' do
     subject.limit = 4
     6.times { subject.acquire }
-    subject.probed.should == 4
+    expect(subject.probed).to eq 4
   end
 
   it 'should acquire tasks with regard to process limit' do
     subject.process_limit = 4
     6.times { subject.acquire }
-    subject.probed.should == 4
+    expect(subject.probed).to eq 4
   end
 
   it 'should release active tasks' do
     6.times { subject.acquire }
     3.times { subject.release }
-    subject.probed.should == 3
+    expect(subject.probed).to eq 3
   end
 
   it 'should pause tasks' do
     3.times { subject.acquire }
     subject.pause
     2.times { subject.acquire }
-    subject.probed.should == 3
+    expect(subject.probed).to eq 3
     2.times { subject.release }
-    subject.probed.should == 1
+    expect(subject.probed).to eq 1
   end
 
   it 'should unpause tasks' do
@@ -50,16 +50,16 @@ describe 'semaphore' do
     3.times { subject.acquire }
     subject.unpause
     2.times { subject.acquire }
-    subject.probed.should == 2
+    expect(subject.probed).to eq 2
   end
 
   it 'should pause tasks for a limited time' do
     3.times { subject.acquire }
     subject.pause_for_ms 50
     2.times { subject.acquire }
-    subject.probed.should == 3
+    expect(subject.probed).to eq 3
     sleep(100.0 / 1000)
     2.times { subject.acquire }
-    subject.probed.should == 5
+    expect(subject.probed).to eq 5
   end
 end

data/spec/sidekiq/limit_fetch_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Sidekiq::LimitFetch do
+RSpec.describe Sidekiq::LimitFetch do
   before :each do
     Sidekiq.redis do |it|
       it.del 'queue:queue1'
@@ -17,31 +17,31 @@ describe Sidekiq::LimitFetch do
 
   it 'should acquire lock on queue for execution' do
     work = subject.retrieve_work
-    work.queue_name.should == 'queue1'
-    work.message.should == 'task1'
+    expect(work.queue_name).to eq 'queue1'
+    expect(work.message).to eq 'task1'
 
-    Sidekiq::Queue['queue1'].busy.should == 1
-    Sidekiq::Queue['queue2'].busy.should == 0
+    expect(Sidekiq::Queue['queue1'].busy).to eq 1
+    expect(Sidekiq::Queue['queue2'].busy).to eq 0
 
-    subject.retrieve_work.should_not be
+    expect(subject.retrieve_work).not_to be
     work.requeue
 
-    Sidekiq::Queue['queue1'].busy.should == 0
-    Sidekiq::Queue['queue2'].busy.should == 0
+    expect(Sidekiq::Queue['queue1'].busy).to eq 0
+    expect(Sidekiq::Queue['queue2'].busy).to eq 0
 
     work = subject.retrieve_work
-    work.message.should == 'task1'
+    expect(work.message).to eq 'task1'
 
-    Sidekiq::Queue['queue1'].busy.should == 1
-    Sidekiq::Queue['queue2'].busy.should == 0
+    expect(Sidekiq::Queue['queue1'].busy).to eq 1
+    expect(Sidekiq::Queue['queue2'].busy).to eq 0
 
-    subject.retrieve_work.should_not be
+    expect(subject.retrieve_work).not_to be
     work.acknowledge
 
-    Sidekiq::Queue['queue1'].busy.should == 0
-    Sidekiq::Queue['queue2'].busy.should == 0
+    expect(Sidekiq::Queue['queue1'].busy).to eq 0
+    expect(Sidekiq::Queue['queue2'].busy).to eq 0
 
     work = subject.retrieve_work
-    work.message.should == 'task2'
+    expect(work.message).to eq 'task2'
   end
 end

data/spec/spec_helper.rb

@@ -6,6 +6,9 @@ Sidekiq.logger = nil
 Sidekiq.redis = { namespace: ENV['namespace'] }
 
 RSpec.configure do |config|
+  config.order = :random
+  config.disable_monkey_patching!
+  config.raise_errors_for_deprecations!
   config.before :each do
     Sidekiq::Queue.reset_instances!
     Sidekiq.redis do |it|

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sidekiq-limit_fetch
 version: !ruby/object:Gem::Version
-  version: 2.4.1
+  version: 2.4.2
 platform: ruby
 authors:
 - brainopia
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-07 00:00:00.000000000 Z
+date: 2015-05-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sidekiq
@@ -34,16 +34,16 @@ dependencies:
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: 3.2.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: 3.2.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement