panda_pal 5.19.0.beta1 → 5.19.0.beta2

data/spec/models/panda_pal/api_call_spec.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-
-module PandaPal
-  RSpec.describe ApiCall, type: :model do
-    let!(:subject) { ApiCall.create!(logic: '"#{p[:foo]}_bar"') }
-    let!(:jwt) { subject.jwt_token }
-
-    describe ".from_jwt" do
-      it "finds an ApiCall from a JWT" do
-        expect(ApiCall.from_jwt(jwt)).to eq subject
-      end
-
-      it "fails if the JWT is invalid" do
-        expect{ ApiCall.from_jwt("really.bad.jwt") }.to raise_error(JWT::DecodeError)
-      end
-    end
-
-    describe "#call" do
-      it "calls the function with parameters" do
-        expect(subject.call({ foo: 'FOO' })).to eq 'FOO_bar'
-      end
-    end
-
-    describe "#call_url" do
-      it "generates a URL with the expected placholders" do
-        expect(subject.call_url).to eq "/panda_pal/call_logic?foo=TODO&token=#{jwt}"
-      end
-    end
-  end
-end

data/spec/models/panda_pal/lti_registration_spec.rb

@@ -1,72 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe PandaPal::LtiRegistration, :isolated_lti_config do
-  let(:organization) { create(:panda_pal_organization) }
-
-  before { PandaPal.define_tool(:translate) }
-
-  def register(**attrs)
-    organization.lti_registrations.create!(tool: 'translate', client_id: '10000000000001', **attrs)
-  end
-
-  describe '.for_launch' do
-    it 'prefers a deployment-specific registration' do
-      key_wide = register
-      dedicated = register(deployment_id: 'dep-1')
-
-      expect(described_class.for_launch('10000000000001', 'dep-1')).to eq(dedicated)
-      expect(described_class.for_launch('10000000000001', 'dep-2')).to eq(key_wide)
-    end
-
-    it 'matches a key-wide registration when the launch has no deployment_id' do
-      key_wide = register
-
-      expect(described_class.for_launch('10000000000001', nil)).to eq(key_wide)
-    end
-
-    it 'matches numeric client_ids' do
-      key_wide = register
-
-      expect(described_class.for_launch(10000000000001, nil)).to eq(key_wide)
-    end
-
-    it 'returns nil for unknown or blank client_ids' do
-      register
-
-      expect(described_class.for_launch('99', nil)).to be_nil
-      expect(described_class.for_launch(nil, 'dep-1')).to be_nil
-    end
-  end
-
-  describe 'validations' do
-    it 'rejects a tool that was never defined' do
-      registration = organization.lti_registrations.build(tool: 'nope', client_id: '1')
-
-      expect(registration).not_to be_valid
-      expect(registration.errors[:tool]).to be_present
-    end
-
-    it 'allows only one key-wide registration per client_id' do
-      register
-
-      expect { register }.to raise_error(ActiveRecord::RecordInvalid)
-    end
-
-    it 'allows only one registration per client_id and deployment' do
-      register(deployment_id: 'dep-1')
-
-      expect { register(deployment_id: 'dep-1') }.to raise_error(ActiveRecord::RecordInvalid)
-      expect { register(deployment_id: 'dep-2') }.not_to raise_error
-    end
-
-    it 'stores a blank deployment_id as nil' do
-      expect(register(deployment_id: '').deployment_id).to be_nil
-    end
-  end
-
-  it 'is destroyed with its organization' do
-    register
-
-    expect { organization.destroy }.to change(described_class, :count).by(-1)
-  end
-end

data/spec/models/panda_pal/organization/settings_validation_spec.rb

