canvas_sync 0.21.1 → 0.22.0.beta1

data/spec/job_uniqueness/compat/sidekiq_spec.rb

@@ -0,0 +1,68 @@
+require 'job_uniqueness/spec_helper'
+
+RSpec.describe CanvasSync::JobUniqueness::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(:insert_before).with(anything, CanvasSync::JobUniqueness::Compat::Sidekiq::ClientMiddleware)
+      CanvasSync::JobUniqueness::Compat::Sidekiq.configure
+    end
+  end
+
+  context 'server' do
+    let(:server_middleware) { double(Sidekiq::Middleware::Chain) }
+
+    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(client_middleware).to receive(:insert_before).with(anything, CanvasSync::JobUniqueness::Compat::Sidekiq::ClientMiddleware)
+      expect(server_middleware).to receive(:insert_after).with(anything, CanvasSync::JobUniqueness::Compat::Sidekiq::ServerMiddleware)
+      CanvasSync::JobUniqueness::Compat::Sidekiq.configure
+    end
+  end
+
+  context 'Job Extension' do
+    let!(:dummy_worker) do
+      Class.new do
+        include Sidekiq::Worker
+      end
+    end
+
+    it 'includes UniqueJobExtension' do
+      expect(dummy_worker < CanvasSync::JobUniqueness::Compat::Sidekiq::WorkerExtension).to be true
+    end
+
+    it 'has the ensure_uniqueness method' do
+      expect(dummy_worker.method(:ensure_uniqueness)).to be_present
+    end
+  end
+
+  context 'Job' do
+    include_context 'with TestWorker'
+
+    it 'runs as expected' do
+      strategy = CanvasSync::JobUniqueness::Strategy::UntilExecuted.new(nil)
+      allow_any_instance_of(CanvasSync::JobUniqueness::LockContext).to receive(:lock_strategy) do |lock_context|
+        strategy.instance_variable_set(:@lock_context, lock_context)
+        strategy
+      end
+      allow(CanvasSync::JobUniqueness::Strategy::UntilExecuted).to receive(:new).and_return(strategy)
+
+      expect(strategy).to receive(:on_enqueue).and_call_original
+      expect(strategy).to receive(:on_perform).and_call_original
+      expect(strategy).to receive(:batch_callback).with(:complete, anything).and_call_original
+      expect(strategy).to receive(:batch_callback).with(:success, anything).and_call_original
+
+      expect_any_instance_of(TestWorker).to receive(:perform)
+
+      Sidekiq::Testing.inline! do
+        worker.perform_async
+      end
+    end
+  end
+end

data/spec/job_uniqueness/lock_context_spec.rb

