canvas_sync 0.26.1 → 0.27.1.beta2

data/spec/canvas_sync/jobs/report_sync_task_spec.rb

@@ -0,0 +1,367 @@
+require 'spec_helper'
+
+RSpec.describe CanvasSync::Jobs::ReportSyncTask do
+  class SyncSpecsTask < CanvasSync::Jobs::ReportSyncTask
+    report_name 'sync_specs_csv'
+
+    def report_parameters
+      merge_report_params(options, { include_all: options[:include_all] })
+    end
+  end
+
+  let(:batch_context) { { canvas_term_id: 1 }.with_indifferent_access }
+
+  def stub_batch_context(context = batch_context)
+    report_batch = instance_double(CanvasSync::JobBatches::Batch,
+      context: { report_class: 'SyncSpecsTask', report_options: {} })
+    parent_batch = instance_double(CanvasSync::JobBatches::Batch, context: context)
+
+    allow(CanvasSync::JobBatches::Batch).to receive(:current).and_return(report_batch)
+    allow(CanvasSync::JobBatches::Batch).to receive(:current_context).and_return(context)
+    allow(report_batch).to receive(:parent).and_return(parent_batch)
+  end
+
+  def create_job(job_class, context = batch_context)
+    job_class.new.tap { |job| allow(job).to receive(:batch_context).and_return(context) }
+  end
+
+  describe "#report_parameters" do
+    before { allow(CanvasSync::JobBatches::Batch).to receive(:current_context).and_return(batch_context) }
+
+    it "merges batch context parameters" do
+      task = SyncSpecsTask.new({}, { canvas_term_id: 123, updated_after: '2024-01-01' }, {})
+      allow(CanvasSync::JobBatches::Batch).to receive(:current_context)
+        .and_return({ canvas_term_id: 123, updated_after: '2024-01-01' })
+
+      expect(task.report_parameters).to eq({
+        parameters: { enrollment_term_id: 123, updated_after: '2024-01-01', include_all: nil }
+      })
+    end
+
+    it "merges options parameters" do
+      task = SyncSpecsTask.new({ canvas_term_id: 456, include_all: true }, {}, {})
+      allow(CanvasSync::JobBatches::Batch).to receive(:current_context).and_return({})
+
+      expect(task.report_parameters).to eq({
+        parameters: { enrollment_term_id: 456, include_all: true }
+      })
+    end
+
+    it "prioritizes options over batch context" do
+      task = SyncSpecsTask.new({ canvas_term_id: 789 }, {}, {})
+      allow(CanvasSync::JobBatches::Batch).to receive(:current_context)
+        .and_return({ canvas_term_id: 123 })
+
+      expect(task.report_parameters[:parameters][:enrollment_term_id]).to eq(789)
+    end
+
+    it "merges report_params and report_parameters from options" do
+      task = SyncSpecsTask.new({
+        report_params: { custom: 'value' },
+        report_parameters: { another: 'value' }
+      }, {}, {})
+      allow(CanvasSync::JobBatches::Batch).to receive(:current_context).and_return({})
+
+      params = task.report_parameters[:parameters]
+      expect(params[:custom]).to eq('value')
+      expect(params[:another]).to eq('value')
+    end
+  end
+
+  describe ".perform_later" do
+    it "creates a batch and enqueues StarterJob" do
+      batch = instance_double(CanvasSync::JobBatches::Batch)
+      allow(CanvasSync::JobBatches::Batch).to receive(:new).and_return(batch)
+      allow(batch).to receive(:description=)
+      allow(batch).to receive(:allow_context_changes=)
+      allow(batch).to receive(:context).and_return({})
+
+      expect(batch).to receive(:jobs) do |&block|
+        expect(SyncSpecsTask::StarterJob).to receive(:perform_later)
+        block.call
+      end
+
+      SyncSpecsTask.perform_later({ include_all: true })
+    end
+  end
+
+  describe ".from_context" do
+    it "reconstructs task from batch context" do
+      stub_batch_context({ canvas_term_id: 1 })
+      allow(CanvasSync::JobBatches::Batch.current).to receive(:context)
+        .and_return({ report_class: 'SyncSpecsTask', report_options: { include_all: true } })
+
+      task = CanvasSync::Jobs::ReportSyncTask.from_context
+
+      expect(task).to be_a(SyncSpecsTask)
+      expect(task.options).to eq({ include_all: true })
+    end
+  end
+
+  describe described_class::StarterJob do
+    let(:client) { instance_double(Bearcat::Client) }
+
+    before do
+      stub_batch_context
+      allow_any_instance_of(Bearcat::Client).to receive(:start_report)
+        .and_return("id" => 123)
+    end
+
+    it "starts the report and enqueues checker" do
+      expect_any_instance_of(Bearcat::Client).to receive(:start_report)
+        .with("self", "sync_specs_csv", { parameters: { enrollment_term_id: 1, include_all: nil } })
+      expect(SyncSpecsTask::CheckerJob).to receive(:set).with(wait: anything)
+        .and_return(double(perform_later: nil))
+
+      job = create_job(SyncSpecsTask::StarterJob)
+      job.perform
+
+      expect(batch_context[:report_attempt]).to eq(1)
+      expect(batch_context[:report_id]).to eq("sync_specs_csv/123")
+    end
+
+    it "enqueues CheckerJob with wait time" do
+      checker_double = double
+      expect(SyncSpecsTask::CheckerJob).to receive(:set).with(wait: anything)
+        .and_return(checker_double)
+      expect(checker_double).to receive(:perform_later)
+
+      job = create_job(SyncSpecsTask::StarterJob)
+      job.perform
+    end
+
+    it "sets sync_start_time in batch context" do
+      allow(SyncSpecsTask::CheckerJob).to receive(:set)
+        .and_return(double(perform_later: nil))
+
+      job = create_job(SyncSpecsTask::StarterJob)
+      job.perform
+
+      expect(batch_context[:sync_start_time]).to be_present
+    end
+
+    context "with caching enabled" do
+      let(:redis_double) { double('Redis') }
+      let(:cache_key) { "SyncBatch[batch-123]:abc123def" }
+
+      before do
+        # CanvasSync.redis can be called with or without a block
+        allow(CanvasSync).to receive(:redis) do |&block|
+          if block
+            block.call(redis_double)
+          else
+            redis_double
+          end
+        end
+        batch_context[:sync_batch_id] = 'batch-123'
+      end
+
+      it "uses cached report when available and fresh" do
+        batch_context[:report_caching] = { scope: :sync_batch, max_age: 23.hours }
+        cached_data = {
+          "report_id" => "sync_specs_csv/999",
+          "started_at" => 1.hour.ago.iso8601
+        }
+
+        expect(redis_double).to receive(:hgetall).with(anything).and_return(cached_data)
+        expect_any_instance_of(Bearcat::Client).to_not receive(:start_report)
+        allow(SyncSpecsTask::CheckerJob).to receive(:set).and_return(double(perform_later: nil))
+
+        job = create_job(SyncSpecsTask::StarterJob)
+        job.perform
+
+        expect(batch_context[:report_id]).to eq("sync_specs_csv/999")
+        expect(batch_context[:sync_start_time]).to eq(cached_data["started_at"])
+      end
+
+      it "ignores stale cached report and starts new one" do
+        batch_context[:report_caching] = { scope: :sync_batch, max_age: 23.hours }
+        stale_cached_data = {
+          "report_id" => "sync_specs_csv/999",
+          "started_at" => 25.hours.ago.iso8601
+        }
+
+        expect(redis_double).to receive(:hgetall).with(anything).and_return(stale_cached_data)
+        expect_any_instance_of(Bearcat::Client).to receive(:start_report).and_return("id" => 123)
+        expect(redis_double).to receive(:hset).with(anything, hash_including(:report_id, :started_at))
+        expect(redis_double).to receive(:expire)
+        allow(SyncSpecsTask::CheckerJob).to receive(:set).and_return(double(perform_later: nil))
+
+        job = create_job(SyncSpecsTask::StarterJob)
+        job.perform
+
+        expect(batch_context[:report_id]).to eq("sync_specs_csv/123")
+      end
+
+      it "stores new report in cache" do
+        batch_context[:report_caching] = { scope: :sync_batch, max_age: 23.hours }
+
+        expect(redis_double).to receive(:hgetall).with(anything).and_return({})
+        expect_any_instance_of(Bearcat::Client).to receive(:start_report).and_return("id" => 123)
+        expect(redis_double).to receive(:hset).with(anything, hash_including(:report_id, :started_at))
+        expect(redis_double).to receive(:expire).with(anything, 23.hours.to_i)
+        allow(SyncSpecsTask::CheckerJob).to receive(:set).and_return(double(perform_later: nil))
+
+        job = create_job(SyncSpecsTask::StarterJob)
+        job.perform
+      end
+
+      it "uses custom max_age when specified" do
+        batch_context[:report_caching] = { scope: :sync_batch, max_age: 12.hours }
+
+        expect(redis_double).to receive(:hgetall).with(anything).and_return({})
+        expect_any_instance_of(Bearcat::Client).to receive(:start_report).and_return("id" => 123)
+        expect(redis_double).to receive(:hset)
+        expect(redis_double).to receive(:expire).with(anything, 12.hours.to_i)
+        allow(SyncSpecsTask::CheckerJob).to receive(:set).and_return(double(perform_later: nil))
+
+        job = create_job(SyncSpecsTask::StarterJob)
+        job.perform
+      end
+
+      it "supports task-level caching options" do
+        task_options = { caching: { scope: :sync_batch, max_age: 6.hours } }
+        allow(SyncSpecsTask).to receive(:new).and_return(
+          SyncSpecsTask.new(task_options, batch_context, batch_context)
+        )
+
+        expect(redis_double).to receive(:hgetall).with(anything).and_return({})
+        expect_any_instance_of(Bearcat::Client).to receive(:start_report).and_return("id" => 123)
+        expect(redis_double).to receive(:hset)
+        expect(redis_double).to receive(:expire).with(anything, 6.hours.to_i)
+        allow(SyncSpecsTask::CheckerJob).to receive(:set).and_return(double(perform_later: nil))
+
+        job = create_job(SyncSpecsTask::StarterJob)
+        allow(job).to receive(:report_task).and_return(
+          SyncSpecsTask.new(task_options, batch_context, batch_context)
+        )
+        job.perform
+      end
+    end
+  end
+
+  describe described_class::CheckerJob do
+    let(:batch_context) {
+      { canvas_term_id: 1, report_id: 'sync_specs_csv/123', report_attempt: 1 }.with_indifferent_access
+    }
+    let(:client) { instance_double(Bearcat::Client) }
+
+    before do
+      stub_batch_context(batch_context)
+      allow(CanvasSync).to receive(:get_canvas_sync_client).and_return(client)
+    end
+
+    context "when complete" do
+      it "enqueues ProcessJob" do
+        allow(client).to receive(:report_status)
+          .and_return("status" => "complete", "attachment" => { "url" => "http://example.com/report.csv" })
+
+        expect(SyncSpecsTask::ProcessJob).to receive(:perform_later).with("http://example.com/report.csv")
+
+        create_job(SyncSpecsTask::CheckerJob, batch_context).perform
+      end
+    end
+
+    context "when error or deleted" do
+      it "retries if under max_tries" do
+        allow(client).to receive(:report_status).and_return("status" => "error")
+        expect(client).to receive(:start_report).and_return("id" => 456)
+        expect(SyncSpecsTask::CheckerJob).to receive(:set).and_return(double(perform_later: nil))
+
+        create_job(SyncSpecsTask::CheckerJob, batch_context).perform
+
+        expect(batch_context[:report_attempt]).to eq(2)
+      end
+
+      it "handles deleted status the same as error" do
+        allow(client).to receive(:report_status).and_return("status" => "deleted")
+        expect(client).to receive(:start_report).and_return("id" => 456)
+        expect(SyncSpecsTask::CheckerJob).to receive(:set).and_return(double(perform_later: nil))
+
+        create_job(SyncSpecsTask::CheckerJob, batch_context).perform
+
+        expect(batch_context[:report_attempt]).to eq(2)
+      end
+
+      it "raises FatalReportError after max_tries" do
+        batch_context[:report_attempt] = 3
+        allow(client).to receive(:report_status).and_return("status" => "error")
+
+        expect {
+          create_job(SyncSpecsTask::CheckerJob, batch_context).perform
+        }.to raise_error(CanvasSync::Jobs::ReportSyncTask::FatalReportError)
+      end
+
+      it "does not re-enqueue or process when errored after max_tries" do
+        batch_context[:report_attempt] = 3
+        allow(client).to receive(:report_status).and_return("status" => "error")
+
+        expect(SyncSpecsTask::CheckerJob).to_not receive(:set)
+        expect(SyncSpecsTask::ProcessJob).to_not receive(:perform_later)
+
+        expect {
+          create_job(SyncSpecsTask::CheckerJob, batch_context).perform
+        }.to raise_error(CanvasSync::Jobs::ReportSyncTask::FatalReportError)
+      end
+    end
+
+    context "when still processing" do
+      it "re-enqueues itself" do
+        allow(client).to receive(:report_status).and_return("status" => "running")
+        expect(SyncSpecsTask::CheckerJob).to receive(:set).and_return(double(perform_later: nil))
+
+        create_job(SyncSpecsTask::CheckerJob, batch_context).perform
+      end
+
+      it "raises FatalReportError on timeout" do
+        batch_context[:sync_start_time] = (DateTime.now - 25.hours).iso8601
+        allow(client).to receive(:report_status).and_return("status" => "running")
+
+        expect {
+          create_job(SyncSpecsTask::CheckerJob, batch_context).perform
+        }.to raise_error(CanvasSync::Jobs::ReportSyncTask::FatalReportError, /stuck/)
+      end
+    end
+
+    context "when compiling" do
+      it "tracks compilation start time" do
+        allow(client).to receive(:report_status).and_return("status" => "compiling")
+        expect(SyncSpecsTask::CheckerJob).to receive(:set).and_return(double(perform_later: nil))
+
+        create_job(SyncSpecsTask::CheckerJob, batch_context).perform
+
+        expect(batch_context[:compiling_since]).to be_present
+      end
+
+      it "raises FatalReportError on compilation timeout" do
+        batch_context[:compiling_since] = (DateTime.now - 4.hours).iso8601
+        allow(client).to receive(:report_status).and_return("status" => "compiling")
+
+        expect {
+          create_job(SyncSpecsTask::CheckerJob, batch_context).perform
+        }.to raise_error(CanvasSync::Jobs::ReportSyncTask::FatalReportError, /stuck/)
+      end
+    end
+  end
+
+  describe described_class::ProcessJob do
+    let(:batch_context) { { report_id: 'sync_specs_csv/123' }.with_indifferent_access }
+    let(:client) { instance_double(Bearcat::Client) }
+
+    before do
+      stub_batch_context(batch_context)
+      allow(CanvasSync).to receive(:get_canvas_sync_client).and_return(client)
+    end
+
+    it "downloads and processes the report" do
+      allow(client).to receive(:download_report)
+      task = instance_double(SyncSpecsTask)
+      allow(SyncSpecsTask).to receive(:new).and_return(task)
+      expect(task).to receive(:process)
+
+      job = create_job(SyncSpecsTask::ProcessJob, batch_context)
+      allow(job).to receive(:canvas_sync_client).and_return(client)
+      job.perform("http://example.com/report.csv")
+    end
+  end
+end

