openstax_accounts 7.13.0 → 8.1.1

data/spec/lib/openstax/accounts/configuration_spec.rb

@@ -1,39 +0,0 @@
-module OpenStax
-  module Accounts
-    RSpec.describe Configuration do
-
-      let!(:config) { Configuration.new.tap {|c| c.openstax_accounts_url = "https://accounts.openstax.org"} }
-      let!(:a_fake_request) { OpenStruct.new(url: "http://foo.com") }
-
-      it "returns the default logout redirect when no explicit URL is set" do
-        expect(config.logout_redirect_url(a_fake_request)).to eq "https://accounts.openstax.org/logout"
-      end
-
-      it "returns an explicitly-set string logout redirect URL when set" do
-        config.logout_redirect_url = "blah"
-        expect(config.logout_redirect_url(a_fake_request)).to eq "blah"
-      end
-
-      it "returns the default URL when Proc logout redirect URL set and returns nil" do
-        config.logout_redirect_url = ->(request) { nil }
-        expect(config.logout_redirect_url(a_fake_request)).to eq "https://accounts.openstax.org/logout"
-      end
-
-      it "returns the Proc URL when Proc logout redirect URL set and returns non-nil" do
-        config.logout_redirect_url = ->(request) { "howdy" }
-        expect(config.logout_redirect_url(a_fake_request)).to eq "howdy"
-      end
-
-      it "says return_to urls not approved when nil" do
-        config.return_to_url_approver = ->(url) { true }
-        expect(config.is_return_to_url_approved?(nil)).to be_falsy
-      end
-
-      it "says return_to urls not approved when approver nil" do
-        config.return_to_url_approver = nil
-        expect(config.is_return_to_url_approved?("http://www.google.com")).to be_falsy
-      end
-
-    end
-  end
-end

data/spec/lib/openstax/accounts/current_user_manager_spec.rb

