canvas_sync 0.27.6 → 0.27.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 989d9d326afba19afe5cb13a4388c8172b8e604a0ef4f6dbfc2ea8e98ee67b49
-  data.tar.gz: b110083dd70fb5d125b0935d44aa2321d5b5c5e1e2efa120d1d0c1ecba75ecae
+  metadata.gz: bc79a9e2241e08965571784e4078895a0be737b2075d9dc7068cee78fee90a39
+  data.tar.gz: 45a423897e00e97f90a785374ca10d967275874b61b1cb9a2afcfd69dccbb3bd
 SHA512:
-  metadata.gz: 6bb121b90fd24127e96fc76422a954839c88315a9cb7a33a8415c21b1d508a9a1691b2e31f6e5209e3a1146beb5a02113b434bda1c99ccab0e53b4c85eae0a1a
-  data.tar.gz: 1751fe22d8d16a80bd2c6e73ebe52ce9838494d56748cdc1142de01afa044071a46aaeab44b6c859326468e9e13777390d9b34c517be1954c16d63744a487de4
+  metadata.gz: 7389e3c5fdc2dcb65b2330b19d5850298dddcc8fcc1ed57873f79594ad5bae59c2754ab6b1f1ef8350e9d2cbe8442e2631ca4dd7d90eb64ef4be1e6909245d7a
+  data.tar.gz: 584dfdd57d8ff294560c62c584b46660f0177e3841a719bee167b13b879418c2553de007baad1b1866ad459234880219038d5037805da331b4a230ac5e2b3e07

data/lib/canvas_sync/concerns/deleted_scoping.rb

@@ -11,10 +11,8 @@ module CanvasSync::Concerns
 
     included do
       default_scope do
-        model = scope.try(:model) || scope
-
-        if model.try(:column_names)&.include?(:workflow_state)
-          scope.where.not(workflow_state: %w[deleted])
+        if column_names.include?("workflow_state")
+          where.not(workflow_state: %w[deleted])
         else
           all
         end

data/lib/canvas_sync/config.rb

@@ -1,8 +1,10 @@
 module CanvasSync
   class Config
-    include ActiveSupport::Configurable
+    attr_accessor :classes_to_only_log_errors_on, :redis_key_prefix
 
-    config_accessor(:classes_to_only_log_errors_on) { ["CanvasSync::Jobs::ReportChecker", "CanvasSync::Jobs::ReportSyncTask::CheckerJob"] }
-    config_accessor(:redis_key_prefix) { "cs" }
+    def initialize
+      @classes_to_only_log_errors_on = ["CanvasSync::Jobs::ReportChecker", "CanvasSync::Jobs::ReportSyncTask::CheckerJob"]
+      @redis_key_prefix = "cs"
+    end
   end
 end

data/lib/canvas_sync/engine.rb

@@ -41,7 +41,7 @@ module CanvasSync
         ensure
           ChronicDuration.raise_exceptions = origExc
         end
-      }
+      },
     }
 
     initializer 'canvas_sync.global_methods' do
@@ -74,7 +74,7 @@ module CanvasSync
               properties: {
                 job_log_retention: { **RETENTION_TYPE },
                 sync_batch_retention: { **RETENTION_TYPE },
-              }
+              },
             })
           end
 

data/lib/canvas_sync/generators/templates/models/assignment_override.rb

@@ -23,6 +23,6 @@ class AssignmentOverride < ApplicationRecord
     student_ids: ->(r) { JSON.parse(r[:student_ids]) if r[:student_ids].present? },
     canvas_group_id: :group_id,
     canvas_section_id: :course_section_id,
-    canvas_course_id: -> (r) { r.dig(:assignment, :course_id) }
+    canvas_course_id: -> (r) { r.dig(:assignment, :course_id) },
   }, -> (api) { api.assignment_override(canvas_assignment_id, canvas_id) })
 end

data/lib/canvas_sync/generators/templates/models/context_module.rb

@@ -35,7 +35,7 @@ class ContextModule < ApplicationRecord
     unlock_at: :unlock_at,
     completion_requirements: :completion_requirements,
     prerequisites: :prerequisites,
-    requirement_count: :requirement_count
+    requirement_count: :requirement_count,
   }, lambda { |api|
     course_modules = api.course_modules(canvas_context_id, { include: ['items'] }) # avoids having 2 API calls for modules as we reuse this data
     context_module = course_modules&.detect { |course_module| course_module['id'] == canvas_id }
@@ -53,7 +53,7 @@ class ContextModule < ApplicationRecord
       {
         id: course_module['id'],
         name: course_module['name'],
-        type: 'context_module'
+        type: 'context_module',
       }.with_indifferent_access
     end.compact
 

data/lib/canvas_sync/generators/templates/models/context_module_item.rb

@@ -18,7 +18,7 @@ class ContextModuleItem < ApplicationRecord
     position: :position,
     canvas_content_type: :type,
     canvas_content_id: :content_id,
-    canvas_assignment_id: :assignment_id
+    canvas_assignment_id: :assignment_id,
   }, lambda { |api|
     module_item = api.module_item(context_module.context.canvas_id, context_module.canvas_id, canvas_id)
     module_item['assignment_id'] = api.assignment(context_module.context.canvas_id, module_item['content_id'])['id'] if module_item['type'] == 'Assignment'

data/lib/canvas_sync/generators/templates/models/course_progress.rb

@@ -18,6 +18,6 @@ class CourseProgress < ApplicationRecord
     requirement_count: :requirement_count,
     requirement_completed_count: :requirement_completed_count,
     # provisioning report has completion_date instead of completed_at in the API
-    completion_date: :completed_at
+    completion_date: :completed_at,
   }, -> (api) { api.course_progress(canvas_course_id, canvas_user_id) })
 end

data/lib/canvas_sync/generators/templates/models/learning_outcome.rb

@@ -19,6 +19,6 @@ class LearningOutcome < ApplicationRecord
     vendor_guid: :vendor_guid,
     calculation_method: :calculation_method,
     calculation_int: :calculation_int,
-    description: :description
+    description: :description,
   }, ->(api) { api.get("/api/v1/outcomes/#{canvas_id}") })
 end

data/lib/canvas_sync/generators/templates/models/learning_outcome_result.rb

