ctt-background-jobs 0.8.0

data/lib/background_jobs/strategies/sidekiq/job_queue.rb

@@ -0,0 +1,42 @@
+require 'sidekiq'
+require 'background_jobs/job_registry'
+require 'background_jobs/strategies/sidekiq/job_adapter'
+require 'background_jobs/strategies/sidekiq/job_attributes_adapter'
+
+module BackgroundJobs
+  module Sidekiq
+    class JobQueue
+
+      def enqueue(job_type, job_id, attributes, options = {})
+        priority = options[:priority] || 1
+        unique = options[:unique] || false
+        at = (Time.now + options[:in]).to_i if options[:in]
+
+        return if unique && is_scheduled?(job_type)
+
+        queue = BackgroundJobs.job_registry.get_type(job_type)
+        attributes.unshift job_id
+        attributes.unshift job_type
+
+        args = {
+          'queue' => queue.to_s, # queue by priority?
+          'class' => JobAdapter,
+          'args' => JobAttributesAdapter.new(attributes).encode
+        }
+
+        args['at'] = at if at
+
+        ::Sidekiq::Client.push(args)
+      end
+
+      private
+
+      def is_scheduled?(job_name)
+        entries = ::Sidekiq::ScheduledSet.new.entries
+        job_names = entries.map(&:item).map {|item| item['args'].first }
+
+        job_names.include?(job_name.to_s)
+      end
+    end
+  end
+end

data/lib/background_jobs/strategies/sidekiq/setup.rb

@@ -0,0 +1,31 @@
+require 'sidekiq'
+require 'background_jobs/job_registry'
+
+module BackgroundJobs
+  module Sidekiq
+    def self.setup(options)
+      ::Sidekiq.configure_server do |config|
+        config.redis = options[:redis] if options[:redis]
+      end
+
+      BackgroundJobs.job_registry.register_callback = method(:register_job_callback)
+    end
+
+    def self.register_job_callback(job_metadata)
+      options = job_metadata.options
+
+      BackgroundJobs::QueueService.enqueue(
+        job_metadata.name, [], :in => options[:schedule], :unique => true
+      ) if options[:schedule]
+    end
+
+    private
+
+    def self.is_scheduled?(job_name)
+      entries = ::Sidekiq::ScheduledSet.new.entries
+      job_names = entries.map(&:item).map {|item| item['args'].first }
+
+      job_names.include?(job_name.to_s)
+    end
+  end
+end

data/lib/version.rb

@@ -0,0 +1,3 @@
+module BackgroundJobs
+  VERSION = '0.8.0'
+end

data/spec/fast_helper.rb

@@ -0,0 +1,11 @@
+# This file is copied to spec/ when you run 'rails generate rspec:install'
+ENV["RAILS_ENV"] ||= 'test'
+
+require 'rspec'
+require 'shoulda'
+require 'require_relative'
+require 'timecop'
+
+RSpec.configure do |config|
+  config.mock_with :mocha
+end

data/spec/integration/sidekiq_spec.rb

@@ -0,0 +1,34 @@
+require 'fast_helper'
+require 'background_jobs/configuration'
+require 'background_jobs/queue_service'
+require 'background_jobs/strategies/sidekiq/setup'
+
+describe 'Sidekiq' do
+
+  let(:sidekiq_fake_job) { Class.new }
+
+  let(:clock) { stub('clock') }
+  let(:clock_schedule) { stub('clock_schedule') }
+
+  before do
+    BackgroundJobs.configure do |config|
+      config.strategy = 'sidekiq'
+    end
+  end
+
+  context 'with schedule' do
+    let(:scheduled_set) { stub('scheduled_set') }
+
+    it 'should schedule the job if schedule is set' do
+      BackgroundJobs::QueueService.expects(:enqueue).with(:fake_job, [], :in => 60*10, :unique => true)
+
+      BackgroundJobs.register_job :fake_job, :core, sidekiq_fake_job, :schedule => 60*10
+    end
+  end
+
+  it 'should not schedule the job if schedule not set' do
+    BackgroundJobs::QueueService.expects(:enqueue).never
+
+    BackgroundJobs.register_job :fake_job, :core, sidekiq_fake_job
+  end
+end

data/spec/lib/background_jobs/configuration_spec.rb

