openstax_accounts 7.13.0 → 8.1.1

data/spec/routines/openstax/accounts/find_or_create_account_spec.rb

@@ -1,76 +0,0 @@
-require 'spec_helper'
-require 'vcr_helper'
-
-module OpenStax
-  module Accounts
-
-    RSpec.describe FindOrCreateAccount, type: :routine, vcr: VCR_OPTS do
-
-      before(:all) do
-        @previous_url = OpenStax::Accounts.configuration.openstax_accounts_url
-        @previous_enable_stubbing = OpenStax::Accounts.configuration.enable_stubbing
-        OpenStax::Accounts.configuration.openstax_accounts_url = "http://localhost:2999/"
-        OpenStax::Accounts.configuration.enable_stubbing = false
-        OpenStax::Accounts::Api.client.site = "http://localhost:2999/"
-      end
-
-      it 'can create users' do
-        account_1 = described_class.call(
-          email: 'alice@example.com', role: 'instructor'
-        ).outputs.account
-        expect(account_1).to be_persisted
-        expect(account_1.uuid).to(
-          match(/\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z/i)
-        )
-        expect(account_1.support_identifier).to match(/\Acs_[0-9a-f]{8}\z/i)
-        expect(account_1.role).to eq 'instructor'
-
-        account_2 = described_class.call(username: 'alice').outputs.account
-        expect(account_2).to be_persisted
-        expect(account_1).not_to eq(account_2)
-
-        account_3 = described_class.call(username: 'alice2',
-                                         password: 'abcdefghijklmnop').outputs.account
-        expect(account_3).to be_persisted
-        expect(account_1).not_to eq(account_3)
-        expect(account_2).not_to eq(account_3)
-      end
-
-      it 'passes params to the API when creating users' do
-        find_or_create_account_response = double('Response')
-        allow(find_or_create_account_response).to receive(:status).and_return(201)
-        allow(find_or_create_account_response).to(
-          receive(:body).and_return(
-            "{\"id\":1,\"uuid\":\"#{SecureRandom.uuid
-            }\",\"support_identifier\":\"cs_#{SecureRandom.hex(4)}\"}"
-          )
-        )
-        expect(OpenStax::Accounts::Api).to receive(:find_or_create_account).with(
-          email: 'bob@example.com', username: nil, password: nil,
-          first_name: 'Bob', last_name: 'Smith', full_name: 'Bob Smith',
-          salesforce_contact_id: 'b0b', faculty_status: :rejected_faculty,
-          role: :instructor, school_type: :college
-        ).and_return(find_or_create_account_response)
-
-        described_class.call(
-          email: 'bob@example.com',
-          first_name: 'Bob',
-          last_name: 'Smith',
-          full_name: 'Bob Smith',
-          salesforce_contact_id: 'b0b',
-          faculty_status: :rejected_faculty,
-          role: :instructor,
-          school_type: :college
-        )
-      end
-
-      after(:all) do
-        OpenStax::Accounts.configuration.openstax_accounts_url = @previous_url
-        OpenStax::Accounts.configuration.enable_stubbing = @previous_enable_stubbing
-        OpenStax::Accounts::Api.client.site = @previous_url
-      end
-
-    end
-
-  end
-end

data/spec/routines/openstax/accounts/search_accounts_shared_examples.rb

