canvas_sync 0.16.5 → 0.17.0.beta1

data/lib/canvas_sync.rb

@@ -5,7 +5,6 @@ require "canvas_sync/engine"
 require "canvas_sync/misc_helper"
 require "canvas_sync/class_callback_executor"
 require "canvas_sync/job"
-require "canvas_sync/job_chain"
 require "canvas_sync/sidekiq_job"
 require "canvas_sync/api_syncable"
 require "canvas_sync/record"
@@ -14,6 +13,8 @@ require "canvas_sync/jobs/report_checker"
 require "canvas_sync/jobs/report_processor_job"
 require "canvas_sync/config"
 
+require "canvas_sync/job_batches/batch"
+
 Dir[File.dirname(__FILE__) +  "/canvas_sync/jobs/*.rb"].each { |file| require file }
 Dir[File.dirname(__FILE__) +  "/canvas_sync/processors/*.rb"].each { |file| require file }
 Dir[File.dirname(__FILE__) +  "/canvas_sync/importers/*.rb"].each { |file| require file }
@@ -58,6 +59,9 @@ module CanvasSync
     graded_submissions
   ].freeze
 
+  JobBatches::ChainBuilder.register_chain_job(CanvasSync::Jobs::SyncTermsJob, :sub_jobs)
+  JobBatches::ChainBuilder.register_chain_job(CanvasSync::Jobs::BeginSyncChainJob, 0)
+
   class << self
     # Runs a standard provisioning sync job with no extra report types.
     # Terms will be synced first using the API. If you are syncing users/roles/admins
@@ -73,51 +77,9 @@ module CanvasSync
     #   and inserts it into the database. If an array of model names is provided then only those models will use legacy support.
     # @param account_id [Integer, nil] This optional parameter can be used if your Term creation and
     #   canvas_sync_client methods require an account ID.
-    def provisioning_sync(models, term_scope: nil, legacy_support: false, account_id: nil)
+    def provisioning_sync(models, **kwargs)
       validate_models!(models)
-      invoke_next(default_provisioning_report_chain(models, term_scope, legacy_support, account_id))
-    end
-
-    # Runs a report different from provisioning sync job with no extra report types.
-    #
-    # @param reports_mapping [Array<Hash>] An Array of hash that list the model and params with their report you
-    #   want to import:
-    #   [{model: 'submissions', report_name: 'my_report_name_csv', params: { "parameters[include_deleted]" => true } }, ...]
-    # @param term_scope [Symbol, nil] An optional symbol representing a scope that exists on the Term model.
-    #   The provisioning report will be run for each of the terms contained in that scope.
-    # @param account_id [Integer, nil] This optional parameter can be used if your Term creation and
-    #   canvas_sync_client methods require an account ID.
-    def simple_report_sync(reports_mapping, term_scope: nil, account_id: nil)
-      invoke_next(simple_report_chain(reports_mapping, term_scope, account_id))
-    end
-
-    # Runs a chain of ordered jobs
-    #
-    # See the README for usage and examples
-    #
-    # @param job_chain [Hash]
-    def process_jobs(job_chain)
-      invoke_next(job_chain)
-    end
-
-    # @deprecated
-    def duplicate_chain(job_chain)
-      Marshal.load(Marshal.dump(job_chain))
-    end
-
-    # Invokes the next job in a chain of jobs.
-    #
-    # This should typically be called automatically by the gem where necessary.
-    #
-    # @param job_chain [Hash] A chain of jobs to execute
-    def invoke_next(job_chain, extra_options: {})
-      job_chain = JobChain.new(job_chain) unless job_chain.is_a?(JobChain)
-      job_chain.perform_next(extra_options)
-    end
-
-    def fork(job_log, job_chain, keys: [], &blk)
-      job_chain = JobChain.new(job_chain) unless job_chain.is_a?(JobChain)
-      job_chain.fork(job_log, keys: keys, &blk)
+      default_provisioning_report_chain(models, **kwargs).process!
     end
 
     # Given a Model or Relation, scope it down to items that should be synced
