canvas_sync 0.23.4 → 0.24.0.beta1

data/spec/job_batching/pool_spec.rb

@@ -1,161 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe CanvasSync::JobBatches::Pool do
-  include ActiveJob::TestHelper
-
-  subject { described_class.new(order: pool_order, concurrency: pool_concurrency) }
-
-  let(:pool) { subject }
-
-  let(:pool_order) { :fifo }
-  let(:pool_concurrency) { 2 }
-
-  describe '#initialize' do
-    subject { described_class }
-
-    it 'creates pid when called without it' do
-      expect(subject.new.pid).not_to be_nil
-    end
-
-    it 'reuses pid when called with it' do
-      batch = subject.new('dayPO5KxuRXXxw')
-      expect(batch.pid).to eq('dayPO5KxuRXXxw')
-    end
-  end
-
-  def load_pool(count = 3)
-    jobs = count.times.map do |i|
-      { job: "BatchTestJobBase", args: [1] }
-    end
-    subject.add_jobs(jobs, skip_refill: true)
-  end
-
-  describe "#job_checked_in" do
-    it "gets called" do
-      expect(CanvasSync::JobBatches::Pool).to receive(:job_checked_in).twice
-      load_pool
-      perform_enqueued_jobs do
-        pool.send :refill_allotment
-        Sidekiq::Worker.drain_all
-      end
-    end
-
-    it "refills the pool" do
-      expect(CanvasSync::JobBatches::Pool).to receive(:job_checked_in).and_call_original.exactly(3).times
-
-      load_pool
-      perform_enqueued_jobs do
-        pool.send :refill_allotment
-        Sidekiq::Worker.drain_all
-      end
-    end
-  end
-
-  describe "#cleanup_if_empty" do
-    it "cleans if pool is empty and allowed to close" do
-      expect(pool).to receive(:cleanup_redis)
-      pool.cleanup_if_empty
-    end
-
-    it "doesn't clean if pool has pending" do
-      load_pool
-      expect(pool).to_not receive(:cleanup_redis)
-      pool.cleanup_if_empty
-    end
-
-    it "doesn't clean if pool has active" do
-      subject.redis.hset("#{subject.send(:redis_key)}-active", "blocked", "{}")
-      expect(pool).to_not receive(:cleanup_redis)
-      pool.cleanup_if_empty
-    end
-
-    it "doesn't clean if pool has activating" do
-      subject.redis.hincrby(subject.send(:redis_key), "_active_count", 1)
-      expect(pool).to_not receive(:cleanup_redis)
-      pool.cleanup_if_empty
-    end
-
-    it "doesn't clean if pool is empty but is kept open" do
-      pool.keep_open!
-      expect(pool).to_not receive(:cleanup_redis)
-      pool.cleanup_if_empty
-    end
-
-    it "doesn't clean if pool is empty but clean_when_empty is false" do
-      subject.redis.hset(subject.send(:redis_key), "clean_when_empty", "false")
-      expect(pool).to_not receive(:cleanup_redis)
-      pool.cleanup_if_empty
-    end
-  end
-
-  shared_examples "basic pool tests" do
-    describe "#push_job_to_pool" do
-      it "adds a job to the pool" do
-        subject.send(:push_job_to_pool, { job: 'job1' })
-        expect(subject.pending_count).to eq(1)
-      end
-    end
-
-    describe "#refill_allotment" do
-      it "refills the pool with jobs" do
-        load_pool
-        expect(CanvasSync::JobBatches::ChainBuilder).to receive(:enqueue_job).twice
-        subject.send(:refill_allotment)
-      end
-
-      it "limits to the concurrency count" do
-        load_pool
-        expect(CanvasSync::JobBatches::ChainBuilder).to receive(:enqueue_job).twice
-        expect(subject.send(:refill_allotment)).to eql 2
-        expect(subject.pending_count).to eql 1
-      end
-
-      it "considers already active jobs against concurrency" do
-        load_pool
-        subject.redis.hset("#{subject.send(:redis_key)}-active", "blocked", "{}")
-        expect(CanvasSync::JobBatches::ChainBuilder).to receive(:enqueue_job).once
-        expect(subject.send(:refill_allotment)).to eql 2
-        expect(subject.pending_count).to eql 2
-      end
-
-      it "considers activating jobs against concurrency" do
-        load_pool
-        subject.redis.hincrby(subject.send(:redis_key), "_active_count", 1)
-        expect(CanvasSync::JobBatches::ChainBuilder).to receive(:enqueue_job).once
-        expect(subject.send(:refill_allotment)).to eql 2
-        expect(subject.pending_count).to eql 2
-      end
-
-      it "doesn't fail if the pool is gone" do
-        load_pool
-        subject.cleanup_redis
-        expect(CanvasSync::JobBatches::ChainBuilder).not_to receive(:enqueue_job)
-        expect(subject.send(:refill_allotment)).to eql -1
-      end
-
-      it "doesn't fail if the pool is empty" do
-        expect(subject.send(:refill_allotment)).to eql 0
-      end
-    end
-  end
-
-  context "FIFO Pool" do
-    let(:pool_order) { :fifo }
-    it_behaves_like "basic pool tests"
-  end
-
-  context "LIFO Pool" do
-    let(:pool_order) { :lifo }
-    it_behaves_like "basic pool tests"
-  end
-
-  context "Random Pool" do
-    let(:pool_order) { :random }
-    it_behaves_like "basic pool tests"
-  end
-
-  context "Priority Pool" do
-    let(:pool_order) { :priority }
-    it_behaves_like "basic pool tests"
-  end
-end

