canvas_sync 0.26.1 → 0.27.1.beta2

data/lib/canvas_sync/processors/course_completion_report_processor.rb

@@ -1,20 +0,0 @@
-require_relative "./report_processor"
-
-module CanvasSync
-  module Processors
-    # Processes a course completion report using the bulk importer.
-    #
-    # @param report_file_path [String]
-    # @param options [Hash]
-    class CourseCompletionReportProcessor < ReportProcessor
-      def self.process(report_file_path, _options, report_id)
-        new(report_file_path, _options)
-      end
-
-      def initialize(report_file_path, options)
-        do_bulk_import(report_file_path, CourseProgress, options: options)
-      end
-    end
-  end
-end
-

data/lib/canvas_sync/processors/provisioning_report_processor.rb

@@ -1,149 +0,0 @@
-require "csv"
-require "activerecord-import"
-require "zip"
-require "zip/version"
-require_relative "./report_processor"
-
-module CanvasSync
-  module Processors
-    class ProvisioningReportProcessor < ReportProcessor
-      # Processes a provisioning report using the bulk importer.
-      #
-      # options must contain a models key. If there is only one model
-      # Canvas downloads the single report directly as a CSV. If it's
-      # more than one model Canvas downloads a ZIP file, so we have to
-      # extract that and iterate through it for processing.
-      #
-      # @param report_file_path [String]
-      # @param options [Hash]
-      def self.process(report_file_path, options, report_id)
-        new(report_file_path, options)
-      end
-
-      def initialize(report_file_path, options) # rubocop:disable Metrics/AbcSize
-        @options = options
-        if options[:models].length == 1
-          run_import(options[:models][0], report_file_path)
-        else
-          unzipped_file_dir = extract(report_file_path)
-          Dir[unzipped_file_dir + "/*.csv"].sort.each do |file_path|
-            model_name = file_path.split("/").last.split(".").first
-            run_import(model_name, file_path)
-          end
-        end
-      end
-
-      private
-
-      def extract(file_path)
-        unzipped_file_dir = "#{file_path}_unzipped"
-
-        Zip::File.open(file_path) do |zip_file|
-          zip_file.each do |f|
-            f_path = File.join(unzipped_file_dir, f.name)
-            FileUtils.mkdir_p(File.dirname(f_path))
-            next if File.exist?(f_path)
-
-            if Zip::VERSION >= "3.0.0"
-              zip_file.extract(f, destination_directory: unzipped_file_dir)
-            else
-              zip_file.extract(f, f_path)
-            end
-          end
-        end
-
-        unzipped_file_dir
-      end
-
-      def run_import(model_name, report_file_path)
-        if legacy?(model_name)
-          CanvasSync::Importers::LegacyImporter.import(
-            report_file_path,
-            model_name.singularize.capitalize.constantize,
-            @options[:account_id],
-            @options,
-          )
-        else
-          send("bulk_process_#{model_name}", report_file_path)
-        end
-      end
-
-      def legacy?(model_name)
-        opt = @options[:legacy_support]
-        return false if opt == false || opt.nil?
-        return true if opt == true
-        return opt.include?(model_name)
-      end
-
-      def bulk_process_users(report_file_path)
-        do_bulk_import(report_file_path, User, options: @options)
-      end
-
-      def bulk_process_user_observers(report_file_path)
-        do_bulk_import(report_file_path, UserObserver, options: @options)
-      end
-
-      def bulk_process_pseudonyms(report_file_path)
-        do_bulk_import(report_file_path, Pseudonym, options: @options)
-      end
-
-      def bulk_process_accounts(report_file_path)
-        do_bulk_import(report_file_path, Account, options: @options)
-      end
-
-      def bulk_process_courses(report_file_path)
-        do_bulk_import(report_file_path, Course, options: @options)
-      end
-
-      def bulk_process_enrollments(report_file_path)
-        do_bulk_import(report_file_path, Enrollment, options: @options)
-      end
-
-      def bulk_process_sections(report_file_path)
-        do_bulk_import(report_file_path, Section, options: @options)
-      end
-
-      def bulk_process_xlist(report_file_path)
-        do_bulk_import(report_file_path, Section, options: @options, mapping_key: :xlist)
-      end
-
-      def bulk_process_groups(report_file_path)
-        do_bulk_import(report_file_path, Group, options: @options)
-      end
-
-      def bulk_process_grading_periods(report_file_path)
-        do_bulk_import(report_file_path, GradingPeriod, options: @options)
-      end
-
-      def bulk_process_grading_period_groups(report_file_path)
-        do_bulk_import(report_file_path, GradingPeriodGroup, options: @options)
-      end
-
-      # Note that group membership is singular because we override the model name param in sync_provisioning_report_job
-      def bulk_process_group_membership(report_file_path)
-        do_bulk_import(report_file_path, GroupMembership, options: @options)
-      end
-
-      def bulk_process_learning_outcomes(report_file_path)
-        do_bulk_import(report_file_path, LearningOutcome, options: @options) do |row|
-          row[:root_account_ids] = JSON.parse row[:root_account_ids]
-          row
-        end
-      end
-
-      def bulk_process_learning_outcome_results(report_file_path)
-        do_bulk_import(report_file_path, LearningOutcomeResult, options: @options)
-      end
-
-      def bulk_process_course_nicknames(report_file_path)
-        exists = []
-        do_bulk_import(report_file_path, CourseNickname, options: @options) do |row|
-          exists << row[:user_preference_value_id]
-          row
-        end
-        # Canvas does not soft delete UserPreferenceValues so there's no point in doing the same
-        CourseNickname.where.not(canvas_user_preference_value_id: exists).or(CourseNickname.where(canvas_user_preference_value_id: nil)).delete_all
-      end
-    end
-  end
-end