@@ -0,0 +1,13 @@
+require 'fast_helper'
+require 'background_jobs/configuration'
+
+module BackgroundJobs
+  describe Configuration do
+    describe '#strategy' do
+      context 'with env configuration set' do
+        before { BackgroundJobs.configure {|c| c.strategy = 'foo' } }
+        it { BackgroundJobs.config.strategy.should == 'foo' }
+      end
+    end
+  end
+end

data/spec/lib/background_jobs/job_factory_fast_spec.rb

@@ -0,0 +1,24 @@
+require 'fast_helper'
+require 'background_jobs/job_factory'
+
+module BackgroundJobs
+  describe JobFactory do
+    before do
+      BackgroundJobs.register_job :foo, :bar, Imitate.mock('Foo')
+    end
+
+    describe '.build' do
+      context 'for existing job' do
+        it 'should create job instance' do
+          JobFactory.build(:foo).should be_instance_of Foo
+        end
+      end
+
+      context 'for not-existing job' do
+        it 'should throw an exception' do
+          expect { JobFactory.build(:not_existing_job) }.to raise_error("Unknown job 'not_existing_job'!")
+        end
+      end
+    end
+  end
+end

data/spec/lib/background_jobs/job_fast_spec.rb

@@ -0,0 +1,38 @@
+require 'fast_helper'
+require 'background_jobs/job'
+
+describe BackgroundJobs::Job do
+  before do
+    Imitate.mock 'Airbrake' do
+      def self.notify(param); end
+    end
+  end
+
+  let(:job) { BackgroundJobs::Job.new }
+
+  subject { job }
+
+  describe '#perform' do
+    it { expect { subject.perform }.to raise_error NotImplementedError }
+  end
+
+  describe '#id=' do
+    before { job.id = 123 }
+
+    it { subject.instance_variable_get(:@id).should eq 123 }
+  end
+
+  describe '#execute' do
+    it { expect { subject.execute }.to raise_error NotImplementedError }
+  end
+
+  describe 'error' do
+    let(:exception) { stub('exception') }
+
+    before do
+      Airbrake.expects(:notify).with(exception)
+    end
+
+    it { job.error('whatever', exception) }
+  end
+end

data/spec/lib/background_jobs/job_id_generator_fast_spec.rb

@@ -0,0 +1,23 @@
+require 'fast_helper'
+require 'background_jobs/job_id_generator'
+require 'imitate'
+
+describe BackgroundJobs::JobIdGenerator do
+  let(:generator) do
+    Imitate.mock('Generator') do
+      include BackgroundJobs::JobIdGenerator
+    end
+  end
+
+  describe '.generate' do
+    let(:result1) { generator.generate_job_id }
+    let(:result2) { generator.generate_job_id }
+    let(:result3) { generator.generate_job_id }
+
+    subject { result1 }
+
+    it { should_not == result2 }
+    it { should_not == result3 }
+    it(:result2) { should_not == result3 }
+  end
+end

data/spec/lib/background_jobs/job_notififer_spec.rb

@@ -0,0 +1,9 @@
+require 'fast_helper'
+require 'background_jobs/job_notifier'
+
+describe BackgroundJobs::JobNotifier do
+
+  let(:job) { stub('job').tap {|j| j.extend BackgroundJobs::JobNotifier } }
+
+  it { should be }
+end

data/spec/lib/background_jobs/job_queue_factory_fast_spec.rb

@@ -0,0 +1,58 @@
+require 'fast_helper'
+require 'background_jobs/job_queue_factory'
+require 'background_jobs/strategies/sidekiq/job_queue'
+require 'background_jobs/strategies/direct_call/job_queue'
+
+module BackgroundJobs
+  describe JobQueueFactory do
+    describe '.build' do
+      subject { JobQueueFactory.build }
+
+      context 'sidekiq' do
+        before { configure_strategy('sidekiq', options) }
+
+        let(:sidekiq_job_queue) { stub('sidekiq_job_queue') }
+
+        let(:options) { stub('options') }
+
+        it { 
+          Sidekiq::JobQueue.expects(:new).returns(sidekiq_job_queue)
+          JobQueueFactory.build.should == sidekiq_job_queue 
+        }
+
+        after { clear_job_queue_strategy }
+      end
+
+      context 'direct_call' do
+        before { configure_strategy('direct_call') }
+
+        it { should be_instance_of DirectCall::JobQueue }
+
+        after { clear_job_queue_strategy }
+      end
+
+      context 'with no strategy configured' do
+        before { clear_job_queue_strategy  }
+
+        it "will blow up" do
+          expect {
+            JobQueueFactory.build 
+          }.to raise_exception UnknownBackgroundJobsQueueStrategy
+        end
+
+        after { configure_strategy('delayed_job') }
+      end
+    end
+  end
+end
+
+def clear_job_queue_strategy
+  configure_strategy nil
+end
+
+def configure_strategy(name, options = {})
+  BackgroundJobs.configure do |config|
+    config.strategy = name
+    config.strategy_options = options
+  end
+end

