sidekiq-status 0.5.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c4b871d99e1ab00e5786f91d61a3f0fc4c17087e
-  data.tar.gz: 6909a5063a68811982f9e38580b1aeb146f5313f
+  metadata.gz: d3dd7cc94267c99010ecd9b47129528e1c2a2a12
+  data.tar.gz: b2fdf88b3ff5717fa202d92652d2b9bae0c40140
 SHA512:
-  metadata.gz: 952fb2284e645179db9b5242bf4a9adcc6f8512b02335b60056b964711498c2c87d633e6f1b95116d576524ca4e3931db25fa51a22eab4d67cc41ac86e84099f
-  data.tar.gz: 249eba2c142648813996c685d6bb5e03b08765580bd36139ce24f348ddc3a1cd19ec0569a9c398d9c08a2d948a2f64d7e537695df6d93b45869416a1546a16ef
+  metadata.gz: 6edd2298f96a0bcbcd3c7dc58426c328f159fd6de092e1764e31cfad2b07c00ba48dc4f7cdadd6e1d0b40c4e9b3c19ffb8f7af2dc33e9378f6e214a306822490
+  data.tar.gz: f4ed9c45848b094916256730db4f286733e662d3a81735490fe1285d40fea464c9d787c72fad8f17c01ad67b8081eac93ebbd28c717a7939a7479939e7338f9b

data/CHANGELOG

@@ -1,2 +1,3 @@
+Version 0.5.1:dependencies versions requirements relaxed
 Version 0.5.0:Sidekiq v3 support, redis pools support
 Version 0.4.0:WebUI added, per-worker expiration setting enabled

data/lib/sidekiq-status.rb

@@ -37,11 +37,9 @@ module Sidekiq::Status
     alias_method :unschedule, :cancel
 
     STATUS.each do |name|
-      class_eval(<<-END, __FILE__, __LINE__)
-        def #{name}?(job_id)
-          status(job_id) == :#{name}
-        end
-      END
+      define_method("#{name}?") do |job_id|
+        status(job_id) == name
+      end
     end
 
     # Methods for retrieving job completion

data/lib/sidekiq-status/version.rb

@@ -1,5 +1,5 @@
 module Sidekiq
   module Status
-    VERSION = "0.5.0"
+    VERSION = "0.5.1"
   end
 end

data/sidekiq-status.gemspec

@@ -14,7 +14,7 @@ Gem::Specification.new do |gem|
   gem.require_paths = ['lib']
   gem.version       = Sidekiq::Status::VERSION
 
-  gem.add_dependency                  'sidekiq', '>= 2.7', '< 3.1'
+  gem.add_dependency                  'sidekiq', '>= 2.7', '< 3.4'
   gem.add_development_dependency      'rake'
   gem.add_development_dependency      'rspec'
 end

data/spec/lib/sidekiq-status/client_middleware_spec.rb

@@ -10,30 +10,30 @@ describe Sidekiq::Status::ClientMiddleware do
 
   describe "#call" do
     it "sets queued status" do
-      SecureRandom.should_receive(:hex).once.and_return(job_id)
-      StubJob.perform_async(:arg1 => 'val1').should == job_id
-      redis.hget(job_id, :status).should == 'queued'
-      Sidekiq::Status::queued?(job_id).should be_true
+      allow(SecureRandom).to receive(:hex).once.and_return(job_id)
+      expect(StubJob.perform_async(:arg1 => 'val1')).to eq(job_id)
+      expect(redis.hget(job_id, :status)).to eq('queued')
+      expect(Sidekiq::Status::queued?(job_id)).to be_truthy
     end
 
     it "sets status hash ttl" do
-      SecureRandom.should_receive(:hex).once.and_return(job_id)
-      StubJob.perform_async(:arg1 => 'val1').should == job_id
-      (1..Sidekiq::Status::DEFAULT_EXPIRY).should cover redis.ttl(job_id)
+      allow(SecureRandom).to receive(:hex).once.and_return(job_id)
+      expect(StubJob.perform_async(:arg1 => 'val1')).to eq(job_id)
+      expect(1..Sidekiq::Status::DEFAULT_EXPIRY).to cover redis.ttl(job_id)
     end
 
     context "when redis_pool passed" do
       it "uses redis_pool" do
         redis_pool = double(:redis_pool)
-        redis_pool.should_receive(:with)
-        Sidekiq.should_not_receive(:redis)
+        allow(redis_pool).to receive(:with)
+        expect(Sidekiq).to_not receive(:redis)
         Sidekiq::Status::ClientMiddleware.new.call(StubJob, {'jid' => SecureRandom.hex}, :queued, redis_pool) do end
       end
     end
 
     context "when redis_pool is not passed" do
       it "uses Sidekiq.redis" do