data/lib/canvas_sync/processors/rubric_assessments_processor.rb

@@ -1,19 +0,0 @@
-require_relative "./report_processor"
-
-module CanvasSync
-  module Processors
-    # Processes a rubric assessments report using the bulk importer.
-    #
-    # @param report_file_path [String]
-    # @param options [Hash]
-    class RubricAssessmentsProcessor < ReportProcessor
-      def self.process(report_file_path, _options, report_id)
-        new(report_file_path, _options)
-      end
-
-      def initialize(report_file_path, options)
-        do_bulk_import(report_file_path, RubricAssessment, options: options)
-      end
-    end
-  end
-end

data/lib/canvas_sync/processors/rubric_associations_processor.rb

@@ -1,19 +0,0 @@
-require_relative "./report_processor"
-
-module CanvasSync
-  module Processors
-    # Processes a rubric association report using the bulk importer.
-    #
-    # @param report_file_path [String]
-    # @param options [Hash]
-    class RubricAssociationsProcessor < ReportProcessor
-      def self.process(report_file_path, _options, report_id)
-        new(report_file_path, _options)
-      end
-
-      def initialize(report_file_path, options)
-        do_bulk_import(report_file_path, RubricAssociation, options: options)
-      end
-    end
-  end
-end

data/lib/canvas_sync/processors/rubrics_processor.rb

@@ -1,19 +0,0 @@
-require_relative "./report_processor"
-
-module CanvasSync
-  module Processors
-    # Processes a rubrics report using the bulk importer.
-    #
-    # @param report_file_path [String]
-    # @param options [Hash]
-    class RubricsProcessor < ReportProcessor
-      def self.process(report_file_path, _options, report_id)
-        new(report_file_path, _options)
-      end
-
-      def initialize(report_file_path, options)
-        do_bulk_import(report_file_path, Rubric, options: options)
-      end
-    end
-  end
-end

data/lib/canvas_sync/processors/submissions_processor.rb

@@ -1,19 +0,0 @@
-require_relative "./report_processor"
-
-module CanvasSync
-  module Processors
-    # Processes a submissions report using the bulk importer.
-    #
-    # @param report_file_path [String]
-    # @param options [Hash]
-    class SubmissionsProcessor < ReportProcessor
-      def self.process(report_file_path, _options, report_id)
-        new(report_file_path, _options)
-      end
-
-      def initialize(report_file_path, options)
-        do_bulk_import(report_file_path, Submission, options: options)
-      end
-    end
-  end
-end

data/spec/canvas_sync/jobs/report_checker_spec.rb

@@ -1,57 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe CanvasSync::Jobs::ReportChecker do
-  let(:client_double) { double('client') }
-  let(:report_id) { 1 }
-  let(:report_name) { 'provisioning_csv' }
-  let(:processor) { 'FakeProcessor' }
-
-  describe '#perform' do
-    def start_job
-      CanvasSync::Jobs::ReportChecker.perform_now(
-        'provisioning_csv',
-        report_id,
-        processor,
-        {}
-      )
-    end
-
-    context 'the report has finished' do
-      it 'enqueues the report processor job' do
-        expect_any_instance_of(Bearcat::Client).to receive(:report_status)
-          .with('self', report_name, report_id)
-          .and_return({ 'status' => 'complete', 'attachment' => { 'url' => 'blah' } })
-
-        expect(CanvasSync::Jobs::ReportProcessorJob).to receive(:perform_later)
-          .with(report_name, 'blah', processor, {}, report_id)
-
-        start_job
-      end
-    end
-
-    context 'the report is still running' do
-      it 're-enqueues the report checker' do
-        expect_any_instance_of(Bearcat::Client).to receive(:report_status)
-          .with('self', report_name, report_id)
-          .and_return({ 'status' => 'running' })
-
-        expect(CanvasSync::Jobs::ReportChecker).to receive(:set).and_call_original
-
-        start_job
-      end
-    end
-
-    context 'the report has errored' do
-      it 'does not re-enqueue the job or enqueue the processor' do
-        expect_any_instance_of(Bearcat::Client).to receive(:report_status)
-          .with('self', report_name, report_id)
-          .and_return({ 'status' => 'error' })
-
-        expect(CanvasSync::Jobs::ReportChecker).to_not receive(:set)
-        expect(CanvasSync::Jobs::ReportProcessorJob).to_not receive(:perform_later)
-
-        expect { start_job }.to raise_error
-      end
-    end
-  end
-end

