openstax_accounts 7.3.0 → 7.4.0

data/spec/factories/openstax_accounts_account.rb

@@ -4,5 +4,7 @@ FactoryGirl.define do
     username     { SecureRandom.hex.to_s }
     access_token { SecureRandom.hex.to_s }
     faculty_status { OpenStax::Accounts::Account.faculty_statuses[:no_faculty_info] }
+    role         { OpenStax::Accounts::Account.roles[:unknown_role] }
+    uuid         { SecureRandom.uuid }
   end
 end

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

@@ -1,3 +1,5 @@
+require 'spec_helper'
+
 module OpenStax
   module Accounts
     describe Api do
@@ -6,29 +8,30 @@ module OpenStax
                          first_name: 'Some', last_name: 'User', full_name: 'SomeUser',
                          title: 'Sir', openstax_uid: 1, access_token: 'secret') }
 
+      def reset(controller)
+        controller.last_action = nil
+        controller.last_json = nil
+        controller.last_params = nil
+      end
+
       it 'makes api requests' do
-        expect(::Api::DummyController.last_action).to be_nil
-        expect(::Api::DummyController.last_params).to be_nil
+        reset(::Api::DummyController)
         Api.request(: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
-
+        before(:each) { reset(::Api::UsersController) }
         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
           Api.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
           Api.update_account(account)
           expect(::Api::UsersController.last_action).to eq :update
           expect(::Api::UsersController.last_json).to include(
@@ -37,8 +40,6 @@ module OpenStax
         end
 
         it 'makes api call to (temp) user create by email' do
-          ::Api::UsersController.last_action = nil
-          ::Api::UsersController.last_json = nil
           Api.find_or_create_account(email: 'dummy@dum.my')
           expect(::Api::UsersController.last_action).to eq :create
           expect(::Api::UsersController.last_json).to(
@@ -47,52 +48,51 @@ module OpenStax
         end
 
         it 'makes api call to (temp) user create by username' do
-          ::Api::UsersController.last_action = nil
-          ::Api::UsersController.last_json = nil
           Api.find_or_create_account(username: 'dummy')
           expect(::Api::UsersController.last_action).to eq :create
           expect(::Api::UsersController.last_json).to(
             include('username' => 'dummy')
           )
         end
-
       end
 
       context 'application_users' do
+        before(:each) { reset(::Api::ApplicationUsersController) }
 
         it 'makes api call to application_users index' do
-          ::Api::ApplicationUsersController.last_action = nil
-          ::Api::ApplicationUsersController.last_params = nil
           Api.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
           Api.get_application_account_updates
           expect(::Api::ApplicationUsersController.last_action).to eq :updates
+          expect(::Api::ApplicationUsersController.last_params).to include limit: "250"
+        end
+
+        it 'does not limit updates call if param blank' do
+          allow(OpenStax::Accounts.configuration).to receive(:max_user_updates_per_request) { "" }
+          Api.get_application_account_updates
+          expect(::Api::ApplicationUsersController.last_action).to eq :updates
+          expect(::Api::ApplicationUsersController.last_params.keys).not_to include "limit"
         end
 
         it 'makes api call to application_users updated' do
-          ::Api::ApplicationUsersController.last_action = nil
-          ::Api::ApplicationUsersController.last_json = nil
           Api.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
+        before(:each) { reset(::Api::GroupsController) }
 
         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
           Api.create_group(account, group)
           expect(::Api::GroupsController.last_action).to eq :create
           expect(::Api::GroupsController.last_json).to include(
@@ -101,9 +101,6 @@ module OpenStax
 
         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
           Api.update_group(account, group)
           expect(::Api::GroupsController.last_action).to eq :update
           expect(::Api::GroupsController.last_params).to include(
@@ -114,24 +111,20 @@ module OpenStax
 
         it 'makes api call to group destroy' do
           group.save!
-          ::Api::GroupsController.last_action = nil
-          ::Api::GroupsController.last_params = nil
           Api.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
+        before(:each) { reset(::Api::GroupMembersController) }
 
         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
           Api.create_group_member(account, group_member)
           expect(::Api::GroupMembersController.last_action).to eq :create
           expect(::Api::GroupMembersController.last_params).to include(
@@ -141,25 +134,21 @@ module OpenStax
 
         it 'makes api call to group_member destroy' do
           group_member.save!
-          ::Api::GroupMembersController.last_action = nil
-          ::Api::GroupMembersController.last_params = nil
           Api.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
+        before(:each) { reset(::Api::GroupOwnersController) }
 
         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
           Api.create_group_owner(account, group_owner)
           expect(::Api::GroupOwnersController.last_action).to eq :create
           expect(::Api::GroupOwnersController.last_params).to include(
@@ -169,25 +158,21 @@ module OpenStax
 
         it 'makes api call to group_owner destroy' do
           group_owner.save!
-          ::Api::GroupOwnersController.last_action = nil
-          ::Api::GroupOwnersController.last_params = nil
           Api.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
+        before(:each) { reset(::Api::GroupNestingsController) }
 
         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
           Api.create_group_nesting(account, group_nesting)
           expect(::Api::GroupNestingsController.last_action).to eq :create
           expect(::Api::GroupNestingsController.last_params).to include(
@@ -197,36 +182,31 @@ module OpenStax
 
         it 'makes api call to group_nesting (destroy)' do
           group_nesting.save!
-          ::Api::GroupNestingsController.last_action = nil
-          ::Api::GroupNestingsController.last_params = nil
           Api.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
+        before(:each) { reset(::Api::ApplicationGroupsController) }
 
         it 'makes api call to application_groups_updates' do
-          ::Api::ApplicationGroupsController.last_action = nil
           Api.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
           Api.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
 end

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

@@ -34,6 +34,12 @@ module OpenStax::Accounts
           FactoryGirl.create(:openstax_accounts_account, username: nil)
         }.not_to raise_error
       end
+
+      it 'requires a role' do
+        expect{
+          FactoryGirl.create(:openstax_accounts_account, role: nil)
+        }.to raise_error(ActiveRecord::RecordInvalid)
+      end
     end
 
     context 'updates' do

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

@@ -36,7 +36,8 @@ module OpenStax
         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
+          salesforce_contact_id: 'b0b', faculty_status: :rejected_faculty,
+          role: :instructor
         ).and_return(find_or_create_account_response)
 
         FindOrCreateAccount.call(
@@ -45,7 +46,8 @@ module OpenStax
           last_name: 'Smith',
           full_name: 'Bob Smith',
           salesforce_contact_id: 'b0b',
-          faculty_status: :rejected_faculty
+          faculty_status: :rejected_faculty,
+          role: :instructor
         )
       end
 

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

@@ -10,7 +10,7 @@ module OpenStax
         allow_any_instance_of(controller_class).to(
           receive(:updates) do |controller|
             controller.render :json => [{id: 1, application_id: 1,
-                                        user: {id: 2, username: 'user'},
+                                        user: {id: 2, username: 'user', self_reported_role: 'instructor', uuid: 'booyah'},
                                         unread_updates: 1, default_contact_info_id: 1},
                                         {id: 3, application_id: 1,
                                         user: {id: 4, username: 'fuego'},
@@ -36,6 +36,8 @@ module OpenStax
           expect(Account.count).to eq 2
           expect(Account.first.openstax_uid).to eq 2
           expect(Account.first.username).to eq 'user'
+          expect(Account.first.role).to eq 'instructor'
+          expect(Account.first.uuid).to eq 'booyah'
           expect(Account.last.openstax_uid).to eq 4
           expect(Account.last.username).to eq 'fuego'
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: openstax_accounts
 version: !ruby/object:Gem::Version
-  version: 7.3.0
+  version: 7.4.0
 platform: ruby
 authors:
 - JP Slavinsky
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-12-22 00:00:00.000000000 Z
+date: 2017-05-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -370,6 +370,7 @@ files:
 - db/migrate/6_add_salesforce_contact_id_to_accounts_accounts.rb
 - db/migrate/7_change_accounts_openstax_uid_to_be_nullable.rb
 - db/migrate/8_change_accounts_username_to_be_nullable.rb
+- db/migrate/9_add_uuid_and_role_to_accounts_accounts.rb
 - lib/generators/openstax/accounts/schedule/USAGE
 - lib/generators/openstax/accounts/schedule/schedule_generator.rb
 - lib/generators/openstax/accounts/schedule/templates/schedule.rb