@@ -1,157 +0,0 @@
-module OpenStax
-  module Accounts
-    RSpec.describe CurrentUserManager do
-      let!(:account) { FactoryBot.create(:openstax_accounts_account,
-                         username: 'some_user',
-                         openstax_uid: 1) }
-      let!(:user)    { User.create(:account => account) }
-
-      let!(:request) { double('request',
-                              :host => 'localhost',
-                              :ssl? => false) }
-
-      let!(:ssl_request) { double('request',
-                                  :host => 'localhost',
-                                  :ssl? => true) }
-
-      let!(:session) { {} }
-
-      let!(:cookies) { ActionDispatch::Cookies::CookieJar.new(
-                         ActiveSupport::KeyGenerator.new(SecureRandom.hex),
-                         'localhost', false,
-                         encrypted_cookie_salt: 'encrypted cookie salt',
-                         encrypted_signed_cookie_salt: 'encrypted signed cookie salt') }
-
-      let!(:current_user_manager) { CurrentUserManager.new(
-                                      request, session, cookies) }
-
-      context 'signing in' do
-
-        it 'signs in an account' do
-          expect(current_user_manager.signed_in?).to eq(false)
-          expect(current_user_manager.current_account).to(
-            eq(AnonymousAccount.instance))
-          expect(current_user_manager.current_user).to(
-            eq(AnonymousUser.instance))
-
-          current_user_manager.sign_in!(account)
-
-          expect(current_user_manager.signed_in?).to eq(true)
-          expect(current_user_manager.current_account).to eq(account)
-          expect(current_user_manager.current_user).to eq(user)
-        end
-
-        it 'signs in a user' do
-          expect(current_user_manager.signed_in?).to eq(false)
-          expect(current_user_manager.current_account).to(
-            eq(AnonymousAccount.instance))
-          expect(current_user_manager.current_user).to(
-            eq(AnonymousUser.instance))
-
-          current_user_manager.sign_in!(user)
-
-          expect(current_user_manager.signed_in?).to eq(true)
-          expect(current_user_manager.current_account).to eq(account)
-          expect(current_user_manager.current_user).to eq(user)
-        end
-
-      end
-
-      context 'from session' do
-
-        before(:each) do
-          current_user_manager.sign_in!(account)
-        end
-
-        it 'keeps a legitimate user signed in' do
-          expect(current_user_manager.signed_in?).to eq(true)
-          expect(current_user_manager.current_account).to eq(account)
-          expect(current_user_manager.current_user).to eq(user)
-
-          # Secure cookies are not sent with non-SSL requests
-          unsecure_cookies = ActionDispatch::Cookies::CookieJar.new(
-                               ActiveSupport::KeyGenerator.new(SecureRandom.hex),
-                               'localhost', false,
-                               encrypted_cookie_salt: 'encrypted cookie salt',
-                               encrypted_signed_cookie_salt: 'encrypted signed cookie salt')
-          unsecure_cookies[:account_id] = cookies[:account_id]
-
-          current_user_manager = CurrentUserManager.new(
-                                   request, session, unsecure_cookies)
-
-          expect(current_user_manager.signed_in?).to eq(true)
-          expect(current_user_manager.current_account).to eq(account)
-          expect(current_user_manager.current_user).to eq(user)
-
-          # But they are sent with SSL requests
-          current_user_manager = CurrentUserManager.new(
-                                   ssl_request, session, cookies)
-
-          expect(current_user_manager.signed_in?).to eq(true)
-          expect(current_user_manager.current_account).to eq(account)
-          expect(current_user_manager.current_user).to eq(user)
-        end
-
-        it 'signs out an attacker attempting to hijack the session' do
-          expect(current_user_manager.signed_in?).to eq(true)
-          expect(current_user_manager.current_account).to eq(account)
-          expect(current_user_manager.current_user).to eq(user)
-
-          # The protection relies on the attacker not being
-          # able to get the secure cookies
-          cookies.delete(:secure_account_id)
-
-          # The attacker can still access non-SSL pages
-          current_user_manager = CurrentUserManager.new(
-                                   request, session, cookies)
-
-          expect(current_user_manager.signed_in?).to eq(true)
-          expect(current_user_manager.current_account).to eq(account)
-          expect(current_user_manager.current_user).to eq(user)
-
-          # But not SSL pages
-          current_user_manager = CurrentUserManager.new(
-                                   ssl_request, session, cookies)
-
-          expect(current_user_manager.signed_in?).to eq(false)
-          expect(current_user_manager.current_account).to(
-            eq(AnonymousAccount.instance))
-          expect(current_user_manager.current_user).to(
-            eq(AnonymousUser.instance))
-
-          # And after they logout, that's it
-          current_user_manager = CurrentUserManager.new(
-                                   request, session, cookies)
-
-          expect(current_user_manager.signed_in?).to eq(false)
-          expect(current_user_manager.current_account).to(
-            eq(AnonymousAccount.instance))
-          expect(current_user_manager.current_user).to(
-            eq(AnonymousUser.instance))
-        end
-
-      end
-
-      context 'signing out' do
-
-        before(:each) { current_user_manager.sign_in!(account) }
-
-        it 'signs out users' do
-          expect(current_user_manager.signed_in?).to eq(true)
-          expect(current_user_manager.current_account).to eq(account)
-          expect(current_user_manager.current_user).to eq(user)
-
-          current_user_manager.sign_out!
-
-          expect(current_user_manager.signed_in?).to eq(false)
-          expect(current_user_manager.current_account).to(
-            eq(AnonymousAccount.instance))
-          expect(current_user_manager.current_user).to(
-            eq(AnonymousUser.instance))
-        end
-
-      end
-
-    end
-  end
-end

data/spec/lib/openstax/accounts/has_many_through_groups/active_record/base_spec.rb

