canvas_sync 0.16.4 → 0.21.0

data/spec/job_batching/integration/integration.rb

@@ -0,0 +1,57 @@
+require 'integration_helper'
+
+# Simple test of adding jobs to the current batch
+# Batches:
+# - Overall (TestWoker) + Another worker
+
+class AnotherWorker
+  include Sidekiq::Worker
+
+  def perform
+    Sidekiq.logger.info "Another Worker"
+  end
+end
+
+class TestWorker
+  include Sidekiq::Worker
+
+  def perform
+    Sidekiq.logger.info "Test Worker"
+    if bid
+      batch.jobs do
+        AnotherWorker.perform_async
+      end
+    end
+  end
+end
+
+class MyCallback
+  def on_success(status, options)
+    Sidekiq.logger.info "Success #{options} #{status.data}"
+  end
+  alias_method :multi, :on_success
+
+  def on_complete(status, options)
+    Sidekiq.logger.info "Complete #{options} #{status.data}"
+  end
+end
+
+batch = CanvasSync::JobBatches::Batch.new
+batch.description = 'Test batch'
+batch.callback_queue = :default
+batch.on(:success, 'MyCallback#on_success', to: 'success@gmail.com')
+batch.on(:success, 'MyCallback#multi', to: 'success@gmail.com')
+batch.on(:complete, MyCallback, to: 'complete@gmail.com')
+
+batch.jobs do
+  10.times do
+    TestWorker.perform_async
+  end
+end
+puts CanvasSync::JobBatches::Batch::Status.new(batch.bid).data
+
+dump_redis_keys
+
+Sidekiq::Worker.drain_all
+
+dump_redis_keys

data/spec/job_batching/integration/nested.rb

@@ -0,0 +1,88 @@
+require 'integration_helper'
+
+# Tests deep nesting of batches
+# Batches:
+# - Overall (Worker 1)
+#  - Worker 2
+#   - Worker 3
+#    - Worker 4
+
+class Worker1
+  include Sidekiq::Worker
+
+  def perform
+    Sidekiq.logger.info "Work1"
+    batch = CanvasSync::JobBatches::Batch.new
+    batch.on(:success, Worker2)
+    batch.jobs do
+      Worker2.perform_async
+    end
+  end
+end
+
+class Worker2
+  include Sidekiq::Worker
+
+  def perform
+    Sidekiq.logger.info "Work2"
+    batch = CanvasSync::JobBatches::Batch.new
+    batch.on(:success, Worker3)
+    batch.jobs do
+      Worker3.perform_async
+    end
+  end
+
+  def on_success status, opts
+    Sidekiq.logger.info "Worker 2 Success"
+  end
+end
+
+class Worker3
+  include Sidekiq::Worker
+
+  def perform
+    Sidekiq.logger.info "Work3"
+    batch = CanvasSync::JobBatches::Batch.new
+    batch.on(:success, Worker4)
+    batch.jobs do
+      Worker4.perform_async
+    end
+  end
+
+  def on_success status, opts
+    Sidekiq.logger.info "Worker 3 Success"
+  end
+end
+
+class Worker4
+  include Sidekiq::Worker
+
+  def perform
+    Sidekiq.logger.info "Work4"
+  end
+
+  def on_success status, opts
+    Sidekiq.logger.info "Worker 4 Success"
+  end
+end
+
+
+class SomeClass
+  def on_complete(status, options)
+    Sidekiq.logger.info "Overall Complete #{options} #{status.data}"
+  end
+  def on_success(status, options)
+    Sidekiq.logger.info "Overall Success #{options} #{status.data}"
+  end
+end
+batch = CanvasSync::JobBatches::Batch.new
+batch.on(:success, SomeClass, 'uid' => 3)
+batch.on(:complete, SomeClass, 'uid' => 3)
+batch.jobs do
+  Worker1.perform_async
+end
+
+puts "Overall bid #{batch.bid}"
+
+output, keys = process_tests
+overall_tests output, keys

data/spec/job_batching/integration/simple.rb