@@ -41,7 +41,7 @@ class LearningOutcomeResult < ActiveRecord::Base
     canvas_user_id: :links&.[]("user"),
     score: :score,
     assessed_at: :submitted_or_assessed_at,
-    percent: :percent
+    percent: :percent,
   }, ->(api) {
     api.get("/api/v1/courses/#{self.canvas_context_id}/#{self.canvas_id}")&.find { |item| item[:id] == self.canvas_id }
   })

data/lib/canvas_sync/importers/bulk_importer.rb

@@ -22,7 +22,7 @@ module CanvasSync
 
       # NEW: (report_file_path, klass, mapping, import_args: {}, &blk)
       # LEGACY: (report_file_path, columns, klass, conflict_target, import_args: {}, &blk)
-      def self.import(report_file_path, *args, import_args: {}, &blk) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/LineLength
+      def self.import(report_file_path, *args, import_args: {}, &blk) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         if args.length == 2
           klass = args[0]
           mapping = args[1]
@@ -129,7 +129,7 @@ module CanvasSync
 
         update_conditions = {
           condition: condition_sql(klass, columns, import_args[:sync_start_time]),
-          columns: columns
+          columns: columns,
         }
         update_conditions[:conflict_target] = conflict_target if conflict_target.present?
 

data/lib/canvas_sync/job.rb

@@ -32,7 +32,11 @@ module CanvasSync
           rescue => e2
             @job_log.backtrace += "\n\nError Occurred while handling an Error: #{e2.class}: #{e2.message}"
             @job_log.backtrace += "\n" + e2.backtrace.join('\n')
-            Raven.captureException(e2) if defined? Raven
+            if Rails.respond_to?(:error)
+              Rails.error.report(e2, handled: true)
+            elsif defined?(Sentry)
+              Sentry.capture_exception(e2)
+            end
           end
         end
         raise e

data/lib/canvas_sync/jobs/sync_provisioning_report_job.rb

@@ -20,7 +20,11 @@ module CanvasSync
 
         # Make sure the report also checks last_activity_at when checking updated_at
         if options[:models].include?("enrollments")
-          if (%w[last_activity_at total_activity_time] & CanvasSync::Concerns::SyncMapping.mapping_for(Enrollment)[:columns].keys).present? && merged_params.dig(:parameters, :include_last_activity) == nil
+          enrollment_columns = CanvasSync::Concerns::SyncMapping.mapping_for(Enrollment)[:columns].keys
+          tracks_last_activity = (%w[last_activity_at total_activity_time] & enrollment_columns).present?
+          include_last_activity_set = !merged_params.dig(:parameters, :include_last_activity).nil?
+
+          if tracks_last_activity && !include_last_activity_set
             merged_params[:parameters][:include_last_activity] = true
           end
         end

data/lib/canvas_sync/jobs/sync_submissions_job.rb

@@ -7,7 +7,7 @@ module CanvasSync
         merge_report_params(options, {
           include_all: options[:include_all],
           enrollment_batch_size: options[:enrollment_batch_size],
-          include_all_except: options[:include_all_except]
+          include_all_except: options[:include_all_except],
         })
       end
     end

data/lib/canvas_sync/live_events/process_event_job.rb

@@ -19,7 +19,11 @@ module CanvasSync::LiveEvents
       rescue => e
         throw e if Rails.env.test?
         Rails.logger.error("LiveEvent Handler raised Error: #{e}")
-        Raven.captureException(e) if defined? Raven
+        if Rails.respond_to?(:error)
+          Rails.error.report(e, handled: true)
+        elsif defined?(Sentry)
+          Sentry.capture_exception(e)
+        end
       end
     end
   end

data/lib/canvas_sync/version.rb

@@ -1,3 +1,3 @@
 module CanvasSync
-  VERSION = "0.27.6".freeze
+  VERSION = "0.27.7".freeze
 end

data/lib/canvas_sync.rb

@@ -151,7 +151,7 @@ module CanvasSync
       end
 
       model = scope.try(:model) || scope
-      if model.try(:column_names)&.include?(:workflow_state)
+      if model.try(:column_names)&.include?("workflow_state")
         return scope.where.not(workflow_state: %w[deleted])
       end
       Rails.logger.warn("Could not filter Syncable Scope for model '#{scope.try(:model)&.name || scope.name}'")
@@ -174,7 +174,7 @@ module CanvasSync
       term_scoped_models: DEFAULT_TERM_SCOPE_MODELS,
       options: {},
       **kwargs
-    ) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/LineLength
+    ) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       return unless models.present?
       models.map! &:to_s
       term_scope = term_scope.to_s if term_scope

data/spec/canvas_sync/canvas_sync_spec.rb

@@ -347,6 +347,94 @@ RSpec.describe CanvasSync do
   end
 
   describe ".sync_scope" do
+    it "uses .should_canvas_sync when the scope responds to it" do
+      filtered = double('filtered_scope')
+      scope = double('scope')
+      allow(scope).to receive(:should_canvas_sync).and_return(filtered)
 
