openstax_accounts 4.1.1 → 5.0.0

data/lib/openstax/accounts/extend_builtins.rb

@@ -1,50 +0,0 @@
-ActionController::Base.class_exec do
-
-  helper_method :current_user, :signed_in?
-
-  # Returns the current user
-  def current_user
-    current_user_manager.current_user
-  end
-
-  # Returns the current account
-  def current_account
-    current_user_manager.current_account
-  end
-
-  # Returns true iff there is a user signed in
-  def signed_in?
-    current_user_manager.signed_in?
-  end
-
-  # Signs in the given account or user
-  def sign_in(user)
-    current_user_manager.sign_in(user)
-  end
-
-  # Signs out the current account and user
-  def sign_out!
-    current_user_manager.sign_out!
-  end
-
-  protected
-
-  def current_user_manager
-    @current_user_manager ||= OpenStax::Accounts::CurrentUserManager.new(
-                                request, session, cookies)
-  end
-
-  def authenticate_user!
-    account = current_account
-
-    return if account && !account.is_anonymous?
-
-    store_url key: :accounts_return_to, strategies: [:session]
-
-    respond_to do |format|
-      format.html { redirect_to openstax_accounts.login_url }
-      format.json { head(:forbidden) }
-    end
-  end
-
-end

data/lib/openstax/accounts/has_many_through_groups.rb

@@ -1,47 +0,0 @@
-module OpenStax
-  module Accounts
-    module HasManyThroughGroups
-      module ActiveRecord
-        def self.included(base)
-          base.extend(ClassMethods)
-        end
-        
-        module ClassMethods
-          def has_many_through_groups(groups_name, name, options = {})
-            options = {class_name: name.to_s.classify}.merge(options)
-            association_name = "direct_#{name.to_s}".to_sym
-
-            OpenStax::Accounts::Group.class_exec do
-              has_many association_name, options
-
-              define_method(name) do
-                OpenStax::Accounts::Group.includes(association_name)
-                  .where(openstax_uid: supertree_group_ids)
-                  .collect{|g| g.send(association_name).to_a}.flatten.uniq
-              end
-            end
-
-            class_exec do
-              has_many association_name, options if options[:as]
-
-              define_method(name) do
-                direct_records = respond_to?(association_name) ? \
-                                   send(association_name).to_a : []
-                indirect_records = OpenStax::Accounts::Group
-                  .includes(association_name).where(
-                    openstax_uid: send(groups_name).collect{|g|
-                      g.supertree_group_ids
-                    }.flatten.uniq
-                  )
-                  .collect{|g| g.send(association_name).to_a}
-                (direct_records + indirect_records).flatten.uniq
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end
-
-ActiveRecord::Base.send :include, OpenStax::Accounts::HasManyThroughGroups::ActiveRecord

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

