rekiq 0.0.1

data/spec/rekiq/job_spec.rb

@@ -0,0 +1,400 @@
+require 'spec_helper'
+
+describe Rekiq::Job do
+  describe '#new' do
+    context 'when no args' do
+      before { @job = Rekiq::Job.new }
+
+      it 'returns an instance of Job' do
+        expect(@job).not_to be_nil
+      end
+
+      it 'sets attribute shift as 0' do
+        expect(@job.shift).to eq(0)
+      end
+
+      it 'sets reschedule_post_work as nil' do
+        expect(@job.reschedule_post_work).to eq(nil)
+      end
+
+      it 'sets schedule_expired as nil' do
+        expect(@job.schedule_expired).to eq(nil)
+      end
+    end
+
+    context 'when shift passed as argument' do
+      let(:shift) { 5 * 60 }
+      before do
+        @job = Rekiq::Job.new('shift' => shift)
+      end
+
+      it 'sets shift to passed value' do
+        expect(@job.shift).to eq(shift)
+      end
+    end
+
+    context 'when reschedule_post_work and ' \
+            'schedule_expired passed as true' do
+      let(:reschedule_post_work) { true }
+      let(:schedule_expired) { true }
+      before do
+        @job =
+          Rekiq::Job.new \
+            'reschedule_post_work' => reschedule_post_work,
+            'schedule_expired'     => schedule_expired
+      end
+
+      it 'sets reschedule_post_work to true' do
+        expect(@job.reschedule_post_work).to eq(true)
+      end
+
+      it 'sets schedule_expired to true' do
+        expect(@job.schedule_expired).to eq(true)
+      end
+    end
+  end
+
+  describe '#from_short_key_hash' do
+    context 'hash returned from Job#to_short_key_hash' do
+      let(:job)  { build(:job, :randomized_attributes) }
+      let(:hash) { job.to_short_key_hash }
+      before     { @job = Rekiq::Job.from_short_key_hash(hash) }
+
+      it 'returns job instance' do
+        expect(@job.class).to eq(Rekiq::Job)
+      end
+
+      it 'returns job with shift value before serialization' do
+        expect(@job.shift).to eq(job.shift)
+      end
+
+      it 'returns job with reschedule_post_work value before serialization' do
+        expect(@job.reschedule_post_work).to eq(job.reschedule_post_work)
+      end
+
+      it 'returns job with schedule_expired value before serialization' do
+        expect(@job.schedule_expired).to eq(job.schedule_expired)
+      end
+
+      it 'returns job with expiration_margin value before serialization' do
+        expect(@job.expiration_margin).to eq(job.expiration_margin)
+      end
+
+      it 'returns job with schedule value before serialization' do
+        expect(@job.schedule.class).to eq(job.schedule.class)
+      end
+
+      it 'returns job with working schedule' do
+        time = Time.now
+        expect(@job.schedule.next_occurrence(time)).to(
+          eq(job.schedule.next_occurrence(time))
+        )
+      end
+    end
+  end
+
+  describe '.to_short_key_hash' do
+    context 'given job instance' do
+      let(:job) { build(:job, :randomized_attributes) }
+      before { @val = job.to_short_key_hash }
+
+      it 'returns an hash' do
+        expect(@val.class).to eq(Hash)
+      end
+
+      it 'returns hash with key sft with shift value' do
+        expect(@val['sft']).to eq(job.shift)
+      end
+
+      it 'returns hash with key rpw with reschedule_post_work value' do
+        expect(@val['rpw']).to eq(job.reschedule_post_work)
+      end
+
+      it 'returns hash with key sh with schedule_expired value' do
+        expect(@val['se']).to eq(job.schedule_expired)
+      end
+
+      it 'returns hash with key em with expiration_margin value' do
+        expect(@val['em']).to eq(job.expiration_margin)
+      end
+
+      it 'returns hash with sch key with schedule serialized with YAML::dump' do
+        expect(@val['sch']).to eq(YAML::dump(job.schedule))
+      end
+    end
+  end
+
+  describe '#next_work_time' do
+    context 'non recurring schedule in future' do
+      let(:exceed_by)     { 10 * 60 }
+      let(:schedule_time) { Time.now + exceed_by }
+      let(:schedule)      { IceCube::Schedule.new(schedule_time) }
+
+      context 'schedule expired as true' do
+        let(:schedule_expired) { true }
+
+        context 'calculating from current time' do
+          let(:job) do
+            build(:job, schedule: schedule, schedule_expired: schedule_expired)
+          end
+          before { @next_work_time = job.next_work_time }
+
+          it 'return schedule time' do
+            expect(@next_work_time).to eq(schedule_time)
+          end
+        end
+
+        context 'shift to time between current and schedule time' do
+          let(:shift) { - exceed_by / 2 }
+
+          context 'calculating from current time' do
+            let(:job) do
+              build(:job,
+                    schedule: schedule,
+                    schedule_expired: schedule_expired,
+                    shift: shift)
+            end
+            before { @next_work_time = job.next_work_time }
+
+            it 'returns shifted schedule time' do
+              expect(@next_work_time).to eq(schedule_time + shift)
+            end
+          end
+        end
+
+        context 'shift to time after schedule time' do
+          let(:shift) { 60 }
+
+          context 'calculating from current time' do
+            let(:job) do
+              build(:job, schedule: schedule,
+                    schedule_expired: schedule_expired,
+                    shift: shift)
+            end
+            before { @next_work_time = job.next_work_time }
+
+            it 'returns shifted schedule time' do
+              expect(@next_work_time).to eq(schedule_time + shift)
+            end
+          end
+        end
+
+        context 'shift to time before current time' do
+          let(:shift) { - (schedule_time - Time.now + 60) }
+
+          context 'calculating from current time' do
+            let(:job) do
+              build(:job, schedule: schedule,
+                    schedule_expired: schedule_expired,
+                    shift: shift)
+            end
+            before { @next_work_time = job.next_work_time }
+
+            it 'returns shifted schedule time' do
+              expect(@next_work_time).to eq(schedule_time + shift)
+            end
+          end
+        end
+      end
+
+      context 'schedule expired as false' do
+        let(:schedule_expired)  { false }
+        let(:expiration_margin) { 10 * 60 }
+
+        context 'calculating from current time' do
+          let(:job) do
+            build(:job, schedule: schedule,
+                  schedule_expired: schedule_expired,
+                  expiration_margin: expiration_margin)
+          end
+          before { @next_work_time = job.next_work_time }
+
+          it 'returns schedule time' do
+            expect(@next_work_time).to eq(schedule_time)
+          end
+        end
+
+        context 'shift to time between current and schedule time' do
+          let(:shift) { - exceed_by / 2 }
+
+          context 'calculating from current time' do
+            let(:job) do
+              build(:job, schedule: schedule,
+                    schedule_expired: schedule_expired,
+                    expiration_margin: expiration_margin,
+                    shift: shift)
+            end
+            before { @next_work_time = job.next_work_time }
+
+            it 'returns shifted schedule time' do
+              expect(@next_work_time).to eq(schedule_time + shift)
+            end
+          end
+        end
+
+        context 'shift to time after schedule time' do
+          let(:shift) { 60 }
+
+          context 'calculating from current time' do
+            let(:job) do
+              build(:job, schedule: schedule,
+                    schedule_expired: schedule_expired,
+                    expiration_margin: expiration_margin,
+                    shift: shift)
+            end
+            before { @next_work_time = job.next_work_time }
+
+            it 'returns shifted schedule time' do
+              expect(@next_work_time).to eq(schedule_time + shift)
+            end
+          end
+        end
+
+        context 'shift to time inside expired margin' do
+          let(:shift) { - (schedule_time - Time.now + expiration_margin / 2) }
+
+          context 'calculating from current time' do
+            let(:job) do
+              build(:job, schedule: schedule,
+                    schedule_expired: schedule_expired,
+                    expiration_margin: expiration_margin,
+                    shift: shift)
+            end
+            before { @next_work_time = job.next_work_time }
+
+            it 'returns shifted schedule time' do
+              expect(@next_work_time).to eq(schedule_time + shift)
+            end
+          end
+        end
+
+        context 'shift to time before expired margin' do
+          let(:shift) { - (schedule_time - Time.now + expiration_margin * 2) }
+
+          context 'calculating from current time' do
+            let(:job) do
+              build(:job, schedule: schedule,
+                    schedule_expired: schedule_expired,
+                    expiration_margin: expiration_margin,
+                    shift: shift)
+            end
+            before { @next_work_time = job.next_work_time }
+
+            it 'returns nil' do
+              expect(@next_work_time).to be_nil
+            end
+          end
+        end
+      end
+    end
+
+    context 'non recurring expired schedule' do
+      let(:expired_by)    { 10 * 60 }
+      let(:schedule_time) { Time.now - expired_by }
+      let(:schedule)      { IceCube::Schedule.new(schedule_time) }
+
+      context 'schedule expired as true' do
+        let(:schedule_expired) { true }
+
+        context 'calculating from current time' do
+          let(:job) do
+              build(:job, schedule: schedule,
+                    schedule_expired: schedule_expired)
+          end
+          before { @next_work_time = job.next_work_time }
+
+          it 'returns nil' do
+            expect(@next_work_time).to be_nil
+          end
+        end
+
+        context 'calculating from before schedule time' do
+          let(:from) { schedule_time - 60 }
+          let(:job) do
+            build(:job, schedule: schedule,
+                  schedule_expired: schedule_expired)
+          end
+          before { @next_work_time = job.next_work_time(from) }
+
+          it 'returns schedule time' do
+            expect(@next_work_time).to eq(schedule_time)
+          end
+        end
+
+        context 'shift to after current time' do
+          let(:shift) { expired_by * 2 }
+
+          context 'calculating from current time' do
+            let(:job) do
+              build(:job, schedule: schedule,
+                    schedule_expired: schedule_expired,
+                    shift: shift)
+            end
+            before { @next_work_time = job.next_work_time }
+
+            it 'returns shifted schedule time' do
+              expect(@next_work_time).to eq(schedule_time + shift)
+            end
+          end
+        end
+      end
+
+      context 'schedule expired as false' do
+        let(:schedule_expired) { false }
+
+        context 'expiration margin as 0' do
+          let(:expiration_margin) { 0 }
+
+          context 'calculating from current time' do
+            let(:job) do
+              build(:job, schedule: schedule,
+                    schedule_expired: schedule_expired,
+                    expiration_margin: expiration_margin)
+            end
+            before { @next_work_time = job.next_work_time }
+
+            it 'returns nil' do
+              expect(@next_work_time).to be_nil
+            end
+          end
+        end
+
+        context 'expiration margin above expiration time' do
+          let(:expiration_margin) { expired_by * 2 }
+
+          context 'calculating from before schedule time' do
+            let(:from) { schedule_time - expiration_margin - 60 }
+            let(:job) do
+              build(:job, schedule: schedule,
+                    expiration_margin: expiration_margin,
+                    schedule_expired: schedule_expired)
+            end
+            before { @next_work_time = job.next_work_time(from) }
+
+            it 'returns schedule time' do
+              expect(@next_work_time).to eq(schedule_time)
+            end
+          end
+        end
+
+        context 'expiration margin above expiration time' do
+          let(:expiration_margin) { expired_by / 2 }
+
+          context 'calculating from before schedule time' do
+            let(:from) { schedule_time - expiration_margin - 60 }
+            let(:job) do
+              build(:job, schedule: schedule,
+                    expiration_margin: expiration_margin,
+                    schedule_expired: schedule_expired)
+            end
+            before { @next_work_time = job.next_work_time(from) }
+
+            it 'returns nil' do
+              expect(@next_work_time).to be_nil
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/rekiq/middleware/utils_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe Rekiq::Middleware::Utils do
+  class UtilsTestWorker
+    include Sidekiq::Worker
+  end
+
+  describe '#call' do
+    let(:worker) { UtilsTestWorker.new }
+    let(:queue)  { UtilsTestWorker.get_sidekiq_options['queue'] }
+    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 } }
+
+        it 'yields passed block' do
+          expect do |b|
+            Rekiq::Middleware::Utils.new
+              .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) {}
+
+          expect(worker.scheduled_work_time).to eq(scheduled_work_time.utc)
+        end
+      end
+
+      context 'msg has no key' do
+        let(:msg) { {} }
+
+        it 'yields passed block' do
+          expect do |b|
+            Rekiq::Middleware::Utils.new
+              .call(worker, msg, queue, &b)
+          end.to yield_control.once
+        end
+
+        it 'scheduled_work_time remaing unchanged' do
+          expect(worker.scheduled_work_time).to be_nil
+        end
+      end
+    end
+  end
+end

