canvas_sync 0.1.1

data/lib/canvas_sync/version.rb

@@ -0,0 +1,3 @@
+module CanvasSync
+  VERSION = "0.1.1"
+end

data/spec/canvas_sync/canvas_sync_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+RSpec.describe CanvasSync do
+  describe '.provisioning_sync' do
+    let(:canvas_base_url) { 'https://test.instructure.com' }
+    let(:canvas_api_token) { 'cool-api-token' }
+
+    it 'invokes the first job in the queue and passes on the rest of the job chain' do
+      expected_job_chain = CanvasSync.default_provisioning_report_chain(['courses'], nil)
+      first_job = expected_job_chain[:jobs].shift
+
+      expect(CanvasSync::Jobs::SyncTermsJob).to receive(:perform_later)
+        .with(
+          canvas_base_url,
+          canvas_api_token,
+          expected_job_chain,
+          first_job[:options]
+        )
+
+      CanvasSync.provisioning_sync(canvas_base_url, canvas_api_token, ['courses'])
+    end
+
+    context 'an invalid model is passed in' do
+      it 'raises a helpful exception' do
+        expect {
+          CanvasSync.provisioning_sync(canvas_base_url, canvas_api_token, ['courses', 'cheeses'])
+        }.to raise_error("Invalid model(s) specified: cheeses. Only #{CanvasSync::SUPPORTED_MODELS.join(', ')} are supported.")
+      end
+    end
+
+    describe '.default_provisioning_report_chain' do
+      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)
+          expect(chain).to eq({
+            jobs: [
+              { job: CanvasSync::Jobs::SyncTermsJob.to_s, options: {} },
+              { job: CanvasSync::Jobs::SyncUsersJob.to_s, options: {} },
+              { job: CanvasSync::Jobs::SyncProvisioningReportJob.to_s, options: { term_scope: 'active', models: ['courses'] } }
+            ],
+            options: {}
+          })
+        end
+      end
+
+      context 'we are syncing users without a term scope' do
+        it 'syncs users along with the rest of the provisioning report' do
+          chain = CanvasSync.default_provisioning_report_chain(['users', 'courses'])
+          expect(chain).to eq({
+            jobs: [
+              { job: CanvasSync::Jobs::SyncTermsJob.to_s, options: {} },
+              { job: CanvasSync::Jobs::SyncProvisioningReportJob.to_s, options: { term_scope: nil, models: ['users', 'courses'] } }
+            ],
+            options: {}
+          })
+        end
+      end
+    end
+  end
+end

