rekiq 0.9.3 → 1.0.0

data/spec/rekiq/contract_spec.rb

@@ -0,0 +1,309 @@
+require 'spec_helper'
+
+describe Rekiq::Contract do
+  describe '.new' do
+    context 'when no args' do
+      before { @contract = Rekiq::Contract.new }
+
+      it 'returns an instance of Contract' do
+        expect(@contract).not_to be_nil
+      end
+
+      it 'sets attribute work_time_shift as nil' do
+        expect(@contract.work_time_shift).to eq(nil)
+      end
+
+      it 'sets schedule_post_work as nil' do
+        expect(@contract.schedule_post_work).to eq(nil)
+      end
+
+      it 'sets schedule_expired as nil' do
+        expect(@contract.schedule_expired).to eq(nil)
+      end
+    end
+
+    context 'when work_time_shift passed as argument' do
+      let(:work_time_shift) { 5 * 60 }
+      before do
+        @contract = Rekiq::Contract.new('work_time_shift' => work_time_shift)
+      end
+
+      it 'sets work_time_shift to passed value' do
+        expect(@contract.work_time_shift).to eq(work_time_shift)
+      end
+    end
+
+    context 'when schedule_post_work and ' \
+            'schedule_expired passed as true' do
+      let(:schedule_post_work) { true }
+      let(:schedule_expired)   { true }
+      before do
+        @contract =
+          Rekiq::Contract.new \
+            'schedule_post_work' => schedule_post_work,
+            'schedule_expired'   => schedule_expired
+      end
+
+      it 'sets schedule_post_work to true' do
+        expect(@contract.schedule_post_work).to eq(true)
+      end
+
+      it 'sets schedule_expired to true' do
+        expect(@contract.schedule_expired).to eq(true)
+      end
+    end
+  end
+
+  describe '.to_hash' do
+    context 'given an hash returned from Contract#to_hash' do
+      let(:original_contract) { build(:contract, :randomized_attributes) }
+      let(:hash) { original_contract.to_hash }
+      before     { @contract = Rekiq::Contract.from_hash(hash) }
+
+      it 'returns contract instance' do
+        expect(@contract.class).to eq(Rekiq::Contract)
+      end
+
+      it 'returns contract with cancel_args value before serialization' do
+        expect(@contract.cancel_args).to eq(original_contract.cancel_args)
+      end
+
+      it 'returns contract with addon value before serialization' do
+        expect(@contract.addon).to eq(original_contract.addon)
+      end
+
+      it 'returns contract with work_time_shift value before serialization' do
+        expect(@contract.work_time_shift).to eq(original_contract.work_time_shift)
+      end
+
+      it 'returns contract with schedule_post_work value before serialization' do
+        expect(@contract.schedule_post_work).to eq(original_contract.schedule_post_work)
+      end
+
+      it 'returns contract with schedule_expired value before serialization' do
+        expect(@contract.schedule_expired).to eq(original_contract.schedule_expired)
+      end
+
+      it 'returns contract with work_time_tolerance value before serialization' do
+        expect(@contract.work_time_tolerance).to eq(original_contract.work_time_tolerance)
+      end
+
+      it 'returns contract with schedule value before serialization' do
+        expect(@contract.schedule.class).to eq(original_contract.schedule.class)
+      end
+
+      it 'returns contract with working schedule' do
+        time = Time.now
+        expect(@contract.schedule.next_occurrence(time))
+          .to eq(original_contract.schedule.next_occurrence(time))
+      end
+    end
+  end
+
+  describe '#to_hash' do
+    context 'given contract instance' do
+      let(:contract) { build(:contract, :randomized_attributes) }
+      before         { @val = contract.to_hash }
+
+      it 'returns an hash' do
+        expect(@val.class).to eq(Hash)
+      end
+
+      it 'returns hash with Marshalled schedule under key s' do
+        # TODO: expect(@val[0]).to eq(Marshal.dump(contract.schedule))
+      end
+
+      it 'returns hash with cancel_args under key ca' do
+        expect(@val['ca']).to eq(contract.cancel_args)
+      end
+
+      it 'returns hash with addon value under key ao' do
+        expect(@val['ao']).to eq(contract.addon)
+      end
+
+      it 'returns hash with schedule_post_work value under key pw' do
+        expect(@val['pw']).to eq(contract.schedule_post_work)
+      end
+
+      it 'returns hash with work_time_shift value under key ws' do
+        expect(@val['ws']).to eq(contract.work_time_shift)
+      end
+
+      it 'returns hash with work_time_tolerance value under key wt' do
+        expect(@val['wt']).to eq(contract.work_time_tolerance)
+      end
+
+      it 'returns hash with schedule_expired value under key se' do
+        expect(@val['se']).to eq(contract.schedule_expired)
+      end
+    end
+  end
+
+  describe '#initial_work_time' do
+    context 'when invoked with current_time' do
+      let(:current_time)        { Time.now }
+      let(:work_time_shift)     { nil }
+      let(:work_time_tolerance) { nil }
+      let(:schedule_rrule)      { nil }
+      let(:schedule) do
+        IceCube::Schedule.new(start_time) do |s|
+          s.rrule(schedule_rrule) unless schedule_rrule.nil?
+        end
+      end
+      let(:contract) do
+        build :contract,
+              schedule:            schedule,
+              work_time_shift:     work_time_shift,
+              work_time_tolerance: work_time_tolerance,
+              schedule_expired:    schedule_expired
+      end
+      before { @work_time = contract.initial_work_time(current_time) }
+
+      context 'with non recurring schedule with start_time in future' do
+        let(:exceed_by)    { 10 * 60 }
+        let(:start_time)   { current_time + exceed_by }
+
+        context 'schedule_expired as true' do
+          let(:schedule_expired)    { true }
+
+          it 'returns start_time' do
+            expect(@work_time).to eq(start_time)
+          end
+
+          context 'work_time_shift to time between current and start_time' do
+            let(:work_time_shift) { - exceed_by / 2 }
+
+            it 'returns shifted start_time' do
+              expect(@work_time).to eq(start_time + work_time_shift)
+            end
+          end
+
+          context 'work_time_shift to time after start_time' do
+            let(:work_time_shift) { exceed_by * 2 }
+
+            it 'returns shifted start_time' do
+              expect(@work_time).to eq(start_time + work_time_shift)
+            end
+          end
+
+          context 'work_time_shift to time before current_time' do
+            let(:work_time_shift) { - (exceed_by + 60) }
+
+            it 'returns shifted start_time' do
+              expect(@work_time).to eq(start_time + work_time_shift)
+            end
+          end
+        end
+
+        context 'schedule expired as false' do
+          let(:schedule_expired) { false }
+
+          it 'returns start_time' do
+            expect(@work_time).to eq(start_time)
+          end
+
+          context 'work_time_shift to time between current and start_time' do
+            let(:work_time_shift) { - exceed_by / 2 }
+
+            it 'returns shifted start_time' do
+              expect(@work_time).to eq(start_time + work_time_shift)
+            end
+          end
+
+          context 'work_time_shift to time after start_time' do
+            let(:work_time_shift) { 60 }
+
+            it 'returns shifted start_time' do
+              expect(@work_time).to eq(start_time + work_time_shift)
+            end
+          end
+
+          context 'work_time_shift to time before current' do
+            let(:work_time_shift) { - (exceed_by + 60) }
+
+            it 'returns nil' do
+              expect(@work_time).to be_nil
+            end
+          end
+
+          context 'work_time_tolerance as 10 minutes' do
+            let(:work_time_tolerance) { 10 * 60 }
+
+            it 'returns start_time' do
+              expect(@work_time).to eq(start_time)
+            end
+
+            context 'work_time_shift to time between current and start_time' do
+              let(:work_time_shift) { - exceed_by / 2 }
+
+              it 'returns shifted start_time' do
+                expect(@work_time).to eq(start_time + work_time_shift)
+              end
+            end
+
+            context 'work_time_shift to time after start_time' do
+              let(:work_time_shift) { 60 }
+
+              it 'returns shifted start_time' do
+                expect(@work_time).to eq(start_time + work_time_shift)
+              end
+            end
+
+            context 'work_time_shift to time inside work_time_tolerance' do
+              let(:work_time_shift) { - (exceed_by + work_time_tolerance / 2) }
+
+              it 'returns shifted start_time' do
+                expect(@work_time).to eq(start_time + work_time_shift)
+              end
+            end
+
+            context 'work_time_shift to time before work_time_tolerance' do
+              let(:work_time_shift) { - (exceed_by + work_time_tolerance * 2) }
+
+              it 'returns nil' do
+                expect(@work_time).to be_nil
+              end
+            end
+          end
+        end
+      end
+
+      context 'non recurring schedule with start_time bellow current_time' do
+        let(:expired_by) { 10 * 60 }
+        let(:start_time) { current_time - expired_by }
+
+        context 'schedule expired as true' do
+          let(:schedule_expired) { true }
+
+          it 'returns nil' do
+            expect(@work_time).to be_nil
+          end
+
+          context 'work_time_shift to time after current_time' do
+            let(:work_time_shift) { expired_by * 2 }
+
+            it 'returns shifted start_time' do
+              expect(@work_time).to eq(start_time + work_time_shift)
+            end
+          end
+        end
+
+        context 'schedule_expired as false' do
+          let(:schedule_expired) { false }
+
+          it 'returns nil' do
+            expect(@work_time).to be_nil
+          end
+
+          context 'work_time_tolerance is above calculated expired work_time' do
+            let(:work_time_tolerance) { expired_by * 2 }
+
+            it 'returns start_time' do
+              expect(@work_time).to eq(start_time)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/rekiq/middleware/utils_spec.rb

