canvas_sync 0.21.1.beta1 → 0.22.0.beta1

data/lib/canvas_sync/job_uniqueness/strategy/base.rb

@@ -0,0 +1,104 @@
+module CanvasSync::JobUniqueness
+  module Strategy
+    class Base
+      attr_reader :lock_context
+
+      def initialize(lock_context)
+        @lock_context = lock_context
+        @conflict_strategies = {}
+      end
+
+      class_attribute :_locks_on, instance_writer: false
+
+      def self.locks_on(*origins)
+        if origins.present?
+          orgins = Array(origins).map(&:to_sym)
+          self._locks_on = origins
+        else
+          self._locks_on || [:enqueue, :perform]
+        end
+      end
+
+      def on_enqueue; end
+      def on_perform; end
+
+      def batch_callback(event, batch_status)
+        if event == :success
+          unlock
+        else
+          unlock_cond = lock_context.config[:unlock_on_failure]
+
+          if (event == :complete && unlock_cond == :any) || (event == :death && unlock_cond == :death) || (event == :stagnated && unlock_cond == :stagnant)
+            unlock
+          end
+        end
+      end
+
+      delegate :locked?, to: :locksmith
+
+      protected
+
+      def key
+        lock_context.base_key
+      end
+
+      def wrap_in_batch(&blk)
+        if Thread.current[:unique_jobs_previous_jid] # Ensure we don't re-wrap in a batch when rescheduling
+          return blk.call
+        end
+
+        batch = CanvasSync::JobBatches::Batch.new
+        batch.context = {
+          uniqueness_lock_key: key,
+        }
+
+        CanvasSync::JobBatches::Batch::Callback::VALID_CALLBACKS.each do |callback|
+          callback = callback.to_sym
+          batch.on(callback, self.class.to_s + ".internal_batch_callback", {
+            event: callback,
+            lock_strategy: self.class.to_s,
+            lock_key: key,
+            lock_context: lock_context.serialize,
+          })
+        end
+
+        batch.jobs do
+          return blk.call
+        end
+      end
+
+      def self.internal_batch_callback(batch_status, opts)
+        strategy_class = opts[:lock_strategy].constantize
+        lock_context = LockContext.from_serialized(opts[:lock_context])
+        strategy = strategy_class.new(lock_context)
+        # TODO Should this route through LockContext#handle_lifecycle!?
+        strategy.batch_callback(opts[:event].to_sym, batch_status)
+      end
+
+      def lock!(purpose, wait: nil)
+        locked = nil
+        if purpose == :enqueue
+          if Thread.current[:unique_jobs_previous_jid].present?
+            locked = locksmith.swap_locks(Thread.current[:unique_jobs_previous_jid])
+          else
+            locked = locksmith.lock()
+          end
+        elsif purpose == :perform
+          locked = locksmith.execute { lock_context.job_id }
+        end
+
+        CanvasSync::JobUniqueness.logger.debug { "Requested lock of #{key} for #{purpose} - (#{locked || 'Not Obtained!'})" }
+
+        raise CouldNotLockError.new(lock_context, source: purpose) if !locked
+      end
+
+      def unlock()
+        locksmith.unlock
+      end
+
+      def locksmith
+        @locksmith ||= Locksmith.new(key, lock_context)
+      end
+    end
+  end
+end

data/lib/canvas_sync/job_uniqueness/strategy/until_and_while_executing.rb

@@ -0,0 +1,35 @@
+module CanvasSync::JobUniqueness
+  module Strategy
+    # Implements two locks - one while enqueued and one while performing
+    class UntilAndWhileExecuting < Base
+      locks_on :enqueue, :perform
+
+      def on_enqueue
+        # Obtain lock
+        lock!(:enqueue)
+
+        # Proceed with enqueuing the job, wrapping it in a batch
+        runtime_lock.on_enqueue do
+          yield
+        end
+      end
+
+      def on_perform
+        # Obtain Runtime lock
+        runtime_lock.on_perform do
+          # Release Queue lock
+          unlock()
+
+          # Run the job
+          yield
+        end
+      end
+
+      private
+
+      def runtime_lock
+        @runtime_lock ||= Strategy::WhileExecuting.new(lock_context)
+      end
+    end
+  end
+end