data/spec/rekiq/middleware/work_overseer_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe Rekiq::Middleware::WorkOverseer do
+  class WorkOverseerTestWorker
+    include Sidekiq::Worker
+
+    sidekiq_options queue: 'work_overseer_test_worker'
+  end
+
+  describe '#call' do
+    let(:worker)   { WorkOverseerTestWorker.new }
+    let(:queue)    { WorkOverseerTestWorker.get_sidekiq_options['queue'] }
+    let(:args)     { [] }
+    let(:schedule) { IceCube::Schedule.new(Time.new + 3600) }
+
+    context 'msg with rq:job key (existing job)' do
+      let(:job) { build(:job, schedule: schedule) }
+      let(:msg) { { 'rq:job' => job.to_short_key_hash, 'args' => args } }
+
+      it 'yields once' do
+        expect do |b|
+          Rekiq::Middleware::WorkOverseer.new
+            .call(worker, msg, queue, &b)
+        end.to yield_control.once
+      end
+
+      it 'schedules job' do
+        Rekiq::Middleware::WorkOverseer.new
+          .call(worker, msg, queue) {}
+
+        expect(WorkOverseerTestWorker.jobs.count).to eq(1)
+      end
+    end
+
+    context 'msg without rq:job key' do
+      let(:msg) { {} }
+
+      it 'yields once' do
+        expect do |b|
+          Rekiq::Middleware::WorkOverseer.new
+            .call(worker, msg, queue, &b)
+        end.to yield_control.once
+      end
+    end
+
+    context 'msg with job retry info and rq:job (existing job)' do
+      let(:job) { build(:job, schedule: schedule) }
+      let(:msg) { { 'rq:job' => job.to_short_key_hash, 'retry_count' => 0,
+                    'args' => args } }
+
+      it 'yields once' do
+        expect do |b|
+          Rekiq::Middleware::WorkOverseer.new
+            .call(worker, msg, queue, &b)
+        end.to yield_control.once
+      end
+
+      it 'does not schedule work' do
+        Rekiq::Middleware::WorkOverseer.new
+          .call(worker, msg, queue) {}
+
+        expect(WorkOverseerTestWorker.jobs.count).to eq(0)
+      end
+    end
+  end
+end

