openstax_accounts 2.0.0 → 3.0.0

data/spec/factories/openstax_accounts_account.rb

@@ -1,6 +1,7 @@
 FactoryGirl.define do
   factory :openstax_accounts_account, :class => OpenStax::Accounts::Account do
-    sequence(:openstax_uid) { -SecureRandom.hex.to_i(16) }
-    sequence(:username) { SecureRandom.hex }
+    openstax_uid { -SecureRandom.hex.to_i(16) }
+    username     { SecureRandom.hex.to_s }
+    access_token { SecureRandom.hex.to_s }
   end
 end

data/spec/factories/openstax_accounts_group.rb

@@ -0,0 +1,7 @@
+FactoryGirl.define do
+  factory :openstax_accounts_group, :class => OpenStax::Accounts::Group do
+    openstax_uid { -SecureRandom.hex.to_i(16) }
+    name "MyGroup"
+    is_public false
+  end
+end

data/spec/factories/openstax_accounts_group_member.rb

@@ -0,0 +1,6 @@
+FactoryGirl.define do
+  factory :openstax_accounts_group_member, :class => OpenStax::Accounts::GroupMember do
+    association :group, factory: :openstax_accounts_group
+    association :user, factory: :openstax_accounts_account
+  end
+end

data/spec/factories/openstax_accounts_group_nesting.rb

@@ -0,0 +1,6 @@
+FactoryGirl.define do
+  factory :openstax_accounts_group_nesting, :class => OpenStax::Accounts::GroupNesting do
+    association :container_group, factory: :openstax_accounts_group
+    association :member_group, factory: :openstax_accounts_group
+  end
+end

data/spec/factories/openstax_accounts_group_owner.rb

@@ -0,0 +1,6 @@
+FactoryGirl.define do
+  factory :openstax_accounts_group_owner, :class => OpenStax::Accounts::GroupOwner do
+    association :group, factory: :openstax_accounts_group
+    association :user, factory: :openstax_accounts_account
+  end
+end

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

@@ -4,7 +4,7 @@ module OpenStax
       let!(:account) { FactoryGirl.create(:openstax_accounts_account,
                          username: 'some_user',
                          openstax_uid: 1) }