data/lib/canvas_sync/job_uniqueness/strategy/until_executed.rb

@@ -0,0 +1,20 @@
+module CanvasSync::JobUniqueness
+  module Strategy
+    class UntilExecuted < Base
+      locks_on :enqueue, :perform
+
+      def on_enqueue
+        lock!(:enqueue)
+
+        wrap_in_batch do
+          yield
+        end
+      end
+
+      def on_perform
+        lock!(:perform)
+        yield
+      end
+    end
+  end
+end

data/lib/canvas_sync/job_uniqueness/strategy/until_executing.rb

@@ -0,0 +1,20 @@
+module CanvasSync::JobUniqueness
+  module Strategy
+    class UntilExecuting < Base
+      locks_on :enqueue
+
+      def on_enqueue
+        lock!(:enqueue)
+        yield
+      end
+
+      def on_perform
+        unlock
+        yield
+      end
+
+      # TODO Define behavior when an error occurs during perform().
+      # SUJ's behavior is to relock, but this has some edge-cases (like how do we handle if another job already took the lock?)
+    end
+  end
+end

data/lib/canvas_sync/job_uniqueness/strategy/until_expired.rb

@@ -0,0 +1,16 @@
+module CanvasSync::JobUniqueness
+  module Strategy
+    class UntilExpired < UntilExecuted
+      locks_on :enqueue, :perform
+
+      def on_enqueue
+        lock!(:enqueue)
+        yield
+      end
+
+      def on_perform
+        lock!(:perform)
+      end
+    end
+  end
+end

data/lib/canvas_sync/job_uniqueness/strategy/while_executing.rb

@@ -0,0 +1,26 @@
+module CanvasSync::JobUniqueness
+  module Strategy
+    class WhileExecuting < Base
+      locks_on :perform
+
+      RUN_SUFFIX = ":RUN"
+
+      def on_enqueue
+        wrap_in_batch do
+          yield
+        end
+      end
+
+      def on_perform
+        lock!(:perform)
+        yield
+      end
+
+      protected
+
+      def key
+        super + RUN_SUFFIX
+      end
+    end
+  end
+end

data/lib/canvas_sync/job_uniqueness/strategy.rb

@@ -0,0 +1,27 @@
+module CanvasSync::JobUniqueness
+  module Strategy
+    extend ActiveSupport::Autoload
+
+    autoload :Base
+
+    autoload :UntilExpired
+    autoload :UntilExecuted
+    autoload :UntilExecuting
+    autoload :UntilAndWhileExecuting
+    autoload :WhileExecuting
+
+    class << self
+      def lookup(strategy)
+        matching_strategy(strategy.to_s.camelize) ||
+          CanvasSync::JobUniqueness.config.lock_strategies[strategy] ||
+          raise(ArgumentError, "strategy: #{strategy} is not found. Is it declared in the configuration?")
+      end
+
+      private
+
+      def matching_strategy(const)
+        const_get(const, false) if const_defined?(const, false)
+      end
+    end
+  end
+end

data/lib/canvas_sync/job_uniqueness/unique_job_common.rb

