canvas_sync 0.15.1 → 0.17.0.beta1

data/lib/canvas_sync/jobs/sync_admins_job.rb

@@ -4,11 +4,10 @@ module CanvasSync
       # Syncs Admins using the Canvas API
       #
       #
-      # @param job_chain [Hash]
       # @param options [Hash]
-      def perform(job_chain, _options)
+      def perform(options)
         updated_admin_ids = []
-        api_client = CanvasSync.get_canvas_sync_client(job_chain[:global_options])
+        api_client = CanvasSync.get_canvas_sync_client(batch_context)
         CanvasSync.sync_scope(Account).find_each do |acc|
           api_client.account_admins(acc.canvas_id).all_pages_each do |admin_params|
             admin_params[:account_id] = acc.canvas_id
@@ -17,7 +16,6 @@ module CanvasSync
           end
         end
         Admin.where.not(id: updated_admin_ids).update_all(workflow_state: 'inactive')
-        CanvasSync.invoke_next(job_chain)
       end
     end
   end

data/lib/canvas_sync/jobs/sync_assignment_groups_job.rb

@@ -6,13 +6,11 @@ module CanvasSync
       # Starts a report processor for the assignment_groups report
       # (the proserv_assignment_group_export_csv report must be enabled)
       #
-      # @param job_chain [Hash]
       # @param options [Hash]
-      def perform(job_chain, options)
+      def perform(options)
         super(
-          job_chain,
           "proserv_assignment_group_export_csv",
-          merge_report_params(job_chain, options),
+          merge_report_params(options),
           CanvasSync::Processors::AssignmentGroupsProcessor.to_s,
           {},
         )

data/lib/canvas_sync/jobs/sync_assignments_job.rb

@@ -6,13 +6,11 @@ module CanvasSync
       # Starts a report processor for the assignment report
       # (the proserv_assignment_export_csv report must be enabled)
       #
-      # @param job_chain [Hash]
       # @param options [Hash]
-      def perform(job_chain, options)
+      def perform(options)
         super(
-          job_chain,
           "proserv_assignment_export_csv",
-          merge_report_params(job_chain, options),
+          merge_report_params(options),
           CanvasSync::Processors::AssignmentsProcessor.to_s,
           {},
         )

data/lib/canvas_sync/jobs/sync_context_module_items_job.rb

@@ -6,13 +6,11 @@ module CanvasSync
       # Starts a report processor for the context modules report
       # (the proserv_context_module_items_csv report must be enabled)
       #
-      # @param job_chain [Hash]
       # @param options [Hash]
-      def perform(job_chain, options)
+      def perform(options)
         super(
-          job_chain,
           "proserv_context_module_items_csv",
-          merge_report_params(job_chain, options),
+          merge_report_params(options),
           CanvasSync::Processors::ContextModuleItemsProcessor.to_s,
           {},
         )

data/lib/canvas_sync/jobs/sync_context_modules_job.rb

@@ -6,13 +6,11 @@ module CanvasSync
       # Starts a report processor for the context modules report
       # (the proserv_context_modules_csv report must be enabled)
       #
-      # @param job_chain [Hash]
       # @param options [Hash]
-      def perform(job_chain, options)
+      def perform(options)
         super(
-          job_chain,
           "proserv_context_modules_csv",
-          merge_report_params(job_chain, options),
+          merge_report_params(options),
           CanvasSync::Processors::ContextModulesProcessor.to_s,
           {},
         )

data/lib/canvas_sync/jobs/sync_provisioning_report_job.rb

@@ -2,40 +2,17 @@ module CanvasSync
   module Jobs
     # ActiveJob class that starts a Canvas provisioning report
     class SyncProvisioningReportJob < CanvasSync::Job
-      # @param job_chain [Hash]
       # @param options [Hash] If options contains a :term_scope a seperate provisioning report
       #   will be started for each term in that scope. :models should be an array of
       #   models to sync.