@@ -0,0 +1,47 @@
+require 'integration_helper'
+
+# Simple nested batch without callbacks
+# Batches:
+# - Overall (Worker1)
+#  - Worker2
+
+class Worker1
+  include Sidekiq::Worker
+
+  def perform
+    Sidekiq.logger.info "Work1"
+    batch = CanvasSync::JobBatches::Batch.new
+    batch.jobs do
+      Worker2.perform_async
+    end
+  end
+end
+
+class Worker2
+  include Sidekiq::Worker
+
+  def perform
+    Sidekiq.logger.info "Work2"
+  end
+end
+
+class SomeClass
+  def on_complete(status, options)
+    Sidekiq.logger.info "Overall Complete #{options} #{status.data}"
+  end
+  def on_success(status, options)
+    Sidekiq.logger.info "Overall Success #{options} #{status.data}"
+  end
+end
+
+batch = CanvasSync::JobBatches::Batch.new
+batch.on(:success, SomeClass)
+batch.on(:complete, SomeClass)
+batch.jobs do
+  Worker1.perform_async
+end
+
+puts "Overall bid #{batch.bid}"
+
+output, keys = process_tests
+overall_tests output, keys

data/spec/job_batching/integration/workflow.rb

@@ -0,0 +1,134 @@
+require 'integration_helper'
+
+# Complex workflow with sequential and nested
+# Also test sub batches without callbacks
+# Batches:
+# - Overall
+#  - Worker1
+#   - Worker3
+#  - Worker2 + Worker3
+#   - Worker1
+#    - Worker3
+#  - Worker4
+#  - Worker5
+
+class Callbacks
+  def worker1 status, opts
+    Sidekiq.logger.info "Success 1 #{status.data}"
+
+    overall = CanvasSync::JobBatches::Batch.new status.parent_bid
+    overall.jobs do
+      batch = CanvasSync::JobBatches::Batch.new
+      batch.on(:success, "Callbacks#worker2")
+      batch.jobs do
+        Worker2.perform_async
+      end
+    end
+  end
+
+  def worker2 status, opts
+    Sidekiq.logger.info "Success 2 #{status.data}"
+    overall = CanvasSync::JobBatches::Batch.new status.parent_bid
+    overall.jobs do
+      batch = CanvasSync::JobBatches::Batch.new
+      batch.on(:success, "Callbacks#worker4")
+      batch.jobs do
+        Worker4.perform_async
+      end
+    end
+
+  end
+
+  def worker4 status, opts
+    Sidekiq.logger.info "Success 4 #{status.data}"
+    overall = CanvasSync::JobBatches::Batch.new status.parent_bid
+    overall.jobs do
+      batch = CanvasSync::JobBatches::Batch.new
+      batch.on(:success, "Callbacks#worker5")
+      batch.jobs do
+        Worker5.perform_async
+      end
+    end
+  end
+
+  def worker5 status, opts
+    Sidekiq.logger.info "Success 5 #{status.data}"
+  end
+end
+
+class Worker1
+  include Sidekiq::Worker
+
+  def perform
+    Sidekiq.logger.info "Work 1"
+    batch = CanvasSync::JobBatches::Batch.new
+    batch.jobs do
+      Worker3.perform_async
+    end
+  end
+end
+
+class Worker2
+  include Sidekiq::Worker
+
+  def perform
+    Sidekiq.logger.info "Work 2"
+    if bid
+      batch.jobs do
+        Worker3.perform_async
+      end
+      newb = CanvasSync::JobBatches::Batch.new
+      newb.jobs do
+        Worker1.perform_async
+      end
+    end
+  end
+end
+
+class Worker3
+  include Sidekiq::Worker
+  def perform
+    Sidekiq.logger.info "Work 3"
+  end
+end
+
+class Worker4
+  include Sidekiq::Worker
+  def perform
+    Sidekiq.logger.info "Work 4"
+  end
+end
+
+class Worker5
+  include Sidekiq::Worker
+  def perform
+    Sidekiq.logger.info "Work 5"
+  end
+end
+
+class MyCallback
+  def on_success(status, options)
+    Sidekiq.logger.info "Overall Success #{options} #{status.data}"
+  end
+  alias_method :multi, :on_success
+
+  def on_complete(status, options)
+    Sidekiq.logger.info "Overall Complete #{options} #{status.data}"
+  end
+end
+
+overall = CanvasSync::JobBatches::Batch.new
+overall.on(:success, MyCallback, to: 'success@gmail.com')
+overall.on(:complete, MyCallback, to: 'success@gmail.com')
+overall.jobs do
+  batch1 = CanvasSync::JobBatches::Batch.new
+  batch1.on(:success, "Callbacks#worker1")
+  batch1.jobs do
+    Worker1.perform_async
+  end
+end
+
+puts "Overall bid #{overall.bid}"
+
+output, keys = process_tests
+overall_tests output, keys