@@ -1,160 +0,0 @@
-require 'spec_helper'
-
-RSpec.shared_examples 'search accounts' do
-
-  let!(:account_1) do
-    FactoryBot.create :openstax_accounts_account, first_name: 'John',
-                                                  last_name: 'Stravinsky',
-                                                  username: 'jstrav'
-  end
-  let!(:account_2) do
-    FactoryBot.create :openstax_accounts_account, first_name: 'Mary',
-                                                  last_name: 'Mighty',
-                                                  full_name: 'Mary Mighty',
-                                                  username: 'mary'
-  end
-  let!(:account_3) do
-    FactoryBot.create :openstax_accounts_account, first_name: 'John',
-                                                  last_name: 'Stead',
-                                                  username: 'jstead'
-  end
-
-  let!(:account_4) do
-    FactoryBot.create :openstax_accounts_account, first_name: 'Bob',
-                                                  last_name: 'JST',
-                                                  username: 'bigbear'
-  end
-
-  it 'should match based on username' do
-    outcome = described_class.call('username:jstra').outputs.items
-    expect(outcome).to eq [account_1]
-  end
-
-  it 'should ignore leading wildcards on username searches' do
-    outcome = described_class.call('username:%rav').outputs.items
-    expect(outcome).to eq []
-  end
-
-  it 'should match based on one first name' do
-    outcome = described_class.call('first_name:"John"').outputs.items
-    expect(outcome).to eq [account_3, account_1]
-  end
-
-  it 'should match based on one full name' do
-    outcome = described_class.call('full_name:"Mary Mighty"').outputs.items
-    expect(outcome).to eq [account_2]
-  end
-
-  it 'should match based on id (openstax_uid)' do
-    outcome = described_class.call("id:#{account_3.openstax_uid}").outputs.items
-    expect(outcome).to eq [account_3]
-  end
-
-  it 'should match based on uuid' do
-    outcome = described_class.call("uuid:#{account_3.uuid}").outputs.items
-    expect(outcome).to eq [account_3]
-  end
-
-  it 'should match based on support_identifier' do
-    outcome = described_class.call(
-      "support_identifier:#{account_3.support_identifier}"
-    ).outputs.items
-    expect(outcome).to eq [account_3]
-  end
-
-  it 'should return all results if the query is empty' do
-    outcome = described_class.call('').outputs.items
-    expect(outcome).to eq [account_4, account_3, account_1, account_2]
-  end
-
-  it 'should match any field when no prefix given' do
-    outcome = described_class.call('jst').outputs.items
-    expect(outcome).to eq [account_4, account_3, account_1]
-  end
-
-  it 'should match any field when no prefix given and intersect when prefix given' do
-    outcome = described_class.call('jst username:jst').outputs.items
-    expect(outcome).to eq [account_3, account_1]
-  end
-
-  it 'shouldn\'t allow users to add their own wildcards' do
-    outcome = described_class.call("username:'%ar'").outputs.items
-    expect(outcome).to eq []
-  end
-
-  it 'should gather comma-separated unprefixed search terms' do
-    outcome = described_class.call('john,mighty').outputs.items
-    expect(outcome).to eq [account_3, account_1, account_2]
-  end
-
-  it 'should not gather space-separated unprefixed search terms' do
-    outcome = described_class.call('john mighty').outputs.items
-    expect(outcome).to eq []
-  end
-
-  context 'pagination and sorting' do
-
-    let!(:billy_accounts) do
-      (0..45).to_a.map do |ii|
-        FactoryBot.create :openstax_accounts_account,
-                           first_name: "Billy#{ii.to_s.rjust(2, '0')}",
-                           last_name: "Bob_#{(45-ii).to_s.rjust(2,'0')}",
-                           username: "billy_#{ii.to_s.rjust(2, '0')}"
-      end
-    end
-
-    it 'should return the first page of values by default when requested' do
-      outcome = described_class.call('username:billy', per_page: 20).outputs.items
-      expect(outcome.length).to eq 20
-      expect(outcome[0]).to eq OpenStax::Accounts::Account.find_by!(username: 'billy_00')
-      expect(outcome[19]).to eq OpenStax::Accounts::Account.find_by!(username: 'billy_19')
-    end
-
-    it 'should return the second page when requested' do
-      outcome = described_class.call('username:billy', page: 2, per_page: 20).outputs.items
-      expect(outcome.length).to eq 20
-      expect(outcome[0]).to eq OpenStax::Accounts::Account.find_by!(username: 'billy_20')
-      expect(outcome[19]).to eq OpenStax::Accounts::Account.find_by!(username: 'billy_39')
-    end
-
-    it 'should return the incomplete 3rd page when requested' do
-      outcome = described_class.call('username:billy', page: 3, per_page: 20).outputs.items
-      expect(outcome.length).to eq 6
-      expect(outcome[5]).to eq OpenStax::Accounts::Account.find_by!(username: 'billy_45')
-    end
-
-  end
-
-  context 'sorting' do
-
-    let!(:bob_brown) do
-      FactoryBot.create :openstax_accounts_account, first_name: 'Bob',
-                                                    last_name: 'Brown',
-                                                    username: 'foo_bb'
-    end
-    let!(:bob_jones) do
-      FactoryBot.create :openstax_accounts_account, first_name: 'Bob',
-                                                    last_name: 'Jones',
-                                                    username: 'foo_bj'
-    end
-    let!(:tim_jones) do
-      FactoryBot.create :openstax_accounts_account, first_name: 'Tim',
-                                                    last_name: 'Jones',
-                                                    username: 'foo_tj'
-    end
-
-    it 'should allow sort by multiple fields in different directions' do
-      outcome = described_class.call(
-        'username:foo', order_by: 'first_name, last_name DESC'
-      ).outputs.items
-      expect(outcome).to eq [bob_jones, bob_brown, tim_jones]
-
-      outcome = described_class.call(
-        'username:foo', order_by: 'first_name, last_name ASC'
-      ).outputs.items
-      expect(outcome).to eq [bob_brown, bob_jones, tim_jones]
-    end
-
-  end
-
-end

