canvas_sync 0.16.4 → 0.17.0.beta1

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,

data/spec/canvas_sync/jobs/report_starter_spec.rb

@@ -16,7 +16,6 @@ RSpec.describe CanvasSync::Jobs::ReportStarter do
       expect(CanvasSync::Jobs::ReportChecker).to receive(:set).and_call_original
 
       CanvasSync::Jobs::ReportStarter.perform_now(
-                                { jobs: [], global_options: {} },
                                 report_name,
                                 report_params,
                                 processor,
@@ -24,30 +23,27 @@ RSpec.describe CanvasSync::Jobs::ReportStarter do
     end
 
     context 'allow_redownloads is true' do
-      context 'the report has already been cached' do
-        it 'runs the report checker for the already started report' do
-          expect_any_instance_of(Bearcat::Client).to_not receive(:start_report)
-          job_chain = { jobs: [], global_options: { report_name => 1 } }
+      # context 'the report has already been cached' do
+      #   it 'runs the report checker for the already started report' do
+      #     expect_any_instance_of(Bearcat::Client).to_not receive(:start_report)
 
-          expect(CanvasSync::Jobs::ReportChecker).to receive(:set).and_return(report_checker_double)
-          expect(report_checker_double).to receive(:perform_later).with(
-            job_chain,
-            report_name,
-            1,
-            processor,
-            options
-          )
+      #     expect(CanvasSync::Jobs::ReportChecker).to receive(:set).and_return(report_checker_double)
+      #     expect(report_checker_double).to receive(:perform_later).with(
+      #       report_name,
+      #       1,
+      #       processor,
+      #       options
+      #     )
 
-          CanvasSync::Jobs::ReportStarter.perform_now(
-                                    job_chain,
-                                    report_name,
-                                    report_params,
-                                    processor,
-                                    options,
-                                    allow_redownloads: true
-          )
-        end
-      end
+      #     CanvasSync::Jobs::ReportStarter.perform_now(
+      #                               report_name,
+      #                               report_params,
+      #                               processor,
+      #                               options,
+      #                               allow_redownloads: true
+      #     )
+      #   end
+      # end
 
       context 'the report has not been started before' do
         it 'starts a new report and caches the report id' do
@@ -55,12 +51,8 @@ RSpec.describe CanvasSync::Jobs::ReportStarter do
             .with('self', report_name, report_params)
             .and_return({ 'id' => 1 })
 
-          orig_job_chain = { jobs: [], global_options: {} }
-          new_job_chain = { jobs: [], global_options: { report_name => 1 } }
-
           expect(CanvasSync::Jobs::ReportChecker).to receive(:set).and_return(report_checker_double)
           expect(report_checker_double).to receive(:perform_later).with(
-            new_job_chain,
             report_name,
             1,
             processor,
@@ -68,7 +60,6 @@ RSpec.describe CanvasSync::Jobs::ReportStarter do
           )
 
           CanvasSync::Jobs::ReportStarter.perform_now(
-                                    orig_job_chain,
                                     report_name,
                                     report_params,
                                     processor,

data/spec/canvas_sync/jobs/sync_admins_job_spec.rb

@@ -4,13 +4,10 @@ RSpec.describe CanvasSync::Jobs::SyncAdminsJob do
   describe '#perform' do
     let!(:account) { FactoryGirl.create(:account, canvas_id: 1) }
     let(:admin_params) { open_canvas_fixture('admins') }
-    let(:job_chain) { { jobs: [], global_options: {}} }
 
     it 'retrieves all admins from the Canvas API and then invokes the next job' do
-      expect(CanvasSync).to receive(:invoke_next).with(job_chain)
-
       expect {
-        CanvasSync::Jobs::SyncAdminsJob.perform_now(job_chain, {})
+        CanvasSync::Jobs::SyncAdminsJob.perform_now({})
       }.to change { Admin.count }.by(admin_params.length)
     end
   end

data/spec/canvas_sync/jobs/sync_assignment_groups_job_spec.rb

@@ -10,7 +10,8 @@ RSpec.describe CanvasSync::Jobs::SyncAssignmentGroupsJob do
 
         expect(CanvasSync::Jobs::ReportChecker).to receive(:set).and_call_original
 
-        CanvasSync::Jobs::SyncAssignmentGroupsJob.perform_now({ jobs: [], global_options: { canvas_term_id: 1 } }, {})
+        set_batch_context(canvas_term_id: 1)
+        CanvasSync::Jobs::SyncAssignmentGroupsJob.perform_now({})
       end
     end
   end

data/spec/canvas_sync/jobs/sync_assignments_job_spec.rb

@@ -10,7 +10,8 @@ RSpec.describe CanvasSync::Jobs::SyncAssignmentsJob do
 
         expect(CanvasSync::Jobs::ReportChecker).to receive(:set).and_call_original
 
-        CanvasSync::Jobs::SyncAssignmentsJob.perform_now({ jobs: [], global_options: { canvas_term_id: 1 } }, {})
+        set_batch_context(canvas_term_id: 1)
+        CanvasSync::Jobs::SyncAssignmentsJob.perform_now({})
       end
     end
 
@@ -22,7 +23,7 @@ RSpec.describe CanvasSync::Jobs::SyncAssignmentsJob do
 
         expect(CanvasSync::Jobs::ReportChecker).to receive(:set).and_call_original
 
-        CanvasSync::Jobs::SyncAssignmentsJob.perform_now({ jobs: [], global_options: {} }, {})
+        CanvasSync::Jobs::SyncAssignmentsJob.perform_now({})
       end
     end
   end

data/spec/canvas_sync/jobs/sync_context_module_items_job_spec.rb

@@ -10,7 +10,8 @@ RSpec.describe CanvasSync::Jobs::SyncContextModuleItemsJob do
 
         expect(CanvasSync::Jobs::ReportChecker).to receive(:set).and_call_original
 
-        CanvasSync::Jobs::SyncContextModuleItemsJob.perform_now({ jobs: [], global_options: { canvas_term_id: 1 } }, {})
+        set_batch_context(canvas_term_id: 1)
+        CanvasSync::Jobs::SyncContextModuleItemsJob.perform_now({})
       end
     end
 
@@ -22,7 +23,7 @@ RSpec.describe CanvasSync::Jobs::SyncContextModuleItemsJob do
 
         expect(CanvasSync::Jobs::ReportChecker).to receive(:set).and_call_original
 
-        CanvasSync::Jobs::SyncContextModuleItemsJob.perform_now({ jobs: [], global_options: {} }, {})
+        CanvasSync::Jobs::SyncContextModuleItemsJob.perform_now({})
       end
     end
   end

data/spec/canvas_sync/jobs/sync_context_modules_job_spec.rb

@@ -10,7 +10,8 @@ RSpec.describe CanvasSync::Jobs::SyncContextModulesJob do
 
         expect(CanvasSync::Jobs::ReportChecker).to receive(:set).and_call_original
 
-        CanvasSync::Jobs::SyncContextModulesJob.perform_now({ jobs: [], global_options: { canvas_term_id: 1 } }, {})
+        set_batch_context(canvas_term_id: 1)
+        CanvasSync::Jobs::SyncContextModulesJob.perform_now({})
       end
     end
 
@@ -22,7 +23,7 @@ RSpec.describe CanvasSync::Jobs::SyncContextModulesJob do
 
         expect(CanvasSync::Jobs::ReportChecker).to receive(:set).and_call_original
 
-        CanvasSync::Jobs::SyncContextModulesJob.perform_now({ jobs: [], global_options: {} }, {})
+        CanvasSync::Jobs::SyncContextModulesJob.perform_now({})
       end
     end
   end

data/spec/canvas_sync/jobs/sync_provisioning_report_job_spec.rb

@@ -2,59 +2,29 @@ require 'spec_helper'
 
 RSpec.describe CanvasSync::Jobs::SyncProvisioningReportJob do
   describe '#perform' do
-    let(:job_chain) { {jobs: [], global_options: {}} }
-
     context 'a term scope is specified' do
-      let!(:active_term_1) { FactoryGirl.create(:term) }
-      let!(:active_term_2) { FactoryGirl.create(:term) }
-      let!(:inactive_term_1) { FactoryGirl.create(:term, workflow_state: 'inactive') }
+      let!(:term) { FactoryGirl.create(:term) }
 
       it 'enqueues a ReportStarter for a provisioning report for the specified models for each term' do
-        expected_job_chain = Marshal.load(Marshal.dump(job_chain))
-        expected_job_chain[:global_options][:canvas_term_id] = active_term_1.canvas_id
-        expected_job_chain[:global_options] = hash_including(expected_job_chain[:global_options])
-
-        expect(CanvasSync::Jobs::ReportStarter).to receive(:perform_later)
-          .with(
-            expected_job_chain,
-            'proservices_provisioning_csv',
-            {
-              parameters: {
-                include_deleted: true,
-                'users' => true,
-                'courses' => true,
-                enrollment_term_id: active_term_1.canvas_id
-              }
-            },
-            CanvasSync::Processors::ProvisioningReportProcessor.to_s,
-            { models: ['users', 'courses'], term_scope: 'active' }
-          )
-
-        expected_job_chain_2 = Marshal.load(Marshal.dump(job_chain))
-        expected_job_chain_2[:global_options][:canvas_term_id] = active_term_2.canvas_id
-        expected_job_chain_2[:global_options] = hash_including(expected_job_chain_2[:global_options])
-
         expect(CanvasSync::Jobs::ReportStarter).to receive(:perform_later)
           .with(
-            expected_job_chain_2,
             'proservices_provisioning_csv',
             {
               parameters: {
                 include_deleted: true,
                 'users' => true,
                 'courses' => true,
-                enrollment_term_id: active_term_2.canvas_id
+                enrollment_term_id: term.canvas_id
               }
             },
             CanvasSync::Processors::ProvisioningReportProcessor.to_s,
             { models: ['users', 'courses'], term_scope: 'active' }
           )
 
+        set_batch_context(canvas_term_id: term.canvas_id)
         CanvasSync::Jobs::SyncProvisioningReportJob.perform_now(
-          job_chain,
           { models: ['users', 'courses'], term_scope: 'active' }
         )
-        expect(CanvasSync::JobLog.last.fork_count).to eq 2
       end
     end
 
@@ -62,7 +32,6 @@ RSpec.describe CanvasSync::Jobs::SyncProvisioningReportJob do
       it 'enqueues a single ReportStarter for a provisioning report across all terms for the specified models' do
         expect(CanvasSync::Jobs::ReportStarter).to receive(:perform_later)
           .with(
-            job_chain,
             'proservices_provisioning_csv',
             {
               parameters: {
@@ -76,7 +45,6 @@ RSpec.describe CanvasSync::Jobs::SyncProvisioningReportJob do
           )
 
         CanvasSync::Jobs::SyncProvisioningReportJob.perform_now(
-          job_chain,
           { models: ['users', 'courses'] }
         )
       end

data/spec/canvas_sync/jobs/sync_roles_job_spec.rb

@@ -4,13 +4,10 @@ RSpec.describe CanvasSync::Jobs::SyncRolesJob do
   describe '#perform' do
     let!(:account) { FactoryGirl.create(:account, canvas_id: 1) }
     let(:role_params) { open_canvas_fixture('roles') }
-    let(:job_chain) { { jobs: [], global_options: {}} }
 
     it 'retrieves all roles from the Canvas API and then invokes the next job' do
-      expect(CanvasSync).to receive(:invoke_next).with(job_chain)
-
       expect {
-        CanvasSync::Jobs::SyncRolesJob.perform_now(job_chain, {})
+        CanvasSync::Jobs::SyncRolesJob.perform_now({})
       }.to change { Role.count }.by(role_params.length)
     end
   end

data/spec/canvas_sync/jobs/sync_simple_table_job_spec.rb

@@ -2,25 +2,17 @@ require 'spec_helper'
 
 RSpec.describe CanvasSync::Jobs::SyncSimpleTableJob do
   describe '#perform' do
-    let(:job_chain) { {jobs: [], global_options: {}} }
-
     context 'Simple report' do
-      let!(:active_term_1) { FactoryGirl.create(:term) }
-      let!(:inactive_term_1) { FactoryGirl.create(:term, workflow_state: 'inactive') }
+      let!(:term) { FactoryGirl.create(:term) }
 
       it 'enqueues a ReportStarter for a provisioning report for the specified model for a term' do
-        expected_job_chain = Marshal.load(Marshal.dump(job_chain))
-        expected_job_chain[:global_options][:canvas_term_id] = active_term_1.canvas_id
-        expected_job_chain[:global_options] = hash_including(expected_job_chain[:global_options])
-
         expect(CanvasSync::Jobs::ReportStarter).to receive(:perform_later)
           .with(
-            expected_job_chain,
             'proservices_provisioning_csv',
             {
               "parameters[include_deleted]" => true,
               "parameters[courses]" => true,
-              "parameters[enrollment_term_id]" => active_term_1.canvas_id
+              "parameters[enrollment_term_id]" => term.canvas_id
             },
             CanvasSync::Processors::NormalProcessor.to_s,
             {
@@ -32,13 +24,14 @@ RSpec.describe CanvasSync::Jobs::SyncSimpleTableJob do
               params: {
                 "parameters[include_deleted]" => true,
                 "parameters[courses]" => true,
-                "parameters[enrollment_term_id]" => active_term_1.canvas_id
+                "parameters[enrollment_term_id]" => term.canvas_id
               }
             }
           )
 
+        set_batch_context(canvas_term_id: term.canvas_id)
+
         CanvasSync::Jobs::SyncSimpleTableJob.perform_now(
-          job_chain,
           {
             report_name: 'proservices_provisioning_csv',
             model: 'courses',

data/spec/canvas_sync/jobs/sync_submissions_job_spec.rb

@@ -10,7 +10,8 @@ RSpec.describe CanvasSync::Jobs::SyncSubmissionsJob do
 
         expect(CanvasSync::Jobs::ReportChecker).to receive(:set).and_call_original
 
-        CanvasSync::Jobs::SyncSubmissionsJob.perform_now({ jobs: [], global_options: { canvas_term_id: 1 } }, {})
+        set_batch_context(canvas_term_id: 1)
+        CanvasSync::Jobs::SyncSubmissionsJob.perform_now({})
       end
     end
   end

data/spec/canvas_sync/jobs/sync_terms_job_spec.rb

@@ -3,13 +3,10 @@ require 'spec_helper'
 RSpec.describe CanvasSync::Jobs::SyncTermsJob do
   describe '#perform' do
     let(:term_params) { open_canvas_fixture('terms')['enrollment_terms'] }
-    let(:job_chain) { { jobs: [], global_options: {}} }
 
     it 'retrieves all terms from the Canvas API and then invokes the next job' do
-      expect(CanvasSync).to receive(:invoke_next).with(job_chain)
-
       expect {
-        CanvasSync::Jobs::SyncTermsJob.perform_now(job_chain, {})
+        CanvasSync::Jobs::SyncTermsJob.perform_now({})
       }.to change { Term.count }.by(term_params.length)
     end
   end

data/spec/dummy/app/models/account.rb

@@ -20,6 +20,9 @@ class Account < ApplicationRecord
                           primary_key: :canvas_id, foreign_key: :canvas_parent_account_id
   has_many :groups, primary_key: :canvas_id, foreign_key: :canvas_account_id
 
+  scope :active, -> { where.not(workflow_state: 'deleted') }
+  # scope :should_canvas_sync, -> { active } # Optional - uses .active if not given
+
   api_syncable({
     name: :name,
     workflow_state: :workflow_state,