+      expect(CanvasSync.sync_scope(scope)).to eq(filtered)
+    end
+
+    it "uses .active_for_canvas_sync when the scope responds to it" do
+      filtered = double('filtered_scope')
+      scope = double('scope')
+      allow(scope).to receive(:active_for_canvas_sync).and_return(filtered)
+
+      expect(CanvasSync.sync_scope(scope)).to eq(filtered)
+    end
+
+    it "uses .should_sync when the scope responds to it" do
+      filtered = double('filtered_scope')
+      scope = double('scope')
+      allow(scope).to receive(:should_sync).and_return(filtered)
+
+      expect(CanvasSync.sync_scope(scope)).to eq(filtered)
+    end
+
+    it "uses .active_for_sync when the scope responds to it" do
+      filtered = double('filtered_scope')
+      scope = double('scope')
+      allow(scope).to receive(:active_for_sync).and_return(filtered)
+
+      expect(CanvasSync.sync_scope(scope)).to eq(filtered)
+    end
+
+    context "the scope has none of the canvas_sync-specific methods, but does have .active" do
+      it "falls back to .active" do
+        # `Account` only defines `scope :active` (see the generator template); it does not
+        # define should_canvas_sync/active_for_canvas_sync/should_sync/active_for_sync.
+        expect(CanvasSync.sync_scope(Account).to_sql).to eq(Account.active.to_sql)
+      end
+    end
+
+    context "the scope has none of the recognized method conventions, but does have a workflow_state column" do
+      it "falls back to filtering out deleted rows" do
+        # `Group` has a workflow_state column but defines none of the sync-scope
+        # conventions (not even .active).
+        expect(CanvasSync.sync_scope(Group).to_sql).to eq(Group.where.not(workflow_state: %w[deleted]).to_sql)
+      end
+    end
+
+    context "the scope has none of the recognized method conventions and no workflow_state column" do
+      it "warns and returns the scope unchanged" do
+        # `CourseNickname` defines none of the sync-scope conventions and has no
+        # workflow_state column, so it falls through every branch.
+        expect(Rails.logger).to receive(:warn).with(/Could not filter Syncable Scope for model 'CourseNickname'/)
+
+        expect(CanvasSync.sync_scope(CourseNickname)).to eq(CourseNickname)
+      end
+    end
+  end
+
+  describe ".configure" do
+    after { CanvasSync.instance_variable_set(:@config, nil) }
+
+    it "yields the current CanvasSync::Config instance" do
+      yielded = nil
+      CanvasSync.configure { |c| yielded = c }
+
+      expect(yielded).to be_a(CanvasSync::Config)
+      expect(yielded).to equal(CanvasSync.config)
+    end
+
+    it "persists mutations made inside the block on .config" do
+      CanvasSync.configure { |c| c.redis_key_prefix = 'custom-prefix' }
+
+      expect(CanvasSync.config.redis_key_prefix).to eq('custom-prefix')
+    end
+  end
+
+  describe ".validate_live_events!" do
+    it "raises a helpful exception when an unsupported live event is given" do
+      expect {
+        CanvasSync.validate_live_events!(['course', 'bogus_event'])
+      }.to raise_error("Invalid live event(s) specified: bogus_event. Only #{CanvasSync::SUPPORTED_LIVE_EVENTS.join(', ')} are supported.")
+    end
+
+    it "does not raise when all live events are supported" do
+      expect {
+        CanvasSync.validate_live_events!(['course', 'enrollment', 'submission'])
+      }.to_not raise_error
+    end
   end
 end

data/spec/canvas_sync/concerns/deleted_scoping_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+RSpec.describe CanvasSync::Concerns::DeletedScoping do
+  with_model :ScopedWidget do
+    table do |t|
+      t.string :workflow_state
+    end
+    model do
+      include CanvasSync::Concerns::DeletedScoping
+    end
+  end
+
+  with_model :UnstatedWidget do
+    table do |t|
+      t.string :name
+    end
+    model do
+      include CanvasSync::Concerns::DeletedScoping
+    end
+  end
+
+  describe "default_scope" do
+    it "excludes deleted rows when the model has a workflow_state column" do
+      active = ScopedWidget.create!(workflow_state: 'active')
+      deleted = ScopedWidget.create!(workflow_state: 'deleted')
+
+      expect(ScopedWidget.all).to contain_exactly(active)
+      expect(ScopedWidget.with_deleted.all).to contain_exactly(active, deleted)
+    end
+
+    it "does not filter when the model has no workflow_state column" do
+      record = UnstatedWidget.create!(name: 'a widget')
+
+      expect(UnstatedWidget.all).to contain_exactly(record)
+    end
+  end
+
+  describe ".with_deleted" do
+    it "unscopes the workflow_state filter" do
+      active = ScopedWidget.create!(workflow_state: 'active')
+      deleted = ScopedWidget.create!(workflow_state: 'deleted')
+
+      expect(ScopedWidget.with_deleted).to contain_exactly(active, deleted)
+    end
+  end
+end

data/spec/canvas_sync/concerns/legacy_columns_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+RSpec.describe CanvasSync::Concerns::LegacyColumns do
+  with_model :Widget do
+    table do |t|
+      t.string :canvas_id
+    end
+    model do
+      include CanvasSync::Concerns::LegacyColumns
+    end
+  end
+
+  with_model :Gadget do
+    table do |t|
+      t.string :canvas_gadget_id
+    end
+    model do
+      include CanvasSync::Concerns::LegacyColumns
+    end
+  end
+
+  context 'when the table only has a canvas_id column' do
+    it 'aliases canvas_<model>_id to canvas_id so both read/write the same value' do
+      widget = Widget.new
+      widget.canvas_id = '123'
+      expect(widget.canvas_widget_id).to eq('123')
+
+      widget.canvas_widget_id = '456'
+      expect(widget.canvas_id).to eq('456')
+    end
+  end
+
+  context 'when the table only has a canvas_<model>_id column' do
+    it 'aliases canvas_id to canvas_<model>_id so both read/write the same value' do
+      gadget = Gadget.new
+      gadget.canvas_id = '789'
+      expect(gadget.canvas_gadget_id).to eq('789')
+
+      gadget.canvas_gadget_id = '321'
+      expect(gadget.canvas_id).to eq('321')
+    end
+  end
+
+  context 'on subclass inheritance' do
+    it "re-applies the aliasing (keyed off of the subclass's own name) via the inherited hook" do
+      # Defined with `class ... < ...; end` (rather than `Class.new(Widget)`) so that Ruby
+      # assigns the constant name *before* invoking Widget.inherited - LegacyColumns needs
+      # `cls.name` to build the per-subclass alias, same as any real STI model definition.
+      class SuperWidget < Widget; end
+
+      super_widget = SuperWidget.new
+      super_widget.canvas_id = 'abc'
+      expect(super_widget.canvas_superwidget_id).to eq('abc')
+
+      super_widget.canvas_superwidget_id = 'xyz'
+      expect(super_widget.canvas_id).to eq('xyz')
+    end
+  end
+end

data/spec/canvas_sync/engine_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+RSpec.describe "CanvasSync::Engine's canvas_sync.safe_yaml_classes initializer" do
+  # The initializer (lib/canvas_sync/engine.rb) whitelists Symbol and
+  # HashWithIndifferentAccess for AR's YAML-column permitted classes. Depending on the
+  # Rails version, that setting is exposed either as a class-level accessor on
+  # ActiveRecord::Base (older Rails) or as a global accessor on the ActiveRecord module
+  # (newer Rails). The initializer guards for both, and the app has already booted by
+  # the time specs run, so both possible locations should reflect the permitted classes.
+  it 'permits Symbol and HashWithIndifferentAccess wherever this Rails version exposes the setting' do
+    checked_any_location = false
+
+    if ActiveRecord::Base.respond_to?(:yaml_column_permitted_classes)
+      checked_any_location = true
+      expect(ActiveRecord::Base.yaml_column_permitted_classes).to include(Symbol, ActiveSupport::HashWithIndifferentAccess)
+    end
+
+    if ActiveRecord.respond_to?(:yaml_column_permitted_classes)
+      checked_any_location = true
+      expect(ActiveRecord.yaml_column_permitted_classes).to include(Symbol, ActiveSupport::HashWithIndifferentAccess)
+    end
+
+    expect(checked_any_location).to eq(true), "Expected this Rails version to expose yaml_column_permitted_classes somewhere"
+  end
+end

