canvas_sync 0.16.5 → 0.17.0.beta1

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(
-            hash_including(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(
-            hash_including(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(
-            hash_including(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/config/environments/test.rb

@@ -37,6 +37,8 @@ Rails.application.configure do
   # Print deprecation notices to the stderr.
   config.active_support.deprecation = :stderr
 
+  config.active_job.queue_adapter = :test
+
   # Raises error for missing translations
   # config.action_view.raise_on_missing_translations = true
 end

data/spec/dummy/db/schema.rb

@@ -10,7 +10,7 @@
 #
 # It's strongly recommended that you check this file into your version control system.
 
-ActiveRecord::Schema.define(version: 2020_10_16_181346) do
+ActiveRecord::Schema.define(version: 2020_10_18_210836) do
 
   # These are extensions that must be enabled in order to support this database
   enable_extension "plpgsql"
@@ -99,6 +99,14 @@ ActiveRecord::Schema.define(version: 2020_10_16_181346) do
     t.index ["job_id"], name: "index_canvas_sync_job_logs_on_job_id"
   end
 
+  create_table "canvas_sync_sync_batches", id: :serial, force: :cascade do |t|
+    t.datetime "started_at"
+    t.datetime "completed_at"
+    t.string "status"
+    t.datetime "created_at"
+    t.datetime "updated_at"
+  end
+
   create_table "context_module_items", force: :cascade do |t|
     t.bigint "canvas_id"
     t.bigint "canvas_context_module_id"

data/spec/job_batching/batch_aware_job_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+
+RSpec.describe CanvasSync::JobBatches::BatchAwareJob do
+  include ActiveJob::TestHelper
+
+  after do
+    clear_enqueued_jobs
+    clear_performed_jobs
+  end
+
+  context "When Performing" do
+    context 'when without batch' do
+      it 'just yields' do
+        expect(CanvasSync::JobBatches::Batch).not_to receive(:process_successful_job)
+        expect(CanvasSync::JobBatches::Batch).not_to receive(:process_failed_job)
+        expect_any_instance_of(BatchTestJobBase).to receive(:perform)
+
+        BatchTestJobBase.perform_now
+      end
+    end
+
+    context 'when in batch' do
+      let(:bid) { 'SAMPLEBID' }
+
+      context 'when successful' do
+        it 'yields' do
+          expect_any_instance_of(BatchTestJobBase).to receive(:perform)
+          BatchTestJobBase.perform_now
+        end
+
+        it 'calls process_successful_job' do
+          job = BatchTestJobBase.new
+          job.instance_variable_set(:@bid, bid)
+          expect(CanvasSync::JobBatches::Batch).to receive(:process_successful_job).with(bid, job.job_id)
+          job.perform_now
+        end
+      end
+
+      context 'when failed' do
+        it 'calls process_failed_job and reraises exception' do
+          reraised = false
+          job = FailingBatchTestJobBase.new
+          job.instance_variable_set(:@bid, bid)
+          expect(CanvasSync::JobBatches::Batch).to receive(:process_failed_job)
+          begin
+            job.perform_now
+          rescue
+            reraised = true
+          end
+          expect(reraised).to be_truthy
+        end
+      end
+    end
+  end
+
+  context "When Enqueueing" do
+    context 'when without batch' do
+      it 'just yields' do
+        expect(CanvasSync::JobBatches::Batch).not_to receive(:increment_job_queue)
+        BatchTestJobBase.perform_later
+        expect(BatchTestJobBase).to have_been_enqueued
+      end
+    end
+
+    context 'when in batch' do
+      let(:bid) { 'SAMPLEBID' }
+
+      before do
+        Thread.current[:batch] = CanvasSync::JobBatches::Batch.new(bid)
+        Thread.current[:batch].instance_variable_set(:@open, true)
+      end
+
+      it 'yields' do
+        expect {
+          BatchTestJobBase.perform_later
+        }.to enqueue_job(BatchTestJobBase)
+      end
+
+      it 'assigns bid to job metadata' do
+        job = BatchTestJobBase.perform_later
+        expect(job.bid).to eq bid
+        expect(job.serialize['batch_id']).to eq bid
+      end
+    end
+  end
+
+  context 'worker' do
+    it 'defines method bid' do
+      expect(ActiveJob::Base.instance_methods).to include(:bid)
+    end
+
+    it 'defines method batch' do
+      expect(ActiveJob::Base.instance_methods).to include(:batch)
+    end
+
+    it 'defines method valid_within_batch?' do
+      expect(ActiveJob::Base.instance_methods).to include(:valid_within_batch?)
+    end
+  end
+end