data/spec/canvas_sync/jobs/report_checker_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+RSpec.describe CanvasSync::Jobs::ReportChecker do
+  let(:canvas_base_url) { 'https://test.instructure.com' }
+  let(:canvas_api_token) { 'cool-api-token' }
+  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(
+        canvas_base_url,
+        canvas_api_token,
+        [],
+        '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(canvas_base_url, canvas_api_token, [], report_name, 'blah', processor, {})
+
+        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

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+class FakeProcessor; end;
+
+RSpec.describe CanvasSync::Jobs::ReportProcessorJob do
+  let(:canvas_base_url) { 'https://test.instructure.com' }
+  let(:canvas_api_token) { 'cool-api-token' }
+  let(:report_name) { 'provisioning_csv' }
+  let(:report_url) { 'https://test.instructure.com/sample_report_download' }
+  let(:processor) { FakeProcessor.to_s }
+  let(:job_chain) { ['another-job'] }
+
+  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(canvas_base_url, canvas_api_token, job_chain)
+
+      CanvasSync::Jobs::ReportProcessorJob.perform_now(
+        canvas_base_url,
+        canvas_api_token,
+        job_chain,
+        report_name,
+        report_url,
+        processor,
+        {}
+      )
+    end
+  end
+end

data/spec/canvas_sync/jobs/report_starter_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+RSpec.describe CanvasSync::Jobs::ReportStarter do
+  let(:canvas_base_url) { 'https://test.instructure.com' }
+  let(:canvas_api_token) { 'cool-api-token' }
+  let(:report_params) { { 'parameters[users]' => true } }
+  let(:report_name) { 'provisioning_csv' }
+  let(:processor) { 'CoolProcessor' }
+
+  describe '#perform' do
+    it 'tells Canvas to start the report and then enqueues a ReportChecker with the report id' do
+      expect_any_instance_of(Bearcat::Client).to receive(:start_report)
+        .with('self', report_name, report_params)
+        .and_return({ 'id' => 1 })
+
+      expect(CanvasSync::Jobs::ReportChecker).to receive(:set).and_call_original
+
+      CanvasSync::Jobs::ReportStarter.perform_now(canvas_base_url,
+                                canvas_api_token,
+                                [],
+                                report_name,
+                                report_params,
+                                processor,
+                                { models: ['users'] })
+    end
+  end
+end

data/spec/canvas_sync/jobs/sync_provisioning_report_job_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+RSpec.describe CanvasSync::Jobs::SyncProvisioningReportJob do
+  let(:canvas_base_url) { 'https://test.instructure.com' }
+  let(:canvas_api_token) { 'cool-api-token' }
+
+  describe '#perform' do
+    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') }
+
+      it 'enqueues a ReportStarter for a provisioning report for the specified models for each term' do
+        expect(CanvasSync::Jobs::ReportStarter).to receive(:perform_later)
+          .with(
+            canvas_base_url,
+            canvas_api_token,
+            [],
+            'proservices_provisioning_csv',
+            {
+              "parameters[include_deleted]" => true,
+              "parameters[users]" => true,
+              "parameters[courses]" => true,
+              "parameters[enrollment_term_id]" => active_term_1.canvas_term_id
+            },
+            CanvasSync::Processors::ProvisioningReportProcessor.to_s,
+            { models: ['users', 'courses'], term_scope: 'active', canvas_term_id: active_term_1.canvas_term_id }
+          )
+
+        expect(CanvasSync::Jobs::ReportStarter).to receive(:perform_later)
+          .with(
+            canvas_base_url,
+            canvas_api_token,
+            [],
+            'proservices_provisioning_csv',
+            {
+              "parameters[include_deleted]" => true,
+              "parameters[users]" => true,
+              "parameters[courses]" => true,
+              "parameters[enrollment_term_id]" => active_term_2.canvas_term_id
+            },
+            CanvasSync::Processors::ProvisioningReportProcessor.to_s,
+            { models: ['users', 'courses'], term_scope: 'active', canvas_term_id: active_term_2.canvas_term_id }
+          )
+
+        CanvasSync::Jobs::SyncProvisioningReportJob.perform_now(
+          canvas_base_url,
+          canvas_api_token,
+          [],
+          { models: ['users', 'courses'], term_scope: 'active' }
+        )
+      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)
+          .with(
+            canvas_base_url,
+            canvas_api_token,
+            [],
+            'proservices_provisioning_csv',
+            {
+              "parameters[include_deleted]" => true,
+              "parameters[users]" => true,
+              "parameters[courses]" => true
+            },
+            CanvasSync::Processors::ProvisioningReportProcessor.to_s,
+            { models: ['users', 'courses'] }
+          )
+
+        CanvasSync::Jobs::SyncProvisioningReportJob.perform_now(
+          canvas_base_url,
+          canvas_api_token,
+          [],
+          { models: ['users', 'courses'] }
+        )
+      end
+    end
+  end
+end

data/spec/canvas_sync/jobs/sync_terms_job_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+RSpec.describe CanvasSync::Jobs::SyncTermsJob do
+  let(:canvas_base_url) { 'https://test.instructure.com' }
+  let(:canvas_api_token) { 'cool-api-token' }
+
+  describe '#perform' do
+    let(:term_params) { open_canvas_fixture('terms')['enrollment_terms'] }
+
+    it 'retrieves all terms from the Canvas API and then invokes the next job' do
+      expect(CanvasSync).to receive(:invoke_next).with(canvas_base_url, canvas_api_token, [])
+
+      expect {
+        CanvasSync::Jobs::SyncTermsJob.perform_now(canvas_base_url, canvas_api_token, [], {})
+      }.to change { Term.count }.by(term_params.length)
+    end
+  end
+end

data/spec/canvas_sync/jobs/sync_users_job_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+RSpec.describe CanvasSync::Jobs::SyncUsersJob do
+  let(:canvas_base_url) { 'https://test.instructure.com' }
+  let(:canvas_api_token) { 'cool-api-token' }
+
+  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)
+        .and_return({ 'id' => 1 })
+
+      expect(CanvasSync::Jobs::ReportChecker).to receive(:set).and_call_original
+
+      CanvasSync::Jobs::SyncUsersJob.perform_now(canvas_base_url, canvas_api_token, [], {})
+    end
+  end
+end

data/spec/canvas_sync/models/course_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+RSpec.describe Course, type: :model do
+  let(:subject) { FactoryGirl.create(:course) }
+
+  describe 'validations' do
+    it { should validate_presence_of(:canvas_course_id) }
+    it { should validate_uniqueness_of(:canvas_course_id) }
+  end
+
+  describe 'associations' do
+    it do
+      should belong_to(:term)
+        .with_primary_key(:canvas_term_id)
+        .with_foreign_key(:canvas_term_id)
+    end
+
+    it do
+      should have_many(:enrollments)
+        .with_primary_key(:canvas_course_id)
+        .with_foreign_key(:canvas_course_id)
+    end
+
+    it do
+      should have_many(:sections)
+        .with_primary_key(:canvas_course_id)
+        .with_foreign_key(:canvas_course_id)
+    end
+  end
+end