data/spec/rekiq/scheduler_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe Rekiq::Scheduler do
+  describe '#schedule' do
+    context 'given existing worker' do
+      class SchedulerTestWorker
+        include Sidekiq::Worker
+      end
+
+      let(:worker) { SchedulerTestWorker.name }
+      let(:queue)  { 'test_queue' }
+      let(:args)   { [] }
+
+      context 'given valid job' do
+        let(:job) { build(:job) }
+
+        context 'given not nil string as addon argument' do
+          let(:addon) { { 'random_key' => Time.now.to_f } }
+
+          context 'given initialized scheduler instance' do
+            let(:scheduler) do
+              Rekiq::Scheduler.new(worker, queue, args, job, addon)
+            end
+            before { @jid, @work_time = scheduler.schedule }
+
+            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
+        end
+
+        context 'give nil as addon argument' do
+          let(:addon) { nil }
+
+          context 'given initialized scheduler instance' do
+            let(:scheduler) do
+              Rekiq::Scheduler.new(worker, queue, args, job, addon)
+            end
+            before { @jid, @work_time = scheduler.schedule }
+
+            it 'creates sidekiq job' do
+              expect(SchedulerTestWorker.jobs.count).to eq(1)
+            end
+
+            it 'does not set key addon in msg' do
+              expect(SchedulerTestWorker.jobs[0].key?('addon')).to eq(false)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/rekiq/worker_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+require 'sidekiq'
+require 'rekiq/worker'
+
+describe Rekiq::Worker do
+  class ExampleWorker
+    include Sidekiq::Worker
+  end
+
+  context 'Class includes Sidekiq::Worker module' do
+    it 'responds to perform_recurringly' do
+      ExampleWorker.respond_to? :perform_recurringly
+    end
+
+    describe '.perform_recurringly' do
+      context 'scheduled one hour from now' do
+        let(:time)     { Time.now + 3600 }
+        let(:schedule) { IceCube::Schedule.new(time) }
+        before do
+          @jid = ExampleWorker.perform_recurringly(schedule)
+        end
+
+        it 'returns created jid' do
+          expect(@jid).not_to be_nil
+        end
+
+        it 'schedules worker' do
+          expect(ExampleWorker.jobs.count).to eq(1)
+        end
+
+        it 'schedules worker for one hour from now' do
+          expect(ExampleWorker.jobs[0]['at']).to eq(time.to_f)
+        end
+      end
+
+      context 'scheduled one hour from now ' \
+              'shift set to minus 5 minutes' do
+        let(:time)     { Time.now + 3600 }
+        let(:schedule) { IceCube::Schedule.new(time) }
+        let(:shift)    { -5 * 60 }
+        before do
+          @jid = ExampleWorker.perform_recurringly(schedule) do |options|
+              options.shift = shift
+            end
+        end
+
+        it 'returns created job id' do
+          expect(@jid).not_to be_nil
+        end
+
+        it 'schedules worker' do
+          expect(ExampleWorker.jobs.count).to eq(1)
+        end
+
+        it 'yields once' do
+          expect do |b|
+            ExampleWorker.perform_recurringly(schedule, &b)
+          end.to yield_control.once
+        end
+
+        it 'sets shift in job' do
+          hash = ExampleWorker.jobs[0]['rq:job']
+
+          expect(hash['sft']).to eq(shift)
+        end
+
+        it 'schedules worker for one hour minus 5 minutes from now' do
+          expect(ExampleWorker.jobs[0]['at']).to eq(time.to_f + shift)
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,35 @@
+if ENV['CODECLIMATE_REPO_TOKEN'].nil?
+  require 'simplecov'
+  SimpleCov.start do
+    coverage_dir 'tmp/coverage'
+  end
+else
+  require "codeclimate-test-reporter"
+  CodeClimate::TestReporter.start
+end
+
+require 'factory_girl'
+require 'pry'
+require 'sidekiq'
+require 'sidekiq/testing'
+require 'rekiq'
+
+# configure sidekiq for testing
+Sidekiq::Testing.fake!
+Sidekiq::Logging.logger = nil
+
+RSpec.configure do |config|
+  config.include FactoryGirl::Syntax::Methods
+
+  config.before(:each) do
+    Sidekiq::Worker.clear_all
+  end
+
+  config.after(:suite) do
+    Sidekiq::Worker.clear_all
+  end
+end
+
+# configure factory girl
+FactoryGirl.definition_file_paths = %w{./spec/factories}
+FactoryGirl.find_definitions