@@ -134,33 +96,6 @@ module CanvasSync
       scope
     end
 
-    # Syn any report to an specific set of models
-    #
-    # @param reports_mapping [Array<Hash>] List of reports with their specific model and params
-    # @param term_scope [String]
-    # @param account_id [Integer, nil] This optional parameter can be used if your Term creation and
-    #   canvas_sync_client methods require an account ID.
-    def simple_report_chain(reports_mapping, term_scope=nil, account_id=nil)
-      jobs = reports_mapping.map do |report|
-        {
-          job: CanvasSync::Jobs::SyncSimpleTableJob.to_s,
-          options: {
-            report_name: report[:report_name],
-            model: report[:model],
-            mapping: report[:model],
-            klass: report[:model].singularize.capitalize.to_s,
-            term_scope: term_scope,
-            params: report[:params]
-          }
-        }
-      end
-
-      global_options = {}
-      global_options[:account_id] = account_id if account_id.present?
-
-      JobChain.new(jobs: jobs, global_options: global_options)
-    end
-
     # Syncs terms, users/roles/admins if necessary, then the rest of the specified models.
     #
     # @param models [Array<String>]
@@ -171,7 +106,7 @@ module CanvasSync
     # @param account_id [Integer, nil] This optional parameter can be used if your Term creation and
     #   canvas_sync_client methods require an account ID.
     # @return [Hash]
-    def default_provisioning_report_chain(models, term_scope=nil, legacy_support=false, account_id=nil, options: {}) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/LineLength
+    def default_provisioning_report_chain(models, term_scope: nil, legacy_support: false, account_id: nil, updated_after: nil, options: {}) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/LineLength
       return unless models.present?
       models.map! &:to_s
       term_scope = term_scope.to_s if term_scope
@@ -190,64 +125,66 @@ module CanvasSync
         context_module_items: CanvasSync::Jobs::SyncContextModuleItemsJob,
       }.with_indifferent_access
 
-      jobs = []
+      root_chain = JobBatches::ChainBuilder.new(CanvasSync::Jobs::BeginSyncChainJob)
+      concurrent_root_chain = JobBatches::ChainBuilder.new(JobBatches::ConcurrentBatchJob)
+      root_chain << concurrent_root_chain
+      current_chain = concurrent_root_chain
+
       try_add_model_job = ->(model) {
         return unless models.include?(model)
-        jobs.push(job: model_job_map[model].to_s, options: options[model.to_sym] || {})
+        current_chain << { job: model_job_map[model].to_s, options: options[model.to_sym] || {} }
         models -= [model]
       }
 
       ##############################
-      # Pre provisioning report jobs
+      # General provisioning jobs (not term-scoped)
       ##############################
 
-      # Always sync Terms first
-      models.unshift('terms') unless models.include?('terms')
-      try_add_model_job.call('terms')
+      # Terms are always synced regardless of the models option
+      models -= ['terms']
 
-      # Accounts, users, roles, and admins are synced before provisioning because they cannot be scoped to term
+      # Accounts, users, roles, and admins cannot be scoped to term
       try_add_model_job.call('accounts')
 
       # These Models use the provisioning report, but are not term-scoped,
-      # so we sync them before to ensure work is not duplicated
+      # so we sync them outside of the term scoping to ensure work is not duplicated
       if term_scope.present?
         models -= (first_provisioning_models = models & ['users', 'pseudonyms'])
-        jobs.concat(
-          generate_provisioning_jobs(first_provisioning_models, options)
-        )
+        current_chain.insert(generate_provisioning_jobs(first_provisioning_models, options))
       end
 
       try_add_model_job.call('roles')
       try_add_model_job.call('admins')
-      pre_provisioning_jobs = jobs
 
       ###############################
-      # Post provisioning report jobs
+      # Per-term provisioning jobs
       ###############################
 