@@ -0,0 +1,95 @@
+require 'job_uniqueness/spec_helper'
+
+RSpec.describe CanvasSync::JobUniqueness::LockContext do
+  let!(:worker) do
+    Class.new do
+      include Sidekiq::Worker
+
+      ensure_uniqueness(
+        strategy: :until_executed,
+      )
+
+      def perform; end
+    end
+  end
+
+  before(:each) { stub_const('TestWorker', worker) }
+
+  let(:lock_context) { described_class.new(context_data) }
+  let(:context_data) { { queue: 'default', job_clazz: 'TestWorker', args: [1,2,3], kwargs: { foo: 'bar' } } }
+
+  describe '#base_key' do
+    let(:scope) { :per_queue }
+    before(:each) do
+      TestWorker.unique_job_options[:scope] = scope
+    end
+
+    context 'when scope is a Proc' do
+      let(:scope) { ->(queue:) { "blob" } }
+
+      it 'returns the base key' do
+        expect(lock_context.base_key).to match /^uniquejob:blob:.*/
+      end
+    end
+
+    context 'when scope is :global' do
+      let(:scope) { :global }
+
+      it 'returns the base key' do
+        expect(lock_context.base_key).to match /^uniquejob:TestWorker:.*/
+      end
+    end
+
+    context 'when scope is :per_queue' do
+      let(:scope) { :per_queue }
+
+      it 'returns the base key' do
+        expect(lock_context.base_key).to match /^uniquejob:TestWorker:default:.*/
+      end
+    end
+
+    context 'when scope is not a Proc, :global, or :per_queue' do
+      let(:scope) { 'foo' }
+
+      it 'returns the base key' do
+        expect(lock_context.base_key).to match /^uniquejob:foo:.*/
+      end
+    end
+  end
+
+  describe '#call_conflict_strategy' do
+    before(:each) do
+      worker.unique_job_options[:on_conflict] = :raise
+    end
+
+    it 'invokes the conflict strategy' do
+      expect_any_instance_of(CanvasSync::JobUniqueness::OnConflict::Raise).to receive(:call)
+      lock_context.send(:call_conflict_strategy, :perform)
+    end
+  end
+
+  describe '#conflict_strategy_for' do
+    before(:each) do
+      worker.unique_job_options[:on_conflict] = :raise
+    end
+
+    it 'resolves a united conflict strategy' do
+      expect(lock_context.send(:conflict_strategy_for, :perform)).to be_a CanvasSync::JobUniqueness::OnConflict::Raise
+    end
+
+    it 'resolves enqueue strategy' do
+      worker.unique_job_options[:on_conflict] = { enqueue: :log, perform: :raise }
+      expect(lock_context.send(:conflict_strategy_for, :enqueue)).to be_a CanvasSync::JobUniqueness::OnConflict::Log
+    end
+
+    it 'resolves perform strategy' do
+      worker.unique_job_options[:on_conflict] = { enqueue: :log, perform: :reject }
+      expect(lock_context.send(:conflict_strategy_for, :perform)).to be_a CanvasSync::JobUniqueness::OnConflict::Reject
+    end
+
+    it 'resolves null strategy' do
+      worker.unique_job_options[:on_conflict] = { enqueue: :log }
+      expect(lock_context.send(:conflict_strategy_for, :perform)).to be_a CanvasSync::JobUniqueness::OnConflict::NullStrategy
+    end
+  end
+end

data/spec/job_uniqueness/on_conflict/log_spec.rb

@@ -0,0 +1,11 @@
+require 'job_uniqueness/spec_helper'
+
+RSpec.describe CanvasSync::JobUniqueness::OnConflict::Log do
+  include_context "on_conflict specs"
+  include_examples "OnConflict is compatible with", %i[until_executing while_executing until_executed until_and_while_executing until_expired]
+
+  it "logs" do
+    expect(CanvasSync::JobUniqueness.logger).to receive(:info)
+    on_conflict.call
+  end
+end

data/spec/job_uniqueness/on_conflict/raise_spec.rb

@@ -0,0 +1,10 @@
+require 'job_uniqueness/spec_helper'
+
+RSpec.describe CanvasSync::JobUniqueness::OnConflict::Raise do
+  include_context "on_conflict specs"
+  include_examples "OnConflict is compatible with", %i[until_executing while_executing until_executed until_and_while_executing until_expired]
+
+  it "raises an error" do
+    expect { on_conflict.call }.to raise_error(CanvasSync::JobUniqueness::Conflict)
+  end
+end

data/spec/job_uniqueness/on_conflict/reschedule_spec.rb

@@ -0,0 +1,24 @@
+require 'job_uniqueness/spec_helper'
+
+RSpec.describe CanvasSync::JobUniqueness::OnConflict::Reschedule do
+  include_context "on_conflict specs"
+  include_examples "OnConflict is compatible with", %i[while_executing]
+
+  it "calls reenqueue" do
+    expect(lock_context).to receive(:reenqueue) do |*args, **kwargs|
+      expect(Thread.current[:unique_jobs_previous_jid]).to be_present
+    end
+    on_conflict.call
+  end
+
+  it "reschedules successfully" do
+    TestWorker.unique_job_options.merge!({ strategy: :until_and_while_executing, on_conflict: { enqueue: :raise, perform: :reschedule }})
+
+    lock_context.handle_lifecycle!(:enqueue) {}
+    lock_context.handle_lifecycle!(:perform) {}
+
+    lock_context2 = CanvasSync::JobUniqueness::Compat::Sidekiq::SidekiqLockContext.new({ jid: 'j2', queue: 'default', job_clazz: 'TestWorker'}, job_instance: {})
+    lock_context2.handle_lifecycle!(:enqueue) {}
+    lock_context2.handle_lifecycle!(:perform) {}
+  end
+end