data/spec/canvas_sync/jobs/report_processor_job_spec.rb

@@ -1,25 +0,0 @@
-require 'spec_helper'
-
-class FakeProcessor; end;
-
-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(: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_any_instance_of(Bearcat::Client).to receive(:download_report)
-      expect(FakeProcessor).to receive(:process)
-
-      CanvasSync::Jobs::ReportProcessorJob.perform_now(
-        report_name,
-        report_url,
-        processor,
-        {},
-        report_id,
-      )
-    end
-  end
-end

data/spec/canvas_sync/jobs/sync_assignment_groups_job_spec.rb

@@ -1,18 +0,0 @@
-require "spec_helper"
-
-RSpec.describe CanvasSync::Jobs::SyncAssignmentGroupsJob do
-  describe "#perform" 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 } })
-          .and_return("id" => 1)
-
-        expect(CanvasSync::Jobs::ReportChecker).to receive(:set).and_call_original
-
-        set_batch_context(canvas_term_id: 1)
-        CanvasSync::Jobs::SyncAssignmentGroupsJob.perform_now({})
-      end
-    end
-  end
-end

data/spec/canvas_sync/jobs/sync_assignments_job_spec.rb

@@ -1,30 +0,0 @@
-require "spec_helper"
-
-RSpec.describe CanvasSync::Jobs::SyncAssignmentsJob do
-  describe "#perform" 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 } })
-          .and_return("id" => 1)
-
-        expect(CanvasSync::Jobs::ReportChecker).to receive(:set).and_call_original
-
-        set_batch_context(canvas_term_id: 1)
-        CanvasSync::Jobs::SyncAssignmentsJob.perform_now({})
-      end
-    end
-
-    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", { parameters: {} })
-          .and_return("id" => 1)
-
-        expect(CanvasSync::Jobs::ReportChecker).to receive(:set).and_call_original
-
-        CanvasSync::Jobs::SyncAssignmentsJob.perform_now({})
-      end
-    end
-  end
-end

data/spec/canvas_sync/jobs/sync_content_migrations_job_spec.rb

@@ -1,30 +0,0 @@
-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

@@ -1,30 +0,0 @@
-require "spec_helper"
-
-RSpec.describe CanvasSync::Jobs::SyncContextModuleItemsJob do
-  describe "#perform" 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 } })
-          .and_return("id" => 1)
-
-        expect(CanvasSync::Jobs::ReportChecker).to receive(:set).and_call_original
-
-        set_batch_context(canvas_term_id: 1)
-        CanvasSync::Jobs::SyncContextModuleItemsJob.perform_now({})
-      end
-    end
-
-    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", { parameters: { } })
-          .and_return("id" => 1)
-
-        expect(CanvasSync::Jobs::ReportChecker).to receive(:set).and_call_original
-
-        CanvasSync::Jobs::SyncContextModuleItemsJob.perform_now({})
-      end
-    end
-  end
-end

data/spec/canvas_sync/jobs/sync_context_modules_job_spec.rb

@@ -1,30 +0,0 @@
-require "spec_helper"
-
-RSpec.describe CanvasSync::Jobs::SyncContextModulesJob do
-  describe "#perform" 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 } })
-          .and_return("id" => 1)
-
-        expect(CanvasSync::Jobs::ReportChecker).to receive(:set).and_call_original
-
-        set_batch_context(canvas_term_id: 1)
-        CanvasSync::Jobs::SyncContextModulesJob.perform_now({})
-      end
-    end
-
-    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", { parameters: { } })
-          .and_return("id" => 1)
-
-        expect(CanvasSync::Jobs::ReportChecker).to receive(:set).and_call_original
-
-        CanvasSync::Jobs::SyncContextModulesJob.perform_now({})
-      end
-    end
-  end
-end

data/spec/canvas_sync/jobs/sync_scores_job_spec.rb

@@ -1,15 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe CanvasSync::Jobs::SyncScoresJob do
-  describe '#perform' 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_scores_data_csv", { parameters: {} })
-        .and_return("id" => 1)
-
-      expect(CanvasSync::Jobs::ReportChecker).to receive(:set).and_call_original
-
-      CanvasSync::Jobs::SyncScoresJob.perform_now({})
-    end
-  end
-end

data/spec/canvas_sync/jobs/sync_submissions_job_spec.rb

@@ -1,23 +0,0 @@
-require "spec_helper"
-
-RSpec.describe CanvasSync::Jobs::SyncSubmissionsJob do
-  describe "#perform" 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,
-              enrollment_batch_size: nil,
-              include_all_except: nil
-          } })
-          .and_return("id" => 1)
-
-        expect(CanvasSync::Jobs::ReportChecker).to receive(:set).and_call_original
-
-        set_batch_context(canvas_term_id: 1)
-        CanvasSync::Jobs::SyncSubmissionsJob.perform_now({})
-      end
-    end
-  end
-end