@@ -0,0 +1,79 @@
+
+module CanvasSync::JobUniqueness
+  module UniqueJobCommon
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :unique_job_options, instance_writer: false
+    end
+
+    class_methods do
+      # ensure_uniqueness(
+      #   strategy: :until_executed, # :until_executed, :until_executing, :until_expired, :until_and_while_executing, :while_executing
+      #   on_conflict: :raise, # :raise, :replace, :log, :reject, :reschedule, { enqueue: ..., perform: ... }, proc
+      #   lock_ttl: 7.days, # seconds
+      #   lock_timeout: 0, # seconds
+
+      #   scope: :per_queue, # :global, :per_queue, string ("<class>-<queue>"), proc
+      #   hash: ->{ { ... } },
+
+      #   # In the case of UntilExecuted and WhileExecuting, how should the execution lock be released in an error condition?
+      #   #  :any - Release the lock when the Job's (implicit) Batch is :complete
+      #   #  :death - Release the lock when the Job's Batch receives the :death callback
+      #   #  :stagnant - Release the lock when the Job's Batch receives the :stagnant callback
+      #   #  :expire - Do not release the lock until it expires
+      #   unlock_on_failure: :stagnant,
+      # )
+      def ensure_uniqueness(**kwargs)
+        if self.unique_job_options.present?
+          raise ArgumentError, "ensure_uniqueness can only be called once per job class"
+        end
+
+        begin
+          require "sidekiq_unique_jobs"
+        rescue LoadError
+          raise LoadError, "SidekiqUniqueJobs is required for ensure_uniqueness"
+        end
+
+        OnConflict.validate!(kwargs[:on_conflict], kwargs[:strategy]) if kwargs[:on_conflict].present?
+
+        kwargs[:scope] ||= :per_queue
+        kwargs[:ttl] ||= 30.days.to_i
+        kwargs[:timeout] ||= 0
+        kwargs[:limit] ||= 1
+
+        self.unique_job_options = kwargs
+
+        include UniqueJobMethods
+      end
+    end
+
+    module UniqueJobMethods
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def unlock!(jid = nil, args: nil, kwargs: nil, queue: nil)
+          queue = self.try(:default_queue_name) || try(:queue)
+          raise ArgumentError, "Must specify queue:" unless queue.is_a?(String) || queue.is_a?(Symbol)
+
+          temp_context = LockContext.new({ job_clazz: self, jid: jid, queue: queue, args: args, kwargs: kwargs })
+          strategy = temp_context.lock_strategy
+          locksmith = strategy.send(:locksmith)
+
+          if jid
+            locksmith.unlock!()
+          else
+            locksmith.locked_jids.each do |jid|
+              unlock!(jid, args: args, kwargs: kwargs, queue: queue)
+            end
+          end
+        end
+
+        # def unlock_all!(queue: :all)
+        #   # TODO Public API to manually remove all locks for this class
+        # end
+      end
+
+    end
+  end
+end

data/lib/canvas_sync/misc_helper.rb

@@ -34,7 +34,7 @@ module CanvasSync
         # TODO Support globalid
         model_class = load_constant(job[:model])
         find_by = job[:find_by]
-        target = find_by.is_a?(Hash) ? model_class.find_by(find_by) : model_class.find_by(id: find_by)
+        target = find_by.is_a?(Hash) ? model_class.find_by(**find_by) : model_class.find_by(id: find_by)
         target.send(job[:method], *job_args, **job_kwargs)
       elsif job[:class]
         target = load_constant(job[:class])

data/lib/canvas_sync/version.rb

@@ -1,3 +1,3 @@
 module CanvasSync
-  VERSION = "0.21.1.beta1".freeze
+  VERSION = "0.22.0.beta1".freeze
 end

data/lib/canvas_sync.rb

@@ -16,6 +16,7 @@ require "canvas_sync/batch_processor"
 require "canvas_sync/config"
 
 require "canvas_sync/job_batches/batch"
+require "canvas_sync/job_uniqueness/job_uniqueness"
 
 Dir[File.dirname(__FILE__) +  "/canvas_sync/jobs/*.rb"].each { |file| require file }
 Dir[File.dirname(__FILE__) +  "/canvas_sync/processors/*.rb"].each { |file| require file }
@@ -249,7 +250,7 @@ module CanvasSync
       global_options[:account_id] = account_id if account_id.present?
       global_options.merge!(globals) if globals
 
-      JobBatches::ChainBuilder.build(CanvasSync::Jobs::BeginSyncChainJob, [], global_options, &blk)
+      JobBatches::ChainBuilder.build(CanvasSync::Jobs::BeginSyncChainJob, *[], **global_options, &blk)
     end
 
     def group_by_job_options(model_list, options_hash, only_split: nil, default_key: :provisioning)