-      def perform(job_chain, options)
-        if options[:term_scope]
-          sub_reports = CanvasSync.fork(@job_log, job_chain, keys: [:canvas_term_id]) do |job_chain|
-            Term.send(options[:term_scope]).find_each.map do |term|
-              # Deep copy the job_chain so each report gets the correct term id passed into
-              # its options with no side effects
-              term_id = get_term_id(term)
-              duped_job_chain = Marshal.load(Marshal.dump(job_chain))
-              duped_job_chain[:global_options][:canvas_term_id] = term_id
-              {
-                job_chain: duped_job_chain,
-                params: report_params(options, term_id),
-                options: options,
-              }
-            end
-          end
-
-          sub_reports.each do |r|
-            start_report(r[:params], r[:job_chain], r[:options])
-          end
-        else
-          start_report(report_params(options), job_chain, options)
-        end
+      def perform(options)
+        start_report(report_params(options), options)
       end
 
-      private
+      protected
 
-      def start_report(report_params, job_chain, options)
+      def start_report(report_params, options)
         CanvasSync::Jobs::ReportStarter.perform_later(
-          job_chain,
           "proservices_provisioning_csv",
           report_params,
           CanvasSync::Processors::ProvisioningReportProcessor.to_s,
@@ -43,7 +20,7 @@ module CanvasSync
         )
       end
 
-      def report_params(options, canvas_term_id=nil)
+      def report_params(options, canvas_term_id = options[:canvas_term_id] || batch_context[:canvas_term_id])
         params = {
           include_deleted: true,
         }
@@ -60,10 +37,6 @@ module CanvasSync
 
         { parameters: params }
       end
-
-      def get_term_id(term)
-        term.try(:canvas_id) || term.canvas_term_id
-      end
     end
   end
 end

data/lib/canvas_sync/jobs/sync_roles_job.rb

@@ -3,12 +3,10 @@ module CanvasSync
     class SyncRolesJob < CanvasSync::Job
       # Syncs Roles using the Canvas API
       #
-      #
-      # @param job_chain [Hash]
       # @param options [Hash]
-      def perform(job_chain, _options)
+      def perform(options)
         updated_role_ids = []
-        api_client = CanvasSync.get_canvas_sync_client(job_chain[:global_options])
+        api_client = CanvasSync.get_canvas_sync_client(batch_context)
         CanvasSync.sync_scope(Account).find_each do |acc|
           api_client.list_roles(acc.canvas_id, state: %w[active inactive]).all_pages_each do |role_params|
             role = update_or_create_model(Role, role_params)
@@ -16,7 +14,6 @@ module CanvasSync
           end
         end
         Role.where.not(id: updated_role_ids).update_all(workflow_state: 'inactive')
-        CanvasSync.invoke_next(job_chain)
       end
     end
   end

data/lib/canvas_sync/jobs/sync_simple_table_job.rb

@@ -5,36 +5,19 @@ module CanvasSync
       # Starts a report processor for the specified report
       # (the specified report must be enabled)
       #
-      # @param job_chain [Hash]
-      # @param options [Hash]
-      def perform(job_chain, options)
-        if options[:term_scope]
-          sub_reports = CanvasSync.fork(@job_log, job_chain, keys: [:canvas_term_id]) do |job_chain|
-            Term.send(options[:term_scope]).find_each.map do |term|
-              # Deep copy the job_chain so each report gets the correct term id passed into
-              # its options with no side effects
-              term_id = get_term_id(term)
-              duped_job_chain = Marshal.load(Marshal.dump(job_chain))
-              duped_job_chain[:global_options][:canvas_term_id] = term_id
-              {
-                job_chain: duped_job_chain,
-                params: report_params(options, term_id),
-                options: options,
-              }
-            end
-          end
-
-          sub_reports.each do |r|
-            start_report(r[:params], r[:job_chain], r[:options])
-          end
-        else
-          start_report(report_params(options), job_chain, options)
-        end
+      # @param options [Hash] {
+      #   report_name: "", # Name of the report in the Canvas API
+      #   model: , # Model to map the report results as
+      #   mapping: {} # Mapping to describe how to convert the report to the Model,
+      #   klass: ,
+      #   params: {}, # List of params to pass to the report
+      # }
+      def perform(options)
+        start_report(report_params(options), options)
       end
 
-      def start_report(params, job_chain, options)
+      def start_report(params, options)
         CanvasSync::Jobs::ReportStarter.perform_later(
-          job_chain,
           options[:report_name],
           params,
           CanvasSync::Processors::NormalProcessor.to_s,
@@ -42,15 +25,11 @@ module CanvasSync
         )
       end
 
