canvas_sync 0.16.2 → 0.17.0.beta3

data/spec/job_batching/callback_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+RSpec.describe CanvasSync::JobBatches::Batch::Callback::Worker do
+  describe '#perform' do
+    it 'does not do anything if it cannot find the callback class' do
+      subject.perform('SampleCallback', 'complete', {}, 'ABCD', 'EFGH')
+    end
+
+    it 'does not do anything if event is different from complete or success' do
+      expect(SampleCallback).not_to receive(:new)
+      subject.perform('SampleCallback', 'ups', {}, 'ABCD', 'EFGH')
+    end
+
+    it 'calls on_success if defined' do
+      callback_instance = double('SampleCallback', on_success: true)
+      expect(SampleCallback).to receive(:new).and_return(callback_instance)
+      expect(callback_instance).to receive(:on_success)
+        .with(instance_of(CanvasSync::JobBatches::Batch::Status), {})
+      subject.perform('SampleCallback', 'success', {}, 'ABCD', 'EFGH')
+    end
+
+    it 'calls on_complete if defined' do
+      callback_instance = double('SampleCallback')
+      expect(SampleCallback).to receive(:new).and_return(callback_instance)
+      expect(callback_instance).to receive(:on_complete)
+        .with(instance_of(CanvasSync::JobBatches::Batch::Status), {})
+      subject.perform('SampleCallback', 'complete', {}, 'ABCD', 'EFGH')
+    end
+
+    it 'calls specific callback if defined' do
+      callback_instance = double('SampleCallback')
+      expect(SampleCallback).to receive(:new).and_return(callback_instance)
+      expect(callback_instance).to receive(:sample_method)
+        .with(instance_of(CanvasSync::JobBatches::Batch::Status), {})
+      subject.perform('SampleCallback#sample_method', 'complete', {}, 'ABCD', 'EFGH')
+    end
+  end
+end

data/spec/job_batching/flow_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+class WorkerA < BatchTestJobBase
+  def perform
+    puts 'A'
+  end
+end
+
+class WorkerB < BatchTestJobBase
+  def perform
+    puts 'B'
+  end
+end
+
+class WorkerC < BatchTestJobBase
+  def perform
+    puts 'C'
+  end
+end
+
+RSpec.describe 'Batch flow' do
+  context 'when handling a batch' do
+    let(:batch) { CanvasSync::JobBatches::Batch.new }
+    before { batch.on(:complete, SampleCallback, :id => 42) }
+    before { batch.description = 'describing the batch' }
+    let(:status) { CanvasSync::JobBatches::Batch::Status.new(batch.bid) }
+    let(:jids) { batch.jobs do 3.times do TestWorker.perform_async end end }
+    let(:queue) { Sidekiq::Queue.new }
+
+    it 'correctly initializes' do
+      expect(jids.size).to eq(3)
+
+      expect(batch.bid).not_to be_nil
+      expect(batch.description).to eq('describing the batch')
+
+      batch.jobs {}
+
+      expect(status.total).to eq(3)
+      expect(status.pending).to eq(3)
+      expect(status.failures).to eq(0)
+      expect(status.complete?).to be false
+      expect(status.created_at).not_to be_nil
+      expect(status.bid).to eq(batch.bid)
+    end
+
+    it 'handles an empty batch' do
+      batch = CanvasSync::JobBatches::Batch.new
+      jids = batch.jobs do nil end
+      expect(jids.size).to eq(0)
+    end
+  end
+
+  context 'when handling a nested batch' do
+    let(:batchA) { CanvasSync::JobBatches::Batch.new }
+    let(:batchB) { CanvasSync::JobBatches::Batch.new }
+    let(:batchC) { CanvasSync::JobBatches::Batch.new(batchA.bid) }
+    let(:batchD) { CanvasSync::JobBatches::Batch.new }
+    let(:jids) { [] }
+    let(:parent) { batchA.bid }
+    let(:children) { [] }
+
+    it 'handles a basic nested batch' do
+      batchA.jobs do
+        jids << WorkerA.perform_async
+        batchB.jobs do
+          jids << WorkerB.perform_async
+        end
+        jids << WorkerA.perform_async
+        children << batchB.bid
+      end
+
+      batchC.jobs do
+        batchD.jobs do
+          jids << WorkerC.perform_async
+        end
+        children << batchD.bid
+      end
+
+      expect(jids.size).to eq(4)
+      expect(CanvasSync::JobBatches::Batch::Status.new(parent).child_count).to eq(2)
+      children.each do |kid|
+          status = CanvasSync::JobBatches::Batch::Status.new(kid)
+          expect(status.child_count).to eq(0)
+          expect(status.pending).to eq(1)
+          expect(status.parent_bid).to eq(parent)
+      end
+
+    end
+
+  end
+end

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