@@ -8,22 +8,21 @@ describe Rekiq::Middleware::Utils do
   describe '#call' do
     let(:worker) { UtilsTestWorker.new }
     let(:queue)  { UtilsTestWorker.get_sidekiq_options['queue'] }
+    let(:utils)  { Rekiq::Middleware::Utils.new }
     let(:scheduled_work_time) { Time.at(Time.now.to_f) }
 
     context 'worker responds to scheduled_work_time' do
-      context 'msg hash has rq:at key with value Time' do
-        let(:msg) { { 'rq:at' => scheduled_work_time.to_f } }
+      context 'msg hash contains keys rq:ctr and rq:at' do
+        let(:msg) { { 'rq:ctr' => nil, 'rq:at' => scheduled_work_time.to_f } }
 
         it 'yields passed block' do
           expect do |b|
-            Rekiq::Middleware::Utils.new
-              .call(worker, msg, queue, &b)
+            utils.call(worker, msg, queue, &b)
           end.to yield_control.once
         end
 
         it 'sets scheduled_work_time attribute in worker' do
-          Rekiq::Middleware::Utils.new
-            .call(worker, msg, queue) {}
+          utils.call(worker, msg, queue) {}
 
           expect(worker.scheduled_work_time).to eq(scheduled_work_time.utc)
         end