data/spec/routines/openstax/accounts/search_accounts_spec.rb

@@ -1,6 +0,0 @@
-require 'spec_helper'
-require_relative 'search_accounts_shared_examples'
-
-RSpec.describe OpenStax::Accounts::SearchAccounts, type: :routine do
-  include_examples 'search accounts'
-end

data/spec/routines/openstax/accounts/search_local_accounts_spec.rb

@@ -1,6 +0,0 @@
-require 'spec_helper'
-require_relative 'search_accounts_shared_examples'
-
-RSpec.describe OpenStax::Accounts::SearchLocalAccounts, type: :routine do
-  include_examples 'search accounts'
-end

data/spec/routines/openstax/accounts/sync_accounts_spec.rb

@@ -1,101 +0,0 @@
-require 'spec_helper'
-
-module OpenStax
-  module Accounts
-
-    RSpec.describe SyncAccounts, type: :routine do
-
-      it 'can sync accounts' do
-        controller_class = ::Api::ApplicationUsersController
-        uuid_1 = SecureRandom.uuid
-        uuid_2 = SecureRandom.uuid
-        support_identifier_1 = "cs_#{SecureRandom.hex(4)}"
-        support_identifier_2 = "cs_#{SecureRandom.hex(4)}"
-        allow_any_instance_of(controller_class).to(
-          receive(:updates) do |controller|
-            controller.render json: [
-              {
-                id: 1,
-                application_id: 1,
-                user: {
-                  id: 2,
-                  username: 'user',
-                  self_reported_role: 'instructor',
-                  uuid: uuid_1,
-                  support_identifier: support_identifier_1,
-                  is_test: true
-                },
-                unread_updates: 1,
-                default_contact_info_id: 1
-              },
-              {
-                id: 3,
-                application_id: 1,
-                user: {
-                  id: 4,
-                  username: 'fuego',
-                  uuid: uuid_2,
-                  support_identifier: support_identifier_2
-                },
-                unread_updates: 2,
-                default_contact_info_id: 5
-              }
-            ]
-          end
-        )
-
-        account = FactoryBot.create :openstax_accounts_account, username: 'u', openstax_uid: 2
-        account.syncing = true
-
-        begin
-          OpenStax::Accounts.configuration.enable_stubbing = false
-          expect(account.reload.openstax_uid).to eq 2
-          expect(account.username).to eq 'u'
-          expect(Account.find_by(openstax_uid: 4)).to be_nil
-
-          controller_class.last_action = nil
-          controller_class.last_json = nil
-
-          expect { SyncAccounts.call }.to change { Account.count }.by(1)
-
-          account_2 = Account.find_by(openstax_uid: 4)
-
-          expect(account.reload.openstax_uid).to eq 2
-          expect(account.username).to eq 'user'
-          expect(account.role).to eq 'instructor'
-          expect(account.uuid).to eq uuid_1
-          expect(account.support_identifier).to eq support_identifier_1
-          expect(account.is_test).to eq true
-          expect(account_2.username).to eq 'fuego'
-          expect(account_2.uuid).to eq uuid_2
-          expect(account_2.support_identifier).to eq support_identifier_2
-          expect(account_2.is_test).to be_nil
-
-          expect(controller_class.last_action).to eq :updated
-          expect(controller_class.last_json).to eq [
-            {'user_id' => 2, 'read_updates' => 1}, {'user_id' => 4, 'read_updates' => 2}
-          ]
-
-          controller_class.last_action = nil
-          controller_class.last_json = nil
-
-          expect { SyncAccounts.call }.not_to change { Account.count }
-
-          expect(account.reload.openstax_uid).to eq 2
-          expect(account.username).to eq 'user'
-          expect(account_2.reload.openstax_uid).to eq 4
-          expect(account_2.username).to eq 'fuego'
-
-          expect(controller_class.last_action).to eq :updated
-          expect(controller_class.last_json).to eq [
-            {'user_id' => 2, 'read_updates' => 1}, {'user_id' => 4, 'read_updates' => 2}
-          ]
-        ensure
-          OpenStax::Accounts.configuration.enable_stubbing = true
-        end
-      end
-
-    end
-
-  end
-end

data/spec/routines/openstax/accounts/sync_groups_spec.rb