data/spec/job_uniqueness/on_conflict_spec.rb

@@ -0,0 +1,16 @@
+require 'job_uniqueness/spec_helper'
+
+RSpec.describe CanvasSync::JobUniqueness::OnConflict do
+
+  describe ".validate!" do
+    it "passes a valid pair" do
+      described_class.validate!(:reject, :while_executing)
+    end
+
+    it "raises an error if the strategy is not valid for the given action" do
+      expect do
+        described_class.validate!(:reject, :until_executed)
+      end.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/job_uniqueness/spec_helper.rb

@@ -0,0 +1,14 @@
+require_relative "../spec_helper"
+require "canvas_sync/job_uniqueness/job_uniqueness"
+
+Dir[File.join(File.dirname(__FILE__), "./support/**/*.rb")].sort.each { |f| require f }
+
+Sidekiq::Testing.server_middleware do |chain|
+  chain.insert_before CanvasSync::JobBatches::Compat::Sidekiq::ServerMiddleware, CanvasSync::JobUniqueness::Compat::Sidekiq::ServerMiddleware
+end
+
+RSpec.configure do |config|
+  config.before(:each) do
+    CanvasSync.redis.flushdb
+  end
+end

data/spec/job_uniqueness/strategy/base_spec.rb

@@ -0,0 +1,100 @@
+require 'job_uniqueness/spec_helper'
+
+RSpec.describe CanvasSync::JobUniqueness::Strategy::Base do
+  include_context 'with TestWorker'
+
+  let!(:jid) { worker.perform_async }
+  let(:context) { CanvasSync::JobUniqueness::LockContext.new({ jid: jid, queue: 'default', job_clazz: 'TestWorker' }) }
+  let(:strategy) { CanvasSync::JobUniqueness::Strategy::UntilExecuted.new(context) }
+
+  describe '#wrap_in_batch' do
+    it 'does not wrap if re-enqueuing' do
+      Thread.current[:unique_jobs_previous_jid] = "j100"
+      expect(CanvasSync::JobBatches::Batch).not_to receive(:new)
+      strategy.send(:wrap_in_batch, &->{ })
+    ensure
+      Thread.current[:unique_jobs_previous_jid] = nil
+    end
+
+    context 'when the job fails' do
+      before(:each) do
+        TestWorker.unique_job_options[:strategy] = :until_executed
+        allow_any_instance_of(worker).to receive(:perform) do |w|
+          @bid = w.bid
+          raise 'error'
+        end
+      end
+
+      context 'unlock_on_failure: :any' do
+        before(:each) { TestWorker.unique_job_options[:unlock_on_failure] = :any }
+
+        it 'unlocks on any failure' do
+          expect(strategy).to be_locked
+          expect{ Sidekiq::Worker.drain_all }.to raise_error('error')
+          Sidekiq::Worker.drain_all
+          expect(strategy).not_to be_locked
+        end
+      end
+
+      context 'unlock_on_failure: :death' do
+        before(:each) { TestWorker.unique_job_options[:unlock_on_failure] = :death }
+
+        it 'does not unlock on any failure' do
+          expect(strategy).to be_locked
+          expect{ Sidekiq::Worker.drain_all }.to raise_error('error')
+          Sidekiq::Worker.drain_all
+          expect(strategy).to be_locked
+        end
+
+        it 'it unlocks on death' do
+          expect{ Sidekiq::Worker.drain_all }.to raise_error('error')
+          Sidekiq::Worker.drain_all
+          expect(strategy).to be_locked
+          CanvasSync::JobBatches::Batch.process_dead_job(@bid, jid)
+          Sidekiq::Worker.drain_all
+          expect(strategy).not_to be_locked
+        end
+      end
+
+      context 'unlock_on_failure: :stagnant' do
+        before(:each) { TestWorker.unique_job_options[:unlock_on_failure] = :stagnant }
+
+        it 'does not unlock on any failure' do
+          expect(strategy).to be_locked
+          expect{ Sidekiq::Worker.drain_all }.to raise_error('error')
+          Sidekiq::Worker.drain_all
+          expect(strategy).to be_locked
+        end
+
+        it 'it unlocks on stagnation' do
+          expect{ Sidekiq::Worker.drain_all }.to raise_error('error')
+          Sidekiq::Worker.drain_all
+          expect(strategy).to be_locked
+          CanvasSync::JobBatches::Batch.process_dead_job(@bid, jid)
+          Sidekiq::Worker.drain_all
+          expect(strategy).not_to be_locked
+        end
+      end
+
+      context 'unlock_on_failure: :expire' do
+        before(:each) { TestWorker.unique_job_options[:unlock_on_failure] = :expire }
+
+        it 'does not unlock on any failure' do
+          expect(strategy).to be_locked
+          expect{ Sidekiq::Worker.drain_all }.to raise_error('error')
+          Sidekiq::Worker.drain_all
+          expect(strategy).to be_locked
+        end
+
+        it 'does not unlock on death' do
+          expect{ Sidekiq::Worker.drain_all }.to raise_error('error')
+          Sidekiq::Worker.drain_all
+          expect(strategy).to be_locked
+          CanvasSync::JobBatches::Batch.process_dead_job(@bid, jid)
+          Sidekiq::Worker.drain_all
+          expect(strategy).to be_locked
+        end
+      end
+    end
+  end
+end

