canvas_sync 0.23.5 → 0.24.0

data/spec/job_batching/compat/sidekiq_spec.rb

@@ -1,127 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe CanvasSync::JobBatches::Compat::Sidekiq do
-  describe CanvasSync::JobBatches::Compat::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::Compat::Sidekiq::ClientMiddleware do
-    context 'when without batch' do
-      it 'just yields' do
-        yielded = false
-        expect(CanvasSync::JobBatches::Batch).not_to receive(:append_jobs)
-        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(:append_jobs).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::Compat::Sidekiq do
-  let(:config) { defined?(Sidekiq::Config) ? double(Sidekiq::Config) : class_double(Sidekiq) }
-  let(:client_middleware) { double(Sidekiq::Middleware::Chain) }
-
-  context 'client' do
-    it 'adds client middleware' do
-      allow(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::Compat::Sidekiq::ClientMiddleware)
-      CanvasSync::JobBatches::Compat::Sidekiq.instance_variable_set(:@already_configured, false)
-      CanvasSync::JobBatches::Compat::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
-      allow(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::Compat::Sidekiq::ClientMiddleware)
-      expect(server_middleware).to receive(:add).with(CanvasSync::JobBatches::Compat::Sidekiq::ServerMiddleware)
-      expect(death_handlers).to receive(:<<)
-      CanvasSync::JobBatches::Compat::Sidekiq.instance_variable_set(:@already_configured, false)
-      CanvasSync::JobBatches::Compat::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

data/spec/job_batching/context_hash_spec.rb

@@ -1,54 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe CanvasSync::JobBatches::ContextHash do
-
-  class ContextedJob < BatchTestJobBase
-    def perform
-      was_performed(batch_context.flatten)
-    end
-
-    def was_performed(*args); end
-
-    def self.callback_perform(*args)
-      perform_later
-    end
-  end
-
-  it "works with first-level jobs" do
-    ActiveJob::Base.queue_adapter = :sidekiq
-    b = CanvasSync::JobBatches::Batch.new
-    b.context = { hello: 'world' }
-    expect_any_instance_of(ContextedJob).to receive(:was_performed).with({ 'hello' => 'world' })
-    b.jobs do
-      ContextedJob.perform_later
-    end
-    Sidekiq::Worker.drain_all
-  end
-
-  it "works with nested-batch jobs" do
-    ActiveJob::Base.queue_adapter = :sidekiq
-    b = CanvasSync::JobBatches::Batch.new
-    b.context = { hello: 'world', foo: 'bar' }
-    expect_any_instance_of(ContextedJob).to receive(:was_performed).with({ 'hello' => 'world', 'foo' => 'baz', 'some' => 'other' })
-    b.jobs do
-      b2 = CanvasSync::JobBatches::Batch.new
-      b2.context = { some: 'other', foo: 'baz' }
-      b2.jobs do
-        ContextedJob.perform_later
-      end
-    end
-    Sidekiq::Worker.drain_all
-  end
-
-  it 'works with a callback batch' do
-    ActiveJob::Base.queue_adapter = :sidekiq
-    b = CanvasSync::JobBatches::Batch.new
-    b.context = { hello: 'world' }
-    b.on(:success, "ContextedJob.callback_perform")
-    expect_any_instance_of(ContextedJob).to receive(:was_performed).with({ 'hello' => 'world' })
-    b.jobs do
-      BatchTestJobBase.perform_later
-    end
-    Sidekiq::Worker.drain_all
-  end
-end

data/spec/job_batching/flow_spec.rb

@@ -1,82 +0,0 @@
-require 'spec_helper'
-
-class WorkerA < BatchTestJobBase
-  def perform
-  end
-end
-
-class WorkerB < BatchTestJobBase
-  def perform
-  end
-end
-
-class WorkerC < BatchTestJobBase
-  def perform
-  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(:queue) { Sidekiq::Queue.new }
-
-    it 'correctly initializes' do
-      expect(batch.bid).not_to be_nil
-      expect(batch.description).to eq('describing the batch')
-
-      batch.jobs do
-        3.times do
-          BatchTestWorker.perform_async
-        end
-      end
-
-      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
-  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/fail_then_succeed.rb

@@ -1,42 +0,0 @@
-require_relative '../integration_helper'
-
-# Workflow when a Job fails, retries, and then succeeds
-
-class Worker1
-  include Sidekiq::Worker
-  sidekiq_options retry: 5
-
-  @@failed = false
-
-  def perform
-    Sidekiq.logger.info "Work 1"
-
-    unless @@failed
-      @@failed = true
-      raise "One Failure"
-    end
-  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
-  Worker1.perform_async
-end
-
-puts "Overall bid #{overall.bid}"
-
-output, keys = process_tests
-overall_tests(output, keys, file: __FILE__)

data/spec/job_batching/integration/integration.rb

@@ -1,57 +0,0 @@
-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

@@ -1,88 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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

@@ -1,134 +0,0 @@
-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

@@ -1,50 +0,0 @@
-require 'spec_helper'
-require 'sidekiq/testing'
-
-Sidekiq::Testing.server_middleware do |chain|
-  chain.add CanvasSync::JobBatches::Compat::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