-        Sidekiq.should_receive(:redis)
+        allow(Sidekiq).to receive(:redis)
         Sidekiq::Status::ClientMiddleware.new.call(StubJob, {'jid' => SecureRandom.hex}, :queued) do end
       end
     end

data/spec/lib/sidekiq-status/server_middleware_spec.rb

@@ -13,54 +13,55 @@ describe Sidekiq::Status::ServerMiddleware do
   describe "#call" do
     it "sets working/complete status" do
       thread = confirmations_thread 4, "status_updates", "job_messages_#{job_id}"
-      SecureRandom.should_receive(:hex).once.and_return(job_id)
+      allow(SecureRandom).to receive(:hex).once.and_return(job_id)
       start_server do
-        ConfirmationJob.perform_async(:arg1 => 'val1').should == job_id
-        thread.value.should == [job_id, job_id,
+        expect(ConfirmationJob.perform_async(:arg1 => 'val1')).to eq(job_id)
+        expect(thread.value).to eq([job_id, job_id,
                                 "while in #perform, status = working",
-                                job_id]
+                                job_id])
       end
-      redis.hget(job_id, :status).should == 'complete'
-      Sidekiq::Status::complete?(job_id).should be_true
+      expect(redis.hget(job_id, :status)).to eq('complete')
+      expect(Sidekiq::Status::complete?(job_id)).to be_truthy
     end
 
     it "sets failed status" do
-      SecureRandom.should_receive(:hex).once.and_return(job_id)
+      allow(SecureRandom).to receive(:hex).once.and_return(job_id)
       start_server do
-        capture_status_updates(3) {
-          FailingJob.perform_async.should == job_id
-        }.should == [job_id]*3
+        expect(capture_status_updates(3) {
+          expect(FailingJob.perform_async).to eq(job_id)
+        }).to eq([job_id]*3)
       end
-      redis.hget(job_id, :status).should == 'failed'
-      Sidekiq::Status::failed?(job_id).should be_true
+      expect(redis.hget(job_id, :status)).to eq('failed')
+      expect(Sidekiq::Status::failed?(job_id)).to be_truthy
     end
 
     it "sets status hash ttl" do
-      SecureRandom.should_receive(:hex).once.and_return(job_id)
-      StubJob.perform_async(:arg1 => 'val1').should == job_id
-      (1..Sidekiq::Status::DEFAULT_EXPIRY).should cover redis.ttl(job_id)
+      allow(SecureRandom).to receive(:hex).once.and_return(job_id)
+      expect(StubJob.perform_async(:arg1 => 'val1')).to eq(job_id)
+      expect(1..Sidekiq::Status::DEFAULT_EXPIRY).to cover redis.ttl(job_id)
     end
   end
 
   describe ":expiration parameter" do
     let(:huge_expiration) { Sidekiq::Status::DEFAULT_EXPIRY * 100 }
     before do
-      SecureRandom.should_receive(:hex).once.and_return(job_id)
+      allow(SecureRandom).to receive(:hex).once.and_return(job_id)
     end
+
     it "overwrites default expiry value" do
       start_server(:expiration => huge_expiration) do
         StubJob.perform_async(:arg1 => 'val1')
       end
-      ((Sidekiq::Status::DEFAULT_EXPIRY+1)..huge_expiration).should cover redis.ttl(job_id)
+      expect((Sidekiq::Status::DEFAULT_EXPIRY+1)..huge_expiration).to cover redis.ttl(job_id)
     end
 
     it "can be overwritten by worker expiration method" do
       overwritten_expiration = huge_expiration * 100
-      StubJob.any_instance.stub(expiration: overwritten_expiration)
+      allow_any_instance_of(StubJob).to receive(:expiration).and_return(overwritten_expiration)
       start_server(:expiration => huge_expiration) do
         StubJob.perform_async(:arg1 => 'val1')
       end
-      ((huge_expiration+1)..overwritten_expiration).should cover redis.ttl(job_id)
+      expect((huge_expiration+1)..overwritten_expiration).to cover redis.ttl(job_id)
     end
   end
 end

data/spec/lib/sidekiq-status/worker_spec.rb

@@ -6,13 +6,14 @@ describe Sidekiq::Status::Worker do
 
   describe ".perform_async" do
     it "generates and returns job id" do