data/spec/job_uniqueness/strategy/until_and_while_executing_spec.rb

@@ -0,0 +1,48 @@
+require 'job_uniqueness/spec_helper'
+
+RSpec.describe CanvasSync::JobUniqueness::Strategy::UntilAndWhileExecuting do
+  include_context 'lock strategy specs', strategy: :until_and_while_executing
+
+  include_examples "a lock implementation"
+
+  describe "#on_enqueue" do
+    it "locks the queue" do
+      process_one.on_enqueue {}
+      expect(process_one).to be_locked
+    end
+
+    it "does not lock the runtime lock" do
+      process_one.on_enqueue {}
+      expect(process_one.send(:runtime_lock)).to_not be_locked
+    end
+  end
+
+  describe "#on_perform" do
+    it "unlocks the queue" do
+      process_one.on_perform do
+        expect(process_one).to_not be_locked
+      end
+    end
+
+    it "locks the runtime lock" do
+      process_one.on_perform do
+        expect(process_one.send(:runtime_lock)).to be_locked
+      end
+    end
+
+    it "unlocks the runtime lock after processing" do
+      process_one.on_perform do
+        process_one.send(:runtime_lock).batch_callback(:success, nil)
+        expect(process_one.send(:runtime_lock)).to_not be_locked
+      end
+    end
+
+    it "prevents other processes from executing" do
+      process_one.on_perform do
+        expect do
+          process_two.on_perform { }
+        end.to raise_error(CanvasSync::JobUniqueness::CouldNotLockError)
+      end
+    end
+  end
+end

data/spec/job_uniqueness/strategy/until_executed_spec.rb

@@ -0,0 +1,23 @@
+require 'job_uniqueness/spec_helper'
+
+RSpec.describe CanvasSync::JobUniqueness::Strategy::UntilExecuted do
+  include_context 'lock strategy specs', strategy: :until_executed
+
+  include_examples "a lock implementation"
+
+  describe "#on_enqueue" do
+    it "locks the queue" do
+      process_one.on_enqueue {}
+      expect(process_one).to be_locked
+    end
+  end
+
+  describe "#on_perform" do
+    it "unlocks after processing" do
+      process_one.on_enqueue {}
+      process_one.on_perform {}
+      process_one.batch_callback(:success, nil)
+      expect(process_one).to_not be_locked
+    end
+  end
+end