data/spec/lib/background_jobs/queue_service_fast_spec.rb

@@ -0,0 +1,36 @@
+require 'fast_helper'
+require 'background_jobs/queue_service'
+
+module BackgroundJobs
+  describe QueueService do
+    let(:job_type) { :fix_all_bugs_while_we_sleep }
+
+    let(:priority) { 1 }
+
+    let(:data) { [1, 2, 3, 'foo', {1 => :uno}] }
+
+    let(:job_id) { 'job_id' }
+
+    let(:expected_queue_params) { data }
+
+    let(:strategy) { stub('strategy') }
+
+    describe '.enqueue' do
+      let(:delay) { stub('delay') }
+
+      before do
+        QueueService.stubs(:generate_job_id).returns(job_id)
+
+        JobQueueFactory.expects(:build).returns(strategy)
+
+        strategy.expects(:enqueue).with(
+          job_type, job_id, expected_queue_params, :priority => priority, :in => delay
+        )
+      end
+
+      subject { QueueService.enqueue(job_type, data, :priority => priority, :in => delay) }
+
+      it { should == job_id }
+    end
+  end
+end

data/spec/lib/background_jobs/strategies/direct_call/job_queue_spec.rb

@@ -0,0 +1,27 @@
+require 'fast_helper'
+require 'background_jobs/strategies/direct_call/job_queue'
+
+module BackgroundJobs
+  module DirectCall
+    describe JobQueue.new do
+      let(:type) { :foo }
+
+      let(:priority) { 1 }
+
+      let(:attrs) { [10..10, :foo => :bar] }
+
+      let(:job) { stub('job') }
+
+      let(:job_id) { 123 }
+
+      describe '.enqueue' do
+        it 'should create a job and execute it' do
+          JobFactory.expects(:build).with(type, attrs).returns(job)
+          job.expects(:execute)
+
+          JobQueue.new.enqueue(type, job_id, attrs)
+        end
+      end
+    end
+  end
+end

data/spec/lib/background_jobs/strategies/sidekiq/job_adapter_spec.rb

@@ -0,0 +1,30 @@
+require 'fast_helper'
+require 'background_jobs/strategies/sidekiq/job_queue'
+
+module BackgroundJobs
+  module Sidekiq
+    describe JobAdapter.new do
+      let(:job) { stub('job', :execute => true) }
+
+      describe '#peform' do
+        subject { JobAdapter.new.perform('foo', '1', :bar, :baz, 'range:[10,1000]') }
+        
+        before { JobFactory.stubs(:build).returns(job) }
+
+        it 'should call job factory with appropriate job type and attributes' do
+          JobFactory.expects(:build).with(:foo, [:bar, :baz, 10..1000]).returns(job)
+          job.expects(:id=).with(1)
+
+          subject
+        end
+
+        it 'should call job perform with no attributes' do
+          job.expects(:execute)
+          job.expects(:id=).with(1)
+
+          subject
+        end
+      end
+    end
+  end
+end

data/spec/lib/background_jobs/strategies/sidekiq/job_attributes_adapter_spec.rb