data/spec/canvas_sync/jobs/begin_sync_chain_job_spec.rb

@@ -0,0 +1,245 @@
+require 'spec_helper'
+
+RSpec.describe CanvasSync::Jobs::BeginSyncChainJob do
+  let(:job) { described_class.new }
+  let(:chain_definition) { { job: 'SomeJob' } }
+
+  # The real `JobBatches::Batch` persists to Redis and drives real job execution when
+  # `.jobs` is called. We stub it here so we can focus on BeginSyncChainJob's own
+  # responsibilities (computing updated_after, full-sync scheduling, refusing to run
+  # concurrently with another full sync, and creating/completing the SyncBatch record)
+  # without needing to actually run the downstream chain.
+  let(:batch_double) do
+    double('batch', bid: 'abc123').tap do |b|
+      allow(b).to receive(:description=)
+      allow(b).to receive(:on)
+      allow(b).to receive(:context=)
+      allow(b).to receive(:jobs).and_yield
+    end
+  end
+
+  before do
+    allow(CanvasSync::JobBatches::Batch).to receive(:new).and_return(batch_double)
+    allow(CanvasSync::JobBatches::SerialBatchJob).to receive(:perform_now)
+  end
+
+  describe '#perform' do
+    it 'creates a processing SyncBatch and stamps it with the new batch bid' do
+      expect {
+        job.perform(chain_definition, {})
+      }.to change { CanvasSync::SyncBatch.count }.by(1)
+
+      sync_batch = CanvasSync::SyncBatch.last
+      expect(sync_batch.status).to eq('processing')
+      expect(sync_batch.batch_genre).to eq('default')
+      expect(sync_batch.batch_bid).to eq('abc123')
+      expect(sync_batch.started_at).to be_present
+    end
+
+    it 'runs the chain definition inside a top-level SerialBatchJob, within the new Batch' do
+      expect(batch_double).to receive(:jobs).and_yield
+      expect(CanvasSync::JobBatches::SerialBatchJob).to receive(:perform_now)
+        .with(chain_definition, description: "Top Serial Batch")
+
+      job.perform(chain_definition, {})
+    end
+
+    it 'registers :complete and :success callbacks that finalize the SyncBatch' do
+      expect(batch_double).to receive(:on).with(:complete, "#{described_class}.batch_completed", sync_batch_id: anything)
+      expect(batch_double).to receive(:on).with(:success, "#{described_class}.batch_completed", sync_batch_id: anything)
+
+      job.perform(chain_definition, {})
+    end
+
+    context 'updated_after is not given' do
+      it 'derives updated_after from the day before the last completed SyncBatch of the same genre' do
+        # Note: `should_full_sync?` unconditionally forces a full sync (updated_after: nil)
+        # whenever there is no prior *full* sync at all, regardless of schedule. So we need a
+        # prior full-sync batch to exist, and we pin full_sync_every to a schedule that's
+        # clearly not due yet, so the derived delta value isn't overridden.
+        last_batch = CanvasSync::SyncBatch.create!(started_at: 10.days.ago, status: 'completed', full_sync: true, batch_genre: 'default')
+
+        job.perform(chain_definition, { full_sync_every: '99 days' })
+
+        expect(job.globals[:updated_after]).to eq((last_batch.started_at - 1.day).iso8601)
+      end
+
+      it 'defaults full_sync_every to "sunday/2" when not otherwise specified' do
+        job.perform(chain_definition, {})
+        expect(job.globals[:full_sync_every]).to eq('sunday/2')
+      end
+
+      it 'leaves updated_after nil (a full sync) when there is no prior completed SyncBatch' do
+        job.perform(chain_definition, {})
+
+        expect(job.globals[:updated_after]).to be_nil
+        expect(CanvasSync::SyncBatch.last.full_sync).to eq(true)
+      end
+
+      it 'only considers completed SyncBatches of the same genre' do
+        CanvasSync::SyncBatch.create!(started_at: 2.days.ago, status: 'completed', full_sync: true, batch_genre: 'other_genre')
+        recent_same_genre = CanvasSync::SyncBatch.create!(started_at: 10.days.ago, status: 'completed', full_sync: true, batch_genre: 'my_genre')
+
+        job.perform(chain_definition, { batch_genre: 'my_genre', full_sync_every: '99 days' })
+
+        expect(job.globals[:updated_after]).to eq((recent_same_genre.started_at - 1.day).iso8601)
+      end
+    end
+
+    context 'updated_after: false is explicitly given' do
+      it 'clears updated_after without computing a default full_sync_every' do
+        job.perform(chain_definition, { updated_after: false })
+
+        expect(job.globals[:updated_after]).to be_nil
+        expect(job.globals[:full_sync_every]).to be_nil
+      end
+    end
+
+    context 'a truthy updated_after value is given' do
+      it 'keeps the given value as-is' do
+        # A prior full sync must already exist, otherwise should_full_sync? unconditionally
+        # forces a full sync the first time around (see note above).
+        CanvasSync::SyncBatch.create!(started_at: 1.year.ago, status: 'completed', full_sync: true, batch_genre: 'default')
+
+        job.perform(chain_definition, { updated_after: '2024-01-01T00:00:00Z' })
+
+        expect(job.globals[:updated_after]).to eq('2024-01-01T00:00:00Z')
+        expect(CanvasSync::SyncBatch.last.full_sync).to eq(false)
+      end
+    end
+
+    context 'a same-genre full sync is already processing' do
+      it 'refuses to start a new sync, warns, and does not create a SyncBatch' do
+        CanvasSync::SyncBatch.create!(started_at: 1.hour.ago, status: 'processing', full_sync: true, batch_genre: 'default')
+
+        expect(Rails.logger).to receive(:warn).with(/Attempted to start a 'default' sync while a full-sync is still processing/)
+        expect(CanvasSync::JobBatches::Batch).to_not receive(:new)
+
+        expect {
+          job.perform(chain_definition, {})
+        }.to_not change { CanvasSync::SyncBatch.count }
+      end
+
+      it 'does not block a sync of a different genre' do
+        CanvasSync::SyncBatch.create!(started_at: 1.hour.ago, status: 'processing', full_sync: true, batch_genre: 'other_genre')
+
+        expect {
+          job.perform(chain_definition, { batch_genre: 'default' })
+        }.to change { CanvasSync::SyncBatch.count }.by(1)
+      end
+    end
+
+    context 'a same-genre full sync is processing but started over 12 hours ago' do
+      it 'treats it as stale and starts a new sync anyway' do
+        CanvasSync::SyncBatch.create!(started_at: 13.hours.ago, status: 'processing', full_sync: true, batch_genre: 'default')
+
+        expect {
+          job.perform(chain_definition, {})
+        }.to change { CanvasSync::SyncBatch.count }.by(1)
+      end
+    end
+
+    context 'should_full_sync? schedule is due' do
+      it 'forces a full sync (nil updated_after) even if an updated_after was given' do
+        allow_any_instance_of(described_class).to receive(:should_full_sync?).and_return(true)
+
+        job.perform(chain_definition, { updated_after: '2024-01-01T00:00:00Z' })
+
+        expect(job.globals[:updated_after]).to be_nil
+        expect(CanvasSync::SyncBatch.last.full_sync).to eq(true)
+      end
+    end
+  end
+
+  describe '#should_full_sync?' do
+    let(:job) { described_class.new }
+    before { allow(job).to receive(:genre).and_return('default') }
+
+    it 'returns true when there is no prior full sync of this genre' do
+      expect(job.should_full_sync?(nil)).to eq(true)
+    end
+
+    it 'returns false when a full sync exists but the option is not a String' do
+      CanvasSync::SyncBatch.create!(status: 'completed', full_sync: true, batch_genre: 'default', started_at: 1.month.ago)
+      expect(job.should_full_sync?(nil)).to eq(false)
+    end
+
+    it 'returns false for an unrecognized schedule format' do
+      CanvasSync::SyncBatch.create!(status: 'completed', full_sync: true, batch_genre: 'default', started_at: 1.month.ago)
+      expect(job.should_full_sync?('not-a-real-schedule')).to eq(false)
+    end
+
+    context 'a "<weekday>/<skip weeks>" schedule (e.g. "sunday/2")' do
+      it 'is true only on the matching weekday once the skip period has elapsed' do
+        Timecop.travel(DateTime.new(2024, 1, 7)) do # a Sunday
+          CanvasSync::SyncBatch.create!(status: 'completed', full_sync: true, batch_genre: 'default', started_at: 3.weeks.ago)
+          expect(job.should_full_sync?('sunday/2')).to eq(true)
+        end
+      end
+
+      it 'is false on the matching weekday if the skip period has not yet elapsed' do
+        Timecop.travel(DateTime.new(2024, 1, 7)) do # a Sunday
+          CanvasSync::SyncBatch.create!(status: 'completed', full_sync: true, batch_genre: 'default', started_at: 1.week.ago)
+          expect(job.should_full_sync?('sunday/2')).to eq(false)
+        end
+      end
+
+      it 'is false on a non-matching weekday even if the skip period has elapsed' do
+        Timecop.travel(DateTime.new(2024, 1, 8)) do # a Monday
+          CanvasSync::SyncBatch.create!(status: 'completed', full_sync: true, batch_genre: 'default', started_at: 3.weeks.ago)
+          expect(job.should_full_sync?('sunday/2')).to eq(false)
+        end
+      end
+    end
+
+    context 'a "<N>%" schedule' do
+      before do
+        CanvasSync::SyncBatch.create!(status: 'completed', full_sync: true, batch_genre: 'default', started_at: 1.month.ago)
+      end
+
+      it 'is true when the random roll lands under the given percentage' do
+        allow(job).to receive(:rand).with(100).and_return(10)
+        expect(job.should_full_sync?('50%')).to eq(true)
+      end
+
+      it 'is false when the random roll lands at or above the given percentage' do
+        allow(job).to receive(:rand).with(100).and_return(90)
+        expect(job.should_full_sync?('50%')).to eq(false)
+      end
+    end
+
+    context 'a "<N> days" schedule' do
+      it 'is true once at least N days have elapsed since the last full sync' do
+        CanvasSync::SyncBatch.create!(status: 'completed', full_sync: true, batch_genre: 'default', started_at: 5.days.ago)
+        expect(job.should_full_sync?('4 days')).to eq(true)
+      end
+
+      it 'is false when fewer than N days have elapsed' do
+        CanvasSync::SyncBatch.create!(status: 'completed', full_sync: true, batch_genre: 'default', started_at: 1.day.ago)
+        expect(job.should_full_sync?('4 days')).to eq(false)
+      end
+    end
+  end
+
+  describe '.batch_completed' do
+    it 'marks the SyncBatch as completed when the batch succeeded' do
+      sync_batch = CanvasSync::SyncBatch.create!(status: 'processing', started_at: Time.now)
+      status = double('status', success?: true)
+
+      described_class.batch_completed(status, { 'sync_batch_id' => sync_batch.id })
+
+      sync_batch.reload
+      expect(sync_batch.status).to eq('completed')
+      expect(sync_batch.completed_at).to be_present
+    end
+
+    it 'marks the SyncBatch as failed when the batch did not succeed' do
+      sync_batch = CanvasSync::SyncBatch.create!(status: 'processing', started_at: Time.now)
+      status = double('status', success?: false)
+
+      described_class.batch_completed(status, { 'sync_batch_id' => sync_batch.id })
+
+      expect(sync_batch.reload.status).to eq('failed')
+    end
+  end
+end