@@ -1,57 +0,0 @@
-module OpenStax
-  module Accounts
-    module HasManyThroughGroups
-      module ActiveRecord
-        RSpec.describe Base do
-          let!(:account_1) { FactoryBot.create(:openstax_accounts_account,
-                             username: 'some_user',
-                             openstax_uid: 1) }
-          let!(:user_1)    { User.create(:account => account_1) }
-
-          let!(:account_2) { FactoryBot.create(:openstax_accounts_account,
-                             username: 'another_user',
-                             openstax_uid: 2) }
-          let!(:user_2)    { User.create(:account => account_2) }
-
-          let!(:group_nesting) { FactoryBot.create(:openstax_accounts_group_nesting) }
-
-          before(:each) do
-            group_nesting.member_group.add_member(account_1)
-          end
-
-          it 'allows users to retrieve all nested has_many_through_groups objects' do
-            expect(user_1.ownerships).to be_empty
-
-            o = Ownership.new
-            o.owner = user_2
-            o.save!
-
-            expect(user_1.reload.ownerships).to be_empty
-
-            o2 = Ownership.new
-            o2.owner = user_1
-            o2.save!
-
-            expect(user_1.reload.ownerships).to include(o2)
-
-            o3 = Ownership.new
-            o3.owner = group_nesting.member_group
-            o3.save!
-
-            expect(user_1.reload.ownerships).to include(o2)
-            expect(user_1.ownerships).to include(o3)
-
-            o4 = Ownership.new
-            o4.owner = group_nesting.container_group
-            o4.save!
-
-            expect(user_1.reload.ownerships).to include(o2)
-            expect(user_1.ownerships).to include(o3)
-            expect(user_1.ownerships).to include(o4)
-          end
-
-        end
-      end
-    end
-  end
-end

data/spec/models/openstax/accounts/account_spec.rb

@@ -1,114 +0,0 @@
-require 'spec_helper'
-
-module OpenStax::Accounts
-  RSpec.describe Account, type: :model do
-    subject(:account) { FactoryBot.create(:openstax_accounts_account) }
-
-    it { is_expected.to validate_presence_of(:uuid) }
-    it { is_expected.to validate_uniqueness_of(:uuid).case_insensitive }
-    it { is_expected.to validate_uniqueness_of(:support_identifier).case_insensitive.allow_nil }
-
-    context 'validation' do
-      it 'requires a unique openstax_uid, if given' do
-        account.openstax_uid = nil
-        expect(account).to be_valid
-
-        account.openstax_uid = -1
-        account.save!
-
-        account_2 = FactoryBot.build(:openstax_accounts_account, openstax_uid: -1)
-        expect(account_2).not_to be_valid
-        expect(account_2.errors[:openstax_uid]).to eq(['has already been taken'])
-      end
-
-      it 'allows nil username' do
-        account.username = nil
-        expect(account).to be_valid
-      end
-
-      it 'requires unique username if not nil' do
-        expect{
-          FactoryBot.create(:openstax_accounts_account, username: account.username)
-        }.to raise_error(ActiveRecord::RecordInvalid)
-      end
-
-      it 'allows multiple accounts saved with nil username' do
-        FactoryBot.create(:openstax_accounts_account, username: nil)
-        expect{
-          FactoryBot.create(:openstax_accounts_account, username: nil)
-        }.not_to raise_error
-      end
-
-      it 'requires a role' do
-        expect{
-          FactoryBot.create(:openstax_accounts_account, role: nil)
-        }.to raise_error(ActiveRecord::RecordInvalid)
-      end
-    end
-
-    context 'updates' do
-      before do
-        account.syncing = false
-        account.openstax_uid = 1
-      end
-
-      context 'stubbing' do
-        it 'does not send updates to accounts' do
-          expect(OpenStax::Accounts::Api).not_to receive(:update_account)
-
-          account.username = 'Stubbed User'
-          account.save!
-        end
-      end
-
-      context 'not stubbing' do
-        before(:all) { OpenStax::Accounts.configuration.enable_stubbing = false }
-        after(:all)  { OpenStax::Accounts.configuration.enable_stubbing = true }
-
-        context 'syncing' do
-          before{ account.syncing = true }
-
-          it 'does not send updates to accounts' do
-            expect(OpenStax::Accounts::Api).not_to receive(:update_account)
-
-            account.username = 'Syncing User'
-            account.save!
-          end
-        end
-
-        context 'not syncing' do
-          context 'invalid openstax_uid' do
-            it 'does not send updates to accounts' do
-              expect(OpenStax::Accounts::Api).not_to receive(:update_account)
-
-              account.openstax_uid = nil
-              account.username = 'Nil User'
-              account.save!
-
-              account.openstax_uid = 0
-              account.username = 'Zeroth User'
-              account.save!
-
-              account.openstax_uid = -1
-              account.username = 'Negative User'
-              account.save!
-            end
-          end
-
-          context 'valid openstax_uid' do
-            it 'sends updates to accounts' do
-              expect(OpenStax::Accounts::Api).to receive(:update_account).once
-
-              account.username = 'Real User'
-              account.save!
-            end
-          end
-        end
-      end
-    end
-
-    it 'is not anonymous' do
-      expect(Account.new.is_anonymous?).to eq false
-    end
-  end
-end