data/spec/canvas_sync/jobs/sync_provisioning_report_job_spec.rb

@@ -1,50 +1,39 @@
 require 'spec_helper'
 
 RSpec.describe CanvasSync::Jobs::SyncProvisioningReportJob do
-  describe '#perform' do
+  describe '#report_parameters' do
     context 'a term scope is specified' do
       let!(:term) { FactoryBot.create(:term) }
 
-      it 'enqueues a ReportStarter for a provisioning report for the specified models for each term' do
-          expect_any_instance_of(CanvasSync::Jobs::ReportStarter).to receive(:start_report)
-          .with(
-            'self',
-            'proservices_provisioning_csv',
-            {
-              parameters: {
-                include_deleted: true,
-                'users' => true,
-                'courses' => true,
-                enrollment_term_id: term.canvas_id,
-              }
-            },
-          )
+      it 'includes term_id and model parameters' do
+        task = described_class.new({ models: ['users', 'courses'], term_scope: 'active' }, {}, {})
+        allow(CanvasSync::JobBatches::Batch).to receive(:current_context).and_return({ canvas_term_id: term.canvas_id })
 
-        set_batch_context(canvas_term_id: term.canvas_id)
-        CanvasSync::Jobs::SyncProvisioningReportJob.perform_now(
-          { models: ['users', 'courses'], term_scope: 'active' }
-        )
+        params = task.report_parameters
+        expect(params).to eq({
+          parameters: {
+            include_deleted: true,
+            'users' => true,
+            'courses' => true,
+            enrollment_term_id: term.canvas_id,
+          }
+        })
       end
     end
 
     context 'a term scope is not specified' do