data/spec/canvas_sync/jobs/job_spec.rb

@@ -62,5 +62,63 @@ RSpec.describe CanvasSync::Job do
       job_log = CanvasSync::JobLog.last
       expect(job_log.backtrace).to include "Error Occurred while handling an Error"
     end
+
+    it 'reports a failing error handler via Rails.error when available' do
+      error_reporter = double("ErrorReporter")
+      allow(Rails).to receive(:respond_to?).and_call_original
+      allow(Rails).to receive(:respond_to?).with(:error).and_return(true)
+      allow(Rails).to receive(:error).and_return(error_reporter)
+      expect(error_reporter).to receive(:report).with(instance_of(EvilError), handled: true)
+
+      set_batch_context(on_failure: 'BadJob.evil_catcher')
+      expect {
+        BadJob.perform_now()
+      }.to raise_exception(StandardError)
+    end
+
+    it 'falls back to Sentry when Rails.error is not available (pre-Rails-7 hosts)' do
+      allow(Rails).to receive(:respond_to?).and_call_original
+      allow(Rails).to receive(:respond_to?).with(:error).and_return(false)
+      sentry = double("Sentry", get_current_scope: nil)
+      stub_const("Sentry", sentry)
+      expect(sentry).to receive(:capture_exception).with(instance_of(EvilError))
+
+      set_batch_context(on_failure: 'BadJob.evil_catcher')
+      expect {
+        BadJob.perform_now()
+      }.to raise_exception(StandardError)
+    end
+
+    it 'does not attempt to report anywhere when neither Rails.error nor Sentry is available' do
+      allow(Rails).to receive(:respond_to?).and_call_original
+      allow(Rails).to receive(:respond_to?).with(:error).and_return(false)
+      hide_const("Sentry") if defined?(Sentry)
+
+      set_batch_context(on_failure: 'BadJob.evil_catcher')
+      expect {
+        BadJob.perform_now()
+      }.to raise_exception(StandardError)
+      # No error raised by the reporting guard -- reaching here proves it.
+    end
+  end
+
+  describe 'before_enqueue' do
+    it 'verifies the ActiveRecord connection before the job is enqueued' do
+      ActiveJob::Base.queue_adapter = :test
+
+      expect(ActiveRecord::Base.connection).to receive(:verify!).once.and_call_original
+
+      GoodJob.perform_later("argument")
+    end
+
+    it 'still creates a CanvasSync::JobLog after verifying the connection' do
+      ActiveJob::Base.queue_adapter = :test
+
+      expect {
+        GoodJob.perform_later("argument")
+      }.to change { CanvasSync::JobLog.count }.by(1)
+
+      expect(CanvasSync::JobLog.last.status).to eq(CanvasSync::JobLog::ENQUEUED_STATUS)
+    end
   end
 end