data/spec/job_batching/status_spec.rb

@@ -1,76 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe CanvasSync::JobBatches::Batch::Status do
-  let(:batch) { CanvasSync::JobBatches::Batch.new() }
-  let(:bid) { batch.bid }
-  subject { described_class.new(bid) }
-
-  describe '#join' do
-    it 'raises info' do
-      expect { subject.join }.to raise_error('Not supported')
-    end
-  end
-
-  describe '#pending' do
-    context 'when not initalized' do
-      it 'returns 0 pending jobs' do
-        expect(subject.pending).to eq(0)
-      end
-    end
-
-    context 'when more than 0' do
-      before { batch.jobs do BatchTestWorker.perform_async end }
-      it 'returns pending jobs' do
-        expect(subject.pending).to eq(1)
-      end
-    end
-  end
-
-  describe '#failures' do
-    context 'when not initalized' do
-      it 'returns 0 failed jobs' do
-        expect(subject.failures).to eq(0)
-      end
-    end
-
-    context 'when more than 0' do
-      before { batch.append_jobs(bid) }
-      before { CanvasSync::JobBatches::Batch.process_failed_job(bid, 'FAILEDID') }
-
-      it 'returns failed jobs' do
-        expect(subject.failures).to eq(1)
-      end
-    end
-  end
-
-  describe '#failure_info' do
-    context 'when not initalized' do
-      it 'returns empty array' do
-        expect(subject.failure_info).to eq([])
-      end
-    end
-
-    context 'when with error' do
-      before { batch.jobs{}; CanvasSync::JobBatches::Batch.process_failed_job(bid, 'jid123') }
-
-      it 'returns array with failed jids' do
-        expect(subject.failure_info).to eq(['jid123'])
-      end
-    end
-  end
-
-  describe '#data' do
-    it 'returns batch description' do
-      expect(subject.data).to include(failures: 0, pending: 0, created_at: nil, complete: false, failure_info: [], parent_bid: nil)
-    end
-  end
-
-  describe '#created_at' do
-    it 'returns time' do
-      batch = CanvasSync::JobBatches::Batch.new
-      batch.jobs do BatchTestWorker.perform_async end
-      status = described_class.new(batch.bid)
-      expect(status.created_at).not_to be_nil
-    end
-  end
-end

data/spec/job_batching/support/base_job.rb