-      def report_params(options, canvas_term_id=nil)
+      def report_params(options, canvas_term_id = options[:canvas_term_id] || batch_context[:canvas_term_id])
         params = options[:params] || {}
         params["parameters[enrollment_term_id]"] = canvas_term_id if canvas_term_id
         params
       end
-
-      def get_term_id(term)
-        term.try(:canvas_id) || term.canvas_term_id
-      end
     end
   end
 end

data/lib/canvas_sync/jobs/sync_submissions_job.rb

@@ -6,13 +6,11 @@ module CanvasSync
       # Starts a report processor for the submission report
       # (the proserv_student_submissions_csv report must be enabled)
       #
-      # @param job_chain [Hash]
       # @param options [Hash]
-      def perform(job_chain, options)
+      def perform(options)
         super(
-          job_chain,
           "proserv_student_submissions_csv",
-          merge_report_params(job_chain, options, { include_all: options[:include_all] }, {}),
+          merge_report_params(options, { include_all: options[:include_all] }, {}),
           CanvasSync::Processors::SubmissionsProcessor.to_s,
           {},
         )

data/lib/canvas_sync/jobs/sync_terms_job.rb

@@ -5,16 +5,15 @@ module CanvasSync
       #
       # Terms are pre-synced so that provisioning reports can be scoped to term.
       #
-      # @param job_chain [Hash]
       # @param options [Hash]
-      def perform(job_chain, _options)
-        CanvasSync.get_canvas_sync_client(job_chain[:global_options]).terms("self").all_pages!.each do |term_params|
-          if job_chain[:global_options][:account_id]
+      def perform(options)
+        CanvasSync.get_canvas_sync_client(batch_context).terms("self").all_pages!.each do |term_params|
+          if account_id = batch_context[:account_id]
             # These branches are primarily to support Legacy apps
             if Term.respond_to?(:create_or_update) && Term.method(:create_or_update).arity.abs == 2
-              Term.create_or_update(term_params, job_chain[:global_options][:account_id])
+              Term.create_or_update(term_params, account_id)
             else
-              term_params[:account_id] |= job_chain[:global_options][:account_id]
+              term_params[:account_id] |= account_id
               update_or_create_model(Term, term_params)
             end
           else
@@ -22,7 +21,23 @@ module CanvasSync
           end
         end
 
-        CanvasSync.invoke_next(job_chain)
+        if (jobs = options[:sub_jobs]).present?
+          context = options[:context] || {}
+          if options[:term_scope]
+            Term.send(options[:term_scope]).find_each.map do |term|
+              local_context = context.merge(canvas_term_id: get_term_id(term))
+              JobBatches::ConcurrentBatchJob.perform_now(jobs, context: local_context)
+            end
+          else
+            JobBatches::ConcurrentBatchJob.perform_now(jobs, context: context)
+          end
+        end
+      end
+
+      protected
+
+      def get_term_id(term)
+        term.try(:canvas_id) || term.canvas_term_id
       end
     end
   end

data/lib/canvas_sync/misc_helper.rb

@@ -0,0 +1,15 @@
+require 'active_record'
+
+module CanvasSync
+  module MiscHelper
+    MigrationClass = Rails.version < '5.0' ? ActiveRecord::Migration : ActiveRecord::Migration[4.2]
+
+    def self.to_boolean(v)
+      if Rails.version < '5.0'
+        ActiveRecord::Type::Boolean.new.type_cast_from_user(v)
+      else
+        ActiveRecord::Type::Boolean.new.deserialize(v)
+      end
+    end
+  end
+end

data/lib/canvas_sync/processors/model_mappings.yml

@@ -249,6 +249,9 @@ submissions:
     submission_date:
       database_column_name: submitted_at
       type: datetime
+    due_at:
+      database_column_name: due_at
+      type: datetime
     graded_date:
       database_column_name: graded_at
       type: datetime

data/lib/canvas_sync/version.rb

@@ -1,3 +1,3 @@
 module CanvasSync
-  VERSION = "0.15.1".freeze
+  VERSION = "0.17.0.beta1".freeze
 end

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