canvas_sync 0.10.3 → 0.11.1

data/lib/canvas_sync/processors/submissions_processor.rb

@@ -8,15 +8,16 @@ module CanvasSync
     # @param options [Hash]
     class SubmissionsProcessor < ReportProcessor
       def self.process(report_file_path, _options, report_id)
-        new(report_file_path)
+        new(report_file_path, _options)
       end
 
-      def initialize(report_file_path)
+      def initialize(report_file_path, options)
         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.10.3".freeze
+  VERSION = "0.11.1".freeze
 end

data/spec/canvas_sync/canvas_sync_spec.rb

@@ -24,6 +24,23 @@ RSpec.describe CanvasSync do
     end
 
     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: {
+          terms: { a: 1 },
+          users: { b: 2 },
+          provisioning: { c: 3 },
+          global: { d: 4 },
+        })
+        expect(chain).to eq({
+          jobs: [
+            { job: CanvasSync::Jobs::SyncTermsJob.to_s, options: { a: 1 } },
+            { job: CanvasSync::Jobs::SyncUsersJob.to_s, options: { b: 2 } },
+            { job: CanvasSync::Jobs::SyncProvisioningReportJob.to_s, options: { term_scope: 'active', models: ['courses'], c: 3 } }
+          ],
+          global_options: { legacy_support: false, 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)

data/spec/canvas_sync/jobs/fork_gather_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+RSpec.describe CanvasSync::Jobs::ForkGather do
+  describe '#perform' do
+    let!(:job_log) { CanvasSync::JobLog.create!(job_id: 'BLAH', fork_count: 3) }
+    let(:job_chain) { {jobs: [], global_options: { fork_path: ['BLAH'] }} }
+
+    it 'decrements fork_count' do
+      CanvasSync::Jobs::ForkGather.perform_now(job_chain, {})
+      expect(job_log.reload.fork_count).to eq 2
+    end
+
+    it 'does not continue chain if fork_count > 0' do
+      expect(CanvasSync).not_to receive(:invoke_next)
+      CanvasSync::Jobs::ForkGather.perform_now(job_chain, {})
+    end
+
+    it 'continues the chain if fork_count <= 0' do
+      job_log.update!(fork_count: 1)
+      expect(CanvasSync).to receive(:invoke_next)
+      CanvasSync::Jobs::ForkGather.perform_now(job_chain, {})
+    end
+
+    it 'continues if no fork_path is specified' do
+      job_chain[:global_options].delete(:fork_path)
+      expect(CanvasSync).to receive(:invoke_next)
+      CanvasSync::Jobs::ForkGather.perform_now(job_chain, {})
+    end
+
+    it 'pops the most-recent fork_path enrty' do
+      job_log.update!(fork_count: 1)
+      expect(CanvasSync).to receive(:invoke_next) do |*args|
+        expect(args[0][:global_options][:fork_path]).to eq []
+      end
+      CanvasSync::Jobs::ForkGather.perform_now(job_chain, {})
+    end
+  end
+
+  describe 'handle_branch_error' do
+    let(:error) { StandardError.new }
+
+    let(:job_chain) {
+      {
+        jobs: [
+          { job: 'CanvasSync::Jobs::ReportChecker' },
+          { job: 'CanvasSync::Jobs::ReportChecker' },
+          { job: 'CanvasSync::Jobs::ForkGather' },
+          { job: 'CanvasSync::Jobs::ReportChecker' },
+        ],
+        global_options: {
+          fork_path: ['BLAH'],
+        }
+      }
+    }
+
+    it 'skips to and performs the next ForkGatherJob' do
+      expect(CanvasSync).to receive(:invoke_next) do |*args|
+        expect(args[0][:jobs][0][:job]).to eq 'CanvasSync::Jobs::ForkGather'
+      end
+      expect(CanvasSync::Jobs::ForkGather.handle_branch_error(error, job_chain: job_chain)).to be true
+    end
+
+    it 'does nothing if no ForkGather is in the chain' do
+      job_chain[:jobs].delete_at(2)
+      expect(CanvasSync::Jobs::ForkGather.handle_branch_error(error, job_chain: job_chain)).to be nil
+    end
+
+    it 'does nothing if no fork_path is present' do
+      job_chain[:global_options][:fork_path] = []
+      expect(CanvasSync::Jobs::ForkGather.handle_branch_error(error, job_chain: job_chain)).to be nil
+    end
+  end
+end

data/spec/canvas_sync/jobs/job_spec.rb

@@ -1,40 +1,74 @@
 require 'spec_helper'
 
 class GoodJob < CanvasSync::Job
-  def perform(argument)
+  def perform(job_chain, argument)
   end
 end
 
 class EvilError < StandardError; end;
 
 class BadJob < CanvasSync::Job
-  def perform(argument)
+  def perform(job_chain, argument)
     raise EvilError
   end
+
+  def self.evil_catcher(e, *opts)
+    raise EvilError
+  end
+
+  def self.good_catcher(e, *opts)
+
+  end
 end
 
 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
       expect(job_log.exception).to eq("EvilError: EvilError")
       expect(job_log.backtrace).to_not be_nil
     end
+
+    it 'invokes an error handler' do
+      expect(BadJob).to receive(:good_catcher).once
+      expect {
+        BadJob.perform_now({
+          jobs: [],
+          global_options: {
+            on_failure: 'BadJob.good_catcher'
+          }
+        })
+      }.to raise_exception(StandardError)
+    end
+
+    it 'logs a failing error handler' do
+      expect(BadJob).to receive(:bad_catcher).once.and_call_original
+      expect {
+        BadJob.perform_now({
+          jobs: [],
+          global_options: {
+            on_failure: 'BadJob.bad_catcher'
+          }
+        })
+      }.to raise_exception(StandardError)
+      job_log = CanvasSync::JobLog.last
+      expect(job_log.backtrace).to include "Error Occurred while handling an Error"
+    end
   end
 end

data/spec/canvas_sync/jobs/sync_admins_job_spec.rb

@@ -2,10 +2,11 @@ require 'spec_helper'
 
 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 terms from the Canvas API and then invokes the next job' do
+    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 {

data/spec/canvas_sync/jobs/sync_assignment_groups_job_spec.rb

@@ -5,7 +5,7 @@ RSpec.describe CanvasSync::Jobs::SyncAssignmentGroupsJob do
     context "a term id is in the global_options" do
       it "enqueues a ReportStarter for the proserv_assignment_group_export_csv for the given term" do
         expect_any_instance_of(Bearcat::Client).to receive(:start_report)
-          .with("self", "proserv_assignment_group_export_csv", "parameters[enrollment_term_id]" => 1)
+          .with("self", "proserv_assignment_group_export_csv", { parameters: { enrollment_term_id: 1 } })
           .and_return("id" => 1)
 
         expect(CanvasSync::Jobs::ReportChecker).to receive(:set).and_call_original

data/spec/canvas_sync/jobs/sync_assignments_job_spec.rb

@@ -5,7 +5,7 @@ RSpec.describe CanvasSync::Jobs::SyncAssignmentsJob do
     context "a term id is in the global_options" do
       it "enqueues a ReportStarter for the proserv_assignment_export_csv for the given term" do
         expect_any_instance_of(Bearcat::Client).to receive(:start_report)
-          .with("self", "proserv_assignment_export_csv", "parameters[enrollment_term_id]" => 1)
+          .with("self", "proserv_assignment_export_csv", { parameters: { enrollment_term_id: 1 } })
           .and_return("id" => 1)
 
         expect(CanvasSync::Jobs::ReportChecker).to receive(:set).and_call_original
@@ -17,7 +17,7 @@ RSpec.describe CanvasSync::Jobs::SyncAssignmentsJob do
     context "no term id is specified" do
       it "enqueues a ReportStarter for the proserv_assignment_export_csv for all terms" do
         expect_any_instance_of(Bearcat::Client).to receive(:start_report)
-          .with("self", "proserv_assignment_export_csv", {})
+          .with("self", "proserv_assignment_export_csv", { parameters: {} })
           .and_return("id" => 1)
 
         expect(CanvasSync::Jobs::ReportChecker).to receive(:set).and_call_original

data/spec/canvas_sync/jobs/sync_context_module_items_job_spec.rb

@@ -5,7 +5,7 @@ RSpec.describe CanvasSync::Jobs::SyncContextModuleItemsJob do
     context "a term id is in the global_options" do
       it "enqueues a ReportStarter for the proserv_context_module_items_csv for the given term" do
         expect_any_instance_of(Bearcat::Client).to receive(:start_report)
-          .with("self", "proserv_context_module_items_csv", "parameters[enrollment_term_id]" => 1)
+          .with("self", "proserv_context_module_items_csv", { parameters: { enrollment_term_id: 1 } })
           .and_return("id" => 1)
 
         expect(CanvasSync::Jobs::ReportChecker).to receive(:set).and_call_original
@@ -17,7 +17,7 @@ RSpec.describe CanvasSync::Jobs::SyncContextModuleItemsJob do
     context "no term id is specified" do
       it "enqueues a ReportStarter for the proserv_context_module_items_csv for all terms" do
         expect_any_instance_of(Bearcat::Client).to receive(:start_report)
-          .with("self", "proserv_context_module_items_csv", {})
+          .with("self", "proserv_context_module_items_csv", { parameters: { } })
           .and_return("id" => 1)
 
         expect(CanvasSync::Jobs::ReportChecker).to receive(:set).and_call_original

data/spec/canvas_sync/jobs/sync_context_modules_job_spec.rb

@@ -5,7 +5,7 @@ RSpec.describe CanvasSync::Jobs::SyncContextModulesJob do
     context "a term id is in the global_options" do
       it "enqueues a ReportStarter for the proserv_context_modules_csv for the given term" do
         expect_any_instance_of(Bearcat::Client).to receive(:start_report)
-          .with("self", "proserv_context_modules_csv", "parameters[enrollment_term_id]" => 1)
+          .with("self", "proserv_context_modules_csv", { parameters: { enrollment_term_id: 1 } })
           .and_return("id" => 1)
 
         expect(CanvasSync::Jobs::ReportChecker).to receive(:set).and_call_original
@@ -17,7 +17,7 @@ RSpec.describe CanvasSync::Jobs::SyncContextModulesJob do
     context "no term id is specified" do
       it "enqueues a ReportStarter for the proserv_context_modules_csv for all terms" do
         expect_any_instance_of(Bearcat::Client).to receive(:start_report)
-          .with("self", "proserv_context_modules_csv", {})
+          .with("self", "proserv_context_modules_csv", { parameters: { } })
           .and_return("id" => 1)
 
         expect(CanvasSync::Jobs::ReportChecker).to receive(:set).and_call_original

data/spec/canvas_sync/jobs/sync_provisioning_report_job_spec.rb

@@ -12,16 +12,19 @@ RSpec.describe CanvasSync::Jobs::SyncProvisioningReportJob do
       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,
-              "parameters[users]" => true,
-              "parameters[courses]" => true,
-              "parameters[enrollment_term_id]" => active_term_1.canvas_id
+              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' }
@@ -29,16 +32,19 @@ RSpec.describe CanvasSync::Jobs::SyncProvisioningReportJob do
 
         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,
-              "parameters[users]" => true,
-              "parameters[courses]" => true,
-              "parameters[enrollment_term_id]" => active_term_2.canvas_id
+              parameters: {
+                include_deleted: true,
+                'users' => true,
+                'courses' => true,
+                enrollment_term_id: active_term_2.canvas_id
+              }
             },
             CanvasSync::Processors::ProvisioningReportProcessor.to_s,
             { models: ['users', 'courses'], term_scope: 'active' }
@@ -48,6 +54,7 @@ RSpec.describe CanvasSync::Jobs::SyncProvisioningReportJob do
           job_chain,
           { models: ['users', 'courses'], term_scope: 'active' }
         )
+        expect(CanvasSync::JobLog.last.fork_count).to eq 2
       end
     end
 
@@ -58,9 +65,11 @@ RSpec.describe CanvasSync::Jobs::SyncProvisioningReportJob do
             job_chain,
             'proservices_provisioning_csv',
             {
-              "parameters[include_deleted]" => true,
-              "parameters[users]" => true,
-              "parameters[courses]" => true
+              parameters: {
+                include_deleted: true,
+                'users' => true,
+                'courses' => true,
+              }
             },
             CanvasSync::Processors::ProvisioningReportProcessor.to_s,
             { models: ['users', 'courses'] }

data/spec/canvas_sync/jobs/sync_roles_job_spec.rb

@@ -2,10 +2,11 @@ require 'spec_helper'
 
 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 terms from the Canvas API and then invokes the next job' do
+    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 {

data/spec/canvas_sync/jobs/sync_simple_table_job_spec.rb

@@ -11,6 +11,7 @@ RSpec.describe CanvasSync::Jobs::SyncSimpleTableJob do
       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(

data/spec/canvas_sync/jobs/sync_submissions_job_spec.rb

@@ -5,7 +5,7 @@ RSpec.describe CanvasSync::Jobs::SyncSubmissionsJob do
     context "a term id is in the global_options" do
       it "enqueues a ReportStarter for the proserv_student_submissions_csv for the given term" do
         expect_any_instance_of(Bearcat::Client).to receive(:start_report)
-          .with("self", "proserv_student_submissions_csv", "parameters[enrollment_term_id]" => 1)
+          .with("self", "proserv_student_submissions_csv", { parameters: { enrollment_term_id: 1, include_all: nil } })
           .and_return("id" => 1)
 
         expect(CanvasSync::Jobs::ReportChecker).to receive(:set).and_call_original

data/spec/canvas_sync/jobs/sync_users_job_spec.rb

@@ -4,7 +4,7 @@ RSpec.describe CanvasSync::Jobs::SyncUsersJob do
   describe '#perform' do
     it 'enqueues a ReportStarter for a provisioning report across all terms with just users' do
       expect_any_instance_of(Bearcat::Client).to receive(:start_report)
-        .with('self', 'proservices_provisioning_csv', CanvasSync::Jobs::SyncUsersJob::REPORT_PARAMS)
+        .with('self', 'proservices_provisioning_csv', { parameters: { users: true, include_deleted: true } })
         .and_return({ 'id' => 1 })
 
       expect(CanvasSync::Jobs::ReportChecker).to receive(:set).and_call_original

data/spec/canvas_sync/models/admins_spec.rb

@@ -8,19 +8,18 @@ RSpec.describe Admin, type: :model do
     it { should validate_uniqueness_of(:canvas_id) }
   end
 
-  describe '.create_or_update' do
+  describe '.create_or_update_from_api_params' do
     let(:admin_params) { open_canvas_fixture('admins')[0] }
 
     context 'the admin does not already exist' do
       it 'creates it' do
         expect {
-          Admin.create_or_update(admin_params)
+          Admin.create_or_update_from_api_params(admin_params)
         }.to change { Admin.count }.by(1)
 
         admin = Admin.last
         expect(admin.role_name).to eq(admin_params['role'])
         expect(admin.canvas_role_id).to eq(admin_params['role_id'])
-        expect(admin.user_data).to eq(admin_params['user'])
         expect(admin.canvas_user_id).to eq(admin_params['user']['id'])
         expect(admin.workflow_state).to eq(admin_params['workflow_state'])
       end
@@ -31,13 +30,12 @@ RSpec.describe Admin, type: :model do
 
       it 'updates it' do
         expect {
-          Admin.create_or_update(admin_params)
+          Admin.create_or_update_from_api_params(admin_params)
         }.to_not change { Admin.count }
 
         existing_admin.reload
         expect(existing_admin.role_name).to eq(admin_params['role'])
         expect(existing_admin.canvas_role_id).to eq(admin_params['role_id'])
-        expect(existing_admin.user_data).to eq(admin_params['user'])
         expect(existing_admin.canvas_user_id).to eq(admin_params['user']['id'])
         expect(existing_admin.workflow_state).to eq(admin_params['workflow_state'])
       end

data/spec/canvas_sync/models/roles_spec.rb

@@ -8,19 +8,19 @@ RSpec.describe Role, type: :model do
     it { should validate_uniqueness_of(:canvas_id) }
   end
 
-  describe '.create_or_update' do
+  describe '.create_or_update_from_api_params' do
     let(:role_params) { open_canvas_fixture('roles')[0] }
 
     context 'the role does not already exist' do
       it 'creates it' do
         expect {
-          Role.create_or_update(role_params)
+          Role.create_or_update_from_api_params(role_params)
         }.to change { Role.count }.by(1)
 
         role = Role.last
         expect(role.label).to eq(role_params['label'])
         expect(role.base_role_type).to eq(role_params['base_role_type'])
-        expect(role.account).to eq(role_params['account'])
+        expect(role.canvas_account_id).to eq(role_params['account']['id'])
         expect(role.permissions).to eq(role_params['permissions'])
         expect(role.workflow_state).to eq(role_params['workflow_state'])
       end
@@ -31,13 +31,13 @@ RSpec.describe Role, type: :model do
 
       it 'updates it' do
         expect {
-          Role.create_or_update(role_params)
+          Role.create_or_update_from_api_params(role_params)
         }.to_not change { Role.count }
 
         existing_role.reload
         expect(existing_role.label).to eq(role_params['label'])
         expect(existing_role.base_role_type).to eq(role_params['base_role_type'])
-        expect(existing_role.account).to eq(role_params['account'])
+        expect(existing_role.canvas_account_id).to eq(role_params['account']['id'])
         expect(existing_role.permissions).to eq(role_params['permissions'])
         expect(existing_role.workflow_state).to eq(role_params['workflow_state'])
       end