canvas_sync 0.16.4 → 0.21.0

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_content_migrations_job_spec.rb

@@ -0,0 +1,30 @@
+require "spec_helper"
+
+RSpec.describe CanvasSync::Jobs::SyncContentMigrationsJob do
+  describe "#perform" do
+    context "no parameters is specified" do
+      it "enqueues a ReportStarter for the proserv_content_migrations_csv" do
+        expect_any_instance_of(Bearcat::Client).to receive(:start_report)
+          .with("self", "proserv_content_migrations_csv", { parameters: { } })
+          .and_return("id" => 1)
+
+        expect(CanvasSync::Jobs::ReportChecker).to receive(:set).and_call_original
+
+        CanvasSync::Jobs::SyncContentMigrationsJob.perform_now({})
+      end
+    end
+
+    context "updated_after parameters is specified" do
+      it "enqueues a ReportStarter for the proserv_content_migrations_csv and get data from given date" do
+        expect_any_instance_of(Bearcat::Client).to receive(:start_report)
+          .with("self", "proserv_content_migrations_csv", { parameters: { updated_after: 6.hours.ago.to_s } })
+          .and_return("id" => 1)
+
+        expect(CanvasSync::Jobs::ReportChecker).to receive(:set).and_call_original
+
+        set_batch_context(updated_after: 6.hours.ago.to_s)
+        CanvasSync::Jobs::SyncContentMigrationsJob.perform_now({})
+      end
+    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,67 +2,36 @@ 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)
+          expect_any_instance_of(CanvasSync::Jobs::ReportStarter).to receive(:start_report)
           .with(
-            expected_job_chain_2,
+            'self',
             '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
 
     context 'a term scope is not specified' 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)
+        expect_any_instance_of(CanvasSync::Jobs::ReportStarter).to receive(:start_report)
           .with(
-            job_chain,
+            'self',
             'proservices_provisioning_csv',
             {
               parameters: {
@@ -71,12 +40,9 @@ RSpec.describe CanvasSync::Jobs::SyncProvisioningReportJob do
                 'courses' => true,
               }
             },
-            CanvasSync::Processors::ProvisioningReportProcessor.to_s,
-            { models: ['users', 'courses'] }
           )
 
         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

@@ -5,12 +5,18 @@ 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, include_all: nil } })
+          .with("self", "proserv_student_submissions_csv", { parameters: {
+              enrollment_term_id: 1,
+              include_all: nil,
+              enrollment_batch_size: nil,
+              include_all_except: nil
+          } })
           .and_return("id" => 1)
 
         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/canvas_sync/live_events/live_event_sync_spec.rb

@@ -0,0 +1,27 @@
+require "spec_helper"
+
+RSpec.describe CanvasSync::Concerns::LiveEventSync do
+  before(:all) do
+    User.include(CanvasSync::Concerns::LiveEventSync)
+  end
+
+  let(:event) {
+    {
+      "metadata" => {
+        event_name: "user_created",
+      },
+      "payload" => {
+        user_id: 124,
+      },
+    }
+  }
+
+  describe "#perform" do
+    it "determines ID from payload" do
+      expect_any_instance_of(User).to receive(:process_live_event).with(:created, event["payload"], event["metadata"]) do |user, *args|
+        expect(user.canvas_id).to eql 124
+      end
+      User.cs_internal_process_live_event(event.with_indifferent_access)
+    end
+  end
+end

data/spec/canvas_sync/live_events/live_events_controller_spec.rb

@@ -0,0 +1,54 @@
+require "spec_helper"
+require "json/jwt"
+
+RSpec.describe CanvasSync::Api::V1::LiveEventsController, type: :controller do
+  routes { CanvasSync::Engine.routes }
+
+  let(:event) {
+    {
+      "metadata" => {
+        event_name: "user_created",
+      },
+      "payload" => {
+        user_id: 42660000000000001,
+      },
+    }.with_indifferent_access
+  }
+
+  describe "#transform_ids!" do
+    it "transforms sharded IDs to local IDs" do
+      controller.send(:transform_ids!, event)
+      expect(event[:payload][:user_id]).to eql 1
+      expect(event[:payload][:sharded_user_id]).to eql 42660000000000001
+    end
+
+    xit "it does not transform cross-shard IDs" do
+      # TODO
+    end
+  end
+
+  describe "#process_dataservices_event" do
+    let(:private_key) { OpenSSL::PKey::RSA.new(2048) }
+    let(:jwk) { JSON::JWK.new(private_key) }
+    let(:jwks) { JSON::JWK::Set.new([jwk]) }
+
+    before :each do
+      allow(controller).to receive(:dataservices_jwks).and_return(jwks)
+    end
+
+    let(:event_data) { event.to_json }
+
+    it "triggers a background job" do
+      expect(controller).to receive(:dispatch_event)
+      expect(controller).to receive(:validate_tenant!)
+      post :process_event, params: { "_json" => JSON::JWT.new(event).sign(jwk).to_s }
+      expect(response).to be_successful
+    end
+
+    it "does not allow unsigned events" do
+      expect(controller).to_not receive(:validate_tenant!)
+      post :process_event, params: { "_json" => event.to_json }
+      expect(response).to_not be_successful
+    end
+  end
+end

