canvas_sync 0.16.4 → 0.21.0

data/spec/canvas_sync/canvas_sync_spec.rb

@@ -3,13 +3,12 @@ require 'spec_helper'
 RSpec.describe CanvasSync do
   describe '.provisioning_sync' do
     it 'invokes the first job in the queue and passes on the rest of the job chain' do
-      expected_job_chain = CanvasSync.default_provisioning_report_chain(['courses'], nil).chain_data
-      first_job = expected_job_chain[:jobs].shift
+      expected_job_chain = CanvasSync.default_provisioning_report_chain(['courses'], term_scope: nil).normalize![:args][0]
 
-      expect(CanvasSync::Jobs::SyncTermsJob).to receive(:perform_later)
+      expect(CanvasSync::Jobs::BeginSyncChainJob).to receive(:perform_later)
         .with(
           expected_job_chain,
-          first_job[:options]
+          anything
         )
 
       CanvasSync.provisioning_sync(['courses'])
@@ -25,32 +24,68 @@ RSpec.describe CanvasSync do
 
     describe '.default_provisioning_report_chain' do
       it 'splits an options: Hash into options for separate models' do
-        chain = CanvasSync.default_provisioning_report_chain(['users', 'courses'], :active, options: {
+        chain = CanvasSync.default_provisioning_report_chain(['users', 'courses'], term_scope: :active, options: {
           terms: { a: 1 },
           users: { b: 2 },
           provisioning: { c: 3 },
           global: { d: 4 },
         })
-        expect(chain.chain_data).to eq({
-          jobs: [
-            { job: CanvasSync::Jobs::SyncTermsJob.to_s, options: { a: 1 } },
-            { job: CanvasSync::Jobs::SyncProvisioningReportJob.to_s, options: { models: ['users'], b: 2 } },
-            { job: CanvasSync::Jobs::SyncProvisioningReportJob.to_s, options: { term_scope: 'active', models: ['courses'], c: 3 } }
+        expect(chain.normalize!).to eq({
+          :job => "CanvasSync::Jobs::BeginSyncChainJob",
+          :args => [
+            [
+              {
+                :job=>"CanvasSync::JobBatches::ConcurrentBatchJob",
+                :args=>[
+                  [
+                    {:job=>"CanvasSync::Jobs::SyncProvisioningReportJob", :options=>{:models=>["users"], :b=>2}},
+                    {
+                      :job=>"CanvasSync::Jobs::SyncTermsJob",
+                      :args=>[],
+                      :kwargs=>{
+                        :term_scope=>"active",
+                        :sub_jobs=>[
+                          {:job=>"CanvasSync::Jobs::SyncProvisioningReportJob", :options=>{:models=>["courses"], :c=>3}},
+                        ],
+                      },
+                    },
+                  ],
+                ],
+                :kwargs=>{},
+              },
+            ],
           ],
-          global_options: { legacy_support: false, d: 4 }
+          :kwargs => {:legacy_support=>false, :updated_after=>nil, :full_sync_every=>nil, :batch_genre=>nil, :d=>4},
         })
       end
 
       context 'we are syncing users with a term scope' do
         it 'syncs the users in a separate job that runs first' do
-          chain = CanvasSync.default_provisioning_report_chain(['users', 'courses'], :active)
-          expect(chain.chain_data).to eq({
-            jobs: [
-              { job: CanvasSync::Jobs::SyncTermsJob.to_s, options: {} },
-              { job: CanvasSync::Jobs::SyncProvisioningReportJob.to_s, options: { models: ['users'] } },
-              { job: CanvasSync::Jobs::SyncProvisioningReportJob.to_s, options: { term_scope: 'active', models: ['courses'] } }
-            ],
-            global_options: { legacy_support: false }
+          chain = CanvasSync.default_provisioning_report_chain(['users', 'courses'], term_scope: :active)
+          expect(chain.normalize!).to eq({
+            :job => "CanvasSync::Jobs::BeginSyncChainJob",
+            :args => [[
+              {
+                :job=>"CanvasSync::JobBatches::ConcurrentBatchJob",
+                :args=>[
+                  [
+                    {:job=>"CanvasSync::Jobs::SyncProvisioningReportJob", :options=>{:models=>["users"]}},
+                    {
+                      :job=>"CanvasSync::Jobs::SyncTermsJob",
+                      :args=>[],
+                      :kwargs=>{
+                        :sub_jobs=>[
+                          {:job=>"CanvasSync::Jobs::SyncProvisioningReportJob", :options=>{:models=>["courses"]}}
+                        ],
+                        :term_scope=>"active",
+                      }
+                    }
+                  ]
+                ],
+                :kwargs=>{},
+              }
+            ]],
+            :kwargs => {:legacy_support=>false, :updated_after=>nil, :full_sync_every=>nil, :batch_genre=>nil},
           })
         end
       end
@@ -58,26 +93,52 @@ RSpec.describe CanvasSync do
       context 'we are syncing users without a term scope' do
         it 'syncs users along with the rest of the provisioning report' do
           chain = CanvasSync.default_provisioning_report_chain(['users', 'courses'])
-          expect(chain.chain_data).to eq({
-            jobs: [
-              { job: CanvasSync::Jobs::SyncTermsJob.to_s, options: {} },
-              { job: CanvasSync::Jobs::SyncProvisioningReportJob.to_s, options: { term_scope: nil, models: ['users', 'courses'] } }
-            ],
-            global_options: { legacy_support: false }
+          expect(chain.normalize!).to eq({
+            :job => "CanvasSync::Jobs::BeginSyncChainJob",
+            :args => [[
+              {
+                :job=>"CanvasSync::JobBatches::ConcurrentBatchJob",
+                :args=>[[
+                  {
+                    :job=>"CanvasSync::Jobs::SyncTermsJob",
+                    :args=>[],
+                    :kwargs=>{
+                      :sub_jobs=>[{:job=>"CanvasSync::Jobs::SyncProvisioningReportJob", :options=>{:models=>["users", "courses"]}}],
+                      :term_scope=>nil,
+                    }
+                  }
+                ]],
+                :kwargs=>{}
+              }
+            ]],
+            :kwargs => {:legacy_support=>false, :updated_after=>nil, :full_sync_every=>nil, :batch_genre=>nil},
           })
         end
       end
 
       context 'we are syncing roles with a term scope' do
         it 'syncs the roles in a separate job that runs first' do
-          chain = CanvasSync.default_provisioning_report_chain(['roles', 'courses'], :active)
-          expect(chain.chain_data).to eq({
-            jobs: [
-              { job: CanvasSync::Jobs::SyncTermsJob.to_s, options: {} },
-              { job: CanvasSync::Jobs::SyncRolesJob.to_s, options: {} },
-              { job: CanvasSync::Jobs::SyncProvisioningReportJob.to_s, options: { term_scope: 'active', models: ['courses'] } }
-            ],
-            global_options: { legacy_support: false }
+          chain = CanvasSync.default_provisioning_report_chain(['roles', 'courses'], term_scope: :active)
+          expect(chain.normalize!).to eq({
+            :job => "CanvasSync::Jobs::BeginSyncChainJob",
+            :args => [[
+              {
+                :job=>"CanvasSync::JobBatches::ConcurrentBatchJob",
+                :args=>[[
+                  {:job=>"CanvasSync::Jobs::SyncRolesJob", :options=>{}},
+                  {
+                    :job=>"CanvasSync::Jobs::SyncTermsJob",
+                    :args=>[],
+                    :kwargs=>{
+                      :sub_jobs=>[{:job=>"CanvasSync::Jobs::SyncProvisioningReportJob", :options=>{:models=>["courses"]}}],
+                      :term_scope=>"active",
+                    }
+                  },
+                ]],
+                :kwargs=>{}
+              }
+            ]],
+            :kwargs => {:batch_genre=>nil, :full_sync_every=>nil, :legacy_support=>false, :updated_after=>nil},
           })
         end
       end
@@ -85,27 +146,53 @@ RSpec.describe CanvasSync do
       context 'we are syncing roles without a term scope' do
         it 'syncs roles separately even with no term scope' do
           chain = CanvasSync.default_provisioning_report_chain(['roles', 'courses'])
-          expect(chain.chain_data).to eq({
-            jobs: [
-              { job: CanvasSync::Jobs::SyncTermsJob.to_s, options: {} },
-              { job: CanvasSync::Jobs::SyncRolesJob.to_s, options: {} },
-              { job: CanvasSync::Jobs::SyncProvisioningReportJob.to_s, options: { term_scope: nil, models: ['courses'] } }
-            ],
-            global_options: { legacy_support: false }
+          expect(chain.normalize!).to eq({
+            :job => "CanvasSync::Jobs::BeginSyncChainJob",
+            :args => [[
+              {
+                :job=>"CanvasSync::JobBatches::ConcurrentBatchJob",
+                :args=>[[
+                  {:job=>"CanvasSync::Jobs::SyncRolesJob", :options=>{}},
+                  {
+                    :job=>"CanvasSync::Jobs::SyncTermsJob",
+                    :args=>[],
+                    :kwargs=>{
+                      :sub_jobs=>[{:job=>"CanvasSync::Jobs::SyncProvisioningReportJob", :options=>{:models=>["courses"]}}],
+                      :term_scope=>nil,
+                    }
+                  }
+                ]],
+                :kwargs=>{}
+              }
+            ]],
+            :kwargs => {:batch_genre=>nil, :full_sync_every=>nil, :legacy_support=>false, :updated_after=>nil},
           })
         end
       end
 
       context 'we are syncing admins with a term scope' do
         it 'syncs the admins in a separate job that runs first' do
-          chain = CanvasSync.default_provisioning_report_chain(['admins', 'courses'], :active)
-          expect(chain.chain_data).to eq({
-            jobs: [
-              { job: CanvasSync::Jobs::SyncTermsJob.to_s, options: {} },
-              { job: CanvasSync::Jobs::SyncAdminsJob.to_s, options: {} },
-              { job: CanvasSync::Jobs::SyncProvisioningReportJob.to_s, options: { term_scope: 'active', models: ['courses'] } }
-            ],
-            global_options: { legacy_support: false }
+          chain = CanvasSync.default_provisioning_report_chain(['admins', 'courses'], term_scope: :active)
+          expect(chain.normalize!).to eq({
+            :job => "CanvasSync::Jobs::BeginSyncChainJob",
+            :args => [[
+              {
+                :job=>"CanvasSync::JobBatches::ConcurrentBatchJob",
+                :args=>[[
+                  {:job=>"CanvasSync::Jobs::SyncAdminsJob", :options=>{}},
+                  {
+                    :job=>"CanvasSync::Jobs::SyncTermsJob",
+                    :args=>[],
+                    :kwargs=>{
+                      :sub_jobs=>[{:job=>"CanvasSync::Jobs::SyncProvisioningReportJob", :options=>{:models=>["courses"]}}],
+                      :term_scope=>"active"
+                    }
+                  }
+                ]],
+                :kwargs=>{}
+              }
+            ]],
+            :kwargs => {:batch_genre=>nil, :full_sync_every=>nil, :legacy_support=>false, :updated_after=>nil},
           })
         end
       end
@@ -113,13 +200,26 @@ RSpec.describe CanvasSync do
       context 'we are syncing admins without a term scope' do
         it 'syncs admins separately even with no term scope' do
           chain = CanvasSync.default_provisioning_report_chain(['admins', 'courses'])
-          expect(chain.chain_data).to eq({
-            jobs: [
-              { job: CanvasSync::Jobs::SyncTermsJob.to_s, options: {} },
-              { job: CanvasSync::Jobs::SyncAdminsJob.to_s, options: {} },
-              { job: CanvasSync::Jobs::SyncProvisioningReportJob.to_s, options: { term_scope: nil, models: ['courses'] } }
-            ],
-            global_options: { legacy_support: false }
+          expect(chain.normalize!).to eq({
+            :job => "CanvasSync::Jobs::BeginSyncChainJob",
+            :args => [[
+              {
+                :job=>"CanvasSync::JobBatches::ConcurrentBatchJob",
+                :args=>[[
+                  {:job=>"CanvasSync::Jobs::SyncAdminsJob", :options=>{}},
+                  {
+                    :job=>"CanvasSync::Jobs::SyncTermsJob",
+                    :args=>[],
+                    :kwargs=>{
+                      :sub_jobs=>[{:job=>"CanvasSync::Jobs::SyncProvisioningReportJob", :options=>{:models=>["courses"]}}],
+                      :term_scope=>nil
+                    }
+                  }
+                ]],
+                :kwargs=>{}
+              }
+            ]],
+            :kwargs => {:batch_genre=>nil, :full_sync_every=>nil, :legacy_support=>false, :updated_after=>nil},
           })
         end
       end
@@ -128,14 +228,29 @@ RSpec.describe CanvasSync do
         it "appends the SyncAssignmentsJob" do
           chain = CanvasSync.default_provisioning_report_chain(%w[users enrollments assignments])
 
-          expect(chain.chain_data).to eq(
-            jobs: [
-              { job: CanvasSync::Jobs::SyncTermsJob.to_s, options: {} },
-              { job: CanvasSync::Jobs::SyncProvisioningReportJob.to_s, options: { term_scope: nil, models: %w[users enrollments] } },
-              { job: CanvasSync::Jobs::SyncAssignmentsJob.to_s, options: {} },
-            ],
-            global_options: { legacy_support: false },
-          )
+          expect(chain.normalize!).to eq({
+            :job => "CanvasSync::Jobs::BeginSyncChainJob",
+            :args => [[
+              {
+                :job=>"CanvasSync::JobBatches::ConcurrentBatchJob",
+                :args=>[[
+                  {
+                    :job=>"CanvasSync::Jobs::SyncTermsJob",
+                    :args=>[],
+                    :kwargs=>{
+                      :sub_jobs=>[
+                        {:job=>"CanvasSync::Jobs::SyncAssignmentsJob", :options=>{}},
+                        {:job=>"CanvasSync::Jobs::SyncProvisioningReportJob", :options=>{:models=>["users", "enrollments"]}}
+                      ],
+                      :term_scope=>nil
+                    }
+                  }
+                ]],
+                :kwargs=>{}
+              }
+            ]],
+            :kwargs => {:batch_genre=>nil, :full_sync_every=>nil, :legacy_support=>false, :updated_after=>nil},
+          })
         end
       end
 
@@ -143,14 +258,29 @@ RSpec.describe CanvasSync do
         it "appends the SyncSubmissionsJob" do
           chain = CanvasSync.default_provisioning_report_chain(%w[users enrollments submissions])
 
-          expect(chain.chain_data).to eq(
-            jobs: [
-              { job: CanvasSync::Jobs::SyncTermsJob.to_s, options: {} },
-              { job: CanvasSync::Jobs::SyncProvisioningReportJob.to_s, options: { term_scope: nil, models: %w[users enrollments] } },
-              { job: CanvasSync::Jobs::SyncSubmissionsJob.to_s, options: {} },
-            ],
-            global_options: { legacy_support: false },
-          )
+          expect(chain.normalize!).to eq({
+            :job => "CanvasSync::Jobs::BeginSyncChainJob",
+            :args => [[
+              {
+                :job=>"CanvasSync::JobBatches::ConcurrentBatchJob",
+                :args=>[[
+                  {
+                    :job=>"CanvasSync::Jobs::SyncTermsJob",
+                    :args=>[],
+                    :kwargs=>{
+                      :sub_jobs=>[
+                        {:job=>"CanvasSync::Jobs::SyncSubmissionsJob", :options=>{}},
+                        {:job=>"CanvasSync::Jobs::SyncProvisioningReportJob", :options=>{:models=>["users", "enrollments"]}}
+                      ],
+                      :term_scope=>nil
+                    }
+                  }
+                ]],
+                :kwargs=>{}
+              }
+            ]],
+            :kwargs => {:batch_genre=>nil, :full_sync_every=>nil, :legacy_support=>false, :updated_after=>nil},
+          })
         end
       end
 
@@ -158,95 +288,34 @@ RSpec.describe CanvasSync do
         it "appends the SyncAssignmentGroupsJob" do
           chain = CanvasSync.default_provisioning_report_chain(%w[users enrollments assignment_groups])
 
-          expect(chain.chain_data).to eq(
-            jobs: [
-              { job: CanvasSync::Jobs::SyncTermsJob.to_s, options: {} },
-              { job: CanvasSync::Jobs::SyncProvisioningReportJob.to_s, options: { term_scope: nil, models: %w[users enrollments] } },
-              { job: CanvasSync::Jobs::SyncAssignmentGroupsJob.to_s, options: {} },
-            ],
-            global_options: { legacy_support: false },
-          )
+          expect(chain.normalize!).to eq({
+            :job => "CanvasSync::Jobs::BeginSyncChainJob",
+            :args => [[
+              {
+                :job=>"CanvasSync::JobBatches::ConcurrentBatchJob",
+                :args=>[[
+                  {
+                    :job=>"CanvasSync::Jobs::SyncTermsJob",
+                    :args=>[],
+                    :kwargs=>{
+                      :sub_jobs=>[
+                        {:job=>"CanvasSync::Jobs::SyncAssignmentGroupsJob", :options=>{}},
+                        {:job=>"CanvasSync::Jobs::SyncProvisioningReportJob", :options=>{:models=>["users", "enrollments"]}}
+                      ],
+                      :term_scope=>nil
+                    }
+                  }
+                ]],
+                :kwargs=>{}
+              }
+            ]],
+            :kwargs => {:batch_genre=>nil, :full_sync_every=>nil, :legacy_support=>false, :updated_after=>nil},
+          })
         end
       end
     end
   end
 
-  describe ".simple_report_sync" do
-
-    it 'invokes the first job in the queue and passes on the rest of the job chain' do
-      expected_job_chain = CanvasSync.simple_report_chain(
-        [
-          {
-            report_name: 'proservices_provisioning_csv',
-            model: 'users',
-            params: {
-              "parameters[include_deleted]" => true,
-              "parameters[users]" => true
-            }
-          }
-        ]
-      ).chain_data
-      first_job = expected_job_chain[:jobs].shift
-
-      expect(CanvasSync::Jobs::SyncSimpleTableJob).to receive(:perform_later)
-        .with(
-          expected_job_chain,
-          first_job[:options]
-        )
-
-      CanvasSync.simple_report_sync(
-        [
-          {
-            report_name: 'proservices_provisioning_csv',
-            model: 'users',
-            params: {
-              "parameters[include_deleted]" => true,
-              "parameters[users]" => true
-            }
-          }
-        ]
-      )
-    end
-
-    it 'receives the job chain for the specified table' do
-      chain = CanvasSync.simple_report_chain(
-        [
-          {
-            report_name: 'proservices_provisioning_csv',
-            model: 'users',
-            params: {
-              "parameters[include_deleted]" => true,
-              "parameters[users]" => true
-            }
-          }
-        ]
-      )
-
-      expected_job_chain = {
-        jobs: [
-          {
-            job: CanvasSync::Jobs::SyncSimpleTableJob.to_s,
-            options: {
-              report_name: 'proservices_provisioning_csv',
-              model: 'users',
-              mapping: 'users',
-              klass: 'User',
-              term_scope: nil,
-              params: {
-                "parameters[include_deleted]" => true,
-                "parameters[users]" => true
-              }
-            }
-          }
-        ],
-        global_options: {}
-      }
-
-      expect(chain.chain_data).to eq(expected_job_chain)
-
-    end
-  end
-
   describe ".sync_scope" do
 
   end

data/spec/canvas_sync/jobs/canvas_process_waiter_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+RSpec.describe CanvasSync::Jobs::CanvasProcessWaiter do
+  let!(:worker) { CanvasSync::Jobs::CanvasProcessWaiter.new }
+
+  describe 'perform' do
+    it 'queues a InvokeCallbackWorker when complete' do
+      job = {
+        args: [1, 2],
+        kwargs: { progress: anything },
+      }
+      allow_any_instance_of(Bearcat::Client).to receive(:get).and_return('workflow_state' => 'completed')
+      expect(CanvasSync::Jobs::CanvasProcessWaiter::InvokeCallbackWorker).to receive(:perform_later).with(job)
+      worker.perform('/blah/', job)
+    end
+
+    it 'invokes the on_failure callback if failed' do
+      job = {
+        args: [1, 2],
+        kwargs: { progress: anything },
+      }
+      allow_any_instance_of(Bearcat::Client).to receive(:get).and_return('workflow_state' => 'failed')
+      expect(CanvasSync::Jobs::CanvasProcessWaiter::InvokeCallbackWorker).to receive(:perform_later).with(job)
+      worker.perform('/blah/', nil, on_failure: job)
+    end
+
+    it 're-enqueues if incomplete' do
+      ActiveJob::Base.queue_adapter = :test
+      allow_any_instance_of(Bearcat::Client).to receive(:get).and_return('workflow_state' => 'pending')
+      worker.perform('/blah/', nil, interval: 13)
+      expect(CanvasSync::Jobs::CanvasProcessWaiter).to have_been_enqueued.once.with('/blah/', nil, interval: 13)
+    end
+  end
+end

data/spec/canvas_sync/jobs/job_spec.rb

@@ -1,14 +1,14 @@
 require 'spec_helper'
 
 class GoodJob < CanvasSync::Job
-  def perform(job_chain, argument)
+  def perform(argument)
   end
 end
 
 class EvilError < StandardError; end;
 
 class BadJob < CanvasSync::Job
-  def perform(job_chain, argument)
+  def perform(argument)
     raise EvilError
   end
 
@@ -25,19 +25,19 @@ RSpec.describe CanvasSync::Job do
   describe '#perform' do
     it 'creates a CanvasSync::JobLog and logs relevant data on it' do
       expect {
-        GoodJob.perform_now({}, "argument")
+        GoodJob.perform_now("argument")
       }.to change { CanvasSync::JobLog.count }.by(1)
 
       job_log = CanvasSync::JobLog.last
       expect(job_log.started_at).to_not be_nil
       expect(job_log.job_class).to eq(GoodJob.to_s)
-      expect(job_log.job_arguments).to eq([{}, "argument"])
+      expect(job_log.job_arguments).to eq(["argument"])
       expect(job_log.completed_at).to_not be_nil
     end
 
     it 'logs exceptions on the CanvasSync::JobLog and then re-raises' do
       expect {
-        BadJob.perform_now({}, "argument")
+        BadJob.perform_now("argument")
       }.to raise_exception(StandardError)
 
       job_log = CanvasSync::JobLog.last
@@ -47,25 +47,17 @@ RSpec.describe CanvasSync::Job do
 
     it 'invokes an error handler' do
       expect(BadJob).to receive(:good_catcher).once
+      set_batch_context(on_failure: 'BadJob.good_catcher')
       expect {
-        BadJob.perform_now({
-          jobs: [],
-          global_options: {
-            on_failure: 'BadJob.good_catcher'
-          }
-        })
+        BadJob.perform_now()
       }.to raise_exception(StandardError)
     end
 
     it 'logs a failing error handler' do
       expect(BadJob).to receive(:bad_catcher).once.and_call_original
+      set_batch_context(on_failure: 'BadJob.bad_catcher')
       expect {
-        BadJob.perform_now({
-          jobs: [],
-          global_options: {
-            on_failure: 'BadJob.bad_catcher'
-          }
-        })
+        BadJob.perform_now()
       }.to raise_exception(StandardError)
       job_log = CanvasSync::JobLog.last
       expect(job_log.backtrace).to include "Error Occurred while handling an Error"

data/spec/canvas_sync/jobs/report_checker_spec.rb

@@ -5,12 +5,10 @@ RSpec.describe CanvasSync::Jobs::ReportChecker do
   let(:report_id) { 1 }
   let(:report_name) { 'provisioning_csv' }
   let(:processor) { 'FakeProcessor' }
-  let(:job_chain) { { jobs: [], global_options: {} } }
 
   describe '#perform' do
     def start_job
       CanvasSync::Jobs::ReportChecker.perform_now(
-        job_chain,
         'provisioning_csv',
         report_id,
         processor,
@@ -25,7 +23,7 @@ RSpec.describe CanvasSync::Jobs::ReportChecker do
           .and_return({ 'status' => 'complete', 'attachment' => { 'url' => 'blah' } })
 
         expect(CanvasSync::Jobs::ReportProcessorJob).to receive(:perform_later)
-          .with(job_chain, report_name, 'blah', processor, {}, report_id)
+          .with(report_name, 'blah', processor, {}, report_id)
 
         start_job
       end

data/spec/canvas_sync/jobs/report_processor_job_spec.rb

@@ -6,17 +6,14 @@ RSpec.describe CanvasSync::Jobs::ReportProcessorJob do
   let(:report_name) { 'provisioning_csv' }
   let(:report_url) { 'https://test.instructure.com/sample_report_download' }
   let(:processor) { FakeProcessor.to_s }
-  let(:job_chain) { { jobs: [], global_options: {} } }
   let(:report_id) { 1 }
 
   describe '#perform' do
     it 'downloads the report to a file and then calls the process method on the processor, and then invokes the next job' do
       expect(IO).to receive(:copy_stream)
       expect(FakeProcessor).to receive(:process)
-      expect(CanvasSync).to receive(:invoke_next).with(job_chain)
 
       CanvasSync::Jobs::ReportProcessorJob.perform_now(
-        job_chain,
         report_name,
         report_url,
         processor,