@@ -1,14 +0,0 @@
-class BatchTestJobBase < ActiveJob::Base
-  def perform(*args, **kwargs)
-  end
-
-  def self.perform_async(*args)
-    perform_later(*args)
-  end
-end
-
-class FailingBatchTestJobBase < BatchTestJobBase
-  def perform
-    raise "Foo"
-  end
-end

data/spec/job_batching/support/sample_callback.rb

@@ -1,2 +0,0 @@
-  class SampleCallback; end
-  class SampleCallback2; end

data/spec/job_uniqueness/compat/active_job_spec.rb

@@ -1,49 +0,0 @@
-require 'job_uniqueness/spec_helper'
-
-RSpec.describe CanvasSync::JobUniqueness::Compat::ActiveJob do
-  context 'Job Extension' do
-    it 'includes UniqueJobExtension' do
-      expect(ActiveJob::Base < CanvasSync::JobUniqueness::Compat::ActiveJob::JobExtension).to be true
-    end
-
-    it 'has the ensure_uniqueness method' do
-      expect(ActiveJob::Base.method(:ensure_uniqueness)).to be_present
-    end
-  end
-
-  context 'Job' do
-    let(:test_job) do
-      Class.new(ActiveJob::Base) do
-        ensure_uniqueness(
-          strategy: :until_executed,
-        )
-        def perform; end
-      end
-    end
-
-    before(:each) do
-      stub_const('TestJob', test_job)
-      ActiveJob::Base.queue_adapter = :sidekiq
-    end
-
-    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(test_job).to receive(:perform)
-
-      Sidekiq::Testing.inline! do
-        test_job.perform_later
-      end
-    end
-  end
-end

data/spec/job_uniqueness/compat/sidekiq_spec.rb

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

@@ -1,106 +0,0 @@
-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
-
-    it 'returns matching keys for equal hashes' do
-      context_data[:args] = [{ foo: 'bar', bar: 'foo' }]
-      key1 = lock_context.base_key
-      lock_context.instance_variable_set(:@base_key, nil)
-
-      context_data[:args] = [{ bar: 'foo', foo: 'bar' }]
-      key2 = lock_context.base_key
-
-      expect(key1).to eq key2
-    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

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

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

@@ -1,63 +0,0 @@
-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_context]).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
-
-  it "maintains a consistent lock_id" do
-    TestWorker.clear
-    TestWorker.unique_job_options.merge!({ strategy: :while_executing, on_conflict: :reschedule })
-
-    lock_context.handle_lifecycle!(:enqueue) {}
-    lock_context.handle_lifecycle!(:perform) {}
-
-    TestWorker.perform_async
-    j1 = TestWorker.jobs[0]
-    TestWorker.perform_one
-    j2 = TestWorker.jobs[0]
-
-    expect(j1).not_to eq(j2)
-    expect(j1['uniqueness_cache_data']['lid']).to be_present
-    expect(j1['uniqueness_cache_data']['lid']).to eq(j2['uniqueness_cache_data']['lid'])
-  end
-
-  it "unlocks after rescheduling" do
-    TestWorker.clear
-    TestWorker.unique_job_options.merge!({ strategy: :while_executing, on_conflict: :reschedule })
-
-    lock_context.handle_lifecycle!(:enqueue) {}
-    lock_context.handle_lifecycle!(:perform) {}
-
-    TestWorker.perform_async
-    expect(TestWorker.jobs.size).to eq(1)
-    TestWorker.perform_one
-    expect(TestWorker.jobs.size).to eq(1)
-
-    lock_context.lock_strategy.send(:unlock)
-    Sidekiq::Worker.drain_all
-    expect(TestWorker.jobs.size).to eq(0)
-
-    # Run another worker to validate that the lock was released
-    TestWorker.perform_async
-    TestWorker.perform_one
-    expect(TestWorker.jobs.size).to eq(0)
-  end
-end

data/spec/job_uniqueness/on_conflict_spec.rb

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

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