-      it 'enqueues a single ReportStarter for a provisioning report across all terms for the specified models' do
-        expect_any_instance_of(CanvasSync::Jobs::ReportStarter).to receive(:start_report)
-          .with(
-            'self',
-            'proservices_provisioning_csv',
-            {
-              parameters: {
-                include_deleted: true,
-                'users' => true,
-                'courses' => true,
-              }
-            },
-          )
+      it 'includes model parameters without term_id' do
+        task = described_class.new({ models: ['users', 'courses'] }, {}, {})
+        allow(CanvasSync::JobBatches::Batch).to receive(:current_context).and_return({})
 
-        CanvasSync::Jobs::SyncProvisioningReportJob.perform_now(
-          { models: ['users', 'courses'] }
-        )
+        params = task.report_parameters
+        expect(params).to eq({
+          parameters: {
+            include_deleted: true,
+            'users' => true,
+            'courses' => true,
+          }
+        })
       end
     end
   end

data/spec/canvas_sync/processors/assignment_groups_processor_spec.rb

@@ -1,12 +1,11 @@
 require "spec_helper"
 
-RSpec.describe CanvasSync::Processors::AssignmentGroupsProcessor do
-  let(:subject) { CanvasSync::Processors::AssignmentGroupsProcessor }
-
+RSpec.describe CanvasSync::Jobs::SyncAssignmentGroupsJob do
   describe "#process" do
     it "inserts assignment_groups" do