-      SecureRandom.should_receive(:hex).once.and_return(job_id)
-      StubJob.perform_async().should == job_id
+      allow(SecureRandom).to receive(:hex).once.and_return(job_id)
+      expect(StubJob.perform_async()).to eq(job_id)
     end
   end
 
   describe ".expiration" do
     subject { StubJob.new }
+    
     it "allows to set/get expiration" do
       expect(subject.expiration).to be_nil
       subject.expiration = :val

data/spec/lib/sidekiq-status_spec.rb

@@ -16,105 +16,109 @@ describe Sidekiq::Status do
 
   describe ".status, .working?, .complete?" do
     it "gets job status by id as symbol" do
-      SecureRandom.should_receive(:hex).once.and_return(job_id)
+      allow(SecureRandom).to receive(:hex).once.and_return(job_id)
 
       start_server do
-        capture_status_updates(2) {
-          LongJob.perform_async(1).should == job_id
-        }.should == [job_id]*2
-        Sidekiq::Status.status(job_id).should == :working
-        Sidekiq::Status.working?(job_id).should be_true
-        Sidekiq::Status::queued?(job_id).should be_false
-        Sidekiq::Status::failed?(job_id ).should be_false
-        Sidekiq::Status::complete?(job_id).should be_false
-        Sidekiq::Status::stopped?(job_id).should be_false
+        expect(capture_status_updates(2) {
+          expect(LongJob.perform_async(1)).to eq(job_id)
+        }).to eq([job_id]*2)
+        expect(Sidekiq::Status.status(job_id)).to eq(:working)
+        expect(Sidekiq::Status.working?(job_id)).to be_truthy
+        expect(Sidekiq::Status::queued?(job_id)).to be_falsey
+        expect(Sidekiq::Status::failed?(job_id)).to be_falsey
+        expect(Sidekiq::Status::complete?(job_id)).to be_falsey
+        expect(Sidekiq::Status::stopped?(job_id)).to be_falsey
       end
-      Sidekiq::Status.status(job_id).should == :complete
-      Sidekiq::Status.complete?(job_id).should be_true
+      expect(Sidekiq::Status.status(job_id)).to eq(:complete)
+      expect(Sidekiq::Status.complete?(job_id)).to be_truthy
     end
   end
 
   describe ".get" do
     it "gets a single value from data hash as string" do
-      SecureRandom.should_receive(:hex).once.and_return(job_id)
+      allow(SecureRandom).to receive(:hex).once.and_return(job_id)
 
       start_server do
-        capture_status_updates(3) {
-          DataJob.perform_async.should == job_id
-        }.should == [job_id]*3
-        Sidekiq::Status.get(job_id, :status).should == 'working'
+        expect(capture_status_updates(3) {
+          expect(DataJob.perform_async).to eq(job_id)
+        }).to eq([job_id]*3)
+        expect(Sidekiq::Status.get(job_id, :status)).to eq('working')
       end
-      Sidekiq::Status.get(job_id, :data).should == 'meow'
+      expect(Sidekiq::Status.get(job_id, :data)).to eq('meow')
     end
   end
 
   describe ".at, .total, .pct_complete, .message" do
     it "should return job progress with correct type to it" do
-      SecureRandom.should_receive(:hex).once.and_return(job_id)
+      allow(SecureRandom).to receive(:hex).once.and_return(job_id)
 
       start_server do
-        capture_status_updates(3) {
-          ProgressJob.perform_async.should == job_id
-        }.should == [job_id]*3
+        expect(capture_status_updates(3) {
+          expect(ProgressJob.perform_async).to eq(job_id)
+        }).to eq([job_id]*3)
       end
-      Sidekiq::Status.at(job_id).should == 100
-      Sidekiq::Status.total(job_id).should == 500
-      Sidekiq::Status.pct_complete(job_id).should == 20
-      Sidekiq::Status.message(job_id).should == 'howdy, partner?'
+      expect(Sidekiq::Status.at(job_id)).to be(100)
+      expect(Sidekiq::Status.total(job_id)).to be(500)
+      # It returns a float therefor we need eq()
+      expect(Sidekiq::Status.pct_complete(job_id)).to eq(20)
+      expect(Sidekiq::Status.message(job_id)).to eq('howdy, partner?')
     end
   end
 
   describe ".get_all" do
     it "gets the job hash by id" do
-      SecureRandom.should_receive(:hex).once.and_return(job_id)
+      allow(SecureRandom).to receive(:hex).once.and_return(job_id)
 
       start_server do
