canvas_sync 0.16.5 → 0.17.0.beta5

data/lib/canvas_sync/processors/submissions_processor.rb

@@ -8,16 +8,15 @@ module CanvasSync
     # @param options [Hash]
     class SubmissionsProcessor < ReportProcessor
       def self.process(report_file_path, _options, report_id)
-        new(report_file_path, _options)
+        new(report_file_path)
       end
 
-      def initialize(report_file_path, options)
+      def initialize(report_file_path)
         CanvasSync::Importers::BulkImporter.import(
           report_file_path,
           mapping[:submissions][:report_columns],
           Submission,
           mapping[:submissions][:conflict_target].to_sym,
-          import_args: options
         )
       end
     end

data/lib/canvas_sync/version.rb

@@ -1,3 +1,3 @@
 module CanvasSync
-  VERSION = "0.16.5".freeze
+  VERSION = "0.17.0.beta5".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,44 @@ 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=>[{
+                :term_scope=>"active",
+                :sub_jobs=>[
+                  {:job=>"CanvasSync::Jobs::SyncProvisioningReportJob", :options=>{:models=>["courses"], :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=>[{
+                  :term_scope=>"active",
+                  :sub_jobs=>[
+                    {:job=>"CanvasSync::Jobs::SyncProvisioningReportJob", :options=>{:models=>["courses"]}}
+                  ]
+                }]}
+              ]]}
+            ], {:legacy_support=>false, :updated_after=>nil}]
           })
         end
       end
@@ -58,26 +69,38 @@ 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=>[{
+                  :term_scope=>nil,
+                  :sub_jobs=>[
+                    {:job=>"CanvasSync::Jobs::SyncProvisioningReportJob", :options=>{:models=>["users", "courses"]}}
+                  ]
+                }]}
+              ]]}
+            ], {: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=>[{
+                  :term_scope=>"active",
+                  :sub_jobs=>[
+                    {:job=>"CanvasSync::Jobs::SyncProvisioningReportJob", :options=>{:models=>["courses"]}}
+                  ]
+                }]}
+              ]]}
+            ], {:legacy_support=>false, :updated_after=>nil}],
           })
         end
       end
@@ -85,27 +108,39 @@ 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=>[{
+                  :term_scope=>nil,
+                  :sub_jobs=>[
+                    {:job=>"CanvasSync::Jobs::SyncProvisioningReportJob", :options=>{:models=>["courses"]}}
+                  ]
+                }]}
+              ]]}
+            ], {: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=>[{
+                  :term_scope=>"active",
+                  :sub_jobs=>[
+                    {:job=>"CanvasSync::Jobs::SyncProvisioningReportJob", :options=>{:models=>["courses"]}}
+                  ]
+                }]}
+              ]]}
+            ], {:legacy_support=>false, :updated_after=>nil}],
           })
         end
       end
@@ -113,13 +148,19 @@ 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=>[{
+                  :term_scope=>nil,
+                  :sub_jobs=>[
+                    {:job=>"CanvasSync::Jobs::SyncProvisioningReportJob", :options=>{:models=>["courses"]}}
+                  ]
+                }]}
+              ]]}
+            ], {:legacy_support=>false, :updated_after=>nil}],
           })
         end
       end
@@ -128,13 +169,19 @@ 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=>[{
+                  :term_scope=>nil,
+                  :sub_jobs=>[
+                    {:job=>"CanvasSync::Jobs::SyncAssignmentsJob", :options=>{}},
+                    {:job=>"CanvasSync::Jobs::SyncProvisioningReportJob", :options=>{:models=>["users", "enrollments"]}}
+                  ]
+                }]}
+              ]]}
+            ], {:legacy_support=>false, :updated_after=>nil}],
           )
         end
       end
@@ -143,13 +190,19 @@ 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=>[{
+                  :term_scope=>nil,
+                  :sub_jobs=>[
+                    {:job=>"CanvasSync::Jobs::SyncSubmissionsJob", :options=>{}},
+                    {:job=>"CanvasSync::Jobs::SyncProvisioningReportJob", :options=>{:models=>["users", "enrollments"]}}
+                  ]
+                }]}
+              ]]}
+            ], {:legacy_support=>false, :updated_after=>nil}],
           )
         end
       end
@@ -158,95 +211,25 @@ 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=>[{
+                  :term_scope=>nil,
+                  :sub_jobs=>[
+                    {:job=>"CanvasSync::Jobs::SyncAssignmentGroupsJob", :options=>{}},
+                    {:job=>"CanvasSync::Jobs::SyncProvisioningReportJob", :options=>{:models=>["users", "enrollments"]}}
+                  ]
+                }]}
+              ]]}
+            ], {: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"