data/spec/canvas_sync/jobs/term_batches_job_spec.rb

@@ -0,0 +1,181 @@
+require 'spec_helper'
+
+RSpec.describe CanvasSync::Jobs::TermBatchesJob do
+  let(:job) { described_class.new }
+  let(:redis_double) { double('redis', get: nil) }
+
+  before do
+    allow(CanvasSync).to receive(:redis).and_return(redis_double)
+    allow(CanvasSync::JobBatches::Batch).to receive(:current_context).and_return({ batch_genre: 'default' })
+  end
+
+  # Stubs CanvasSync::JobBatches::ManagedBatchJob.make_batch (or ConcurrentBatchJob.make_batch)
+  # to record each invocation and yield a fake "batch proxy" double, without touching real Redis
+  # or actually enqueuing anything.
+  def stub_make_batch(klass)
+    calls = []
+    allow(klass).to receive(:make_batch) do |sub_jobs, **kwargs, &blk|
+      proxy = double("batch_proxy")
+      allow(proxy).to receive(:description=) { |v| calls.last[:description] = v }
+      allow(proxy).to receive(:context=) { |v| calls.last[:context] = v }
+      allow(proxy).to receive(:on) { |*args| (calls.last[:on] ||= []) << args }
+
+      calls << { sub_jobs: sub_jobs, kwargs: kwargs }
+      blk.call(proxy) if blk
+      proxy
+    end
+    calls
+  end
+
+  describe '#perform' do
+    context 'no sub_jobs are given' do
+      it 'does nothing' do
+        expect(CanvasSync::JobBatches::ManagedBatchJob).to_not receive(:make_batch)
+        expect(CanvasSync::JobBatches::ConcurrentBatchJob).to_not receive(:make_batch)
+
+        job.perform({})
+      end
+    end
+
+    context 'term_scope: false' do
+      it 'forks all sub_jobs into a single ConcurrentBatchJob covering every term at once' do
+        calls = stub_make_batch(CanvasSync::JobBatches::ConcurrentBatchJob)
+        expect(CanvasSync::JobBatches::ManagedBatchJob).to_not receive(:make_batch)
+        jobs = [{ job: 'SomeJob' }]
+
+        job.perform(sub_jobs: jobs, term_scope: false, context: { foo: 'bar' })
+
+        expect(calls.length).to eq(1)
+        expect(calls[0][:sub_jobs]).to eq(jobs)
+        expect(calls[0][:kwargs]).to eq(context: { foo: 'bar' }, concurrency: 8)
+        expect(calls[0][:description]).to eq('All Terms')
+      end
+    end
+
+    context 'term_scope is not given' do
+      let!(:matching_term) { FactoryBot.create(:term) }
+      let!(:other_term) { FactoryBot.create(:term) }
+
+      it 'forks a ManagedBatchJob per Term returned by CanvasSync.sync_scope(Term)' do
+        allow(CanvasSync).to receive(:sync_scope).with(Term).and_return(Term.where(canvas_id: matching_term.canvas_id))
+        calls = stub_make_batch(CanvasSync::JobBatches::ManagedBatchJob)
+        jobs = [{ job: 'SomeJob' }]
+
+        job.perform(sub_jobs: jobs)
+
+        expect(CanvasSync).to have_received(:sync_scope).with(Term)
+        expect(calls.length).to eq(1)
+        expect(calls[0][:sub_jobs]).to eq(jobs)
+        expect(calls[0][:kwargs]).to eq(ordered: false, concurrency: 8)
+        expect(calls[0][:description]).to eq("Term##{matching_term.canvas_id} Fork")
+        expect(calls[0][:context][:canvas_term_id]).to eq(matching_term.canvas_id)
+      end
+    end
+
+    context 'term_scope: true' do
+      let!(:matching_term) { FactoryBot.create(:term) }
+
+      it 'also uses CanvasSync.sync_scope(Term), same as when term_scope is omitted' do
+        allow(CanvasSync).to receive(:sync_scope).with(Term).and_return(Term.where(canvas_id: matching_term.canvas_id))
+        calls = stub_make_batch(CanvasSync::JobBatches::ManagedBatchJob)
+
+        job.perform(sub_jobs: [{ job: 'SomeJob' }], term_scope: true)
+
+        expect(CanvasSync).to have_received(:sync_scope).with(Term)
+        expect(calls.length).to eq(1)
+      end
+    end
+
+    context 'term_scope is a Symbol' do
+      let!(:term) { FactoryBot.create(:term) }
+
+      it "uses Term.send(term_scope) instead of CanvasSync.sync_scope" do
+        allow(Term).to receive(:my_custom_scope).and_return(Term.where(canvas_id: term.canvas_id))
+        calls = stub_make_batch(CanvasSync::JobBatches::ManagedBatchJob)
+
+        job.perform(sub_jobs: [{ job: 'SomeJob' }], term_scope: :my_custom_scope)
+
+        expect(Term).to have_received(:my_custom_scope)
+        expect(calls.length).to eq(1)
+        expect(calls[0][:context][:canvas_term_id]).to eq(term.canvas_id)
+      end
+    end
+
+    context 'per-term last-sync tracking in Redis' do
+      let!(:term) { FactoryBot.create(:term, canvas_id: 55555) }
+
+      before do
+        allow(Term).to receive(:my_scope).and_return(Term.where(canvas_id: term.canvas_id))
+      end
+
+      it "registers a .batch_finished success callback and uses the term-specific redis key" do
+        calls = stub_make_batch(CanvasSync::JobBatches::ManagedBatchJob)
+
+        job.perform(sub_jobs: [{ job: 'SomeJob' }], term_scope: :my_scope)
+
+        expect(redis_double).to have_received(:get).with("cs:default:55555:last_sync")
+        expect(calls[0][:on]).to include([:success, "CanvasSync::Jobs::TermBatchesJob.batch_finished"])
+      end
+
+      it "does not register the success callback when mark_synced: false" do
+        calls = stub_make_batch(CanvasSync::JobBatches::ManagedBatchJob)
+
+        job.perform(sub_jobs: [{ job: 'SomeJob' }], term_scope: :my_scope, mark_synced: false)
+
+        expect(calls[0][:on]).to be_nil
+      end
+
+      it "overrides the term's updated_after with nil when the term has never been synced" do
+        allow(redis_double).to receive(:get).and_return(nil)
+        set_batch_context(updated_after: '2024-06-01T00:00:00Z')
+        calls = stub_make_batch(CanvasSync::JobBatches::ManagedBatchJob)
+
+        job.perform(sub_jobs: [{ job: 'SomeJob' }], term_scope: :my_scope)
+
+        expect(calls[0][:context]).to have_key(:updated_after)
+        expect(calls[0][:context][:updated_after]).to be_nil
+      end
+
+      it "overrides the term's updated_after with its own last-sync time when that is more recent than the batch cutoff" do
+        allow(redis_double).to receive(:get).and_return('2024-01-01T00:00:00Z')
+        set_batch_context(updated_after: '2024-06-01T00:00:00Z')
+        calls = stub_make_batch(CanvasSync::JobBatches::ManagedBatchJob)
+
+        job.perform(sub_jobs: [{ job: 'SomeJob' }], term_scope: :my_scope)
+
+        expect(calls[0][:context][:updated_after]).to eq('2024-01-01T00:00:00Z')
+      end
+
+      it "leaves the term's context updated_after alone when the term already synced after the batch cutoff" do
+        allow(redis_double).to receive(:get).and_return('2024-06-15T00:00:00Z')
+        set_batch_context(updated_after: '2024-06-01T00:00:00Z')
+        calls = stub_make_batch(CanvasSync::JobBatches::ManagedBatchJob)
+
+        job.perform(sub_jobs: [{ job: 'SomeJob' }], term_scope: :my_scope)
+
+        expect(calls[0][:context]).to_not have_key(:updated_after)
+      end
+    end
+  end
+
+  describe '.batch_finished' do
+    it "stores the batch's start time in redis, namespaced by prefix/genre/term" do
+      allow(CanvasSync::JobBatches::Batch).to receive(:current_context).and_return({
+        canvas_term_id: 42,
+        batch_start_time: '2024-01-01T00:00:00Z',
+        batch_genre: 'default',
+      })
+      expect(redis_double).to receive(:set).with('cs:default:42:last_sync', '2024-01-01T00:00:00Z')
+
+      described_class.batch_finished(double('status'), {})
+    end
+  end
+
+  describe '.last_sync_key' do
+    it 'builds a redis key namespaced by the configured prefix, the current batch genre, and the term id' do
+      allow(CanvasSync::JobBatches::Batch).to receive(:current_context).and_return({ batch_genre: 'nightly' })
+
+      expect(described_class.last_sync_key(7)).to eq('cs:nightly:7:last_sync')
+    end
+  end
+end