-      jobs = []
+      per_term_chain = JobBatches::ChainBuilder.new(model_job_map[:terms])
+      current_chain << per_term_chain
+      current_chain = per_term_chain
+
       try_add_model_job.call('assignments')
       try_add_model_job.call('submissions')
       try_add_model_job.call('assignment_groups')
       try_add_model_job.call('context_modules')
       try_add_model_job.call('context_module_items')
-      post_provisioning_jobs = jobs
+
+      current_chain.insert(
+        generate_provisioning_jobs(models, options, job_options: { term_scope: term_scope }, only_split: ['users'])
+      )
 
       ###############################
-      # Main provisioning job and queueing
+      # Wrap it all up
       ###############################
 
-      jobs = [
-        *pre_provisioning_jobs,
-        *generate_provisioning_jobs(models, options, job_options: { term_scope: term_scope }, only_split: ['users']),
-        *post_provisioning_jobs,
-      ]
-
-      global_options = { legacy_support: legacy_support }
+      global_options = { legacy_support: legacy_support, updated_after: updated_after }
       global_options[:account_id] = account_id if account_id.present?
       global_options.merge!(options[:global]) if options[:global].present?
 
-      JobChain.new(jobs: jobs, global_options: global_options)
+      root_chain.params[1] = global_options
+
+      root_chain
     end
 
     def group_by_job_options(model_list, options_hash, only_split: nil, default_key: :provisioning)

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![:parameters][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,42 @@ 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 } }
-          ],
-          global_options: { legacy_support: false, d: 4 }
+        expect(chain.normalize!).to eq({
+          :job => "CanvasSync::Jobs::BeginSyncChainJob",
+          :parameters => [[
+            {:job=>"CanvasSync::JobBatches::ConcurrentBatchJob", :parameters=>[[
+              {:job=>"CanvasSync::Jobs::SyncProvisioningReportJob", :options=>{:models=>["users"], :b=>2}},
+              {:job=>"CanvasSync::Jobs::SyncTermsJob", :parameters=>[{
+                :sub_jobs=>[
+                  {:job=>"CanvasSync::Jobs::SyncProvisioningReportJob", :options=>{:models=>["courses"], :term_scope=>"active", :c=>3}}
+                ]
+              }]}
+            ]]}
+          ], {:legacy_support=>false, :updated_after=>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",
+            :parameters => [[
+              {:job=>"CanvasSync::JobBatches::ConcurrentBatchJob", :parameters=>[[
+                {:job=>"CanvasSync::Jobs::SyncProvisioningReportJob", :options=>{:models=>["users"]}},
+                {:job=>"CanvasSync::Jobs::SyncTermsJob", :parameters=>[{
+                  :sub_jobs=>[
+                    {:job=>"CanvasSync::Jobs::SyncProvisioningReportJob", :options=>{:models=>["courses"], :term_scope=>"active"}}
+                  ]
+                }]}
+              ]]}
+            ], {:legacy_support=>false, :updated_after=>nil}]
           })
         end
       end
@@ -58,26 +67,36 @@ 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",
+            :parameters => [[
+              {:job=>"CanvasSync::JobBatches::ConcurrentBatchJob", :parameters=>[[
+                {:job=>"CanvasSync::Jobs::SyncTermsJob", :parameters=>[{
+                  :sub_jobs=>[
+                    {:job=>"CanvasSync::Jobs::SyncProvisioningReportJob", :options=>{:models=>["users", "courses"], :term_scope=>nil}}
+                  ]
+                }]}
+              ]]}
+            ], {:legacy_support=>false, :updated_after=>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",
+            :parameters => [[
+              {:job=>"CanvasSync::JobBatches::ConcurrentBatchJob", :parameters=>[[
+                {:job=>"CanvasSync::Jobs::SyncRolesJob", :options=>{}},
+                {:job=>"CanvasSync::Jobs::SyncTermsJob", :parameters=>[{
+                  :sub_jobs=>[
+                    {:job=>"CanvasSync::Jobs::SyncProvisioningReportJob", :options=>{:models=>["courses"], :term_scope=>"active"}}
+                  ]
+                }]}
+              ]]}
+            ], {:legacy_support=>false, :updated_after=>nil}],
           })
         end
       end
@@ -85,27 +104,37 @@ 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",
+            :parameters => [[
+              {:job=>"CanvasSync::JobBatches::ConcurrentBatchJob", :parameters=>[[
+                {:job=>"CanvasSync::Jobs::SyncRolesJob", :options=>{}},
+                {:job=>"CanvasSync::Jobs::SyncTermsJob", :parameters=>[{
+                  :sub_jobs=>[
+                    {:job=>"CanvasSync::Jobs::SyncProvisioningReportJob", :options=>{:models=>["courses"], :term_scope=>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",
+            :parameters => [[
+              {:job=>"CanvasSync::JobBatches::ConcurrentBatchJob", :parameters=>[[
+                {:job=>"CanvasSync::Jobs::SyncAdminsJob", :options=>{}},
+                {:job=>"CanvasSync::Jobs::SyncTermsJob", :parameters=>[{
+                  :sub_jobs=>[
+                    {:job=>"CanvasSync::Jobs::SyncProvisioningReportJob", :options=>{:models=>["courses"], :term_scope=>"active"}}
+                  ]
+                }]}
+              ]]}
+            ], {:legacy_support=>false, :updated_after=>nil}],
           })
         end
       end
@@ -113,13 +142,18 @@ 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",
+            :parameters => [[
+              {:job=>"CanvasSync::JobBatches::ConcurrentBatchJob", :parameters=>[[
+                {:job=>"CanvasSync::Jobs::SyncAdminsJob", :options=>{}},
+                {:job=>"CanvasSync::Jobs::SyncTermsJob", :parameters=>[{
+                  :sub_jobs=>[
+                    {:job=>"CanvasSync::Jobs::SyncProvisioningReportJob", :options=>{:models=>["courses"], :term_scope=>nil}}
+                  ]
+                }]}
+              ]]}
+            ], {:legacy_support=>false, :updated_after=>nil}],
           })
         end
       end
@@ -128,13 +162,18 @@ 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",
+            :parameters => [[
+              {:job=>"CanvasSync::JobBatches::ConcurrentBatchJob", :parameters=>[[
+                {:job=>"CanvasSync::Jobs::SyncTermsJob", :parameters=>[{
+                  :sub_jobs=>[
+                    {:job=>"CanvasSync::Jobs::SyncAssignmentsJob", :options=>{}},
+                    {:job=>"CanvasSync::Jobs::SyncProvisioningReportJob", :options=>{:models=>["users", "enrollments"], :term_scope=>nil}}
+                  ]
+                }]}
+              ]]}
+            ], {:legacy_support=>false, :updated_after=>nil}],
           )
         end
       end
@@ -143,13 +182,18 @@ 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",
+            :parameters => [[
+              {:job=>"CanvasSync::JobBatches::ConcurrentBatchJob", :parameters=>[[
+                {:job=>"CanvasSync::Jobs::SyncTermsJob", :parameters=>[{
+                  :sub_jobs=>[
+                    {:job=>"CanvasSync::Jobs::SyncSubmissionsJob", :options=>{}},
+                    {:job=>"CanvasSync::Jobs::SyncProvisioningReportJob", :options=>{:models=>["users", "enrollments"], :term_scope=>nil}}
+                  ]
+                }]}
+              ]]}
+            ], {:legacy_support=>false, :updated_after=>nil}],
           )
         end
       end
@@ -158,95 +202,24 @@ 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",
+            :parameters => [[
+              {:job=>"CanvasSync::JobBatches::ConcurrentBatchJob", :parameters=>[[
+                {:job=>"CanvasSync::Jobs::SyncTermsJob", :parameters=>[{
+                  :sub_jobs=>[
+                    {:job=>"CanvasSync::Jobs::SyncAssignmentGroupsJob", :options=>{}},
+                    {:job=>"CanvasSync::Jobs::SyncProvisioningReportJob", :options=>{:models=>["users", "enrollments"], :term_scope=>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/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"