@@ -1,53 +0,0 @@
-module OpenStax
-  module Accounts
-    describe HasManyThroughGroups do
-      let!(:account_1) { FactoryGirl.create(:openstax_accounts_account,
-                         username: 'some_user',
-                         openstax_uid: 1) }
-      let!(:user_1)    { User.create(:account => account_1) }
-
-      let!(:account_2) { FactoryGirl.create(:openstax_accounts_account,
-                         username: 'another_user',
-                         openstax_uid: 2) }
-      let!(:user_2)    { User.create(:account => account_2) }
-
-      let!(:group_nesting) { FactoryGirl.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

data/spec/lib/openstax_accounts_spec.rb

@@ -1,210 +0,0 @@
-module OpenStax
-  describe Accounts do
-
-    let!(:account) { OpenStax::Accounts::Account.create(username: 'some_user',
-                       first_name: 'Some', last_name: 'User', full_name: 'SomeUser',
-                       title: 'Sir', openstax_uid: 1, access_token: 'secret') }
-
-    it 'makes api calls' do
-      expect(::Api::DummyController.last_action).to be_nil
-      expect(::Api::DummyController.last_params).to be_nil
-      Accounts.api_call(:post, 'dummy', :params => {:test => true})
-      expect(::Api::DummyController.last_action).to eq :dummy
-      expect(::Api::DummyController.last_params).to include 'test' => 'true'
-    end
-
-    context 'users' do
-
-      let!(:account) { FactoryGirl.create :openstax_accounts_account }
-
-      it 'makes api call to users index' do
-        ::Api::UsersController.last_action = nil
-        ::Api::UsersController.last_params = nil
-        Accounts.search_accounts('something')
-        expect(::Api::UsersController.last_action).to eq :index
-        expect(::Api::UsersController.last_params).to include :q => 'something'
-      end
-
-      it 'makes api call to user update' do
-        ::Api::UsersController.last_action = nil
-        ::Api::UsersController.last_json = nil
-        Accounts.update_account(account)
-        expect(::Api::UsersController.last_action).to eq :update
-        expect(::Api::UsersController.last_json).to include(
-          account.attributes.slice('username', 'first_name',
-            'last_name', 'full_name', 'title'))
-      end
-
-    end
-
-    context 'application_users' do
-
-      it 'makes api call to application_users index' do
-        ::Api::ApplicationUsersController.last_action = nil
-        ::Api::ApplicationUsersController.last_params = nil
-        Accounts.search_application_accounts('something')
-        expect(::Api::ApplicationUsersController.last_action).to eq :index
-        expect(::Api::ApplicationUsersController.last_params).to include :q => 'something'
-      end
-
-      it 'makes api call to application_users updates' do
-        ::Api::ApplicationUsersController.last_action = nil
-        Accounts.get_application_account_updates
-        expect(::Api::ApplicationUsersController.last_action).to eq :updates
-      end
-
-      it 'makes api call to application_users updated' do
-        ::Api::ApplicationUsersController.last_action = nil
-        ::Api::ApplicationUsersController.last_json = nil
-        Accounts.mark_account_updates_as_read([{id: 1, read_updates: 1}])
-        expect(::Api::ApplicationUsersController.last_action).to eq :updated
-        expect(::Api::ApplicationUsersController.last_json).to include(
-          {'id' => 1, 'read_updates' => 1})
-      end
-
-    end
-
-    context 'groups' do
-
-      let!(:account) { FactoryGirl.create :openstax_accounts_account }
-      let!(:group)   { FactoryGirl.create :openstax_accounts_group }
-
-      it 'makes api call to groups create' do
-        ::Api::GroupsController.last_action = nil
-        ::Api::GroupsController.last_json = nil
-        Accounts.create_group(account, group)
-        expect(::Api::GroupsController.last_action).to eq :create
-        expect(::Api::GroupsController.last_json).to include(
-          {'name' => 'MyGroup', 'is_public' => false})
-      end
-
-      it 'makes api call to group update' do
-        group.save!
-        ::Api::GroupsController.last_action = nil
-        ::Api::GroupsController.last_params = nil
-        ::Api::GroupsController.last_json = nil
-        Accounts.update_group(account, group)
-        expect(::Api::GroupsController.last_action).to eq :update
-        expect(::Api::GroupsController.last_params).to include(
-          {'id' => group.openstax_uid.to_s})
-        expect(::Api::GroupsController.last_json).to include(
-          {'name' => group.name, 'is_public' => group.is_public})
-      end
-
-      it 'makes api call to group destroy' do
-        group.save!
-        ::Api::GroupsController.last_action = nil
-        ::Api::GroupsController.last_params = nil
-        Accounts.destroy_group(account, group)
-        expect(::Api::GroupsController.last_action).to eq :destroy
-        expect(::Api::GroupsController.last_params).to include(
-          {'id' => group.openstax_uid.to_s})
-      end
-
-    end
-
-    context 'group_members' do
-
-      let!(:account) { FactoryGirl.create :openstax_accounts_account }
-      let!(:group_member)   { FactoryGirl.build :openstax_accounts_group_member }
-
-      it 'makes api call to group_members create' do
-        ::Api::GroupMembersController.last_action = nil
-        ::Api::GroupMembersController.last_params = nil
-        Accounts.create_group_member(account, group_member)
-        expect(::Api::GroupMembersController.last_action).to eq :create
-        expect(::Api::GroupMembersController.last_params).to include(
-          {'group_id' => group_member.group_id.to_s,
-           'user_id' => group_member.user_id.to_s})
-      end
-
-      it 'makes api call to group_member destroy' do
-        group_member.save!
-        ::Api::GroupMembersController.last_action = nil
-        ::Api::GroupMembersController.last_params = nil
-        Accounts.destroy_group_member(account, group_member)
-        expect(::Api::GroupMembersController.last_action).to eq :destroy
-        expect(::Api::GroupMembersController.last_params).to include(
-          {'group_id' => group_member.group_id.to_s,
-           'user_id' => group_member.user_id.to_s})
-      end
-
-    end
-
-    context 'group_owners' do
-
-      let!(:account)      { FactoryGirl.create :openstax_accounts_account }
-      let!(:group_owner) { FactoryGirl.build :openstax_accounts_group_owner }
-
-      it 'makes api call to group_owners create' do
-        ::Api::GroupOwnersController.last_action = nil
-        ::Api::GroupOwnersController.last_params = nil
-        Accounts.create_group_owner(account, group_owner)
-        expect(::Api::GroupOwnersController.last_action).to eq :create
-        expect(::Api::GroupOwnersController.last_params).to include(
-          {'group_id' => group_owner.group_id.to_s,
-           'user_id' => group_owner.user_id.to_s})
-      end
-
-      it 'makes api call to group_owner destroy' do
-        group_owner.save!
-        ::Api::GroupOwnersController.last_action = nil
-        ::Api::GroupOwnersController.last_params = nil
-        Accounts.destroy_group_owner(account, group_owner)
-        expect(::Api::GroupOwnersController.last_action).to eq :destroy
-        expect(::Api::GroupOwnersController.last_params).to include(
-          {'group_id' => group_owner.group_id.to_s,
-           'user_id' => group_owner.user_id.to_s})
-      end
-
-    end
-
-    context 'group_nestings' do
-
-      let!(:account)      { FactoryGirl.create :openstax_accounts_account }
-      let!(:group_nesting) { FactoryGirl.build :openstax_accounts_group_nesting }
-
-      it 'makes api call to group_nestings (create)' do
-        ::Api::GroupNestingsController.last_action = nil
-        ::Api::GroupNestingsController.last_params = nil
-        Accounts.create_group_nesting(account, group_nesting)
-        expect(::Api::GroupNestingsController.last_action).to eq :create
-        expect(::Api::GroupNestingsController.last_params).to include(
-          {'group_id' => group_nesting.container_group_id.to_s,
-           'member_group_id' => group_nesting.member_group_id.to_s})
-      end
-
-      it 'makes api call to group_nesting (destroy)' do
-        group_nesting.save!
-        ::Api::GroupNestingsController.last_action = nil
-        ::Api::GroupNestingsController.last_params = nil
-        Accounts.destroy_group_nesting(account, group_nesting)
-        expect(::Api::GroupNestingsController.last_action).to eq :destroy
-        expect(::Api::GroupNestingsController.last_params).to include(
-          {'group_id' => group_nesting.container_group_id.to_s,
-           'member_group_id' => group_nesting.member_group_id.to_s})
-      end
-
-    end
-
-    context 'application_groups' do
-
-      it 'makes api call to application_groups_updates' do
-        ::Api::ApplicationGroupsController.last_action = nil
-        Accounts.get_application_group_updates
-        expect(::Api::ApplicationGroupsController.last_action).to eq :updates
-      end
-
-      it 'makes api call to application_groups_updated' do
-        ::Api::ApplicationGroupsController.last_action = nil
-        ::Api::ApplicationGroupsController.last_json = nil
-        Accounts.mark_group_updates_as_read([{id: 1, read_updates: 1}])
-        expect(::Api::ApplicationGroupsController.last_action).to eq :updated
-        expect(::Api::ApplicationGroupsController.last_json).to include(
-          {'id' => 1, 'read_updates' => 1})
-      end
-
-    end
-
-  end
-end