+      task = described_class.new({}, {}, {})
       expect {
-        subject.process("spec/support/fixtures/reports/assignment_groups.csv", {}, 1)
+        task.process("spec/support/fixtures/reports/assignment_groups.csv")
       }.to change { AssignmentGroup.count }.by(2)
     end
   end

data/spec/canvas_sync/processors/assignment_overrides_processor_spec.rb

@@ -1,10 +1,11 @@
 require "spec_helper"
 
-RSpec.describe CanvasSync::Processors::AssignmentOverridesProcessor do
+RSpec.describe CanvasSync::Jobs::SyncAssignmentOverridesJob do
   describe '#process' do
     it 'inserts assignment overrides' do
+      task = described_class.new({}, {}, {})
       expect {
-        described_class.process('spec/support/fixtures/reports/assignment_overrides.csv', {}, 1)
+        task.process('spec/support/fixtures/reports/assignment_overrides.csv')
       }.to change { AssignmentOverride.count }.by(2)
 
       override = AssignmentOverride.first
@@ -23,12 +24,14 @@ RSpec.describe CanvasSync::Processors::AssignmentOverridesProcessor do
 
     context 'record already present in the database' do
       before do
-        described_class.process('spec/support/fixtures/reports/assignment_overrides.csv', {}, 1)
+        task = described_class.new({}, {}, {})
+        task.process('spec/support/fixtures/reports/assignment_overrides.csv')
       end
 
       it 'updates the override' do