@@ -0,0 +1,129 @@
+require 'fast_helper'
+require 'background_jobs/strategies/sidekiq/job_attributes_adapter'
+
+module BackgroundJobs
+  module Sidekiq
+    describe JobAttributesAdapter do
+      context 'date' do
+        let(:attributes) { [Date.parse('1st Jan 2011')] }
+        let(:attributes_encoded) { ['date:2011-01-01'] }
+
+        it 'does decode to string with "date:"" prefix' do
+          JobAttributesAdapter.new(attributes_encoded).decode.should eq attributes
+        end
+
+        it 'does encode to string with "date:"" prefix' do
+          JobAttributesAdapter.new(attributes).encode.should eq attributes_encoded
+        end
+      end
+
+      context 'date range' do
+        let(:attributes) { [Date.parse('1st Jan 2011')..Date.parse('1st Feb 2011')] }
+        let(:attributes_encoded) { ['range:[date:2011-01-01,date:2011-02-01]'] }
+
+        it 'does decode to string with "range:" prefix and encode its boundary dates' do
+          JobAttributesAdapter.new(attributes_encoded).decode.should eq attributes
+        end
+
+        it 'does encode to string with "range:" prefix and encode its boundary dates' do
+          JobAttributesAdapter.new(attributes).encode.should eq attributes_encoded
+        end
+      end
+
+      context 'integers range' do
+        let(:attributes) { [1..10] }
+        let(:attributes_encoded) { ['range:[1,10]'] }
+
+        it 'does decode to string with prefix range:' do
+          JobAttributesAdapter.new(attributes_encoded).decode.should eq attributes
+        end
+
+        it 'does encode to string with prefix range:' do
+          JobAttributesAdapter.new(attributes).encode.should eq attributes_encoded
+        end
+      end
+
+      context 'integer' do
+        let(:attributes) { [12345] }
+        let(:attributes_encoded) { [12345] }
+
+        it 'is left decodehout any tranformations' do
+          JobAttributesAdapter.new(attributes_encoded).decode.should eq attributes
+        end
+
+        it 'does encode to string with prefix range:' do
+          JobAttributesAdapter.new(attributes).encode.should eq attributes_encoded
+        end
+      end
+
+      context 'hash' do
+        let(:attributes) { [{:foo => 'bar'}] }
+        let(:attributes_encoded) { [{'foo' => 'bar'}] }
+
+        it 'is left decodehout any tranformations' do
+          JobAttributesAdapter.new(attributes_encoded).decode.should eq attributes
+        end
+
+        it 'does encode to string with prefix range:' do
+          JobAttributesAdapter.new(attributes).encode.should eq attributes_encoded
+        end
+      end
+
+      context 'integer, hash and range' do
+        let(:attributes) { [12345, {:foo => 'bar'}, 10..1000] }
+        let(:attributes_encoded) { [12345, {'foo'=>"bar"}, "range:[10,1000]"] }
+
+        it 'does decode all together appropriately to their type' do
+          JobAttributesAdapter.new(attributes_encoded).decode.should eq attributes
+        end
+
+        it 'does encode to string with prefix range:' do
+          JobAttributesAdapter.new(attributes).encode.should eq attributes_encoded
+        end
+      end
+
+      context 'unknown group id bug' do
+        let(:attributes) { 
+          [
+            "624ea403ad028e03045ba34c923bce0b2a812099bcd815bb1ddf2d92d8aaa560", 
+            {
+              :group_id => 627, 
+              :date_range => [Date.parse("2016-12-31")], 
+              :week_schedule => {
+                :monday => 0, 
+                :tuesday => 1, 
+                :wednesday => 2, 
+                :thursday => 3, 
+                :friday => 2, 
+                :saturday => 0, 
+                :sunday => 0
+              }
+            }
+          ]
+        }
+
+        let(:attributes_encoded) { 
+          [
+            "624ea403ad028e03045ba34c923bce0b2a812099bcd815bb1ddf2d92d8aaa560", 
+            {
+              "group_id"=>627, 
+              "date_range"=>["date:2016-12-31"], 
+              "week_schedule"=>{"monday"=>0, "tuesday"=>1, "wednesday"=>2, "thursday"=>3, "friday"=>2, "saturday"=>0, "sunday"=>0}
+            }
+          ]
+        }
+
+        it 'does encode well' do
+          JobAttributesAdapter.new(attributes).encode.should eq attributes_encoded
+        end
+
+        it 'does decode well' do
+          decoded = JobAttributesAdapter.new(attributes_encoded).decode
+
+          decoded.should eq attributes
+          decoded.last[:group_id].should == 627
+        end
+      end
+    end
+  end
+end