data/spec/job_batching/integration_helper.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+require 'sidekiq/testing'
+
+Sidekiq::Testing.server_middleware do |chain|
+  chain.add CanvasSync::JobBatches::Sidekiq::ServerMiddleware
+end
+
+CanvasSync.redis { |r| r.flushdb }
+
+def redis_keys
+  CanvasSync.redis { |r| r.keys('BID-*') }
+end
+
+def dump_redis_keys
+  puts redis_keys.inspect
+end
+
+def process_tests
+  out_buf = StringIO.new
+  Sidekiq.logger = Logger.new out_buf
+
+  # Sidekiq.logger.level = :info
+
+  Sidekiq::Worker.drain_all
+
+  output = out_buf.string
+  keys = redis_keys
+  puts out_buf.string
+
+  [output, keys]
+end
+
+def overall_tests(output, keys, file: nil)
+  test_name = "Batch Integration Test"
+  test_name = File.basename(file, ".*")  if file
+
+  Rspec.describe test_name do
+    it "runs overall complete callback" do
+      expect(output).to include "Overall Complete"
+    end
+
+    it "runs overall success callback" do
+      expect(output).to include "Overall Success"
+    end
+
+    it "cleans redis keys" do
+      expect(keys).to eq([])
+    end
+  end
+end

data/spec/job_batching/pool_spec.rb