+        task = described_class.new({}, {}, {})
         expect {
-          described_class.process('spec/support/fixtures/reports/assignment_overrides_conflict.csv', {}, 1)
+          task.process('spec/support/fixtures/reports/assignment_overrides_conflict.csv')
         }.to change { AssignmentOverride.count }.by(0)
 
         override = AssignmentOverride.first

data/spec/canvas_sync/processors/assignments_processor_spec.rb

@@ -1,12 +1,11 @@
 require "spec_helper"
 
-RSpec.describe CanvasSync::Processors::AssignmentsProcessor do
-  let(:subject) { CanvasSync::Processors::AssignmentsProcessor }
-
+RSpec.describe CanvasSync::Jobs::SyncAssignmentsJob do
   describe "#process" do
     it "inserts assignments" do
+      task = described_class.new({}, {}, {})
       expect {
-        subject.process("spec/support/fixtures/reports/assignments.csv", {}, 1)
+        task.process("spec/support/fixtures/reports/assignments.csv")
       }.to change { Assignment.count }.by(2)
     end
   end

data/spec/canvas_sync/processors/content_migrations_processor_spec.rb

@@ -1,12 +1,11 @@
 require "spec_helper"
 
-RSpec.describe CanvasSync::Processors::ContentMigrationsProcessor do
-  let(:subject) { CanvasSync::Processors::ContentMigrationsProcessor }
-
+RSpec.describe CanvasSync::Jobs::SyncContentMigrationsJob do
   describe "#process" do
     it "inserts content migrations" do