data/spec/canvas_sync/live_events/process_event_job_spec.rb

@@ -0,0 +1,38 @@
+require "spec_helper"
+
+RSpec.describe CanvasSync::LiveEvents::ProcessEventJob do
+  before(:all) do
+    User.include(CanvasSync::Concerns::LiveEventSync)
+  end
+
+  let(:event) {
+    {
+      "metadata" => {
+        event_name: "user_created",
+      },
+      "payload" => {
+        user_id: 1,
+      },
+    }
+  }
+
+  describe "#perform" do
+    it "invokes a legacy handler if present" do
+      expect(LiveEvents::UserCreatedEvent).to receive(:perform_later)
+      described_class.perform_now(event)
+    end
+
+    it "does not invoke new handlers if legacy is present" do
+      expect(CanvasSync::LiveEvents).to_not receive(:registered_handlers)
+      described_class.perform_now(event)
+    end
+
+    it "invokes new handlers" do
+      hide_const("LiveEvents::UserCreatedEvent")
+      expect(CanvasSync::LiveEvents).to receive(:registered_handlers).and_call_original
+      expect(User).to receive(:cs_internal_process_live_event).and_call_original
+      expect_any_instance_of(User).to receive(:process_live_event).with(:created, event["payload"], event["metadata"])
+      described_class.perform_now(event)
+    end
+  end
+end

data/spec/canvas_sync/misc_helper_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+RSpec.describe CanvasSync::MiscHelper do
+  describe ".invoke_task" do
+    with_model :Model do
+      table
+      model do
+        def wait_callback(*args); end
+
+        def self.wait_callback(*args); end
+      end
+    end
+
+    class CPW_TestWorker
+      extend Sidekiq::Worker
+    end
+
+    it 'schedules a given job' do
+      expect(CPW_TestWorker).to receive(:perform_async)
+      described_class.invoke_task(
+        job: 'CPW_TestWorker',
+        args: [1, 2],
+      )
+    end
+
+    it 'accepts a method string' do
+      expect(Model).to receive(:wait_callback).with(1, 2, a: 3, b: 4)
+      described_class.invoke_task(
+        method: "#{Model.to_s}.wait_callback",
+        args: [1, 2],
+        kwargs: { a: 3, b: 4 },
+      )
+    end
+
+    it 'invokes a model method' do
+      model = Model.create!
+      expect(Model).to receive(:find_by).with(id: model.id).and_return(model)
+      expect(model).to receive(:wait_callback).with(1, 2, a: 3, b: 4)
+      described_class.invoke_task(
+        model: Model.to_s,
+        find_by: { id: model.id },
+        method: :wait_callback,
+        args: [1, 2],
+        kwargs: { a: 3, b: 4 },
+      )
+    end
+
+    it 'invokes a class method' do
+      expect(Model).to receive(:wait_callback).with(1, 2, a: 3, b: 4)
+      described_class.invoke_task(
+        class: Model.to_s,
+        method: :wait_callback,
+        args: [1, 2],
+        kwargs: { a: 3, b: 4 },
+      )
+    end
+  end
+end

data/spec/canvas_sync/models/assignment_spec.rb

@@ -35,7 +35,7 @@ RSpec.describe Assignment, type: :model do
       let!(:matching_course) { FactoryGirl.create(:course) }
 
       before do
-        subject.update_attributes(canvas_context_type: "Course", canvas_context_id: matching_course.canvas_id)
+        subject.update(canvas_context_type: "Course", canvas_context_id: matching_course.canvas_id)
       end
 
       it "should belong to courses where the canvas_context_type is Course and canvas_context_id is the canvas_course_id" do

data/spec/canvas_sync/processors/content_migrations_processor_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+RSpec.describe CanvasSync::Processors::ContentMigrationsProcessor do
+  let(:subject) { CanvasSync::Processors::ContentMigrationsProcessor }
+
+  describe "#process" do
+    it "inserts content migrations" do
+      expect {
+        subject.process("spec/support/fixtures/reports/content_migrations.csv", {}, 1)
+      }.to change { ContentMigration.count }.by(2)
+    end
+  end
+end