require 'spec_helper'

RSpec.describe CanvasSync do
  describe '.provisioning_sync' do
    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'], term_scope: nil).normalize![:parameters][0]

      expect(CanvasSync::Jobs::BeginSyncChainJob).to receive(:perform_later)
        .with(
          expected_job_chain,
          anything
        )

      CanvasSync.provisioning_sync(['courses'])
    end

    context 'an invalid model is passed in' do
      it 'raises a helpful exception' do
        expect {
          CanvasSync.provisioning_sync(['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
      it 'splits an options: Hash into options for separate models' do
        chain = CanvasSync.default_provisioning_report_chain(['users', 'courses'], term_scope: :active, options: {
          terms: { a: 1 },
          users: { b: 2 },
          provisioning: { c: 3 },
          global: { d: 4 },
        })
        expect(chain.normalize!).to eq({
          :job => "CanvasSync::Jobs::BeginSyncChainJob",
          :parameters => [[
            {:job=>"CanvasSync::JobBatches::ConcurrentBatchJob", :parameters=>[[
              {:job=>"CanvasSync::Jobs::SyncProvisioningReportJob", :options=>{:models=>["users"], :b=>2}},
              {:job=>"CanvasSync::Jobs::SyncTermsJob", :parameters=>[{
                :sub_jobs=>[
                  {:job=>"CanvasSync::Jobs::SyncProvisioningReportJob", :options=>{:models=>["courses"], :term_scope=>"active", :c=>3}}
                ]
              }]}
            ]]}
          ], {:legacy_support=>false, :updated_after=>nil, :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'], term_scope: :active)
          expect(chain.normalize!).to eq({
            :job => "CanvasSync::Jobs::BeginSyncChainJob",
            :parameters => [[
              {:job=>"CanvasSync::JobBatches::ConcurrentBatchJob", :parameters=>[[
                {:job=>"CanvasSync::Jobs::SyncProvisioningReportJob", :options=>{:models=>["users"]}},
                {:job=>"CanvasSync::Jobs::SyncTermsJob", :parameters=>[{
                  :sub_jobs=>[
                    {:job=>"CanvasSync::Jobs::SyncProvisioningReportJob", :options=>{:models=>["courses"], :term_scope=>"active"}}
                  ]
                }]}
              ]]}
            ], {:legacy_support=>false, :updated_after=>nil}]
          })
        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.normalize!).to eq({
            :job => "CanvasSync::Jobs::BeginSyncChainJob",
            :parameters => [[
              {:job=>"CanvasSync::JobBatches::ConcurrentBatchJob", :parameters=>[[
                {:job=>"CanvasSync::Jobs::SyncTermsJob", :parameters=>[{
                  :sub_jobs=>[
                    {:job=>"CanvasSync::Jobs::SyncProvisioningReportJob", :options=>{:models=>["users", "courses"], :term_scope=>nil}}
                  ]
                }]}
              ]]}
            ], {:legacy_support=>false, :updated_after=>nil}],
          })
        end
      end

      context 'we are syncing roles with a term scope' do
        it 'syncs the roles in a separate job that runs first' do
          chain = CanvasSync.default_provisioning_report_chain(['roles', 'courses'], term_scope: :active)
          expect(chain.normalize!).to eq({
            :job => "CanvasSync::Jobs::BeginSyncChainJob",
            :parameters => [[
              {:job=>"CanvasSync::JobBatches::ConcurrentBatchJob", :parameters=>[[
                {:job=>"CanvasSync::Jobs::SyncRolesJob", :options=>{}},
                {:job=>"CanvasSync::Jobs::SyncTermsJob", :parameters=>[{
                  :sub_jobs=>[
                    {:job=>"CanvasSync::Jobs::SyncProvisioningReportJob", :options=>{:models=>["courses"], :term_scope=>"active"}}
                  ]
                }]}
              ]]}
            ], {:legacy_support=>false, :updated_after=>nil}],
          })
        end
      end

      context 'we are syncing roles without a term scope' do
        it 'syncs roles separately even with no term scope' do
          chain = CanvasSync.default_provisioning_report_chain(['roles', 'courses'])
          expect(chain.normalize!).to eq({
            :job => "CanvasSync::Jobs::BeginSyncChainJob",
            :parameters => [[
              {:job=>"CanvasSync::JobBatches::ConcurrentBatchJob", :parameters=>[[
                {:job=>"CanvasSync::Jobs::SyncRolesJob", :options=>{}},
                {:job=>"CanvasSync::Jobs::SyncTermsJob", :parameters=>[{
                  :sub_jobs=>[
                    {:job=>"CanvasSync::Jobs::SyncProvisioningReportJob", :options=>{:models=>["courses"], :term_scope=>nil}}
                  ]
                }]}
              ]]}
            ], {:legacy_support=>false, :updated_after=>nil}],
          })
        end
      end

      context 'we are syncing admins with a term scope' do
        it 'syncs the admins in a separate job that runs first' do
          chain = CanvasSync.default_provisioning_report_chain(['admins', 'courses'], term_scope: :active)
          expect(chain.normalize!).to eq({
            :job => "CanvasSync::Jobs::BeginSyncChainJob",
            :parameters => [[
              {:job=>"CanvasSync::JobBatches::ConcurrentBatchJob", :parameters=>[[
                {:job=>"CanvasSync::Jobs::SyncAdminsJob", :options=>{}},
                {:job=>"CanvasSync::Jobs::SyncTermsJob", :parameters=>[{
                  :sub_jobs=>[
                    {:job=>"CanvasSync::Jobs::SyncProvisioningReportJob", :options=>{:models=>["courses"], :term_scope=>"active"}}
                  ]
                }]}
              ]]}
            ], {:legacy_support=>false, :updated_after=>nil}],
          })
        end
      end

      context 'we are syncing admins without a term scope' do
        it 'syncs admins separately even with no term scope' do
          chain = CanvasSync.default_provisioning_report_chain(['admins', 'courses'])
          expect(chain.normalize!).to eq({
            :job => "CanvasSync::Jobs::BeginSyncChainJob",
            :parameters => [[
              {:job=>"CanvasSync::JobBatches::ConcurrentBatchJob", :parameters=>[[
                {:job=>"CanvasSync::Jobs::SyncAdminsJob", :options=>{}},
                {:job=>"CanvasSync::Jobs::SyncTermsJob", :parameters=>[{
                  :sub_jobs=>[
                    {:job=>"CanvasSync::Jobs::SyncProvisioningReportJob", :options=>{:models=>["courses"], :term_scope=>nil}}
                  ]
                }]}
              ]]}
            ], {:legacy_support=>false, :updated_after=>nil}],
          })
        end
      end

      context "we are syncing assignments" do
        it "appends the SyncAssignmentsJob" do
          chain = CanvasSync.default_provisioning_report_chain(%w[users enrollments assignments])

          expect(chain.normalize!).to eq(
            :job => "CanvasSync::Jobs::BeginSyncChainJob",
            :parameters => [[
              {:job=>"CanvasSync::JobBatches::ConcurrentBatchJob", :parameters=>[[
                {:job=>"CanvasSync::Jobs::SyncTermsJob", :parameters=>[{
                  :sub_jobs=>[
                    {:job=>"CanvasSync::Jobs::SyncAssignmentsJob", :options=>{}},
                    {:job=>"CanvasSync::Jobs::SyncProvisioningReportJob", :options=>{:models=>["users", "enrollments"], :term_scope=>nil}}
                  ]
                }]}
              ]]}
            ], {:legacy_support=>false, :updated_after=>nil}],
          )
        end
      end

      context "we are syncing submissions" do
        it "appends the SyncSubmissionsJob" do
          chain = CanvasSync.default_provisioning_report_chain(%w[users enrollments submissions])

          expect(chain.normalize!).to eq(
            :job => "CanvasSync::Jobs::BeginSyncChainJob",
            :parameters => [[
              {:job=>"CanvasSync::JobBatches::ConcurrentBatchJob", :parameters=>[[
                {:job=>"CanvasSync::Jobs::SyncTermsJob", :parameters=>[{
                  :sub_jobs=>[
                    {:job=>"CanvasSync::Jobs::SyncSubmissionsJob", :options=>{}},
                    {:job=>"CanvasSync::Jobs::SyncProvisioningReportJob", :options=>{:models=>["users", "enrollments"], :term_scope=>nil}}
                  ]
                }]}
              ]]}
            ], {:legacy_support=>false, :updated_after=>nil}],
          )
        end
      end

      context "we are syncing assignment groups" do
        it "appends the SyncAssignmentGroupsJob" do
          chain = CanvasSync.default_provisioning_report_chain(%w[users enrollments assignment_groups])

          expect(chain.normalize!).to eq(
            :job => "CanvasSync::Jobs::BeginSyncChainJob",
            :parameters => [[
              {:job=>"CanvasSync::JobBatches::ConcurrentBatchJob", :parameters=>[[
                {:job=>"CanvasSync::Jobs::SyncTermsJob", :parameters=>[{
                  :sub_jobs=>[
                    {:job=>"CanvasSync::Jobs::SyncAssignmentGroupsJob", :options=>{}},
                    {:job=>"CanvasSync::Jobs::SyncProvisioningReportJob", :options=>{:models=>["users", "enrollments"], :term_scope=>nil}}
                  ]
                }]}
              ]]}
            ], {:legacy_support=>false, :updated_after=>nil}],
          )
        end
      end
    end
  end

  describe ".sync_scope" do

  end
end