-        capture_status_updates(2) {
-          LongJob.perform_async(1).should == job_id
-        }.should == [job_id]*2
-        (hash = Sidekiq::Status.get_all(job_id)).should include 'status' => 'working'
-        hash.should include 'update_time'
+        expect(capture_status_updates(2) {
+          expect(LongJob.perform_async(1)).to eq(job_id)
+        }).to eq([job_id]*2)
+        expect(hash = Sidekiq::Status.get_all(job_id)).to include 'status' => 'working'
+        expect(hash).to include 'update_time'
       end
-      (hash = Sidekiq::Status.get_all(job_id)).should include 'status' => 'complete'
-      hash.should include 'update_time'
+      expect(hash = Sidekiq::Status.get_all(job_id)).to include 'status' => 'complete'
+      expect(hash).to include 'update_time'
     end
   end
 
   describe ".cancel" do
     it "cancels a job by id" do
-      SecureRandom.should_receive(:hex).twice.and_return(job_id, job_id_1)
+      allow(SecureRandom).to receive(:hex).twice.and_return(job_id, job_id_1)
       start_server do
         job = LongJob.perform_in(3600)
-        job.should == job_id
+        expect(job).to eq(job_id)
         second_job = LongJob.perform_in(3600)
-        second_job.should == job_id_1
+        expect(second_job).to eq(job_id_1)
 
         initial_schedule = redis.zrange "schedule", 0, -1, {withscores: true}
-        initial_schedule.size.should be 2
-        initial_schedule.select {|scheduled_job| JSON.parse(scheduled_job[0])["jid"] == job_id }.size.should be 1
+        expect(initial_schedule.size).to  be(2)
+        expect(initial_schedule.select {|scheduled_job| JSON.parse(scheduled_job[0])["jid"] == job_id }.size).to be(1)
 
-        Sidekiq::Status.unschedule(job_id).should be_true
-        Sidekiq::Status.cancel(unused_id).should be_false # Unused, therefore unfound => false
+        expect(Sidekiq::Status.unschedule(job_id)).to be_truthy
+        # Unused, therefore unfound => false
+        expect(Sidekiq::Status.cancel(unused_id)).to be_falsey
 
         remaining_schedule = redis.zrange "schedule", 0, -1, {withscores: true}
-        remaining_schedule.size.should == (initial_schedule.size - 1)
-        remaining_schedule.select {|scheduled_job| JSON.parse(scheduled_job[0])["jid"] == job_id }.size.should be 0
+        expect(remaining_schedule.size).to be(initial_schedule.size - 1)
+        expect(remaining_schedule.select {|scheduled_job| JSON.parse(scheduled_job[0])["jid"] == job_id }.size).to be(0)
       end
     end
 
     it "does not cancel a job with correct id but wrong time" do
-      SecureRandom.should_receive(:hex).once.and_return(job_id)
+      allow(SecureRandom).to receive(:hex).once.and_return(job_id)
       start_server do
         scheduled_time = Time.now.to_i + 3600
         returned_job_id = LongJob.perform_at(scheduled_time)
-        returned_job_id.should == job_id
+        expect(returned_job_id).to eq(job_id)
 
         initial_schedule = redis.zrange "schedule", 0, -1, {withscores: true}
-        initial_schedule.size.should == 1
-        Sidekiq::Status.cancel(returned_job_id, (scheduled_time + 1)).should be_false # wrong time, therefore unfound => false
-        (redis.zrange "schedule", 0, -1, {withscores: true}).size.should be 1
-        Sidekiq::Status.cancel(returned_job_id, (scheduled_time)).should be_true # same id, same time, deletes
-        (redis.zrange "schedule", 0, -1, {withscores: true}).size.should be_zero
+        expect(initial_schedule.size).to be(1)
+        # wrong time, therefore unfound => false
+        expect(Sidekiq::Status.cancel(returned_job_id, (scheduled_time + 1))).to be_falsey
+        expect((redis.zrange "schedule", 0, -1, {withscores: true}).size).to be(1)
+        # same id, same time, deletes
+        expect(Sidekiq::Status.cancel(returned_job_id, (scheduled_time))).to be_truthy
+        expect(redis.zrange "schedule", 0, -1, {withscores: true}).to be_empty
       end
     end
   end
@@ -130,13 +134,13 @@ describe Sidekiq::Status do
     end
 
     it "retries failed jobs" do
-      SecureRandom.should_receive(:hex).once.and_return(retried_job_id)
+      allow(SecureRandom).to receive(:hex).once.and_return(retried_job_id)
       start_server do
-        capture_status_updates(5) {
-          RetriedJob.perform_async().should == retried_job_id
-        }.should == [retried_job_id] * 5
+        expect(capture_status_updates(5) {
+          expect(RetriedJob.perform_async()).to eq(retried_job_id)
+        }).to eq([retried_job_id] * 5)
       end