data/spec/canvas_sync/models/enrollment_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+RSpec.describe Enrollment, type: :model do
+  let(:subject) { FactoryGirl.create(:enrollment) }
+
+  describe 'validations' do
+    it { should validate_presence_of(:canvas_enrollment_id) }
+    it { should validate_uniqueness_of(:canvas_enrollment_id) }
+  end
+
+  describe 'associations' do
+    it do
+      should belong_to(:user)
+        .with_primary_key(:canvas_user_id)
+        .with_foreign_key(:canvas_user_id)
+    end
+
+    it do
+      should belong_to(:course)
+        .with_primary_key(:canvas_course_id)
+        .with_foreign_key(:canvas_course_id)
+    end
+
+    it do
+      should belong_to(:section)
+        .with_primary_key(:canvas_section_id)
+        .with_foreign_key(:canvas_section_id)
+    end
+  end
+end

data/spec/canvas_sync/models/section_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+RSpec.describe Section, type: :model do
+  let(:subject) { FactoryGirl.create(:section) }
+
+  describe 'validations' do
+    it { should validate_presence_of(:canvas_section_id) }
+    it { should validate_uniqueness_of(:canvas_section_id) }
+  end
+
+  describe 'associations' do
+    it do
+      should belong_to(:course)
+        .with_primary_key(:canvas_course_id)
+        .with_foreign_key(:canvas_course_id)
+    end
+
+    it do
+      should have_many(:enrollments)
+        .with_primary_key(:canvas_section_id)
+        .with_foreign_key(:canvas_section_id)
+    end
+  end
+end

data/spec/canvas_sync/models/term_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+RSpec.describe Term, type: :model do
+  let(:subject) { FactoryGirl.create(:term) }
+
+  describe 'validations' do
+    it { should validate_presence_of(:canvas_term_id) }
+    it { should validate_uniqueness_of(:canvas_term_id) }
+  end
+
+  describe 'associations' do
+    it do
+      should have_many(:courses)
+        .with_primary_key(:canvas_term_id)
+        .with_foreign_key(:canvas_term_id)
+    end
+  end
+
+  describe 'scopes' do
+    describe '.active' do
+      let!(:active_term) { FactoryGirl.create(:term, workflow_state: 'active', start_at: 2.days.ago, end_at: 3.days.from_now) }
+      let!(:inactive_term) { FactoryGirl.create(:term, workflow_state: 'inactive') }
+      let!(:completed_term) { FactoryGirl.create(:term, start_at: 2.months.ago, end_at: 1.month.ago) }
+      let!(:unstarted_term) { FactoryGirl.create(:term, start_at: 6.months.from_now, end_at: 1.year.from_now) }
+
+      it 'returns terms with an active workflow_state that have a start_date 15 days in the future or earlier and an end_date 15 days in the past or later' do
+        expect(Term.active).to match_array([active_term])
+      end
+    end
+  end
+
+  describe '.create_or_update' do
+    let(:term_params) { open_canvas_fixture('terms')['enrollment_terms'][0] }
+
+    context 'the term does not already exist' do
+      it 'creates it' do
+        expect {
+          Term.create_or_update(term_params)
+        }.to change { Term.count }.by(1)
+
+        term = Term.last
+        expect(term.name).to eq(term_params['name'])
+        expect(term.start_at).to eq(term_params['start_at'])
+        expect(term.end_at).to eq(term_params['end_at'])
+        expect(term.canvas_term_id).to eq(term_params['id'])
+        expect(term.grading_period_group_id).to eq(term_params['grading_period_group_id'])
+        expect(term.sis_id).to eq(term_params['sis_term_id'])
+        expect(term.workflow_state).to eq(term_params['workflow_state'])
+      end
+    end
+
+    context 'the term already exists' do
+      let!(:existing_term) { FactoryGirl.create(:term, canvas_term_id: term_params['id']) }
+
+      it 'updates it' do
+        expect {
+          Term.create_or_update(term_params)
+        }.to_not change { Term.count }
+
+        existing_term.reload
+        expect(existing_term.name).to eq(term_params['name'])
+        expect(existing_term.start_at).to eq(term_params['start_at'])
+        expect(existing_term.end_at).to eq(term_params['end_at'])
+        expect(existing_term.canvas_term_id).to eq(term_params['id'])
+        expect(existing_term.grading_period_group_id).to eq(term_params['grading_period_group_id'])
+        expect(existing_term.sis_id).to eq(term_params['sis_term_id'])
+        expect(existing_term.workflow_state).to eq(term_params['workflow_state'])
+      end
+    end
+  end
+end