data/spec/job_uniqueness/strategy/until_executing_spec.rb

@@ -0,0 +1,23 @@
+require 'job_uniqueness/spec_helper'
+
+RSpec.describe CanvasSync::JobUniqueness::Strategy::UntilExecuting do
+  include_context 'lock strategy specs', strategy: :until_executing
+
+  include_examples "a lock implementation"
+
+  describe "#on_enqueue" do
+    it "locks the queue" do
+      process_one.on_enqueue {}
+      expect(process_one).to be_locked
+    end
+  end
+
+  describe "#on_perform" do
+    it "unlocks before processing" do
+      process_one.on_enqueue {}
+      process_one.on_perform do
+        expect(process_one).to_not be_locked
+      end
+    end
+  end
+end

data/spec/job_uniqueness/strategy/until_expired_spec.rb

@@ -0,0 +1,23 @@
+require 'job_uniqueness/spec_helper'
+
+RSpec.describe CanvasSync::JobUniqueness::Strategy::UntilExpired do
+  include_context 'lock strategy specs', strategy: :until_expired
+
+  # include_examples "a lock implementation"
+
+  describe "#on_enqueue" do
+    it "locks the queue" do
+      process_one.on_enqueue {}
+      expect(process_one).to be_locked
+    end
+  end
+
+  describe "#on_perform" do
+    it "does not unlock after processing" do
+      process_one.on_enqueue {}
+      process_one.on_perform {}
+      process_one.batch_callback(:success, nil)
+      expect(process_one).to be_locked
+    end
+  end
+end

data/spec/job_uniqueness/strategy/while_executing_spec.rb

@@ -0,0 +1,33 @@
+require 'job_uniqueness/spec_helper'
+
+RSpec.describe CanvasSync::JobUniqueness::Strategy::WhileExecuting do
+  include_context 'lock strategy specs', strategy: :while_executing
+
+  include_examples "a lock implementation"
+
+  describe "#on_enqueue" do
+    it "does not lock jobs" do
+      expect(process_one.on_enqueue {})
+      expect(process_one).not_to be_locked
+
+      expect(process_two.on_enqueue {})
+      expect(process_two).not_to be_locked
+    end
+  end
+
+  describe "#on_perform" do
+    it "locks the process" do
+      process_one.on_perform do
+        expect(process_one).to be_locked
+      end
+    end
+
+    it "prevents other processes from executing" do
+      process_one.on_perform do
+        expect do
+          process_two.on_perform { }
+        end.to raise_error(CanvasSync::JobUniqueness::CouldNotLockError)
+      end
+    end
+  end
+end

data/spec/job_uniqueness/support/lock_strategy.rb

@@ -0,0 +1,28 @@
+require 'job_uniqueness/spec_helper'
+
+RSpec.shared_context "lock strategy specs" do |strategy:|
+  include_context 'with TestWorker'
+
+  before(:each) { TestWorker.unique_job_options[:strategy] = strategy }
+
+  let(:context1) { CanvasSync::JobUniqueness::LockContext.new({ jid: 'j1', queue: 'default', job_clazz: 'TestWorker'}) }
+  let(:context2) { CanvasSync::JobUniqueness::LockContext.new({ jid: 'j2', queue: 'default', job_clazz: 'TestWorker'}) }
+
+  let(:process_one) { described_class.new(context1) }
+  let(:process_two) { described_class.new(context2) }
+end
+
+RSpec.shared_examples "a lock implementation" do
+  it "is unlocked when done" do
+    process_one.on_enqueue {}
+    did_lock = process_one.locked?
+
+    process_one.on_perform {}
+    did_lock ||= process_one.locked?
+
+    expect(did_lock).to be_truthy
+
+    process_one.batch_callback(:success, nil)
+    expect(process_one).not_to be_locked
+  end
+end

data/spec/job_uniqueness/support/on_conflict.rb