@@ -338,7 +339,7 @@ module CanvasSync
     def logger
       return @logger if defined? @logger
       @logger = Logger.new(STDOUT)
-      @logger.level = Logger::DEBUG
+      @logger.level = Logger::WARN
       @logger
     end
 
@@ -347,7 +348,7 @@ module CanvasSync
     end
 
     def redis_prefix
-      pfx = "cs"
+      pfx = config.redis_key_prefix
       pfx = "#{Apartment::Tenant.current}:#{pfx}" if defined?(Apartment)
       pfx
     end

data/spec/dummy/app/models/rubric.rb

@@ -17,8 +17,9 @@ class Rubric < ApplicationRecord
   belongs_to :rubric, primary_key: :canvas_id, foreign_key: :canvas_rubric_id , optional: true # based on another rubric
   belongs_to :context, polymorphic: true, primary_key: :canvas_id, foreign_key: :canvas_context_id, foreign_type: :canvas_context_type, optional: true
 
-  has_many :rubric_associations, primary_key: :canvas_id, foreign_key: :canvas_association_id, foreign_type: :canvas_association_type
   has_many :rubric_assessments, through: :rubric_associations, dependent: :destroy
+  has_many :rubric_associations, primary_key: :canvas_id, foreign_key: :canvas_rubric_id
+  has_many :associated_objects, through: :rubric_associations, source: :association_object
 
   api_syncable({
     canvas_id: :id,

data/spec/dummy/config/environments/test.rb

@@ -5,7 +5,7 @@ Rails.application.configure do
   # test suite. You never need to work with it otherwise. Remember that
   # your test database is "scratch space" for the test suite and is wiped
   # and recreated between test runs. Don't rely on the data there!
-  config.cache_classes = true
+  config.cache_classes = false
 
   # Do not eager load code on boot. This avoids loading your whole application
   # just for the purpose of running a single test. If you are using a tool that

data/spec/job_batching/batch_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-class TestWorker < BatchTestJobBase
+class BatchTestWorker < BatchTestJobBase
   def perform
   end
 end
@@ -173,6 +173,48 @@ RSpec.describe CanvasSync::JobBatches::Batch do
     end
   end
 
+  describe '#process_dead_job' do
+    let(:batch) { CanvasSync::JobBatches::Batch.new }
+    let(:bid) { batch.bid }
+    let(:jid) { 'ABCD' }
+    before { CanvasSync::JobBatches::Batch.redis { |r| r.hset("BID-#{bid}", 'pending', 1) } }
+
+    context 'dead' do
+      let(:failed_jid) { 'xxx' }
+
+      it 'tries to call death callback' do
+        allow(CanvasSync::JobBatches::Batch).to receive(:enqueue_callbacks).with(:stagnated, bid)
+        expect(CanvasSync::JobBatches::Batch).to receive(:enqueue_callbacks).with(:death, bid)
+        CanvasSync::JobBatches::Batch.process_dead_job(bid, failed_jid)
+      end
+
+      it 'add job to failed list' do
+        CanvasSync::JobBatches::Batch.process_dead_job(bid, 'failed-job-id')
+        CanvasSync::JobBatches::Batch.process_dead_job(bid, failed_jid)
+        failed = CanvasSync::JobBatches::Batch.redis { |r| r.smembers("BID-#{bid}-dead") }
+        expect(failed).to contain_exactly('xxx', 'failed-job-id')
+      end
+
+      it 'automattically triggers the :stagnated callback' do
+        expect(CanvasSync::JobBatches::Batch).to receive(:enqueue_callbacks).with(:stagnated, bid)
+        allow(CanvasSync::JobBatches::Batch).to receive(:enqueue_callbacks).with(:death, bid)
+        CanvasSync::JobBatches::Batch.process_dead_job(bid, failed_jid)
+      end
+
+      it 'does not trigger :stagnated if pending jobs are still present' do
+        CanvasSync::JobBatches::Batch.redis { |r| r.hset("BID-#{bid}", 'pending', 2) }
+        expect(CanvasSync::JobBatches::Batch).to_not receive(:enqueue_callbacks).with(:stagnated, bid)
+        CanvasSync::JobBatches::Batch.process_dead_job(bid, failed_jid)
+      end
+
+      it 'does not trigger :stagnated if pending batches are still present' do
+        CanvasSync::JobBatches::Batch.redis { |r| r.hset("BID-#{bid}", 'pending', 2) }
+        expect(CanvasSync::JobBatches::Batch).to_not receive(:enqueue_callbacks).with(:stagnated, bid)
+        CanvasSync::JobBatches::Batch.process_dead_job(bid, failed_jid)
+      end
+    end
+  end
+
   describe '#process_successful_job' do
     let(:batch) { CanvasSync::JobBatches::Batch.new }
     let(:bid) { batch.bid }
@@ -182,7 +224,7 @@ RSpec.describe CanvasSync::JobBatches::Batch do
     context 'complete' do
       before { batch.on(:complete, Object) }
       # before { batch.increment_job_queue(bid) }
-      # before { batch.jobs do TestWorker.perform_async end }
+      # before { batch.jobs do BatchTestWorker.perform_async end }
       # before { CanvasSync::JobBatches::Batch.process_failed_job(bid, 'failed-job-id') }
 
       it 'tries to call complete callback' do
@@ -211,7 +253,7 @@ RSpec.describe CanvasSync::JobBatches::Batch do
 
       it 'triggers callbacks as expected' do
         ActiveJob::Base.queue_adapter = :sidekiq
-        CanvasSync::JobBatches::Batch::Callback.worker_class = CanvasSync::JobBatches::Sidekiq::SidekiqCallbackWorker
+        CanvasSync::JobBatches::Batch::Callback.worker_class = CanvasSync::JobBatches::Compat::Sidekiq::SidekiqCallbackWorker
 
         callback_instance = double('SampleCallback')
         expect(SampleCallback).to receive(:new).at_least(1).times.and_return(callback_instance)
@@ -229,7 +271,7 @@ RSpec.describe CanvasSync::JobBatches::Batch do
 
       it 'delays triggering callbacks if keep_open is set' do
         ActiveJob::Base.queue_adapter = :sidekiq
-        CanvasSync::JobBatches::Batch::Callback.worker_class = CanvasSync::JobBatches::Sidekiq::SidekiqCallbackWorker
+        CanvasSync::JobBatches::Batch::Callback.worker_class = CanvasSync::JobBatches::Compat::Sidekiq::SidekiqCallbackWorker
 
         callback_instance = double('SampleCallback')
         expect(SampleCallback).to receive(:new).at_least(1).times.and_return(callback_instance)
@@ -303,7 +345,7 @@ RSpec.describe CanvasSync::JobBatches::Batch do
     let(:batch) { CanvasSync::JobBatches::Batch.new }
 
     it 'increments pending' do
-      batch.jobs do TestWorker.perform_async end
+      batch.jobs do BatchTestWorker.perform_async end
       pending = CanvasSync::JobBatches::Batch.redis { |r| r.hget("BID-#{batch.bid}", 'pending') }
       expect(pending).to eq('1')
     end
@@ -338,7 +380,7 @@ RSpec.describe CanvasSync::JobBatches::Batch do
 
     context 'With ActiveJob Adapter' do
       around(:all) do |block|
-        CanvasSync::JobBatches::Batch::Callback.worker_class = CanvasSync::JobBatches::ActiveJob::ActiveJobCallbackWorker
+        CanvasSync::JobBatches::Batch::Callback.worker_class = CanvasSync::JobBatches::Compat::ActiveJob::ActiveJobCallbackWorker
         block.run
       end
 
@@ -396,7 +438,7 @@ RSpec.describe CanvasSync::JobBatches::Batch do
 
     context 'With Sidekiq Adapter' do
       around(:all) do |block|
-        CanvasSync::JobBatches::Batch::Callback.worker_class = CanvasSync::JobBatches::Sidekiq::SidekiqCallbackWorker
+        CanvasSync::JobBatches::Batch::Callback.worker_class = CanvasSync::JobBatches::Compat::Sidekiq::SidekiqCallbackWorker
         block.run
       end
 

data/spec/job_batching/{active_job_spec.rb → compat/active_job_spec.rb}

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
-RSpec.describe CanvasSync::JobBatches::ActiveJob do
-  describe CanvasSync::JobBatches::ActiveJob::BatchAwareJob do
+RSpec.describe CanvasSync::JobBatches::Compat::ActiveJob do
+  describe CanvasSync::JobBatches::Compat::ActiveJob::BatchAwareJob do
     include ActiveJob::TestHelper
 
     after do

data/spec/job_batching/{sidekiq_spec.rb → compat/sidekiq_spec.rb}

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
-RSpec.describe CanvasSync::JobBatches::Sidekiq do
-  describe CanvasSync::JobBatches::Sidekiq::ServerMiddleware do
+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
@@ -44,7 +44,7 @@ RSpec.describe CanvasSync::JobBatches::Sidekiq do
     end
   end
 
-  describe CanvasSync::JobBatches::Sidekiq::ClientMiddleware do
+  describe CanvasSync::JobBatches::Compat::Sidekiq::ClientMiddleware do
     context 'when without batch' do
       it 'just yields' do
         yielded = false
@@ -80,16 +80,17 @@ RSpec.describe CanvasSync::JobBatches::Sidekiq do
   end
 end
 
-RSpec.describe CanvasSync::JobBatches::Sidekiq do
-  let(:config) { class_double(Sidekiq) }
+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
-      expect(Sidekiq).to receive(:configure_client).and_yield(config)
+      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::Sidekiq::ClientMiddleware)
-      CanvasSync::JobBatches::Sidekiq.configure
+      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
 
@@ -98,14 +99,15 @@ RSpec.describe CanvasSync::JobBatches::Sidekiq do
     let(:death_handlers) { double(Array) }
 
     it 'adds client and server middleware' do
-      expect(Sidekiq).to receive(:configure_server).and_yield(config)
+      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::Sidekiq::ClientMiddleware)
-      expect(server_middleware).to receive(:add).with(CanvasSync::JobBatches::Sidekiq::ServerMiddleware)
+      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::Sidekiq.configure
+      CanvasSync::JobBatches::Compat::Sidekiq.instance_variable_set(:@already_configured, false)
+      CanvasSync::JobBatches::Compat::Sidekiq.configure
     end
   end
 