@@ -34,12 +33,11 @@ describe Rekiq::Middleware::Utils do
 
         it 'yields passed block' do
           expect do |b|
-            Rekiq::Middleware::Utils.new
-              .call(worker, msg, queue, &b)
+            utils.call(worker, msg, queue, &b)
           end.to yield_control.once
         end
 
-        it 'scheduled_work_time remaing unchanged' do
+        it 'scheduled_work_time is unchanged (nil)' do
           expect(worker.scheduled_work_time).to be_nil
         end
       end

data/spec/rekiq/middleware/work_overseer_spec.rb

@@ -19,19 +19,22 @@ describe Rekiq::Middleware::WorkOverseer do
   end
 
   describe '#call' do
-    let(:args)     { [] }
-    let(:schedule) { IceCube::Schedule.new(Time.new + 3600) }
-    let(:job)      { build(:job, schedule: schedule) }
-    let(:overseer) { Rekiq::Middleware::WorkOverseer.new }
+    let(:args)        { [] }
+    let(:schedule)    { IceCube::Schedule.new(Time.new + 3600) }
+    let(:overseer)    { Rekiq::Middleware::WorkOverseer.new }
+    let(:cancel_args) { nil }
+    let(:contract) do
+      build :contract, schedule: schedule, cancel_args: cancel_args
+    end
 
-    context 'worker does not have rekiq_cancel_method set' do
-      let(:worker)   { WorkOverseerTestWorker.new }
-      let(:queue)    { WorkOverseerTestWorker.get_sidekiq_options['queue'] }
+    context 'worker without rekiq_cancel_method configured' do
+      let(:worker) { WorkOverseerTestWorker.new }
+      let(:queue)  { WorkOverseerTestWorker.get_sidekiq_options['queue'] }
 