data/spec/models/openstax/accounts/anonymous_account_spec.rb

@@ -1,9 +0,0 @@
-require 'spec_helper'
-
-module OpenStax::Accounts
-  RSpec.describe AnonymousAccount, type: :model do
-    it 'is anonymous' do
-      expect(AnonymousAccount.instance.is_anonymous?).to eq true
-    end
-  end
-end

data/spec/models/openstax/accounts/group_spec.rb

@@ -1,51 +0,0 @@
-require 'spec_helper'
-
-module OpenStax::Accounts
-  RSpec.describe Group, type: :model do
-    context 'validation' do
-      it 'requires a unique openstax_uid' do
-        group = FactoryBot.build(:openstax_accounts_group, openstax_uid: nil)
-        expect(group).not_to be_valid
-        expect(group.errors[:openstax_uid]).to eq(['can\'t be blank'])
-
-        group.openstax_uid = 1
-        group.save!
-
-        group_2 = FactoryBot.build(:openstax_accounts_group, openstax_uid: 1)
-        expect(group_2).not_to be_valid
-        expect(group_2.errors[:openstax_uid]).to eq(['has already been taken'])
-      end
-    end
-
-    context 'no stubbing' do
-      before(:all)     do
-        @stubbing = OpenStax::Accounts.configuration.enable_stubbing?
-        OpenStax::Accounts.configuration.enable_stubbing = false
-      end
-
-      after(:all)      { OpenStax::Accounts.configuration.enable_stubbing = @stubbing }
-
-      let!(:requestor) { FactoryBot.create(:openstax_accounts_account) }
-      let!(:group)     do
-        FactoryBot.build(:openstax_accounts_group).tap{ |group| group.requestor = requestor }
-      end
-
-      it 'calls OpenStax Accounts when created' do
-        expect(OpenStax::Accounts::Api).to receive(:create_group).with(requestor, group)
-        group.save!
-      end
-
-      it 'fails to save if the requestor is nil' do
-        group.requestor = nil
-        expect(OpenStax::Accounts::Api).not_to receive(:create_group)
-        expect(group.save).to eq false
-      end
-
-      it 'does not call OpenStax Accounts if the requestor is temp' do
-        group.requestor.access_token = nil
-        expect(OpenStax::Accounts::Api).not_to receive(:create_group)
-        group.save!
-      end
-    end
-  end
-end

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

@@ -1,32 +0,0 @@
-require 'spec_helper'
-
-module OpenStax
-  module Accounts
-
-    RSpec.describe CreateGroup, type: :routine do
-
-      before(:all) do
-        @previous_enable_stubbing = OpenStax::Accounts.configuration.enable_stubbing
-        OpenStax::Accounts.configuration.enable_stubbing = true
-      end
-
-      let!(:owner) { FactoryBot.create :openstax_accounts_account }
-
-      it 'can create groups' do
-        group = CreateGroup[owner: owner, name: 'Test', is_public: true]
-        expect(group).to be_persisted
-
-        expect(group.name).to eq 'Test'
-        expect(group.is_public).to eq true
-        expect(group.owners.first).to eq owner
-        expect(group.members).to be_empty
-      end
-
-      after(:all) do
-        OpenStax::Accounts.configuration.enable_stubbing = @previous_enable_stubbing
-      end
-
-    end
-
-  end
-end