-      Sidekiq::Status.status(retried_job_id).should == :complete
+      expect(Sidekiq::Status.status(retried_job_id)).to eq(:complete)
     end
 
     context ":expiration param" do
@@ -151,8 +155,10 @@ describe Sidekiq::Status do
 
       it "allow to overwrite :expiration parameter by .expiration method from worker" do
         overwritten_expiration = expiration_param * 100
-        NoStatusConfirmationJob.any_instance.stub(:expiration => overwritten_expiration)
-        StubJob.any_instance.stub(:expiration => overwritten_expiration)
+        allow_any_instance_of(NoStatusConfirmationJob).to receive(:expiration).
+          and_return(overwritten_expiration)
+        allow_any_instance_of(StubJob).to receive(:expiration).
+          and_return(overwritten_expiration)
         run_2_jobs!
         expect_2_jobs_are_done_and_status_eq :complete
         expect_2_jobs_ttl_covers (expiration_param+1)..overwritten_expiration
@@ -160,29 +166,30 @@ describe Sidekiq::Status do
     end
 
     def seed_secure_random_with_job_ids
-      SecureRandom.should_receive(:hex).exactly(4).times.and_return(plain_sidekiq_job_id, plain_sidekiq_job_id, job_id_1, job_id_1)
+      allow(SecureRandom).to receive(:hex).exactly(4).times.
+        and_return(plain_sidekiq_job_id, plain_sidekiq_job_id, job_id_1, job_id_1)
     end
 
     def run_2_jobs!
       start_server(:expiration => expiration_param) do
-        capture_status_updates(12) {
-          StubJob.perform_async.should == plain_sidekiq_job_id
+        expect(capture_status_updates(12) {
+          expect(StubJob.perform_async).to eq(plain_sidekiq_job_id)
           NoStatusConfirmationJob.perform_async(1)
-          StubJob.perform_async.should == job_id_1
+          expect(StubJob.perform_async).to eq(job_id_1)
           NoStatusConfirmationJob.perform_async(2)
-        }.should =~ [plain_sidekiq_job_id, job_id_1] * 6
+        }).to match_array([plain_sidekiq_job_id, job_id_1] * 6)
       end
     end
 
     def expect_2_jobs_ttl_covers(range)
-      range.should cover redis.ttl(plain_sidekiq_job_id)
-      range.should cover redis.ttl(job_id_1)
+      expect(range).to cover redis.ttl(plain_sidekiq_job_id)
+      expect(range).to cover redis.ttl(job_id_1)
     end
 
     def expect_2_jobs_are_done_and_status_eq(status)
-      redis.mget('NoStatusConfirmationJob_1', 'NoStatusConfirmationJob_2').should == %w(done)*2
-      Sidekiq::Status.status(plain_sidekiq_job_id).should == status
-      Sidekiq::Status.status(job_id_1).should == status
+      expect(redis.mget('NoStatusConfirmationJob_1', 'NoStatusConfirmationJob_2')).to eq(%w(done)*2)
+      expect(Sidekiq::Status.status(plain_sidekiq_job_id)).to eq(status)
+      expect(Sidekiq::Status.status(job_id_1)).to eq(status)
     end
   end
 

data/spec/spec_helper.rb

@@ -50,6 +50,7 @@ def start_server(server_middleware_options={})
     $stderr.reopen File::NULL, 'w'
     require 'sidekiq/cli'
     Sidekiq.options[:queues] << 'default'
+    Sidekiq.options[:require] =  File.expand_path('../support/test_jobs.rb', __FILE__)
     Sidekiq.configure_server do |config|
       config.redis = Sidekiq::RedisConnection.create
       config.server_middleware do |chain|
@@ -60,7 +61,6 @@ def start_server(server_middleware_options={})
   end
 
   yield
-
   sleep 0.1
   Process.kill 'TERM', pid
   Timeout::timeout(10) { Process.wait pid } rescue Timeout::Error

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sidekiq-status
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.1
 platform: ruby
 authors:
 - Evgeniy Tsvigun
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-09 00:00:00.000000000 Z
+date: 2014-08-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sidekiq
@@ -19,7 +19,7 @@ dependencies:
         version: '2.7'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '3.4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -29,7 +29,7 @@ dependencies:
         version: '2.7'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '3.4'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -122,4 +122,3 @@ test_files:
 - spec/lib/sidekiq-status_spec.rb
 - spec/spec_helper.rb
 - spec/support/test_jobs.rb
-has_rdoc: