canvas_sync 0.23.5 → 0.24.0.beta1

data/spec/job_uniqueness/strategy/base_spec.rb

@@ -1,100 +0,0 @@
-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_context] = context
-      expect(CanvasSync::JobBatches::Batch).not_to receive(:new)
-      strategy.send(:wrap_in_batch, &->{ })
-    ensure
-      Thread.current[:unique_jobs_previous_context] = 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

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

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

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

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

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

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

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

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

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