@@ -0,0 +1,161 @@
+require 'spec_helper'
+
+RSpec.describe CanvasSync::JobBatches::Pool do
+  include ActiveJob::TestHelper
+
+  subject { described_class.new(order: pool_order, concurrency: pool_concurrency) }
+
+  let(:pool) { subject }
+
+  let(:pool_order) { :fifo }
+  let(:pool_concurrency) { 2 }
+
+  describe '#initialize' do
+    subject { described_class }
+
+    it 'creates pid when called without it' do
+      expect(subject.new.pid).not_to be_nil
+    end
+
+    it 'reuses pid when called with it' do
+      batch = subject.new('dayPO5KxuRXXxw')
+      expect(batch.pid).to eq('dayPO5KxuRXXxw')
+    end
+  end
+
+  def load_pool(count = 3)
+    jobs = count.times.map do |i|
+      { job: "BatchTestJobBase", args: [1] }
+    end
+    subject.add_jobs(jobs, skip_refill: true)
+  end
+
+  describe "#job_checked_in" do
+    it "gets called" do
+      expect(CanvasSync::JobBatches::Pool).to receive(:job_checked_in).twice
+      load_pool
+      perform_enqueued_jobs do
+        pool.send :refill_allotment
+        Sidekiq::Worker.drain_all
+      end
+    end
+
+    it "refills the pool" do
+      expect(CanvasSync::JobBatches::Pool).to receive(:job_checked_in).and_call_original.exactly(3).times
+
+      load_pool
+      perform_enqueued_jobs do
+        pool.send :refill_allotment
+        Sidekiq::Worker.drain_all
+      end
+    end
+  end
+
+  describe "#cleanup_if_empty" do
+    it "cleans if pool is empty and allowed to close" do
+      expect(pool).to receive(:cleanup_redis)
+      pool.cleanup_if_empty
+    end
+
+    it "doesn't clean if pool has pending" do
+      load_pool
+      expect(pool).to_not receive(:cleanup_redis)
+      pool.cleanup_if_empty
+    end
+
+    it "doesn't clean if pool has active" do
+      subject.redis.hset("#{subject.send(:redis_key)}-active", "blocked", "{}")
+      expect(pool).to_not receive(:cleanup_redis)
+      pool.cleanup_if_empty
+    end
+
+    it "doesn't clean if pool has activating" do
+      subject.redis.hincrby(subject.send(:redis_key), "_active_count", 1)
+      expect(pool).to_not receive(:cleanup_redis)
+      pool.cleanup_if_empty
+    end
+
+    it "doesn't clean if pool is empty but is kept open" do
+      pool.keep_open!
+      expect(pool).to_not receive(:cleanup_redis)
+      pool.cleanup_if_empty
+    end
+
+    it "doesn't clean if pool is empty but clean_when_empty is false" do
+      subject.redis.hset(subject.send(:redis_key), "clean_when_empty", "false")
+      expect(pool).to_not receive(:cleanup_redis)
+      pool.cleanup_if_empty
+    end
+  end
+
+  shared_examples "basic pool tests" do
+    describe "#push_job_to_pool" do
+      it "adds a job to the pool" do
+        subject.send(:push_job_to_pool, { job: 'job1' })
+        expect(subject.pending_count).to eq(1)
+      end
+    end
+
+    describe "#refill_allotment" do
+      it "refills the pool with jobs" do
+        load_pool
+        expect(CanvasSync::JobBatches::ChainBuilder).to receive(:enqueue_job).twice
+        subject.send(:refill_allotment)
+      end
+
+      it "limits to the concurrency count" do
+        load_pool
+        expect(CanvasSync::JobBatches::ChainBuilder).to receive(:enqueue_job).twice
+        expect(subject.send(:refill_allotment)).to eql 2
+        expect(subject.pending_count).to eql 1
+      end
+
+      it "considers already active jobs against concurrency" do
+        load_pool
+        subject.redis.hset("#{subject.send(:redis_key)}-active", "blocked", "{}")
+        expect(CanvasSync::JobBatches::ChainBuilder).to receive(:enqueue_job).once
+        expect(subject.send(:refill_allotment)).to eql 2
+        expect(subject.pending_count).to eql 2
+      end
+
+      it "considers activating jobs against concurrency" do
+        load_pool
+        subject.redis.hincrby(subject.send(:redis_key), "_active_count", 1)
+        expect(CanvasSync::JobBatches::ChainBuilder).to receive(:enqueue_job).once
+        expect(subject.send(:refill_allotment)).to eql 2
+        expect(subject.pending_count).to eql 2
+      end
+
+      it "doesn't fail if the pool is gone" do
+        load_pool
+        subject.cleanup_redis
+        expect(CanvasSync::JobBatches::ChainBuilder).not_to receive(:enqueue_job)
+        expect(subject.send(:refill_allotment)).to eql -1
+      end
+
+      it "doesn't fail if the pool is empty" do
+        expect(subject.send(:refill_allotment)).to eql 0
+      end
+    end
+  end
+
+  context "FIFO Pool" do
+    let(:pool_order) { :fifo }
+    it_behaves_like "basic pool tests"
+  end
+
+  context "LIFO Pool" do
+    let(:pool_order) { :lifo }
+    it_behaves_like "basic pool tests"
+  end
+
+  context "Random Pool" do
+    let(:pool_order) { :random }
+    it_behaves_like "basic pool tests"
+  end
+
+  context "Priority Pool" do
+    let(:pool_order) { :priority }
+    it_behaves_like "basic pool tests"
+  end
+end

data/spec/job_batching/sidekiq_spec.rb