-      context 'msg with rq:job key (existing job), ' \
-              'with rq:schdlr key (value is irrelevant)' do
+      context 'msg with rq:ctr key (existing contract), ' \
+              'with rq:sdl key (value is irrelevant)' do
         let(:msg) do
-          { 'rq:job' => job.to_array, 'args' => args, 'rq:schdlr' => nil }
+          { 'rq:ctr' => contract.to_hash, 'args' => args, 'rq:sdl' => nil }
         end
 
         it 'yields once' do
@@ -40,20 +43,20 @@ describe Rekiq::Middleware::WorkOverseer do
           end.to yield_control.once
         end
 
-        it 'schedules job' do
+        it 'schedules worker' do
           overseer.call(worker, msg, queue) {}
 
           expect(WorkOverseerTestWorker.jobs.count).to eq(1)
         end
 
-        it 'removes key rq:schdlr from message after invocation' do
+        it 'removes key rq:sdl from message after invocation' do
           overseer.call(worker, msg, queue) {}
 
-          expect(msg.key?('rq:schdlr')).to eq(false)
+          expect(msg.key?('rq:sdl')).to eq(false)
         end
       end
 
-      context 'msg without rq:job key' do
+      context 'msg without rq:ctr key' do
         let(:msg) { {} }
 
         it 'yields once' do
@@ -61,10 +64,16 @@ describe Rekiq::Middleware::WorkOverseer do
             overseer.call(worker, msg, queue, &b)
           end.to yield_control.once
         end
+
+        it 'does not schedule worker' do
+          overseer.call(worker, msg, queue) {}
+
+          expect(WorkOverseerTestWorker.jobs.count).to eq(0)
+        end
       end
 
-      context 'msg without rq:schdlr and rq:job (existing job)' do
-        let(:msg) { { 'rq:job' => job.to_array, 'args' => args } }
+      context 'msg without key rq:sdl but with key rq:ctr' do
+        let(:msg) { { 'rq:ctr' => contract.to_hash, 'args' => args } }
 
         it 'yields once' do
           expect do |b|
@@ -80,51 +89,64 @@ describe Rekiq::Middleware::WorkOverseer do
       end
     end
 
-    context 'worker has rekiq_cancel_method method set' do
+    context 'worker with rekiq_cancel_method configured' do
       let(:worker) { WorkOverseerCancelTestWorker.new }
       let(:queue)  { WorkOverseerCancelTestWorker.get_sidekiq_options['queue'] }
 
-      context 'msg with rq:ca key with value to cancel worker' do
+      context 'msg with keys rc:ctr and rc:sdl' do
         let(:msg) do
-          { 'rq:job' => job.to_array, 'args' => args, 'rq:ca' => true }
+          { 'rq:ctr' => contract.to_hash, 'args' => args, 'rq:sdl' => nil }
         end
 
-        it 'does not yield' do
-          expect do |b|
-            overseer.call(worker, msg, queue, &b)
-          end.not_to yield_control
-        end
+        context 'work is cancelled by cancel method' do
+          let(:cancel_args) { true }
 
-        it 'does not schedule worker' do
-          expect(WorkOverseerCancelTestWorker.jobs.count).to eq(0)
-        end
-      end
+          it 'does not yield' do
+            expect do |b|
+              overseer.call(worker, msg, queue, &b)
+            end.not_to yield_control
+          end
 
-      context 'msg with rq:ca key with value that does not cancel worker' do
-        let(:msg) do
-          { 'rq:job' => job.to_array, 'args' => args, 'rq:ca' => false }
-        end
+          it 'does not schedule next work' do
+            overseer.call(worker, msg, queue) {}
 
-        it 'yields given block' do
-          expect do |b|
-            overseer.call(worker, msg, queue, &b)
-          end.to yield_control.once
+            expect(WorkOverseerCancelTestWorker.jobs.count).to eq(0)
+          end
         end
 
-        it 'does not schedule worker' do
-          expect(WorkOverseerCancelTestWorker.jobs.count).to eq(0)
-        end
-      end
+        context 'work is not cancelled by cancel method' do
+          let(:cancel_args) { false }
 