@@ -0,0 +1,24 @@
+
+RSpec.shared_context "on_conflict specs" do
+  include_context 'with TestWorker'
+  let(:lock_context) { CanvasSync::JobUniqueness::LockContext.new({ jid: 'j1', queue: 'default', job_clazz: 'TestWorker'}) }
+  let(:on_conflict) { described_class.new(lock_context)}
+end
+
+RSpec.shared_examples "OnConflict is compatible with" do |lock_strategies|
+  it "is compatible with the expected Lock Strategies" do
+    lock_strategies.each do |lock_strategy|
+      CanvasSync::JobUniqueness::OnConflict.validate!(described_class, lock_strategy)
+    end
+  end
+end
+
+RSpec.shared_examples "OnConflict is incompatible with" do |lock_strategies|
+  it "is not compatible with the expected Lock Strategies" do
+    lock_strategies.each do |lock_strategy|
+      expect do
+        CanvasSync::JobUniqueness::OnConflict.validate!(described_class, lock_strategy)
+      end.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/job_uniqueness/support/test_worker.rb

@@ -0,0 +1,19 @@
+require 'job_uniqueness/spec_helper'
+
+RSpec.shared_context "with TestWorker" do
+  let!(:worker) do
+    Class.new do
+      include Sidekiq::Worker
+
+      ensure_uniqueness(
+        strategy: :until_executed,
+      )
+
+      def perform; end
+    end
+  end
+
+  before(:each) { stub_const('TestWorker', worker) }
+
+  let(:lock_context) { CanvasSync::JobUniqueness::LockContext.new({ jid: 'j1', queue: 'default', job_clazz: 'TestWorker'}) }
+end

data/spec/job_uniqueness/unique_job_common_spec.rb

@@ -0,0 +1,45 @@
+require 'job_uniqueness/spec_helper'
+
+RSpec.describe CanvasSync::JobUniqueness::UniqueJobCommon do
+  describe ".unlock!" do
+    include_context "with TestWorker"
+
+    it "unlocks the lock with a specific JID" do
+      jid = TestWorker.perform_async
+      lctx = CanvasSync::JobUniqueness::LockContext.new({ jid: jid, queue: 'default', job_clazz: 'TestWorker'})
+      lstrat = lctx.lock_strategy
+      lsmith = lstrat.send(:locksmith)
+      expect(lsmith.locked?).to be_truthy
+
+      TestWorker.unlock!(jid, queue: 'default')
+      expect(lsmith.locked?).to be_falsey
+    end
+
+    it "unlocks the lock without a specific JID" do
+      jid = TestWorker.perform_async
+      lctx = CanvasSync::JobUniqueness::LockContext.new({ jid: jid, queue: 'default', job_clazz: 'TestWorker'})
+      lstrat = lctx.lock_strategy
+      lsmith = lstrat.send(:locksmith)
+      expect(lsmith.locked?).to be_truthy
+
+      TestWorker.unlock!(queue: 'default')
+      expect(lsmith.locked?).to be_falsey
+    end
+
+    it "unlocks the lock matching parameters" do
+      args = [1, 2, 3]
+      jid = TestWorker.perform_async(*args)
+
+      lctx = CanvasSync::JobUniqueness::LockContext.new({ jid: jid, queue: 'default', job_clazz: 'TestWorker', args: args})
+      lstrat = lctx.lock_strategy
+      lsmith = lstrat.send(:locksmith)
+      expect(lsmith.locked?).to be_truthy
+
+      TestWorker.unlock!(queue: 'default')
+      expect(lsmith.locked?).to be_truthy
+
+      TestWorker.unlock!(queue: 'default', args: args)
+      expect(lsmith.locked?).to be_falsey
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -19,7 +19,7 @@ require 'with_model'
 require 'sidekiq/testing'
 Sidekiq::Testing.fake!
 Sidekiq::Testing.server_middleware do |chain|
-  chain.add CanvasSync::JobBatches::Sidekiq::ServerMiddleware
+  chain.add CanvasSync::JobBatches::Compat::Sidekiq::ServerMiddleware
 end
 
 Dir[File.dirname(__FILE__) + "/job_batching/support/**/*.rb"].each {|f| require f }