@@ -1,143 +0,0 @@
-require 'spec_helper'
-
-module OpenStax
-  module Accounts
-
-    RSpec.describe SyncGroups, type: :routine do
-
-      it 'can sync groups' do
-        controller_class = ::Api::ApplicationGroupsController
-        allow_any_instance_of(controller_class).to(
-          receive(:updates) do |controller|
-            controller.render json: [
-              {
-                id: 1,
-                application_id: 1,
-                group: {
-                  id: 2,
-                  name: 'M',
-                  members: [],
-                  owners: [],
-                  nestings: [
-                    {
-                      container_group_id: 2,
-                      member_group_id: 3
-                    }
-                  ]
-                },
-                unread_updates: 1,
-                default_contact_info_id: 1
-              },
-              {
-                id: 3,
-                application_id: 1,
-                group: {
-                  id: 3,
-                  name: 'Fuego\'s Deputies',
-                  members: [
-                    {
-                      group_id: 3,
-                      user: {
-                        id: 2,
-                        username: 'User'
-                      }
-                    }
-                  ],
-                  owners: [
-                    {
-                      group_id: 3,
-                      user: {
-                        id: 3,
-                        username: 'Fuego'
-                      }
-                    }
-                  ],
-                  nestings: []
-                },
-                unread_updates: 2,
-                default_contact_info_id: 5
-              }
-            ]
-          end
-        )
-
-        u = FactoryBot.create :openstax_accounts_account, openstax_uid: 2, username: 'User'
-        u.syncing = true
-
-        u2 = FactoryBot.create :openstax_accounts_account, openstax_uid: 3, username: 'Fuego'
-        u2.syncing = true
-
-        g = FactoryBot.create :openstax_accounts_group, openstax_uid: 2, name: 'Member Group'
-        g.syncing = true
-
-        gm = FactoryBot.create :openstax_accounts_group_member, group: g, user: u
-
-        g2 = FactoryBot.create :openstax_accounts_group, openstax_uid: 4, name: 'Container Group'
-        g2.syncing = true
-
-        go = FactoryBot.create :openstax_accounts_group_owner, group: g2, user: u
-
-        gn = FactoryBot.create :openstax_accounts_group_nesting, container_group: g2,
-                                                                 member_group: g
-
-        begin
-          OpenStax::Accounts.configuration.enable_stubbing = false
-          expect(g.reload.openstax_uid).to eq 2
-          expect(g.name).to eq 'Member Group'
-          expect(g.members).to eq [ u ]
-          expect(g2.reload.openstax_uid).to eq 4
-          expect(g2.name).to eq 'Container Group'
-          expect(g2.member_groups).to eq [ g ]
-          expect(g2.owners).to eq [ u ]
-
-          controller_class.last_action = nil
-          controller_class.last_json = nil
-
-          expect { SyncGroups.call }.to change { Group.count }.by(1)
-
-          g3 = Group.find_by(openstax_uid: 3)
-
-          expect(g.reload.openstax_uid).to eq 2
-          expect(g.name).to eq 'M'
-          expect(g.member_groups).to eq [ g3 ]
-          expect(g2.reload.openstax_uid).to eq 4
-          expect(g2.name).to eq 'Container Group'
-          expect(g2.member_groups).to eq [ g ]
-          expect(g3.name).to eq 'Fuego\'s Deputies'
-          expect(g3.owners).to eq [ u2 ]
-          expect(g3.members).to eq [ u ]
-
-          expect(controller_class.last_action).to eq :updated
-          expect(controller_class.last_json).to eq [
-            {'group_id' => 2, 'read_updates' => 1}, {'group_id' => 3, 'read_updates' => 2}
-          ]
-
-          controller_class.last_action = nil
-          controller_class.last_json = nil
-
-          expect { SyncGroups.call }.not_to change { Group.count }
-
-          expect(g.reload.openstax_uid).to eq 2
-          expect(g.name).to eq 'M'
-          expect(g.member_groups).to eq [ g3 ]
-          expect(g2.reload.openstax_uid).to eq 4
-          expect(g2.name).to eq 'Container Group'
-          expect(g2.member_groups).to eq [ g ]
-          expect(g3.reload.openstax_uid).to eq 3
-          expect(g3.name).to eq 'Fuego\'s Deputies'
-          expect(g3.owners).to eq [ u2 ]
-          expect(g3.members).to eq [ u ]
-
-          expect(controller_class.last_action).to eq :updated
-          expect(controller_class.last_json).to eq [
-            {'group_id' => 2, 'read_updates' => 1}, {'group_id' => 3, 'read_updates' => 2}
-          ]
-        ensure
-          OpenStax::Accounts.configuration.enable_stubbing = true
-        end
-      end
-
-    end
-
-  end
-end