data/spec/job_batching/flow_spec.rb

@@ -29,7 +29,7 @@ RSpec.describe 'Batch flow' do
 
       batch.jobs do
         3.times do
-          TestWorker.perform_async
+          BatchTestWorker.perform_async
         end
       end
 

data/spec/job_batching/integration_helper.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 require 'sidekiq/testing'
 
 Sidekiq::Testing.server_middleware do |chain|
-  chain.add CanvasSync::JobBatches::Sidekiq::ServerMiddleware
+  chain.add CanvasSync::JobBatches::Compat::Sidekiq::ServerMiddleware
 end
 
 CanvasSync.redis { |r| r.flushdb }

data/spec/job_batching/status_spec.rb

@@ -19,7 +19,7 @@ RSpec.describe CanvasSync::JobBatches::Batch::Status do
     end
 
     context 'when more than 0' do
-      before { batch.jobs do TestWorker.perform_async end }
+      before { batch.jobs do BatchTestWorker.perform_async end }
       it 'returns pending jobs' do
         expect(subject.pending).to eq(1)
       end
@@ -68,7 +68,7 @@ RSpec.describe CanvasSync::JobBatches::Batch::Status do
   describe '#created_at' do
     it 'returns time' do
       batch = CanvasSync::JobBatches::Batch.new
-      batch.jobs do TestWorker.perform_async end
+      batch.jobs do BatchTestWorker.perform_async end
       status = described_class.new(batch.bid)
       expect(status.created_at).not_to be_nil
     end

data/spec/job_uniqueness/compat/active_job_spec.rb

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