data/spec/canvas_sync/live_events/process_event_job_spec.rb

@@ -35,5 +35,44 @@ RSpec.describe CanvasSync::LiveEvents::ProcessEventJob do
       expect_any_instance_of(User).to receive(:process_live_event).with(:created, event["payload"], event["metadata"])
       described_class.perform_now(event)
     end
+
+    context "when a handler raises outside the test environment" do
+      before do
+        hide_const("LiveEvents::UserCreatedEvent")
+        allow(Rails.env).to receive(:test?).and_return(false)
+        allow_any_instance_of(User).to receive(:process_live_event).and_raise(StandardError, "boom")
+      end
+
+      it "logs the error and reports it via Rails.error when available" do
+        error_reporter = double("ErrorReporter")
+        allow(Rails).to receive(:respond_to?).and_call_original
+        allow(Rails).to receive(:respond_to?).with(:error).and_return(true)
+        allow(Rails).to receive(:error).and_return(error_reporter)
+        expect(error_reporter).to receive(:report).with(instance_of(StandardError), handled: true)
+        expect(Rails.logger).to receive(:error).with(/LiveEvent Handler raised Error/)
+
+        described_class.perform_now(event)
+      end
+
+      it "falls back to Sentry when Rails.error is not available (pre-Rails-7 hosts)" do
+        allow(Rails).to receive(:respond_to?).and_call_original
+        allow(Rails).to receive(:respond_to?).with(:error).and_return(false)
+        sentry = double("Sentry", get_current_scope: nil)
+        stub_const("Sentry", sentry)
+        expect(sentry).to receive(:capture_exception).with(instance_of(StandardError))
+        expect(Rails.logger).to receive(:error).with(/LiveEvent Handler raised Error/)
+
+        described_class.perform_now(event)
+      end
+
+      it "does not attempt to report anywhere when neither Rails.error nor Sentry is available" do
+        allow(Rails).to receive(:respond_to?).and_call_original
+        allow(Rails).to receive(:respond_to?).with(:error).and_return(false)
+        hide_const("Sentry") if defined?(Sentry)
+        expect(Rails.logger).to receive(:error).with(/LiveEvent Handler raised Error/)
+
+        described_class.perform_now(event)
+      end
+    end
   end
 end

