joblin 0.1.0

data/spec/batching/compat/sidekiq_spec.rb

@@ -0,0 +1,127 @@
+require 'spec_helper'
+
+RSpec.describe Joblin::Batching::Compat::Sidekiq do
+  describe Joblin::Batching::Compat::Sidekiq::ServerMiddleware do
+    context 'when without batch' do
+      it 'just yields' do
+        yielded = false
+        expect(Joblin::Batching::Batch).not_to receive(:process_successful_job)
+        expect(Joblin::Batching::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(Joblin::Batching::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(Joblin::Batching::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 Joblin::Batching::Compat::Sidekiq::ClientMiddleware do
+    context 'when without batch' do
+      it 'just yields' do
+        yielded = false
+        expect(Joblin::Batching::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[Joblin::Batching::CURRENT_BATCH_THREAD_KEY] = Joblin::Batching::Batch.new(bid) }
+      after { Thread.current[Joblin::Batching::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(Joblin::Batching::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 Joblin::Batching::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(Joblin::Batching::Compat::Sidekiq::ClientMiddleware)
+      Joblin::Batching::Compat::Sidekiq.instance_variable_set(:@already_configured, false)
+      Joblin::Batching::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(Joblin::Batching::Compat::Sidekiq::ClientMiddleware)
+      expect(server_middleware).to receive(:add).with(Joblin::Batching::Compat::Sidekiq::ServerMiddleware)
+      expect(death_handlers).to receive(:<<)
+      Joblin::Batching::Compat::Sidekiq.instance_variable_set(:@already_configured, false)
+      Joblin::Batching::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/batching/context_hash_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+RSpec.describe Joblin::Batching::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 = Joblin::Batching::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 = Joblin::Batching::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 = Joblin::Batching::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 = Joblin::Batching::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/batching/flow_spec.rb

@@ -0,0 +1,82 @@
+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) { Joblin::Batching::Batch.new }
+    before { batch.on(:complete, SampleCallback, :id => 42) }
+    before { batch.description = 'describing the batch' }
+    let(:status) { Joblin::Batching::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) { Joblin::Batching::Batch.new }
+    let(:batchB) { Joblin::Batching::Batch.new }
+    let(:batchC) { Joblin::Batching::Batch.new(batchA.bid) }
+    let(:batchD) { Joblin::Batching::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(Joblin::Batching::Batch::Status.new(parent).child_count).to eq(2)
+      children.each do |kid|
+          status = Joblin::Batching::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/batching/integration/fail_then_succeed.rb

@@ -0,0 +1,42 @@
+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 = Joblin::Batching::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/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 = Joblin::Batching::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 Joblin::Batching::Batch::Status.new(batch.bid).data
+
+dump_redis_keys
+
+Sidekiq::Worker.drain_all
+
+dump_redis_keys

data/spec/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 = Joblin::Batching::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 = Joblin::Batching::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 = Joblin::Batching::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 = Joblin::Batching::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/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 = Joblin::Batching::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 = Joblin::Batching::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/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 = Joblin::Batching::Batch.new status.parent_bid
+    overall.jobs do
+      batch = Joblin::Batching::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 = Joblin::Batching::Batch.new status.parent_bid
+    overall.jobs do
+      batch = Joblin::Batching::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 = Joblin::Batching::Batch.new status.parent_bid
+    overall.jobs do
+      batch = Joblin::Batching::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 = Joblin::Batching::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 = Joblin::Batching::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 = Joblin::Batching::Batch.new
+overall.on(:success, MyCallback, to: 'success@gmail.com')
+overall.on(:complete, MyCallback, to: 'success@gmail.com')
+overall.jobs do
+  batch1 = Joblin::Batching::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/batching/integration_helper.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+require 'sidekiq/testing'
+
+Sidekiq::Testing.server_middleware do |chain|
+  chain.add Joblin::Batching::Compat::Sidekiq::ServerMiddleware
+end
+
+Joblin.redis { |r| r.flushdb }
+
+def redis_keys
+  Joblin.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