-      let!(:user)    { User.create(:openstax_accounts_account => account) }
+      let!(:user)    { User.create(:account => account) }
 
       let!(:request) { double('request',
                               :host => 'localhost',
@@ -17,7 +17,10 @@ module OpenStax
       let!(:session) { {} }
 
       let!(:cookies) { ActionDispatch::Cookies::CookieJar.new(
-                         SecureRandom.hex, 'localhost') }
+                         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) }
@@ -67,7 +70,10 @@ module OpenStax
 
           # Secure cookies are not sent with non-SSL requests
           unsecure_cookies = ActionDispatch::Cookies::CookieJar.new(
-                               SecureRandom.hex, 'localhost')
+                               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(

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

@@ -0,0 +1,53 @@
+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,7 +1,9 @@
 module OpenStax
   describe Accounts do
+
     let!(:account) { OpenStax::Accounts::Account.create(username: 'some_user',
-                       openstax_uid: 1, access_token: 'secret') }
+                       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
@@ -11,36 +13,198 @@ module OpenStax
       expect(Api::DummyController.last_params).to include 'test' => 'true'
     end
 
-    it 'makes api call to accounts (index)' do
-      Api::UsersController.last_action = nil
-      Api::UsersController.last_params = nil
-      Accounts.search_accounts('sth')
-      expect(Api::UsersController.last_action).to eq :index
-      expect(Api::UsersController.last_params).to include :q => 'sth'
+    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
 
-    it 'makes api call to application_accounts (index)' do
-      Api::ApplicationUsersController.last_action = nil
-      Api::ApplicationUsersController.last_params = nil
-      Accounts.search_application_accounts('sth')
-      expect(Api::ApplicationUsersController.last_action).to eq :index
-      expect(Api::ApplicationUsersController.last_params).to include :q => 'sth'
+    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
 
-    it 'makes api call to application_users_updates' do
-      Api::ApplicationUsersController.last_action = nil
-      Api::ApplicationUsersController.last_params = nil
-      Accounts.get_application_account_updates
-      expect(Api::ApplicationUsersController.last_action).to eq :updates
-      expect(Api::ApplicationUsersController.last_params).not_to be_nil
+    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
 
-    it 'makes api call to application_users_updated' do
-      Api::ApplicationUsersController.last_action = nil
-      Api::ApplicationUsersController.last_params = nil
-      Accounts.mark_updates_as_read({1 => 1})
-      expect(Api::ApplicationUsersController.last_action).to eq :updated
-      expect(Api::ApplicationUsersController.last_params[:application_users]).to include '1' => '1'
+    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

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

@@ -2,8 +2,23 @@ require 'spec_helper'
 
 module OpenStax::Accounts
   describe Account do
+    context 'validation' do
+      it 'requires a unique openstax_uid' do
+        account = FactoryGirl.build(:openstax_accounts_account, openstax_uid: nil)
+        expect(account).not_to be_valid
+        expect(account.errors[:openstax_uid]).to eq(['can\'t be blank'])
+
+        account.openstax_uid = 1
+        account.save!
+
+        account_2 = FactoryGirl.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
+    end
+
     it 'is not anonymous' do
-      expect(Account.new.is_anonymous?).to be_false
+      expect(Account.new.is_anonymous?).to eq false
     end
   end
 end

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

@@ -3,7 +3,7 @@ require 'spec_helper'
 module OpenStax::Accounts
   describe AnonymousAccount do
     it 'is anonymous' do
-      expect(AnonymousAccount.instance.is_anonymous?).to be_true
+      expect(AnonymousAccount.instance.is_anonymous?).to eq true
     end
   end
 end

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

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+module OpenStax::Accounts
+  describe Group do
+    context 'validation' do
+      it 'requires a unique openstax_uid' do
+        group = FactoryGirl.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 = FactoryGirl.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
+  end
+end

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

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+module OpenStax
+  module Accounts
+
+    describe SyncAccounts do
+
+      it 'can sync accounts' do
+        controller_class = ::Api::ApplicationUsersController
+        allow_any_instance_of(controller_class).to(
+          receive(:updates) do |controller|
+            controller.render :json => [{id: 1, application_id: 1,
+                                        user: {id: 2, username: 'user'},
+                                        unread_updates: 1, default_contact_info_id: 1},
+                                        {id: 3, application_id: 1,
+                                        user: {id: 4, username: 'fuego'},
+                                        unread_updates: 2, default_contact_info_id: 5}]
+          end)
+
+        begin
+          OpenStax::Accounts.syncing = true
+          account = OpenStax::Accounts::Account.new
+          account.username = 'u'
+          account.openstax_uid = 2
+          account.save!
+        ensure
+          OpenStax::Accounts.syncing = false
+        end
+
+        begin
+          OpenStax::Accounts.configuration.enable_stubbing = false
+          expect(Account.count).to eq 1
+          expect(Account.first.openstax_uid).to eq 2
+          expect(Account.first.username).to eq 'u'
+
+          controller_class.last_action = nil
+          controller_class.last_json = nil
+          SyncAccounts.call
+          expect(Account.count).to eq 2
+          expect(Account.first.openstax_uid).to eq 2
+          expect(Account.first.username).to eq 'user'
+          expect(Account.last.openstax_uid).to eq 4
+          expect(Account.last.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}]
+
+          controller_class.last_action = nil
+          controller_class.last_json = nil
+
+          SyncAccounts.call
+          expect(Account.count).to eq 2
+          expect(Account.first.openstax_uid).to eq 2
+          expect(Account.first.username).to eq 'user'
+          expect(Account.last.openstax_uid).to eq 4
+          expect(Account.last.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