+      task = described_class.new({}, {}, {})
       expect {
-        subject.process("spec/support/fixtures/reports/content_migrations.csv", {}, 1)
+        task.process("spec/support/fixtures/reports/content_migrations.csv")
       }.to change { ContentMigration.count }.by(2)
     end
   end

data/spec/canvas_sync/processors/context_module_items_processor_spec.rb

@@ -1,12 +1,11 @@
 require "spec_helper"
 
-RSpec.describe CanvasSync::Processors::ContextModuleItemsProcessor do
-  let(:subject) { CanvasSync::Processors::ContextModuleItemsProcessor }
-
+RSpec.describe CanvasSync::Jobs::SyncContextModuleItemsJob do
   describe "#process" do
-    it "inserts context modules" do
+    it "inserts context module items" do
+      task = described_class.new({}, {}, {})
       expect {
-        subject.process("spec/support/fixtures/reports/context_module_items.csv", {}, 1)
+        task.process("spec/support/fixtures/reports/context_module_items.csv")
       }.to change { ContextModuleItem.count }.by(2)
     end
   end

data/spec/canvas_sync/processors/context_modules_processor_spec.rb

@@ -1,12 +1,11 @@
 require "spec_helper"
 
-RSpec.describe CanvasSync::Processors::ContextModulesProcessor do
-  let(:subject) { CanvasSync::Processors::ContextModulesProcessor }
-
+RSpec.describe CanvasSync::Jobs::SyncContextModulesJob do
   describe "#process" do
     it "inserts context modules" do
+      task = described_class.new({}, {}, {})
       expect {
-        subject.process("spec/support/fixtures/reports/context_modules.csv", {}, 1)
+        task.process("spec/support/fixtures/reports/context_modules.csv")
       }.to change { ContextModule.count }.by(2)
       expect(ContextModule.last).to have_attributes(
         canvas_id: 23,

data/spec/canvas_sync/processors/course_completion_report_processor_spec.rb

@@ -1,11 +1,12 @@
 require "spec_helper"
 
-RSpec.describe CanvasSync::Processors::CourseCompletionReportProcessor do
+RSpec.describe CanvasSync::Jobs::SyncCourseProgressesJob do
 
   describe '#process' do
     it 'inserts course progresses' do
+      task = described_class.new({}, {}, {})
       expect {
-        described_class.process('spec/support/fixtures/reports/course_progresses.csv', {}, 1)
+        task.process('spec/support/fixtures/reports/course_progresses.csv')
       }.to change { CourseProgress.count }.by(2)
       cp = CourseProgress.first
       expect(cp).to have_attributes(
@@ -26,12 +27,14 @@ RSpec.describe CanvasSync::Processors::CourseCompletionReportProcessor do
 
     context 'record already present in the database' do
       before do
-        described_class.process('spec/support/fixtures/reports/course_progresses.csv', {}, 1)
+        task = described_class.new({}, {}, {})
+        task.process('spec/support/fixtures/reports/course_progresses.csv')
       end
 
       it 'updates the course progress' do
+        task = described_class.new({}, {}, {})
         expect {
-          described_class.process('spec/support/fixtures/reports/course_progresses_conflict.csv', {}, 1)
+          task.process('spec/support/fixtures/reports/course_progresses_conflict.csv')
         }.to change { CourseProgress.count }.by(0)
         cp = CourseProgress.first
         expect(cp).to have_attributes(