@@ -1,179 +0,0 @@
-require 'spec_helper'
-
-module PandaPal
-  PandaPal::Organization
-  RSpec.describe OrganizationConcerns::SettingsValidation, type: :model do
-    let!(:org) { create :panda_pal_organization }
-
-    after :all do
-      PandaPal.lti_options[:settings_structure] = nil
-    end
-
-    def set_test_settings_structure
-      PandaPal.lti_options = {
-        title: 'Test App',
-        settings_structure: structure,
-      }
-    end
-
-    RSpec.shared_examples "shared stuff" do
-      it 'does not perform any validations if settings is not defined' do
-        PandaPal.lti_options = {}
-        expect(org.valid?).to be_truthy
-      end
-
-      it 'does not perform any validations if options is not defined' do
-        PandaPal.lti_options = nil
-        expect(org.valid?).to be_truthy
-      end
-
-      it 'does perform validations if settings_structure is defined' do
-        set_test_settings_structure
-        org.valid?
-        expect(org.valid?).to be_falsey
-      end
-
-      it 'will fail if a required setting is not present' do
-        set_test_settings_structure
-        expect(org.valid?).to be_falsey
-        errors = org.errors.messages[:settings]
-        expect(errors[0]).to eq("Entry [:canvas] is required")
-      end
-
-      it 'will fail if a setting is supplied but data_type is wrong' do
-        set_test_settings_structure
-        org.settings = {canvas: "Dog", reports: {}}
-        expect(org.valid?).to be_falsey
-        errors = org.errors.messages[:settings]
-        expect(errors[0]).to eq("Expected [:canvas] to be a Hash. Was a String")
-      end
-
-      it 'will fail if a required subsetting is missing' do
-        set_test_settings_structure
-        org.settings = {canvas: {base_url: 'http://'}, reports: {}}
-        expect(org.valid?).to be_falsey
-        errors = org.errors.messages[:settings]
-        expect(errors[0]).to eq("Entry [:canvas][:api_token] is required")
-      end
-
-      it 'will fail if extra options are specified' do
-        set_test_settings_structure
-        org.settings = {canvas: {base_url: 'http://', api_token: 'TEST'}, reports: {}, unknown_option: "WHAT IS THIS?"}
-        expect(org.valid?).to be_falsey
-        errors = org.errors.messages[:settings]
-        expect(errors[0]).to eq("Did not expect [:] to contain [unknown_option]")
-      end
-
-      it 'will pass if all structure is maintained' do
-        set_test_settings_structure
-        org.settings = {canvas: {base_url: 'http://', api_token: 'TEST'}, reports: {submissions_report_time_length: 30.minutes, max_recheck_time: 10.hours}}
-        expect(org.valid?).to be_truthy
-      end
-    end
-
-    context 'new settings_structure' do
-      let!(:properties) do
-        {
-          canvas: {
-            required: true,
-            type: 'Hash',
-            properties: {
-              api_token: { type: 'String', required: true },
-              base_url: { type: 'String', required: true },
-            },
-          },
-          reports: {
-            required: true,
-            type: 'Hash',
-            allow_additional: true,
-          }
-        }
-      end
-
-      let!(:structure) do
-        {
-          properties: properties,
-        }
-      end
-
-      it_behaves_like("shared stuff")
-
-      describe ':allow_additional' do
-        it 'passes extra properties if allow_additional is a matching Hash' do
-          structure[:allow_additional] = { type: 'String' }
-          set_test_settings_structure
-          org.settings = {canvas: {base_url: 'http://', api_token: 'TEST'}, reports: {}, unknown_option: "WHAT IS THIS?"}
-          expect(org).to be_valid
-        end
-
-        it 'fails extra properties if allow_additional is an unmatching Hash' do
-          structure[:allow_additional] = { type: 'Hash' }
-          set_test_settings_structure
-          org.settings = {canvas: {base_url: 'http://', api_token: 'TEST'}, reports: {}, unknown_option: "WHAT IS THIS?"}
-          expect(org).not_to be_valid
-        end
-
-        it 'passes extra properties if allow_additional is a blank Hash' do
-          structure[:allow_additional] = { }
-          set_test_settings_structure
-          org.settings = {canvas: {base_url: 'http://', api_token: 'TEST'}, reports: {}, unknown_option: "WHAT IS THIS?"}
-          expect(org).to be_valid
-        end
-      end
-
-      describe ':validate' do
-        let!(:properties) do
-          {
-            blah: {
-              type: 'String',
-              validate: -> (v, *args) { v == 'blah' ? nil : '<path> failed validation' },
-            }
-          }
-        end
-
-        it 'supports a custom validation proc' do
-          set_test_settings_structure
-          org.settings = { blah: 'blah' }
-          expect(org).to be_valid
-        end
-
-        it 'replaces <path> with the human readable path' do
-          set_test_settings_structure
-          org.settings = { blah: '' }
-          expect(org.valid?).to be_falsey
-          errors = org.errors.messages[:settings]
-          expect(errors[0]).to eq("[:blah] failed validation")
-        end
-      end
-    end
-
-    context 'old settings_structure' do
-      let!(:structure) do
-        YAML.load("
-          canvas:
-            is_required: true
-            data_type: Hash
-            api_token:
-              is_required: true
-              data_type: String
-            base_url:
-              is_required: true
-              data_type: String
-          reports:
-            is_required: true
-            data_type: Hash
-            active_term_allowance:
-            submissions_report_time_length:
-              is_required: false
-              data_type: ActiveSupport::Duration
-            recheck_wait:
-              data_type: ActiveSupport::Duration
-            max_recheck_time:
-              is_required: false
-        ").deep_symbolize_keys
-      end
-
-      it_behaves_like("shared stuff")
-    end
-  end
-end

data/spec/models/panda_pal/organization/task_scheduling_spec.rb

@@ -1,145 +0,0 @@
-require 'spec_helper'
-
-module PandaPal
-  PandaPal::Organization
-
-  RSpec.describe OrganizationConcerns::TaskScheduling, type: :model do
-    let!(:organization) { create(:panda_pal_organization) }
-    let(:schedules) { {} }
-
-    before :each do
-      Organization.instance_variable_set(:@_schedule_descriptors, nil)
-      Organization.scheduled_task('0 0 0 * * *', :ident) { }
-
-      allow(Sidekiq).to receive(:remove_schedule)
-      allow(Sidekiq).to receive(:get_schedule) { schedules }
-    end
-
-    def descriptors
-      Organization.instance_variable_get(:@_schedule_descriptors)
-    end
-
-    def descriptor
-      descriptors[descriptors.keys[0]]
-    end
-
-    describe '.scheduled_task' do
-      it 'adds to the set of descriptors' do
-        expect(descriptors).to match(
-          'ident' => {
-            :key=>"ident",
-            :schedule=>"0 0 0 * * *",
-            :worker=>Proc,
-            :queue=>"default",
-          }
-        )
-      end
-    end
-
-    describe '.sync_schedules' do
-      it 'adds new schedules' do
-        expect(Sidekiq).to receive(:set_schedule).with(/org:\w+-ident/, anything)
-        Organization.sync_schedules
-      end
-
-      it 'removes schedules for deleted Orgs' do
-        schedules['org:deleted_org-schedule'] = {}
-        expect(Sidekiq).to receive(:remove_schedule).with('org:deleted_org-schedule')
-        Organization.sync_schedules
-      end
-
-      it 'keeps schedules created from other sources' do
-        schedules['other-schedule'] = {}
-        expect(Sidekiq).not_to receive(:remove_schedule).with('other-schedule')
-        Organization.sync_schedules
-      end
-    end
-
-    describe '#generate_schedule' do
-      it 'generates the expected schedule' do
-        expect(organization.generate_schedule).to eq({
-          "org:#{organization.name}-ident" => {
-            "cron"=>"0 0 0 * * *",
-            "queue"=>"default",
-            "class"=>"PandaPal::OrganizationConcerns::TaskScheduling::ScheduledTaskExecutor",
-            "args"=>[organization.name, "ident"],
-            "enabled" => true,
-          }
-        })
-      end
-    end
-
-    describe '#schedule_task_cron_time' do
-      before :each do
-        organization.settings = { timezone: 'America/Denver' }
-      end
-
-      it 'includes timezone if in settings' do
-        expect(organization.send(:schedule_task_cron_time, descriptor)).to eq '0 0 0 * * * America/Denver'
-      end
-
-      it 'does not re-append timezone if already present' do
-        descriptor[:schedule] = '1 1 1 * * * America/Chicago'
-        expect(organization.send(:schedule_task_cron_time, descriptor)).to eq '1 1 1 * * * America/Chicago'
-      end
-    end
-
-    describe '#sync_schedule' do
-      it 'adds new schedules' do
-        expect(Sidekiq).to receive(:set_schedule).with(/org:\w+-ident/, anything)
-        organization.sync_schedule
-      end
-
-      it 'removes old jobs' do
-        schedules["org:#{organization.name}-old_schedule"] = {}
-        expect(Sidekiq).to receive(:remove_schedule).with("org:#{organization.name}-old_schedule")
-        organization.sync_schedule
-      end
-    end
-
-    describe 'SettingsValidation' do
-      before :each do
-        organization.settings = {}
-      end
-
-      it 'passes a valid timezone' do
-        organization.settings[:timezone] = 'America/Denver'
-        expect(organization).to be_valid
-      end
-
-      it 'fails an invalid timezone' do
-        organization.settings[:timezone] = 'Timezone/Blorg'
-        expect(organization).not_to be_valid
-      end
-
-      it 'allows [:task_schedules] entry to be missing' do
-        expect(organization).to be_valid
-      end
-
-      it 'does not require [:task_schedules] sub-entries' do
-        organization.settings[:task_schedules] = {}
-        expect(organization).to be_valid
-      end
-
-      it 'allows task entry to be false' do
-        organization.settings[:task_schedules] = { ident: false }
-        expect(organization).to be_valid
-      end
-
-      it 'allows task entry to be a valid cron string' do
-        organization.settings[:task_schedules] = { ident: '0 0 0 * * * America/Denver' }
-        expect(organization).to be_valid
-      end
-
-      it 'does not allow task entry to be an invalid cron string' do
-        organization.settings[:task_schedules] = { ident: 'blort' }
-        expect(organization).not_to be_valid
-      end
-
-      it 'does not allow sub-entries for unknown tasks' do
-        organization.settings[:task_schedules] = { missing_ident: '0 0 0 * * * America/Denver' }
-        expect(organization).not_to be_valid
-      end
-    end
-  end
-end

data/spec/models/panda_pal/organization_spec.rb

@@ -1,50 +0,0 @@
-require 'spec_helper'
-
-module PandaPal
-  RSpec.describe Organization, type: :model do
-    it 'creates a schema upon creation' do
-      expect(Apartment::Tenant).to receive(:create).and_call_original
-      create :panda_pal_organization
-    end
-
-    it 'deletes a schema upon deletion' do
-      expect(Apartment::Tenant).to receive(:create).and_call_original
-      expect(Apartment::Tenant).to receive(:drop).and_call_original
-      org = create :panda_pal_organization
-      org.destroy
-    end
-
-    it 'does not allow the name to be changed after creation' do
-      org = create :panda_pal_organization
-      org.name = 'test123'
-      expect(org.valid?).to be_falsey
-    end
-
-    it 'requires a salesforce_id' do
-      org = build :panda_pal_organization, salesforce_id: nil
-      expect(org.valid?).to be_falsey
-    end
-
-    it 'does not allow duplicate salesforce ids' do
-      org = create :panda_pal_organization, salesforce_id: 'salesforce'
-      org2 = build :panda_pal_organization, salesforce_id: 'salesforce'
-      expect(org2.valid?).to be_falsey
-    end
-
-    it 'stores setting as an indifferent Hash' do
-      org = create :panda_pal_organization
-      org.update!(settings: { a: 1 })
-
-      expect(Organization.last.settings).to be_a (ActiveSupport::HashWithIndifferentAccess)
-
-      org.settings = {}
-      expect(org.settings).to be_a (ActiveSupport::HashWithIndifferentAccess)
-    end
-
-    it 'stores settings' do
-      org = create :panda_pal_organization
-      org.update!(settings: { a: 1 })
-      expect(Organization.last.settings[:a]).to eql(1)
-    end
-  end
-end

data/spec/models/panda_pal/platform/canvas_install_spec.rb

@@ -1,115 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe 'PandaPal::Platform::Canvas::OrgExtension#install_lti', :isolated_lti_config do
-  let(:organization) { create(:panda_pal_organization, key: '10000000000001') }
-  let(:client) { double('Bearcat::Client') }
-  let(:host) { 'https://tool.example.com' }
-  let(:installed_tools) { [] }
-
-  before do
-    # _install_lti only checks that Bearcat exists; the client itself is stubbed.
-    stub_const('Bearcat', Module.new)
-    c = client
-    organization.define_singleton_method(:bearcat_client) { c }
-
-    PandaPal.lti_environments = { domain: 'tool.example.com' }
-    PandaPal.lti_options = { title: 'Shared Title' }
-    PandaPal.define_tool(:translate, title: 'Translate Title')
-    PandaPal.stage_placement(:editor_button, tool: :translate, url: :panda_pal)
-
-    allow(client).to receive(:account_external_tools).with('self').and_return(double(all_pages_each: installed_tools))
-  end
-
-  after { Apartment::Tenant.reset }
-
-  describe 'LTI 1.3' do
-    let(:developer_key) do
-      { id: 10000000000002, api_key: 'dev-key-secret', developer_key_account_binding: { workflow_state: 'on' } }
-    end
-
-    before do
-      allow(client).to receive(:get).and_return([])
-      allow(HTTParty).to receive(:get) do |url, **|
-        double(body: { target_link_uri: "#{host}/panda_pal/v1p3/resource_link_request", extensions: [] }.to_json, url: url)
-      end
-    end
-
-    it 'creates a Developer Key from the tool config, installs it, and registers it without touching the org key' do
-      expect(client).to receive(:post).with('api/lti/accounts/self/developer_keys/tool_configuration', hash_including(
-        developer_key: hash_including(name: 'Translate Title'),
-      )).and_return({ developer_key: developer_key })
-      expect(client).to receive(:create_account_external_tool).with('self', { client_id: 10000000000002 }).and_return({ id: 7, deployment_id: 'dep-9' })
-
-      organization.install_lti(host: host, tool: :translate)
-
-      expect(HTTParty).to have_received(:get).with(a_string_including('v1p3/config?tool=translate'), format: :plain)
-      expect(organization.reload.key).to eq('10000000000001')
-      expect(organization.lti_registrations.pluck(:tool, :client_id, :deployment_id)).to eq([['translate', '10000000000002', nil]])
-    end
-
-    it 'records the deployment_id for a dedicated deployment' do
-      allow(client).to receive(:post).and_return({ developer_key: developer_key })
-      allow(client).to receive(:create_account_external_tool).and_return({ id: 7, deployment_id: 'dep-9' })
-
-      organization.install_lti(host: host, tool: :translate, dedicated_deployment: true)
-
-      expect(organization.lti_registrations.pluck(:deployment_id)).to eq(['dep-9'])
-    end
-
-    context 'when the tool is already registered and installed' do
-      let(:installed_tools) { [{ id: 7, developer_key_id: 2, deployment_id: 'dep-9' }] }
-
-      before do
-        organization.lti_registrations.create!(tool: 'translate', client_id: '10000000000002')
-        allow(client).to receive(:get).and_return([developer_key])
-      end
-
-      it 'updates the registered Developer Key in place and reuses its install' do
-        expect(client).not_to receive(:post)
-        expect(client).not_to receive(:create_account_external_tool)
-        expect(client).to receive(:put).with('api/lti/developer_keys/10000000000002/tool_configuration', anything).and_return(developer_key)
-
-        organization.install_lti(host: host, tool: :translate, exists: :update)
-
-        expect(organization.lti_registrations.count).to eq(1)
-      end
-    end
-
-    it 'parses dotted versions (1.3 used to resolve to v1p1)' do
-      allow(client).to receive(:post).and_return({ developer_key: developer_key })
-      allow(client).to receive(:create_account_external_tool).and_return({ id: 7, deployment_id: 'dep-9' })
-
-      expect { organization.install_lti(host: host, tool: :translate, version: '1.3') }.not_to raise_error
-      expect(organization.lti_registrations.count).to eq(1)
-    end
-
-    it 'raises for a tool that was never defined' do
-      expect { organization.install_lti(host: host, tool: :nope) }.to raise_error(PandaPal::UnknownLtiTool)
-    end
-  end
-
-  describe 'LTI 1.0' do
-    let(:installed_tools) do
-      [
-        { id: 1, consumer_key: organization.key, custom_fields: {} },
-        { id: 2, consumer_key: organization.key, custom_fields: { PandaPal::TOOL_CUSTOM_FIELD => 'translate' } },
-      ]
-    end
-
-    it "updates only the matching tool's install, pointing it at that tool's config" do
-      expect(client).to receive(:edit_account_external_tool).with('self', 2, hash_including(
-        name: 'Translate Title',
-        consumer_key: organization.key,
-        config_url: a_string_including('v1p0/config?tool=translate'),
-      ))
-
-      organization.install_lti(host: host, tool: :translate, version: '1.0', exists: :update)
-    end
-
-    it 'still matches the default install by consumer key alone' do
-      expect(client).to receive(:edit_account_external_tool).with('self', 1, hash_including(name: 'Shared Title'))
-
-      organization.install_lti(host: host, version: 'v1p0', exists: :update)
-    end
-  end
-end