@@ -0,0 +1,125 @@
+require 'spec_helper'
+
+RSpec.describe CanvasSync::JobBatches::Sidekiq do
+  describe CanvasSync::JobBatches::Sidekiq::ServerMiddleware do
+    context 'when without batch' do
+      it 'just yields' do
+        yielded = false
+        expect(CanvasSync::JobBatches::Batch).not_to receive(:process_successful_job)
+        expect(CanvasSync::JobBatches::Batch).not_to receive(:process_failed_job)
+        subject.call(nil, {}, nil) { yielded = true }
+        expect(yielded).to be_truthy
+      end
+    end
+
+    context 'when in batch' do
+      let(:bid) { 'SAMPLEBID' }
+      let(:jid) { 'SAMPLEJID' }
+
+      context 'when successful' do
+        it 'yields' do
+          yielded = false
+          subject.call(nil, { 'bid' => bid, 'jid' => jid }, nil) { yielded = true }
+          expect(yielded).to be_truthy
+        end
+
+        it 'calls process_successful_job' do
+          expect(CanvasSync::JobBatches::Batch).to receive(:process_successful_job).with(bid, nil)
+          subject.call(nil, { 'bid' => bid }, nil) {}
+        end
+      end
+
+      context 'when failed' do
+        it 'calls process_failed_job and reraises exception' do
+          reraised = false
+          expect(CanvasSync::JobBatches::Batch).to receive(:process_failed_job)
+          begin
+            subject.call(nil, { 'bid' => bid }, nil) { raise 'ERR' }
+          rescue
+            reraised = true
+          end
+          expect(reraised).to be_truthy
+        end
+      end
+    end
+  end
+
+  describe CanvasSync::JobBatches::Sidekiq::ClientMiddleware do
+    context 'when without batch' do
+      it 'just yields' do
+        yielded = false
+        expect(CanvasSync::JobBatches::Batch).not_to receive(:increment_job_queue)
+        subject.call(nil, {}, nil) { yielded = true }
+        expect(yielded).to be_truthy
+      end
+    end
+
+    context 'when in batch' do
+      let(:bid) { 'SAMPLEBID' }
+      let(:jid) { 'SAMPLEJID' }
+      before { Thread.current[CanvasSync::JobBatches::CURRENT_BATCH_THREAD_KEY] = CanvasSync::JobBatches::Batch.new(bid) }
+      after { Thread.current[CanvasSync::JobBatches::CURRENT_BATCH_THREAD_KEY] = nil }
+
+      it 'yields' do
+        yielded = false
+        subject.call(nil, { 'jid' => jid }, nil) { yielded = true }
+        expect(yielded).to be_truthy
+      end
+
+      it 'increments job queue' do
+        # expect(CanvasSync::JobBatches::Batch).to receive(:increment_job_queue).with(bid)
+        # subject.call(nil, { 'jid' => jid }, nil) {}
+      end
+
+      it 'assigns bid to msg' do
+        msg = { 'jid' => jid }
+        subject.call(nil, msg, nil) {}
+        expect(msg[:bid]).to eq(bid)
+      end
+    end
+  end
+end
+
+RSpec.describe CanvasSync::JobBatches::Sidekiq do
+  let(:config) { class_double(Sidekiq) }
+  let(:client_middleware) { double(Sidekiq::Middleware::Chain) }
+
+  context 'client' do
+    it 'adds client middleware' do
+      expect(Sidekiq).to receive(:configure_client).and_yield(config)
+      expect(config).to receive(:client_middleware).and_yield(client_middleware)
+      expect(client_middleware).to receive(:add).with(CanvasSync::JobBatches::Sidekiq::ClientMiddleware)
+      CanvasSync::JobBatches::Sidekiq.configure
+    end
+  end
+
+  context 'server' do
+    let(:server_middleware) { double(Sidekiq::Middleware::Chain) }
+    let(:death_handlers) { double(Array) }
+
+    it 'adds client and server middleware' do
+      expect(Sidekiq).to receive(:configure_server).and_yield(config)
+      expect(config).to receive(:client_middleware).and_yield(client_middleware)
+      expect(config).to receive(:server_middleware).and_yield(server_middleware)
+      expect(config).to receive(:death_handlers).and_return(death_handlers)
+      expect(client_middleware).to receive(:add).with(CanvasSync::JobBatches::Sidekiq::ClientMiddleware)
+      expect(server_middleware).to receive(:add).with(CanvasSync::JobBatches::Sidekiq::ServerMiddleware)
+      expect(death_handlers).to receive(:<<)
+      CanvasSync::JobBatches::Sidekiq.configure
+    end
+  end
+
+  context 'worker' do
+    it 'defines method bid' do
+      expect(Sidekiq::Worker.instance_methods).to include(:bid)
+    end
+
+    it 'defines method batch' do
+      expect(Sidekiq::Worker.instance_methods).to include(:batch)
+    end
+
+    it 'defines method valid_within_batch?' do
+      expect(Sidekiq::Worker.instance_methods).to include(:valid_within_batch?)
+    end
+  end
+end