data/spec/canvas_sync/models/job_log_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+RSpec.describe CanvasSync::JobLog do
+  describe 'job_arguments serialization' do
+    it 'round-trips a Hash (including nested structures) through the job_arguments column' do
+      payload = { 'a' => 1, 'nested' => { 'b' => [1, 2, 3], 'c' => nil } }
+
+      job_log = CanvasSync::JobLog.create!(
+        job_class: 'SomeJob',
+        job_id: SecureRandom.uuid,
+        status: CanvasSync::JobLog::ENQUEUED_STATUS,
+        job_arguments: [payload, 'a string arg', 42],
+      )
+
+      reloaded = CanvasSync::JobLog.find(job_log.id)
+      expect(reloaded.job_arguments).to eq([payload, 'a string arg', 42])
+    end
+
+    it 'defaults to an empty Array when no job_arguments are given' do
+      job_log = CanvasSync::JobLog.create!(
+        job_class: 'SomeJob',
+        job_id: SecureRandom.uuid,
+        status: CanvasSync::JobLog::ENQUEUED_STATUS,
+      )
+
+      expect(CanvasSync::JobLog.find(job_log.id).job_arguments).to eq([])
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,3 +1,8 @@
+require 'simplecov'
+SimpleCov.start do
+  add_filter '/spec/'
+end
+
 ENV["RAILS_ENV"] ||= 'test'
 ENV['REDIS_URL'] ||= 'redis://localhost:6379/9'
 
@@ -6,6 +11,7 @@ Bundler.require :default, :development
 
 Combustion::Application.configure do
   config.enable_reloading = true # Required for with_model
+  config.active_support.deprecation = :raise
 end
 
 # Register application/jwt MIME type for testing

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: canvas_sync
 version: !ruby/object:Gem::Version
-  version: 0.27.6
+  version: 0.27.7
 platform: ruby
 authors:
 - Instructure CustomDev
@@ -121,6 +121,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: shoulda-matchers
   requirement: !ruby/object:Gem::Requirement
@@ -275,20 +289,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: open-uri
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: activejob
   requirement: !ruby/object:Gem::Requirement
@@ -569,6 +569,10 @@ files:
 - lib/canvas_sync/version.rb
 - lib/tasks/canvas_sync_tasks.rake
 - spec/canvas_sync/canvas_sync_spec.rb
+- spec/canvas_sync/concerns/deleted_scoping_spec.rb
+- spec/canvas_sync/concerns/legacy_columns_spec.rb
+- spec/canvas_sync/engine_spec.rb
+- spec/canvas_sync/jobs/begin_sync_chain_job_spec.rb
 - spec/canvas_sync/jobs/canvas_process_waiter_spec.rb
 - spec/canvas_sync/jobs/job_spec.rb
 - spec/canvas_sync/jobs/report_starter_spec.rb
@@ -578,6 +582,7 @@ files:
 - spec/canvas_sync/jobs/sync_roles_job_spec.rb
 - spec/canvas_sync/jobs/sync_simple_table_job_spec.rb
 - spec/canvas_sync/jobs/sync_terms_job_spec.rb
+- spec/canvas_sync/jobs/term_batches_job_spec.rb
 - spec/canvas_sync/live_events/live_event_sync_spec.rb
 - spec/canvas_sync/live_events/live_events_controller_spec.rb
 - spec/canvas_sync/live_events/process_event_job_spec.rb
@@ -592,6 +597,7 @@ files:
 - spec/canvas_sync/models/enrollment_spec.rb
 - spec/canvas_sync/models/group_membership_spec.rb
 - spec/canvas_sync/models/group_spec.rb
+- spec/canvas_sync/models/job_log_spec.rb
 - spec/canvas_sync/models/roles_spec.rb
 - spec/canvas_sync/models/section_spec.rb
 - spec/canvas_sync/models/submission_spec.rb
@@ -762,6 +768,10 @@ specification_version: 4
 summary: Gem for generating Canvas models and migrations and syncing data from Canvas
 test_files:
 - spec/canvas_sync/canvas_sync_spec.rb
+- spec/canvas_sync/concerns/deleted_scoping_spec.rb
+- spec/canvas_sync/concerns/legacy_columns_spec.rb
+- spec/canvas_sync/engine_spec.rb
+- spec/canvas_sync/jobs/begin_sync_chain_job_spec.rb
 - spec/canvas_sync/jobs/canvas_process_waiter_spec.rb
 - spec/canvas_sync/jobs/job_spec.rb
 - spec/canvas_sync/jobs/report_starter_spec.rb
@@ -771,6 +781,7 @@ test_files:
 - spec/canvas_sync/jobs/sync_roles_job_spec.rb
 - spec/canvas_sync/jobs/sync_simple_table_job_spec.rb
 - spec/canvas_sync/jobs/sync_terms_job_spec.rb
+- spec/canvas_sync/jobs/term_batches_job_spec.rb
 - spec/canvas_sync/live_events/live_event_sync_spec.rb
 - spec/canvas_sync/live_events/live_events_controller_spec.rb
 - spec/canvas_sync/live_events/process_event_job_spec.rb
@@ -785,6 +796,7 @@ test_files:
 - spec/canvas_sync/models/enrollment_spec.rb
 - spec/canvas_sync/models/group_membership_spec.rb
 - spec/canvas_sync/models/group_spec.rb
+- spec/canvas_sync/models/job_log_spec.rb
 - spec/canvas_sync/models/roles_spec.rb
 - spec/canvas_sync/models/section_spec.rb
 - spec/canvas_sync/models/submission_spec.rb