-      context 'msg with rq:ca key with different arity from cancel method' do
-        let(:msg) do
-          { 'rq:job' => job.to_array, 'args' => args, 'rq:ca' => [true, true] }
+          it 'yields given block' do
+            expect do |b|
+              overseer.call(worker, msg, queue, &b)
+            end.to yield_control.once
+          end
+
+          it 'it schedules work' do
+            overseer.call(worker, msg, queue) {}
+
+            expect(WorkOverseerCancelTestWorker.jobs.count).to eq(1)
+          end
+
+          it 'removes key rq:sdl from message after invocation' do
+            overseer.call(worker, msg, queue) {}
+
+            expect(msg.key?('rq:sdl')).to eq(false)
+          end
         end
 
-        it 'raises error' do
-          expect do |b|
-            overseer.call(worker, msg, queue, &b)
-          end.to raise_error
+        context 'contract with incorrect arity of cancel_args' do
+          let(:cancel_args) { [true, false] }
+          let(:msg) do
+            { 'rq:ctr' => contract.to_hash, 'args' => args }
+          end
+
+          it 'raises error' do
+            expect do |b|
+              overseer.call(worker, msg, queue, &b)
+            end.to raise_error
+          end
         end
       end
     end

data/spec/rekiq/scheduler_spec.rb

@@ -1,75 +1,27 @@
 require 'spec_helper'
 
 describe Rekiq::Scheduler do
-  describe '#schedule' do
+  describe '#schedule_initial_work' do
     context 'given existing worker' do
       class SchedulerTestWorker
         include Sidekiq::Worker
       end
 
-      let(:worker) { SchedulerTestWorker.name }
-      let(:queue)  { 'test_queue' }
-      let(:args)   { [] }
-      let(:addon)  { nil }
-      let(:c_args) { nil }
+      let(:worker_name) { SchedulerTestWorker.name }
+      let(:queue) { 'test_queue' }
+      let(:args)  { [] }
       let(:scheduler) do
-        Rekiq::Scheduler.new(worker, queue, args, job, addon, c_args)
+        Rekiq::Scheduler.new(worker_name, queue, args, contract)
       end
-      before { @jid, @work_time = scheduler.schedule }
+      before { @jid, @work_time = scheduler.schedule_initial_work }
 
-      context 'given valid job' do
-        let(:job) { build(:job) }
-
-        context 'give nil as addon argument' do
-          it 'creates sidekiq job' do
-            expect(SchedulerTestWorker.jobs.count).to eq(1)
-          end
-
-          it 'does not set key rq:addon in msg' do
-            expect(SchedulerTestWorker.jobs[0].key?('rq:addon')).to eq(false)
-          end
-        end
-
-        context 'given not nil string as addon argument' do
-          let(:addon) { { 'random_key' => Time.now.to_f } }
-
-          it 'creates sidekiq job' do
-            expect(SchedulerTestWorker.jobs.count).to eq(1)
-          end
-
-          it 'add key rq:addon in msg' do
-            expect(SchedulerTestWorker.jobs[0].key?('rq:addon')).to eq(true)
-          end
-
-          it 'sets addon value in key rq:addon' do
-            expect(SchedulerTestWorker.jobs[0]['rq:addon']).to eq(addon)
-          end
-        end
+      context 'given valid contract' do
+        let(:contract) { build :contract }
 
         context 'given nil as rekiq_cancel_args' do
           it 'creates sidekiq job' do
             expect(SchedulerTestWorker.jobs.count).to eq(1)
           end
-
-          it 'does not set key rq:ca in msg' do
-            expect(SchedulerTestWorker.jobs[0].key?('rq:ca')).to eq(false)
-          end
-        end
-
-        context 'given non empty array as rekiq_cancel_args' do
-          let(:c_args) { [1, 2, 3] }
-
-          it 'creates sidekiq job' do
-            expect(SchedulerTestWorker.jobs.count).to eq(1)
-          end
-
-          it 'sets key rq:ca in msg' do
-            expect(SchedulerTestWorker.jobs[0].key?('rq:ca')).to eq(true)
-          end
-
-          it 'sets key rq:ca in msg with passed value' do
-            expect(SchedulerTestWorker.jobs[0]['rq:ca']).to eq(c_args)
-          end
         end
       end
     end